开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
lex.newick.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：40k
源码类别：

生物技术

开发平台：

C/C++

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