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] */