src/ftacmp/ftalexer.cc

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