## modules/rpsl/members_rs.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_rs_reset

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

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