## modules/rpsl/members_is.lex.c

/* [<][>][^][v][top][bottom][index][help] */

## FUNCTIONS

This source file includes following functions.

1. YY_PROTO
2. YY_PROTO
3. YY_SC_TO_UI
4. YY_STATE_EOF
5. yyless
6. unput
7. yy_set_interactive
8. yy_set_bol
9. YY_AT_BOL
10. yymore
11. YY_INPUT
12. YY_INPUT
13. yyterminate
14. YY_FATAL_ERROR
15. yy_get_next_buffer
16. yy_get_previous_state
17. yy_try_NUL_trans
18. yyunput
19. yyinput
20. yyrestart
21. yy_switch_to_buffer
22. yy_load_buffer_state
23. yy_create_buffer
24. yy_delete_buffer
25. yy_init_buffer
26. yy_flush_buffer
27. yy_scan_buffer
28. yy_scan_string
29. yy_scan_bytes
30. yy_push_state
31. yy_pop_state
32. yy_top_state
33. yy_fatal_error
34. yyless
35. yy_flex_strncpy
36. yy_flex_strlen
37. yy_flex_alloc
38. yy_flex_realloc
39. yy_flex_free
40. main
41. members_is_reset

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

/* [<][>][^][v][top][bottom][index][help] */