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

Go to the SVN repository for this file.

1 #include <ncbi_pch.hpp>
2 #define yy_create_buffer newick_create_buffer
3 #define yy_delete_buffer newick_delete_buffer
4 #define yy_scan_buffer newick_scan_buffer
5 #define yy_scan_string newick_scan_string
6 #define yy_scan_bytes newick_scan_bytes
7 #define yy_flex_debug newick_flex_debug
8 #define yy_init_buffer newick_init_buffer
9 #define yy_flush_buffer newick_flush_buffer
10 #define yy_load_buffer_state newick_load_buffer_state
11 #define yy_switch_to_buffer newick_switch_to_buffer
12 #define yyin newickin
13 #define yyleng newickleng
14 #define yylex newicklex
15 #define yyout newickout
16 #define yyrestart newickrestart
17 #define yytext newicktext
18 
19 #line 19 "lex.newick.cpp"
20 /* A lexical scanner generated by flex */
21 
22 /* Scanner skeleton version:
23  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
24  */
25 
26 #define FLEX_SCANNER
27 #define YY_FLEX_MAJOR_VERSION 2
28 #define YY_FLEX_MINOR_VERSION 5
29 
30 #include <stdio.h>
31 
32 
33 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
34 #ifdef c_plusplus
35 #ifndef __cplusplus
36 #define __cplusplus
37 #endif
38 #endif
39 
40 
41 #ifdef __cplusplus
42 
43 #include <stdlib.h>
44 
45 /* Use prototypes in function declarations. */
46 #define YY_USE_PROTOS
47 
48 /* The "const" storage-class-modifier is valid. */
49 #define YY_USE_CONST
50 
51 #else /* ! __cplusplus */
52 
53 #if __STDC__
54 
55 #define YY_USE_PROTOS
56 #define YY_USE_CONST
57 
58 #endif /* __STDC__ */
59 #endif /* ! __cplusplus */
60 
61 #ifdef __TURBOC__
62  #pragma warn -rch
63  #pragma warn -use
64 #include <io.h>
65 #include <stdlib.h>
66 #define YY_USE_CONST
67 #define YY_USE_PROTOS
68 #endif
69 
70 #ifdef YY_USE_CONST
71 #define yyconst const
72 #else
73 #define yyconst
74 #endif
75 
76 
77 #ifdef YY_USE_PROTOS
78 #define YY_PROTO(proto) proto
79 #else
80 #define YY_PROTO(proto) ()
81 #endif
82 
83 /* Returned upon end-of-file. */
84 #define YY_NULL 0
85 
86 /* Promotes a possibly negative, possibly signed char to an unsigned
87  * integer for use as an array index. If the signed char is negative,
88  * we want to instead treat it as an 8-bit unsigned char, hence the
89  * double cast.
90  */
91 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
92 
93 /* Enter a start condition. This macro really ought to take a parameter,
94  * but we do it the disgusting crufty way forced on us by the ()-less
95  * definition of BEGIN.
96  */
97 #define BEGIN yy_start = 1 + 2 *
98 
99 /* Translate the current start state into a value that can be later handed
100  * to BEGIN to return to the state. The YYSTATE alias is for lex
101  * compatibility.
102  */
103 #define YY_START ((yy_start - 1) / 2)
104 #define YYSTATE YY_START
105 
106 /* Action number for EOF rule of a given start state. */
107 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
108 
109 /* Special action meaning "start processing a new file". */
110 #define YY_NEW_FILE yyrestart( yyin )
111 
112 #define YY_END_OF_BUFFER_CHAR 0
113 
114 /* Size of default input buffer. */
115 #define YY_BUF_SIZE 16384
116 
118 
119 extern int yyleng;
120 extern FILE *yyin, *yyout;
121 
122 #define EOB_ACT_CONTINUE_SCAN 0
123 #define EOB_ACT_END_OF_FILE 1
124 #define EOB_ACT_LAST_MATCH 2
125 
126 /* The funky do-while in the following #define is used to turn the definition
127  * int a single C statement (which needs a semi-colon terminator). This
128  * avoids problems with code like:
129  *
130  * if ( condition_holds )
131  * yyless( 5 );
132  * else
133  * do_something_else();
134  *
135  * Prior to using the do-while the compiler would get upset at the
136  * "else" because it interpreted the "if" statement as being all
137  * done when it reached the ';' after the yyless() call.
138  */
139 
140 /* Return all but the first 'n' matched characters back to the input stream. */
141 
142 #define yyless(n) \
143  do \
144  { \
145  /* Undo effects of setting up yytext. */ \
146  *yy_cp = yy_hold_char; \
147  YY_RESTORE_YY_MORE_OFFSET \
148  yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
149  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
150  } \
151  while ( 0 )
152 
153 #define unput(c) yyunput( c, yytext_ptr )
154 
155 /* The following is because we cannot portably get our hands on size_t
156  * (without autoconf's help, which isn't available because we want
157  * flex-generated scanners to compile on their own).
158  */
159 typedef unsigned int yy_size_t;
160 
161 
163  {
165 
166  char *yy_ch_buf; /* input buffer */
167  char *yy_buf_pos; /* current position in input buffer */
168 
169  /* Size of input buffer in bytes, not including room for EOB
170  * characters.
171  */
172  yy_size_t yy_buf_size;
173 
174  /* Number of characters read into yy_ch_buf, not including EOB
175  * characters.
176  */
178 
179  /* Whether we "own" the buffer - i.e., we know we created it,
180  * and can realloc() it to grow it, and should free() it to
181  * delete it.
182  */
184 
185  /* Whether this is an "interactive" input source; if so, and
186  * if we're using stdio for input, then we want to use getc()
187  * instead of fread(), to make sure we stop fetching input after
188  * each newline.
189  */
191 
192  /* Whether we're considered to be at the beginning of a line.
193  * If so, '^' rules will be active on the next match, otherwise
194  * not.
195  */
197 
198  /* Whether to try to fill the input buffer when we reach the
199  * end of it.
200  */
202 
204 #define YY_BUFFER_NEW 0
205 #define YY_BUFFER_NORMAL 1
206  /* When an EOF's been seen but there's still some text to process
207  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
208  * shouldn't try reading from the input source any more. We might
209  * still have a bunch of tokens to match, though, because of
210  * possible backing-up.
211  *
212  * When we actually see the EOF, we change the status to "new"
213  * (via yyrestart()), so that the user can continue scanning by
214  * just pointing yyin at a new input file.
215  */
216 #define YY_BUFFER_EOF_PENDING 2
217  };
218 
219 static YY_BUFFER_STATE yy_current_buffer = 0;
220 
221 /* We provide macros for accessing buffer states in case in the
222  * future we want to put the buffer states in a more general
223  * "scanner state".
224  */
225 #define YY_CURRENT_BUFFER yy_current_buffer
226 
227 
228 /* yy_hold_char holds the character lost when yytext is formed. */
229 static char yy_hold_char;
230 
231 static int yy_n_chars; /* number of characters read into yy_ch_buf */
232 
233 
234 int yyleng;
235 
236 /* Points to current character in buffer. */
237 static char *yy_c_buf_p = (char *) 0;
238 static int yy_init = 1; /* whether we need to initialize */
239 static int yy_start = 0; /* start state number */
240 
241 /* Flag which is used to allow yywrap()'s to do buffer switches
242  * instead of setting up a fresh yyin. A bit of a hack ...
243  */
245 
246 void yyrestart YY_PROTO(( FILE *input_file ));
247 
248 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
249 void yy_load_buffer_state YY_PROTO(( void ));
250 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
251 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
252 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
253 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
254 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
255 
256 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
257 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
258 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
259 
260 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
261 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
262 static void yy_flex_free YY_PROTO(( void * ));
263 
264 #define yy_new_buffer yy_create_buffer
265 
266 #define yy_set_interactive(is_interactive) \
267  { \
268  if ( ! yy_current_buffer ) \
269  yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
270  yy_current_buffer->yy_is_interactive = is_interactive; \
271  }
272 
273 #define yy_set_bol(at_bol) \
274  { \
275  if ( ! yy_current_buffer ) \
276  yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
277  yy_current_buffer->yy_at_bol = at_bol; \
278  }
279 
280 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
281 
282 
283 #define yywrap() 1
284 #define YY_SKIP_YYWRAP
285 typedef unsigned char YY_CHAR;
286 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
287 typedef int yy_state_type;
288 extern char *yytext;
289 #define yytext_ptr yytext
290 
291 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
292 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
293 static int yy_get_next_buffer YY_PROTO(( void ));
294 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
295 
296 /* Done after the current pattern has been matched and before the
297  * corresponding action - sets up yytext.
298  */
299 #define YY_DO_BEFORE_ACTION \
300  yytext_ptr = yy_bp; \
301  yyleng = (int) (yy_cp - yy_bp); \
302  yy_hold_char = *yy_cp; \
303  *yy_cp = '\0'; \
304  yy_c_buf_p = yy_cp;
305 
306 #define YY_NUM_RULES 7
307 #define YY_END_OF_BUFFER 8
308 static yyconst short int yy_accept[26] =
309  { 0,
310  4, 4, 4, 4, 8, 3, 2, 2, 6, 6,
311  5, 3, 3, 1, 3, 0, 4, 3, 1, 1,
312  3, 0, 3, 1, 0
313  } ;
314 
315 static yyconst int yy_ec[256] =
316  { 0,
317  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
318  1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
319  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
320  1, 2, 1, 1, 1, 1, 1, 1, 4, 5,
321  5, 1, 6, 5, 6, 7, 1, 8, 8, 8,
322  8, 8, 8, 8, 8, 8, 8, 9, 5, 1,
323  1, 1, 1, 1, 1, 1, 1, 1, 10, 1,
324  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
325  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
326  5, 1, 5, 1, 1, 1, 1, 1, 1, 1,
327 
328  10, 1, 1, 1, 1, 1, 1, 1, 1, 1,
329  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
330  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
331  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
332  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
333  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
334  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
335  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
336  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
337  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
338 
339  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
340  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
341  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
342  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
343  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
344  1, 1, 1, 1, 1
345  } ;
346 
347 static yyconst int yy_meta[11] =
348  { 0,
349  1, 2, 2, 2, 2, 1, 1, 1, 2, 1
350  } ;
351 
352 static yyconst short int yy_base[28] =
353  { 0,
354  0, 0, 5, 0, 29, 0, 30, 30, 24, 30,
355  30, 7, 19, 16, 0, 21, 20, 0, 0, 13,
356  10, 18, 13, 0, 30, 16, 18
357  } ;
358 
359 static yyconst short int yy_def[28] =
360  { 0,
361  25, 1, 1, 3, 25, 26, 25, 25, 27, 25,
362  25, 26, 26, 12, 26, 27, 25, 13, 14, 13,
363  13, 27, 13, 23, 0, 25, 25
364  } ;
365 
366 static yyconst short int yy_nxt[41] =
367  { 0,
368  6, 7, 8, 9, 10, 6, 6, 6, 11, 6,
369  12, 13, 14, 18, 19, 23, 15, 24, 16, 16,
370  24, 17, 21, 22, 17, 21, 20, 17, 25, 5,
371  25, 25, 25, 25, 25, 25, 25, 25, 25, 25
372  } ;
373 
374 static yyconst short int yy_chk[41] =
375  { 0,
376  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
377  3, 3, 3, 12, 12, 21, 26, 21, 27, 27,
378  23, 22, 20, 17, 16, 14, 13, 9, 5, 25,
379  25, 25, 25, 25, 25, 25, 25, 25, 25, 25
380  } ;
381 
382 static yy_state_type yy_last_accepting_state;
384 
385 /* The intent behind this definition is that it'll catch
386  * any uses of REJECT which flex missed.
387  */
388 #define REJECT reject_used_but_not_detected
389 #define yymore() yymore_used_but_not_detected
390 #define YY_MORE_ADJ 0
391 #define YY_RESTORE_YY_MORE_OFFSET
392 char *yytext;
393 #line 1 "newick.lpp"
394 #define INITIAL 0
395 /* $Id: lex.newick.cpp 49119 2011-03-30 11:58:10Z ludwigf $
396  * ===========================================================================
397  *
398  * PUBLIC DOMAIN NOTICE
399  * National Center for Biotechnology Information
400  *
401  * This software/database is a "United States Government Work" under the
402  * terms of the United States Copyright Act. It was written as part of
403  * the author's official duties as a United States Government employee and
404  * thus cannot be copyrighted. This software/database is freely available
405  * to the public for use. The National Library of Medicine and the U.S.
406  * Government have not placed any restriction on its use or reproduction.
407  *
408  * Although all reasonable efforts have been taken to ensure the accuracy
409  * and reliability of the software and data, the NLM and the U.S.
410  * Government do not and cannot warrant the performance or results that
411  * may be obtained by using this software or data. The NLM and the U.S.
412  * Government disclaim all warranties, express or implied, including
413  * warranties of performance, merchantability or fitness for any particular
414  * purpose.
415  *
416  * Please cite the author in any work or product based on this material.
417  *
418  * ===========================================================================
419  *
420  * Authors: Josh Cherry
421  *
422  * File Description: flex lexer for Newick format phylogenetic trees
423  *
424  */
425 /*
426  * Meant to be used in conjunction with bison parser defined
427  * by newick.ypp. Generate code using (essentially)
428  * flex -olex.newick.cpp newick.lpp
429  * bison -d -p newick newick.ypp
430  * The line '#include <unistd.h>' must be removed from the flex-generated
431  * code for it to compile on some platforms.
432  */
433 #line 44 "newick.lpp"
434 #include <ncbi_pch.hpp>
435 #include <string.h>
436 #include <corelib/stream_utils.hpp>
438 
439 #define YY_NO_UNPUT 1 // avoid a compiler warning
440 
442 
443 #include "newick.tab.hpp"
444 
445 static string g_Buffer;
446 
447 // input from a stream
448 extern CNcbiIstream *g_NewickIstr;
449 #define YY_INPUT(buf, result, max_size) \
450 { \
451  result = CStreamUtils::Readsome(*g_NewickIstr, buf, max_size); \
452  if (result == 0 && !*g_NewickIstr) { \
453  result = YY_NULL; \
454  } \
455 }
456 
457 #define YY_NEVER_INTERACTIVE 1
458 #define EXPECT_NUM 1
459 
460 #line 461 "lex.newick.cpp"
461 
462 /* Macros after this point can all be overridden by user definitions in
463  * section 1.
464  */
465 
466 #ifndef YY_SKIP_YYWRAP
467 #ifdef __cplusplus
468 extern "C" int yywrap YY_PROTO(( void ));
469 #else
470 extern int yywrap YY_PROTO(( void ));
471 #endif
472 #endif
473 
474 #ifndef YY_NO_UNPUT
475 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
476 #endif
477 
478 #ifndef yytext_ptr
479 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
480 #endif
481 
482 #ifdef YY_NEED_STRLEN
483 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
484 #endif
485 
486 #ifndef YY_NO_INPUT
487 #ifdef __cplusplus
488 static int yyinput YY_PROTO(( void ));
489 #else
490 static int input YY_PROTO(( void ));
491 #endif
492 #endif
493 
494 #if YY_STACK_USED
495 static int yy_start_stack_ptr = 0;
496 static int yy_start_stack_depth = 0;
497 static int *yy_start_stack = 0;
498 #ifndef YY_NO_PUSH_STATE
499 static void yy_push_state YY_PROTO(( int new_state ));
500 #endif
501 #ifndef YY_NO_POP_STATE
502 static void yy_pop_state YY_PROTO(( void ));
503 #endif
504 #ifndef YY_NO_TOP_STATE
505 static int yy_top_state YY_PROTO(( void ));
506 #endif
507 
508 #else
509 #define YY_NO_PUSH_STATE 1
510 #define YY_NO_POP_STATE 1
511 #define YY_NO_TOP_STATE 1
512 #endif
513 
514 #ifdef YY_MALLOC_DECL
515 YY_MALLOC_DECL
516 #else
517 #if __STDC__
518 #ifndef __cplusplus
519 #include <stdlib.h>
520 #endif
521 #else
522 /* Just try to get by without declaring the routines. This will fail
523  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
524  * or sizeof(void*) != sizeof(int).
525  */
526 #endif
527 #endif
528 
529 /* Amount of stuff to slurp up with each read. */
530 #ifndef YY_READ_BUF_SIZE
531 #define YY_READ_BUF_SIZE 8192
532 #endif
533 
534 /* Copy whatever the last rule matched to the standard output. */
535 
536 #ifndef ECHO
537 /* This used to be an fputs(), but since the string might contain NUL's,
538  * we now use fwrite().
539  */
540 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
541 #endif
542 
543 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
544  * is returned in "result".
545  */
546 #ifndef YY_INPUT
547 #define YY_INPUT(buf,result,max_size) \
548  if ( yy_current_buffer->yy_is_interactive ) \
549  { \
550  int c = '*', n; \
551  for ( n = 0; n < max_size && \
552  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
553  buf[n] = (char) c; \
554  if ( c == '\n' ) \
555  buf[n++] = (char) c; \
556  if ( c == EOF && ferror( yyin ) ) \
557  YY_FATAL_ERROR( "input in flex scanner failed" ); \
558  result = n; \
559  } \
560  else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
561  && ferror( yyin ) ) \
562  YY_FATAL_ERROR( "input in flex scanner failed" );
563 #endif
564 
565 /* No semi-colon after return; correct usage is to write "yyterminate();" -
566  * we don't want an extra ';' after the "return" because that will cause
567  * some compilers to complain about unreachable statements.
568  */
569 #ifndef yyterminate
570 #define yyterminate() return YY_NULL
571 #endif
572 
573 /* Number of entries by which start-condition stack grows. */
574 #ifndef YY_START_STACK_INCR
575 #define YY_START_STACK_INCR 25
576 #endif
577 
578 /* Report a fatal error. */
579 #ifndef YY_FATAL_ERROR
580 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
581 #endif
582 
583 /* Default declaration of generated scanner - a define so the user can
584  * easily add parameters.
585  */
586 #ifndef YY_DECL
587 #define YY_DECL int yylex YY_PROTO(( void ))
588 #endif
589 
590 /* Code executed at the beginning of each rule, after yytext and yyleng
591  * have been set up.
592  */
593 #ifndef YY_USER_ACTION
594 #define YY_USER_ACTION
595 #endif
596 
597 /* Code executed at the end of each rule. */
598 #ifndef YY_BREAK
599 #define YY_BREAK break;
600 #endif
601 
602 #define YY_RULE_SETUP \
603  YY_USER_ACTION
604 
606  {
607  register yy_state_type yy_current_state;
608  register char *yy_cp, *yy_bp;
609  register int yy_act;
610 
611 #line 75 "newick.lpp"
612 
613 
614 #line 615 "lex.newick.cpp"
615 
616  if ( yy_init )
617  {
618  yy_init = 0;
619 
620 #ifdef YY_USER_INIT
621  YY_USER_INIT;
622 #endif
623 
624  if ( ! yy_start )
625  yy_start = 1; /* first start state */
626 
627  if ( ! yyin )
628  yyin = stdin;
629 
630  if ( ! yyout )
631  yyout = stdout;
632 
633  if ( ! yy_current_buffer )
634  yy_current_buffer =
635  yy_create_buffer( yyin, YY_BUF_SIZE );
636 
638  }
639 
640  while ( 1 ) /* loops until end-of-file is reached */
641  {
642  yy_cp = yy_c_buf_p;
643 
644  /* Support of yytext. */
645  *yy_cp = yy_hold_char;
646 
647  /* yy_bp points to the position in yy_ch_buf of the start of
648  * the current run.
649  */
650  yy_bp = yy_cp;
651 
652  yy_current_state = yy_start;
653 yy_match:
654  do
655  {
656  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
657  if ( yy_accept[yy_current_state] )
658  {
659  yy_last_accepting_state = yy_current_state;
660  yy_last_accepting_cpos = yy_cp;
661  }
662  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
663  {
664  yy_current_state = (int) yy_def[yy_current_state];
665  if ( yy_current_state >= 26 )
666  yy_c = yy_meta[(unsigned int) yy_c];
667  }
668  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
669  ++yy_cp;
670  }
671  while ( yy_base[yy_current_state] != 30 );
672 
673 yy_find_action:
674  yy_act = yy_accept[yy_current_state];
675  if ( yy_act == 0 )
676  { /* have to back up */
677  yy_cp = yy_last_accepting_cpos;
678  yy_current_state = yy_last_accepting_state;
679  yy_act = yy_accept[yy_current_state];
680  }
681 
683 
684 
685 do_action: /* This label is used only to access EOF actions. */
686 
687 
688  switch ( yy_act )
689  { /* beginning of action switch */
690  case 0: /* must back up */
691  /* undo the effects of YY_DO_BEFORE_ACTION */
692  *yy_cp = yy_hold_char;
693  yy_cp = yy_last_accepting_cpos;
694  yy_current_state = yy_last_accepting_state;
695  goto yy_find_action;
696 
697 case 1:
699 #line 77 "newick.lpp"
700 {
701  newicklval.dblval = atof(yytext);
702  BEGIN 0;
703  return NUM;
704 }
705  YY_BREAK
706 case 2:
708 #line 83 "newick.lpp"
709 ;
710  YY_BREAK
711 case 3:
713 #line 85 "newick.lpp"
714 {
715  g_Buffer = yytext;
716  for (unsigned int i = 0; i < g_Buffer.size(); ++i) {
717  if (g_Buffer[i] == '_') {
718  g_Buffer[i] = ' ';
719  }
720  }
721  newicklval.strval = const_cast<char *>(g_Buffer.c_str());
722 // printf( "Token: %s\n", yytext );
723  return LABEL;
724 }
725  YY_BREAK
726 case 4:
728 #line 97 "newick.lpp"
729 {
730  g_Buffer.erase();
731  g_Buffer.reserve(strlen(yytext));
732  for (unsigned int i = 1; i < strlen(yytext) - 1; ++ i) {
733  g_Buffer += yytext[i];
734  if (yytext[i] == '\'') {
735  ++i;
736  }
737  }
738  newicklval.strval = const_cast<char *>(g_Buffer.c_str());
739 // printf( "Token: %s\n", yytext );
740  return LABEL;
741 }
742  YY_BREAK
743 case 5:
745 #line 111 "newick.lpp"
746 {
748  return ':';
749 }
750  YY_BREAK
751 case 6:
753 #line 116 "newick.lpp"
754 return yytext[0];
755  YY_BREAK
756 case 7:
758 #line 118 "newick.lpp"
759 ECHO;
760  YY_BREAK
761 #line 762 "lex.newick.cpp"
762 case YY_STATE_EOF(INITIAL):
764  yyterminate();
765 
766  case YY_END_OF_BUFFER:
767  {
768  /* Amount of text matched not including the EOB char. */
769  int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
770 
771  /* Undo the effects of YY_DO_BEFORE_ACTION. */
772  *yy_cp = yy_hold_char;
774 
775  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
776  {
777  /* We're scanning a new file or input source. It's
778  * possible that this happened because the user
779  * just pointed yyin at a new source and called
780  * yylex(). If so, then we have to assure
781  * consistency between yy_current_buffer and our
782  * globals. Here is the right place to do so, because
783  * this is the first action (other than possibly a
784  * back-up) that will match for the new input source.
785  */
786  yy_n_chars = yy_current_buffer->yy_n_chars;
787  yy_current_buffer->yy_input_file = yyin;
788  yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
789  }
790 
791  /* Note that here we test for yy_c_buf_p "<=" to the position
792  * of the first EOB in the buffer, since yy_c_buf_p will
793  * already have been incremented past the NUL character
794  * (since all states make transitions on EOB to the
795  * end-of-buffer state). Contrast this with the test
796  * in input().
797  */
798  if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
799  { /* This was really a NUL. */
800  yy_state_type yy_next_state;
801 
802  yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
803 
804  yy_current_state = yy_get_previous_state();
805 
806  /* Okay, we're now positioned to make the NUL
807  * transition. We couldn't have
808  * yy_get_previous_state() go ahead and do it
809  * for us because it doesn't know how to deal
810  * with the possibility of jamming (and we don't
811  * want to build jamming into it because then it
812  * will run more slowly).
813  */
814 
815  yy_next_state = yy_try_NUL_trans( yy_current_state );
816 
817  yy_bp = yytext_ptr + YY_MORE_ADJ;
818 
819  if ( yy_next_state )
820  {
821  /* Consume the NUL. */
822  yy_cp = ++yy_c_buf_p;
823  yy_current_state = yy_next_state;
824  goto yy_match;
825  }
826 
827  else
828  {
829  yy_cp = yy_c_buf_p;
830  goto yy_find_action;
831  }
832  }
833 
834  else switch ( yy_get_next_buffer() )
835  {
836  case EOB_ACT_END_OF_FILE:
837  {
838  yy_did_buffer_switch_on_eof = 0;
839 
840  if ( yywrap() )
841  {
842  /* Note: because we've taken care in
843  * yy_get_next_buffer() to have set up
844  * yytext, we can now set up
845  * yy_c_buf_p so that if some total
846  * hoser (like flex itself) wants to
847  * call the scanner after we return the
848  * YY_NULL, it'll still work - another
849  * YY_NULL will get returned.
850  */
851  yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
852 
853  yy_act = YY_STATE_EOF(YY_START);
854  goto do_action;
855  }
856 
857  else
858  {
859  if ( ! yy_did_buffer_switch_on_eof )
860  YY_NEW_FILE;
861  }
862  break;
863  }
864 
866  yy_c_buf_p =
867  yytext_ptr + yy_amount_of_matched_text;
868 
869  yy_current_state = yy_get_previous_state();
870 
871  yy_cp = yy_c_buf_p;
872  yy_bp = yytext_ptr + YY_MORE_ADJ;
873  goto yy_match;
874 
875  case EOB_ACT_LAST_MATCH:
876  yy_c_buf_p =
877  &yy_current_buffer->yy_ch_buf[yy_n_chars];
878 
879  yy_current_state = yy_get_previous_state();
880 
881  yy_cp = yy_c_buf_p;
882  yy_bp = yytext_ptr + YY_MORE_ADJ;
883  goto yy_find_action;
884  }
885  break;
886  }
887 
888  default:
890  "fatal flex scanner internal error--no action found" );
891  } /* end of action switch */
892  } /* end of scanning one token */
893  } /* end of yylex */
894 
895 
896 /* yy_get_next_buffer - try to read in a new buffer
897  *
898  * Returns a code representing an action:
899  * EOB_ACT_LAST_MATCH -
900  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
901  * EOB_ACT_END_OF_FILE - end of file
902  */
903 
904 static int yy_get_next_buffer()
905  {
906  register char *dest = yy_current_buffer->yy_ch_buf;
907  register char *source = yytext_ptr;
908  register int number_to_move, i;
909  int ret_val;
910 
911  if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
913  "fatal flex scanner internal error--end of buffer missed" );
914 
915  if ( yy_current_buffer->yy_fill_buffer == 0 )
916  { /* Don't try to fill the buffer, so this is an EOF. */
917  if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
918  {
919  /* We matched a single character, the EOB, so
920  * treat this as a final EOF.
921  */
922  return EOB_ACT_END_OF_FILE;
923  }
924 
925  else
926  {
927  /* We matched some text prior to the EOB, first
928  * process it.
929  */
930  return EOB_ACT_LAST_MATCH;
931  }
932  }
933 
934  /* Try to read more data. */
935 
936  /* First move last chars to start of buffer. */
937  number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
938 
939  for ( i = 0; i < number_to_move; ++i )
940  *(dest++) = *(source++);
941 
942  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
943  /* don't do the read, it's not guaranteed to return an EOF,
944  * just force an EOF
945  */
946  yy_current_buffer->yy_n_chars = yy_n_chars = 0;
947 
948  else
949  {
950  int num_to_read =
951  yy_current_buffer->yy_buf_size - number_to_move - 1;
952 
953  while ( num_to_read <= 0 )
954  { /* Not enough room in the buffer - grow it. */
955 #ifdef YY_USES_REJECT
957 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
958 #else
959 
960  /* just a shorter name for the current buffer */
961  YY_BUFFER_STATE b = yy_current_buffer;
962 
963  int yy_c_buf_p_offset =
964  (int) (yy_c_buf_p - b->yy_ch_buf);
965 
966  if ( b->yy_is_our_buffer )
967  {
968  int new_size = b->yy_buf_size * 2;
969 
970  if ( new_size <= 0 )
971  b->yy_buf_size += b->yy_buf_size / 8;
972  else
973  b->yy_buf_size *= 2;
974 
975  b->yy_ch_buf = (char *)
976  /* Include room in for 2 EOB chars. */
977  yy_flex_realloc( (void *) b->yy_ch_buf,
978  b->yy_buf_size + 2 );
979  }
980  else
981  /* Can't grow it, we don't own it. */
982  b->yy_ch_buf = 0;
983 
984  if ( ! b->yy_ch_buf )
986  "fatal error - scanner input buffer overflow" );
987 
988  yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
989 
990  num_to_read = yy_current_buffer->yy_buf_size -
991  number_to_move - 1;
992 #endif
993  }
994 
995  if ( num_to_read > YY_READ_BUF_SIZE )
996  num_to_read = YY_READ_BUF_SIZE;
997 
998  /* Read in more data. */
999  YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1000  yy_n_chars, num_to_read );
1001 
1002  yy_current_buffer->yy_n_chars = yy_n_chars;
1003  }
1004 
1005  if ( yy_n_chars == 0 )
1006  {
1007  if ( number_to_move == YY_MORE_ADJ )
1008  {
1009  ret_val = EOB_ACT_END_OF_FILE;
1010  yyrestart( yyin );
1011  }
1012 
1013  else
1014  {
1015  ret_val = EOB_ACT_LAST_MATCH;
1016  yy_current_buffer->yy_buffer_status =
1018  }
1019  }
1020 
1021  else
1022  ret_val = EOB_ACT_CONTINUE_SCAN;
1023 
1024  yy_n_chars += number_to_move;
1025  yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1026  yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1027 
1028  yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1029 
1030  return ret_val;
1031  }
1032 
1033 
1034 /* yy_get_previous_state - get the state just before the EOB char was reached */
1035 
1036 static yy_state_type yy_get_previous_state()
1037  {
1038  register yy_state_type yy_current_state;
1039  register char *yy_cp;
1040 
1041  yy_current_state = yy_start;
1042 
1043  for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1044  {
1045  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1046  if ( yy_accept[yy_current_state] )
1047  {
1048  yy_last_accepting_state = yy_current_state;
1049  yy_last_accepting_cpos = yy_cp;
1050  }
1051  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1052  {
1053  yy_current_state = (int) yy_def[yy_current_state];
1054  if ( yy_current_state >= 26 )
1055  yy_c = yy_meta[(unsigned int) yy_c];
1056  }
1057  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1058  }
1059 
1060  return yy_current_state;
1061  }
1062 
1063 
1064 /* yy_try_NUL_trans - try to make a transition on the NUL character
1065  *
1066  * synopsis
1067  * next_state = yy_try_NUL_trans( current_state );
1068  */
1069 
1070 #ifdef YY_USE_PROTOS
1071 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1072 #else
1073 static yy_state_type yy_try_NUL_trans( yy_current_state )
1074 yy_state_type yy_current_state;
1075 #endif
1076  {
1077  register int yy_is_jam;
1078  register char *yy_cp = yy_c_buf_p;
1079 
1080  register YY_CHAR yy_c = 1;
1081  if ( yy_accept[yy_current_state] )
1082  {
1083  yy_last_accepting_state = yy_current_state;
1084  yy_last_accepting_cpos = yy_cp;
1085  }
1086  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1087  {
1088  yy_current_state = (int) yy_def[yy_current_state];
1089  if ( yy_current_state >= 26 )
1090  yy_c = yy_meta[(unsigned int) yy_c];
1091  }
1092  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1093  yy_is_jam = (yy_current_state == 25);
1094 
1095  return yy_is_jam ? 0 : yy_current_state;
1096  }
1097 
1098 
1099 #ifndef YY_NO_UNPUT
1100 #ifdef YY_USE_PROTOS
1101 static void yyunput( int c, register char *yy_bp )
1102 #else
1103 static void yyunput( c, yy_bp )
1104 int c;
1105 register char *yy_bp;
1106 #endif
1107  {
1108  register char *yy_cp = yy_c_buf_p;
1109 
1110  /* undo effects of setting up yytext */
1111  *yy_cp = yy_hold_char;
1112 
1113  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1114  { /* need to shift things up to make room */
1115  /* +2 for EOB chars. */
1116  register int number_to_move = yy_n_chars + 2;
1117  register char *dest = &yy_current_buffer->yy_ch_buf[
1118  yy_current_buffer->yy_buf_size + 2];
1119  register char *source =
1120  &yy_current_buffer->yy_ch_buf[number_to_move];
1121 
1122  while ( source > yy_current_buffer->yy_ch_buf )
1123  *--dest = *--source;
1124 
1125  yy_cp += (int) (dest - source);
1126  yy_bp += (int) (dest - source);
1127  yy_current_buffer->yy_n_chars =
1128  yy_n_chars = yy_current_buffer->yy_buf_size;
1129 
1130  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1131  YY_FATAL_ERROR( "flex scanner push-back overflow" );
1132  }
1133 
1134  *--yy_cp = (char) c;
1135 
1136 
1137  yytext_ptr = yy_bp;
1138  yy_hold_char = *yy_cp;
1139  yy_c_buf_p = yy_cp;
1140  }
1141 #endif /* ifndef YY_NO_UNPUT */
1142 
1143 
1144 #ifdef __cplusplus
1145 static int yyinput()
1146 #else
1147 static int input()
1148 #endif
1149  {
1150  int c;
1151 
1152  *yy_c_buf_p = yy_hold_char;
1153 
1154  if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1155  {
1156  /* yy_c_buf_p now points to the character we want to return.
1157  * If this occurs *before* the EOB characters, then it's a
1158  * valid NUL; if not, then we've hit the end of the buffer.
1159  */
1160  if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1161  /* This was really a NUL. */
1162  *yy_c_buf_p = '\0';
1163 
1164  else
1165  { /* need more input */
1166  int offset = yy_c_buf_p - yytext_ptr;
1167  ++yy_c_buf_p;
1168 
1169  switch ( yy_get_next_buffer() )
1170  {
1171  case EOB_ACT_LAST_MATCH:
1172  /* This happens because yy_g_n_b()
1173  * sees that we've accumulated a
1174  * token and flags that we need to
1175  * try matching the token before
1176  * proceeding. But for input(),
1177  * there's no matching to consider.
1178  * So convert the EOB_ACT_LAST_MATCH
1179  * to EOB_ACT_END_OF_FILE.
1180  */
1181 
1182  /* Reset buffer status. */
1183  yyrestart( yyin );
1184 
1185  /* fall through */
1186 
1187  case EOB_ACT_END_OF_FILE:
1188  {
1189  if ( yywrap() )
1190  return EOF;
1191 
1192  if ( ! yy_did_buffer_switch_on_eof )
1193  YY_NEW_FILE;
1194 #ifdef __cplusplus
1195  return yyinput();
1196 #else
1197  return input();
1198 #endif
1199  }
1200 
1201  case EOB_ACT_CONTINUE_SCAN:
1202  yy_c_buf_p = yytext_ptr + offset;
1203  break;
1204  }
1205  }
1206  }
1207 
1208  c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1209  *yy_c_buf_p = '\0'; /* preserve yytext */
1210  yy_hold_char = *++yy_c_buf_p;
1211 
1212 
1213  return c;
1214  }
1215 
1216 
1217 #ifdef YY_USE_PROTOS
1218 void yyrestart( FILE *input_file )
1219 #else
1220 void yyrestart( input_file )
1221 FILE *input_file;
1222 #endif
1223  {
1224  if ( ! yy_current_buffer )
1225  yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1226 
1227  yy_init_buffer( yy_current_buffer, input_file );
1229  }
1230 
1231 
1232 #ifdef YY_USE_PROTOS
1233 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1234 #else
1235 void yy_switch_to_buffer( new_buffer )
1236 YY_BUFFER_STATE new_buffer;
1237 #endif
1238  {
1239  if ( yy_current_buffer == new_buffer )
1240  return;
1241 
1242  if ( yy_current_buffer )
1243  {
1244  /* Flush out information for old buffer. */
1245  *yy_c_buf_p = yy_hold_char;
1246  yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1247  yy_current_buffer->yy_n_chars = yy_n_chars;
1248  }
1249 
1250  yy_current_buffer = new_buffer;
1252 
1253  /* We don't actually know whether we did this switch during
1254  * EOF (yywrap()) processing, but the only time this flag
1255  * is looked at is after yywrap() is called, so it's safe
1256  * to go ahead and always set it.
1257  */
1258  yy_did_buffer_switch_on_eof = 1;
1259  }
1260 
1261 
1262 #ifdef YY_USE_PROTOS
1263 void yy_load_buffer_state( void )
1264 #else
1266 #endif
1267  {
1268  yy_n_chars = yy_current_buffer->yy_n_chars;
1269  yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1270  yyin = yy_current_buffer->yy_input_file;
1271  yy_hold_char = *yy_c_buf_p;
1272  }
1273 
1274 
1275 #ifdef YY_USE_PROTOS
1276 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1277 #else
1278 YY_BUFFER_STATE yy_create_buffer( file, size )
1279 FILE *file;
1280 int size;
1281 #endif
1282  {
1283  YY_BUFFER_STATE b;
1284 
1285  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1286  if ( ! b )
1287  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1288 
1290 
1291  /* yy_ch_buf has to be 2 characters longer than the size given because
1292  * we need to put in 2 end-of-buffer characters.
1293  */
1294  b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1295  if ( ! b->yy_ch_buf )
1296  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1297 
1299 
1300  yy_init_buffer( b, file );
1301 
1302  return b;
1303  }
1304 
1305 
1306 #ifdef YY_USE_PROTOS
1307 void yy_delete_buffer( YY_BUFFER_STATE b )
1308 #else
1309 void yy_delete_buffer( b )
1310 YY_BUFFER_STATE b;
1311 #endif
1312  {
1313  if ( ! b )
1314  return;
1315 
1316  if ( b == yy_current_buffer )
1317  yy_current_buffer = (YY_BUFFER_STATE) 0;
1318 
1319  if ( b->yy_is_our_buffer )
1320  yy_flex_free( (void *) b->yy_ch_buf );
1321 
1322  yy_flex_free( (void *) b );
1323  }
1324 
1325 
1326 #ifndef YY_ALWAYS_INTERACTIVE
1327 #ifndef YY_NEVER_INTERACTIVE
1328 extern int isatty YY_PROTO(( int ));
1329 #endif
1330 #endif
1331 
1332 #ifdef YY_USE_PROTOS
1333 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1334 #else
1335 void yy_init_buffer( b, file )
1336 YY_BUFFER_STATE b;
1337 FILE *file;
1338 #endif
1339 
1340 
1341  {
1342  yy_flush_buffer( b );
1343 
1344  b->yy_input_file = file;
1345  b->yy_fill_buffer = 1;
1346 
1347 #if YY_ALWAYS_INTERACTIVE
1348  b->yy_is_interactive = 1;
1349 #else
1350 #if YY_NEVER_INTERACTIVE
1351  b->yy_is_interactive = 0;
1352 #else
1353  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1354 #endif
1355 #endif
1356  }
1357 
1358 
1359 #ifdef YY_USE_PROTOS
1360 void yy_flush_buffer( YY_BUFFER_STATE b )
1361 #else
1362 void yy_flush_buffer( b )
1363 YY_BUFFER_STATE b;
1364 #endif
1365 
1366  {
1367  if ( ! b )
1368  return;
1369 
1370  b->yy_n_chars = 0;
1371 
1372  /* We always need two end-of-buffer characters. The first causes
1373  * a transition to the end-of-buffer state. The second causes
1374  * a jam in that state.
1375  */
1376  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1377  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1378 
1379  b->yy_buf_pos = &b->yy_ch_buf[0];
1380 
1381  b->yy_at_bol = 1;
1382  b->yy_buffer_status = YY_BUFFER_NEW;
1383 
1384  if ( b == yy_current_buffer )
1386  }
1387 
1388 
1389 #ifndef YY_NO_SCAN_BUFFER
1390 #ifdef YY_USE_PROTOS
1391 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1392 #else
1393 YY_BUFFER_STATE yy_scan_buffer( base, size )
1394 char *base;
1395 yy_size_t size;
1396 #endif
1397  {
1398  YY_BUFFER_STATE b;
1399 
1400  if ( size < 2 ||
1401  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1402  base[size-1] != YY_END_OF_BUFFER_CHAR )
1403  /* They forgot to leave room for the EOB's. */
1404  return 0;
1405 
1406  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1407  if ( ! b )
1408  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1409 
1410  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1411  b->yy_buf_pos = b->yy_ch_buf = base;
1412  b->yy_is_our_buffer = 0;
1413  b->yy_input_file = 0;
1414  b->yy_n_chars = b->yy_buf_size;
1415  b->yy_is_interactive = 0;
1416  b->yy_at_bol = 1;
1417  b->yy_fill_buffer = 0;
1419 
1420  yy_switch_to_buffer( b );
1421 
1422  return b;
1423  }
1424 #endif
1425 
1426 
1427 #ifndef YY_NO_SCAN_STRING
1428 #ifdef YY_USE_PROTOS
1429 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1430 #else
1431 YY_BUFFER_STATE yy_scan_string( yy_str )
1432 yyconst char *yy_str;
1433 #endif
1434  {
1435  int len;
1436  for ( len = 0; yy_str[len]; ++len )
1437  ;
1438 
1439  return yy_scan_bytes( yy_str, len );
1440  }
1441 #endif
1442 
1443 
1444 #ifndef YY_NO_SCAN_BYTES
1445 #ifdef YY_USE_PROTOS
1446 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1447 #else
1448 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1449 yyconst char *bytes;
1450 int len;
1451 #endif
1452  {
1453  YY_BUFFER_STATE b;
1454  char *buf;
1455  yy_size_t n;
1456  int i;
1457 
1458  /* Get memory for full buffer, including space for trailing EOB's. */
1459  n = len + 2;
1460  buf = (char *) yy_flex_alloc( n );
1461  if ( ! buf )
1462  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1463 
1464  for ( i = 0; i < len; ++i )
1465  buf[i] = bytes[i];
1466 
1467  buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1468 
1469  b = yy_scan_buffer( buf, n );
1470  if ( ! b )
1471  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1472 
1473  /* It's okay to grow etc. this buffer, and we should throw it
1474  * away when we're done.
1475  */
1476  b->yy_is_our_buffer = 1;
1477 
1478  return b;
1479  }
1480 #endif
1481 
1482 
1483 #ifndef YY_NO_PUSH_STATE
1484 #ifdef YY_USE_PROTOS
1485 static void yy_push_state( int new_state )
1486 #else
1487 static void yy_push_state( new_state )
1488 int new_state;
1489 #endif
1490  {
1491  if ( yy_start_stack_ptr >= yy_start_stack_depth )
1492  {
1493  yy_size_t new_size;
1494 
1495  yy_start_stack_depth += YY_START_STACK_INCR;
1496  new_size = yy_start_stack_depth * sizeof( int );
1497 
1498  if ( ! yy_start_stack )
1499  yy_start_stack = (int *) yy_flex_alloc( new_size );
1500 
1501  else
1502  yy_start_stack = (int *) yy_flex_realloc(
1503  (void *) yy_start_stack, new_size );
1504 
1505  if ( ! yy_start_stack )
1507  "out of memory expanding start-condition stack" );
1508  }
1509 
1510  yy_start_stack[yy_start_stack_ptr++] = YY_START;
1511 
1512  BEGIN(new_state);
1513  }
1514 #endif
1515 
1516 
1517 #ifndef YY_NO_POP_STATE
1518 static void yy_pop_state()
1519  {
1520  if ( --yy_start_stack_ptr < 0 )
1521  YY_FATAL_ERROR( "start-condition stack underflow" );
1522 
1523  BEGIN(yy_start_stack[yy_start_stack_ptr]);
1524  }
1525 #endif
1526 
1527 
1528 #ifndef YY_NO_TOP_STATE
1529 static int yy_top_state()
1530  {
1531  return yy_start_stack[yy_start_stack_ptr - 1];
1532  }
1533 #endif
1534 
1535 #ifndef YY_EXIT_FAILURE
1536 #define YY_EXIT_FAILURE 2
1537 #endif
1538 
1539 #ifdef YY_USE_PROTOS
1540 static void yy_fatal_error( yyconst char msg[] )
1541 #else
1542 static void yy_fatal_error( msg )
1543 char msg[];
1544 #endif
1545  {
1546  (void) fprintf( stderr, "%s\n", msg );
1547  exit( YY_EXIT_FAILURE );
1548  }
1549 
1550 
1551 
1552 /* Redefine yyless() so it works in section 3 code. */
1553 
1554 #undef yyless
1555 #define yyless(n) \
1556  do \
1557  { \
1558  /* Undo effects of setting up yytext. */ \
1559  yytext[yyleng] = yy_hold_char; \
1560  yy_c_buf_p = yytext + n; \
1561  yy_hold_char = *yy_c_buf_p; \
1562  *yy_c_buf_p = '\0'; \
1563  yyleng = n; \
1564  } \
1565  while ( 0 )
1566 
1567 
1568 /* Internal utility routines. */
1569 
1570 #ifndef yytext_ptr
1571 #ifdef YY_USE_PROTOS
1572 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1573 #else
1574 static void yy_flex_strncpy( s1, s2, n )
1575 char *s1;
1576 yyconst char *s2;
1577 int n;
1578 #endif
1579  {
1580  register int i;
1581  for ( i = 0; i < n; ++i )
1582  s1[i] = s2[i];
1583  }
1584 #endif
1585 
1586 #ifdef YY_NEED_STRLEN
1587 #ifdef YY_USE_PROTOS
1588 static int yy_flex_strlen( yyconst char *s )
1589 #else
1590 static int yy_flex_strlen( s )
1591 yyconst char *s;
1592 #endif
1593  {
1594  register int n;
1595  for ( n = 0; s[n]; ++n )
1596  ;
1597 
1598  return n;
1599  }
1600 #endif
1601 
1602 
1603 #ifdef YY_USE_PROTOS
1604 static void *yy_flex_alloc( yy_size_t size )
1605 #else
1606 static void *yy_flex_alloc( size )
1607 yy_size_t size;
1608 #endif
1609  {
1610  return (void *) malloc( size );
1611  }
1612 
1613 #ifdef YY_USE_PROTOS
1614 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1615 #else
1616 static void *yy_flex_realloc( ptr, size )
1617 void *ptr;
1618 yy_size_t size;
1619 #endif
1620  {
1621  /* The cast to (char *) in the following accommodates both
1622  * implementations that use char* generic pointers, and those
1623  * that use void* generic pointers. It works with the latter
1624  * because both ANSI C and C++ allow castless assignment from
1625  * any pointer type to void*, and deal with argument conversions
1626  * as though doing an assignment.
1627  */
1628  return (void *) realloc( (char *) ptr, size );
1629  }
1630 
1631 #ifdef YY_USE_PROTOS
1632 static void yy_flex_free( void *ptr )
1633 #else
1634 static void yy_flex_free( ptr )
1635 void *ptr;
1636 #endif
1637  {
1638  free( ptr );
1639  }
1640 
1641 #if YY_MAIN
1642 int main()
1643  {
1644  yylex();
1645  return 0;
1646  }
1647 #endif
1648 #line 118 "newick.lpp"
1649 
1650 
1651 // Reset the lexer: discard input buffer and enter initial state
1653 {
1654  newickrestart(0); // flush flex buffer
1655  BEGIN 0;
1656 }
static void * yy_flex_realloc()
#define YY_NEW_FILE
Definition: lex.newick.cpp:110
#define yyleng
Definition: lex.newick.cpp:13
#define LABEL
Definition: newick.tab.cpp:71
#define YY_PROTO(proto)
Definition: lex.newick.cpp:80
char * buf
b yy_ch_buf
static void yy_fatal_error()
#define yytext
Definition: lex.newick.cpp:17
static int yy_init
Definition: lex.newick.cpp:238
static char yy_hold_char
Definition: lex.newick.cpp:229
#define yy_load_buffer_state
Definition: lex.newick.cpp:10
#define yy_flush_buffer
Definition: lex.newick.cpp:9
#define yy_scan_bytes
Definition: lex.newick.cpp:6
#define yy_create_buffer
Definition: lex.newick.cpp:2
YYSTYPE newicklval
Definition: newick.tab.cpp:768
#define YY_START
Definition: lex.newick.cpp:103
#define YY_BUF_SIZE
Definition: lex.newick.cpp:115
#define YY_RULE_SETUP
Definition: lex.newick.cpp:602
static yy_state_type yy_get_previous_state()
const TSeqPos offset(200)
#define yywrap()
Definition: lex.newick.cpp:283
static void * yy_flex_alloc()
#define YY_SC_TO_UI(c)
Definition: lex.newick.cpp:91
#define EOB_ACT_LAST_MATCH
Definition: lex.newick.cpp:124
char * strval
Definition: newick.tab.cpp:150
yy_size_t yy_buf_size
Definition: lex.newick.cpp:172
static void yy_flex_free()
unsigned int yy_size_t
Definition: lex.newick.cpp:159
#define YY_RESTORE_YY_MORE_OFFSET
Definition: lex.newick.cpp:391
static char * yy_last_accepting_cpos
Definition: lex.newick.cpp:383
int i
#define YY_DO_BEFORE_ACTION
Definition: lex.newick.cpp:299
#define YY_STATE_EOF(state)
Definition: lex.newick.cpp:107
FILE * file
#define yylex
Definition: lex.newick.cpp:14
#define yytext_ptr
Definition: lex.newick.cpp:289
static string g_Buffer
Definition: lex.newick.cpp:445
register int yy_is_jam
static int yy_n_chars
Definition: lex.newick.cpp:231
#define YY_INPUT(buf, result, max_size)
Definition: lex.newick.cpp:449
static yy_state_type yy_last_accepting_state
Definition: lex.newick.cpp:382
#define yy_init_buffer
Definition: lex.newick.cpp:8
int main(int argc, char **argv)
#define EOB_ACT_CONTINUE_SCAN
Definition: lex.newick.cpp:122
#define NUM
Definition: newick.tab.cpp:72
#define YY_START_STACK_INCR
Definition: lex.newick.cpp:575
#define yyout
Definition: lex.newick.cpp:15
int yy_state_type
Definition: lex.newick.cpp:287
const CharType(& source)[N]
Definition: pointer.h:1107
#define YY_BREAK
Definition: lex.newick.cpp:599
struct yy_buffer_state * YY_BUFFER_STATE
Definition: lex.newick.cpp:117
static yy_state_type yy_try_NUL_trans()
unsigned char YY_CHAR
Definition: lex.newick.cpp:285
int size
#define EOB_ACT_END_OF_FILE
Definition: lex.newick.cpp:123
#define YY_BUFFER_NEW
Definition: lex.newick.cpp:204
static int yy_start
Definition: lex.newick.cpp:239
#define INITIAL
Definition: lex.newick.cpp:394
USING_SCOPE(ncbi)
static int yy_get_next_buffer()
Definition: lex.newick.cpp:904
#define YY_BUFFER_NORMAL
Definition: lex.newick.cpp:205
#define yy_scan_string
Definition: lex.newick.cpp:5
double dblval
Definition: newick.tab.cpp:151
register char * yy_cp
Magic spell ;-) needed for some weird compilers... very empiric.
void newickrestart()
#define yyconst
Definition: lex.newick.cpp:73
void newick_flex_reset(void)
#define yy_scan_buffer
Definition: lex.newick.cpp:4
#define YY_MORE_ADJ
Definition: lex.newick.cpp:390
#define YY_FATAL_ERROR(msg)
Definition: lex.newick.cpp:580
#define yyrestart
Definition: lex.newick.cpp:16
#define YY_READ_BUF_SIZE
Definition: lex.newick.cpp:531
#define yy_switch_to_buffer
Definition: lex.newick.cpp:11
int len
static char * yy_c_buf_p
Definition: lex.newick.cpp:237
#define ECHO
Definition: lex.newick.cpp:540
CNcbiIstream * g_NewickIstr
Definition: newick.tab.cpp:126
#define yyterminate()
Definition: lex.newick.cpp:570
yy_size_t n
FILE * yy_input_file
Definition: lex.newick.cpp:164
#define YY_EXIT_FAILURE
#define YY_END_OF_BUFFER
Definition: lex.newick.cpp:307
exit(2)
#define BEGIN
Definition: lex.newick.cpp:97
#define YY_BUFFER_EOF_PENDING
Definition: lex.newick.cpp:216
#define YY_DECL
Definition: lex.newick.cpp:587
yy_current_state
IO_PREFIX::istream CNcbiIstream
Portable alias for istream.
Definition: ncbistre.hpp:147
static YY_BUFFER_STATE yy_current_buffer
Definition: lex.newick.cpp:219
static int yy_did_buffer_switch_on_eof
Definition: lex.newick.cpp:244
unsigned int
Definition: types.hpp:1153
#define YY_END_OF_BUFFER_CHAR
Definition: lex.newick.cpp:112
#define yy_delete_buffer
Definition: lex.newick.cpp:3
#define yyin
Definition: lex.newick.cpp:12
static int input()
#define EXPECT_NUM
Definition: lex.newick.cpp:458
Modified on Mon Jan 23 17:07:18 2017 by modify_doxy.py rev. 506947