## modules/rpsl/aggr_bndry.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. aggr_bndry_reset

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

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