NCBI C++ ToolKit
newick.tab.cpp
Go to the documentation of this file.

Go to the SVN repository for this file.

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
7  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  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  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. */
28 
29 /* All symbols defined below should begin with yy or YY, to avoid
30  infringing on user name space. This should be done even for local
31  variables, as they might otherwise be expanded by user macros.
32  There are some unavoidable exceptions within include files to
33  define necessary library symbols; they are noted "INFRINGES ON
34  USER NAME SPACE" below. */
35 
36 #include <ncbi_pch.hpp>
37 
38 /* Identify Bison output. */
39 #define YYBISON 1
40 
41 /* Skeleton name. */
42 #define YYSKELETON_NAME "yacc.c"
43 
44 /* Pure parsers. */
45 #define YYPURE 0
46 
47 /* Using locations. */
48 #define YYLSP_NEEDED 0
49 
50 /* If NAME_PREFIX is specified substitute the variables and functions
51  names. */
52 #define yyparse newickparse
53 #define yylex newicklex
54 #define yyerror newickerror
55 #define yylval newicklval
56 #define yychar newickchar
57 #define yydebug newickdebug
58 #define yynerrs newicknerrs
59 
60 
61 /* Tokens. */
62 #ifndef YYTOKENTYPE
63 # define YYTOKENTYPE
64  /* Put the tokens into the symbol table, so that GDB and other debuggers
65  know about them. */
66  enum yytokentype {
67  LABEL = 258,
68  NUM = 259
69  };
70 #endif
71 #define LABEL 258
72 #define NUM 259
73 
74 
75 
76 
77 /* Copy the first part of user declarations. */
78 #line 1 "newick.ypp"
79 
80 /* $Id: newick.tab.cpp 94645 2021-08-25 19:58:37Z boratyng $
81  * ===========================================================================
82  *
83  * PUBLIC DOMAIN NOTICE
84  * National Center for Biotechnology Information
85  *
86  * This software/database is a "United States Government Work" under the
87  * terms of the United States Copyright Act. It was written as part of
88  * the author's official duties as a United States Government employee and
89  * thus cannot be copyrighted. This software/database is freely available
90  * to the public for use. The National Library of Medicine and the U.S.
91  * Government have not placed any restriction on its use or reproduction.
92  *
93  * Although all reasonable efforts have been taken to ensure the accuracy
94  * and reliability of the software and data, the NLM and the U.S.
95  * Government do not and cannot warrant the performance or results that
96  * may be obtained by using this software or data. The NLM and the U.S.
97  * Government disclaim all warranties, express or implied, including
98  * warranties of performance, merchantability or fitness for any particular
99  * purpose.
100  *
101  * Please cite the author in any work or product based on this material.
102  *
103  * ===========================================================================
104  *
105  * Authors: Josh Cherry
106  *
107  * File Description: bison parser for Newick format phylogenetic trees
108  *
109  */
110 
111 /*
112  * Meant to be used in conjunction with flex lexer defined
113  * by newick.lpp. Generate code using (essentially)
114  * flex -olex.newick.cpp newick.lpp
115  * bison -d -p newick newick.ypp
116  * The line '#include <unistd.h>' must be removed from the flex-generated
117  * code for it to compile on some platforms.
118  */
119 
122 static int nodecount = 0;
123 static TPhyTreeNode *g_Tree = 0;
124 void yyerror(const char *error);
125 int yylex(void);
127 // a list of all allocated nodes so they can be deleted on error
128 vector<TPhyTreeNode*> g_NodeList;
129 
130 // Increase stack size
131 #define YYINITDEPTH 10000
132 
133 
134 /* Enabling traces. */
135 #ifndef YYDEBUG
136 # define YYDEBUG 0
137 #endif
138 
139 /* Enabling verbose error messages. */
140 #ifdef YYERROR_VERBOSE
141 # undef YYERROR_VERBOSE
142 # define YYERROR_VERBOSE 1
143 #else
144 # define YYERROR_VERBOSE 0
145 #endif
146 
147 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
148 #line 56 "newick.ypp"
149 typedef union YYSTYPE {
150  char *strval;
151  double dblval;
154 /* Line 191 of yacc.c. */
155 #line 153 "newick.tab.cpp"
156 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
157 # define YYSTYPE_IS_DECLARED 1
158 # define YYSTYPE_IS_TRIVIAL 1
159 #endif
160 
161 
162 
163 /* Copy the second part of user declarations. */
164 
165 
166 /* Line 214 of yacc.c. */
167 #line 165 "newick.tab.cpp"
168 
169 #if ! defined (yyoverflow) || YYERROR_VERBOSE
170 
171 /* The parser invokes alloca or malloc; define the necessary symbols. */
172 
173 # if YYSTACK_USE_ALLOCA
174 # define YYSTACK_ALLOC alloca
175 # else
176 # ifndef YYSTACK_USE_ALLOCA
177 # if defined (alloca) || defined (_ALLOCA_H)
178 # define YYSTACK_ALLOC alloca
179 # else
180 # ifdef __GNUC__
181 # define YYSTACK_ALLOC __builtin_alloca
182 # endif
183 # endif
184 # endif
185 # endif
186 
187 # ifdef YYSTACK_ALLOC
188  /* Pacify GCC's `empty if-body' warning. */
189 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
190 # else
191 # if defined (__STDC__) || defined (__cplusplus)
192 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
193 # define YYSIZE_T size_t
194 # endif
195 # define YYSTACK_ALLOC malloc
196 # define YYSTACK_FREE free
197 # endif
198 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
199 
200 
201 #if (! defined (yyoverflow) \
202  && (! defined (__cplusplus) \
203  || (YYSTYPE_IS_TRIVIAL)))
204 
205 /* A type that is properly aligned for any stack member. */
206 union yyalloc
207 {
208  short yyss;
210  };
211 
212 /* The size of the maximum gap between one aligned stack and the next. */
213 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
214 
215 /* The size of an array large to enough to hold all stacks, each with
216  N elements. */
217 # define YYSTACK_BYTES(N) \
218  ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
219  + YYSTACK_GAP_MAXIMUM)
220 
221 /* Copy COUNT objects from FROM to TO. The source and destination do
222  not overlap. */
223 # ifndef YYCOPY
224 # if 1 < __GNUC__
225 # define YYCOPY(To, From, Count) \
226  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
227 # else
228 # define YYCOPY(To, From, Count) \
229  do \
230  { \
231  YYSIZE_T yyi; \
232  for (yyi = 0; yyi < (Count); yyi++) \
233  (To)[yyi] = (From)[yyi]; \
234  } \
235  while (0)
236 # endif
237 # endif
238 
239 /* Relocate STACK from its old location to the new one. The
240  local variables YYSIZE and YYSTACKSIZE give the old and new number of
241  elements in the stack, and YYPTR gives the new location of the
242  stack. Advance YYPTR to a properly aligned location for the next
243  stack. */
244 # define YYSTACK_RELOCATE(Stack) \
245  do \
246  { \
247  YYSIZE_T yynewbytes; \
248  YYCOPY (&yyptr->Stack, Stack, yysize); \
249  Stack = &yyptr->Stack; \
250  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
251  yyptr += yynewbytes / sizeof (*yyptr); \
252  } \
253  while (0)
254 
255 #endif
256 
257 #if defined (__STDC__) || defined (__cplusplus)
258  typedef signed char yysigned_char;
259 #else
260  typedef short yysigned_char;
261 #endif
262 
263 /* YYFINAL -- State number of the termination state. */
264 #define YYFINAL 10
265 /* YYLAST -- Last index in YYTABLE. */
266 #define YYLAST 17
267 
268 /* YYNTOKENS -- Number of terminals. */
269 #define YYNTOKENS 10
270 /* YYNNTS -- Number of nonterminals. */
271 #define YYNNTS 4
272 /* YYNRULES -- Number of rules. */
273 #define YYNRULES 12
274 /* YYNRULES -- Number of states. */
275 #define YYNSTATES 21
276 
277 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
278 #define YYUNDEFTOK 2
279 #define YYMAXUTOK 259
280 
281 #define YYTRANSLATE(YYX) \
282  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
283 
284 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
285 static const unsigned char yytranslate[] =
286 {
287  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
288  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
289  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
290  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
291  6, 7, 2, 2, 9, 2, 2, 2, 2, 2,
292  2, 2, 2, 2, 2, 2, 2, 2, 8, 5,
293  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
294  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
295  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
296  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
297  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
298  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
299  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
300  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
301  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
302  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
303  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
304  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
305  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
306  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
307  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
308  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
309  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
310  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
311  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
312  2, 2, 2, 2, 2, 2, 1, 2, 3, 4
313 };
314 
315 #if YYDEBUG
316 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
317  YYRHS. */
318 static const unsigned char yyprhs[] =
319 {
320  0, 0, 3, 6, 12, 16, 23, 28, 32, 35,
321  37, 38, 40
322 };
323 
324 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
325 static const yysigned_char yyrhs[] =
326 {
327  11, 0, -1, 12, 5, -1, 6, 13, 7, 8,
328  4, -1, 6, 13, 7, -1, 6, 13, 7, 3,
329  8, 4, -1, 6, 13, 7, 3, -1, 3, 8,
330  4, -1, 8, 4, -1, 3, -1, -1, 12, -1,
331  13, 9, 12, -1
332 };
333 
334 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
335 static const unsigned char yyrline[] =
336 {
337  0, 70, 70, 76, 83, 89, 97, 104, 112, 120,
338  127, 136, 141
339 };
340 #endif
341 
342 #if YYDEBUG || YYERROR_VERBOSE
343 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
344  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
345 static const char *const yytname[] =
346 {
347  "$end", "error", "$undefined", "LABEL", "NUM", "';'", "'('", "')'", "':'",
348  "','", "$accept", "tree", "node", "nodelist", 0
349 };
350 #endif
351 
352 # ifdef YYPRINT
353 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
354  token YYLEX-NUM. */
355 static const unsigned short yytoknum[] =
356 {
357  0, 256, 257, 258, 259, 59, 40, 41, 58, 44
358 };
359 # endif
360 
361 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
362 static const unsigned char yyr1[] =
363 {
364  0, 10, 11, 12, 12, 12, 12, 12, 12, 12,
365  12, 13, 13
366 };
367 
368 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
369 static const unsigned char yyr2[] =
370 {
371  0, 2, 2, 5, 3, 6, 4, 3, 2, 1,
372  0, 1, 3
373 };
374 
375 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
376  STATE-NUM when YYTABLE doesn't specify something else to do. Zero
377  means the default is an error. */
378 static const unsigned char yydefact[] =
379 {
380  10, 9, 10, 0, 0, 0, 0, 11, 0, 8,
381  1, 2, 7, 4, 10, 6, 0, 12, 0, 3,
382  5
383 };
384 
385 /* YYDEFGOTO[NTERM-NUM]. */
386 static const yysigned_char yydefgoto[] =
387 {
388  -1, 4, 5, 8
389 };
390 
391 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
392  STATE-NUM. */
393 #define YYPACT_NINF -8
394 static const yysigned_char yypact[] =
395 {
396  -1, -7, -1, 5, 10, 6, 9, -8, -3, -8,
397  -8, -8, -8, 0, -1, 7, 12, -8, 13, -8,
398  -8
399 };
400 
401 /* YYPGOTO[NTERM-NUM]. */
402 static const yysigned_char yypgoto[] =
403 {
404  -8, -8, -2, -8
405 };
406 
407 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
408  positive, shift that token. If negative, reduce the rule which
409  number is the opposite. If zero, do what YYDEFACT says.
410  If YYTABLE_NINF, syntax error. */
411 #define YYTABLE_NINF -1
412 static const unsigned char yytable[] =
413 {
414  7, 6, 1, 15, 13, 2, 14, 3, 16, 9,
415  10, 11, 17, 12, 0, 18, 19, 20
416 };
417 
418 static const yysigned_char yycheck[] =
419 {
420  2, 8, 3, 3, 7, 6, 9, 8, 8, 4,
421  0, 5, 14, 4, -1, 8, 4, 4
422 };
423 
424 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
425  symbol of state STATE-NUM. */
426 static const unsigned char yystos[] =
427 {
428  0, 3, 6, 8, 11, 12, 8, 12, 13, 4,
429  0, 5, 4, 7, 9, 3, 8, 12, 8, 4,
430  4
431 };
432 
433 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
434 # define YYSIZE_T __SIZE_TYPE__
435 #endif
436 #if ! defined (YYSIZE_T) && defined (size_t)
437 # define YYSIZE_T size_t
438 #endif
439 #if ! defined (YYSIZE_T)
440 # if defined (__STDC__) || defined (__cplusplus)
441 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
442 # define YYSIZE_T size_t
443 # endif
444 #endif
445 #if ! defined (YYSIZE_T)
446 # define YYSIZE_T unsigned int
447 #endif
448 
449 #define yyerrok (yyerrstatus = 0)
450 #define yyclearin (yychar = YYEMPTY)
451 #define YYEMPTY (-2)
452 #define YYEOF 0
453 
454 #define YYACCEPT goto yyacceptlab
455 #define YYABORT goto yyabortlab
456 #define YYERROR goto yyerrlab1
457 
458 /* Like YYERROR except do call yyerror. This remains here temporarily
459  to ease the transition to the new meaning of YYERROR, for GCC.
460  Once GCC version 2 has supplanted version 1, this can go. */
461 
462 #define YYFAIL goto yyerrlab
463 
464 #define YYRECOVERING() (!!yyerrstatus)
465 
466 #define YYBACKUP(Token, Value) \
467 do \
468  if (yychar == YYEMPTY && yylen == 1) \
469  { \
470  yychar = (Token); \
471  yylval = (Value); \
472  yytoken = YYTRANSLATE (yychar); \
473  YYPOPSTACK; \
474  goto yybackup; \
475  } \
476  else \
477  { \
478  yyerror ("syntax error: cannot back up");\
479  YYERROR; \
480  } \
481 while (0)
482 
483 #define YYTERROR 1
484 #define YYERRCODE 256
485 
486 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
487  are run). */
488 
489 #ifndef YYLLOC_DEFAULT
490 # define YYLLOC_DEFAULT(Current, Rhs, N) \
491  Current.first_line = Rhs[1].first_line; \
492  Current.first_column = Rhs[1].first_column; \
493  Current.last_line = Rhs[N].last_line; \
494  Current.last_column = Rhs[N].last_column;
495 #endif
496 
497 /* YYLEX -- calling `yylex' with the right arguments. */
498 
499 #ifdef YYLEX_PARAM
500 # define YYLEX yylex (YYLEX_PARAM)
501 #else
502 # define YYLEX yylex ()
503 #endif
504 
505 /* Enable debugging if requested. */
506 #if YYDEBUG
507 
508 # ifndef YYFPRINTF
509 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
510 # define YYFPRINTF fprintf
511 # endif
512 
513 # define YYDPRINTF(Args) \
514 do { \
515  if (yydebug) \
516  YYFPRINTF Args; \
517 } while (0)
518 
519 # define YYDSYMPRINT(Args) \
520 do { \
521  if (yydebug) \
522  yysymprint Args; \
523 } while (0)
524 
525 # define YYDSYMPRINTF(Title, Token, Value, Location) \
526 do { \
527  if (yydebug) \
528  { \
529  YYFPRINTF (stderr, "%s ", Title); \
530  yysymprint (stderr, \
531  Token, Value); \
532  YYFPRINTF (stderr, "\n"); \
533  } \
534 } while (0)
535 
536 /*------------------------------------------------------------------.
537 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
538 | TOP (cinluded). |
539 `------------------------------------------------------------------*/
540 
541 #if defined (__STDC__) || defined (__cplusplus)
542 static void
543 yy_stack_print (short *bottom, short *top)
544 #else
545 static void
546 yy_stack_print (bottom, top)
547  short *bottom;
548  short *top;
549 #endif
550 {
551  YYFPRINTF (stderr, "Stack now");
552  for (/* Nothing. */; bottom <= top; ++bottom)
553  YYFPRINTF (stderr, " %d", *bottom);
554  YYFPRINTF (stderr, "\n");
555 }
556 
557 # define YY_STACK_PRINT(Bottom, Top) \
558 do { \
559  if (yydebug) \
560  yy_stack_print ((Bottom), (Top)); \
561 } while (0)
562 
563 
564 /*------------------------------------------------.
565 | Report that the YYRULE is going to be reduced. |
566 `------------------------------------------------*/
567 
568 #if defined (__STDC__) || defined (__cplusplus)
569 static void
570 yy_reduce_print (int yyrule)
571 #else
572 static void
573 yy_reduce_print (yyrule)
574  int yyrule;
575 #endif
576 {
577  int yyi;
578  unsigned int yylineno = yyrline[yyrule];
579  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
580  yyrule - 1, yylineno);
581  /* Print the symbols being reduced, and their result. */
582  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
583  YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
584  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
585 }
586 
587 # define YY_REDUCE_PRINT(Rule) \
588 do { \
589  if (yydebug) \
590  yy_reduce_print (Rule); \
591 } while (0)
592 
593 /* Nonzero means print parse trace. It is left uninitialized so that
594  multiple parsers can coexist. */
595 int yydebug;
596 #else /* !YYDEBUG */
597 # define YYDPRINTF(Args)
598 # define YYDSYMPRINT(Args)
599 # define YYDSYMPRINTF(Title, Token, Value, Location)
600 # define YY_STACK_PRINT(Bottom, Top)
601 # define YY_REDUCE_PRINT(Rule)
602 #endif /* !YYDEBUG */
603 
604 
605 /* YYINITDEPTH -- initial size of the parser's stacks. */
606 #ifndef YYINITDEPTH
607 # define YYINITDEPTH 200
608 #endif
609 
610 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
611  if the built-in stack extension method is used).
612 
613  Do not make this value too large; the results are undefined if
614  SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
615  evaluated with infinite-precision integer arithmetic. */
616 
617 #if YYMAXDEPTH == 0
618 # undef YYMAXDEPTH
619 #endif
620 
621 #ifndef YYMAXDEPTH
622 # define YYMAXDEPTH 10000
623 #endif
624 
625 ␌
626 
627 #if YYERROR_VERBOSE
628 
629 # ifndef yystrlen
630 # if defined (__GLIBC__) && defined (_STRING_H)
631 # define yystrlen strlen
632 # else
633 /* Return the length of YYSTR. */
634 static YYSIZE_T
635 # if defined (__STDC__) || defined (__cplusplus)
636 yystrlen (const char *yystr)
637 # else
638 yystrlen (yystr)
639  const char *yystr;
640 # endif
641 {
642  const char *yys = yystr;
643 
644  while (*yys++ != '\0')
645  continue;
646 
647  return yys - yystr - 1;
648 }
649 # endif
650 # endif
651 
652 # ifndef yystpcpy
653 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
654 # define yystpcpy stpcpy
655 # else
656 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
657  YYDEST. */
658 static char *
659 # if defined (__STDC__) || defined (__cplusplus)
660 yystpcpy (char *yydest, const char *yysrc)
661 # else
662 yystpcpy (yydest, yysrc)
663  char *yydest;
664  const char *yysrc;
665 # endif
666 {
667  char *yyd = yydest;
668  const char *yys = yysrc;
669 
670  while ((*yyd++ = *yys++) != '\0')
671  continue;
672 
673  return yyd - 1;
674 }
675 # endif
676 # endif
677 
678 #endif /* !YYERROR_VERBOSE */
679 
680 ␌
681 
682 #if YYDEBUG
683 /*--------------------------------.
684 | Print this symbol on YYOUTPUT. |
685 `--------------------------------*/
686 
687 #if defined (__STDC__) || defined (__cplusplus)
688 static void
689 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
690 #else
691 static void
692 yysymprint (yyoutput, yytype, yyvaluep)
693  FILE *yyoutput;
694  int yytype;
695  YYSTYPE *yyvaluep;
696 #endif
697 {
698  /* Pacify ``unused variable'' warnings. */
699  (void) yyvaluep;
700 
701  if (yytype < YYNTOKENS)
702  {
703  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
704 # ifdef YYPRINT
705  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
706 # endif
707  }
708  else
709  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
710 
711  switch (yytype)
712  {
713  default:
714  break;
715  }
716  YYFPRINTF (yyoutput, ")");
717 }
718 
719 #endif /* ! YYDEBUG */
720 /*-----------------------------------------------.
721 | Release the memory associated to this symbol. |
722 `-----------------------------------------------*/
723 
724 #if defined (__STDC__) || defined (__cplusplus)
725 static void
726 yydestruct (int yytype, YYSTYPE *yyvaluep)
727 #else
728 static void
730  int yytype;
732 #endif
733 {
734  /* Pacify ``unused variable'' warnings. */
735  (void) yyvaluep;
736 
737  switch (yytype)
738  {
739 
740  default:
741  break;
742  }
743 }
744 ␌
745 
746 /* Prevent warnings from -Wmissing-prototypes. */
747 
748 #ifdef YYPARSE_PARAM
749 # if defined (__STDC__) || defined (__cplusplus)
750 int yyparse (void *YYPARSE_PARAM);
751 # else
752 int yyparse ();
753 # endif
754 #else /* ! YYPARSE_PARAM */
755 #if defined (__STDC__) || defined (__cplusplus)
756 int yyparse (void);
757 #else
758 int yyparse ();
759 #endif
760 #endif /* ! YYPARSE_PARAM */
761 
762 
763 
764 /* The lookahead symbol. */
765 int yychar;
766 
767 /* The semantic value of the lookahead symbol. */
769 
770 /* Number of syntax errors so far. */
772 
773 
774 
775 /*----------.
776 | yyparse. |
777 `----------*/
778 
779 #ifdef YYPARSE_PARAM
780 # if defined (__STDC__) || defined (__cplusplus)
781 int yyparse (void *YYPARSE_PARAM)
782 # else
784  void *YYPARSE_PARAM;
785 # endif
786 #else /* ! YYPARSE_PARAM */
787 #if defined (__STDC__) || defined (__cplusplus)
788 int
789 yyparse (void)
790 #else
791 int
793 
794 #endif
795 #endif
796 {
797 
798  int yystate;
799  int yyn;
800  int yyresult;
801  /* Number of tokens to shift before error messages enabled. */
802  int yyerrstatus;
803  /* Lookahead token as an internal (translated) token number. */
804  int yytoken = 0;
805 
806  /* Three stacks and their tools:
807  `yyss': related to states,
808  `yyvs': related to semantic values,
809  `yyls': related to locations.
810 
811  Refer to the stacks thru separate pointers, to allow yyoverflow
812  to reallocate them elsewhere. */
813 
814  /* The state stack. */
815  short yyssa[YYINITDEPTH];
816  short *yyss = yyssa;
817  short *yyssp;
818 
819  /* The semantic value stack. */
820  YYSTYPE yyvsa[YYINITDEPTH];
821  YYSTYPE *yyvs = yyvsa;
822  YYSTYPE *yyvsp;
823 
824 
825 
826 #define YYPOPSTACK (yyvsp--, yyssp--)
827 
828  YYSIZE_T yystacksize = YYINITDEPTH;
829 
830  /* The variables used to return semantic value and location from the
831  action routines. */
832  YYSTYPE yyval;
833 
834 
835  /* When reducing, the number of symbols on the RHS of the reduced
836  rule. */
837  int yylen;
838 
839  YYDPRINTF ((stderr, "Starting parse\n"));
840 
841  yystate = 0;
842  yyerrstatus = 0;
843  yynerrs = 0;
844  yychar = YYEMPTY; /* Cause a token to be read. */
845 
846  /* Initialize stack pointers.
847  Waste one element of value and location stack
848  so that they stay on the same level as the state stack.
849  The wasted elements are never initialized. */
850 
851  yyssp = yyss;
852  yyvsp = yyvs;
853 
854  goto yysetstate;
855 
856 /*------------------------------------------------------------.
857 | yynewstate -- Push a new state, which is found in yystate. |
858 `------------------------------------------------------------*/
859  yynewstate:
860  /* In all cases, when you get here, the value and location stacks
861  have just been pushed. so pushing a state here evens the stacks.
862  */
863  yyssp++;
864 
865  yysetstate:
866  *yyssp = yystate;
867 
868  if (yyss + yystacksize - 1 <= yyssp)
869  {
870  /* Get the current used size of the three stacks, in elements. */
871  YYSIZE_T yysize = yyssp - yyss + 1;
872 
873 #ifdef yyoverflow
874  {
875  /* Give user a chance to reallocate the stack. Use copies of
876  these so that the &'s don't force the real ones into
877  memory. */
878  YYSTYPE *yyvs1 = yyvs;
879  short *yyss1 = yyss;
880 
881 
882  /* Each stack pointer address is followed by the size of the
883  data in use in that stack, in bytes. This used to be a
884  conditional around just the two extra args, but that might
885  be undefined if yyoverflow is a macro. */
886  yyoverflow ("parser stack overflow",
887  &yyss1, yysize * sizeof (*yyssp),
888  &yyvs1, yysize * sizeof (*yyvsp),
889 
890  &yystacksize);
891 
892  yyss = yyss1;
893  yyvs = yyvs1;
894  }
895 #else /* no yyoverflow */
896 # ifndef YYSTACK_RELOCATE
897  goto yyoverflowlab;
898 # else
899  /* Extend the stack our own way. */
900  if (YYMAXDEPTH <= yystacksize)
901  goto yyoverflowlab;
902  yystacksize *= 2;
903  if (YYMAXDEPTH < yystacksize)
904  yystacksize = YYMAXDEPTH;
905 
906  {
907  short *yyss1 = yyss;
908  union yyalloc *yyptr =
909  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
910  if (! yyptr)
911  goto yyoverflowlab;
914 
915 # undef YYSTACK_RELOCATE
916  if (yyss1 != yyssa)
917  YYSTACK_FREE (yyss1);
918  }
919 # endif
920 #endif /* no yyoverflow */
921 
922  yyssp = yyss + yysize - 1;
923  yyvsp = yyvs + yysize - 1;
924 
925 
926  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
927  (unsigned long int) yystacksize));
928 
929  if (yyss + yystacksize - 1 <= yyssp)
930  YYABORT;
931  }
932 
933  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
934 
935  goto yybackup;
936 
937 /*-----------.
938 | yybackup. |
939 `-----------*/
940 yybackup:
941 
942 /* Do appropriate processing given the current state. */
943 /* Read a lookahead token if we need one and don't already have one. */
944 /* yyresume: */
945 
946  /* First try to decide what to do without reference to lookahead token. */
947 
948  yyn = yypact[yystate];
949  if (yyn == YYPACT_NINF)
950  goto yydefault;
951 
952  /* Not known => get a lookahead token if don't already have one. */
953 
954  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
955  if (yychar == YYEMPTY)
956  {
957  YYDPRINTF ((stderr, "Reading a token: "));
958  yychar = YYLEX;
959  }
960 
961  if (yychar <= YYEOF)
962  {
963  yychar = yytoken = YYEOF;
964  YYDPRINTF ((stderr, "Now at end of input.\n"));
965  }
966  else
967  {
968  yytoken = YYTRANSLATE (yychar);
969  YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
970  }
971 
972  /* If the proper action on seeing token YYTOKEN is to reduce or to
973  detect an error, take that action. */
974  yyn += yytoken;
975  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
976  goto yydefault;
977  yyn = yytable[yyn];
978  if (yyn <= 0)
979  {
980  if (yyn == 0 || yyn == YYTABLE_NINF)
981  goto yyerrlab;
982  yyn = -yyn;
983  goto yyreduce;
984  }
985 
986  if (yyn == YYFINAL)
987  YYACCEPT;
988 
989  /* Shift the lookahead token. */
990  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
991 
992  /* Discard the token being shifted unless it is eof. */
993  if (yychar != YYEOF)
994  yychar = YYEMPTY;
995 
996  *++yyvsp = yylval;
997 
998 
999  /* Count tokens shifted since error; after three, turn off error
1000  status. */
1001  if (yyerrstatus)
1002  yyerrstatus--;
1003 
1004  yystate = yyn;
1005  goto yynewstate;
1006 
1007 
1008 /*-----------------------------------------------------------.
1009 | yydefault -- do the default action for the current state. |
1010 `-----------------------------------------------------------*/
1011 yydefault:
1012  yyn = yydefact[yystate];
1013  if (yyn == 0)
1014  goto yyerrlab;
1015  goto yyreduce;
1016 
1017 
1018 /*-----------------------------.
1019 | yyreduce -- Do a reduction. |
1020 `-----------------------------*/
1021 yyreduce:
1022  /* yyn is the number of a rule to reduce with. */
1023  yylen = yyr2[yyn];
1024 
1025  /* If YYLEN is nonzero, implement the default value of the action:
1026  `$$ = $1'.
1027 
1028  Otherwise, the following line sets YYVAL to garbage.
1029  This behavior is undocumented and Bison
1030  users should not rely upon it. Assigning to YYVAL
1031  unconditionally makes the parser a bit smaller, and it avoids a
1032  GCC warning that YYVAL may be used uninitialized. */
1033  yyval = yyvsp[1-yylen];
1034 
1035 
1036  YY_REDUCE_PRINT (yyn);
1037  switch (yyn)
1038  {
1039  case 2:
1040 #line 70 "newick.ypp"
1041  {
1042  g_Tree = yyvsp[-1].nodeval;
1043 ;}
1044  break;
1045 
1046  case 3:
1047 #line 76 "newick.ypp"
1048  {
1049  yyval.nodeval = yyvsp[-3].nodeval;
1050  yyval.nodeval->GetValue().SetDist(yyvsp[0].dblval);
1051  yyval.nodeval->GetValue().SetId(nodecount);
1052  nodecount++;
1053 ;}
1054  break;
1055 
1056  case 4:
1057 #line 83 "newick.ypp"
1058  {
1059  yyval.nodeval = yyvsp[-1].nodeval;
1060  yyval.nodeval->GetValue().SetId(nodecount);
1061  nodecount++;
1062 ;}
1063  break;
1064 
1065  case 5:
1066 #line 89 "newick.ypp"
1067  {
1068  yyval.nodeval = yyvsp[-4].nodeval;
1069  yyval.nodeval->GetValue().SetLabel(yyvsp[-2].strval);
1070  yyval.nodeval->GetValue().SetDist(yyvsp[0].dblval);
1071  yyval.nodeval->GetValue().SetId(nodecount);
1072  nodecount++;
1073 ;}
1074  break;
1075 
1076  case 6:
1077 #line 97 "newick.ypp"
1078  {
1079  yyval.nodeval = yyvsp[-2].nodeval;
1080  yyval.nodeval->GetValue().SetLabel(yyvsp[0].strval);
1081  yyval.nodeval->GetValue().SetId(nodecount);
1082  nodecount++;
1083 ;}
1084  break;
1085 
1086  case 7:
1087 #line 104 "newick.ypp"
1088  {
1089  yyval.nodeval = new TPhyTreeNode;
1090  yyval.nodeval->GetValue().SetLabel(yyvsp[-2].strval);
1091  yyval.nodeval->GetValue().SetDist(yyvsp[0].dblval);
1092  yyval.nodeval->GetValue().SetId(nodecount);
1093  nodecount++;
1094 ;}
1095  break;
1096 
1097  case 8:
1098 #line 112 "newick.ypp"
1099  {
1100  yyval.nodeval = new TPhyTreeNode;
1101  yyval.nodeval->GetValue().SetLabel("");
1102  yyval.nodeval->GetValue().SetDist(yyvsp[0].dblval);
1103  yyval.nodeval->GetValue().SetId(nodecount);
1104  nodecount++;
1105 ;}
1106  break;
1107 
1108  case 9:
1109 #line 120 "newick.ypp"
1110  {
1111  yyval.nodeval = new TPhyTreeNode;
1112  yyval.nodeval->GetValue().SetLabel(yyvsp[0].strval);
1113  yyval.nodeval->GetValue().SetId(nodecount);
1114  nodecount++;
1115 ;}
1116  break;
1117 
1118  case 10:
1119 #line 127 "newick.ypp"
1120  {
1121  yyval.nodeval = new TPhyTreeNode;
1122  yyval.nodeval->GetValue().SetLabel("");
1123  yyval.nodeval->GetValue().SetId(nodecount);
1124  nodecount++;
1125 ;}
1126  break;
1127 
1128  case 11:
1129 #line 136 "newick.ypp"
1130  {
1131  yyval.nodeval = new TPhyTreeNode;
1132  yyval.nodeval->AddNode(yyvsp[0].nodeval);
1133 ;}
1134  break;
1135 
1136  case 12:
1137 #line 141 "newick.ypp"
1138  {
1139  yyval.nodeval = yyvsp[-2].nodeval;
1140  yyval.nodeval->AddNode(yyvsp[0].nodeval);
1141 ;}
1142  break;
1143 
1144 
1145  }
1146 
1147 /* Line 991 of yacc.c. */
1148 #line 1146 "newick.tab.cpp"
1149 ␌
1150  yyvsp -= yylen;
1151  yyssp -= yylen;
1152 
1153 
1154  YY_STACK_PRINT (yyss, yyssp);
1155 
1156  *++yyvsp = yyval;
1157 
1158 
1159  /* Now `shift' the result of the reduction. Determine what state
1160  that goes to, based on the state we popped back to and the rule
1161  number reduced by. */
1162 
1163  yyn = yyr1[yyn];
1164 
1165  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1166  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1167  yystate = yytable[yystate];
1168  else
1169  yystate = yydefgoto[yyn - YYNTOKENS];
1170 
1171  goto yynewstate;
1172 
1173 
1174 /*------------------------------------.
1175 | yyerrlab -- here on detecting error |
1176 `------------------------------------*/
1177 yyerrlab:
1178  /* If not already recovering from an error, report this error. */
1179  if (!yyerrstatus)
1180  {
1181  ++yynerrs;
1182 #if YYERROR_VERBOSE
1183  yyn = yypact[yystate];
1184 
1185  if (YYPACT_NINF < yyn && yyn < YYLAST)
1186  {
1187  YYSIZE_T yysize = 0;
1188  int yytype = YYTRANSLATE (yychar);
1189  char *yymsg;
1190  int yyx, yycount;
1191 
1192  yycount = 0;
1193  /* Start YYX at -YYN if negative to avoid negative indexes in
1194  YYCHECK. */
1195  for (yyx = yyn < 0 ? -yyn : 0;
1196  yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1197  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1198  yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1199  yysize += yystrlen ("syntax error, unexpected ") + 1;
1200  yysize += yystrlen (yytname[yytype]);
1201  yymsg = (char *) YYSTACK_ALLOC (yysize);
1202  if (yymsg != 0)
1203  {
1204  char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1205  yyp = yystpcpy (yyp, yytname[yytype]);
1206 
1207  if (yycount < 5)
1208  {
1209  yycount = 0;
1210  for (yyx = yyn < 0 ? -yyn : 0;
1211  yyx < (int) (sizeof (yytname) / sizeof (char *));
1212  yyx++)
1213  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1214  {
1215  const char *yyq = ! yycount ? ", expecting " : " or ";
1216  yyp = yystpcpy (yyp, yyq);
1217  yyp = yystpcpy (yyp, yytname[yyx]);
1218  yycount++;
1219  }
1220  }
1221  yyerror (yymsg);
1222  YYSTACK_FREE (yymsg);
1223  }
1224  else
1225  yyerror ("syntax error; also virtual memory exhausted");
1226  }
1227  else
1228 #endif /* YYERROR_VERBOSE */
1229  yyerror ("syntax error");
1230  }
1231 
1232 
1233 
1234  if (yyerrstatus == 3)
1235  {
1236  /* If just tried and failed to reuse lookahead token after an
1237  error, discard it. */
1238 
1239  /* Return failure if at end of input. */
1240  if (yychar == YYEOF)
1241  {
1242  /* Pop the error token. */
1243  YYPOPSTACK;
1244  /* Pop the rest of the stack. */
1245  while (yyss < yyssp)
1246  {
1247  YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1248  yydestruct (yystos[*yyssp], yyvsp);
1249  YYPOPSTACK;
1250  }
1251  YYABORT;
1252  }
1253 
1254  YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
1255  yydestruct (yytoken, &yylval);
1256  yychar = YYEMPTY;
1257 
1258  }
1259 
1260  /* Else will try to reuse lookahead token after shifting the error
1261  token. */
1262  goto yyerrlab2;
1263 
1264 
1265 /*----------------------------------------------------.
1266 | yyerrlab1 -- error raised explicitly by an action. |
1267 `----------------------------------------------------*/
1268 yyerrlab1:
1269 
1270  /* Suppress GCC warning that yyerrlab1 is unused when no action
1271  invokes YYERROR. */
1272 #if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__) \
1273  && !defined __cplusplus
1274  __attribute__ ((__unused__))
1275 #endif
1276 
1277 
1278  goto yyerrlab2;
1279 
1280 
1281 /*---------------------------------------------------------------.
1282 | yyerrlab2 -- pop states until the error token can be shifted. |
1283 `---------------------------------------------------------------*/
1284 yyerrlab2:
1285  yyerrstatus = 3; /* Each real token shifted decrements this. */
1286 
1287  for (;;)
1288  {
1289  yyn = yypact[yystate];
1290  if (yyn != YYPACT_NINF)
1291  {
1292  yyn += YYTERROR;
1293  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1294  {
1295  yyn = yytable[yyn];
1296  if (0 < yyn)
1297  break;
1298  }
1299  }
1300 
1301  /* Pop the current state because it cannot handle the error token. */
1302  if (yyssp == yyss)
1303  YYABORT;
1304 
1305  YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1306  yydestruct (yystos[yystate], yyvsp);
1307  yyvsp--;
1308  yystate = *--yyssp;
1309 
1310  YY_STACK_PRINT (yyss, yyssp);
1311  }
1312 
1313  if (yyn == YYFINAL)
1314  YYACCEPT;
1315 
1316  YYDPRINTF ((stderr, "Shifting error token, "));
1317 
1318  *++yyvsp = yylval;
1319 
1320 
1321  yystate = yyn;
1322  goto yynewstate;
1323 
1324 
1325 /*-------------------------------------.
1326 | yyacceptlab -- YYACCEPT comes here. |
1327 `-------------------------------------*/
1328 yyacceptlab:
1329  yyresult = 0;
1330  goto yyreturn;
1331 
1332 /*-----------------------------------.
1333 | yyabortlab -- YYABORT comes here. |
1334 `-----------------------------------*/
1335 yyabortlab:
1336  yyresult = 1;
1337  goto yyreturn;
1338 
1339 #ifndef yyoverflow
1340 /*----------------------------------------------.
1341 | yyoverflowlab -- parser overflow comes here. |
1342 `----------------------------------------------*/
1343 yyoverflowlab:
1344  yyerror ("parser stack overflow");
1345  yyresult = 2;
1346  /* Fall through. */
1347 #endif
1348 
1349 yyreturn:
1350 #ifndef yyoverflow
1351  if (yyss != yyssa)
1352  YYSTACK_FREE (yyss);
1353 #endif
1354  return yyresult;
1355 }
1356 
1357 
1358 #line 148 "newick.ypp"
1359 
1360 
1361 void yyerror(const char *s)
1362 {
1363  if (g_Tree) {
1364  delete g_Tree;
1365  } else {
1366  // delete only those nodes that are nobody's children
1367  vector<TPhyTreeNode*> del_list;
1368  ITERATE (vector<TPhyTreeNode*>, iter, g_NodeList) {
1369  if (!(*iter)->GetParent()) {
1370  del_list.push_back(*iter);
1371  }
1372  }
1373  ITERATE (vector<TPhyTreeNode*>, iter, del_list) {
1374  delete *iter;
1375  }
1376  }
1377  g_NodeList.clear();
1378  throw runtime_error(string("error parsing Newick format tree file: ")
1379  + s);
1380 }
1381 
1382 void newick_flex_reset(void);
1383 
1385 
1387 {
1388  g_NewickIstr = &is;
1389  g_Tree = 0;
1390  g_NodeList.clear();
1392  yyparse();
1393  if (!g_Tree) {
1394  yyerror("unknown");
1395  }
1396  g_NodeList.clear();
1397  return g_Tree;
1398 }
1399 
1401 
#define YYPARSE_PARAM
static void yy_reduce_print(int yyrule)
static void yysymprint(FILE *yyoutput, int yytype, CBDB_Query::TQueryClause **yyvaluep)
static const unsigned char yyrline[]
static void yy_stack_print(short *bottom, short *top)
static const yysigned_char yyrhs[]
static const char *const yytname[]
static const unsigned char yyprhs[]
#define YYFPRINTF
definition of a Culling tree
Definition: ncbi_tree.hpp:100
#define ITERATE(Type, Var, Cont)
ITERATE macro to sequence through container elements.
Definition: ncbimisc.hpp:815
#define END_NCBI_SCOPE
End previously defined NCBI scope.
Definition: ncbistl.hpp:103
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
Definition: ncbistl.hpp:100
IO_PREFIX::istream CNcbiIstream
Portable alias for istream.
Definition: ncbistre.hpp:146
void AddNode(TTreeType *subnode)
Add new subnode.
Definition: ncbi_tree.hpp:743
const TValue & GetValue(void) const
Return node's value.
Definition: ncbi_tree.hpp:184
unsigned int
A callback function used to compare two keys in a database.
Definition: types.hpp:1210
Magic spell ;-) needed for some weird compilers... very empiric.
static TPhyTreeNode * g_Tree
Definition: newick.tab.cpp:123
#define LABEL
Definition: newick.tab.cpp:71
#define YYLEX
Definition: newick.tab.cpp:502
#define YYMAXDEPTH
Definition: newick.tab.cpp:622
yytokentype
Definition: newick.tab.cpp:66
short yysigned_char
Definition: newick.tab.cpp:260
#define YYSTACK_FREE
Definition: newick.tab.cpp:196
void newick_flex_reset(void)
#define YYDSYMPRINTF(Title, Token, Value, Location)
Definition: newick.tab.cpp:599
static const unsigned char yytable[]
Definition: newick.tab.cpp:412
#define yychar
Definition: newick.tab.cpp:56
YYSTYPE * yyvaluep
Definition: newick.tab.cpp:731
#define YYEOF
Definition: newick.tab.cpp:452
#define YYABORT
Definition: newick.tab.cpp:455
#define YYSTACK_BYTES(N)
Definition: newick.tab.cpp:217
vector< TPhyTreeNode * > g_NodeList
Definition: newick.tab.cpp:128
static const unsigned char yydefact[]
Definition: newick.tab.cpp:378
static void yydestruct(yytype, yyvaluep) int yytype
#define YY_REDUCE_PRINT(Rule)
Definition: newick.tab.cpp:601
static const yysigned_char yypact[]
Definition: newick.tab.cpp:394
#define YYTABLE_NINF
Definition: newick.tab.cpp:411
#define yylex
Definition: newick.tab.cpp:53
static int nodecount
Definition: newick.tab.cpp:122
#define YYPACT_NINF
Definition: newick.tab.cpp:393
#define YYFINAL
Definition: newick.tab.cpp:264
#define yyparse
Definition: newick.tab.cpp:52
#define yylval
Definition: newick.tab.cpp:55
#define YYNTOKENS
Definition: newick.tab.cpp:269
#define YY_STACK_PRINT(Bottom, Top)
Definition: newick.tab.cpp:600
#define YYSIZE_T
Definition: newick.tab.cpp:446
#define yydebug
Definition: newick.tab.cpp:57
static const unsigned char yyr2[]
Definition: newick.tab.cpp:369
static const unsigned char yytranslate[]
Definition: newick.tab.cpp:285
#define yynerrs
Definition: newick.tab.cpp:58
static const yysigned_char yypgoto[]
Definition: newick.tab.cpp:402
#define YYACCEPT
Definition: newick.tab.cpp:454
#define YYTRANSLATE(YYX)
Definition: newick.tab.cpp:281
#define NUM
Definition: newick.tab.cpp:72
USING_SCOPE(ncbi)
static const yysigned_char yycheck[]
Definition: newick.tab.cpp:418
static const yysigned_char yydefgoto[]
Definition: newick.tab.cpp:386
static const unsigned char yystos[]
Definition: newick.tab.cpp:426
union YYSTYPE YYSTYPE
#define YYSTACK_RELOCATE(Stack)
Definition: newick.tab.cpp:244
#define YYTERROR
Definition: newick.tab.cpp:483
CNcbiIstream * g_NewickIstr
Definition: newick.tab.cpp:126
#define YYPOPSTACK
#define YYEMPTY
Definition: newick.tab.cpp:451
#define YYLAST
Definition: newick.tab.cpp:266
static const unsigned char yyr1[]
Definition: newick.tab.cpp:362
#define YYINITDEPTH
Definition: newick.tab.cpp:131
#define YYSTACK_ALLOC
Definition: newick.tab.cpp:195
TPhyTreeNode * ReadNewickTree(CNcbiIstream &is)
Newick format input.
#define YYDPRINTF(Args)
Definition: newick.tab.cpp:597
#define yyerror
Definition: newick.tab.cpp:54
CTreeNode< CPhyNodeData > TPhyTreeNode
Definition: phy_node.hpp:81
static char * yystpcpy(char *yydest, const char *yysrc)
static unsigned int yystrlen(char *yystr) const
char * strval
Definition: newick.tab.cpp:150
TPhyTreeNode * nodeval
Definition: newick.tab.cpp:152
double dblval
Definition: newick.tab.cpp:151
short yyss
Definition: newick.tab.cpp:208
YYSTYPE yyvs
Definition: newick.tab.cpp:209
Modified on Sun Apr 21 03:45:20 2024 by modify_doxy.py rev. 669887