rpm  4.11.3
lex.yy.c
Go to the documentation of this file.
1 
2 #line 3 "lex.yy.c"
3 
4 #define YY_INT_ALIGNED short int
5 
6 /* A lexical scanner generated by flex */
7 
8 #define FLEX_SCANNER
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
13 #define FLEX_BETA
14 #endif
15 
16 /* First, we deal with platform-specific or compiler-specific issues. */
17 
18 /* begin standard C headers. */
19 #include <stdio.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <stdlib.h>
23 
24 /* end standard C headers. */
25 
26 /* flex integer type definitions */
27 
28 #ifndef FLEXINT_H
29 #define FLEXINT_H
30 
31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32 
33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
34 
35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
36  * if you want the limit (max/min) macros for int types.
37  */
38 #ifndef __STDC_LIMIT_MACROS
39 #define __STDC_LIMIT_MACROS 1
40 #endif
41 
42 #include <inttypes.h>
43 typedef int8_t flex_int8_t;
44 typedef uint8_t flex_uint8_t;
45 typedef int16_t flex_int16_t;
46 typedef uint16_t flex_uint16_t;
47 typedef int32_t flex_int32_t;
48 typedef uint32_t flex_uint32_t;
49 #else
50 typedef signed char flex_int8_t;
51 typedef short int flex_int16_t;
52 typedef int flex_int32_t;
53 typedef unsigned char flex_uint8_t;
54 typedef unsigned short int flex_uint16_t;
55 typedef unsigned int flex_uint32_t;
56 
57 /* Limits of integral types. */
58 #ifndef INT8_MIN
59 #define INT8_MIN (-128)
60 #endif
61 #ifndef INT16_MIN
62 #define INT16_MIN (-32767-1)
63 #endif
64 #ifndef INT32_MIN
65 #define INT32_MIN (-2147483647-1)
66 #endif
67 #ifndef INT8_MAX
68 #define INT8_MAX (127)
69 #endif
70 #ifndef INT16_MAX
71 #define INT16_MAX (32767)
72 #endif
73 #ifndef INT32_MAX
74 #define INT32_MAX (2147483647)
75 #endif
76 #ifndef UINT8_MAX
77 #define UINT8_MAX (255U)
78 #endif
79 #ifndef UINT16_MAX
80 #define UINT16_MAX (65535U)
81 #endif
82 #ifndef UINT32_MAX
83 #define UINT32_MAX (4294967295U)
84 #endif
85 
86 #endif /* ! C99 */
87 
88 #endif /* ! FLEXINT_H */
89 
90 #ifdef __cplusplus
91 
92 /* The "const" storage-class-modifier is valid. */
93 #define YY_USE_CONST
94 
95 #else /* ! __cplusplus */
96 
97 /* C99 requires __STDC__ to be defined as 1. */
98 #if defined (__STDC__)
99 
100 #define YY_USE_CONST
101 
102 #endif /* defined (__STDC__) */
103 #endif /* ! __cplusplus */
104 
105 #ifdef YY_USE_CONST
106 #define yyconst const
107 #else
108 #define yyconst
109 #endif
110 
111 /* Returned upon end-of-file. */
112 #define YY_NULL 0
113 
114 /* Promotes a possibly negative, possibly signed char to an unsigned
115  * integer for use as an array index. If the signed char is negative,
116  * we want to instead treat it as an 8-bit unsigned char, hence the
117  * double cast.
118  */
119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
120 
121 /* Enter a start condition. This macro really ought to take a parameter,
122  * but we do it the disgusting crufty way forced on us by the ()-less
123  * definition of BEGIN.
124  */
125 #define BEGIN (yy_start) = 1 + 2 *
126 
127 /* Translate the current start state into a value that can be later handed
128  * to BEGIN to return to the state. The YYSTATE alias is for lex
129  * compatibility.
130  */
131 #define YY_START (((yy_start) - 1) / 2)
132 #define YYSTATE YY_START
133 
134 /* Action number for EOF rule of a given start state. */
135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
136 
137 /* Special action meaning "start processing a new file". */
138 #define YY_NEW_FILE yyrestart(yyin )
139 
140 #define YY_END_OF_BUFFER_CHAR 0
141 
142 /* Size of default input buffer. */
143 #ifndef YY_BUF_SIZE
144 #define YY_BUF_SIZE 16384
145 #endif
146 
147 /* The state buf must be large enough to hold one state per character in the main buffer.
148  */
149 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
150 
151 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
152 #define YY_TYPEDEF_YY_BUFFER_STATE
154 #endif
155 
156 #ifndef YY_TYPEDEF_YY_SIZE_T
157 #define YY_TYPEDEF_YY_SIZE_T
158 typedef size_t yy_size_t;
159 #endif
160 
161 extern yy_size_t yyleng;
162 
163 extern FILE *yyin, *yyout;
164 
165 #define EOB_ACT_CONTINUE_SCAN 0
166 #define EOB_ACT_END_OF_FILE 1
167 #define EOB_ACT_LAST_MATCH 2
168 
169  #define YY_LESS_LINENO(n)
170 
171 /* Return all but the first "n" matched characters back to the input stream. */
172 #define yyless(n) \
173  do \
174  { \
175  /* Undo effects of setting up yytext. */ \
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; /* set up yytext again */ \
182  } \
183  while ( 0 )
184 
185 #define unput(c) yyunput( c, (yytext_ptr) )
186 
187 #ifndef YY_STRUCT_YY_BUFFER_STATE
188 #define YY_STRUCT_YY_BUFFER_STATE
190  {
192 
193  char *yy_ch_buf; /* input buffer */
194  char *yy_buf_pos; /* current position in input buffer */
195 
196  /* Size of input buffer in bytes, not including room for EOB
197  * characters.
198  */
200 
201  /* Number of characters read into yy_ch_buf, not including EOB
202  * characters.
203  */
205 
206  /* Whether we "own" the buffer - i.e., we know we created it,
207  * and can realloc() it to grow it, and should free() it to
208  * delete it.
209  */
211 
212  /* Whether this is an "interactive" input source; if so, and
213  * if we're using stdio for input, then we want to use getc()
214  * instead of fread(), to make sure we stop fetching input after
215  * each newline.
216  */
218 
219  /* Whether we're considered to be at the beginning of a line.
220  * If so, '^' rules will be active on the next match, otherwise
221  * not.
222  */
224 
228  /* Whether to try to fill the input buffer when we reach the
229  * end of it.
230  */
232 
234 
235 #define YY_BUFFER_NEW 0
236 #define YY_BUFFER_NORMAL 1
237  /* When an EOF's been seen but there's still some text to process
238  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
239  * shouldn't try reading from the input source any more. We might
240  * still have a bunch of tokens to match, though, because of
241  * possible backing-up.
242  *
243  * When we actually see the EOF, we change the status to "new"
244  * (via yyrestart()), so that the user can continue scanning by
245  * just pointing yyin at a new input file.
246  */
247 #define YY_BUFFER_EOF_PENDING 2
248 
249  };
250 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
251 
252 /* Stack of input buffers. */
253 static size_t yy_buffer_stack_top = 0;
254 static size_t yy_buffer_stack_max = 0;
255 static YY_BUFFER_STATE * yy_buffer_stack = 0;
257 /* We provide macros for accessing buffer states in case in the
258  * future we want to put the buffer states in a more general
259  * "scanner state".
260  *
261  * Returns the top of the stack, or NULL.
262  */
263 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
264  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
265  : NULL)
266 
267 /* Same as previous macro, but useful when we know that the buffer stack is not
268  * NULL or when we need an lvalue. For internal use only.
269  */
270 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
271 
272 /* yy_hold_char holds the character lost when yytext is formed. */
273 static char yy_hold_char;
274 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
276 
277 /* Points to current character in buffer. */
278 static char *yy_c_buf_p = (char *) 0;
279 static int yy_init = 0; /* whether we need to initialize */
280 static int yy_start = 0; /* start state number */
281 
282 /* Flag which is used to allow yywrap()'s to do buffer switches
283  * instead of setting up a fresh yyin. A bit of a hack ...
284  */
286 
287 void yyrestart (FILE *input_file );
288 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
289 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
290 void yy_delete_buffer (YY_BUFFER_STATE b );
291 void yy_flush_buffer (YY_BUFFER_STATE b );
292 void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
293 void yypop_buffer_state (void );
294 
295 static void yyensure_buffer_stack (void );
296 static void yy_load_buffer_state (void );
297 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
298 
299 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
300 
301 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
302 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
303 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len );
304 
305 void *yyalloc (yy_size_t );
306 void *yyrealloc (void *,yy_size_t );
307 void yyfree (void * );
308 
309 #define yy_new_buffer yy_create_buffer
310 
311 #define yy_set_interactive(is_interactive) \
312  { \
313  if ( ! YY_CURRENT_BUFFER ){ \
314  yyensure_buffer_stack (); \
315  YY_CURRENT_BUFFER_LVALUE = \
316  yy_create_buffer(yyin,YY_BUF_SIZE ); \
317  } \
318  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
319  }
320 
321 #define yy_set_bol(at_bol) \
322  { \
323  if ( ! YY_CURRENT_BUFFER ){\
324  yyensure_buffer_stack (); \
325  YY_CURRENT_BUFFER_LVALUE = \
326  yy_create_buffer(yyin,YY_BUF_SIZE ); \
327  } \
328  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
329  }
330 
331 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
332 
333 /* Begin user sect3 */
334 
335 typedef unsigned char YY_CHAR;
336 
337 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
338 
339 typedef int yy_state_type;
340 
341 extern int yylineno;
342 
343 int yylineno = 1;
344 
345 extern char *yytext;
346 #define yytext_ptr yytext
347 
348 static yy_state_type yy_get_previous_state (void );
349 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
350 static int yy_get_next_buffer (void );
351 static void yy_fatal_error (yyconst char msg[] );
352 
353 /* Done after the current pattern has been matched and before the
354  * corresponding action - sets up yytext.
355  */
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; \
360  *yy_cp = '\0'; \
361  (yy_c_buf_p) = yy_cp;
362 
363 #define YY_NUM_RULES 9
364 #define YY_END_OF_BUFFER 10
365 /* This struct is not used in this scanner,
366  but its presence is necessary. */
368  {
371  };
373  { 0,
374  0, 0, 10, 9, 5, 6, 8, 9, 7, 8,
375  8, 8, 1, 8, 7, 8, 4, 3, 2, 0
376  } ;
377 
379  { 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,
390 
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,
401 
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,
407  1, 1, 1, 1, 1
408  } ;
409 
411  { 0,
412  1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
413  1, 1, 1, 1, 1
414  } ;
415 
417  { 0,
418  0, 0, 23, 24, 24, 24, 0, 15, 14, 8,
419  9, 4, 0, 0, 24, 8, 0, 0, 0, 24,
420  15
421  } ;
422 
424  { 0,
425  20, 1, 20, 20, 20, 20, 21, 20, 20, 21,
426  21, 21, 21, 21, 20, 21, 21, 21, 21, 0,
427  20
428  } ;
429 
431  { 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
436  } ;
437 
439  { 0,
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
444  } ;
445 
446 static yy_state_type yy_last_accepting_state;
448 
449 extern int yy_flex_debug;
450 int yy_flex_debug = 0;
451 
452 /* The intent behind this definition is that it'll catch
453  * any uses of REJECT which flex missed.
454  */
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
459 char *yytext;
460 #line 1 "build/parseReqs.l"
461 #line 3 "build/parseReqs.l"
462 #include "parseReqs.tab.h"
463 #line 464 "lex.yy.c"
464 
465 #define INITIAL 0
466 
467 #ifndef YY_NO_UNISTD_H
468 /* Special case for "unistd.h", since it is non-ANSI. We include it way
469  * down here because we want the user's section 1 to have been scanned first.
470  * The user has a chance to override it with an option.
471  */
472 #include <unistd.h>
473 #endif
474 
475 #ifndef YY_EXTRA_TYPE
476 #define YY_EXTRA_TYPE void *
477 #endif
478 
479 static int yy_init_globals (void );
480 
481 /* Accessor methods to globals.
482  These are made visible to non-reentrant scanners for convenience. */
483 
484 int yylex_destroy (void );
485 
486 int yyget_debug (void );
487 
488 void yyset_debug (int debug_flag );
489 
490 YY_EXTRA_TYPE yyget_extra (void );
491 
492 void yyset_extra (YY_EXTRA_TYPE user_defined );
493 
494 FILE *yyget_in (void );
495 
496 void yyset_in (FILE * in_str );
497 
498 FILE *yyget_out (void );
499 
500 void yyset_out (FILE * out_str );
501 
502 yy_size_t yyget_leng (void );
503 
504 char *yyget_text (void );
505 
506 int yyget_lineno (void );
507 
508 void yyset_lineno (int line_number );
509 
510 /* Macros after this point can all be overridden by user definitions in
511  * section 1.
512  */
513 
514 #ifndef YY_SKIP_YYWRAP
515 #ifdef __cplusplus
516 extern "C" int yywrap (void );
517 #else
518 extern int yywrap (void );
519 #endif
520 #endif
521 
522  static void yyunput (int c,char *buf_ptr );
523 
524 #ifndef yytext_ptr
525 static void yy_flex_strncpy (char *,yyconst char *,int );
526 #endif
527 
528 #ifdef YY_NEED_STRLEN
529 static int yy_flex_strlen (yyconst char * );
530 #endif
531 
532 #ifndef YY_NO_INPUT
533 
534 #ifdef __cplusplus
535 static int yyinput (void );
536 #else
537 static int input (void );
538 #endif
539 
540 #endif
541 
542 /* Amount of stuff to slurp up with each read. */
543 #ifndef YY_READ_BUF_SIZE
544 #define YY_READ_BUF_SIZE 8192
545 #endif
546 
547 /* Copy whatever the last rule matched to the standard output. */
548 #ifndef ECHO
549 /* This used to be an fputs(), but since the string might contain NUL's,
550  * we now use fwrite().
551  */
552 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
553 #endif
554 
555 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
556  * is returned in "result".
557  */
558 #ifndef YY_INPUT
559 #define YY_INPUT(buf,result,max_size) \
560  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
561  { \
562  int c = '*'; \
563  size_t n; \
564  for ( n = 0; n < max_size && \
565  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
566  buf[n] = (char) c; \
567  if ( c == '\n' ) \
568  buf[n++] = (char) c; \
569  if ( c == EOF && ferror( yyin ) ) \
570  YY_FATAL_ERROR( "input in flex scanner failed" ); \
571  result = n; \
572  } \
573  else \
574  { \
575  errno=0; \
576  while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
577  { \
578  if( errno != EINTR) \
579  { \
580  YY_FATAL_ERROR( "input in flex scanner failed" ); \
581  break; \
582  } \
583  errno=0; \
584  clearerr(yyin); \
585  } \
586  }\
587 \
588 
589 #endif
590 
591 /* No semi-colon after return; correct usage is to write "yyterminate();" -
592  * we don't want an extra ';' after the "return" because that will cause
593  * some compilers to complain about unreachable statements.
594  */
595 #ifndef yyterminate
596 #define yyterminate() return YY_NULL
597 #endif
598 
599 /* Number of entries by which start-condition stack grows. */
600 #ifndef YY_START_STACK_INCR
601 #define YY_START_STACK_INCR 25
602 #endif
603 
604 /* Report a fatal error. */
605 #ifndef YY_FATAL_ERROR
606 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
607 #endif
608 
609 /* end tables serialization structures and prototypes */
610 
611 /* Default declaration of generated scanner - a define so the user can
612  * easily add parameters.
613  */
614 #ifndef YY_DECL
615 #define YY_DECL_IS_OURS 1
616 
617 extern int yylex (void);
618 
619 #define YY_DECL int yylex (void)
620 #endif /* !YY_DECL */
621 
622 /* Code executed at the beginning of each rule, after yytext and yyleng
623  * have been set up.
624  */
625 #ifndef YY_USER_ACTION
626 #define YY_USER_ACTION
627 #endif
628 
629 /* Code executed at the end of each rule. */
630 #ifndef YY_BREAK
631 #define YY_BREAK break;
632 #endif
633 
634 #define YY_RULE_SETUP \
635  YY_USER_ACTION
636 
640 {
641  register yy_state_type yy_current_state;
642  register char *yy_cp, *yy_bp;
643  register int yy_act;
644 
645 #line 7 "build/parseReqs.l"
646 
647 
648 #line 649 "lex.yy.c"
649 
650  if ( !(yy_init) )
651  {
652  (yy_init) = 1;
653 
654 #ifdef YY_USER_INIT
655  YY_USER_INIT;
656 #endif
657 
658  if ( ! (yy_start) )
659  (yy_start) = 1; /* first start state */
660 
661  if ( ! yyin )
662  yyin = stdin;
663 
664  if ( ! yyout )
665  yyout = stdout;
666 
667  if ( ! YY_CURRENT_BUFFER ) {
671  }
672 
674  }
675 
676  while ( 1 ) /* loops until end-of-file is reached */
677  {
678  yy_cp = (yy_c_buf_p);
679 
680  /* Support of yytext. */
681  *yy_cp = (yy_hold_char);
682 
683  /* yy_bp points to the position in yy_ch_buf of the start of
684  * the current run.
685  */
686  yy_bp = yy_cp;
687 
688  yy_current_state = (yy_start);
689 yy_match:
690  do
691  {
692  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
693  if ( yy_accept[yy_current_state] )
694  {
695  (yy_last_accepting_state) = yy_current_state;
696  (yy_last_accepting_cpos) = yy_cp;
697  }
698  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
699  {
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];
703  }
704  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
705  ++yy_cp;
706  }
707  while ( yy_base[yy_current_state] != 24 );
708 
709 yy_find_action:
710  yy_act = yy_accept[yy_current_state];
711  if ( yy_act == 0 )
712  { /* have to back up */
713  yy_cp = (yy_last_accepting_cpos);
714  yy_current_state = (yy_last_accepting_state);
715  yy_act = yy_accept[yy_current_state];
716  }
717 
719 
720 do_action: /* This label is used only to access EOF actions. */
721 
722  switch ( yy_act )
723  { /* beginning of action switch */
724  case 0: /* must back up */
725  /* undo the effects of YY_DO_BEFORE_ACTION */
726  *yy_cp = (yy_hold_char);
727  yy_cp = (yy_last_accepting_cpos);
728  yy_current_state = (yy_last_accepting_state);
729  goto yy_find_action;
730 
731 case 1:
733 #line 9 "build/parseReqs.l"
734 ;
735  YY_BREAK
736 case 2:
738 #line 10 "build/parseReqs.l"
739 return and;
740  YY_BREAK
741 case 3:
743 #line 11 "build/parseReqs.l"
744 return or;
745  YY_BREAK
746 case 4:
748 #line 12 "build/parseReqs.l"
749 return if;
750  YY_BREAK
751 case 5:
753 #line 13 "build/parseReqs.l"
754 return "(";
755  YY_BREAK
756 case 6:
758 #line 14 "build/parseReqs.l"
759 return ")";
760  YY_BREAK
761 case 7:
763 #line 15 "build/parseReqs.l"
764 return cmp;
765  YY_BREAK
766 case 8:
768 #line 16 "build/parseReqs.l"
769 return name;
770  YY_BREAK
771 case 9:
773 #line 18 "build/parseReqs.l"
774 ECHO;
775  YY_BREAK
776 #line 777 "lex.yy.c"
777 case YY_STATE_EOF(INITIAL):
778  yyterminate();
779 
780  case YY_END_OF_BUFFER:
781  {
782  /* Amount of text matched not including the EOB char. */
783  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
784 
785  /* Undo the effects of YY_DO_BEFORE_ACTION. */
786  *yy_cp = (yy_hold_char);
788 
789  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
790  {
791  /* We're scanning a new file or input source. It's
792  * possible that this happened because the user
793  * just pointed yyin at a new source and called
794  * yylex(). If so, then we have to assure
795  * consistency between YY_CURRENT_BUFFER and our
796  * globals. Here is the right place to do so, because
797  * this is the first action (other than possibly a
798  * back-up) that will match for the new input source.
799  */
800  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
801  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
802  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
803  }
804 
805  /* Note that here we test for yy_c_buf_p "<=" to the position
806  * of the first EOB in the buffer, since yy_c_buf_p will
807  * already have been incremented past the NUL character
808  * (since all states make transitions on EOB to the
809  * end-of-buffer state). Contrast this with the test
810  * in input().
811  */
812  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
813  { /* This was really a NUL. */
814  yy_state_type yy_next_state;
815 
816  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
817 
818  yy_current_state = yy_get_previous_state( );
819 
820  /* Okay, we're now positioned to make the NUL
821  * transition. We couldn't have
822  * yy_get_previous_state() go ahead and do it
823  * for us because it doesn't know how to deal
824  * with the possibility of jamming (and we don't
825  * want to build jamming into it because then it
826  * will run more slowly).
827  */
828 
829  yy_next_state = yy_try_NUL_trans( yy_current_state );
830 
831  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
832 
833  if ( yy_next_state )
834  {
835  /* Consume the NUL. */
836  yy_cp = ++(yy_c_buf_p);
837  yy_current_state = yy_next_state;
838  goto yy_match;
839  }
840 
841  else
842  {
843  yy_cp = (yy_c_buf_p);
844  goto yy_find_action;
845  }
846  }
847 
848  else switch ( yy_get_next_buffer( ) )
849  {
850  case EOB_ACT_END_OF_FILE:
851  {
853 
854  if ( yywrap( ) )
855  {
856  /* Note: because we've taken care in
857  * yy_get_next_buffer() to have set up
858  * yytext, we can now set up
859  * yy_c_buf_p so that if some total
860  * hoser (like flex itself) wants to
861  * call the scanner after we return the
862  * YY_NULL, it'll still work - another
863  * YY_NULL will get returned.
864  */
866 
867  yy_act = YY_STATE_EOF(YY_START);
868  goto do_action;
869  }
870 
871  else
872  {
873  if ( ! (yy_did_buffer_switch_on_eof) )
874  YY_NEW_FILE;
875  }
876  break;
877  }
878 
880  (yy_c_buf_p) =
881  (yytext_ptr) + yy_amount_of_matched_text;
882 
883  yy_current_state = yy_get_previous_state( );
884 
885  yy_cp = (yy_c_buf_p);
886  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
887  goto yy_match;
888 
889  case EOB_ACT_LAST_MATCH:
890  (yy_c_buf_p) =
891  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
892 
893  yy_current_state = yy_get_previous_state( );
894 
895  yy_cp = (yy_c_buf_p);
896  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
897  goto yy_find_action;
898  }
899  break;
900  }
901 
902  default:
904  "fatal flex scanner internal error--no action found" );
905  } /* end of action switch */
906  } /* end of scanning one token */
907 } /* end of yylex */
908 
909 /* yy_get_next_buffer - try to read in a new buffer
910  *
911  * Returns a code representing an action:
912  * EOB_ACT_LAST_MATCH -
913  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
914  * EOB_ACT_END_OF_FILE - end of file
915  */
916 static int yy_get_next_buffer (void)
917 {
918  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
919  register char *source = (yytext_ptr);
920  register int number_to_move, i;
921  int ret_val;
922 
923  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
925  "fatal flex scanner internal error--end of buffer missed" );
926 
927  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
928  { /* Don't try to fill the buffer, so this is an EOF. */
929  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
930  {
931  /* We matched a single character, the EOB, so
932  * treat this as a final EOF.
933  */
934  return EOB_ACT_END_OF_FILE;
935  }
936 
937  else
938  {
939  /* We matched some text prior to the EOB, first
940  * process it.
941  */
942  return EOB_ACT_LAST_MATCH;
943  }
944  }
945 
946  /* Try to read more data. */
947 
948  /* First move last chars to start of buffer. */
949  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
950 
951  for ( i = 0; i < number_to_move; ++i )
952  *(dest++) = *(source++);
953 
954  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
955  /* don't do the read, it's not guaranteed to return an EOF,
956  * just force an EOF
957  */
958  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
959 
960  else
961  {
962  yy_size_t num_to_read =
963  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
964 
965  while ( num_to_read <= 0 )
966  { /* Not enough room in the buffer - grow it. */
967 
968  /* just a shorter name for the current buffer */
969  YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
970 
971  int yy_c_buf_p_offset =
972  (int) ((yy_c_buf_p) - b->yy_ch_buf);
973 
974  if ( b->yy_is_our_buffer )
975  {
976  yy_size_t new_size = b->yy_buf_size * 2;
977 
978  if ( new_size <= 0 )
979  b->yy_buf_size += b->yy_buf_size / 8;
980  else
981  b->yy_buf_size *= 2;
982 
983  b->yy_ch_buf = (char *)
984  /* Include room in for 2 EOB chars. */
985  yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
986  }
987  else
988  /* Can't grow it, we don't own it. */
989  b->yy_ch_buf = 0;
990 
991  if ( ! b->yy_ch_buf )
993  "fatal error - scanner input buffer overflow" );
994 
995  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
996 
997  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
998  number_to_move - 1;
999 
1000  }
1001 
1002  if ( num_to_read > YY_READ_BUF_SIZE )
1003  num_to_read = YY_READ_BUF_SIZE;
1004 
1005  /* Read in more data. */
1006  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1007  (yy_n_chars), num_to_read );
1008 
1009  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1010  }
1011 
1012  if ( (yy_n_chars) == 0 )
1013  {
1014  if ( number_to_move == YY_MORE_ADJ )
1015  {
1016  ret_val = EOB_ACT_END_OF_FILE;
1017  yyrestart(yyin );
1018  }
1019 
1020  else
1021  {
1022  ret_val = EOB_ACT_LAST_MATCH;
1023  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1025  }
1026  }
1027 
1028  else
1029  ret_val = EOB_ACT_CONTINUE_SCAN;
1030 
1031  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1032  /* Extend the array by 50%, plus the number we really need. */
1033  yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1034  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1035  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1036  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1037  }
1038 
1039  (yy_n_chars) += number_to_move;
1042 
1043  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1044 
1045  return ret_val;
1046 }
1047 
1048 /* yy_get_previous_state - get the state just before the EOB char was reached */
1049 
1050  static yy_state_type yy_get_previous_state (void)
1051 {
1052  register yy_state_type yy_current_state;
1053  register char *yy_cp;
1054 
1055  yy_current_state = (yy_start);
1056 
1057  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1058  {
1059  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1060  if ( yy_accept[yy_current_state] )
1061  {
1062  (yy_last_accepting_state) = yy_current_state;
1063  (yy_last_accepting_cpos) = yy_cp;
1064  }
1065  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1066  {
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];
1070  }
1071  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1072  }
1073 
1074  return yy_current_state;
1075 }
1076 
1077 /* yy_try_NUL_trans - try to make a transition on the NUL character
1078  *
1079  * synopsis
1080  * next_state = yy_try_NUL_trans( current_state );
1081  */
1082  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1083 {
1084  register int yy_is_jam;
1085  register char *yy_cp = (yy_c_buf_p);
1086 
1087  register YY_CHAR yy_c = 1;
1088  if ( yy_accept[yy_current_state] )
1089  {
1090  (yy_last_accepting_state) = yy_current_state;
1091  (yy_last_accepting_cpos) = yy_cp;
1092  }
1093  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1094  {
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];
1098  }
1099  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1100  yy_is_jam = (yy_current_state == 20);
1101 
1102  return yy_is_jam ? 0 : yy_current_state;
1103 }
1104 
1105  static void yyunput (int c, register char * yy_bp )
1106 {
1107  register char *yy_cp;
1108 
1109  yy_cp = (yy_c_buf_p);
1110 
1111  /* undo effects of setting up yytext */
1112  *yy_cp = (yy_hold_char);
1113 
1114  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1115  { /* need to shift things up to make room */
1116  /* +2 for EOB chars. */
1117  register yy_size_t number_to_move = (yy_n_chars) + 2;
1118  register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1119  YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1120  register char *source =
1121  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1122 
1123  while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1124  *--dest = *--source;
1125 
1126  yy_cp += (int) (dest - source);
1127  yy_bp += (int) (dest - source);
1128  YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1129  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1130 
1131  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1132  YY_FATAL_ERROR( "flex scanner push-back overflow" );
1133  }
1134 
1135  *--yy_cp = (char) c;
1136 
1137  (yytext_ptr) = yy_bp;
1138  (yy_hold_char) = *yy_cp;
1139  (yy_c_buf_p) = yy_cp;
1140 }
1141 
1142 #ifndef YY_NO_INPUT
1143 #ifdef __cplusplus
1144  static int yyinput (void)
1145 #else
1146  static int input (void)
1147 #endif
1148 
1149 {
1150  int c;
1151 
1152  *(yy_c_buf_p) = (yy_hold_char);
1153 
1154  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1155  {
1156  /* yy_c_buf_p now points to the character we want to return.
1157  * If this occurs *before* the EOB characters, then it's a
1158  * valid NUL; if not, then we've hit the end of the buffer.
1159  */
1160  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1161  /* This was really a NUL. */
1162  *(yy_c_buf_p) = '\0';
1163 
1164  else
1165  { /* need more input */
1166  yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1167  ++(yy_c_buf_p);
1168 
1169  switch ( yy_get_next_buffer( ) )
1170  {
1171  case EOB_ACT_LAST_MATCH:
1172  /* This happens because yy_g_n_b()
1173  * sees that we've accumulated a
1174  * token and flags that we need to
1175  * try matching the token before
1176  * proceeding. But for input(),
1177  * there's no matching to consider.
1178  * So convert the EOB_ACT_LAST_MATCH
1179  * to EOB_ACT_END_OF_FILE.
1180  */
1181 
1182  /* Reset buffer status. */
1183  yyrestart(yyin );
1184 
1185  /*FALLTHROUGH*/
1186 
1187  case EOB_ACT_END_OF_FILE:
1188  {
1189  if ( yywrap( ) )
1190  return EOF;
1191 
1192  if ( ! (yy_did_buffer_switch_on_eof) )
1193  YY_NEW_FILE;
1194 #ifdef __cplusplus
1195  return yyinput();
1196 #else
1197  return input();
1198 #endif
1199  }
1200 
1201  case EOB_ACT_CONTINUE_SCAN:
1202  (yy_c_buf_p) = (yytext_ptr) + offset;
1203  break;
1204  }
1205  }
1206  }
1207 
1208  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1209  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1210  (yy_hold_char) = *++(yy_c_buf_p);
1211 
1212  return c;
1213 }
1214 #endif /* ifndef YY_NO_INPUT */
1215 
1221  void yyrestart (FILE * input_file )
1222 {
1223 
1224  if ( ! YY_CURRENT_BUFFER ){
1228  }
1229 
1230  yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1232 }
1233 
1238  void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1239 {
1240 
1241  /* TODO. We should be able to replace this entire function body
1242  * with
1243  * yypop_buffer_state();
1244  * yypush_buffer_state(new_buffer);
1245  */
1247  if ( YY_CURRENT_BUFFER == new_buffer )
1248  return;
1249 
1250  if ( YY_CURRENT_BUFFER )
1251  {
1252  /* Flush out information for old buffer. */
1253  *(yy_c_buf_p) = (yy_hold_char);
1254  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1255  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1256  }
1257 
1258  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1260 
1261  /* We don't actually know whether we did this switch during
1262  * EOF (yywrap()) processing, but the only time this flag
1263  * is looked at is after yywrap() is called, so it's safe
1264  * to go ahead and always set it.
1265  */
1267 }
1268 
1269 static void yy_load_buffer_state (void)
1270 {
1271  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1272  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1273  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1274  (yy_hold_char) = *(yy_c_buf_p);
1275 }
1276 
1283  YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1284 {
1285  YY_BUFFER_STATE b;
1286 
1287  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1288  if ( ! b )
1289  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1290 
1291  b->yy_buf_size = size;
1292 
1293  /* yy_ch_buf has to be 2 characters longer than the size given because
1294  * we need to put in 2 end-of-buffer characters.
1295  */
1296  b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
1297  if ( ! b->yy_ch_buf )
1298  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1299 
1300  b->yy_is_our_buffer = 1;
1301 
1302  yy_init_buffer(b,file );
1303 
1304  return b;
1305 }
1306 
1311  void yy_delete_buffer (YY_BUFFER_STATE b )
1312 {
1313 
1314  if ( ! b )
1315  return;
1316 
1317  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1319 
1320  if ( b->yy_is_our_buffer )
1321  yyfree((void *) b->yy_ch_buf );
1322 
1323  yyfree((void *) b );
1324 }
1325 
1326 /* Initializes or reinitializes a buffer.
1327  * This function is sometimes called more than once on the same buffer,
1328  * such as during a yyrestart() or at EOF.
1329  */
1330  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1331 
1332 {
1333  int oerrno = errno;
1334 
1335  yy_flush_buffer(b );
1336 
1337  b->yy_input_file = file;
1338  b->yy_fill_buffer = 1;
1339 
1340  /* If b is the current buffer, then yy_init_buffer was _probably_
1341  * called from yyrestart() or through yy_get_next_buffer.
1342  * In that case, we don't want to reset the lineno or column.
1343  */
1344  if (b != YY_CURRENT_BUFFER){
1345  b->yy_bs_lineno = 1;
1346  b->yy_bs_column = 0;
1347  }
1348 
1349  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1350 
1351  errno = oerrno;
1352 }
1353 
1358  void yy_flush_buffer (YY_BUFFER_STATE b )
1359 {
1360  if ( ! b )
1361  return;
1362 
1363  b->yy_n_chars = 0;
1364 
1365  /* We always need two end-of-buffer characters. The first causes
1366  * a transition to the end-of-buffer state. The second causes
1367  * a jam in that state.
1368  */
1371 
1372  b->yy_buf_pos = &b->yy_ch_buf[0];
1373 
1374  b->yy_at_bol = 1;
1376 
1377  if ( b == YY_CURRENT_BUFFER )
1379 }
1380 
1387 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1388 {
1389  if (new_buffer == NULL)
1390  return;
1391 
1393 
1394  /* This block is copied from yy_switch_to_buffer. */
1395  if ( YY_CURRENT_BUFFER )
1396  {
1397  /* Flush out information for old buffer. */
1398  *(yy_c_buf_p) = (yy_hold_char);
1399  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1400  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1401  }
1402 
1403  /* Only push if top exists. Otherwise, replace top. */
1404  if (YY_CURRENT_BUFFER)
1405  (yy_buffer_stack_top)++;
1406  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1407 
1408  /* copied from yy_switch_to_buffer. */
1411 }
1412 
1418 {
1419  if (!YY_CURRENT_BUFFER)
1420  return;
1421 
1423  YY_CURRENT_BUFFER_LVALUE = NULL;
1424  if ((yy_buffer_stack_top) > 0)
1425  --(yy_buffer_stack_top);
1426 
1427  if (YY_CURRENT_BUFFER) {
1430  }
1431 }
1432 
1433 /* Allocates the stack if it does not exist.
1434  * Guarantees space for at least one push.
1435  */
1436 static void yyensure_buffer_stack (void)
1437 {
1438  yy_size_t num_to_alloc;
1439 
1440  if (!(yy_buffer_stack)) {
1441 
1442  /* First allocation is just for 2 elements, since we don't know if this
1443  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1444  * immediate realloc on the next call.
1445  */
1446  num_to_alloc = 1;
1448  (num_to_alloc * sizeof(struct yy_buffer_state*)
1449  );
1450  if ( ! (yy_buffer_stack) )
1451  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1452 
1453  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1454 
1455  (yy_buffer_stack_max) = num_to_alloc;
1456  (yy_buffer_stack_top) = 0;
1457  return;
1458  }
1459 
1460  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1461 
1462  /* Increase the buffer to prepare for a possible push. */
1463  int grow_size = 8 /* arbitrary grow size */;
1464 
1465  num_to_alloc = (yy_buffer_stack_max) + grow_size;
1467  ((yy_buffer_stack),
1468  num_to_alloc * sizeof(struct yy_buffer_state*)
1469  );
1470  if ( ! (yy_buffer_stack) )
1471  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1472 
1473  /* zero only the new slots.*/
1474  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1475  (yy_buffer_stack_max) = num_to_alloc;
1476  }
1477 }
1478 
1485 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1486 {
1487  YY_BUFFER_STATE b;
1488 
1489  if ( size < 2 ||
1490  base[size-2] != YY_END_OF_BUFFER_CHAR ||
1491  base[size-1] != YY_END_OF_BUFFER_CHAR )
1492  /* They forgot to leave room for the EOB's. */
1493  return 0;
1494 
1495  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
1496  if ( ! b )
1497  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1498 
1499  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1500  b->yy_buf_pos = b->yy_ch_buf = base;
1501  b->yy_is_our_buffer = 0;
1502  b->yy_input_file = 0;
1503  b->yy_n_chars = b->yy_buf_size;
1504  b->yy_is_interactive = 0;
1505  b->yy_at_bol = 1;
1506  b->yy_fill_buffer = 0;
1508 
1509  yy_switch_to_buffer(b );
1510 
1511  return b;
1512 }
1513 
1522 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1523 {
1524 
1525  return yy_scan_bytes(yystr,strlen(yystr) );
1526 }
1527 
1535 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
1536 {
1537  YY_BUFFER_STATE b;
1538  char *buf;
1539  yy_size_t n;
1540  yy_size_t i;
1541 
1542  /* Get memory for full buffer, including space for trailing EOB's. */
1543  n = _yybytes_len + 2;
1544  buf = (char *) yyalloc(n );
1545  if ( ! buf )
1546  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1547 
1548  for ( i = 0; i < _yybytes_len; ++i )
1549  buf[i] = yybytes[i];
1550 
1551  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1552 
1553  b = yy_scan_buffer(buf,n );
1554  if ( ! b )
1555  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1556 
1557  /* It's okay to grow etc. this buffer, and we should throw it
1558  * away when we're done.
1559  */
1560  b->yy_is_our_buffer = 1;
1561 
1562  return b;
1563 }
1564 
1565 #ifndef YY_EXIT_FAILURE
1566 #define YY_EXIT_FAILURE 2
1567 #endif
1568 
1569 static void yy_fatal_error (yyconst char* msg )
1570 {
1571  (void) fprintf( stderr, "%s\n", msg );
1572  exit( YY_EXIT_FAILURE );
1573 }
1574 
1575 /* Redefine yyless() so it works in section 3 code. */
1576 
1577 #undef yyless
1578 #define yyless(n) \
1579  do \
1580  { \
1581  /* Undo effects of setting up yytext. */ \
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; \
1589  } \
1590  while ( 0 )
1591 
1592 /* Accessor methods (get/set functions) to struct members. */
1593 
1597 int yyget_lineno (void)
1598 {
1599 
1600  return yylineno;
1601 }
1602 
1606 FILE *yyget_in (void)
1607 {
1608  return yyin;
1609 }
1610 
1614 FILE *yyget_out (void)
1615 {
1616  return yyout;
1617 }
1618 
1623 {
1624  return yyleng;
1625 }
1626 
1631 char *yyget_text (void)
1632 {
1633  return yytext;
1634 }
1635 
1640 void yyset_lineno (int line_number )
1641 {
1642 
1643  yylineno = line_number;
1644 }
1645 
1652 void yyset_in (FILE * in_str )
1653 {
1654  yyin = in_str ;
1655 }
1656 
1657 void yyset_out (FILE * out_str )
1658 {
1659  yyout = out_str ;
1660 }
1661 
1662 int yyget_debug (void)
1663 {
1664  return yy_flex_debug;
1665 }
1666 
1667 void yyset_debug (int bdebug )
1668 {
1669  yy_flex_debug = bdebug ;
1670 }
1671 
1672 static int yy_init_globals (void)
1673 {
1674  /* Initialization is the same as for the non-reentrant scanner.
1675  * This function is called from yylex_destroy(), so don't allocate here.
1676  */
1677 
1678  (yy_buffer_stack) = 0;
1679  (yy_buffer_stack_top) = 0;
1680  (yy_buffer_stack_max) = 0;
1681  (yy_c_buf_p) = (char *) 0;
1682  (yy_init) = 0;
1683  (yy_start) = 0;
1684 
1685 /* Defined in main.c */
1686 #ifdef YY_STDINIT
1687  yyin = stdin;
1688  yyout = stdout;
1689 #else
1690  yyin = (FILE *) 0;
1691  yyout = (FILE *) 0;
1692 #endif
1693 
1694  /* For future reference: Set errno on error, since we are called by
1695  * yylex_init()
1696  */
1697  return 0;
1698 }
1699 
1700 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1701 int yylex_destroy (void)
1702 {
1703 
1704  /* Pop the buffer stack, destroying each element. */
1705  while(YY_CURRENT_BUFFER){
1707  YY_CURRENT_BUFFER_LVALUE = NULL;
1709  }
1710 
1711  /* Destroy the stack itself. */
1712  yyfree((yy_buffer_stack) );
1713  (yy_buffer_stack) = NULL;
1714 
1715  /* Reset the globals. This is important in a non-reentrant scanner so the next time
1716  * yylex() is called, initialization will occur. */
1717  yy_init_globals( );
1718 
1719  return 0;
1720 }
1721 
1722 /*
1723  * Internal utility routines.
1724  */
1725 
1726 #ifndef yytext_ptr
1727 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1728 {
1729  register int i;
1730  for ( i = 0; i < n; ++i )
1731  s1[i] = s2[i];
1732 }
1733 #endif
1734 
1735 #ifdef YY_NEED_STRLEN
1736 static int yy_flex_strlen (yyconst char * s )
1737 {
1738  register int n;
1739  for ( n = 0; s[n]; ++n )
1740  ;
1741 
1742  return n;
1743 }
1744 #endif
1745 
1746 void *yyalloc (yy_size_t size )
1747 {
1748  return (void *) malloc( size );
1749 }
1750 
1751 void *yyrealloc (void * ptr, yy_size_t size )
1752 {
1753  /* The cast to (char *) in the following accommodates both
1754  * implementations that use char* generic pointers, and those
1755  * that use void* generic pointers. It works with the latter
1756  * because both ANSI C and C++ allow castless assignment from
1757  * any pointer type to void*, and deal with argument conversions
1758  * as though doing an assignment.
1759  */
1760  return (void *) realloc( (char *) ptr, size );
1761 }
1762 
1763 void yyfree (void * ptr )
1764 {
1765  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1766 }
1767 
1768 #define YYTABLES_NAME "yytables"
1769 
1770 #line 18 "build/parseReqs.l"
1771 
1772 
1773 
#define EOB_ACT_CONTINUE_SCAN
Definition: lex.yy.c:165
signed char flex_int8_t
Definition: lex.yy.c:50
void yyrestart(FILE *input_file)
Immediately switch to a different input stream.
Definition: lex.yy.c:1221
void yyset_extra(void *user_defined)
void * yyrealloc(void *, yy_size_t)
Definition: lex.yy.c:1751
int yy_state_type
Definition: lex.yy.c:339
static flex_int16_t yy_base[22]
Definition: lex.yy.c:416
#define YY_BREAK
Definition: lex.yy.c:631
int yy_fill_buffer
Definition: lex.yy.c:231
#define YY_INPUT(buf, result, max_size)
Definition: lex.yy.c:559
struct yy_buffer_state * YY_BUFFER_STATE
Definition: lex.yy.c:153
#define YY_STATE_EOF(state)
Definition: lex.yy.c:135
#define YY_RESTORE_YY_MORE_OFFSET
Definition: lex.yy.c:458
void yyfree(void *)
Definition: lex.yy.c:1763
static flex_int16_t yy_accept[21]
Definition: lex.yy.c:372
static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: lex.yy.c:1330
static void yyensure_buffer_stack(void)
Definition: lex.yy.c:1436
static int yy_get_next_buffer(void)
Definition: lex.yy.c:916
char * yyget_text(void)
Get the current token.
Definition: lex.yy.c:1631
int yy_bs_lineno
The line count.
Definition: lex.yy.c:225
yy_size_t yyleng
Definition: lex.yy.c:275
yy_size_t yyget_leng(void)
Get the length of the current token.
Definition: lex.yy.c:1622
#define YY_MORE_ADJ
Definition: lex.yy.c:457
void yyset_out(FILE *out_str)
Definition: lex.yy.c:1657
static int input(void)
Definition: lex.yy.c:1146
static flex_int16_t yy_chk[40]
Definition: lex.yy.c:438
#define YY_DECL
Definition: lex.yy.c:619
FILE * yyin
Definition: lex.yy.c:337
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Switch to a different input buffer.
Definition: lex.yy.c:1238
#define EOB_ACT_LAST_MATCH
Definition: lex.yy.c:167
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition: lex.yy.c:1082
#define YY_CURRENT_BUFFER
Definition: lex.yy.c:263
char * yy_buf_pos
Definition: lex.yy.c:194
int yyget_lineno(void)
Get the current line number.
Definition: lex.yy.c:1597
int flex_int32_t
Definition: lex.yy.c:52
static YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
Definition: lex.yy.c:255
yy_size_t yy_buf_size
Definition: lex.yy.c:199
#define YY_DO_BEFORE_ACTION
Definition: lex.yy.c:356
void yypush_buffer_state(YY_BUFFER_STATE new_buffer)
Pushes the new state onto the stack.
Definition: lex.yy.c:1387
void yyset_debug(int debug_flag)
Definition: lex.yy.c:1667
yy_size_t yy_n_chars
Definition: lex.yy.c:204
int yylineno
Definition: lex.yy.c:343
static int source
Definition: rpmspec.c:20
static int yy_init
Definition: lex.yy.c:279
#define INITIAL
Definition: lex.yy.c:465
static char * yy_last_accepting_cpos
Definition: lex.yy.c:447
static char * yy_c_buf_p
Definition: lex.yy.c:278
FILE * yyget_in(void)
Get the input stream.
Definition: lex.yy.c:1606
static yy_state_type yy_last_accepting_state
Definition: lex.yy.c:446
unsigned int flex_uint32_t
Definition: lex.yy.c:55
static flex_int32_t yy_ec[256]
Definition: lex.yy.c:378
#define YY_READ_BUF_SIZE
Definition: lex.yy.c:544
#define YY_BUFFER_NORMAL
Definition: lex.yy.c:236
#define YY_BUFFER_NEW
Definition: lex.yy.c:235
int yy_bs_column
The column count.
Definition: lex.yy.c:226
static int yy_init_globals(void)
Definition: lex.yy.c:1672
void yyset_in(FILE *in_str)
Set the input stream.
Definition: lex.yy.c:1652
static void yy_fatal_error(char msg[])
size_t yy_size_t
Definition: lex.yy.c:158
unsigned short int flex_uint16_t
Definition: lex.yy.c:54
#define YY_CURRENT_BUFFER_LVALUE
Definition: lex.yy.c:270
#define ECHO
Definition: lex.yy.c:552
#define YY_END_OF_BUFFER
Definition: lex.yy.c:364
#define YY_END_OF_BUFFER_CHAR
Definition: lex.yy.c:140
#define yyconst
Definition: lex.yy.c:108
int yywrap(void)
#define YY_BUFFER_EOF_PENDING
Definition: lex.yy.c:247
static int yy_start
Definition: lex.yy.c:280
static void yyunput(int c, char *buf_ptr)
#define EOB_ACT_END_OF_FILE
Definition: lex.yy.c:166
static int yy_did_buffer_switch_on_eof
Definition: lex.yy.c:285
YY_BUFFER_STATE yy_scan_string(char *yy_str)
Setup the input buffer state to scan a string.
Definition: lex.yy.c:1522
static flex_int32_t yy_meta[16]
Definition: lex.yy.c:410
YY_BUFFER_STATE yy_scan_bytes(char *bytes, yy_size_t len)
Setup the input buffer state to scan the given bytes.
Definition: lex.yy.c:1535
void * yyalloc(yy_size_t)
Definition: lex.yy.c:1746
#define YY_FATAL_ERROR(msg)
Definition: lex.yy.c:606
int yy_is_our_buffer
Definition: lex.yy.c:210
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.
Definition: lex.yy.c:1485
static yy_size_t yy_n_chars
Definition: lex.yy.c:274
short int flex_int16_t
Definition: lex.yy.c:51
int yylex(void)
The main scanner function which does all the work.
Definition: lex.yy.c:639
char * yy_ch_buf
Definition: lex.yy.c:193
static size_t yy_buffer_stack_max
capacity of stack.
Definition: lex.yy.c:254
void * yyget_extra(void)
FILE * yyout
Definition: lex.yy.c:337
#define YY_EXTRA_TYPE
Definition: lex.yy.c:476
#define YY_SC_TO_UI(c)
Definition: lex.yy.c:119
static yy_state_type yy_get_previous_state(void)
Definition: lex.yy.c:1050
unsigned char YY_CHAR
Definition: lex.yy.c:335
flex_int32_t yy_verify
Definition: lex.yy.c:369
static void yy_load_buffer_state(void)
Definition: lex.yy.c:1269
#define YY_RULE_SETUP
Definition: lex.yy.c:634
#define YY_START
Definition: lex.yy.c:131
static size_t yy_buffer_stack_top
index of top of stack.
Definition: lex.yy.c:253
int yylex_destroy(void)
Definition: lex.yy.c:1701
void yy_flush_buffer(YY_BUFFER_STATE b)
Discard all buffered characters.
Definition: lex.yy.c:1358
int yy_flex_debug
Definition: lex.yy.c:450
FILE * yy_input_file
Definition: lex.yy.c:191
unsigned char flex_uint8_t
Definition: lex.yy.c:53
#define YY_BUF_SIZE
Definition: lex.yy.c:144
static char yy_hold_char
Definition: lex.yy.c:273
flex_int32_t yy_nxt
Definition: lex.yy.c:370
void yypop_buffer_state(void)
Removes and deletes the top of the stack, if present.
Definition: lex.yy.c:1417
int yy_is_interactive
Definition: lex.yy.c:217
FILE * yyget_out(void)
Get the output stream.
Definition: lex.yy.c:1614
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Allocate and initialize an input buffer state.
Definition: lex.yy.c:1283
void yy_delete_buffer(YY_BUFFER_STATE b)
Destroy the buffer.
Definition: lex.yy.c:1311
int yyget_debug(void)
Definition: lex.yy.c:1662
char * yytext
Definition: lex.yy.c:459
#define YY_EXIT_FAILURE
Definition: lex.yy.c:1566
int yy_buffer_status
Definition: lex.yy.c:233
#define yytext_ptr
Definition: lex.yy.c:346
void yyset_lineno(int line_number)
Set the current line number.
Definition: lex.yy.c:1640
#define YY_NEW_FILE
Definition: lex.yy.c:138
static flex_int16_t yy_nxt[40]
Definition: lex.yy.c:430
#define yyterminate()
Definition: lex.yy.c:596
static flex_int16_t yy_def[22]
Definition: lex.yy.c:423