4 #define  YY_INT_ALIGNED short int 
    9 #define YY_FLEX_MAJOR_VERSION 2 
   10 #define YY_FLEX_MINOR_VERSION 5 
   11 #define YY_FLEX_SUBMINOR_VERSION 37 
   12 #if YY_FLEX_SUBMINOR_VERSION > 0 
   33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 
   38 #ifndef __STDC_LIMIT_MACROS 
   39 #define __STDC_LIMIT_MACROS 1 
   59 #define INT8_MIN               (-128) 
   62 #define INT16_MIN              (-32767-1) 
   65 #define INT32_MIN              (-2147483647-1) 
   68 #define INT8_MAX               (127) 
   71 #define INT16_MAX              (32767) 
   74 #define INT32_MAX              (2147483647) 
   77 #define UINT8_MAX              (255U) 
   80 #define UINT16_MAX             (65535U) 
   83 #define UINT32_MAX             (4294967295U) 
   98 #if defined (__STDC__) 
  106 #define yyconst const 
  119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 
  125 #define BEGIN (yy_start) = 1 + 2 * 
  131 #define YY_START (((yy_start) - 1) / 2) 
  132 #define YYSTATE YY_START 
  135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 
  138 #define YY_NEW_FILE yyrestart(yyin  ) 
  140 #define YY_END_OF_BUFFER_CHAR 0 
  144 #define YY_BUF_SIZE 16384 
  149 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 
  151 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 
  152 #define YY_TYPEDEF_YY_BUFFER_STATE 
  156 #ifndef YY_TYPEDEF_YY_SIZE_T 
  157 #define YY_TYPEDEF_YY_SIZE_T 
  165 #define EOB_ACT_CONTINUE_SCAN 0 
  166 #define EOB_ACT_END_OF_FILE 1 
  167 #define EOB_ACT_LAST_MATCH 2 
  169     #define YY_LESS_LINENO(n) 
  176         int yyless_macro_arg = (n); \ 
  177         YY_LESS_LINENO(yyless_macro_arg);\ 
  178                 *yy_cp = (yy_hold_char); \ 
  179                 YY_RESTORE_YY_MORE_OFFSET \ 
  180                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 
  181                 YY_DO_BEFORE_ACTION;  \ 
  185 #define unput(c) yyunput( c, (yytext_ptr)  ) 
  187 #ifndef YY_STRUCT_YY_BUFFER_STATE 
  188 #define YY_STRUCT_YY_BUFFER_STATE 
  235 #define YY_BUFFER_NEW 0 
  236 #define YY_BUFFER_NORMAL 1 
  247 #define YY_BUFFER_EOF_PENDING 2 
  263 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 
  264                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 
  270 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 
  299 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) 
  309 #define yy_new_buffer yy_create_buffer 
  311 #define yy_set_interactive(is_interactive) \ 
  313         if ( ! YY_CURRENT_BUFFER ){ \ 
  314         yyensure_buffer_stack (); \ 
  315                 YY_CURRENT_BUFFER_LVALUE =    \ 
  316             yy_create_buffer(yyin,YY_BUF_SIZE ); \ 
  318         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 
  321 #define yy_set_bol(at_bol) \ 
  323         if ( ! YY_CURRENT_BUFFER ){\ 
  324         yyensure_buffer_stack (); \ 
  325                 YY_CURRENT_BUFFER_LVALUE =    \ 
  326             yy_create_buffer(yyin,YY_BUF_SIZE ); \ 
  328         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 
  331 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 
  346 #define yytext_ptr yytext 
  356 #define YY_DO_BEFORE_ACTION \ 
  357         (yytext_ptr) = yy_bp; \ 
  358         yyleng = (size_t) (yy_cp - yy_bp); \ 
  359         (yy_hold_char) = *yy_cp; \ 
  361         (yy_c_buf_p) = yy_cp; 
  363 #define YY_NUM_RULES 9 
  364 #define YY_END_OF_BUFFER 10 
  374         0,    0,   10,    9,    5,    6,    8,    9,    7,    8,
 
  375         8,    8,    1,    8,    7,    8,    4,    3,    2,    0
 
  380         1,    1,    1,    1,    1,    1,    1,    1,    2,    2,
 
  381         2,    2,    2,    1,    1,    1,    1,    1,    1,    1,
 
  382         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  383         1,    2,    1,    1,    1,    1,    1,    1,    1,    3,
 
  384         4,    1,    1,    1,    1,    1,    5,    5,    5,    5,
 
  385         5,    5,    5,    5,    5,    5,    5,    1,    1,    6,
 
  386         7,    6,    1,    1,    5,    5,    5,    5,    5,    5,
 
  387         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 
  388         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 
  389         1,    1,    1,    1,    5,    1,    8,    5,    5,    9,
 
  391         5,   10,    5,    5,   11,    5,    5,    5,    5,   12,
 
  392        13,    5,    5,   14,    5,    5,    5,    5,   15,    5,
 
  393         5,    5,    1,    1,    1,    1,    1,    1,    1,    1,
 
  394         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  395         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  398         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  399         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  400         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  403         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  405         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  412         1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
 
  418         0,    0,   23,   24,   24,   24,    0,   15,   14,    8,
 
  419         9,    4,    0,    0,   24,    8,    0,    0,    0,   24,
 
  425        20,    1,   20,   20,   20,   20,   21,   20,   20,   21,
 
  426        21,   21,   21,   21,   20,   21,   21,   21,   21,    0,
 
  432         4,    4,    5,    6,    7,    8,    9,   10,    7,    7,
 
  433        11,    7,   12,    7,   13,   14,   19,   18,   17,   16,
 
  434        15,   15,   20,    3,   20,   20,   20,   20,   20,   20,
 
  435        20,   20,   20,   20,   20,   20,   20,   20,   20
 
  440         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 
  441         1,    1,    1,    1,    1,   21,   16,   12,   11,   10,
 
  442         9,    8,    3,   20,   20,   20,   20,   20,   20,   20,
 
  443        20,   20,   20,   20,   20,   20,   20,   20,   20
 
  450 int yy_flex_debug = 0;
 
  455 #define REJECT reject_used_but_not_detected 
  456 #define yymore() yymore_used_but_not_detected 
  457 #define YY_MORE_ADJ 0 
  458 #define YY_RESTORE_YY_MORE_OFFSET 
  460 #line 1 "build/parseReqs.l" 
  461 #line 3 "build/parseReqs.l" 
  462 #include "parseReqs.tab.h" 
  467 #ifndef YY_NO_UNISTD_H 
  475 #ifndef YY_EXTRA_TYPE 
  476 #define YY_EXTRA_TYPE void * 
  514 #ifndef YY_SKIP_YYWRAP 
  516 extern "C" int yywrap (
void );
 
  518 extern int yywrap (
void );
 
  522     static void yyunput (
int c,
char *buf_ptr  );
 
  525 static void yy_flex_strncpy (
char *,
yyconst char *,
int );
 
  528 #ifdef YY_NEED_STRLEN 
  529 static int yy_flex_strlen (
yyconst char * );
 
  535 static int yyinput (
void );
 
  537 static int input (
void );
 
  543 #ifndef YY_READ_BUF_SIZE 
  544 #define YY_READ_BUF_SIZE 8192 
  552 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0) 
  559 #define YY_INPUT(buf,result,max_size) \ 
  560         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 
  564                 for ( n = 0; n < max_size && \ 
  565                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 
  568                         buf[n++] = (char) c; \ 
  569                 if ( c == EOF && ferror( yyin ) ) \ 
  570                         YY_FATAL_ERROR( "input in flex scanner failed" ); \ 
  576                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 
  578                         if( errno != EINTR) \ 
  580                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 
  596 #define yyterminate() return YY_NULL 
  600 #ifndef YY_START_STACK_INCR 
  601 #define YY_START_STACK_INCR 25 
  605 #ifndef YY_FATAL_ERROR 
  606 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 
  615 #define YY_DECL_IS_OURS 1 
  617 extern int yylex (
void);
 
  619 #define YY_DECL int yylex (void) 
  625 #ifndef YY_USER_ACTION 
  626 #define YY_USER_ACTION 
  631 #define YY_BREAK break; 
  634 #define YY_RULE_SETUP \ 
  641         register yy_state_type yy_current_state;
 
  642         register char *yy_cp, *yy_bp;
 
  645 #line 7 "build/parseReqs.l" 
  693                         if ( yy_accept[yy_current_state] )
 
  698                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 
  700                                 yy_current_state = (int) yy_def[yy_current_state];
 
  701                                 if ( yy_current_state >= 21 )
 
  702                                         yy_c = yy_meta[(
unsigned int) yy_c];
 
  704                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
 
  707                 while ( yy_base[yy_current_state] != 24 );
 
  710                 yy_act = yy_accept[yy_current_state];
 
  715                         yy_act = yy_accept[yy_current_state];
 
  733 #line 9 "build/parseReqs.l" 
  738 #line 10 "build/parseReqs.l" 
  743 #line 11 "build/parseReqs.l" 
  748 #line 12 "build/parseReqs.l" 
  753 #line 13 "build/parseReqs.l" 
  758 #line 14 "build/parseReqs.l" 
  763 #line 15 "build/parseReqs.l" 
  768 #line 16 "build/parseReqs.l" 
  773 #line 18 "build/parseReqs.l" 
  783                 int yy_amount_of_matched_text = (int) (yy_cp - (
yytext_ptr)) - 1;
 
  814                         yy_state_type yy_next_state;
 
  837                                 yy_current_state = yy_next_state;
 
  904                         "fatal flex scanner internal error--no action found" );
 
  920         register int number_to_move, i;
 
  925                 "fatal flex scanner internal error--end of buffer missed" );
 
  951         for ( i = 0; i < number_to_move; ++i )
 
  952                 *(dest++) = *(source++);
 
  965                 while ( num_to_read <= 0 )
 
  971                         int yy_c_buf_p_offset =
 
  993                                 "fatal error - scanner input buffer overflow" );
 
 1036                         YY_FATAL_ERROR( 
"out of dynamic memory in yy_get_next_buffer()" );
 
 1052         register yy_state_type yy_current_state;
 
 1053         register char *yy_cp;
 
 1060                 if ( yy_accept[yy_current_state] )
 
 1065                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 
 1067                         yy_current_state = (int) yy_def[yy_current_state];
 
 1068                         if ( yy_current_state >= 21 )
 
 1069                                 yy_c = yy_meta[(
unsigned int) yy_c];
 
 1071                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
 
 1074         return yy_current_state;
 
 1084         register int yy_is_jam;
 
 1088         if ( yy_accept[yy_current_state] )
 
 1093         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 
 1095                 yy_current_state = (int) yy_def[yy_current_state];
 
 1096                 if ( yy_current_state >= 21 )
 
 1097                         yy_c = yy_meta[(
unsigned int) yy_c];
 
 1099         yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
 
 1100         yy_is_jam = (yy_current_state == 20);
 
 1102                 return yy_is_jam ? 0 : yy_current_state;
 
 1105     static void yyunput (
int c, 
register char * yy_bp )
 
 1107         register char *yy_cp;
 
 1114         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 
 1126                 yy_cp += (int) (dest - source);
 
 1127                 yy_bp += (int) (dest - source);
 
 1131                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
 
 1135         *--yy_cp = (char) c;
 
 1144     static int yyinput (
void)
 
 1389         if (new_buffer == NULL)
 
 1440         if (!(yy_buffer_stack)) {
 
 1450                 if ( ! (yy_buffer_stack) )
 
 1451                         YY_FATAL_ERROR( 
"out of dynamic memory in yyensure_buffer_stack()" );
 
 1453                 memset((yy_buffer_stack), 0, num_to_alloc * 
sizeof(
struct yy_buffer_state*));
 
 1470                 if ( ! (yy_buffer_stack) )
 
 1471                         YY_FATAL_ERROR( 
"out of dynamic memory in yyensure_buffer_stack()" );
 
 1543         n = _yybytes_len + 2;
 
 1548         for ( i = 0; i < _yybytes_len; ++i )
 
 1549                 buf[i] = yybytes[i];
 
 1565 #ifndef YY_EXIT_FAILURE 
 1566 #define YY_EXIT_FAILURE 2 
 1571         (void) fprintf( stderr, 
"%s\n", msg );
 
 1582         int yyless_macro_arg = (n); \ 
 1583         YY_LESS_LINENO(yyless_macro_arg);\ 
 1584                 yytext[yyleng] = (yy_hold_char); \ 
 1585                 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 
 1586                 (yy_hold_char) = *(yy_c_buf_p); \ 
 1587                 *(yy_c_buf_p) = '\0'; \ 
 1588                 yyleng = yyless_macro_arg; \ 
 1643     yylineno = line_number;
 
 1669         yy_flex_debug = bdebug ;
 
 1712         yyfree((yy_buffer_stack) );
 
 1727 static void yy_flex_strncpy (
char* s1, 
yyconst char * s2, 
int n )
 
 1730         for ( i = 0; i < n; ++i )
 
 1735 #ifdef YY_NEED_STRLEN 
 1736 static int yy_flex_strlen (
yyconst char * s )
 
 1739         for ( n = 0; s[n]; ++n )
 
 1748         return (
void *) malloc( size );
 
 1760         return (
void *) realloc( (
char *) ptr, size );
 
 1765         free( (
char *) ptr );   
 
 1768 #define YYTABLES_NAME "yytables" 
 1770 #line 18 "build/parseReqs.l" 
#define EOB_ACT_CONTINUE_SCAN
void yyrestart(FILE *input_file)
Immediately switch to a different input stream. 
void yyset_extra(void *user_defined)
void * yyrealloc(void *, yy_size_t)
static flex_int16_t yy_base[22]
#define YY_INPUT(buf, result, max_size)
struct yy_buffer_state * YY_BUFFER_STATE
#define YY_STATE_EOF(state)
#define YY_RESTORE_YY_MORE_OFFSET
static flex_int16_t yy_accept[21]
static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
static void yyensure_buffer_stack(void)
static int yy_get_next_buffer(void)
char * yyget_text(void)
Get the current token. 
int yy_bs_lineno
The line count. 
yy_size_t yyget_leng(void)
Get the length of the current token. 
void yyset_out(FILE *out_str)
static flex_int16_t yy_chk[40]
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Switch to a different input buffer. 
#define EOB_ACT_LAST_MATCH
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
#define YY_CURRENT_BUFFER
int yyget_lineno(void)
Get the current line number. 
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array. 
#define YY_DO_BEFORE_ACTION
void yypush_buffer_state(YY_BUFFER_STATE new_buffer)
Pushes the new state onto the stack. 
void yyset_debug(int debug_flag)
static char * yy_last_accepting_cpos
FILE * yyget_in(void)
Get the input stream. 
static yy_state_type yy_last_accepting_state
unsigned int flex_uint32_t
static flex_int32_t yy_ec[256]
int yy_bs_column
The column count. 
static int yy_init_globals(void)
void yyset_in(FILE *in_str)
Set the input stream. 
static void yy_fatal_error(char msg[])
unsigned short int flex_uint16_t
#define YY_CURRENT_BUFFER_LVALUE
#define YY_END_OF_BUFFER_CHAR
#define YY_BUFFER_EOF_PENDING
static void yyunput(int c, char *buf_ptr)
#define EOB_ACT_END_OF_FILE
static int yy_did_buffer_switch_on_eof
YY_BUFFER_STATE yy_scan_string(char *yy_str)
Setup the input buffer state to scan a string. 
static flex_int32_t yy_meta[16]
YY_BUFFER_STATE yy_scan_bytes(char *bytes, yy_size_t len)
Setup the input buffer state to scan the given bytes. 
void * yyalloc(yy_size_t)
#define YY_FATAL_ERROR(msg)
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
Setup the input buffer state to scan directly from a user-specified character buffer. 
static yy_size_t yy_n_chars
int yylex(void)
The main scanner function which does all the work. 
static size_t yy_buffer_stack_max
capacity of stack. 
static yy_state_type yy_get_previous_state(void)
static void yy_load_buffer_state(void)
static size_t yy_buffer_stack_top
index of top of stack. 
void yy_flush_buffer(YY_BUFFER_STATE b)
Discard all buffered characters. 
unsigned char flex_uint8_t
void yypop_buffer_state(void)
Removes and deletes the top of the stack, if present. 
FILE * yyget_out(void)
Get the output stream. 
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Allocate and initialize an input buffer state. 
void yy_delete_buffer(YY_BUFFER_STATE b)
Destroy the buffer. 
void yyset_lineno(int line_number)
Set the current line number. 
static flex_int16_t yy_nxt[40]
static flex_int16_t yy_def[22]