Back to index

wims  3.65+svn20090927
lex.yy.c
Go to the documentation of this file.
00001 
00002 #line 3 "lex.yy.c"
00003 
00004 #define  YY_INT_ALIGNED short int
00005 
00006 /* A lexical scanner generated by flex */
00007 
00008 #define FLEX_SCANNER
00009 #define YY_FLEX_MAJOR_VERSION 2
00010 #define YY_FLEX_MINOR_VERSION 5
00011 #define YY_FLEX_SUBMINOR_VERSION 35
00012 #if YY_FLEX_SUBMINOR_VERSION > 0
00013 #define FLEX_BETA
00014 #endif
00015 
00016 /* First, we deal with  platform-specific or compiler-specific issues. */
00017 
00018 /* begin standard C headers. */
00019 #include <stdio.h>
00020 #include <string.h>
00021 #include <errno.h>
00022 #include <stdlib.h>
00023 
00024 /* end standard C headers. */
00025 
00026 /* flex integer type definitions */
00027 
00028 #ifndef FLEXINT_H
00029 #define FLEXINT_H
00030 
00031 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
00032 
00033 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
00034 
00035 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
00036  * if you want the limit (max/min) macros for int types. 
00037  */
00038 #ifndef __STDC_LIMIT_MACROS
00039 #define __STDC_LIMIT_MACROS 1
00040 #endif
00041 
00042 #include <inttypes.h>
00043 typedef int8_t flex_int8_t;
00044 typedef uint8_t flex_uint8_t;
00045 typedef int16_t flex_int16_t;
00046 typedef uint16_t flex_uint16_t;
00047 typedef int32_t flex_int32_t;
00048 typedef uint32_t flex_uint32_t;
00049 #else
00050 typedef signed char flex_int8_t;
00051 typedef short int flex_int16_t;
00052 typedef int flex_int32_t;
00053 typedef unsigned char flex_uint8_t; 
00054 typedef unsigned short int flex_uint16_t;
00055 typedef unsigned int flex_uint32_t;
00056 
00057 /* Limits of integral types. */
00058 #ifndef INT8_MIN
00059 #define INT8_MIN               (-128)
00060 #endif
00061 #ifndef INT16_MIN
00062 #define INT16_MIN              (-32767-1)
00063 #endif
00064 #ifndef INT32_MIN
00065 #define INT32_MIN              (-2147483647-1)
00066 #endif
00067 #ifndef INT8_MAX
00068 #define INT8_MAX               (127)
00069 #endif
00070 #ifndef INT16_MAX
00071 #define INT16_MAX              (32767)
00072 #endif
00073 #ifndef INT32_MAX
00074 #define INT32_MAX              (2147483647)
00075 #endif
00076 #ifndef UINT8_MAX
00077 #define UINT8_MAX              (255U)
00078 #endif
00079 #ifndef UINT16_MAX
00080 #define UINT16_MAX             (65535U)
00081 #endif
00082 #ifndef UINT32_MAX
00083 #define UINT32_MAX             (4294967295U)
00084 #endif
00085 
00086 #endif /* ! C99 */
00087 
00088 #endif /* ! FLEXINT_H */
00089 
00090 #ifdef __cplusplus
00091 
00092 /* The "const" storage-class-modifier is valid. */
00093 #define YY_USE_CONST
00094 
00095 #else  /* ! __cplusplus */
00096 
00097 /* C99 requires __STDC__ to be defined as 1. */
00098 #if defined (__STDC__)
00099 
00100 #define YY_USE_CONST
00101 
00102 #endif /* defined (__STDC__) */
00103 #endif /* ! __cplusplus */
00104 
00105 #ifdef YY_USE_CONST
00106 #define yyconst const
00107 #else
00108 #define yyconst
00109 #endif
00110 
00111 /* Returned upon end-of-file. */
00112 #define YY_NULL 0
00113 
00114 /* Promotes a possibly negative, possibly signed char to an unsigned
00115  * integer for use as an array index.  If the signed char is negative,
00116  * we want to instead treat it as an 8-bit unsigned char, hence the
00117  * double cast.
00118  */
00119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00120 
00121 /* Enter a start condition.  This macro really ought to take a parameter,
00122  * but we do it the disgusting crufty way forced on us by the ()-less
00123  * definition of BEGIN.
00124  */
00125 #define BEGIN (yy_start) = 1 + 2 *
00126 
00127 /* Translate the current start state into a value that can be later handed
00128  * to BEGIN to return to the state.  The YYSTATE alias is for lex
00129  * compatibility.
00130  */
00131 #define YY_START (((yy_start) - 1) / 2)
00132 #define YYSTATE YY_START
00133 
00134 /* Action number for EOF rule of a given start state. */
00135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00136 
00137 /* Special action meaning "start processing a new file". */
00138 #define YY_NEW_FILE yyrestart(yyin  )
00139 
00140 #define YY_END_OF_BUFFER_CHAR 0
00141 
00142 /* Size of default input buffer. */
00143 #ifndef YY_BUF_SIZE
00144 #ifdef __ia64__
00145 /* On IA-64, the buffer size is 16k, not 8k.
00146  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
00147  * Ditto for the __ia64__ case accordingly.
00148  */
00149 #define YY_BUF_SIZE 32768
00150 #else
00151 #define YY_BUF_SIZE 16384
00152 #endif /* __ia64__ */
00153 #endif
00154 
00155 /* The state buf must be large enough to hold one state per character in the main buffer.
00156  */
00157 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
00158 
00159 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
00160 #define YY_TYPEDEF_YY_BUFFER_STATE
00161 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00162 #endif
00163 
00164 extern int yyleng;
00165 
00166 extern FILE *yyin, *yyout;
00167 
00168 #define EOB_ACT_CONTINUE_SCAN 0
00169 #define EOB_ACT_END_OF_FILE 1
00170 #define EOB_ACT_LAST_MATCH 2
00171 
00172     #define YY_LESS_LINENO(n)
00173     
00174 /* Return all but the first "n" matched characters back to the input stream. */
00175 #define yyless(n) \
00176        do \
00177               { \
00178               /* Undo effects of setting up yytext. */ \
00179         int yyless_macro_arg = (n); \
00180         YY_LESS_LINENO(yyless_macro_arg);\
00181               *yy_cp = (yy_hold_char); \
00182               YY_RESTORE_YY_MORE_OFFSET \
00183               (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
00184               YY_DO_BEFORE_ACTION; /* set up yytext again */ \
00185               } \
00186        while ( 0 )
00187 
00188 #define unput(c) yyunput( c, (yytext_ptr)  )
00189 
00190 #ifndef YY_TYPEDEF_YY_SIZE_T
00191 #define YY_TYPEDEF_YY_SIZE_T
00192 typedef size_t yy_size_t;
00193 #endif
00194 
00195 #ifndef YY_STRUCT_YY_BUFFER_STATE
00196 #define YY_STRUCT_YY_BUFFER_STATE
00197 struct yy_buffer_state
00198        {
00199        FILE *yy_input_file;
00200 
00201        char *yy_ch_buf;            /* input buffer */
00202        char *yy_buf_pos;           /* current position in input buffer */
00203 
00204        /* Size of input buffer in bytes, not including room for EOB
00205         * characters.
00206         */
00207        yy_size_t yy_buf_size;
00208 
00209        /* Number of characters read into yy_ch_buf, not including EOB
00210         * characters.
00211         */
00212        int yy_n_chars;
00213 
00214        /* Whether we "own" the buffer - i.e., we know we created it,
00215         * and can realloc() it to grow it, and should free() it to
00216         * delete it.
00217         */
00218        int yy_is_our_buffer;
00219 
00220        /* Whether this is an "interactive" input source; if so, and
00221         * if we're using stdio for input, then we want to use getc()
00222         * instead of fread(), to make sure we stop fetching input after
00223         * each newline.
00224         */
00225        int yy_is_interactive;
00226 
00227        /* Whether we're considered to be at the beginning of a line.
00228         * If so, '^' rules will be active on the next match, otherwise
00229         * not.
00230         */
00231        int yy_at_bol;
00232 
00233     int yy_bs_lineno; 
00234     int yy_bs_column; 
00236        /* Whether to try to fill the input buffer when we reach the
00237         * end of it.
00238         */
00239        int yy_fill_buffer;
00240 
00241        int yy_buffer_status;
00242 
00243 #define YY_BUFFER_NEW 0
00244 #define YY_BUFFER_NORMAL 1
00245        /* When an EOF's been seen but there's still some text to process
00246         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
00247         * shouldn't try reading from the input source any more.  We might
00248         * still have a bunch of tokens to match, though, because of
00249         * possible backing-up.
00250         *
00251         * When we actually see the EOF, we change the status to "new"
00252         * (via yyrestart()), so that the user can continue scanning by
00253         * just pointing yyin at a new input file.
00254         */
00255 #define YY_BUFFER_EOF_PENDING 2
00256 
00257        };
00258 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
00259 
00260 /* Stack of input buffers. */
00261 static size_t yy_buffer_stack_top = 0; 
00262 static size_t yy_buffer_stack_max = 0; 
00263 static YY_BUFFER_STATE * yy_buffer_stack = 0; 
00265 /* We provide macros for accessing buffer states in case in the
00266  * future we want to put the buffer states in a more general
00267  * "scanner state".
00268  *
00269  * Returns the top of the stack, or NULL.
00270  */
00271 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
00272                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
00273                           : NULL)
00274 
00275 /* Same as previous macro, but useful when we know that the buffer stack is not
00276  * NULL or when we need an lvalue. For internal use only.
00277  */
00278 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
00279 
00280 /* yy_hold_char holds the character lost when yytext is formed. */
00281 static char yy_hold_char;
00282 static int yy_n_chars;             /* number of characters read into yy_ch_buf */
00283 int yyleng;
00284 
00285 /* Points to current character in buffer. */
00286 static char *yy_c_buf_p = (char *) 0;
00287 static int yy_init = 0;            /* whether we need to initialize */
00288 static int yy_start = 0;    /* start state number */
00289 
00290 /* Flag which is used to allow yywrap()'s to do buffer switches
00291  * instead of setting up a fresh yyin.  A bit of a hack ...
00292  */
00293 static int yy_did_buffer_switch_on_eof;
00294 
00295 void yyrestart (FILE *input_file  );
00296 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
00297 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
00298 void yy_delete_buffer (YY_BUFFER_STATE b  );
00299 void yy_flush_buffer (YY_BUFFER_STATE b  );
00300 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
00301 void yypop_buffer_state (void );
00302 
00303 static void yyensure_buffer_stack (void );
00304 static void yy_load_buffer_state (void );
00305 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
00306 
00307 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
00308 
00309 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
00310 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
00311 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
00312 
00313 void *yyalloc (yy_size_t  );
00314 void *yyrealloc (void *,yy_size_t  );
00315 void yyfree (void *  );
00316 
00317 #define yy_new_buffer yy_create_buffer
00318 
00319 #define yy_set_interactive(is_interactive) \
00320        { \
00321        if ( ! YY_CURRENT_BUFFER ){ \
00322         yyensure_buffer_stack (); \
00323               YY_CURRENT_BUFFER_LVALUE =    \
00324             yy_create_buffer(yyin,YY_BUF_SIZE ); \
00325        } \
00326        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
00327        }
00328 
00329 #define yy_set_bol(at_bol) \
00330        { \
00331        if ( ! YY_CURRENT_BUFFER ){\
00332         yyensure_buffer_stack (); \
00333               YY_CURRENT_BUFFER_LVALUE =    \
00334             yy_create_buffer(yyin,YY_BUF_SIZE ); \
00335        } \
00336        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
00337        }
00338 
00339 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
00340 
00341 #define yywrap(n) 1
00342 #define YY_SKIP_YYWRAP
00343 
00344 typedef unsigned char YY_CHAR;
00345 
00346 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
00347 
00348 typedef int yy_state_type;
00349 
00350 extern int yylineno;
00351 
00352 int yylineno = 1;
00353 
00354 extern char *yytext;
00355 #define yytext_ptr yytext
00356 
00357 static yy_state_type yy_get_previous_state (void );
00358 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
00359 static int yy_get_next_buffer (void );
00360 static void yy_fatal_error (yyconst char msg[]  );
00361 
00362 /* Done after the current pattern has been matched and before the
00363  * corresponding action - sets up yytext.
00364  */
00365 #define YY_DO_BEFORE_ACTION \
00366        (yytext_ptr) = yy_bp; \
00367        yyleng = (size_t) (yy_cp - yy_bp); \
00368        (yy_hold_char) = *yy_cp; \
00369        *yy_cp = '\0'; \
00370        (yy_c_buf_p) = yy_cp;
00371 
00372 #define YY_NUM_RULES 55
00373 #define YY_END_OF_BUFFER 56
00374 /* This struct is not used in this scanner,
00375    but its presence is necessary. */
00376 struct yy_trans_info
00377        {
00378        flex_int32_t yy_verify;
00379        flex_int32_t yy_nxt;
00380        };
00381 static yyconst flex_int16_t yy_accept[113] =
00382     {   0,
00383         0,    0,   56,   53,   48,   54,   53,   39,   53,   53,
00384        36,   37,    1,   52,    8,   53,   17,   35,   21,   35,
00385        24,   15,    9,   43,   13,   53,   35,   20,   22,   18,
00386        16,   53,    5,   42,   35,   35,   53,    6,    2,   43,
00387         4,   53,   53,    7,   44,   47,   53,   38,   33,   34,
00388        48,    0,    0,   36,   37,   52,    0,    0,   49,   40,
00389         0,    1,   36,   37,    1,    0,    0,   52,   27,   28,
00390        12,    0,   14,   29,   23,    0,    0,   32,    0,   11,
00391        35,   46,   25,   26,    0,    0,    0,    0,   31,    0,
00392        50,   41,    9,   49,    0,    0,    1,    0,    0,    1,
00393 
00394        19,   45,    3,   10,   30,   47,   50,   50,   51,    0,
00395        51,    0
00396     } ;
00397 
00398 static yyconst flex_int32_t yy_ec[256] =
00399     {   0,
00400         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
00401         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00403         1,    2,    1,    1,    4,    1,    5,    1,    6,    1,
00404         1,    1,    7,    1,    8,    9,   10,   11,   11,   11,
00405        11,   11,   11,   11,   11,   11,   11,   12,    1,    1,
00406         1,    1,    1,    1,   13,   14,   15,    1,   16,   17,
00407        18,   19,    1,   20,   21,   22,   23,   24,   25,   26,
00408         1,    1,   27,   28,    1,   29,   30,    1,   23,   23,
00409         1,    1,    1,   31,    1,    1,   32,   33,   34,   35,
00410 
00411        36,   23,   37,   38,   39,    1,   23,   40,   41,   42,
00412        43,   23,   44,   45,   46,   47,   48,   49,    1,   50,
00413        51,   52,    1,    1,    1,   53,    1,    1,    1,    1,
00414         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00415         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00416         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00417         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00418         1,    1,    1,    1,    1,   54,    1,   55,   56,    1,
00419        23,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00420         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00421 
00422         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00423         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00424         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00425         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00426         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00427         1,    1,    1,    1,    1
00428     } ;
00429 
00430 static yyconst flex_int32_t yy_meta[57] =
00431     {   0,
00432         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00433         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00434         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00435         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00436         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00437         1,    1,    1,    1,    1,    1
00438     } ;
00439 
00440 static yyconst flex_int16_t yy_base[113] =
00441     {   0,
00442         0,    0,  177,  178,   55,  178,  165,  169,   50,  163,
00443       171,  170,   61,  169,  178,  126,  178,  178,  178,  118,
00444       116,  178,  178,  178,  178,  129,  134,  116,  178,  178,
00445       131,   67,  178,  131,  127,  129,  131,  178,  178,   30,
00446        40,  121,  126,  112,  178,  114,  143,   53,  178,  178,
00447        80,  142,  144,  149,  148,  147,   91,  137,   74,  178,
00448        89,   94,  145,  144,   79,  134,  105,  142,  178,  178,
00449       178,  102,  178,  178,  178,  112,  131,  130,   95,  178,
00450       178,  178,  178,  178,   97,   97,   91,   93,  178,   95,
00451       107,  178,  178,  123,  115,   83,  120,  127,  113,  110,
00452 
00453       178,  178,  178,  178,  178,  178,  104,  102,   99,   68,
00454        58,  178
00455     } ;
00456 
00457 static yyconst flex_int16_t yy_def[113] =
00458     {   0,
00459       112,    1,  112,  112,  112,  112,  112,  112,  112,  112,
00460       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00461       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00462       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00463       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00464       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00465       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00466       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00467       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00468       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00469 
00470       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00471       112,    0
00472     } ;
00473 
00474 static yyconst flex_int16_t yy_nxt[235] =
00475     {   0,
00476         4,    5,    6,    7,    4,    8,    9,   10,   11,   12,
00477        13,   14,   15,   16,   17,   18,   19,   20,   21,   22,
00478        23,   24,   18,   25,   26,   27,   28,   29,   30,   31,
00479        32,   33,   34,   35,   36,   37,   38,   39,    4,   40,
00480        41,   18,   42,    4,   43,   44,   45,   46,    4,    4,
00481        18,   18,   47,   48,   49,   50,   51,   61,   52,  111,
00482        62,   53,   65,   54,   55,   92,   56,   93,   76,   66,
00483        83,   62,  109,   77,   77,   94,   67,   78,   85,   84,
00484        65,   51,   86,   52,   59,   57,   53,  109,   54,   55,
00485        95,   56,   76,  110,   67,   65,   67,   77,   77,   96,
00486 
00487       111,   78,   66,  107,   62,  107,   98,   58,  107,   67,
00488        57,   99,   99,   76,   67,  100,   95,  108,   77,   77,
00489       100,   65,   78,  100,   94,   96,  106,  105,   98,   67,
00490        97,  101,   58,   99,   99,   67,  104,  100,  103,  102,
00491        78,   78,  101,   68,   97,   64,   63,   91,   68,   64,
00492        63,   61,   59,   91,   90,   67,   89,   88,   87,   82,
00493        81,   80,   79,   75,   74,   73,   72,   71,   70,   69,
00494        68,   64,   63,   62,   60,   59,  112,    3,  112,  112,
00495       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00496       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00497 
00498       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00499       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00500       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00501       112,  112,  112,  112
00502     } ;
00503 
00504 static yyconst flex_int16_t yy_chk[235] =
00505     {   0,
00506         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00507         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00508         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00509         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00510         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00511         1,    1,    1,    1,    1,    1,    5,    9,    5,  111,
00512         9,    5,   13,    5,    5,   48,    5,   48,   32,   13,
00513        40,   13,  110,   32,   32,   59,   13,   32,   41,   40,
00514        65,   51,   41,   51,   59,    5,   51,   96,   51,   51,
00515        61,   51,   57,   96,   65,   62,   13,   57,   57,   61,
00516 
00517       109,   57,   62,  108,   62,  107,   67,    5,   91,   62,
00518        51,   67,   67,   76,   65,   67,   95,   91,   76,   76,
00519       100,   97,   76,   99,   94,   95,   90,   88,   98,   62,
00520        97,   87,   51,   98,   98,   97,   86,   98,   85,   79,
00521        78,   77,   72,   68,   66,   64,   63,   58,   56,   55,
00522        54,   53,   52,   47,   46,   97,   44,   43,   42,   37,
00523        36,   35,   34,   31,   28,   27,   26,   21,   20,   16,
00524        14,   12,   11,   10,    8,    7,    3,  112,  112,  112,
00525       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00526       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00527 
00528       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00529       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00530       112,  112,  112,  112,  112,  112,  112,  112,  112,  112,
00531       112,  112,  112,  112
00532     } ;
00533 
00534 static yy_state_type yy_last_accepting_state;
00535 static char *yy_last_accepting_cpos;
00536 
00537 extern int yy_flex_debug;
00538 int yy_flex_debug = 0;
00539 
00540 /* The intent behind this definition is that it'll catch
00541  * any uses of REJECT which flex missed.
00542  */
00543 #define REJECT reject_used_but_not_detected
00544 #define yymore() yymore_used_but_not_detected
00545 #define YY_MORE_ADJ 0
00546 #define YY_RESTORE_YY_MORE_OFFSET
00547 char *yytext;
00548 #line 1 "unites.l"
00549 /* coding: iso-8859-1 */
00550 #include <stdlib.h>
00551 #include "unites.h"
00552 /* les nombres */
00553 /*quelques séparateurs particuliers*/
00554 /* les unités de temps hors système */
00555 /* les unités du SI */
00556 /* Handbook of Chemistry & Physics 78, CRC Press 1997, page 1-20 */
00557 /* unités annexes, voir page 1-22 */
00558 /* prefixes sauf milli et téra */
00559 /* Handbook of Chemistry & Physics 78, CRC Press 1997, page 1-21 */
00560 /* notation des exposants */
00561 #line 562 "lex.yy.c"
00562 
00563 #define INITIAL 0
00564 
00565 #ifndef YY_NO_UNISTD_H
00566 /* Special case for "unistd.h", since it is non-ANSI. We include it way
00567  * down here because we want the user's section 1 to have been scanned first.
00568  * The user has a chance to override it with an option.
00569  */
00570 #include <unistd.h>
00571 #endif
00572 
00573 #ifndef YY_EXTRA_TYPE
00574 #define YY_EXTRA_TYPE void *
00575 #endif
00576 
00577 static int yy_init_globals (void );
00578 
00579 /* Accessor methods to globals.
00580    These are made visible to non-reentrant scanners for convenience. */
00581 
00582 int yylex_destroy (void );
00583 
00584 int yyget_debug (void );
00585 
00586 void yyset_debug (int debug_flag  );
00587 
00588 YY_EXTRA_TYPE yyget_extra (void );
00589 
00590 void yyset_extra (YY_EXTRA_TYPE user_defined  );
00591 
00592 FILE *yyget_in (void );
00593 
00594 void yyset_in  (FILE * in_str  );
00595 
00596 FILE *yyget_out (void );
00597 
00598 void yyset_out  (FILE * out_str  );
00599 
00600 int yyget_leng (void );
00601 
00602 char *yyget_text (void );
00603 
00604 int yyget_lineno (void );
00605 
00606 void yyset_lineno (int line_number  );
00607 
00608 /* Macros after this point can all be overridden by user definitions in
00609  * section 1.
00610  */
00611 
00612 #ifndef YY_SKIP_YYWRAP
00613 #ifdef __cplusplus
00614 extern "C" int yywrap (void );
00615 #else
00616 extern int yywrap (void );
00617 #endif
00618 #endif
00619 
00620     static void yyunput (int c,char *buf_ptr  );
00621     
00622 #ifndef yytext_ptr
00623 static void yy_flex_strncpy (char *,yyconst char *,int );
00624 #endif
00625 
00626 #ifdef YY_NEED_STRLEN
00627 static int yy_flex_strlen (yyconst char * );
00628 #endif
00629 
00630 #ifndef YY_NO_INPUT
00631 
00632 #ifdef __cplusplus
00633 static int yyinput (void );
00634 #else
00635 static int input (void );
00636 #endif
00637 
00638 #endif
00639 
00640 /* Amount of stuff to slurp up with each read. */
00641 #ifndef YY_READ_BUF_SIZE
00642 #ifdef __ia64__
00643 /* On IA-64, the buffer size is 16k, not 8k */
00644 #define YY_READ_BUF_SIZE 16384
00645 #else
00646 #define YY_READ_BUF_SIZE 8192
00647 #endif /* __ia64__ */
00648 #endif
00649 
00650 /* Copy whatever the last rule matched to the standard output. */
00651 #ifndef ECHO
00652 /* This used to be an fputs(), but since the string might contain NUL's,
00653  * we now use fwrite().
00654  */
00655 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
00656 #endif
00657 
00658 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00659  * is returned in "result".
00660  */
00661 #ifndef YY_INPUT
00662 #define YY_INPUT(buf,result,max_size) \
00663        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
00664               { \
00665               int c = '*'; \
00666               size_t n; \
00667               for ( n = 0; n < max_size && \
00668                           (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00669                      buf[n] = (char) c; \
00670               if ( c == '\n' ) \
00671                      buf[n++] = (char) c; \
00672               if ( c == EOF && ferror( yyin ) ) \
00673                      YY_FATAL_ERROR( "input in flex scanner failed" ); \
00674               result = n; \
00675               } \
00676        else \
00677               { \
00678               errno=0; \
00679               while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
00680                      { \
00681                      if( errno != EINTR) \
00682                             { \
00683                             YY_FATAL_ERROR( "input in flex scanner failed" ); \
00684                             break; \
00685                             } \
00686                      errno=0; \
00687                      clearerr(yyin); \
00688                      } \
00689               }\
00690 \
00691 
00692 #endif
00693 
00694 /* No semi-colon after return; correct usage is to write "yyterminate();" -
00695  * we don't want an extra ';' after the "return" because that will cause
00696  * some compilers to complain about unreachable statements.
00697  */
00698 #ifndef yyterminate
00699 #define yyterminate() return YY_NULL
00700 #endif
00701 
00702 /* Number of entries by which start-condition stack grows. */
00703 #ifndef YY_START_STACK_INCR
00704 #define YY_START_STACK_INCR 25
00705 #endif
00706 
00707 /* Report a fatal error. */
00708 #ifndef YY_FATAL_ERROR
00709 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
00710 #endif
00711 
00712 /* end tables serialization structures and prototypes */
00713 
00714 /* Default declaration of generated scanner - a define so the user can
00715  * easily add parameters.
00716  */
00717 #ifndef YY_DECL
00718 #define YY_DECL_IS_OURS 1
00719 
00720 extern int yylex (void);
00721 
00722 #define YY_DECL int yylex (void)
00723 #endif /* !YY_DECL */
00724 
00725 /* Code executed at the beginning of each rule, after yytext and yyleng
00726  * have been set up.
00727  */
00728 #ifndef YY_USER_ACTION
00729 #define YY_USER_ACTION
00730 #endif
00731 
00732 /* Code executed at the end of each rule. */
00733 #ifndef YY_BREAK
00734 #define YY_BREAK break;
00735 #endif
00736 
00737 #define YY_RULE_SETUP \
00738        YY_USER_ACTION
00739 
00742 YY_DECL
00743 {
00744        register yy_state_type yy_current_state;
00745        register char *yy_cp, *yy_bp;
00746        register int yy_act;
00747     
00748 #line 83 "unites.l"
00749 
00750 
00751 
00752 #line 753 "lex.yy.c"
00753 
00754        if ( !(yy_init) )
00755               {
00756               (yy_init) = 1;
00757 
00758 #ifdef YY_USER_INIT
00759               YY_USER_INIT;
00760 #endif
00761 
00762               if ( ! (yy_start) )
00763                      (yy_start) = 1;      /* first start state */
00764 
00765               if ( ! yyin )
00766                      yyin = stdin;
00767 
00768               if ( ! yyout )
00769                      yyout = stdout;
00770 
00771               if ( ! YY_CURRENT_BUFFER ) {
00772                      yyensure_buffer_stack ();
00773                      YY_CURRENT_BUFFER_LVALUE =
00774                             yy_create_buffer(yyin,YY_BUF_SIZE );
00775               }
00776 
00777               yy_load_buffer_state( );
00778               }
00779 
00780        while ( 1 )          /* loops until end-of-file is reached */
00781               {
00782               yy_cp = (yy_c_buf_p);
00783 
00784               /* Support of yytext. */
00785               *yy_cp = (yy_hold_char);
00786 
00787               /* yy_bp points to the position in yy_ch_buf of the start of
00788                * the current run.
00789                */
00790               yy_bp = yy_cp;
00791 
00792               yy_current_state = (yy_start);
00793 yy_match:
00794               do
00795                      {
00796                      register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00797                      if ( yy_accept[yy_current_state] )
00798                             {
00799                             (yy_last_accepting_state) = yy_current_state;
00800                             (yy_last_accepting_cpos) = yy_cp;
00801                             }
00802                      while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00803                             {
00804                             yy_current_state = (int) yy_def[yy_current_state];
00805                             if ( yy_current_state >= 113 )
00806                                    yy_c = yy_meta[(unsigned int) yy_c];
00807                             }
00808                      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00809                      ++yy_cp;
00810                      }
00811               while ( yy_base[yy_current_state] != 178 );
00812 
00813 yy_find_action:
00814               yy_act = yy_accept[yy_current_state];
00815               if ( yy_act == 0 )
00816                      { /* have to back up */
00817                      yy_cp = (yy_last_accepting_cpos);
00818                      yy_current_state = (yy_last_accepting_state);
00819                      yy_act = yy_accept[yy_current_state];
00820                      }
00821 
00822               YY_DO_BEFORE_ACTION;
00823 
00824 do_action:    /* This label is used only to access EOF actions. */
00825 
00826               switch ( yy_act )
00827        { /* beginning of action switch */
00828                      case 0: /* must back up */
00829                      /* undo the effects of YY_DO_BEFORE_ACTION */
00830                      *yy_cp = (yy_hold_char);
00831                      yy_cp = (yy_last_accepting_cpos);
00832                      yy_current_state = (yy_last_accepting_state);
00833                      goto yy_find_action;
00834 
00835 case 1:
00836 YY_RULE_SETUP
00837 #line 86 "unites.l"
00838 { val_real = atof1(yytext); yylval.v=strdup(yytext); pos+=yyleng; return REAL;}
00839        YY_BREAK
00840 case 2:
00841 YY_RULE_SETUP
00842 #line 87 "unites.l"
00843 { pos+=yyleng; return Uh;}
00844        YY_BREAK
00845 case 3:
00846 YY_RULE_SETUP
00847 #line 88 "unites.l"
00848 { pos+=yyleng; return Umin;}
00849        YY_BREAK
00850 case 4:
00851 YY_RULE_SETUP
00852 #line 89 "unites.l"
00853 { pos+=yyleng; return Um;}
00854        YY_BREAK
00855 case 5:
00856 YY_RULE_SETUP
00857 #line 90 "unites.l"
00858 {pos+=yyleng; return Uare;}
00859        YY_BREAK
00860 case 6:
00861 YY_RULE_SETUP
00862 #line 91 "unites.l"
00863 { pos+=yyleng; return Ug;}
00864        YY_BREAK
00865 case 7:
00866 YY_RULE_SETUP
00867 #line 92 "unites.l"
00868 { pos+=yyleng; return Us;}
00869        YY_BREAK
00870 case 8:
00871 YY_RULE_SETUP
00872 #line 93 "unites.l"
00873 { pos+=yyleng; return UA;}
00874        YY_BREAK
00875 case 9:
00876 YY_RULE_SETUP
00877 #line 94 "unites.l"
00878 { pos+=yyleng; return UK;}
00879        YY_BREAK
00880 case 10:
00881 YY_RULE_SETUP
00882 #line 95 "unites.l"
00883 { pos+=yyleng; return Umol;}
00884        YY_BREAK
00885 case 11:
00886 YY_RULE_SETUP
00887 #line 96 "unites.l"
00888 { pos+=yyleng; return Ucd;}
00889        YY_BREAK
00890 case 12:
00891 YY_RULE_SETUP
00892 #line 97 "unites.l"
00893 { pos+=yyleng; return UHz;}
00894        YY_BREAK
00895 case 13:
00896 YY_RULE_SETUP
00897 #line 98 "unites.l"
00898 { pos+=yyleng; return UN;}
00899        YY_BREAK
00900 case 14:
00901 YY_RULE_SETUP
00902 #line 99 "unites.l"
00903 { pos+=yyleng; return UPa;}
00904        YY_BREAK
00905 case 15:
00906 YY_RULE_SETUP
00907 #line 100 "unites.l"
00908 { pos+=yyleng; return UJ;}
00909        YY_BREAK
00910 case 16:
00911 YY_RULE_SETUP
00912 #line 101 "unites.l"
00913 { pos+=yyleng; return UW;}
00914        YY_BREAK
00915 case 17:
00916 YY_RULE_SETUP
00917 #line 102 "unites.l"
00918 { pos+=yyleng; return UC;}
00919        YY_BREAK
00920 case 18:
00921 YY_RULE_SETUP
00922 #line 103 "unites.l"
00923 { pos+=yyleng; return UV;}
00924        YY_BREAK
00925 case 19:
00926 YY_RULE_SETUP
00927 #line 104 "unites.l"
00928 { pos+=yyleng; return Uohm;}
00929        YY_BREAK
00930 case 20:
00931 YY_RULE_SETUP
00932 #line 105 "unites.l"
00933 { pos+=yyleng; return US;}
00934        YY_BREAK
00935 case 21:
00936 YY_RULE_SETUP
00937 #line 106 "unites.l"
00938 { pos+=yyleng; return UF;}
00939        YY_BREAK
00940 case 22:
00941 YY_RULE_SETUP
00942 #line 107 "unites.l"
00943 { pos+=yyleng; return UT;}
00944        YY_BREAK
00945 case 23:
00946 YY_RULE_SETUP
00947 #line 108 "unites.l"
00948 { pos+=yyleng; return UWb;}
00949        YY_BREAK
00950 case 24:
00951 YY_RULE_SETUP
00952 #line 109 "unites.l"
00953 { pos+=yyleng; return UH;}
00954        YY_BREAK
00955 case 25:
00956 YY_RULE_SETUP
00957 #line 110 "unites.l"
00958 { pos+=yyleng; return Ulm;}
00959        YY_BREAK
00960 case 26:
00961 YY_RULE_SETUP
00962 #line 111 "unites.l"
00963 { pos+=yyleng; return Ulx;}
00964        YY_BREAK
00965 case 27:
00966 YY_RULE_SETUP
00967 #line 112 "unites.l"
00968 { pos+=yyleng; return UBq;}
00969        YY_BREAK
00970 case 28:
00971 YY_RULE_SETUP
00972 #line 113 "unites.l"
00973 { pos+=yyleng; return UGy;}
00974        YY_BREAK
00975 case 29:
00976 YY_RULE_SETUP
00977 #line 114 "unites.l"
00978 { pos+=yyleng; return USv;}
00979        YY_BREAK
00980 case 30:
00981 YY_RULE_SETUP
00982 #line 115 "unites.l"
00983 { pos+=yyleng; return Urad;}
00984        YY_BREAK
00985 case 31:
00986 YY_RULE_SETUP
00987 #line 116 "unites.l"
00988 { pos+=yyleng; return Usr;}
00989        YY_BREAK
00990 case 32:
00991 YY_RULE_SETUP
00992 #line 117 "unites.l"
00993 { pos+=yyleng; while (!index("-0123456789", *yytext)) yytext++; return PUIS;}
00994        YY_BREAK
00995 case 33:
00996 YY_RULE_SETUP
00997 #line 118 "unites.l"
00998 { yytext="2"; pos+=yyleng; return PUIS;}
00999        YY_BREAK
01000 case 34:
01001 YY_RULE_SETUP
01002 #line 119 "unites.l"
01003 { yytext="3"; pos+=yyleng; return PUIS;}
01004        YY_BREAK
01005 case 35:
01006 YY_RULE_SETUP
01007 #line 120 "unites.l"
01008 { pos+=yyleng; return PP;}
01009        YY_BREAK
01010 case 36:
01011 YY_RULE_SETUP
01012 #line 121 "unites.l"
01013 { pos+=yyleng; return POINT;}
01014        YY_BREAK
01015 case 37:
01016 YY_RULE_SETUP
01017 #line 122 "unites.l"
01018 { pos+=yyleng; return BARRE;}
01019        YY_BREAK
01020 case 38:
01021 YY_RULE_SETUP
01022 #line 123 "unites.l"
01023 {pos+=yyleng; return Uda;}
01024        YY_BREAK
01025 case 39:
01026 YY_RULE_SETUP
01027 #line 124 "unites.l"
01028 {pos+=yyleng; return Uma;}
01029        YY_BREAK
01030 case 40:
01031 YY_RULE_SETUP
01032 #line 125 "unites.l"
01033 {pos+=yyleng; return Usa;}
01034        YY_BREAK
01035 case 41:
01036 YY_RULE_SETUP
01037 #line 126 "unites.l"
01038 {pos+=yyleng; return Uangs;}
01039        YY_BREAK
01040 case 42:
01041 YY_RULE_SETUP
01042 #line 127 "unites.l"
01043 {pos+=yyleng; return Ubarn;}
01044        YY_BREAK
01045 case 43:
01046 YY_RULE_SETUP
01047 #line 128 "unites.l"
01048 { pos+=yyleng; return Ul;}
01049        YY_BREAK
01050 case 44:
01051 YY_RULE_SETUP
01052 #line 129 "unites.l"
01053 {pos+=yyleng; return Ut;}
01054        YY_BREAK
01055 case 45:
01056 YY_RULE_SETUP
01057 #line 130 "unites.l"
01058 {pos+=yyleng; return Ubar;}
01059        YY_BREAK
01060 case 46:
01061 YY_RULE_SETUP
01062 #line 131 "unites.l"
01063 {pos+=yyleng; return UeV;}
01064        YY_BREAK
01065 case 47:
01066 YY_RULE_SETUP
01067 #line 132 "unites.l"
01068 {pos+=yyleng; return Uuam;}
01069        YY_BREAK
01070 case 48:
01071 YY_RULE_SETUP
01072 #line 133 "unites.l"
01073 { pos+=yyleng; return SPC;}
01074        YY_BREAK
01075 case 49:
01076 YY_RULE_SETUP
01077 #line 134 "unites.l"
01078 {pos+=yyleng; val_int=atoi(strchr(yytext,'#')+1); return Signif;}
01079        YY_BREAK
01080 case 50:
01081 YY_RULE_SETUP
01082 #line 135 "unites.l"
01083 {pos+=yyleng; val_int=atoi(strchr(yytext,'~')+1); return PlusminPC;}
01084        YY_BREAK
01085 case 51:
01086 YY_RULE_SETUP
01087 #line 136 "unites.l"
01088 {pos+=yyleng; val_int=atoi(strchr(yytext,'+')+2); return PlusminPC;}
01089        YY_BREAK
01090 case 52:
01091 YY_RULE_SETUP
01092 #line 137 "unites.l"
01093 {pos+=yyleng; return COLON;}
01094        YY_BREAK
01095 case 53:
01096 YY_RULE_SETUP
01097 #line 139 "unites.l"
01098 pos+=yyleng;
01099        YY_BREAK
01100 case 54:
01101 /* rule 54 can match eol */
01102 YY_RULE_SETUP
01103 #line 140 "unites.l"
01104 pos+=yyleng;
01105        YY_BREAK
01106 case 55:
01107 YY_RULE_SETUP
01108 #line 141 "unites.l"
01109 ECHO;
01110        YY_BREAK
01111 #line 1112 "lex.yy.c"
01112 case YY_STATE_EOF(INITIAL):
01113        yyterminate();
01114 
01115        case YY_END_OF_BUFFER:
01116               {
01117               /* Amount of text matched not including the EOB char. */
01118               int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
01119 
01120               /* Undo the effects of YY_DO_BEFORE_ACTION. */
01121               *yy_cp = (yy_hold_char);
01122               YY_RESTORE_YY_MORE_OFFSET
01123 
01124               if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
01125                      {
01126                      /* We're scanning a new file or input source.  It's
01127                       * possible that this happened because the user
01128                       * just pointed yyin at a new source and called
01129                       * yylex().  If so, then we have to assure
01130                       * consistency between YY_CURRENT_BUFFER and our
01131                       * globals.  Here is the right place to do so, because
01132                       * this is the first action (other than possibly a
01133                       * back-up) that will match for the new input source.
01134                       */
01135                      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01136                      YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
01137                      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
01138                      }
01139 
01140               /* Note that here we test for yy_c_buf_p "<=" to the position
01141                * of the first EOB in the buffer, since yy_c_buf_p will
01142                * already have been incremented past the NUL character
01143                * (since all states make transitions on EOB to the
01144                * end-of-buffer state).  Contrast this with the test
01145                * in input().
01146                */
01147               if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
01148                      { /* This was really a NUL. */
01149                      yy_state_type yy_next_state;
01150 
01151                      (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
01152 
01153                      yy_current_state = yy_get_previous_state(  );
01154 
01155                      /* Okay, we're now positioned to make the NUL
01156                       * transition.  We couldn't have
01157                       * yy_get_previous_state() go ahead and do it
01158                       * for us because it doesn't know how to deal
01159                       * with the possibility of jamming (and we don't
01160                       * want to build jamming into it because then it
01161                       * will run more slowly).
01162                       */
01163 
01164                      yy_next_state = yy_try_NUL_trans( yy_current_state );
01165 
01166                      yy_bp = (yytext_ptr) + YY_MORE_ADJ;
01167 
01168                      if ( yy_next_state )
01169                             {
01170                             /* Consume the NUL. */
01171                             yy_cp = ++(yy_c_buf_p);
01172                             yy_current_state = yy_next_state;
01173                             goto yy_match;
01174                             }
01175 
01176                      else
01177                             {
01178                             yy_cp = (yy_c_buf_p);
01179                             goto yy_find_action;
01180                             }
01181                      }
01182 
01183               else switch ( yy_get_next_buffer(  ) )
01184                      {
01185                      case EOB_ACT_END_OF_FILE:
01186                             {
01187                             (yy_did_buffer_switch_on_eof) = 0;
01188 
01189                             if ( yywrap( ) )
01190                                    {
01191                                    /* Note: because we've taken care in
01192                                     * yy_get_next_buffer() to have set up
01193                                     * yytext, we can now set up
01194                                     * yy_c_buf_p so that if some total
01195                                     * hoser (like flex itself) wants to
01196                                     * call the scanner after we return the
01197                                     * YY_NULL, it'll still work - another
01198                                     * YY_NULL will get returned.
01199                                     */
01200                                    (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
01201 
01202                                    yy_act = YY_STATE_EOF(YY_START);
01203                                    goto do_action;
01204                                    }
01205 
01206                             else
01207                                    {
01208                                    if ( ! (yy_did_buffer_switch_on_eof) )
01209                                           YY_NEW_FILE;
01210                                    }
01211                             break;
01212                             }
01213 
01214                      case EOB_ACT_CONTINUE_SCAN:
01215                             (yy_c_buf_p) =
01216                                    (yytext_ptr) + yy_amount_of_matched_text;
01217 
01218                             yy_current_state = yy_get_previous_state(  );
01219 
01220                             yy_cp = (yy_c_buf_p);
01221                             yy_bp = (yytext_ptr) + YY_MORE_ADJ;
01222                             goto yy_match;
01223 
01224                      case EOB_ACT_LAST_MATCH:
01225                             (yy_c_buf_p) =
01226                             &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
01227 
01228                             yy_current_state = yy_get_previous_state(  );
01229 
01230                             yy_cp = (yy_c_buf_p);
01231                             yy_bp = (yytext_ptr) + YY_MORE_ADJ;
01232                             goto yy_find_action;
01233                      }
01234               break;
01235               }
01236 
01237        default:
01238               YY_FATAL_ERROR(
01239                      "fatal flex scanner internal error--no action found" );
01240        } /* end of action switch */
01241               } /* end of scanning one token */
01242 } /* end of yylex */
01243 
01244 /* yy_get_next_buffer - try to read in a new buffer
01245  *
01246  * Returns a code representing an action:
01247  *     EOB_ACT_LAST_MATCH -
01248  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
01249  *     EOB_ACT_END_OF_FILE - end of file
01250  */
01251 static int yy_get_next_buffer (void)
01252 {
01253        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
01254        register char *source = (yytext_ptr);
01255        register int number_to_move, i;
01256        int ret_val;
01257 
01258        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
01259               YY_FATAL_ERROR(
01260               "fatal flex scanner internal error--end of buffer missed" );
01261 
01262        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
01263               { /* Don't try to fill the buffer, so this is an EOF. */
01264               if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
01265                      {
01266                      /* We matched a single character, the EOB, so
01267                       * treat this as a final EOF.
01268                       */
01269                      return EOB_ACT_END_OF_FILE;
01270                      }
01271 
01272               else
01273                      {
01274                      /* We matched some text prior to the EOB, first
01275                       * process it.
01276                       */
01277                      return EOB_ACT_LAST_MATCH;
01278                      }
01279               }
01280 
01281        /* Try to read more data. */
01282 
01283        /* First move last chars to start of buffer. */
01284        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
01285 
01286        for ( i = 0; i < number_to_move; ++i )
01287               *(dest++) = *(source++);
01288 
01289        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01290               /* don't do the read, it's not guaranteed to return an EOF,
01291                * just force an EOF
01292                */
01293               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
01294 
01295        else
01296               {
01297                      int num_to_read =
01298                      YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
01299 
01300               while ( num_to_read <= 0 )
01301                      { /* Not enough room in the buffer - grow it. */
01302 
01303                      /* just a shorter name for the current buffer */
01304                      YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
01305 
01306                      int yy_c_buf_p_offset =
01307                             (int) ((yy_c_buf_p) - b->yy_ch_buf);
01308 
01309                      if ( b->yy_is_our_buffer )
01310                             {
01311                             int new_size = b->yy_buf_size * 2;
01312 
01313                             if ( new_size <= 0 )
01314                                    b->yy_buf_size += b->yy_buf_size / 8;
01315                             else
01316                                    b->yy_buf_size *= 2;
01317 
01318                             b->yy_ch_buf = (char *)
01319                                    /* Include room in for 2 EOB chars. */
01320                                    yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
01321                             }
01322                      else
01323                             /* Can't grow it, we don't own it. */
01324                             b->yy_ch_buf = 0;
01325 
01326                      if ( ! b->yy_ch_buf )
01327                             YY_FATAL_ERROR(
01328                             "fatal error - scanner input buffer overflow" );
01329 
01330                      (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
01331 
01332                      num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
01333                                           number_to_move - 1;
01334 
01335                      }
01336 
01337               if ( num_to_read > YY_READ_BUF_SIZE )
01338                      num_to_read = YY_READ_BUF_SIZE;
01339 
01340               /* Read in more data. */
01341               YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
01342                      (yy_n_chars), (size_t) num_to_read );
01343 
01344               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
01345               }
01346 
01347        if ( (yy_n_chars) == 0 )
01348               {
01349               if ( number_to_move == YY_MORE_ADJ )
01350                      {
01351                      ret_val = EOB_ACT_END_OF_FILE;
01352                      yyrestart(yyin  );
01353                      }
01354 
01355               else
01356                      {
01357                      ret_val = EOB_ACT_LAST_MATCH;
01358                      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
01359                             YY_BUFFER_EOF_PENDING;
01360                      }
01361               }
01362 
01363        else
01364               ret_val = EOB_ACT_CONTINUE_SCAN;
01365 
01366        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
01367               /* Extend the array by 50%, plus the number we really need. */
01368               yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
01369               YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
01370               if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
01371                      YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
01372        }
01373 
01374        (yy_n_chars) += number_to_move;
01375        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
01376        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
01377 
01378        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
01379 
01380        return ret_val;
01381 }
01382 
01383 /* yy_get_previous_state - get the state just before the EOB char was reached */
01384 
01385     static yy_state_type yy_get_previous_state (void)
01386 {
01387        register yy_state_type yy_current_state;
01388        register char *yy_cp;
01389     
01390        yy_current_state = (yy_start);
01391 
01392        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
01393               {
01394               register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01395               if ( yy_accept[yy_current_state] )
01396                      {
01397                      (yy_last_accepting_state) = yy_current_state;
01398                      (yy_last_accepting_cpos) = yy_cp;
01399                      }
01400               while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01401                      {
01402                      yy_current_state = (int) yy_def[yy_current_state];
01403                      if ( yy_current_state >= 113 )
01404                             yy_c = yy_meta[(unsigned int) yy_c];
01405                      }
01406               yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01407               }
01408 
01409        return yy_current_state;
01410 }
01411 
01412 /* yy_try_NUL_trans - try to make a transition on the NUL character
01413  *
01414  * synopsis
01415  *     next_state = yy_try_NUL_trans( current_state );
01416  */
01417     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
01418 {
01419        register int yy_is_jam;
01420        register char *yy_cp = (yy_c_buf_p);
01421 
01422        register YY_CHAR yy_c = 1;
01423        if ( yy_accept[yy_current_state] )
01424               {
01425               (yy_last_accepting_state) = yy_current_state;
01426               (yy_last_accepting_cpos) = yy_cp;
01427               }
01428        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01429               {
01430               yy_current_state = (int) yy_def[yy_current_state];
01431               if ( yy_current_state >= 113 )
01432                      yy_c = yy_meta[(unsigned int) yy_c];
01433               }
01434        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01435        yy_is_jam = (yy_current_state == 112);
01436 
01437        return yy_is_jam ? 0 : yy_current_state;
01438 }
01439 
01440     static void yyunput (int c, register char * yy_bp )
01441 {
01442        register char *yy_cp;
01443     
01444     yy_cp = (yy_c_buf_p);
01445 
01446        /* undo effects of setting up yytext */
01447        *yy_cp = (yy_hold_char);
01448 
01449        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
01450               { /* need to shift things up to make room */
01451               /* +2 for EOB chars. */
01452               register int number_to_move = (yy_n_chars) + 2;
01453               register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
01454                                    YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
01455               register char *source =
01456                             &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
01457 
01458               while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
01459                      *--dest = *--source;
01460 
01461               yy_cp += (int) (dest - source);
01462               yy_bp += (int) (dest - source);
01463               YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
01464                      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
01465 
01466               if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
01467                      YY_FATAL_ERROR( "flex scanner push-back overflow" );
01468               }
01469 
01470        *--yy_cp = (char) c;
01471 
01472        (yytext_ptr) = yy_bp;
01473        (yy_hold_char) = *yy_cp;
01474        (yy_c_buf_p) = yy_cp;
01475 }
01476 
01477 #ifndef YY_NO_INPUT
01478 #ifdef __cplusplus
01479     static int yyinput (void)
01480 #else
01481     static int input  (void)
01482 #endif
01483 
01484 {
01485        int c;
01486     
01487        *(yy_c_buf_p) = (yy_hold_char);
01488 
01489        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
01490               {
01491               /* yy_c_buf_p now points to the character we want to return.
01492                * If this occurs *before* the EOB characters, then it's a
01493                * valid NUL; if not, then we've hit the end of the buffer.
01494                */
01495               if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
01496                      /* This was really a NUL. */
01497                      *(yy_c_buf_p) = '\0';
01498 
01499               else
01500                      { /* need more input */
01501                      int offset = (yy_c_buf_p) - (yytext_ptr);
01502                      ++(yy_c_buf_p);
01503 
01504                      switch ( yy_get_next_buffer(  ) )
01505                             {
01506                             case EOB_ACT_LAST_MATCH:
01507                                    /* This happens because yy_g_n_b()
01508                                     * sees that we've accumulated a
01509                                     * token and flags that we need to
01510                                     * try matching the token before
01511                                     * proceeding.  But for input(),
01512                                     * there's no matching to consider.
01513                                     * So convert the EOB_ACT_LAST_MATCH
01514                                     * to EOB_ACT_END_OF_FILE.
01515                                     */
01516 
01517                                    /* Reset buffer status. */
01518                                    yyrestart(yyin );
01519 
01520                                    /*FALLTHROUGH*/
01521 
01522                             case EOB_ACT_END_OF_FILE:
01523                                    {
01524                                    if ( yywrap( ) )
01525                                           return EOF;
01526 
01527                                    if ( ! (yy_did_buffer_switch_on_eof) )
01528                                           YY_NEW_FILE;
01529 #ifdef __cplusplus
01530                                    return yyinput();
01531 #else
01532                                    return input();
01533 #endif
01534                                    }
01535 
01536                             case EOB_ACT_CONTINUE_SCAN:
01537                                    (yy_c_buf_p) = (yytext_ptr) + offset;
01538                                    break;
01539                             }
01540                      }
01541               }
01542 
01543        c = *(unsigned char *) (yy_c_buf_p);      /* cast for 8-bit char's */
01544        *(yy_c_buf_p) = '\0';       /* preserve yytext */
01545        (yy_hold_char) = *++(yy_c_buf_p);
01546 
01547        return c;
01548 }
01549 #endif /* ifndef YY_NO_INPUT */
01550 
01556     void yyrestart  (FILE * input_file )
01557 {
01558     
01559        if ( ! YY_CURRENT_BUFFER ){
01560         yyensure_buffer_stack ();
01561               YY_CURRENT_BUFFER_LVALUE =
01562             yy_create_buffer(yyin,YY_BUF_SIZE );
01563        }
01564 
01565        yy_init_buffer(YY_CURRENT_BUFFER,input_file );
01566        yy_load_buffer_state( );
01567 }
01568 
01573     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
01574 {
01575     
01576        /* TODO. We should be able to replace this entire function body
01577         * with
01578         *            yypop_buffer_state();
01579         *            yypush_buffer_state(new_buffer);
01580      */
01581        yyensure_buffer_stack ();
01582        if ( YY_CURRENT_BUFFER == new_buffer )
01583               return;
01584 
01585        if ( YY_CURRENT_BUFFER )
01586               {
01587               /* Flush out information for old buffer. */
01588               *(yy_c_buf_p) = (yy_hold_char);
01589               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
01590               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
01591               }
01592 
01593        YY_CURRENT_BUFFER_LVALUE = new_buffer;
01594        yy_load_buffer_state( );
01595 
01596        /* We don't actually know whether we did this switch during
01597         * EOF (yywrap()) processing, but the only time this flag
01598         * is looked at is after yywrap() is called, so it's safe
01599         * to go ahead and always set it.
01600         */
01601        (yy_did_buffer_switch_on_eof) = 1;
01602 }
01603 
01604 static void yy_load_buffer_state  (void)
01605 {
01606        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01607        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
01608        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
01609        (yy_hold_char) = *(yy_c_buf_p);
01610 }
01611 
01618     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
01619 {
01620        YY_BUFFER_STATE b;
01621     
01622        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
01623        if ( ! b )
01624               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01625 
01626        b->yy_buf_size = size;
01627 
01628        /* yy_ch_buf has to be 2 characters longer than the size given because
01629         * we need to put in 2 end-of-buffer characters.
01630         */
01631        b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
01632        if ( ! b->yy_ch_buf )
01633               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01634 
01635        b->yy_is_our_buffer = 1;
01636 
01637        yy_init_buffer(b,file );
01638 
01639        return b;
01640 }
01641 
01646     void yy_delete_buffer (YY_BUFFER_STATE  b )
01647 {
01648     
01649        if ( ! b )
01650               return;
01651 
01652        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
01653               YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
01654 
01655        if ( b->yy_is_our_buffer )
01656               yyfree((void *) b->yy_ch_buf  );
01657 
01658        yyfree((void *) b  );
01659 }
01660 
01661 #ifndef __cplusplus
01662 extern int isatty (int );
01663 #endif /* __cplusplus */
01664     
01665 /* Initializes or reinitializes a buffer.
01666  * This function is sometimes called more than once on the same buffer,
01667  * such as during a yyrestart() or at EOF.
01668  */
01669     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
01670 
01671 {
01672        int oerrno = errno;
01673     
01674        yy_flush_buffer(b );
01675 
01676        b->yy_input_file = file;
01677        b->yy_fill_buffer = 1;
01678 
01679     /* If b is the current buffer, then yy_init_buffer was _probably_
01680      * called from yyrestart() or through yy_get_next_buffer.
01681      * In that case, we don't want to reset the lineno or column.
01682      */
01683     if (b != YY_CURRENT_BUFFER){
01684         b->yy_bs_lineno = 1;
01685         b->yy_bs_column = 0;
01686     }
01687 
01688         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01689     
01690        errno = oerrno;
01691 }
01692 
01697     void yy_flush_buffer (YY_BUFFER_STATE  b )
01698 {
01699        if ( ! b )
01700               return;
01701 
01702        b->yy_n_chars = 0;
01703 
01704        /* We always need two end-of-buffer characters.  The first causes
01705         * a transition to the end-of-buffer state.  The second causes
01706         * a jam in that state.
01707         */
01708        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01709        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01710 
01711        b->yy_buf_pos = &b->yy_ch_buf[0];
01712 
01713        b->yy_at_bol = 1;
01714        b->yy_buffer_status = YY_BUFFER_NEW;
01715 
01716        if ( b == YY_CURRENT_BUFFER )
01717               yy_load_buffer_state( );
01718 }
01719 
01726 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
01727 {
01728        if (new_buffer == NULL)
01729               return;
01730 
01731        yyensure_buffer_stack();
01732 
01733        /* This block is copied from yy_switch_to_buffer. */
01734        if ( YY_CURRENT_BUFFER )
01735               {
01736               /* Flush out information for old buffer. */
01737               *(yy_c_buf_p) = (yy_hold_char);
01738               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
01739               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
01740               }
01741 
01742        /* Only push if top exists. Otherwise, replace top. */
01743        if (YY_CURRENT_BUFFER)
01744               (yy_buffer_stack_top)++;
01745        YY_CURRENT_BUFFER_LVALUE = new_buffer;
01746 
01747        /* copied from yy_switch_to_buffer. */
01748        yy_load_buffer_state( );
01749        (yy_did_buffer_switch_on_eof) = 1;
01750 }
01751 
01756 void yypop_buffer_state (void)
01757 {
01758        if (!YY_CURRENT_BUFFER)
01759               return;
01760 
01761        yy_delete_buffer(YY_CURRENT_BUFFER );
01762        YY_CURRENT_BUFFER_LVALUE = NULL;
01763        if ((yy_buffer_stack_top) > 0)
01764               --(yy_buffer_stack_top);
01765 
01766        if (YY_CURRENT_BUFFER) {
01767               yy_load_buffer_state( );
01768               (yy_did_buffer_switch_on_eof) = 1;
01769        }
01770 }
01771 
01772 /* Allocates the stack if it does not exist.
01773  *  Guarantees space for at least one push.
01774  */
01775 static void yyensure_buffer_stack (void)
01776 {
01777        int num_to_alloc;
01778     
01779        if (!(yy_buffer_stack)) {
01780 
01781               /* First allocation is just for 2 elements, since we don't know if this
01782                * scanner will even need a stack. We use 2 instead of 1 to avoid an
01783                * immediate realloc on the next call.
01784          */
01785               num_to_alloc = 1;
01786               (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
01787                                                         (num_to_alloc * sizeof(struct yy_buffer_state*)
01788                                                         );
01789               if ( ! (yy_buffer_stack) )
01790                      YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
01791                                                           
01792               memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
01793                             
01794               (yy_buffer_stack_max) = num_to_alloc;
01795               (yy_buffer_stack_top) = 0;
01796               return;
01797        }
01798 
01799        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
01800 
01801               /* Increase the buffer to prepare for a possible push. */
01802               int grow_size = 8 /* arbitrary grow size */;
01803 
01804               num_to_alloc = (yy_buffer_stack_max) + grow_size;
01805               (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
01806                                                         ((yy_buffer_stack),
01807                                                         num_to_alloc * sizeof(struct yy_buffer_state*)
01808                                                         );
01809               if ( ! (yy_buffer_stack) )
01810                      YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
01811 
01812               /* zero only the new slots.*/
01813               memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
01814               (yy_buffer_stack_max) = num_to_alloc;
01815        }
01816 }
01817 
01824 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
01825 {
01826        YY_BUFFER_STATE b;
01827     
01828        if ( size < 2 ||
01829             base[size-2] != YY_END_OF_BUFFER_CHAR ||
01830             base[size-1] != YY_END_OF_BUFFER_CHAR )
01831               /* They forgot to leave room for the EOB's. */
01832               return 0;
01833 
01834        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
01835        if ( ! b )
01836               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
01837 
01838        b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
01839        b->yy_buf_pos = b->yy_ch_buf = base;
01840        b->yy_is_our_buffer = 0;
01841        b->yy_input_file = 0;
01842        b->yy_n_chars = b->yy_buf_size;
01843        b->yy_is_interactive = 0;
01844        b->yy_at_bol = 1;
01845        b->yy_fill_buffer = 0;
01846        b->yy_buffer_status = YY_BUFFER_NEW;
01847 
01848        yy_switch_to_buffer(b  );
01849 
01850        return b;
01851 }
01852 
01861 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
01862 {
01863     
01864        return yy_scan_bytes(yystr,strlen(yystr) );
01865 }
01866 
01874 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
01875 {
01876        YY_BUFFER_STATE b;
01877        char *buf;
01878        yy_size_t n;
01879        int i;
01880     
01881        /* Get memory for full buffer, including space for trailing EOB's. */
01882        n = _yybytes_len + 2;
01883        buf = (char *) yyalloc(n  );
01884        if ( ! buf )
01885               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
01886 
01887        for ( i = 0; i < _yybytes_len; ++i )
01888               buf[i] = yybytes[i];
01889 
01890        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
01891 
01892        b = yy_scan_buffer(buf,n );
01893        if ( ! b )
01894               YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
01895 
01896        /* It's okay to grow etc. this buffer, and we should throw it
01897         * away when we're done.
01898         */
01899        b->yy_is_our_buffer = 1;
01900 
01901        return b;
01902 }
01903 
01904 #ifndef YY_EXIT_FAILURE
01905 #define YY_EXIT_FAILURE 2
01906 #endif
01907 
01908 static void yy_fatal_error (yyconst char* msg )
01909 {
01910        (void) fprintf( stderr, "%s\n", msg );
01911        exit( YY_EXIT_FAILURE );
01912 }
01913 
01914 /* Redefine yyless() so it works in section 3 code. */
01915 
01916 #undef yyless
01917 #define yyless(n) \
01918        do \
01919               { \
01920               /* Undo effects of setting up yytext. */ \
01921         int yyless_macro_arg = (n); \
01922         YY_LESS_LINENO(yyless_macro_arg);\
01923               yytext[yyleng] = (yy_hold_char); \
01924               (yy_c_buf_p) = yytext + yyless_macro_arg; \
01925               (yy_hold_char) = *(yy_c_buf_p); \
01926               *(yy_c_buf_p) = '\0'; \
01927               yyleng = yyless_macro_arg; \
01928               } \
01929        while ( 0 )
01930 
01931 /* Accessor  methods (get/set functions) to struct members. */
01932 
01936 int yyget_lineno  (void)
01937 {
01938         
01939     return yylineno;
01940 }
01941 
01945 FILE *yyget_in  (void)
01946 {
01947         return yyin;
01948 }
01949 
01953 FILE *yyget_out  (void)
01954 {
01955         return yyout;
01956 }
01957 
01961 int yyget_leng  (void)
01962 {
01963         return yyleng;
01964 }
01965 
01970 char *yyget_text  (void)
01971 {
01972         return yytext;
01973 }
01974 
01979 void yyset_lineno (int  line_number )
01980 {
01981     
01982     yylineno = line_number;
01983 }
01984 
01991 void yyset_in (FILE *  in_str )
01992 {
01993         yyin = in_str ;
01994 }
01995 
01996 void yyset_out (FILE *  out_str )
01997 {
01998         yyout = out_str ;
01999 }
02000 
02001 int yyget_debug  (void)
02002 {
02003         return yy_flex_debug;
02004 }
02005 
02006 void yyset_debug (int  bdebug )
02007 {
02008         yy_flex_debug = bdebug ;
02009 }
02010 
02011 static int yy_init_globals (void)
02012 {
02013         /* Initialization is the same as for the non-reentrant scanner.
02014      * This function is called from yylex_destroy(), so don't allocate here.
02015      */
02016 
02017     (yy_buffer_stack) = 0;
02018     (yy_buffer_stack_top) = 0;
02019     (yy_buffer_stack_max) = 0;
02020     (yy_c_buf_p) = (char *) 0;
02021     (yy_init) = 0;
02022     (yy_start) = 0;
02023 
02024 /* Defined in main.c */
02025 #ifdef YY_STDINIT
02026     yyin = stdin;
02027     yyout = stdout;
02028 #else
02029     yyin = (FILE *) 0;
02030     yyout = (FILE *) 0;
02031 #endif
02032 
02033     /* For future reference: Set errno on error, since we are called by
02034      * yylex_init()
02035      */
02036     return 0;
02037 }
02038 
02039 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
02040 int yylex_destroy  (void)
02041 {
02042     
02043     /* Pop the buffer stack, destroying each element. */
02044        while(YY_CURRENT_BUFFER){
02045               yy_delete_buffer(YY_CURRENT_BUFFER  );
02046               YY_CURRENT_BUFFER_LVALUE = NULL;
02047               yypop_buffer_state();
02048        }
02049 
02050        /* Destroy the stack itself. */
02051        yyfree((yy_buffer_stack) );
02052        (yy_buffer_stack) = NULL;
02053 
02054     /* Reset the globals. This is important in a non-reentrant scanner so the next time
02055      * yylex() is called, initialization will occur. */
02056     yy_init_globals( );
02057 
02058     return 0;
02059 }
02060 
02061 /*
02062  * Internal utility routines.
02063  */
02064 
02065 #ifndef yytext_ptr
02066 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
02067 {
02068        register int i;
02069        for ( i = 0; i < n; ++i )
02070               s1[i] = s2[i];
02071 }
02072 #endif
02073 
02074 #ifdef YY_NEED_STRLEN
02075 static int yy_flex_strlen (yyconst char * s )
02076 {
02077        register int n;
02078        for ( n = 0; s[n]; ++n )
02079               ;
02080 
02081        return n;
02082 }
02083 #endif
02084 
02085 void *yyalloc (yy_size_t  size )
02086 {
02087        return (void *) malloc( size );
02088 }
02089 
02090 void *yyrealloc  (void * ptr, yy_size_t  size )
02091 {
02092        /* The cast to (char *) in the following accommodates both
02093         * implementations that use char* generic pointers, and those
02094         * that use void* generic pointers.  It works with the latter
02095         * because both ANSI C and C++ allow castless assignment from
02096         * any pointer type to void*, and deal with argument conversions
02097         * as though doing an assignment.
02098         */
02099        return (void *) realloc( (char *) ptr, size );
02100 }
02101 
02102 void yyfree (void * ptr )
02103 {
02104        free( (char *) ptr );       /* see yyrealloc() for (char *) cast */
02105 }
02106 
02107 #define YYTABLES_NAME "yytables"
02108 
02109 #line 141 "unites.l"