## modules/rpsl/inet6num.lex.c

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

## FUNCTIONS

This source file includes following functions.

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

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

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