## modules/rpsl/import.lex.c

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

## DEFINITIONS

This source file includes following functions.

1. YY_BUFFER_STATE
2. yy_size_t
3. YY_CHAR
4. yy_state_type
5. yy_get_next_buffer
6. yy_get_previous_state
7. yy_try_NUL_trans
8. yyunput
9. yyinput
10. yyrestart
11. yy_switch_to_buffer
12. yy_load_buffer_state
13. yy_create_buffer
14. yy_delete_buffer
15. yy_init_buffer
16. yy_flush_buffer
17. yy_scan_buffer
18. yy_scan_string
19. yy_scan_bytes
20. yy_push_state
21. yy_pop_state
22. yy_top_state
23. yy_fatal_error
24. yy_flex_strncpy
25. yy_flex_strlen
26. yy_flex_alloc
27. yy_flex_realloc
28. yy_flex_free
29. main
30. import_reset

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

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