"Fossies" - the Fresh Open Source Software Archive

Member "bc-1.06.95/bc/scan.c" (5 Sep 2006, 67961 Bytes) of package /linux/misc/old/bc-1.06.95.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "scan.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 1.06.95_vs_1.07.

    1 
    2 #line 3 "scan.c"
    3 
    4 #define  YY_INT_ALIGNED short int
    5 
    6 /* A lexical scanner generated by flex */
    7 
    8 #define FLEX_SCANNER
    9 #define YY_FLEX_MAJOR_VERSION 2
   10 #define YY_FLEX_MINOR_VERSION 5
   11 #define YY_FLEX_SUBMINOR_VERSION 33
   12 #if YY_FLEX_SUBMINOR_VERSION > 0
   13 #define FLEX_BETA
   14 #endif
   15 
   16 /* First, we deal with  platform-specific or compiler-specific issues. */
   17 
   18 /* begin standard C headers. */
   19 #include <stdio.h>
   20 #include <string.h>
   21 #include <errno.h>
   22 #include <stdlib.h>
   23 
   24 /* end standard C headers. */
   25 
   26 /* flex integer type definitions */
   27 
   28 #ifndef FLEXINT_H
   29 #define FLEXINT_H
   30 
   31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
   32 
   33 #if __STDC_VERSION__ >= 199901L
   34 
   35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
   36  * if you want the limit (max/min) macros for int types. 
   37  */
   38 #ifndef __STDC_LIMIT_MACROS
   39 #define __STDC_LIMIT_MACROS 1
   40 #endif
   41 
   42 #include <inttypes.h>
   43 typedef int8_t flex_int8_t;
   44 typedef uint8_t flex_uint8_t;
   45 typedef int16_t flex_int16_t;
   46 typedef uint16_t flex_uint16_t;
   47 typedef int32_t flex_int32_t;
   48 typedef uint32_t flex_uint32_t;
   49 #else
   50 typedef signed char flex_int8_t;
   51 typedef short int flex_int16_t;
   52 typedef int flex_int32_t;
   53 typedef unsigned char flex_uint8_t; 
   54 typedef unsigned short int flex_uint16_t;
   55 typedef unsigned int flex_uint32_t;
   56 #endif /* ! C99 */
   57 
   58 /* Limits of integral types. */
   59 #ifndef INT8_MIN
   60 #define INT8_MIN               (-128)
   61 #endif
   62 #ifndef INT16_MIN
   63 #define INT16_MIN              (-32767-1)
   64 #endif
   65 #ifndef INT32_MIN
   66 #define INT32_MIN              (-2147483647-1)
   67 #endif
   68 #ifndef INT8_MAX
   69 #define INT8_MAX               (127)
   70 #endif
   71 #ifndef INT16_MAX
   72 #define INT16_MAX              (32767)
   73 #endif
   74 #ifndef INT32_MAX
   75 #define INT32_MAX              (2147483647)
   76 #endif
   77 #ifndef UINT8_MAX
   78 #define UINT8_MAX              (255U)
   79 #endif
   80 #ifndef UINT16_MAX
   81 #define UINT16_MAX             (65535U)
   82 #endif
   83 #ifndef UINT32_MAX
   84 #define UINT32_MAX             (4294967295U)
   85 #endif
   86 
   87 #endif /* ! FLEXINT_H */
   88 
   89 #ifdef __cplusplus
   90 
   91 /* The "const" storage-class-modifier is valid. */
   92 #define YY_USE_CONST
   93 
   94 #else   /* ! __cplusplus */
   95 
   96 #if __STDC__
   97 
   98 #define YY_USE_CONST
   99 
  100 #endif  /* __STDC__ */
  101 #endif  /* ! __cplusplus */
  102 
  103 #ifdef YY_USE_CONST
  104 #define yyconst const
  105 #else
  106 #define yyconst
  107 #endif
  108 
  109 /* Returned upon end-of-file. */
  110 #define YY_NULL 0
  111 
  112 /* Promotes a possibly negative, possibly signed char to an unsigned
  113  * integer for use as an array index.  If the signed char is negative,
  114  * we want to instead treat it as an 8-bit unsigned char, hence the
  115  * double cast.
  116  */
  117 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  118 
  119 /* Enter a start condition.  This macro really ought to take a parameter,
  120  * but we do it the disgusting crufty way forced on us by the ()-less
  121  * definition of BEGIN.
  122  */
  123 #define BEGIN (yy_start) = 1 + 2 *
  124 
  125 /* Translate the current start state into a value that can be later handed
  126  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  127  * compatibility.
  128  */
  129 #define YY_START (((yy_start) - 1) / 2)
  130 #define YYSTATE YY_START
  131 
  132 /* Action number for EOF rule of a given start state. */
  133 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  134 
  135 /* Special action meaning "start processing a new file". */
  136 #define YY_NEW_FILE yyrestart(yyin  )
  137 
  138 #define YY_END_OF_BUFFER_CHAR 0
  139 
  140 /* Size of default input buffer. */
  141 #ifndef YY_BUF_SIZE
  142 #define YY_BUF_SIZE 16384
  143 #endif
  144 
  145 /* The state buf must be large enough to hold one state per character in the main buffer.
  146  */
  147 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
  148 
  149 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
  150 #define YY_TYPEDEF_YY_BUFFER_STATE
  151 typedef struct yy_buffer_state *YY_BUFFER_STATE;
  152 #endif
  153 
  154 extern int yyleng;
  155 
  156 extern FILE *yyin, *yyout;
  157 
  158 #define EOB_ACT_CONTINUE_SCAN 0
  159 #define EOB_ACT_END_OF_FILE 1
  160 #define EOB_ACT_LAST_MATCH 2
  161 
  162     #define YY_LESS_LINENO(n)
  163     
  164 /* Return all but the first "n" matched characters back to the input stream. */
  165 #define yyless(n) \
  166     do \
  167         { \
  168         /* Undo effects of setting up yytext. */ \
  169         int yyless_macro_arg = (n); \
  170         YY_LESS_LINENO(yyless_macro_arg);\
  171         *yy_cp = (yy_hold_char); \
  172         YY_RESTORE_YY_MORE_OFFSET \
  173         (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
  174         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  175         } \
  176     while ( 0 )
  177 
  178 #define unput(c) yyunput( c, (yytext_ptr)  )
  179 
  180 /* The following is because we cannot portably get our hands on size_t
  181  * (without autoconf's help, which isn't available because we want
  182  * flex-generated scanners to compile on their own).
  183  */
  184 
  185 #ifndef YY_TYPEDEF_YY_SIZE_T
  186 #define YY_TYPEDEF_YY_SIZE_T
  187 typedef unsigned int yy_size_t;
  188 #endif
  189 
  190 #ifndef YY_STRUCT_YY_BUFFER_STATE
  191 #define YY_STRUCT_YY_BUFFER_STATE
  192 struct yy_buffer_state
  193     {
  194     FILE *yy_input_file;
  195 
  196     char *yy_ch_buf;        /* input buffer */
  197     char *yy_buf_pos;       /* current position in input buffer */
  198 
  199     /* Size of input buffer in bytes, not including room for EOB
  200      * characters.
  201      */
  202     yy_size_t yy_buf_size;
  203 
  204     /* Number of characters read into yy_ch_buf, not including EOB
  205      * characters.
  206      */
  207     int yy_n_chars;
  208 
  209     /* Whether we "own" the buffer - i.e., we know we created it,
  210      * and can realloc() it to grow it, and should free() it to
  211      * delete it.
  212      */
  213     int yy_is_our_buffer;
  214 
  215     /* Whether this is an "interactive" input source; if so, and
  216      * if we're using stdio for input, then we want to use getc()
  217      * instead of fread(), to make sure we stop fetching input after
  218      * each newline.
  219      */
  220     int yy_is_interactive;
  221 
  222     /* Whether we're considered to be at the beginning of a line.
  223      * If so, '^' rules will be active on the next match, otherwise
  224      * not.
  225      */
  226     int yy_at_bol;
  227 
  228     int yy_bs_lineno; /**< The line count. */
  229     int yy_bs_column; /**< The column count. */
  230     
  231     /* Whether to try to fill the input buffer when we reach the
  232      * end of it.
  233      */
  234     int yy_fill_buffer;
  235 
  236     int yy_buffer_status;
  237 
  238 #define YY_BUFFER_NEW 0
  239 #define YY_BUFFER_NORMAL 1
  240     /* When an EOF's been seen but there's still some text to process
  241      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  242      * shouldn't try reading from the input source any more.  We might
  243      * still have a bunch of tokens to match, though, because of
  244      * possible backing-up.
  245      *
  246      * When we actually see the EOF, we change the status to "new"
  247      * (via yyrestart()), so that the user can continue scanning by
  248      * just pointing yyin at a new input file.
  249      */
  250 #define YY_BUFFER_EOF_PENDING 2
  251 
  252     };
  253 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
  254 
  255 /* Stack of input buffers. */
  256 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
  257 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
  258 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
  259 
  260 /* We provide macros for accessing buffer states in case in the
  261  * future we want to put the buffer states in a more general
  262  * "scanner state".
  263  *
  264  * Returns the top of the stack, or NULL.
  265  */
  266 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
  267                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
  268                           : NULL)
  269 
  270 /* Same as previous macro, but useful when we know that the buffer stack is not
  271  * NULL or when we need an lvalue. For internal use only.
  272  */
  273 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
  274 
  275 /* yy_hold_char holds the character lost when yytext is formed. */
  276 static char yy_hold_char;
  277 static int yy_n_chars;      /* number of characters read into yy_ch_buf */
  278 int yyleng;
  279 
  280 /* Points to current character in buffer. */
  281 static char *yy_c_buf_p = (char *) 0;
  282 static int yy_init = 0;     /* whether we need to initialize */
  283 static int yy_start = 0;    /* start state number */
  284 
  285 /* Flag which is used to allow yywrap()'s to do buffer switches
  286  * instead of setting up a fresh yyin.  A bit of a hack ...
  287  */
  288 static int yy_did_buffer_switch_on_eof;
  289 
  290 void yyrestart (FILE *input_file  );
  291 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
  292 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
  293 void yy_delete_buffer (YY_BUFFER_STATE b  );
  294 void yy_flush_buffer (YY_BUFFER_STATE b  );
  295 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
  296 void yypop_buffer_state (void );
  297 
  298 static void yyensure_buffer_stack (void );
  299 static void yy_load_buffer_state (void );
  300 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
  301 
  302 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
  303 
  304 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
  305 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
  306 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
  307 
  308 void *yyalloc (yy_size_t  );
  309 void *yyrealloc (void *,yy_size_t  );
  310 void yyfree (void *  );
  311 
  312 #define yy_new_buffer yy_create_buffer
  313 
  314 #define yy_set_interactive(is_interactive) \
  315     { \
  316     if ( ! YY_CURRENT_BUFFER ){ \
  317         yyensure_buffer_stack (); \
  318         YY_CURRENT_BUFFER_LVALUE =    \
  319             yy_create_buffer(yyin,YY_BUF_SIZE ); \
  320     } \
  321     YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
  322     }
  323 
  324 #define yy_set_bol(at_bol) \
  325     { \
  326     if ( ! YY_CURRENT_BUFFER ){\
  327         yyensure_buffer_stack (); \
  328         YY_CURRENT_BUFFER_LVALUE =    \
  329             yy_create_buffer(yyin,YY_BUF_SIZE ); \
  330     } \
  331     YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
  332     }
  333 
  334 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
  335 
  336 /* Begin user sect3 */
  337 
  338 typedef unsigned char YY_CHAR;
  339 
  340 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  341 
  342 typedef int yy_state_type;
  343 
  344 extern int yylineno;
  345 
  346 int yylineno = 1;
  347 
  348 extern char *yytext;
  349 #define yytext_ptr yytext
  350 
  351 static yy_state_type yy_get_previous_state (void );
  352 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
  353 static int yy_get_next_buffer (void );
  354 static void yy_fatal_error (yyconst char msg[]  );
  355 
  356 /* Done after the current pattern has been matched and before the
  357  * corresponding action - sets up yytext.
  358  */
  359 #define YY_DO_BEFORE_ACTION \
  360     (yytext_ptr) = yy_bp; \
  361     yyleng = (size_t) (yy_cp - yy_bp); \
  362     (yy_hold_char) = *yy_cp; \
  363     *yy_cp = '\0'; \
  364     (yy_c_buf_p) = yy_cp;
  365 
  366 #define YY_NUM_RULES 46
  367 #define YY_END_OF_BUFFER 47
  368 /* This struct is not used in this scanner,
  369    but its presence is necessary. */
  370 struct yy_trans_info
  371     {
  372     flex_int32_t yy_verify;
  373     flex_int32_t yy_nxt;
  374     };
  375 static yyconst flex_int16_t yy_accept[316] =
  376     {   0,
  377         0,    0,    2,    2,   47,   45,   40,   38,   32,   45,
  378         1,   33,   33,   29,   33,   29,   29,   28,   33,   44,
  379        36,   34,   36,   45,   29,   42,   42,   42,   42,   42,
  380        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
  381        42,   42,   45,    2,    2,    3,    2,    2,    1,    2,
  382         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  383         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  384         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  385         2,   40,   36,    0,   43,   34,   30,   37,   44,    0,
  386        41,   44,   44,    0,   35,   39,   42,   42,   42,   42,
  387 
  388        42,   42,   42,   42,   42,   42,   10,   42,   42,   42,
  389        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
  390        31,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  391         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  392         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  393         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  394         2,   44,    0,    0,   44,    0,   42,   42,   42,   42,
  395        42,    9,   42,   42,   42,   42,   42,   42,   42,   42,
  396        42,   42,   42,   42,   42,   42,   42,   42,   42,    2,
  397         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  398 
  399         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  400         2,    2,    2,    2,    2,    2,   16,   42,   42,   42,
  401        17,   20,   42,   42,   21,   42,   42,   42,   42,    6,
  402        42,   18,   42,   42,   12,   22,   42,   42,    2,    2,
  403         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  404         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
  405         5,   42,   42,   42,   14,   42,   42,   15,   26,   42,
  406        42,   13,   42,   11,    2,    2,    2,    2,    2,    2,
  407         2,    2,    2,    2,    2,    2,    2,    2,   42,    4,
  408        42,    7,   27,   19,    8,   42,    2,    2,    2,    2,
  409 
  410         2,    2,    2,    2,   42,   23,   42,    2,    2,    2,
  411        25,   24,    2,    2,    0
  412     } ;
  413 
  414 static yyconst flex_int32_t yy_ec[256] =
  415     {   0,
  416         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  417         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  418         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  419         1,    2,    4,    5,    6,    1,    7,    8,    1,    9,
  420        10,   11,   12,   13,   14,   15,   16,   17,   17,   17,
  421        17,   17,   17,   17,   17,   17,   17,    1,   18,   19,
  422        20,   21,    1,    1,   22,   22,   22,   22,   22,   22,
  423         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  424         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  425        23,   24,   25,   26,   27,    1,   28,   29,   30,   31,
  426 
  427        32,   33,   34,   35,   36,   37,   38,   39,   40,   41,
  428        42,   43,   44,   45,   46,   47,   48,   49,   50,   37,
  429        51,   37,   52,   53,   54,    1,    1,    1,    1,    1,
  430         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  431         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  432         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  433         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  434         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  435         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  436         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  437 
  438         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  439         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  440         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  441         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  442         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  443         1,    1,    1,    1,    1
  444     } ;
  445 
  446 static yyconst flex_int32_t yy_meta[55] =
  447     {   0,
  448         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
  449         1,    1,    1,    1,    1,    1,    3,    1,    1,    1,
  450         1,    1,    1,    1,    1,    1,    3,    3,    3,    3,
  451         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  452         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  453         3,    1,    1,    1
  454     } ;
  455 
  456 static yyconst flex_int16_t yy_base[320] =
  457     {   0,
  458         0,    0,   54,    0,  553,  554,  550,  554,  531,  545,
  459       554,  529,  540,  554,  527,   97,   96,   96,  101,  107,
  460       526,  116,  525,  541,  523,  494,  496,  498,  507,  499,
  461       495,    0,   83,  104,  107,  507,  490,  486,  106,   96,
  462       491,  113,  479,    0,  529,  554,  510,  141,    0,  509,
  463       520,    0,  507,  133,  135,  130,  139,  141,  506,  150,
  464       505,  521,  503,  160,  123,  125,  137,  112,  130,  474,
  465       184,  185,  187,  188,  134,  473,  193,  183,  132,  194,
  466       467,  517,  554,  513,  554,  554,  554,  554,  221,  514,
  467       554,  222,  232,  513,  554,  554,    0,  468,  482,  472,
  468 
  469       479,  465,  465,  470,  462,  479,    0,  460,  464,  464,
  470       475,  466,  465,  459,  206,  471,  453,  461,  451,  459,
  471       554,    0,  492,    0,  178,    0,    0,    0,    0,  233,
  472       490,    0,  241,  244,  489,    0,  443,   67,  192,  189,
  473       219,  138,  203,  221,  180,  234,  442,  224,  223,  233,
  474       246,  239,  240,  236,  250,  251,  235,  253,  245,  255,
  475         0,  278,  486,  287,  288,  485,  445,  458,  438,  448,
  476       451,    0,  435,  434,  434,  432,  444,  441,  430,  434,
  477       427,  442,  441,  423,  431,  422,  437,  422,  427,  291,
  478       462,  297,  461,  244,  268,  259,  281,  286,  415,  275,
  479 
  480       277,  280,  283,  293,  284,  287,  295,  290,  308,  309,
  481       414,  303,  297,  315,  302,  310,    0,  423,  424,  418,
  482         0,    0,  416,  425,    0,  409,  408,  422,  406,    0,
  483       410,    0,  406,  418,    0,    0,  421,  416,  399,  314,
  484       312,  313,  398,  397,  311,  323,  396,  317,  319,  336,
  485       322,  395,  330,  394,  328,  342,  393,  392,  347,  345,
  486         0,  398,  406,  392,    0,  401,  389,    0,    0,  394,
  487       392,    0,  391,    0,  383,  338,  348,  337,  382,  346,
  488       341,  381,  380,  343,  351,  379,  356,  378,  373,    0,
  489       364,    0,    0,    0,    0,  367,  365,  364,  350,  363,
  490 
  491       362,  361,  359,  355,  374,    0,  337,  368,  237,  357,
  492         0,    0,  168,  127,  554,  416,  122,  419,  422
  493     } ;
  494 
  495 static yyconst flex_int16_t yy_def[320] =
  496     {   0,
  497       315,    1,  315,    3,  315,  315,  315,  315,  315,  316,
  498       315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
  499       315,  315,  315,  315,  315,  317,  317,  317,  317,  317,
  500       317,  317,  317,  317,  317,  317,  317,  317,  317,  317,
  501       317,  317,  315,  318,  318,  315,  318,  319,  318,  318,
  502       318,  318,  318,  318,  318,  318,  318,  318,  318,  318,
  503       318,  318,  318,  318,   64,   64,   64,   64,   64,   64,
  504        64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
  505       318,  315,  315,  316,  315,  315,  315,  315,  315,  315,
  506       315,  315,  315,  315,  315,  315,  317,  317,  317,  317,
  507 
  508       317,  317,  317,  317,  317,  317,  317,  317,  317,  317,
  509       317,  317,  317,  317,  317,  317,  317,  317,  317,  317,
  510       315,  318,  318,  318,  319,  318,  318,  318,  318,  318,
  511       318,  318,  318,  318,  318,  318,   64,   64,   64,   64,
  512        64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
  513        64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
  514       318,  315,  315,  315,  315,  315,  317,  317,  317,  317,
  515       317,  317,  317,  317,  317,  317,  317,  317,  317,  317,
  516       317,  317,  317,  317,  317,  317,  317,  317,  317,  318,
  517       318,  318,  318,   64,   64,   64,   64,   64,   64,   64,
  518 
  519        64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
  520        64,   64,   64,   64,   64,   64,  317,  317,  317,  317,
  521       317,  317,  317,  317,  317,  317,  317,  317,  317,  317,
  522       317,  317,  317,  317,  317,  317,  317,  317,   64,   64,
  523        64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
  524        64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
  525       317,  317,  317,  317,  317,  317,  317,  317,  317,  317,
  526       317,  317,  317,  317,   64,   64,   64,   64,   64,   64,
  527        64,   64,   64,   64,   64,   64,   64,   64,  317,  317,
  528       317,  317,  317,  317,  317,  317,   64,   64,   64,   64,
  529 
  530        64,   64,   64,   64,  317,  317,  317,   64,   64,   64,
  531       317,  317,   64,   64,    0,  315,  315,  315,  315
  532     } ;
  533 
  534 static yyconst flex_int16_t yy_nxt[609] =
  535     {   0,
  536         6,    7,    8,    9,   10,   11,   12,   13,   14,   14,
  537        15,   16,   14,   17,   18,   19,   20,   14,   21,   22,
  538        23,   20,   14,   24,   14,   25,    6,   26,   27,   28,
  539        29,   30,   31,   32,   33,   34,   32,   32,   35,   32,
  540        32,   36,   37,   38,   39,   40,   32,   32,   41,   42,
  541        32,   14,   43,   14,   44,   45,   46,   47,   48,   49,
  542        50,   51,   52,   52,   53,   54,   52,   55,   56,   57,
  543        58,   52,   59,   60,   61,   58,   52,   62,   52,   63,
  544        44,   64,   65,   66,   67,   68,   69,   70,   71,   72,
  545        70,   70,   73,   70,   70,   74,   75,   76,   77,   78,
  546 
  547        70,   70,   79,   80,   70,   52,   81,   52,   88,   88,
  548       104,   91,   89,  194,  137,   86,   86,   89,  105,   90,
  549        86,   92,   95,   93,   97,  116,   95,   95,   93,   95,
  550        94,   95,  106,  114,  108,   83,  107,  115,  109,  117,
  551       119,   95,  110,   84,  129,  126,  130,  120,  129,  132,
  552       142,  130,  127,  131,  127,  133,  136,  134,  127,  137,
  553       136,  136,  134,  136,  135,  136,  140,  139,  141,  124,
  554       137,  143,  137,  158,  137,  136,  137,  137,  152,  137,
  555        84,  137,  126,  198,  137,  137,  137,  137,  137,  137,
  556       137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
  557 
  558       137,  137,  137,  137,  137,  137,  137,  138,  137,  137,
  559       137,  144,  156,  146,  148,  137,  151,  147,  149,  145,
  560       154,  159,  150,  195,  155,  201,  157,  137,  160,  196,
  561       137,  137,  137,  183,  137,  137,  137,  162,  165,  137,
  562       137,  137,  162,  165,  163,  166,   92,  199,   93,  190,
  563       137,  197,  184,   93,  190,   94,  191,  192,  133,  200,
  564       134,  202,  192,  204,  193,  134,  137,  135,  137,  203,
  565       137,  137,  205,  206,  207,  208,  209,  210,  212,  213,
  566       137,  137,  137,  137,  137,  239,  137,  137,  214,  215,
  567       216,  137,  137,  137,  162,  240,  211,  137,  137,  162,
  568 
  569       137,  163,  137,   89,  165,  241,  137,  190,   89,  165,
  570        90,  166,  190,  192,  191,  137,  242,  243,  192,  249,
  571       193,  244,  137,  245,  137,  246,  248,  137,  137,  247,
  572       137,  137,  250,  137,  137,  251,  252,  137,  253,  254,
  573       137,  256,  137,  257,  137,  258,  259,  276,  260,  137,
  574       137,  275,  278,  277,  279,  137,  137,  137,  137,  137,
  575       137,  137,  137,  280,  137,  281,  137,  282,  283,  137,
  576       137,  284,  285,  286,  287,  137,  288,  137,  297,  298,
  577       300,  299,  302,  137,  137,  137,  301,  312,  137,  137,
  578       137,  303,  137,  137,  137,  137,  304,  137,  137,  313,
  579 
  580       309,  310,  137,  137,  137,  311,  137,  314,  137,  137,
  581       137,  137,  308,  307,  306,  137,   84,   84,   84,  122,
  582       305,  122,  125,  125,  125,  137,  137,  137,  137,  137,
  583       137,  296,  295,  294,  293,  292,  291,  290,  289,  137,
  584       137,  137,  137,  137,  137,  137,  137,  274,  273,  272,
  585       271,  270,  269,  268,  267,  266,  265,  264,  263,  262,
  586       261,  255,  137,  165,  162,  238,  237,  236,  235,  234,
  587       233,  232,  231,  230,  229,  228,  227,  226,  225,  224,
  588       223,  222,  221,  220,  219,  218,  217,  165,  162,  137,
  589       137,   93,  164,  123,  189,  188,  187,  186,  185,  182,
  590 
  591       181,  180,  179,  178,  177,  176,  175,  174,  173,  172,
  592       171,  170,  169,  168,  167,   93,  164,   85,   82,  161,
  593       153,  137,  127,   96,  124,  124,  127,  128,  127,  124,
  594       123,  121,  118,  113,  112,  111,  103,  102,  101,  100,
  595        99,   98,   86,   96,   83,   83,   86,   87,   86,   85,
  596        83,   82,  315,    5,  315,  315,  315,  315,  315,  315,
  597       315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
  598       315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
  599       315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
  600       315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
  601 
  602       315,  315,  315,  315,  315,  315,  315,  315
  603     } ;
  604 
  605 static yyconst flex_int16_t yy_chk[609] =
  606     {   0,
  607         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  608         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  609         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  610         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  611         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  612         1,    1,    1,    1,    3,    3,    3,    3,    3,    3,
  613         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  614         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  615         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  616         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  617 
  618         3,    3,    3,    3,    3,    3,    3,    3,   16,   17,
  619        33,   19,   18,  138,  138,   17,   16,   18,   33,   18,
  620        19,   20,   22,   20,  317,   40,   22,   22,   20,   22,
  621        20,   22,   34,   39,   35,   22,   34,   39,   35,   40,
  622        42,   22,   35,   48,   54,   48,   56,   42,   55,   57,
  623        68,   56,   54,   56,   55,   58,   60,   58,   57,   68,
  624        60,   60,   58,   60,   58,   60,   66,   65,   67,   60,
  625        65,   69,   66,   79,  314,   60,   64,   69,   75,   79,
  626       125,   75,  125,  142,   67,  142,   64,   64,   64,   64,
  627        64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
  628 
  629        64,   64,   64,   64,   64,   64,   64,   64,   64,   64,
  630        64,   71,   78,   72,   73,  313,   74,   72,   73,   71,
  631        77,   80,   73,  139,   77,  145,   78,  145,   80,  140,
  632        78,   71,   72,  115,   73,   74,  140,   89,   92,  139,
  633        77,   80,   89,   92,   89,   92,   93,  143,   93,  130,
  634       143,  141,  115,   93,  130,   93,  130,  133,  134,  144,
  635       134,  146,  133,  149,  133,  134,  141,  134,  144,  148,
  636       149,  148,  150,  151,  152,  153,  154,  155,  156,  157,
  637       150,  146,  157,  154,  309,  194,  152,  153,  158,  159,
  638       160,  194,  159,  151,  162,  195,  155,  155,  156,  162,
  639 
  640       158,  162,  160,  164,  165,  196,  196,  190,  164,  165,
  641       164,  165,  190,  192,  190,  195,  197,  198,  192,  205,
  642       192,  200,  200,  201,  201,  202,  204,  202,  197,  203,
  643       203,  205,  206,  198,  206,  207,  208,  208,  209,  210,
  644       204,  212,  207,  213,  213,  214,  215,  241,  216,  215,
  645       212,  240,  245,  242,  246,  209,  210,  216,  245,  241,
  646       242,  240,  214,  248,  248,  249,  249,  250,  251,  251,
  647       246,  253,  255,  256,  259,  255,  260,  253,  276,  277,
  648       280,  278,  284,  250,  278,  276,  281,  307,  281,  256,
  649       284,  285,  260,  280,  259,  277,  287,  299,  285,  308,
  650 
  651       299,  304,  304,  287,  310,  305,  303,  310,  302,  301,
  652       300,  298,  297,  296,  291,  308,  316,  316,  316,  318,
  653       289,  318,  319,  319,  319,  288,  286,  283,  282,  279,
  654       275,  273,  271,  270,  267,  266,  264,  263,  262,  258,
  655       257,  254,  252,  247,  244,  243,  239,  238,  237,  234,
  656       233,  231,  229,  228,  227,  226,  224,  223,  220,  219,
  657       218,  211,  199,  193,  191,  189,  188,  187,  186,  185,
  658       184,  183,  182,  181,  180,  179,  178,  177,  176,  175,
  659       174,  173,  171,  170,  169,  168,  167,  166,  163,  147,
  660       137,  135,  131,  123,  120,  119,  118,  117,  116,  114,
  661 
  662       113,  112,  111,  110,  109,  108,  106,  105,  104,  103,
  663       102,  101,  100,   99,   98,   94,   90,   84,   82,   81,
  664        76,   70,   63,   62,   61,   59,   53,   51,   50,   47,
  665        45,   43,   41,   38,   37,   36,   31,   30,   29,   28,
  666        27,   26,   25,   24,   23,   21,   15,   13,   12,   10,
  667         9,    7,    5,  315,  315,  315,  315,  315,  315,  315,
  668       315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
  669       315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
  670       315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
  671       315,  315,  315,  315,  315,  315,  315,  315,  315,  315,
  672 
  673       315,  315,  315,  315,  315,  315,  315,  315
  674     } ;
  675 
  676 static yy_state_type yy_last_accepting_state;
  677 static char *yy_last_accepting_cpos;
  678 
  679 extern int yy_flex_debug;
  680 int yy_flex_debug = 0;
  681 
  682 /* The intent behind this definition is that it'll catch
  683  * any uses of REJECT which flex missed.
  684  */
  685 #define REJECT reject_used_but_not_detected
  686 #define yymore() yymore_used_but_not_detected
  687 #define YY_MORE_ADJ 0
  688 #define YY_RESTORE_YY_MORE_OFFSET
  689 char *yytext;
  690 #line 1 "scan.l"
  691 /*  This file is part of GNU bc.
  692 
  693     Copyright (C) 1991-1994, 1997, 2006 Free Software Foundation, Inc.
  694 
  695     This program is free software; you can redistribute it and/or modify
  696     it under the terms of the GNU General Public License as published by
  697     the Free Software Foundation; either version 2 of the License , or
  698     (at your option) any later version.
  699 
  700     This program is distributed in the hope that it will be useful,
  701     but WITHOUT ANY WARRANTY; without even the implied warranty of
  702     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  703     GNU General Public License for more details.
  704 
  705     You should have received a copy of the GNU General Public License
  706     along with this program; see the file COPYING.  If not, write to:
  707       The Free Software Foundation, Inc.
  708       Foundation, Inc.  51 Franklin Street, Fifth Floor,
  709       Boston, MA 02110-1301  USA
  710 
  711     You may contact the author by:
  712        e-mail:  philnelson@acm.org
  713       us-mail:  Philip A. Nelson
  714                 Computer Science Department, 9062
  715                 Western Washington University
  716                 Bellingham, WA 98226-9062
  717        
  718 *************************************************************************/
  719 /* scan.l: the (f)lex description file for the scanner. */
  720 #line 33 "scan.l"
  721 
  722 #include "bcdefs.h"
  723 #include "bc.h"
  724 #include "global.h"
  725 #include "proto.h"
  726 #include <errno.h>
  727 
  728 /* Using flex, we can ask for a smaller input buffer.  With lex, this
  729    does nothing! */
  730 
  731 #ifdef SMALL_BUF
  732 #undef YY_READ_BUF_SIZE
  733 #define YY_READ_BUF_SIZE 512
  734 #endif
  735 
  736 /* Force . as last for now. */
  737 #define DOT_IS_LAST
  738 
  739 /* We want to define our own yywrap. */
  740 #undef yywrap
  741 _PROTOTYPE(int yywrap, (void));
  742 
  743 #if defined(LIBEDIT)
  744 /* Support for the BSD libedit with history for
  745    nicer input on the interactive part of input. */
  746 
  747 #include <histedit.h>
  748 
  749 /* Have input call the following function. */
  750 #undef  YY_INPUT
  751 #define YY_INPUT(buf,result,max_size) \
  752         bcel_input((char *)buf, &result, max_size)
  753 
  754 /* Variables to help interface editline with bc. */
  755 static const char *bcel_line = (char *)NULL;
  756 static int   bcel_len = 0;
  757 
  758 
  759 /* Required to get rid of that ugly ? default prompt! */
  760 char *
  761 null_prompt (EditLine *el)
  762 {
  763   return "";
  764 }
  765 
  766 
  767 /* bcel_input puts upto MAX characters into BUF with the number put in
  768    BUF placed in *RESULT.  If the yy input file is the same as
  769    stdin, use editline.  Otherwise, just read it.
  770 */
  771 
  772 static void
  773 bcel_input (buf, result, max)
  774     char *buf;
  775     int  *result;
  776     int   max;
  777 {
  778   if (!edit || yyin != stdin)
  779     {
  780       while ( (*result = read( fileno(yyin), buf, max )) < 0 )
  781         if (errno != EINTR)
  782       {
  783         yyerror( "read() in flex scanner failed" );
  784         exit (1);
  785       }
  786       return;
  787     }
  788 
  789   /* Do we need a new string? */
  790   if (bcel_len == 0)
  791     {
  792       bcel_line = el_gets(edit, &bcel_len);
  793       if (bcel_line == NULL) {
  794     /* end of file */
  795     *result = 0;
  796     bcel_len = 0;
  797     return;
  798       }
  799       if (bcel_len != 0)
  800     history (hist, &histev, H_ENTER, bcel_line); 
  801       fflush (stdout);
  802     }
  803 
  804   if (bcel_len <= max)
  805     {
  806       strncpy (buf, bcel_line, bcel_len);
  807       *result = bcel_len;
  808       bcel_len = 0;
  809     }
  810   else
  811     {
  812       strncpy (buf, bcel_line, max);
  813       *result = max;
  814       bcel_line += max;
  815       bcel_len -= max;
  816     }
  817 }
  818 #endif
  819 
  820 #ifdef READLINE
  821 /* Support for the readline and history libraries.  This allows
  822    nicer input on the interactive part of input. */
  823 
  824 /* Have input call the following function. */
  825 #undef  YY_INPUT
  826 #define YY_INPUT(buf,result,max_size) \
  827         rl_input((char *)buf, &result, max_size)
  828 
  829 /* Variables to help interface readline with bc. */
  830 static char *rl_line = (char *)NULL;
  831 static char *rl_start = (char *)NULL;
  832 static int   rl_len = 0;
  833 
  834 /* Definitions for readline access. */
  835 extern FILE *rl_instream;
  836 
  837 /* rl_input puts upto MAX characters into BUF with the number put in
  838    BUF placed in *RESULT.  If the yy input file is the same as
  839    rl_instream (stdin), use readline.  Otherwise, just read it.
  840 */
  841 
  842 static void
  843 rl_input (buf, result, max)
  844     char *buf;
  845     int  *result;
  846     int   max;
  847 {
  848   if (yyin != rl_instream)
  849     {
  850       while ( (*result = read( fileno(yyin), buf, max )) < 0 )
  851         if (errno != EINTR)
  852       {
  853         yyerror( "read() in flex scanner failed" );
  854         exit (1);
  855       }
  856       return;
  857     }
  858 
  859   /* Do we need a new string? */
  860   if (rl_len == 0)
  861     {
  862       if (rl_start)
  863     free(rl_start);
  864       rl_start = readline ("");
  865       if (rl_start == NULL) {
  866     /* end of file */
  867     *result = 0;
  868     rl_len = 0;
  869     return;
  870       }
  871       rl_line = rl_start;
  872       rl_len = strlen (rl_line)+1;
  873       if (rl_len != 1)
  874     add_history (rl_line); 
  875       rl_line[rl_len-1] = '\n';
  876       fflush (stdout);
  877     }
  878 
  879   if (rl_len <= max)
  880     {
  881       strncpy (buf, rl_line, rl_len);
  882       *result = rl_len;
  883       rl_len = 0;
  884     }
  885   else
  886     {
  887       strncpy (buf, rl_line, max);
  888       *result = max;
  889       rl_line += max;
  890       rl_len -= max;
  891     }
  892 }
  893 #endif
  894 
  895 #if !defined(READLINE) && !defined(LIBEDIT)
  896 
  897 /* MINIX returns from read with < 0 if SIGINT is  encountered.
  898    In flex, we can redefine YY_INPUT to the following.  In lex, this
  899    does nothing! */
  900 #undef  YY_INPUT
  901 #define YY_INPUT(buf,result,max_size) \
  902     while ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
  903         if (errno != EINTR) \
  904         YY_FATAL_ERROR( "read() in flex scanner failed" );
  905 #endif
  906 
  907 
  908 #line 909 "scan.c"
  909 
  910 #define INITIAL 0
  911 #define slcomment 1
  912 
  913 #ifndef YY_NO_UNISTD_H
  914 /* Special case for "unistd.h", since it is non-ANSI. We include it way
  915  * down here because we want the user's section 1 to have been scanned first.
  916  * The user has a chance to override it with an option.
  917  */
  918 #include <unistd.h>
  919 #endif
  920 
  921 #ifndef YY_EXTRA_TYPE
  922 #define YY_EXTRA_TYPE void *
  923 #endif
  924 
  925 static int yy_init_globals (void );
  926 
  927 /* Macros after this point can all be overridden by user definitions in
  928  * section 1.
  929  */
  930 
  931 #ifndef YY_SKIP_YYWRAP
  932 #ifdef __cplusplus
  933 extern "C" int yywrap (void );
  934 #else
  935 extern int yywrap (void );
  936 #endif
  937 #endif
  938 
  939     static void yyunput (int c,char *buf_ptr  );
  940     
  941 #ifndef yytext_ptr
  942 static void yy_flex_strncpy (char *,yyconst char *,int );
  943 #endif
  944 
  945 #ifdef YY_NEED_STRLEN
  946 static int yy_flex_strlen (yyconst char * );
  947 #endif
  948 
  949 #ifndef YY_NO_INPUT
  950 
  951 #ifdef __cplusplus
  952 static int yyinput (void );
  953 #else
  954 static int input (void );
  955 #endif
  956 
  957 #endif
  958 
  959 /* Amount of stuff to slurp up with each read. */
  960 #ifndef YY_READ_BUF_SIZE
  961 #define YY_READ_BUF_SIZE 8192
  962 #endif
  963 
  964 /* Copy whatever the last rule matched to the standard output. */
  965 #ifndef ECHO
  966 /* This used to be an fputs(), but since the string might contain NUL's,
  967  * we now use fwrite().
  968  */
  969 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  970 #endif
  971 
  972 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  973  * is returned in "result".
  974  */
  975 #ifndef YY_INPUT
  976 #define YY_INPUT(buf,result,max_size) \
  977     if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
  978         { \
  979         int c = '*'; \
  980         size_t n; \
  981         for ( n = 0; n < max_size && \
  982                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  983             buf[n] = (char) c; \
  984         if ( c == '\n' ) \
  985             buf[n++] = (char) c; \
  986         if ( c == EOF && ferror( yyin ) ) \
  987             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  988         result = n; \
  989         } \
  990     else \
  991         { \
  992         errno=0; \
  993         while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
  994             { \
  995             if( errno != EINTR) \
  996                 { \
  997                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
  998                 break; \
  999                 } \
 1000             errno=0; \
 1001             clearerr(yyin); \
 1002             } \
 1003         }\
 1004 \
 1005 
 1006 #endif
 1007 
 1008 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 1009  * we don't want an extra ';' after the "return" because that will cause
 1010  * some compilers to complain about unreachable statements.
 1011  */
 1012 #ifndef yyterminate
 1013 #define yyterminate() return YY_NULL
 1014 #endif
 1015 
 1016 /* Number of entries by which start-condition stack grows. */
 1017 #ifndef YY_START_STACK_INCR
 1018 #define YY_START_STACK_INCR 25
 1019 #endif
 1020 
 1021 /* Report a fatal error. */
 1022 #ifndef YY_FATAL_ERROR
 1023 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 1024 #endif
 1025 
 1026 /* end tables serialization structures and prototypes */
 1027 
 1028 /* Default declaration of generated scanner - a define so the user can
 1029  * easily add parameters.
 1030  */
 1031 #ifndef YY_DECL
 1032 #define YY_DECL_IS_OURS 1
 1033 
 1034 extern int yylex (void);
 1035 
 1036 #define YY_DECL int yylex (void)
 1037 #endif /* !YY_DECL */
 1038 
 1039 /* Code executed at the beginning of each rule, after yytext and yyleng
 1040  * have been set up.
 1041  */
 1042 #ifndef YY_USER_ACTION
 1043 #define YY_USER_ACTION
 1044 #endif
 1045 
 1046 /* Code executed at the end of each rule. */
 1047 #ifndef YY_BREAK
 1048 #define YY_BREAK break;
 1049 #endif
 1050 
 1051 #define YY_RULE_SETUP \
 1052     YY_USER_ACTION
 1053 
 1054 /** The main scanner function which does all the work.
 1055  */
 1056 YY_DECL
 1057 {
 1058     register yy_state_type yy_current_state;
 1059     register char *yy_cp, *yy_bp;
 1060     register int yy_act;
 1061     
 1062 #line 223 "scan.l"
 1063 
 1064 #line 1065 "scan.c"
 1065 
 1066     if ( !(yy_init) )
 1067         {
 1068         (yy_init) = 1;
 1069 
 1070 #ifdef YY_USER_INIT
 1071         YY_USER_INIT;
 1072 #endif
 1073 
 1074         if ( ! (yy_start) )
 1075             (yy_start) = 1; /* first start state */
 1076 
 1077         if ( ! yyin )
 1078             yyin = stdin;
 1079 
 1080         if ( ! yyout )
 1081             yyout = stdout;
 1082 
 1083         if ( ! YY_CURRENT_BUFFER ) {
 1084             yyensure_buffer_stack ();
 1085             YY_CURRENT_BUFFER_LVALUE =
 1086                 yy_create_buffer(yyin,YY_BUF_SIZE );
 1087         }
 1088 
 1089         yy_load_buffer_state( );
 1090         }
 1091 
 1092     while ( 1 )     /* loops until end-of-file is reached */
 1093         {
 1094         yy_cp = (yy_c_buf_p);
 1095 
 1096         /* Support of yytext. */
 1097         *yy_cp = (yy_hold_char);
 1098 
 1099         /* yy_bp points to the position in yy_ch_buf of the start of
 1100          * the current run.
 1101          */
 1102         yy_bp = yy_cp;
 1103 
 1104         yy_current_state = (yy_start);
 1105 yy_match:
 1106         do
 1107             {
 1108             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 1109             if ( yy_accept[yy_current_state] )
 1110                 {
 1111                 (yy_last_accepting_state) = yy_current_state;
 1112                 (yy_last_accepting_cpos) = yy_cp;
 1113                 }
 1114             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 1115                 {
 1116                 yy_current_state = (int) yy_def[yy_current_state];
 1117                 if ( yy_current_state >= 316 )
 1118                     yy_c = yy_meta[(unsigned int) yy_c];
 1119                 }
 1120             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 1121             ++yy_cp;
 1122             }
 1123         while ( yy_base[yy_current_state] != 554 );
 1124 
 1125 yy_find_action:
 1126         yy_act = yy_accept[yy_current_state];
 1127         if ( yy_act == 0 )
 1128             { /* have to back up */
 1129             yy_cp = (yy_last_accepting_cpos);
 1130             yy_current_state = (yy_last_accepting_state);
 1131             yy_act = yy_accept[yy_current_state];
 1132             }
 1133 
 1134         YY_DO_BEFORE_ACTION;
 1135 
 1136 do_action:  /* This label is used only to access EOF actions. */
 1137 
 1138         switch ( yy_act )
 1139     { /* beginning of action switch */
 1140             case 0: /* must back up */
 1141             /* undo the effects of YY_DO_BEFORE_ACTION */
 1142             *yy_cp = (yy_hold_char);
 1143             yy_cp = (yy_last_accepting_cpos);
 1144             yy_current_state = (yy_last_accepting_state);
 1145             goto yy_find_action;
 1146 
 1147 case 1:
 1148 YY_RULE_SETUP
 1149 #line 224 "scan.l"
 1150 {
 1151           if (!std_only)
 1152             BEGIN(slcomment);
 1153           else
 1154             yyerror ("illegal character: #");
 1155         }
 1156     YY_BREAK
 1157 case 2:
 1158 YY_RULE_SETUP
 1159 #line 230 "scan.l"
 1160 { BEGIN(INITIAL); }
 1161     YY_BREAK
 1162 case 3:
 1163 /* rule 3 can match eol */
 1164 YY_RULE_SETUP
 1165 #line 231 "scan.l"
 1166 { line_no++; BEGIN(INITIAL); return(ENDOFLINE); }
 1167     YY_BREAK
 1168 case 4:
 1169 YY_RULE_SETUP
 1170 #line 232 "scan.l"
 1171 return(Define);
 1172     YY_BREAK
 1173 case 5:
 1174 YY_RULE_SETUP
 1175 #line 233 "scan.l"
 1176 return(Break);
 1177     YY_BREAK
 1178 case 6:
 1179 YY_RULE_SETUP
 1180 #line 234 "scan.l"
 1181 return(Quit);
 1182     YY_BREAK
 1183 case 7:
 1184 YY_RULE_SETUP
 1185 #line 235 "scan.l"
 1186 return(Length);
 1187     YY_BREAK
 1188 case 8:
 1189 YY_RULE_SETUP
 1190 #line 236 "scan.l"
 1191 return(Return);
 1192     YY_BREAK
 1193 case 9:
 1194 YY_RULE_SETUP
 1195 #line 237 "scan.l"
 1196 return(For);
 1197     YY_BREAK
 1198 case 10:
 1199 YY_RULE_SETUP
 1200 #line 238 "scan.l"
 1201 return(If);
 1202     YY_BREAK
 1203 case 11:
 1204 YY_RULE_SETUP
 1205 #line 239 "scan.l"
 1206 return(While);
 1207     YY_BREAK
 1208 case 12:
 1209 YY_RULE_SETUP
 1210 #line 240 "scan.l"
 1211 return(Sqrt);
 1212     YY_BREAK
 1213 case 13:
 1214 YY_RULE_SETUP
 1215 #line 241 "scan.l"
 1216 return(Scale);
 1217     YY_BREAK
 1218 case 14:
 1219 YY_RULE_SETUP
 1220 #line 242 "scan.l"
 1221 return(Ibase);
 1222     YY_BREAK
 1223 case 15:
 1224 YY_RULE_SETUP
 1225 #line 243 "scan.l"
 1226 return(Obase);
 1227     YY_BREAK
 1228 case 16:
 1229 YY_RULE_SETUP
 1230 #line 244 "scan.l"
 1231 return(Auto);
 1232     YY_BREAK
 1233 case 17:
 1234 YY_RULE_SETUP
 1235 #line 245 "scan.l"
 1236 return(Else);
 1237     YY_BREAK
 1238 case 18:
 1239 YY_RULE_SETUP
 1240 #line 246 "scan.l"
 1241 return(Read);
 1242     YY_BREAK
 1243 case 19:
 1244 YY_RULE_SETUP
 1245 #line 247 "scan.l"
 1246 return(Random);
 1247     YY_BREAK
 1248 case 20:
 1249 YY_RULE_SETUP
 1250 #line 248 "scan.l"
 1251 return(Halt);
 1252     YY_BREAK
 1253 case 21:
 1254 YY_RULE_SETUP
 1255 #line 249 "scan.l"
 1256 return(Last);
 1257     YY_BREAK
 1258 case 22:
 1259 YY_RULE_SETUP
 1260 #line 250 "scan.l"
 1261 return(Void); 
 1262     YY_BREAK
 1263 case 23:
 1264 YY_RULE_SETUP
 1265 #line 251 "scan.l"
 1266 {
 1267 #if defined(READLINE) || defined(LIBEDIT)
 1268       return(HistoryVar);
 1269 #else
 1270       yylval.s_value = strcopyof(yytext); return(NAME);
 1271 #endif
 1272     }
 1273     YY_BREAK
 1274 case 24:
 1275 YY_RULE_SETUP
 1276 #line 259 "scan.l"
 1277 return(Warranty);
 1278     YY_BREAK
 1279 case 25:
 1280 YY_RULE_SETUP
 1281 #line 260 "scan.l"
 1282 return(Continue);
 1283     YY_BREAK
 1284 case 26:
 1285 YY_RULE_SETUP
 1286 #line 261 "scan.l"
 1287 return(Print);
 1288     YY_BREAK
 1289 case 27:
 1290 YY_RULE_SETUP
 1291 #line 262 "scan.l"
 1292 return(Limits);
 1293     YY_BREAK
 1294 case 28:
 1295 YY_RULE_SETUP
 1296 #line 263 "scan.l"
 1297 {
 1298 #ifdef DOT_IS_LAST
 1299        return(Last);
 1300 #else
 1301        yyerror ("illegal character: %s",yytext);
 1302 #endif
 1303     }
 1304     YY_BREAK
 1305 case 29:
 1306 YY_RULE_SETUP
 1307 #line 270 "scan.l"
 1308 { yylval.c_value = yytext[0]; 
 1309                           return((int)yytext[0]); }
 1310     YY_BREAK
 1311 case 30:
 1312 YY_RULE_SETUP
 1313 #line 272 "scan.l"
 1314 { return(AND); }
 1315     YY_BREAK
 1316 case 31:
 1317 YY_RULE_SETUP
 1318 #line 273 "scan.l"
 1319 { return(OR); }
 1320     YY_BREAK
 1321 case 32:
 1322 YY_RULE_SETUP
 1323 #line 274 "scan.l"
 1324 { return(NOT); }
 1325     YY_BREAK
 1326 case 33:
 1327 YY_RULE_SETUP
 1328 #line 275 "scan.l"
 1329 { yylval.c_value = yytext[0]; return((int)yytext[0]); }
 1330     YY_BREAK
 1331 case 34:
 1332 YY_RULE_SETUP
 1333 #line 276 "scan.l"
 1334 { yylval.c_value = yytext[0]; return(ASSIGN_OP); }
 1335     YY_BREAK
 1336 case 35:
 1337 YY_RULE_SETUP
 1338 #line 277 "scan.l"
 1339 { 
 1340 #ifdef OLD_EQ_OP
 1341              char warn_save;
 1342              warn_save = warn_not_std;
 1343              warn_not_std = TRUE;
 1344              warn ("Old fashioned =<op>");
 1345              warn_not_std = warn_save;
 1346              yylval.c_value = yytext[1];
 1347 #else
 1348              yylval.c_value = '=';
 1349              yyless (1);
 1350 #endif
 1351              return(ASSIGN_OP);
 1352                }
 1353     YY_BREAK
 1354 case 36:
 1355 YY_RULE_SETUP
 1356 #line 291 "scan.l"
 1357 { yylval.s_value = strcopyof(yytext); return(REL_OP); }
 1358     YY_BREAK
 1359 case 37:
 1360 YY_RULE_SETUP
 1361 #line 292 "scan.l"
 1362 { yylval.c_value = yytext[0]; return(INCR_DECR); }
 1363     YY_BREAK
 1364 case 38:
 1365 /* rule 38 can match eol */
 1366 YY_RULE_SETUP
 1367 #line 293 "scan.l"
 1368 { line_no++; return(ENDOFLINE); }
 1369     YY_BREAK
 1370 case 39:
 1371 /* rule 39 can match eol */
 1372 YY_RULE_SETUP
 1373 #line 294 "scan.l"
 1374 {  line_no++;  /* ignore a "quoted" newline */ }
 1375     YY_BREAK
 1376 case 40:
 1377 YY_RULE_SETUP
 1378 #line 295 "scan.l"
 1379 { /* ignore spaces and tabs */ }
 1380     YY_BREAK
 1381 case 41:
 1382 YY_RULE_SETUP
 1383 #line 296 "scan.l"
 1384 {
 1385     int c;
 1386 
 1387     for (;;)
 1388       {
 1389         while ( ((c=input()) != '*') && (c != EOF)) 
 1390           /* eat it */
 1391           if (c == '\n') line_no++;
 1392         if (c == '*')
 1393           {
 1394         while ( (c=input()) == '*') /* eat it*/;
 1395         if (c == '/') break; /* at end of comment */
 1396         if (c == '\n') line_no++;
 1397           }
 1398         if (c == EOF)
 1399           {
 1400         fprintf (stderr,"EOF encountered in a comment.\n");
 1401         break;
 1402           }
 1403       }
 1404       }
 1405     YY_BREAK
 1406 case 42:
 1407 YY_RULE_SETUP
 1408 #line 317 "scan.l"
 1409 { yylval.s_value = strcopyof(yytext); return(NAME); }
 1410     YY_BREAK
 1411 case 43:
 1412 /* rule 43 can match eol */
 1413 YY_RULE_SETUP
 1414 #line 318 "scan.l"
 1415 {
 1416           const char *look;
 1417           int count = 0;
 1418           yylval.s_value = strcopyof(yytext);
 1419           for (look = yytext; *look != 0; look++)
 1420         {
 1421           if (*look == '\n') line_no++;
 1422           if (*look == '"')  count++;
 1423         }
 1424           if (count != 2) yyerror ("NUL character in string.");
 1425           return(STRING);
 1426         }
 1427     YY_BREAK
 1428 case 44:
 1429 /* rule 44 can match eol */
 1430 YY_RULE_SETUP
 1431 #line 330 "scan.l"
 1432 {
 1433           char *src, *dst;
 1434           int len;
 1435           /* remove a trailing decimal point. */
 1436           len = strlen(yytext);
 1437           if (yytext[len-1] == '.')
 1438             yytext[len-1] = 0;
 1439           /* remove leading zeros. */
 1440           src = yytext;
 1441           dst = yytext;
 1442           while (*src == '0') src++;
 1443           if (*src == 0) src--;
 1444           /* Copy strings removing the newlines. */
 1445           while (*src != 0)
 1446         {
 1447               if (*src == '\\')
 1448             {
 1449               src++; src++;
 1450               line_no++;
 1451             }
 1452           else
 1453             *dst++ = *src++;
 1454             }
 1455           *dst = 0;
 1456           yylval.s_value = strcopyof(yytext); 
 1457           return(NUMBER);
 1458         }
 1459     YY_BREAK
 1460 case 45:
 1461 YY_RULE_SETUP
 1462 #line 357 "scan.l"
 1463 {
 1464       if (yytext[0] < ' ')
 1465         yyerror ("illegal character: ^%c",yytext[0] + '@');
 1466       else
 1467         if (yytext[0] > '~')
 1468           yyerror ("illegal character: \\%03o", (int) yytext[0]);
 1469         else
 1470           yyerror ("illegal character: %s",yytext);
 1471     }
 1472     YY_BREAK
 1473 case 46:
 1474 YY_RULE_SETUP
 1475 #line 366 "scan.l"
 1476 ECHO;
 1477     YY_BREAK
 1478 #line 1479 "scan.c"
 1479 case YY_STATE_EOF(INITIAL):
 1480 case YY_STATE_EOF(slcomment):
 1481     yyterminate();
 1482 
 1483     case YY_END_OF_BUFFER:
 1484         {
 1485         /* Amount of text matched not including the EOB char. */
 1486         int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 1487 
 1488         /* Undo the effects of YY_DO_BEFORE_ACTION. */
 1489         *yy_cp = (yy_hold_char);
 1490         YY_RESTORE_YY_MORE_OFFSET
 1491 
 1492         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 1493             {
 1494             /* We're scanning a new file or input source.  It's
 1495              * possible that this happened because the user
 1496              * just pointed yyin at a new source and called
 1497              * yylex().  If so, then we have to assure
 1498              * consistency between YY_CURRENT_BUFFER and our
 1499              * globals.  Here is the right place to do so, because
 1500              * this is the first action (other than possibly a
 1501              * back-up) that will match for the new input source.
 1502              */
 1503             (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 1504             YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
 1505             YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 1506             }
 1507 
 1508         /* Note that here we test for yy_c_buf_p "<=" to the position
 1509          * of the first EOB in the buffer, since yy_c_buf_p will
 1510          * already have been incremented past the NUL character
 1511          * (since all states make transitions on EOB to the
 1512          * end-of-buffer state).  Contrast this with the test
 1513          * in input().
 1514          */
 1515         if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
 1516             { /* This was really a NUL. */
 1517             yy_state_type yy_next_state;
 1518 
 1519             (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 1520 
 1521             yy_current_state = yy_get_previous_state(  );
 1522 
 1523             /* Okay, we're now positioned to make the NUL
 1524              * transition.  We couldn't have
 1525              * yy_get_previous_state() go ahead and do it
 1526              * for us because it doesn't know how to deal
 1527              * with the possibility of jamming (and we don't
 1528              * want to build jamming into it because then it
 1529              * will run more slowly).
 1530              */
 1531 
 1532             yy_next_state = yy_try_NUL_trans( yy_current_state );
 1533 
 1534             yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 1535 
 1536             if ( yy_next_state )
 1537                 {
 1538                 /* Consume the NUL. */
 1539                 yy_cp = ++(yy_c_buf_p);
 1540                 yy_current_state = yy_next_state;
 1541                 goto yy_match;
 1542                 }
 1543 
 1544             else
 1545                 {
 1546                 yy_cp = (yy_c_buf_p);
 1547                 goto yy_find_action;
 1548                 }
 1549             }
 1550 
 1551         else switch ( yy_get_next_buffer(  ) )
 1552             {
 1553             case EOB_ACT_END_OF_FILE:
 1554                 {
 1555                 (yy_did_buffer_switch_on_eof) = 0;
 1556 
 1557                 if ( yywrap( ) )
 1558                     {
 1559                     /* Note: because we've taken care in
 1560                      * yy_get_next_buffer() to have set up
 1561                      * yytext, we can now set up
 1562                      * yy_c_buf_p so that if some total
 1563                      * hoser (like flex itself) wants to
 1564                      * call the scanner after we return the
 1565                      * YY_NULL, it'll still work - another
 1566                      * YY_NULL will get returned.
 1567                      */
 1568                     (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 1569 
 1570                     yy_act = YY_STATE_EOF(YY_START);
 1571                     goto do_action;
 1572                     }
 1573 
 1574                 else
 1575                     {
 1576                     if ( ! (yy_did_buffer_switch_on_eof) )
 1577                         YY_NEW_FILE;
 1578                     }
 1579                 break;
 1580                 }
 1581 
 1582             case EOB_ACT_CONTINUE_SCAN:
 1583                 (yy_c_buf_p) =
 1584                     (yytext_ptr) + yy_amount_of_matched_text;
 1585 
 1586                 yy_current_state = yy_get_previous_state(  );
 1587 
 1588                 yy_cp = (yy_c_buf_p);
 1589                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 1590                 goto yy_match;
 1591 
 1592             case EOB_ACT_LAST_MATCH:
 1593                 (yy_c_buf_p) =
 1594                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 1595 
 1596                 yy_current_state = yy_get_previous_state(  );
 1597 
 1598                 yy_cp = (yy_c_buf_p);
 1599                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 1600                 goto yy_find_action;
 1601             }
 1602         break;
 1603         }
 1604 
 1605     default:
 1606         YY_FATAL_ERROR(
 1607             "fatal flex scanner internal error--no action found" );
 1608     } /* end of action switch */
 1609         } /* end of scanning one token */
 1610 } /* end of yylex */
 1611 
 1612 /* yy_get_next_buffer - try to read in a new buffer
 1613  *
 1614  * Returns a code representing an action:
 1615  *  EOB_ACT_LAST_MATCH -
 1616  *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 1617  *  EOB_ACT_END_OF_FILE - end of file
 1618  */
 1619 static int yy_get_next_buffer (void)
 1620 {
 1621         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
 1622     register char *source = (yytext_ptr);
 1623     register int number_to_move, i;
 1624     int ret_val;
 1625 
 1626     if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
 1627         YY_FATAL_ERROR(
 1628         "fatal flex scanner internal error--end of buffer missed" );
 1629 
 1630     if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
 1631         { /* Don't try to fill the buffer, so this is an EOF. */
 1632         if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
 1633             {
 1634             /* We matched a single character, the EOB, so
 1635              * treat this as a final EOF.
 1636              */
 1637             return EOB_ACT_END_OF_FILE;
 1638             }
 1639 
 1640         else
 1641             {
 1642             /* We matched some text prior to the EOB, first
 1643              * process it.
 1644              */
 1645             return EOB_ACT_LAST_MATCH;
 1646             }
 1647         }
 1648 
 1649     /* Try to read more data. */
 1650 
 1651     /* First move last chars to start of buffer. */
 1652     number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
 1653 
 1654     for ( i = 0; i < number_to_move; ++i )
 1655         *(dest++) = *(source++);
 1656 
 1657     if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
 1658         /* don't do the read, it's not guaranteed to return an EOF,
 1659          * just force an EOF
 1660          */
 1661         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
 1662 
 1663     else
 1664         {
 1665             int num_to_read =
 1666             YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
 1667 
 1668         while ( num_to_read <= 0 )
 1669             { /* Not enough room in the buffer - grow it. */
 1670 
 1671             /* just a shorter name for the current buffer */
 1672             YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
 1673 
 1674             int yy_c_buf_p_offset =
 1675                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
 1676 
 1677             if ( b->yy_is_our_buffer )
 1678                 {
 1679                 int new_size = b->yy_buf_size * 2;
 1680 
 1681                 if ( new_size <= 0 )
 1682                     b->yy_buf_size += b->yy_buf_size / 8;
 1683                 else
 1684                     b->yy_buf_size *= 2;
 1685 
 1686                 b->yy_ch_buf = (char *)
 1687                     /* Include room in for 2 EOB chars. */
 1688                     yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
 1689                 }
 1690             else
 1691                 /* Can't grow it, we don't own it. */
 1692                 b->yy_ch_buf = 0;
 1693 
 1694             if ( ! b->yy_ch_buf )
 1695                 YY_FATAL_ERROR(
 1696                 "fatal error - scanner input buffer overflow" );
 1697 
 1698             (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
 1699 
 1700             num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
 1701                         number_to_move - 1;
 1702 
 1703             }
 1704 
 1705         if ( num_to_read > YY_READ_BUF_SIZE )
 1706             num_to_read = YY_READ_BUF_SIZE;
 1707 
 1708         /* Read in more data. */
 1709         YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
 1710             (yy_n_chars), num_to_read );
 1711 
 1712         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
 1713         }
 1714 
 1715     if ( (yy_n_chars) == 0 )
 1716         {
 1717         if ( number_to_move == YY_MORE_ADJ )
 1718             {
 1719             ret_val = EOB_ACT_END_OF_FILE;
 1720             yyrestart(yyin  );
 1721             }
 1722 
 1723         else
 1724             {
 1725             ret_val = EOB_ACT_LAST_MATCH;
 1726             YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
 1727                 YY_BUFFER_EOF_PENDING;
 1728             }
 1729         }
 1730 
 1731     else
 1732         ret_val = EOB_ACT_CONTINUE_SCAN;
 1733 
 1734     (yy_n_chars) += number_to_move;
 1735     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
 1736     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
 1737 
 1738     (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 1739 
 1740     return ret_val;
 1741 }
 1742 
 1743 /* yy_get_previous_state - get the state just before the EOB char was reached */
 1744 
 1745     static yy_state_type yy_get_previous_state (void)
 1746 {
 1747     register yy_state_type yy_current_state;
 1748     register char *yy_cp;
 1749     
 1750     yy_current_state = (yy_start);
 1751 
 1752     for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
 1753         {
 1754         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
 1755         if ( yy_accept[yy_current_state] )
 1756             {
 1757             (yy_last_accepting_state) = yy_current_state;
 1758             (yy_last_accepting_cpos) = yy_cp;
 1759             }
 1760         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 1761             {
 1762             yy_current_state = (int) yy_def[yy_current_state];
 1763             if ( yy_current_state >= 316 )
 1764                 yy_c = yy_meta[(unsigned int) yy_c];
 1765             }
 1766         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 1767         }
 1768 
 1769     return yy_current_state;
 1770 }
 1771 
 1772 /* yy_try_NUL_trans - try to make a transition on the NUL character
 1773  *
 1774  * synopsis
 1775  *  next_state = yy_try_NUL_trans( current_state );
 1776  */
 1777     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
 1778 {
 1779     register int yy_is_jam;
 1780         register char *yy_cp = (yy_c_buf_p);
 1781 
 1782     register YY_CHAR yy_c = 1;
 1783     if ( yy_accept[yy_current_state] )
 1784         {
 1785         (yy_last_accepting_state) = yy_current_state;
 1786         (yy_last_accepting_cpos) = yy_cp;
 1787         }
 1788     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 1789         {
 1790         yy_current_state = (int) yy_def[yy_current_state];
 1791         if ( yy_current_state >= 316 )
 1792             yy_c = yy_meta[(unsigned int) yy_c];
 1793         }
 1794     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 1795     yy_is_jam = (yy_current_state == 315);
 1796 
 1797     return yy_is_jam ? 0 : yy_current_state;
 1798 }
 1799 
 1800     static void yyunput (int c, register char * yy_bp )
 1801 {
 1802     register char *yy_cp;
 1803     
 1804     yy_cp = (yy_c_buf_p);
 1805 
 1806     /* undo effects of setting up yytext */
 1807     *yy_cp = (yy_hold_char);
 1808 
 1809     if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 1810         { /* need to shift things up to make room */
 1811         /* +2 for EOB chars. */
 1812         register int number_to_move = (yy_n_chars) + 2;
 1813         register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
 1814                     YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
 1815         register char *source =
 1816                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
 1817 
 1818         while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
 1819             *--dest = *--source;
 1820 
 1821         yy_cp += (int) (dest - source);
 1822         yy_bp += (int) (dest - source);
 1823         YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
 1824             (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
 1825 
 1826         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 1827             YY_FATAL_ERROR( "flex scanner push-back overflow" );
 1828         }
 1829 
 1830     *--yy_cp = (char) c;
 1831 
 1832     (yytext_ptr) = yy_bp;
 1833     (yy_hold_char) = *yy_cp;
 1834     (yy_c_buf_p) = yy_cp;
 1835 }
 1836 
 1837 #ifndef YY_NO_INPUT
 1838 #ifdef __cplusplus
 1839     static int yyinput (void)
 1840 #else
 1841     static int input  (void)
 1842 #endif
 1843 
 1844 {
 1845     int c;
 1846     
 1847     *(yy_c_buf_p) = (yy_hold_char);
 1848 
 1849     if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
 1850         {
 1851         /* yy_c_buf_p now points to the character we want to return.
 1852          * If this occurs *before* the EOB characters, then it's a
 1853          * valid NUL; if not, then we've hit the end of the buffer.
 1854          */
 1855         if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
 1856             /* This was really a NUL. */
 1857             *(yy_c_buf_p) = '\0';
 1858 
 1859         else
 1860             { /* need more input */
 1861             int offset = (yy_c_buf_p) - (yytext_ptr);
 1862             ++(yy_c_buf_p);
 1863 
 1864             switch ( yy_get_next_buffer(  ) )
 1865                 {
 1866                 case EOB_ACT_LAST_MATCH:
 1867                     /* This happens because yy_g_n_b()
 1868                      * sees that we've accumulated a
 1869                      * token and flags that we need to
 1870                      * try matching the token before
 1871                      * proceeding.  But for input(),
 1872                      * there's no matching to consider.
 1873                      * So convert the EOB_ACT_LAST_MATCH
 1874                      * to EOB_ACT_END_OF_FILE.
 1875                      */
 1876 
 1877                     /* Reset buffer status. */
 1878                     yyrestart(yyin );
 1879 
 1880                     /*FALLTHROUGH*/
 1881 
 1882                 case EOB_ACT_END_OF_FILE:
 1883                     {
 1884                     if ( yywrap( ) )
 1885                         return EOF;
 1886 
 1887                     if ( ! (yy_did_buffer_switch_on_eof) )
 1888                         YY_NEW_FILE;
 1889 #ifdef __cplusplus
 1890                     return yyinput();
 1891 #else
 1892                     return input();
 1893 #endif
 1894                     }
 1895 
 1896                 case EOB_ACT_CONTINUE_SCAN:
 1897                     (yy_c_buf_p) = (yytext_ptr) + offset;
 1898                     break;
 1899                 }
 1900             }
 1901         }
 1902 
 1903     c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
 1904     *(yy_c_buf_p) = '\0';   /* preserve yytext */
 1905     (yy_hold_char) = *++(yy_c_buf_p);
 1906 
 1907     return c;
 1908 }
 1909 #endif  /* ifndef YY_NO_INPUT */
 1910 
 1911 /** Immediately switch to a different input stream.
 1912  * @param input_file A readable stream.
 1913  * 
 1914  * @note This function does not reset the start condition to @c INITIAL .
 1915  */
 1916     void yyrestart  (FILE * input_file )
 1917 {
 1918     
 1919     if ( ! YY_CURRENT_BUFFER ){
 1920         yyensure_buffer_stack ();
 1921         YY_CURRENT_BUFFER_LVALUE =
 1922             yy_create_buffer(yyin,YY_BUF_SIZE );
 1923     }
 1924 
 1925     yy_init_buffer(YY_CURRENT_BUFFER,input_file );
 1926     yy_load_buffer_state( );
 1927 }
 1928 
 1929 /** Switch to a different input buffer.
 1930  * @param new_buffer The new input buffer.
 1931  * 
 1932  */
 1933     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
 1934 {
 1935     
 1936     /* TODO. We should be able to replace this entire function body
 1937      * with
 1938      *      yypop_buffer_state();
 1939      *      yypush_buffer_state(new_buffer);
 1940      */
 1941     yyensure_buffer_stack ();
 1942     if ( YY_CURRENT_BUFFER == new_buffer )
 1943         return;
 1944 
 1945     if ( YY_CURRENT_BUFFER )
 1946         {
 1947         /* Flush out information for old buffer. */
 1948         *(yy_c_buf_p) = (yy_hold_char);
 1949         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
 1950         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
 1951         }
 1952 
 1953     YY_CURRENT_BUFFER_LVALUE = new_buffer;
 1954     yy_load_buffer_state( );
 1955 
 1956     /* We don't actually know whether we did this switch during
 1957      * EOF (yywrap()) processing, but the only time this flag
 1958      * is looked at is after yywrap() is called, so it's safe
 1959      * to go ahead and always set it.
 1960      */
 1961     (yy_did_buffer_switch_on_eof) = 1;
 1962 }
 1963 
 1964 static void yy_load_buffer_state  (void)
 1965 {
 1966         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 1967     (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
 1968     yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
 1969     (yy_hold_char) = *(yy_c_buf_p);
 1970 }
 1971 
 1972 /** Allocate and initialize an input buffer state.
 1973  * @param file A readable stream.
 1974  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 1975  * 
 1976  * @return the allocated buffer state.
 1977  */
 1978     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
 1979 {
 1980     YY_BUFFER_STATE b;
 1981     
 1982     b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
 1983     if ( ! b )
 1984         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 1985 
 1986     b->yy_buf_size = size;
 1987 
 1988     /* yy_ch_buf has to be 2 characters longer than the size given because
 1989      * we need to put in 2 end-of-buffer characters.
 1990      */
 1991     b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
 1992     if ( ! b->yy_ch_buf )
 1993         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 1994 
 1995     b->yy_is_our_buffer = 1;
 1996 
 1997     yy_init_buffer(b,file );
 1998 
 1999     return b;
 2000 }
 2001 
 2002 /** Destroy the buffer.
 2003  * @param b a buffer created with yy_create_buffer()
 2004  * 
 2005  */
 2006     void yy_delete_buffer (YY_BUFFER_STATE  b )
 2007 {
 2008     
 2009     if ( ! b )
 2010         return;
 2011 
 2012     if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
 2013         YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 2014 
 2015     if ( b->yy_is_our_buffer )
 2016         yyfree((void *) b->yy_ch_buf  );
 2017 
 2018     yyfree((void *) b  );
 2019 }
 2020 
 2021 #ifndef _UNISTD_H /* assume unistd.h has isatty() for us */
 2022 #ifdef __cplusplus
 2023 extern "C" {
 2024 #endif
 2025 #ifdef __THROW /* this is a gnuism */
 2026 extern int isatty (int ) __THROW;
 2027 #else
 2028 extern int isatty (int );
 2029 #endif
 2030 #ifdef __cplusplus
 2031 }
 2032 #endif
 2033 #endif
 2034     
 2035 /* Initializes or reinitializes a buffer.
 2036  * This function is sometimes called more than once on the same buffer,
 2037  * such as during a yyrestart() or at EOF.
 2038  */
 2039     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
 2040 
 2041 {
 2042     int oerrno = errno;
 2043     
 2044     yy_flush_buffer(b );
 2045 
 2046     b->yy_input_file = file;
 2047     b->yy_fill_buffer = 1;
 2048 
 2049     /* If b is the current buffer, then yy_init_buffer was _probably_
 2050      * called from yyrestart() or through yy_get_next_buffer.
 2051      * In that case, we don't want to reset the lineno or column.
 2052      */
 2053     if (b != YY_CURRENT_BUFFER){
 2054         b->yy_bs_lineno = 1;
 2055         b->yy_bs_column = 0;
 2056     }
 2057 
 2058         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
 2059     
 2060     errno = oerrno;
 2061 }
 2062 
 2063 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
 2064  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 2065  * 
 2066  */
 2067     void yy_flush_buffer (YY_BUFFER_STATE  b )
 2068 {
 2069         if ( ! b )
 2070         return;
 2071 
 2072     b->yy_n_chars = 0;
 2073 
 2074     /* We always need two end-of-buffer characters.  The first causes
 2075      * a transition to the end-of-buffer state.  The second causes
 2076      * a jam in that state.
 2077      */
 2078     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
 2079     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
 2080 
 2081     b->yy_buf_pos = &b->yy_ch_buf[0];
 2082 
 2083     b->yy_at_bol = 1;
 2084     b->yy_buffer_status = YY_BUFFER_NEW;
 2085 
 2086     if ( b == YY_CURRENT_BUFFER )
 2087         yy_load_buffer_state( );
 2088 }
 2089 
 2090 /** Pushes the new state onto the stack. The new state becomes
 2091  *  the current state. This function will allocate the stack
 2092  *  if necessary.
 2093  *  @param new_buffer The new state.
 2094  *  
 2095  */
 2096 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
 2097 {
 2098         if (new_buffer == NULL)
 2099         return;
 2100 
 2101     yyensure_buffer_stack();
 2102 
 2103     /* This block is copied from yy_switch_to_buffer. */
 2104     if ( YY_CURRENT_BUFFER )
 2105         {
 2106         /* Flush out information for old buffer. */
 2107         *(yy_c_buf_p) = (yy_hold_char);
 2108         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
 2109         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
 2110         }
 2111 
 2112     /* Only push if top exists. Otherwise, replace top. */
 2113     if (YY_CURRENT_BUFFER)
 2114         (yy_buffer_stack_top)++;
 2115     YY_CURRENT_BUFFER_LVALUE = new_buffer;
 2116 
 2117     /* copied from yy_switch_to_buffer. */
 2118     yy_load_buffer_state( );
 2119     (yy_did_buffer_switch_on_eof) = 1;
 2120 }
 2121 
 2122 /** Removes and deletes the top of the stack, if present.
 2123  *  The next element becomes the new top.
 2124  *  
 2125  */
 2126 void yypop_buffer_state (void)
 2127 {
 2128         if (!YY_CURRENT_BUFFER)
 2129         return;
 2130 
 2131     yy_delete_buffer(YY_CURRENT_BUFFER );
 2132     YY_CURRENT_BUFFER_LVALUE = NULL;
 2133     if ((yy_buffer_stack_top) > 0)
 2134         --(yy_buffer_stack_top);
 2135 
 2136     if (YY_CURRENT_BUFFER) {
 2137         yy_load_buffer_state( );
 2138         (yy_did_buffer_switch_on_eof) = 1;
 2139     }
 2140 }
 2141 
 2142 /* Allocates the stack if it does not exist.
 2143  *  Guarantees space for at least one push.
 2144  */
 2145 static void yyensure_buffer_stack (void)
 2146 {
 2147     int num_to_alloc;
 2148     
 2149     if (!(yy_buffer_stack)) {
 2150 
 2151         /* First allocation is just for 2 elements, since we don't know if this
 2152          * scanner will even need a stack. We use 2 instead of 1 to avoid an
 2153          * immediate realloc on the next call.
 2154          */
 2155         num_to_alloc = 1;
 2156         (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
 2157                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
 2158                                 );
 2159         
 2160         memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
 2161                 
 2162         (yy_buffer_stack_max) = num_to_alloc;
 2163         (yy_buffer_stack_top) = 0;
 2164         return;
 2165     }
 2166 
 2167     if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
 2168 
 2169         /* Increase the buffer to prepare for a possible push. */
 2170         int grow_size = 8 /* arbitrary grow size */;
 2171 
 2172         num_to_alloc = (yy_buffer_stack_max) + grow_size;
 2173         (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
 2174                                 ((yy_buffer_stack),
 2175                                 num_to_alloc * sizeof(struct yy_buffer_state*)
 2176                                 );
 2177 
 2178         /* zero only the new slots.*/
 2179         memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
 2180         (yy_buffer_stack_max) = num_to_alloc;
 2181     }
 2182 }
 2183 
 2184 /** Setup the input buffer state to scan directly from a user-specified character buffer.
 2185  * @param base the character buffer
 2186  * @param size the size in bytes of the character buffer
 2187  * 
 2188  * @return the newly allocated buffer state object. 
 2189  */
 2190 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
 2191 {
 2192     YY_BUFFER_STATE b;
 2193     
 2194     if ( size < 2 ||
 2195          base[size-2] != YY_END_OF_BUFFER_CHAR ||
 2196          base[size-1] != YY_END_OF_BUFFER_CHAR )
 2197         /* They forgot to leave room for the EOB's. */
 2198         return 0;
 2199 
 2200     b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
 2201     if ( ! b )
 2202         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
 2203 
 2204     b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
 2205     b->yy_buf_pos = b->yy_ch_buf = base;
 2206     b->yy_is_our_buffer = 0;
 2207     b->yy_input_file = 0;
 2208     b->yy_n_chars = b->yy_buf_size;
 2209     b->yy_is_interactive = 0;
 2210     b->yy_at_bol = 1;
 2211     b->yy_fill_buffer = 0;
 2212     b->yy_buffer_status = YY_BUFFER_NEW;
 2213 
 2214     yy_switch_to_buffer(b  );
 2215 
 2216     return b;
 2217 }
 2218 
 2219 /** Setup the input buffer state to scan a string. The next call to yylex() will
 2220  * scan from a @e copy of @a str.
 2221  * @param str a NUL-terminated string to scan
 2222  * 
 2223  * @return the newly allocated buffer state object.
 2224  * @note If you want to scan bytes that may contain NUL values, then use
 2225  *       yy_scan_bytes() instead.
 2226  */
 2227 YY_BUFFER_STATE yy_scan_string (yyconst char * __yystr )
 2228 {
 2229     
 2230     return yy_scan_bytes(__yystr,strlen(__yystr) );
 2231 }
 2232 
 2233 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
 2234  * scan from a @e copy of @a bytes.
 2235  * @param bytes the byte buffer to scan
 2236  * @param len the number of bytes in the buffer pointed to by @a bytes.
 2237  * 
 2238  * @return the newly allocated buffer state object.
 2239  */
 2240 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
 2241 {
 2242     YY_BUFFER_STATE b;
 2243     char *buf;
 2244     yy_size_t n;
 2245     int i;
 2246     
 2247     /* Get memory for full buffer, including space for trailing EOB's. */
 2248     n = _yybytes_len + 2;
 2249     buf = (char *) yyalloc(n  );
 2250     if ( ! buf )
 2251         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 2252 
 2253     for ( i = 0; i < _yybytes_len; ++i )
 2254         buf[i] = yybytes[i];
 2255 
 2256     buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 2257 
 2258     b = yy_scan_buffer(buf,n );
 2259     if ( ! b )
 2260         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 2261 
 2262     /* It's okay to grow etc. this buffer, and we should throw it
 2263      * away when we're done.
 2264      */
 2265     b->yy_is_our_buffer = 1;
 2266 
 2267     return b;
 2268 }
 2269 
 2270 #ifndef YY_EXIT_FAILURE
 2271 #define YY_EXIT_FAILURE 2
 2272 #endif
 2273 
 2274 static void yy_fatal_error (yyconst char* msg )
 2275 {
 2276         (void) fprintf( stderr, "%s\n", msg );
 2277     exit( YY_EXIT_FAILURE );
 2278 }
 2279 
 2280 /* Redefine yyless() so it works in section 3 code. */
 2281 
 2282 #undef yyless
 2283 #define yyless(n) \
 2284     do \
 2285         { \
 2286         /* Undo effects of setting up yytext. */ \
 2287         int yyless_macro_arg = (n); \
 2288         YY_LESS_LINENO(yyless_macro_arg);\
 2289         yytext[yyleng] = (yy_hold_char); \
 2290         (yy_c_buf_p) = yytext + yyless_macro_arg; \
 2291         (yy_hold_char) = *(yy_c_buf_p); \
 2292         *(yy_c_buf_p) = '\0'; \
 2293         yyleng = yyless_macro_arg; \
 2294         } \
 2295     while ( 0 )
 2296 
 2297 /* Accessor  methods (get/set functions) to struct members. */
 2298 
 2299 /** Get the current line number.
 2300  * 
 2301  */
 2302 int yyget_lineno  (void)
 2303 {
 2304         
 2305     return yylineno;
 2306 }
 2307 
 2308 /** Get the input stream.
 2309  * 
 2310  */
 2311 FILE *yyget_in  (void)
 2312 {
 2313         return yyin;
 2314 }
 2315 
 2316 /** Get the output stream.
 2317  * 
 2318  */
 2319 FILE *yyget_out  (void)
 2320 {
 2321         return yyout;
 2322 }
 2323 
 2324 /** Get the length of the current token.
 2325  * 
 2326  */
 2327 int yyget_leng  (void)
 2328 {
 2329         return yyleng;
 2330 }
 2331 
 2332 /** Get the current token.
 2333  * 
 2334  */
 2335 
 2336 char *yyget_text  (void)
 2337 {
 2338         return yytext;
 2339 }
 2340 
 2341 /** Set the current line number.
 2342  * @param line_number
 2343  * 
 2344  */
 2345 void yyset_lineno (int  line_number )
 2346 {
 2347     
 2348     yylineno = line_number;
 2349 }
 2350 
 2351 /** Set the input stream. This does not discard the current
 2352  * input buffer.
 2353  * @param in_str A readable stream.
 2354  * 
 2355  * @see yy_switch_to_buffer
 2356  */
 2357 void yyset_in (FILE *  in_str )
 2358 {
 2359         yyin = in_str ;
 2360 }
 2361 
 2362 void yyset_out (FILE *  out_str )
 2363 {
 2364         yyout = out_str ;
 2365 }
 2366 
 2367 int yyget_debug  (void)
 2368 {
 2369         return yy_flex_debug;
 2370 }
 2371 
 2372 void yyset_debug (int  bdebug )
 2373 {
 2374         yy_flex_debug = bdebug ;
 2375 }
 2376 
 2377 static int yy_init_globals (void)
 2378 {
 2379         /* Initialization is the same as for the non-reentrant scanner.
 2380      * This function is called from yylex_destroy(), so don't allocate here.
 2381      */
 2382 
 2383     (yy_buffer_stack) = 0;
 2384     (yy_buffer_stack_top) = 0;
 2385     (yy_buffer_stack_max) = 0;
 2386     (yy_c_buf_p) = (char *) 0;
 2387     (yy_init) = 0;
 2388     (yy_start) = 0;
 2389 
 2390 /* Defined in main.c */
 2391 #ifdef YY_STDINIT
 2392     yyin = stdin;
 2393     yyout = stdout;
 2394 #else
 2395     yyin = (FILE *) 0;
 2396     yyout = (FILE *) 0;
 2397 #endif
 2398 
 2399     /* For future reference: Set errno on error, since we are called by
 2400      * yylex_init()
 2401      */
 2402     return 0;
 2403 }
 2404 
 2405 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
 2406 int yylex_destroy  (void)
 2407 {
 2408     
 2409     /* Pop the buffer stack, destroying each element. */
 2410     while(YY_CURRENT_BUFFER){
 2411         yy_delete_buffer(YY_CURRENT_BUFFER  );
 2412         YY_CURRENT_BUFFER_LVALUE = NULL;
 2413         yypop_buffer_state();
 2414     }
 2415 
 2416     /* Destroy the stack itself. */
 2417     yyfree((yy_buffer_stack) );
 2418     (yy_buffer_stack) = NULL;
 2419 
 2420     /* Reset the globals. This is important in a non-reentrant scanner so the next time
 2421      * yylex() is called, initialization will occur. */
 2422     yy_init_globals( );
 2423 
 2424     return 0;
 2425 }
 2426 
 2427 /*
 2428  * Internal utility routines.
 2429  */
 2430 
 2431 #ifndef yytext_ptr
 2432 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
 2433 {
 2434     register int i;
 2435     for ( i = 0; i < n; ++i )
 2436         s1[i] = s2[i];
 2437 }
 2438 #endif
 2439 
 2440 #ifdef YY_NEED_STRLEN
 2441 static int yy_flex_strlen (yyconst char * s )
 2442 {
 2443     register int n;
 2444     for ( n = 0; s[n]; ++n )
 2445         ;
 2446 
 2447     return n;
 2448 }
 2449 #endif
 2450 
 2451 void *yyalloc (yy_size_t  size )
 2452 {
 2453     return (void *) malloc( size );
 2454 }
 2455 
 2456 void *yyrealloc  (void * ptr, yy_size_t  size )
 2457 {
 2458     /* The cast to (char *) in the following accommodates both
 2459      * implementations that use char* generic pointers, and those
 2460      * that use void* generic pointers.  It works with the latter
 2461      * because both ANSI C and C++ allow castless assignment from
 2462      * any pointer type to void*, and deal with argument conversions
 2463      * as though doing an assignment.
 2464      */
 2465     return (void *) realloc( (char *) ptr, size );
 2466 }
 2467 
 2468 void yyfree (void * ptr )
 2469 {
 2470     free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
 2471 }
 2472 
 2473 #define YYTABLES_NAME "yytables"
 2474 
 2475 #line 366 "scan.l"
 2476 
 2477 
 2478 
 2479 
 2480 
 2481 /* This is the way to get multiple files input into lex. */
 2482 
 2483 int
 2484 yywrap()
 2485 {
 2486   if (!open_new_file ()) return (1);    /* EOF on standard in. */
 2487   return (0);               /* We have more input. */
 2488 }
 2489