SignatureGenerator: Add empty implementation for dump_sigs
[bitbake.git] / parse_c / bitbakescanner.cc
1
2 #line 3 "<stdout>"
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 31
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 #include <inttypes.h>
35 typedef int8_t flex_int8_t;
36 typedef uint8_t flex_uint8_t;
37 typedef int16_t flex_int16_t;
38 typedef uint16_t flex_uint16_t;
39 typedef int32_t flex_int32_t;
40 typedef uint32_t flex_uint32_t;
41 #else
42 typedef signed char flex_int8_t;
43 typedef short int flex_int16_t;
44 typedef int flex_int32_t;
45 typedef unsigned char flex_uint8_t; 
46 typedef unsigned short int flex_uint16_t;
47 typedef unsigned int flex_uint32_t;
48 #endif /* ! C99 */
49
50 /* Limits of integral types. */
51 #ifndef INT8_MIN
52 #define INT8_MIN               (-128)
53 #endif
54 #ifndef INT16_MIN
55 #define INT16_MIN              (-32767-1)
56 #endif
57 #ifndef INT32_MIN
58 #define INT32_MIN              (-2147483647-1)
59 #endif
60 #ifndef INT8_MAX
61 #define INT8_MAX               (127)
62 #endif
63 #ifndef INT16_MAX
64 #define INT16_MAX              (32767)
65 #endif
66 #ifndef INT32_MAX
67 #define INT32_MAX              (2147483647)
68 #endif
69 #ifndef UINT8_MAX
70 #define UINT8_MAX              (255U)
71 #endif
72 #ifndef UINT16_MAX
73 #define UINT16_MAX             (65535U)
74 #endif
75 #ifndef UINT32_MAX
76 #define UINT32_MAX             (4294967295U)
77 #endif
78
79 #endif /* ! FLEXINT_H */
80
81 #ifdef __cplusplus
82
83 /* The "const" storage-class-modifier is valid. */
84 #define YY_USE_CONST
85
86 #else   /* ! __cplusplus */
87
88 #if __STDC__
89
90 #define YY_USE_CONST
91
92 #endif  /* __STDC__ */
93 #endif  /* ! __cplusplus */
94
95 #ifdef YY_USE_CONST
96 #define yyconst const
97 #else
98 #define yyconst
99 #endif
100
101 /* Returned upon end-of-file. */
102 #define YY_NULL 0
103
104 /* Promotes a possibly negative, possibly signed char to an unsigned
105  * integer for use as an array index.  If the signed char is negative,
106  * we want to instead treat it as an 8-bit unsigned char, hence the
107  * double cast.
108  */
109 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
110
111 /* An opaque pointer. */
112 #ifndef YY_TYPEDEF_YY_SCANNER_T
113 #define YY_TYPEDEF_YY_SCANNER_T
114 typedef void* yyscan_t;
115 #endif
116
117 /* For convenience, these vars (plus the bison vars far below)
118    are macros in the reentrant scanner. */
119 #define yyin yyg->yyin_r
120 #define yyout yyg->yyout_r
121 #define yyextra yyg->yyextra_r
122 #define yyleng yyg->yyleng_r
123 #define yytext yyg->yytext_r
124 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
125 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
126 #define yy_flex_debug yyg->yy_flex_debug_r
127
128 int yylex_init (yyscan_t* scanner);
129
130 /* Enter a start condition.  This macro really ought to take a parameter,
131  * but we do it the disgusting crufty way forced on us by the ()-less
132  * definition of BEGIN.
133  */
134 #define BEGIN yyg->yy_start = 1 + 2 *
135
136 /* Translate the current start state into a value that can be later handed
137  * to BEGIN to return to the state.  The YYSTATE alias is for lex
138  * compatibility.
139  */
140 #define YY_START ((yyg->yy_start - 1) / 2)
141 #define YYSTATE YY_START
142
143 /* Action number for EOF rule of a given start state. */
144 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
145
146 /* Special action meaning "start processing a new file". */
147 #define YY_NEW_FILE yyrestart(yyin ,yyscanner )
148
149 #define YY_END_OF_BUFFER_CHAR 0
150
151 /* Size of default input buffer. */
152 #ifndef YY_BUF_SIZE
153 #define YY_BUF_SIZE 16384
154 #endif
155
156 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
157 #define YY_TYPEDEF_YY_BUFFER_STATE
158 typedef struct yy_buffer_state *YY_BUFFER_STATE;
159 #endif
160
161 #define EOB_ACT_CONTINUE_SCAN 0
162 #define EOB_ACT_END_OF_FILE 1
163 #define EOB_ACT_LAST_MATCH 2
164
165     /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
166      *       access to the local variable yy_act. Since yyless() is a macro, it would break
167      *       existing scanners that call yyless() from OUTSIDE yylex. 
168      *       One obvious solution it to make yy_act a global. I tried that, and saw
169      *       a 5% performance hit in a non-yylineno scanner, because yy_act is
170      *       normally declared as a register variable-- so it is not worth it.
171      */
172     #define  YY_LESS_LINENO(n) \
173             do { \
174                 int yyl;\
175                 for ( yyl = n; yyl < yyleng; ++yyl )\
176                     if ( yytext[yyl] == '\n' )\
177                         --yylineno;\
178             }while(0)
179     
180 /* Return all but the first "n" matched characters back to the input stream. */
181 #define yyless(n) \
182         do \
183                 { \
184                 /* Undo effects of setting up yytext. */ \
185         int yyless_macro_arg = (n); \
186         YY_LESS_LINENO(yyless_macro_arg);\
187                 *yy_cp = yyg->yy_hold_char; \
188                 YY_RESTORE_YY_MORE_OFFSET \
189                 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
190                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
191                 } \
192         while ( 0 )
193
194 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
195
196 /* The following is because we cannot portably get our hands on size_t
197  * (without autoconf's help, which isn't available because we want
198  * flex-generated scanners to compile on their own).
199  */
200
201 #ifndef YY_TYPEDEF_YY_SIZE_T
202 #define YY_TYPEDEF_YY_SIZE_T
203 typedef unsigned int yy_size_t;
204 #endif
205
206 #ifndef YY_STRUCT_YY_BUFFER_STATE
207 #define YY_STRUCT_YY_BUFFER_STATE
208 struct yy_buffer_state
209         {
210         FILE *yy_input_file;
211
212         char *yy_ch_buf;                /* input buffer */
213         char *yy_buf_pos;               /* current position in input buffer */
214
215         /* Size of input buffer in bytes, not including room for EOB
216          * characters.
217          */
218         yy_size_t yy_buf_size;
219
220         /* Number of characters read into yy_ch_buf, not including EOB
221          * characters.
222          */
223         int yy_n_chars;
224
225         /* Whether we "own" the buffer - i.e., we know we created it,
226          * and can realloc() it to grow it, and should free() it to
227          * delete it.
228          */
229         int yy_is_our_buffer;
230
231         /* Whether this is an "interactive" input source; if so, and
232          * if we're using stdio for input, then we want to use getc()
233          * instead of fread(), to make sure we stop fetching input after
234          * each newline.
235          */
236         int yy_is_interactive;
237
238         /* Whether we're considered to be at the beginning of a line.
239          * If so, '^' rules will be active on the next match, otherwise
240          * not.
241          */
242         int yy_at_bol;
243
244     int yy_bs_lineno; /**< The line count. */
245     int yy_bs_column; /**< The column count. */
246     
247         /* Whether to try to fill the input buffer when we reach the
248          * end of it.
249          */
250         int yy_fill_buffer;
251
252         int yy_buffer_status;
253
254 #define YY_BUFFER_NEW 0
255 #define YY_BUFFER_NORMAL 1
256         /* When an EOF's been seen but there's still some text to process
257          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
258          * shouldn't try reading from the input source any more.  We might
259          * still have a bunch of tokens to match, though, because of
260          * possible backing-up.
261          *
262          * When we actually see the EOF, we change the status to "new"
263          * (via yyrestart()), so that the user can continue scanning by
264          * just pointing yyin at a new input file.
265          */
266 #define YY_BUFFER_EOF_PENDING 2
267
268         };
269 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
270
271 /* We provide macros for accessing buffer states in case in the
272  * future we want to put the buffer states in a more general
273  * "scanner state".
274  *
275  * Returns the top of the stack, or NULL.
276  */
277 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
278                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
279                           : NULL)
280
281 /* Same as previous macro, but useful when we know that the buffer stack is not
282  * NULL or when we need an lvalue. For internal use only.
283  */
284 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
285
286 void yyrestart (FILE *input_file ,yyscan_t yyscanner );
287 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
288 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
289 void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
290 void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
291 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
292 void yypop_buffer_state (yyscan_t yyscanner );
293
294 static void yyensure_buffer_stack (yyscan_t yyscanner );
295 static void yy_load_buffer_state (yyscan_t yyscanner );
296 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
297
298 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
299
300 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
301 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
302 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
303
304 void *yyalloc (yy_size_t ,yyscan_t yyscanner );
305 void *yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
306 void yyfree (void * ,yyscan_t yyscanner );
307
308 #define yy_new_buffer yy_create_buffer
309
310 #define yy_set_interactive(is_interactive) \
311         { \
312         if ( ! YY_CURRENT_BUFFER ){ \
313         yyensure_buffer_stack (yyscanner); \
314                 YY_CURRENT_BUFFER_LVALUE =    \
315             yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
316         } \
317         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
318         }
319
320 #define yy_set_bol(at_bol) \
321         { \
322         if ( ! YY_CURRENT_BUFFER ){\
323         yyensure_buffer_stack (yyscanner); \
324                 YY_CURRENT_BUFFER_LVALUE =    \
325             yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
326         } \
327         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
328         }
329
330 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
331
332 /* Begin user sect3 */
333
334 #define yywrap(n) 1
335 #define YY_SKIP_YYWRAP
336
337 typedef unsigned char YY_CHAR;
338
339 typedef int yy_state_type;
340
341 #define yytext_ptr yytext_r
342
343 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
344 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
345 static int yy_get_next_buffer (yyscan_t yyscanner );
346 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
347
348 /* Done after the current pattern has been matched and before the
349  * corresponding action - sets up yytext.
350  */
351 #define YY_DO_BEFORE_ACTION \
352         yyg->yytext_ptr = yy_bp; \
353         yyleng = (size_t) (yy_cp - yy_bp); \
354         yyg->yy_hold_char = *yy_cp; \
355         *yy_cp = '\0'; \
356         yyg->yy_c_buf_p = yy_cp;
357
358 #define YY_NUM_RULES 45
359 #define YY_END_OF_BUFFER 46
360 /* This struct is not used in this scanner,
361    but its presence is necessary. */
362 struct yy_trans_info
363         {
364         flex_int32_t yy_verify;
365         flex_int32_t yy_nxt;
366         };
367 static yyconst flex_int16_t yy_accept[798] =
368     {   0,
369         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
370         0,    0,    0,    0,    0,    0,   24,   24,    0,    0,
371         0,    0,   46,   44,   43,   43,   44,   44,   44,   44,
372        44,    4,   44,   33,   33,   33,   33,   33,   33,   33,
373        33,   33,   26,   26,   26,   26,   26,   26,   44,   43,
374        28,   43,   44,   44,   44,   27,    4,   44,   44,   44,
375        44,   44,   44,   31,   31,   30,   31,   31,   31,   31,
376        31,    4,   31,   31,   31,   31,   31,   31,   41,   36,
377        36,   36,   36,   36,   36,   44,   38,   38,   38,   38,
378        38,   38,   42,   37,   37,   37,   37,   37,   37,   44,
379
380        39,   39,   39,   39,   39,   39,   24,   24,   24,   24,
381        24,   24,   24,    4,   24,   24,   24,   24,   24,   24,
382        23,    9,   43,   10,    9,   44,    9,   44,    9,    9,
383         9,    4,    9,    9,    9,    9,    9,    9,    9,   40,
384        35,   35,   35,   35,   35,   35,   35,    0,   32,   34,
385         0,    0,    1,    3,    2,    5,    0,   33,    0,   33,
386        33,   33,   33,   33,   33,   33,   33,   26,   26,   26,
387        26,   26,   26,    0,   27,    0,   28,    0,   27,    0,
388         0,    1,    2,    5,    0,    0,    0,    0,    0,    0,
389         0,   29,    0,    0,    0,    0,    0,   36,   36,   36,
390
391        36,   36,   36,    0,    0,   38,   38,   38,   38,   38,
392        38,   37,   37,   37,   37,   37,   37,    0,    0,   39,
393        39,   39,   39,   39,   39,   24,   24,   24,   24,   24,
394        24,    1,    3,    2,    5,   24,   24,   24,   24,   24,
395        23,   23,    9,    0,    9,    0,   10,    0,    7,    0,
396         9,    0,    9,    0,    8,    0,    0,    9,    1,    3,
397         2,    5,    9,    6,    9,    9,    9,    9,   35,   35,
398        35,   35,   35,   35,   35,   35,   34,    0,   22,    0,
399         0,   34,   33,   33,   25,   33,   33,   33,   33,   33,
400        33,   26,   26,   25,   26,   26,   26,    0,   22,    0,
401
402         0,   25,    0,    0,    0,    0,    0,   25,    0,    0,
403         0,   36,   36,   25,   36,   36,   36,    0,    0,   38,
404        38,   25,   38,   38,   38,   37,   37,   25,   37,   37,
405        37,    0,    0,   39,   39,   25,   39,   39,   39,   24,
406        22,   24,   24,   24,   24,   24,   24,   32,    0,    9,
407         9,    6,    9,    9,    9,    9,    9,   35,   35,   35,
408        35,   25,   35,   35,   35,   22,   22,    0,   33,   33,
409        33,   33,   33,   33,   33,   33,   33,   26,   26,   26,
410        26,   26,   26,   22,    0,    0,    0,    0,    0,    0,
411         0,    0,    0,    0,    0,    0,   36,   36,   36,   36,
412
413        36,   36,    0,   38,    0,   38,   38,   38,   38,   38,
414        38,   37,   37,   37,   37,   37,   37,    0,   39,    0,
415        39,   39,   39,   39,   39,   39,   22,   22,   24,   24,
416        24,   24,   24,   24,   22,    9,    9,    9,    9,    9,
417         9,   35,   35,   35,   35,   35,   35,   35,   35,    0,
418        34,   33,   33,   33,   33,   33,   33,   33,   33,   33,
419        26,   26,   26,   26,   26,   26,    0,    0,    0,    0,
420         0,    0,    0,    0,    0,    0,    0,    0,   36,   36,
421        36,   36,   36,   36,    0,   38,   38,   38,   38,   38,
422        38,   38,   37,   37,   37,   37,   37,   37,    0,   39,
423
424        39,   39,   39,   39,   39,   39,   24,   24,   24,   24,
425        24,   24,    9,    9,    9,    9,    9,    9,   35,   35,
426        35,   18,   35,   35,   35,   35,   33,   33,   33,   19,
427        33,   33,   33,   21,   33,   26,   26,   26,   26,   26,
428        26,    0,    0,    0,    0,    0,    0,    0,    0,    0,
429         0,    0,    0,   36,   36,   36,   36,   36,   36,   38,
430        38,   38,   38,   38,   38,   37,   37,   37,   37,   37,
431        37,   39,   39,   39,   39,   39,   39,   24,   24,   24,
432        24,   24,   24,    9,    9,    9,    9,    9,    9,   35,
433        35,   35,   17,   35,   35,   35,   33,   33,   14,   33,
434
435        11,   13,   12,   26,   26,   14,   11,   13,   12,    0,
436         0,   14,   11,   13,   12,    0,    0,   14,   11,   13,
437        12,   36,   36,   14,   11,   13,   12,   38,   38,   14,
438        11,   13,   12,   37,   37,   14,   11,   13,   12,   39,
439        39,   14,   11,   13,   12,   24,   24,   14,   11,   13,
440        12,    9,    9,    9,    9,    9,    9,   35,   35,   14,
441        11,   13,   12,   33,   33,   20,   26,   26,    0,    0,
442         0,    0,   36,   36,   38,   38,   37,   37,   39,   39,
443        24,   24,    9,    9,   35,   35,   33,   33,   26,   26,
444         0,    0,    0,    0,   36,   36,   38,   38,   37,   37,
445
446        39,   39,   24,   24,    9,    9,   35,   35,   33,   15,
447        26,   15,    0,   15,    0,   15,   36,   15,   38,   15,
448        37,   15,   39,   15,   24,   15,    9,    9,   35,   15,
449        33,   26,    0,    0,   36,   38,   37,   39,   24,    9,
450        35,   33,   26,    0,    0,   36,   38,   37,   39,   24,
451         9,   35,   33,   26,    0,    0,   36,   38,   37,   39,
452        24,    9,   35,   33,   26,    0,    0,   36,   38,   37,
453        39,   24,    9,   35,   33,   26,    0,    0,   36,   38,
454        37,   39,   24,    9,   35,   16,   16,   16,   16,   16,
455        16,   16,   16,   16,    9,   16,    0
456
457     } ;
458
459 static yyconst flex_int32_t yy_ec[256] =
460     {   0,
461         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
462         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
463         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
464         1,    2,    1,    5,    6,    7,    1,    1,    8,    9,
465        10,    1,   11,   12,   13,   14,   15,   16,   16,   16,
466        16,   16,   16,   16,   16,   16,   16,   17,    1,    1,
467        18,    1,   19,    1,   20,   20,   21,   20,   22,   23,
468        20,   20,   24,   20,   20,   20,   20,   25,   26,   27,
469        20,   28,   29,   30,   31,   20,   20,   32,   20,   20,
470        33,   34,   35,    1,   36,    1,   37,   38,   39,   40,
471
472        41,   42,   20,   43,   44,   20,   45,   46,   20,   47,
473        48,   49,   50,   51,   52,   53,   54,   20,   20,   55,
474        56,   20,   57,    1,   58,    1,    1,    1,    1,    1,
475         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
476         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
477         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
478         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
479         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
480         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
481         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
482
483         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
484         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
485         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
486         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
487         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
488         1,    1,    1,    1,    1
489     } ;
490
491 static yyconst flex_int32_t yy_meta[59] =
492     {   0,
493         1,    1,    2,    3,    1,    1,    4,    1,    1,    1,
494         5,    6,    5,    5,    7,    8,    1,    1,    1,    9,
495         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
496         9,    9,   10,    1,   11,    9,    9,    9,    9,    9,
497         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
498         9,    9,    9,    9,    9,    9,    1,   12
499     } ;
500
501 static yyconst flex_int16_t yy_base[832] =
502     {   0,
503         0,    0,   58,    0,  115,  165,  215,  265,  316,    0,
504       374,    0,  432,    0,  490,    0,  547,  604,  661,  711,
505       762,    0, 2156, 2157, 2157, 2157, 2152,    0,  118, 2136,
506      2135, 2141, 2133,  115,  118,  116,  120,  124,  140,  131,
507       129,  139,    0, 2118, 2109, 2107, 2100, 2105, 2128,  127,
508      2157, 2127,  137,  179,  124, 2125,  128,  173,  126,  146,
509       153,  118,  158, 2157,  190, 2157, 2157, 2139,  193, 2123,
510      2122, 2128, 2120, 2105, 2096, 2094, 2087, 2092, 2157,    0,
511      2100, 2091, 2089, 2082, 2087, 2070, 2119,  181,  190,  194,
512       153,  197, 2157,    0, 2093, 2084, 2082, 2075, 2080, 2063,
513
514      2112,  191,  199,  200,  201,  203, 2115, 2114, 2113, 2112,
515       212,  209,  222,  217,  228,  226,  233,  208,  239,  240,
516       248,  255,  251, 2111,  270,  251,  552,  254,  565,  575,
517       577,  622,  627,  626,  634,  612,  669,  684,  691, 2157,
518         0, 2081,  205, 2071, 2070, 2063, 2068, 2105, 2157,  257,
519       289,  559, 2157, 2157, 2157, 2157, 2050,  263, 2071,  270,
520       273,  555,  545,  556,  642,  585,  569,    0, 2078, 2064,
521      2061,  222, 2052, 2084, 2157,  290, 2157,  291, 2097,  674,
522       680, 2082, 2081, 2080,  283,  564,  554,  608,  262, 2093,
523       312, 2157, 2068, 2054, 2051,  529, 2042,    0, 2064, 2050,
524
525      2047,  611, 2038,    0, 2030, 2079,  646,  650,  652,  695,
526       593,    0, 2058, 2044, 2041,  661, 2032,    0, 2024, 2073,
527       680,  681,  699,  701,  702, 2076, 2075, 2074, 2073,  733,
528       819, 2072, 2071, 2070, 2069,  720,  600,  708,  820,  821,
529       724, 2068,  823,  824,  831,  751, 2067,  822,  830,  835,
530       839,  843,  847,  845,  846,  858,  880,  870,  881,  889,
531       891,  898,  903, 2067,  905,  914,  916,  926,    0, 2041,
532      2027, 2013, 2023, 2022,  703, 2013,  902,  841,  754,    0,
533      2027, 2157,  910,  919,  905,  913,  933,  934,  937,  940,
534       935, 2035,  258,    0, 2014, 2018, 2004,  947,  979,  732,
535
536       934, 2040,  912,  843,  707, 2030,  910, 2157, 2009, 2013,
537      1999, 2026,  922,    0, 2005, 2009, 1995, 1990,    0,  861,
538       926, 2040,  855,  947,  964, 2020,  941,    0, 1999, 2003,
539      1989, 1984,    0,  979,  950, 2034,  978,  984,  983,  995,
540       757,  989,  992, 2037,  996,  571,  997, 1004, 1005, 1014,
541      1006, 2037, 1021, 1025, 1026, 1039, 1041, 2012, 1010, 1996,
542      1988,    0, 1989, 1993, 1979,  999, 2029, 1973, 1043, 1049,
543      1050, 1051, 1058, 1059, 1060, 1070, 1061, 2002, 1992, 1991,
544      1973, 1975, 1981, 1087, 1053, 1061, 1062,  813, 1003, 1044,
545      1996, 1986, 1985, 1967, 1969, 1975, 1990, 1980, 1979, 1961,
546
547      1963, 1969, 1954, 2004, 1952,  867, 1078, 1089, 1062, 1090,
548      1093, 1981, 1971, 1970, 1952, 1954, 1960, 1945, 1995, 1943,
549      1094, 1099, 1101, 1100, 1105, 1103, 1117, 1997, 1111, 1114,
550      1118, 1120, 1121, 1122, 1125, 1141, 1127, 1155, 1160, 1165,
551      1174, 1971, 1961, 1960, 1945, 1944, 1940, 1942, 1948, 1933,
552      1138, 1151, 1170, 1145, 1173, 1176, 1179, 1178, 1180, 1188,
553      1960, 1942, 1936, 1947, 1942, 1934, 1114, 1173, 1136, 1183,
554      1181, 1179, 1954, 1936, 1930, 1941, 1936, 1928, 1948, 1930,
555      1924, 1935, 1930, 1922, 1914, 1964, 1198, 1184, 1141,  830,
556      1194, 1195, 1940, 1922, 1916, 1927, 1922, 1914, 1906, 1956,
557
558      1203, 1197, 1200, 1208, 1222, 1225, 1231, 1232, 1233, 1234,
559      1237, 1238, 1248, 1249, 1257, 1265, 1267, 1282, 1932, 1914,
560      1908,    0, 1918, 1918, 1913, 1905, 1235, 1253, 1270, 1273,
561      1281, 1285, 1287, 1288, 1290, 1919, 1914, 1908, 1911, 1898,
562      1909, 1228, 1285, 1283, 1281, 1290, 1291, 1913, 1908, 1902,
563      1905, 1892, 1903, 1907, 1902, 1896, 1899, 1886, 1897, 1303,
564      1297, 1305, 1306, 1310, 1312, 1901, 1896, 1890, 1893, 1880,
565      1891, 1320, 1317, 1323, 1328, 1327, 1329, 1335, 1338, 1339,
566      1341, 1342, 1345, 1347, 1356, 1357, 1371, 1392, 1396, 1895,
567      1890, 1884,    0, 1887, 1874, 1885, 1344, 1339, 1359, 1380,
568
569      1381, 1382, 1386, 1902, 1878,    0,    0,    0,    0, 1117,
570      1357, 1906, 1905, 1904, 1903, 1896, 1872, 2157, 2157, 2157,
571      2157, 1894, 1870,    0,    0,    0,    0, 1240, 1353, 1908,
572      1907, 1906, 1905, 1888, 1864,    0,    0,    0,    0, 1399,
573      1400, 1902, 1901, 1900, 1899, 1405, 1372, 1902, 1901, 1900,
574      1899, 1415, 1419, 1427, 1434, 1439, 1446, 1878, 1854,    0,
575         0,    0,    0, 1424, 1433, 1427, 1867, 1856, 1394, 1426,
576      1863, 1849, 1858, 1845, 1445, 1409, 1851, 1840, 1451, 1449,
577      1456, 1459, 1467, 1476, 1847, 1833, 1463, 1456, 1848, 1819,
578      1125, 1454, 1841, 1814, 1837, 1807, 1470, 1457, 1827, 1795,
579
580      1472, 1476, 1488, 1482, 1501, 1510, 1809, 1782, 1495, 1486,
581      1789,    0, 1503, 1792, 1776, 2157, 1747,    0, 1504, 1756,
582      1736,    0, 1515, 1745, 1483, 1712, 1529, 1537, 1690,    0,
583      1516, 1675, 1513, 1610, 1609, 1522, 1608, 1525, 1491, 1546,
584      1607, 1533, 1612, 1475, 1611, 1609, 1534, 1608, 1540, 1535,
585      1560, 1607, 1546, 1604, 1232, 1602, 1601, 1549, 1599, 1560,
586      1557, 1580, 1597, 1562, 1596, 1553, 1595, 1593, 1566, 1592,
587      1567, 1574, 1588, 1591, 1574, 1581, 1226, 1575, 1572, 1582,
588      1485, 1590, 1595, 1600, 1381, 1593,    0, 1392, 2157,    0,
589      1347,    0, 1029, 1018, 1607,    0, 2157, 1641, 1653, 1665,
590
591      1677, 1689,  893, 1698, 1704, 1713, 1725, 1737, 1745, 1751,
592      1756, 1762, 1771, 1783, 1795, 1807, 1819, 1831, 1839, 1845,
593      1848,  730,  581,  550, 1855,  289, 1863,  286, 1871, 1879,
594      1887
595     } ;
596
597 static yyconst flex_int16_t yy_def[832] =
598     {   0,
599       797,    1,  797,    3,  798,  798,  799,  799,  797,    9,
600       797,   11,  797,   13,  797,   15,  800,  800,  801,  801,
601       797,   21,  797,  797,  797,  797,  802,  803,  797,  797,
602       797,  797,  797,  804,  804,  804,  804,  804,  804,  804,
603       804,  804,  805,  805,  805,  805,  805,  805,  806,  806,
604       797,  806,  807,  806,  806,  797,  806,  806,  806,  806,
605       806,  806,  806,  797,  808,  797,  797,  802,  797,  797,
606       797,  797,  797,  797,  797,  797,  797,  797,  797,  809,
607       809,  809,  809,  809,  809,  797,  810,  810,  810,  810,
608       810,  810,  797,  811,  811,  811,  811,  811,  811,  797,
609
610       812,  812,  812,  812,  812,  812,  813,  813,  813,  814,
611       813,  813,  813,  813,  813,  813,  813,  813,  813,  813,
612       797,  815,  797,  797,  815,  816,  817,  818,  815,  815,
613       815,  815,  815,  815,  815,  815,  815,  815,  815,  797,
614       819,  819,  819,  819,  819,  819,  819,  802,  797,  820,
615       797,  797,  797,  797,  797,  797,  797,  804,  821,  804,
616       804,  804,  804,  804,  804,  804,  804,  805,  805,  805,
617       805,  805,  805,  806,  797,  806,  797,  807,  802,  806,
618       806,  806,  806,  806,  806,  806,  806,  806,  806,  808,
619       808,  797,  797,  797,  797,  797,  797,  809,  809,  809,
620
621       809,  809,  809,  822,  797,  810,  810,  810,  810,  810,
622       810,  811,  811,  811,  811,  811,  811,  823,  797,  812,
623       812,  812,  812,  812,  812,  813,  797,  814,  797,  813,
624       813,  813,  813,  813,  813,  813,  813,  813,  813,  813,
625       797,  797,  815,  815,  815,  797,  797,  816,  816,  816,
626       817,  817,  817,  818,  818,  818,  815,  815,  815,  815,
627       815,  815,  815,  797,  815,  815,  815,  815,  819,  819,
628       819,  819,  819,  819,  819,  819,  820,  797,  797,  824,
629       821,  797,  804,  804,  804,  804,  804,  804,  804,  804,
630       804,  805,  805,  805,  805,  805,  805,  806,  806,  806,
631
632       806,  806,  806,  806,  806,  797,  797,  797,  797,  797,
633       797,  809,  809,  809,  809,  809,  809,  825,  826,  810,
634       810,  810,  810,  810,  810,  811,  811,  811,  811,  811,
635       811,  827,  828,  812,  812,  812,  812,  812,  812,  813,
636       813,  813,  813,  813,  813,  813,  813,  815,  815,  815,
637       815,  797,  815,  815,  815,  815,  815,  819,  819,  819,
638       819,  819,  819,  819,  819,  797,  797,  829,  804,  804,
639       804,  804,  804,  804,  804,  804,  804,  805,  805,  805,
640       805,  805,  805,  806,  806,  806,  806,  806,  806,  806,
641       797,  797,  797,  797,  797,  797,  809,  809,  809,  809,
642
643       809,  809,  825,  810,  830,  810,  810,  810,  810,  810,
644       810,  811,  811,  811,  811,  811,  811,  827,  812,  831,
645       812,  812,  812,  812,  812,  812,  813,  797,  813,  813,
646       813,  813,  813,  813,  815,  815,  815,  815,  815,  815,
647       815,  819,  819,  819,  819,  819,  819,  819,  819,  829,
648       820,  804,  804,  804,  804,  804,  804,  804,  804,  804,
649       805,  805,  805,  805,  805,  805,  806,  806,  806,  806,
650       806,  806,  797,  797,  797,  797,  797,  797,  809,  809,
651       809,  809,  809,  809,  830,  810,  810,  810,  810,  810,
652       810,  810,  811,  811,  811,  811,  811,  811,  831,  812,
653
654       812,  812,  812,  812,  812,  812,  813,  813,  813,  813,
655       813,  813,  815,  815,  815,  815,  815,  815,  819,  819,
656       819,  819,  819,  819,  819,  819,  804,  804,  804,  804,
657       804,  804,  804,  804,  804,  805,  805,  805,  805,  805,
658       805,  806,  806,  806,  806,  806,  806,  797,  797,  797,
659       797,  797,  797,  809,  809,  809,  809,  809,  809,  810,
660       810,  810,  810,  810,  810,  811,  811,  811,  811,  811,
661       811,  812,  812,  812,  812,  812,  812,  813,  813,  813,
662       813,  813,  813,  815,  815,  815,  815,  815,  815,  819,
663       819,  819,  819,  819,  819,  819,  804,  804,  804,  804,
664
665       804,  804,  804,  805,  805,  805,  805,  805,  805,  806,
666       806,  806,  806,  806,  806,  797,  797,  797,  797,  797,
667       797,  809,  809,  809,  809,  809,  809,  810,  810,  810,
668       810,  810,  810,  811,  811,  811,  811,  811,  811,  812,
669       812,  812,  812,  812,  812,  813,  813,  813,  813,  813,
670       813,  815,  815,  815,  815,  815,  815,  819,  819,  819,
671       819,  819,  819,  804,  804,  804,  805,  805,  806,  806,
672       797,  797,  809,  809,  810,  810,  811,  811,  812,  812,
673       813,  813,  815,  815,  819,  819,  804,  804,  805,  805,
674       806,  806,  797,  797,  809,  809,  810,  810,  811,  811,
675
676       812,  812,  813,  813,  815,  815,  819,  819,  804,  804,
677       805,  805,  806,  806,  797,  797,  809,  809,  810,  810,
678       811,  811,  812,  812,  813,  813,  815,  815,  819,  819,
679       804,  805,  806,  797,  809,  810,  811,  812,  813,  815,
680       819,  804,  805,  806,  797,  809,  810,  811,  812,  813,
681       815,  819,  804,  805,  806,  797,  809,  810,  811,  812,
682       813,  815,  819,  804,  805,  806,  797,  809,  810,  811,
683       812,  813,  815,  819,  804,  805,  806,  797,  809,  810,
684       811,  812,  813,  815,  819,  804,  805,  806,  797,  809,
685       810,  811,  812,  813,  815,  819,    0,  797,  797,  797,
686
687       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
688       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
689       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
690       797
691     } ;
692
693 static yyconst flex_int16_t yy_nxt[2216] =
694     {   0,
695        24,   25,   26,   25,   24,   27,   28,   24,   29,   24,
696        30,   24,   24,   24,   24,   24,   31,   32,   33,   34,
697        34,   35,   34,   34,   34,   34,   34,   34,   34,   34,
698        34,   34,   24,   24,   24,   34,   36,   34,   34,   37,
699        38,   39,   34,   40,   34,   34,   34,   34,   41,   34,
700        42,   34,   34,   34,   34,   34,   24,   24,   24,   25,
701        26,   25,   24,   27,   24,   24,   29,   24,   30,   24,
702        24,   24,   24,   24,   31,   32,   33,   43,   43,   44,
703        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
704        24,   24,   24,   43,   45,   43,   43,   46,   43,   43,
705
706        43,   47,   43,   43,   43,   43,   43,   43,   48,   43,
707        43,   43,   43,   43,   24,   24,   50,   51,   52,  151,
708        53,  157,  157,   54,  157,   55,  157,  152,  176,  177,
709       157,   56,   57,   58,  175,  157,   59,  157,  183,  149,
710       175,  182,  175,  175,  175,  157,  157,  159,  159,  160,
711       159,   60,  159,  179,   61,  161,  159,  185,   62,  205,
712       162,  159,  175,  159,  188,   63,   50,   51,   52,  175,
713        53,  159,  159,   54,  175,   55,  164,  165,  163,  167,
714       180,   56,   57,   58,  166,  186,   59,  205,  181,  175,
715       184,  191,  192,  187,  151,  175,  205,  219,  189,  210,
716
717       205,   60,  152,  205,   61,  219,  219,  219,   62,  219,
718       227,  227,  207,  230,  227,   63,   65,   66,   67,  227,
719        68,  231,  221,   69,  227,   70,  232,  234,  227,  208,
720       227,   71,   72,   73,  209,  227,   74,  211,  222,  233,
721       223,  227,  227,  225,  271,  235,  272,  224,  238,  241,
722       242,   75,  246,  247,   76,  249,  244,  236,   77,  244,
723       295,  255,  244,  157,  296,   78,   65,   66,   67,  157,
724        68,  244,  237,   69,  244,   70,  157,  244,  175,  157,
725       240,   71,   72,   73,  250,  239,   74,  256,  245,  159,
726       151,  176,  177,  149,  420,  159,  283,  405,  152,  175,
727
728       379,   75,  159,  245,   76,  159,  175,  179,   77,  300,
729       380,  305,  284,  191,  192,   78,   24,   25,   79,   25,
730        24,   27,   24,   24,   29,   24,   30,   24,   24,   24,
731        24,   24,   31,   32,   33,   80,   80,   81,   80,   80,
732        80,   80,   80,   80,   80,   80,   80,   80,   24,   24,
733        24,   80,   82,   80,   80,   83,   80,   80,   80,   84,
734        80,   80,   80,   80,   80,   80,   85,   80,   80,   80,
735        80,   80,   24,   24,   24,   25,   26,   25,   24,   27,
736        86,   24,   29,   24,   30,   24,   24,   87,   87,   24,
737        31,   32,   33,   87,   87,   88,   87,   87,   87,   87,
738
739        87,   87,   87,   87,   87,   87,   24,   24,   24,   87,
740        89,   87,   87,   90,   87,   87,   87,   91,   87,   87,
741        87,   87,   87,   87,   92,   87,   87,   87,   87,   87,
742        24,   24,   24,   25,   93,   25,   24,   27,   24,   24,
743        29,   24,   30,   24,   24,   24,   24,   24,   31,   32,
744        33,   94,   94,   95,   94,   94,   94,   94,   94,   94,
745        94,   94,   94,   94,   24,   24,   24,   94,   96,   94,
746        94,   97,   94,   94,   94,   98,   94,   94,   94,   94,
747        94,   94,   99,   94,   94,   94,   94,   94,   24,   24,
748        24,   25,   26,   25,   24,   27,  100,   24,   29,   24,
749
750        30,   24,   24,  101,  101,   24,   31,   32,   33,  101,
751       101,  102,  101,  101,  101,  101,  101,  101,  101,  101,
752       101,  101,   24,   24,   24,  101,  103,  101,  101,  104,
753       101,  101,  101,  105,  101,  101,  101,  101,  101,  101,
754       106,  101,  101,  101,  101,  101,   24,   24,  108,  109,
755       108,  157,  110,  252,  149,  111,  252,  112,  368,  252,
756       278,  157,  157,  113,  114,  115,  257,  309,  116,  244,
757       175,  310,  244,  227,  258,  157,  244,  159,  244,  244,
758       175,  244,  244,  117,  244,  253,  118,  159,  159,  332,
759       119,  157,  259,  286,  260,  302,  285,  120,  245,  205,
760
761       287,  159,  227,  301,  121,  108,  109,  108,  245,  110,
762       245,  433,  111,  244,  112,  279,  244,  159,  291,  244,
763       113,  114,  115,  244,  175,  116,  244,  244,  244,  244,
764       244,  244,  261,  244,  244,  244,  264,  290,  244,  343,
765       117,  244,  325,  118,  262,  245,  303,  119,  157,  315,
766       304,  265,  205,  316,  120,  245,  205,  263,  205,  245,
767       245,  121,  123,  124,  125,  126,  127,  245,  128,  129,
768       244,  130,  320,  244,  159,  180,  244,  131,  132,  133,
769       288,  298,  134,  181,  289,  244,  219,  219,  244,  321,
770       175,  244,  244,  322,  135,  244,  175,  136,  244,  329,
771
772       137,  205,  245,  330,  138,  219,  334,  219,  219,  266,
773       227,  139,  123,  124,  125,  126,  127,  245,  128,  129,
774       335,  130,  227,  175,  245,  241,  242,  131,  132,  133,
775       267,  268,  134,  323,  230,  227,  299,  324,  318,  337,
776       336,  363,  231,  338,  135,  364,  342,  136,  175,  344,
777       137,  339,  246,  247,  138,  366,  367,  385,  427,  428,
778       390,  139,   24,   25,  140,   25,   24,   27,   24,   24,
779        29,   24,   30,   24,   24,   24,   24,   24,   31,   32,
780        33,  141,  141,  142,  141,  141,  141,  141,  141,  141,
781       141,  141,  141,  141,   24,   24,   24,  141,  143,  144,
782
783       141,  145,  141,  141,  141,  146,  141,  141,  141,  141,
784       141,  141,  147,  141,  141,  141,  141,  141,   24,   24,
785       340,  227,  227,  227,  244,  244,  249,  244,  244,  175,
786       244,  244,  244,  244,  249,  244,  205,  248,  244,  249,
787       252,  149,  278,  252,  252,  149,  252,  252,  252,  348,
788       252,  252,  255,  255,  252,  250,  245,  245,  345,  175,
789       254,  205,  346,  250,  245,  255,  470,  205,  250,  563,
790       347,  349,  253,  205,  244,  341,  253,  244,  256,  256,
791       253,  257,  244,  389,  244,  244,  406,  244,  244,  258,
792       244,  256,  244,  244,  487,  244,  244,  279,  244,  244,
793
794       409,  150,  244,  245,  244,  244,  244,  244,  157,  244,
795       244,  157,  244,  245,  245,  244,  157,  244,  244,  157,
796       244,  244,  245,  244,  245,  157,  350,  244,  175,  351,
797       244,  245,  205,  244,  159,  369,  245,  159,  245,  157,
798       157,  157,  159,  157,  353,  159,  157,  245,  298,  245,
799       175,  159,  392,  205,  355,  354,  219,  388,  356,  245,
800       372,  370,  393,  175,  398,  159,  159,  159,  407,  159,
801       205,  371,  159,  373,  399,  357,  386,  375,  408,  374,
802       384,  367,  376,  413,  219,  219,  387,  410,  377,  219,
803       219,  227,  422,  414,  227,  175,  340,  227,  227,  227,
804
805       366,  367,  423,  299,  421,  244,  349,  244,  244,  244,
806       244,  244,  244,  244,  429,  435,  367,  411,  244,  175,
807       227,  244,  244,  424,  425,  244,  244,  244,  244,  244,
808       244,  436,  244,  244,  430,  219,  426,  245,  245,  245,
809       244,  432,  244,  244,  431,  244,  244,  245,  244,  157,
810       434,  341,  443,  471,  245,  157,  157,  157,  245,  245,
811       175,  350,  444,  437,  157,  157,  157,  157,  205,  175,
812       452,  439,  245,  438,  245,  159,  157,  175,  175,  440,
813       467,  159,  159,  159,  205,  453,  454,  472,  384,  367,
814       159,  159,  159,  159,  441,  205,  205,  468,  469,  205,
815
816       219,  455,  159,  175,  460,  219,  219,  219,  456,  219,
817       458,  219,  457,  227,  488,  490,  227,  459,  427,  428,
818       227,  501,  227,  227,  227,  489,  435,  367,  244,  244,
819       175,  244,  244,  175,  244,  502,  492,  503,  507,  669,
820       491,  175,  244,  542,  157,  244,  506,  205,  244,  713,
821       508,  157,  175,  504,  509,  505,  244,  157,  245,  244,
822       245,  244,  244,  514,  244,  512,  244,  244,  513,  244,
823       159,  511,  244,  510,  245,  244,  157,  159,  244,  157,
824       527,  244,  157,  159,  157,  157,  157,  544,  245,  175,
825       205,  515,  562,  245,  157,  175,  529,  175,  245,  175,
826
827       205,  205,  159,  219,  205,  159,  219,  245,  159,  219,
828       159,  159,  159,  516,  219,  517,  528,  518,  532,  543,
829       159,  533,  545,  531,  546,  530,  534,  560,  219,  547,
830       561,  219,  572,  227,  227,  227,  227,  564,  535,  227,
831       227,  157,  175,  573,  175,  565,  205,  575,  175,  244,
832       244,  574,  244,  244,  788,  244,  244,  766,  244,  157,
833       578,  244,  675,  610,  244,  576,  244,  159,  244,  244,
834       597,  244,  244,  581,  244,  577,  157,  584,  579,  157,
835       582,  245,  245,  244,  580,  159,  244,  157,  583,  244,
836       245,  157,  598,  157,  157,  585,  157,  175,  245,  175,
837
838       245,  175,  159,  205,  587,  159,  175,  175,  586,  205,
839       588,  205,  205,  159,  599,  245,  205,  159,  205,  159,
840       159,  613,  159,  219,  611,  601,  219,  612,  600,  219,
841       603,  615,  589,  219,  219,  219,  629,  227,  628,  602,
842       227,  227,  614,  227,  227,  157,  631,  227,  244,  630,
843       157,  244,  633,  205,  244,  640,  641,  244,  244,  205,
844       244,  244,  632,  244,  244,  157,  664,  642,  643,  645,
845       646,  159,  244,  175,  227,  244,  159,  647,  244,  644,
846       245,  649,  652,  648,  665,  651,  157,  157,  157,  245,
847       245,  159,  157,  244,  650,  653,  244,  244,  676,  244,
848
849       244,  654,  670,  244,  245,  219,  219,  227,  175,  796,
850       175,  655,  159,  159,  159,  205,  244,  682,  159,  244,
851       244,  679,  244,  244,  691,  245,  244,  681,  244,  245,
852       157,  244,  666,  157,  244,  244,  657,  683,  244,  157,
853       244,  244,  175,  244,  656,  680,  244,  244,  245,  698,
854       244,  205,  245,  244,  687,  219,  159,  219,  227,  159,
855       245,  227,  157,  205,  684,  159,  692,  245,  244,  157,
856       175,  244,  245,  688,  244,  697,  205,  244,  219,  245,
857       244,  701,  219,  244,  227,  227,  703,  709,  159,  702,
858       227,  175,  157,  227,  719,  159,  723,  705,  755,  704,
859
860       245,  157,  244,  739,  714,  244,  710,  720,  244,  245,
861       205,  244,  725,  792,  244,  731,  706,  244,  159,  175,
862       750,  219,  157,  733,  736,  727,  724,  159,  205,  175,
863       244,  219,  726,  244,  245,  738,  244,  227,  244,  157,
864       205,  244,  744,  245,  244,  742,  219,  244,  159,  740,
865       244,  747,  157,  244,  749,  205,  753,  758,  761,  227,
866       728,  244,  245,  760,  244,  159,  219,  244,  157,  175,
867       245,  764,  205,  219,  769,  751,  227,  777,  159,  245,
868       157,  244,  772,  762,  244,  771,  775,  244,  205,  244,
869       780,  782,  244,  245,  159,  244,  219,  227,  783,  157,
870
871       790,  244,  786,  789,  244,  773,  159,  244,  244,  787,
872       791,  244,  784,  245,  244,  785,  781,  779,  793,  778,
873       776,  245,  774,  794,  770,  159,  768,  767,  795,  765,
874       763,  759,  757,  245,  756,  754,  752,  748,  746,  745,
875       245,   49,   49,   49,   49,   49,   49,   49,   49,   49,
876        49,   49,   49,   64,   64,   64,   64,   64,   64,   64,
877        64,   64,   64,   64,   64,  107,  107,  107,  107,  107,
878       107,  107,  107,  107,  107,  107,  107,  122,  122,  122,
879       122,  122,  122,  122,  122,  122,  122,  122,  122,  148,
880       148,  148,  148,  148,  148,  148,  148,  148,  148,  148,
881
882       148,  158,  158,  158,  743,  158,  158,  158,  168,  168,
883       741,  168,  168,  174,  227,  174,  174,  174,  174,  174,
884       174,  174,  174,  174,  174,  178,  178,  178,  178,  178,
885       178,  178,  178,  178,  178,  178,  178,  190,  190,  190,
886       190,  190,  190,  190,  190,  190,  190,  190,  190,  198,
887       198,  219,  198,  198,  206,  206,  737,  206,  206,  206,
888       212,  212,  205,  212,  212,  220,  220,  735,  220,  220,
889       220,  226,  226,  226,  226,  226,  226,  226,  226,  226,
890       226,  226,  226,  228,  228,  228,  228,  228,  228,  228,
891       228,  228,  228,  228,  228,  243,  734,  243,  243,  243,
892
893       243,  243,  243,  243,  243,  243,  243,  248,  175,  732,
894       248,  248,  248,  248,  248,  248,  248,  248,  248,  251,
895       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
896       251,  254,  730,  729,  254,  254,  254,  254,  254,  254,
897       254,  254,  254,  269,  269,  722,  269,  269,  277,  277,
898       277,  721,  277,  277,  277,  281,  281,  718,  281,  403,
899       403,  717,  403,  403,  716,  715,  403,  418,  418,  712,
900       418,  418,  711,  708,  418,  450,  450,  707,  450,  450,
901       700,  699,  450,  485,  485,  696,  485,  485,  695,  694,
902       485,  499,  499,  693,  499,  499,  690,  689,  499,  686,
903
904       685,  227,  227,  227,  227,  219,  219,  219,  219,  678,
905       677,  205,  205,  205,  205,  674,  673,  672,  671,  175,
906       175,  175,  175,  668,  667,  663,  662,  661,  660,  659,
907       658,  639,  638,  637,  636,  635,  634,  627,  626,  625,
908       624,  623,  622,  621,  620,  619,  618,  617,  616,  609,
909       608,  607,  606,  605,  604,  596,  595,  594,  593,  592,
910       591,  590,  219,  500,  571,  570,  569,  568,  567,  566,
911       205,  486,  559,  558,  557,  556,  555,  554,  553,  552,
912       551,  550,  549,  548,  541,  540,  539,  538,  537,  536,
913       451,  526,  525,  524,  523,  522,  521,  520,  519,  428,
914
915       500,  219,  419,  498,  497,  496,  495,  494,  493,  486,
916       205,  404,  484,  483,  482,  481,  480,  479,  478,  477,
917       476,  475,  474,  473,  466,  465,  464,  463,  462,  461,
918       451,  367,  449,  448,  447,  446,  445,  442,  352,  227,
919       219,  419,  417,  416,  415,  412,  205,  404,  402,  401,
920       400,  397,  396,  395,  394,  391,  175,  383,  382,  381,
921       378,  282,  365,  362,  361,  360,  359,  358,  352,  247,
922       242,  227,  227,  227,  227,  227,  229,  227,  227,  219,
923       333,  331,  328,  327,  326,  205,  319,  317,  314,  313,
924       312,  311,  308,  307,  306,  192,  175,  175,  175,  149,
925
926       175,  297,  294,  293,  292,  282,  280,  149,  276,  275,
927       274,  273,  270,  247,  229,  227,  227,  227,  219,  218,
928       217,  216,  215,  214,  213,  205,  204,  203,  202,  201,
929       200,  199,  197,  196,  195,  194,  193,  156,  155,  154,
930       153,  149,  154,  175,  175,  173,  172,  171,  170,  169,
931       156,  155,  154,  153,  149,  797,   23,  797,  797,  797,
932       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
933       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
934       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
935       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
936
937       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
938       797,  797,  797,  797,  797
939     } ;
940
941 static yyconst flex_int16_t yy_chk[2216] =
942     {   0,
943         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
944         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
945         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
946         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
947         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
948         1,    1,    1,    1,    1,    1,    1,    1,    3,    3,
949         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
950         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
951         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
952         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
953
954         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
955         3,    3,    3,    3,    3,    3,    5,    5,    5,   29,
956         5,   34,   36,    5,   35,    5,   37,   29,   50,   50,
957        38,    5,    5,    5,   62,   41,    5,   40,   57,   53,
958        55,   55,   59,   50,   57,   42,   39,   34,   36,   35,
959        35,    5,   37,   53,    5,   36,   38,   59,    5,   91,
960        37,   41,   60,   40,   62,    5,    6,    6,    6,   61,
961         6,   42,   39,    6,   63,    6,   39,   40,   38,   42,
962        54,    6,    6,    6,   41,   60,    6,   88,   54,   58,
963        58,   65,   65,   61,   69,   54,   89,  102,   63,   91,
964
965        90,    6,   69,   92,    6,  103,  104,  105,    6,  106,
966       118,  112,   88,  111,  111,    6,    7,    7,    7,  114,
967         7,  111,  102,    7,  113,    7,  112,  114,  116,   89,
968       115,    7,    7,    7,   90,  117,    7,   92,  103,  113,
969       104,  119,  120,  106,  143,  115,  143,  105,  118,  121,
970       121,    7,  123,  123,    7,  126,  122,  116,    7,  122,
971       172,  128,  122,  150,  172,    7,    8,    8,    8,  158,
972         8,  125,  117,    8,  125,    8,  160,  125,  189,  161,
973       120,    8,    8,    8,  126,  119,    8,  128,  122,  150,
974       151,  176,  176,  178,  828,  158,  160,  826,  151,  185,
975
976       293,    8,  160,  125,    8,  161,  176,  178,    8,  185,
977       293,  189,  161,  191,  191,    8,    9,    9,    9,    9,
978         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
979         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
980         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
981         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
982         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
983         9,    9,    9,    9,   11,   11,   11,   11,   11,   11,
984        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
985        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
986
987        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
988        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
989        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
990        11,   11,   13,   13,   13,   13,   13,   13,   13,   13,
991        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
992        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
993        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
994        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
995        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
996        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
997
998        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
999        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
1000        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
1001        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
1002        15,   15,   15,   15,   15,   15,   15,   15,   17,   17,
1003        17,  163,   17,  127,  127,   17,  127,   17,  824,  127,
1004       152,  162,  164,   17,   17,   17,  129,  196,   17,  129,
1005       187,  196,  129,  346,  129,  167,  130,  163,  131,  130,
1006       186,  131,  130,   17,  131,  127,   17,  162,  164,  823,
1007        17,  166,  130,  163,  131,  187,  162,   17,  129,  211,
1008
1009       164,  167,  237,  186,   17,   18,   18,   18,  130,   18,
1010       131,  346,   18,  136,   18,  152,  136,  166,  167,  136,
1011        18,   18,   18,  132,  188,   18,  132,  134,  133,  132,
1012       134,  133,  132,  134,  133,  135,  135,  166,  135,  237,
1013        18,  135,  211,   18,  133,  136,  188,   18,  165,  202,
1014       188,  136,  207,  202,   18,  132,  208,  134,  209,  134,
1015       133,   18,   19,   19,   19,   19,   19,  135,   19,   19,
1016       137,   19,  207,  137,  165,  180,  137,   19,   19,   19,
1017       165,  181,   19,  180,  165,  138,  221,  222,  138,  208,
1018       180,  138,  139,  209,   19,  139,  181,   19,  139,  216,
1019
1020        19,  210,  137,  216,   19,  223,  221,  224,  225,  137,
1021       238,   19,   20,   20,   20,   20,   20,  138,   20,   20,
1022       222,   20,  236,  305,  139,  241,  241,   20,   20,   20,
1023       138,  139,   20,  210,  230,  230,  181,  210,  822,  224,
1024       223,  275,  230,  224,   20,  275,  236,   20,  300,  238,
1025        20,  225,  246,  246,   20,  279,  279,  300,  341,  341,
1026       305,   20,   21,   21,   21,   21,   21,   21,   21,   21,
1027        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1028        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1029        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1030
1031        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1032        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1033       231,  231,  239,  240,  243,  244,  248,  243,  244,  388,
1034       243,  244,  245,  245,  249,  245,  490,  250,  245,  250,
1035       251,  251,  278,  251,  252,  252,  251,  252,  253,  253,
1036       252,  253,  254,  255,  253,  248,  243,  244,  239,  304,
1037       256,  323,  239,  249,  245,  256,  388,  320,  250,  490,
1038       240,  258,  251,  406,  258,  231,  252,  258,  254,  255,
1039       253,  257,  259,  304,  257,  259,  320,  257,  259,  257,
1040       260,  256,  261,  260,  406,  261,  260,  278,  261,  262,
1041
1042       323,  803,  262,  258,  263,  262,  265,  263,  277,  265,
1043       263,  285,  265,  257,  259,  266,  283,  267,  266,  286,
1044       267,  266,  260,  267,  261,  284,  258,  268,  303,  263,
1045       268,  262,  321,  268,  277,  283,  263,  285,  265,  287,
1046       288,  291,  283,  289,  265,  286,  290,  266,  298,  267,
1047       301,  284,  307,  324,  267,  266,  335,  303,  267,  268,
1048       286,  284,  307,  298,  313,  287,  288,  291,  321,  289,
1049       325,  284,  290,  287,  313,  268,  301,  289,  321,  288,
1050       299,  299,  290,  327,  337,  334,  301,  324,  291,  339,
1051       338,  342,  335,  327,  343,  299,  340,  340,  345,  347,
1052
1053       366,  366,  335,  298,  334,  348,  349,  351,  348,  349,
1054       351,  348,  349,  351,  342,  350,  350,  325,  350,  389,
1055       794,  350,  353,  337,  338,  353,  354,  355,  353,  354,
1056       355,  351,  354,  355,  343,  793,  339,  348,  349,  351,
1057       356,  345,  357,  356,  343,  357,  356,  350,  357,  369,
1058       347,  340,  359,  389,  353,  370,  371,  372,  354,  355,
1059       390,  349,  359,  353,  373,  374,  375,  377,  409,  385,
1060       369,  355,  356,  353,  357,  369,  376,  386,  387,  356,
1061       385,  370,  371,  372,  407,  370,  371,  390,  384,  384,
1062       373,  374,  375,  377,  357,  408,  410,  386,  387,  411,
1063
1064       421,  372,  376,  384,  377,  422,  424,  423,  373,  426,
1065       375,  425,  374,  429,  407,  409,  430,  376,  427,  427,
1066       431,  421,  432,  433,  434,  408,  435,  435,  437,  435,
1067       467,  437,  435,  610,  437,  422,  411,  423,  429,  610,
1068       410,  691,  436,  467,  451,  436,  426,  489,  436,  691,
1069       430,  454,  469,  424,  431,  425,  438,  452,  435,  438,
1070       437,  439,  438,  437,  439,  434,  440,  439,  436,  440,
1071       451,  433,  440,  432,  436,  441,  453,  454,  441,  455,
1072       452,  441,  456,  452,  458,  457,  459,  469,  438,  468,
1073       488,  438,  489,  439,  460,  472,  454,  471,  440,  470,
1074
1075       491,  492,  453,  502,  487,  455,  503,  441,  456,  501,
1076       458,  457,  459,  439,  504,  440,  453,  441,  457,  468,
1077       460,  458,  470,  456,  471,  455,  459,  487,  505,  472,
1078       488,  506,  501,  507,  508,  509,  510,  491,  460,  511,
1079       512,  527,  777,  502,  542,  492,  628,  504,  755,  513,
1080       514,  503,  513,  514,  777,  513,  514,  755,  515,  528,
1081       507,  515,  628,  542,  515,  505,  516,  527,  517,  516,
1082       527,  517,  516,  510,  517,  506,  529,  513,  508,  530,
1083       511,  513,  514,  518,  509,  528,  518,  531,  512,  518,
1084       515,  532,  528,  533,  534,  514,  535,  545,  516,  544,
1085
1086       517,  543,  529,  561,  516,  530,  546,  547,  515,  560,
1087       517,  562,  563,  531,  529,  518,  564,  532,  565,  533,
1088       534,  545,  535,  573,  543,  532,  572,  544,  531,  574,
1089       535,  547,  518,  576,  575,  577,  561,  578,  560,  533,
1090       579,  580,  546,  581,  582,  598,  563,  583,  584,  562,
1091       597,  584,  565,  791,  584,  572,  573,  585,  586,  629,
1092       585,  586,  564,  585,  586,  599,  597,  574,  575,  577,
1093       578,  598,  587,  611,  647,  587,  597,  579,  587,  576,
1094       584,  581,  584,  580,  598,  583,  600,  601,  602,  585,
1095       586,  599,  603,  588,  582,  585,  588,  589,  629,  588,
1096
1097       589,  586,  611,  589,  587,  640,  641,  646,  788,  785,
1098       669,  587,  600,  601,  602,  676,  652,  647,  603,  652,
1099       653,  640,  652,  653,  669,  588,  653,  646,  654,  589,
1100       664,  654,  600,  666,  654,  655,  589,  652,  655,  665,
1101       656,  655,  670,  656,  588,  641,  656,  657,  652,  676,
1102       657,  675,  653,  657,  664,  680,  664,  679,  681,  666,
1103       654,  682,  688,  698,  653,  665,  670,  655,  683,  687,
1104       692,  683,  656,  665,  683,  675,  697,  684,  701,  657,
1105       684,  679,  702,  684,  704,  725,  681,  687,  688,  680,
1106       703,  744,  710,  739,  697,  687,  701,  683,  744,  682,
1107
1108       683,  709,  705,  725,  692,  705,  688,  698,  705,  684,
1109       719,  706,  703,  781,  706,  709,  684,  706,  710,  713,
1110       739,  723,  731,  713,  719,  705,  702,  709,  736,  733,
1111       727,  738,  704,  727,  705,  723,  727,  750,  728,  742,
1112       747,  728,  733,  706,  728,  731,  749,  740,  731,  727,
1113       740,  736,  753,  740,  738,  758,  742,  747,  750,  761,
1114       706,  751,  727,  749,  751,  742,  760,  751,  764,  766,
1115       728,  753,  769,  771,  758,  740,  772,  766,  753,  740,
1116       775,  762,  761,  751,  762,  760,  764,  762,  780,  773,
1117       769,  771,  773,  751,  764,  773,  782,  783,  772,  786,
1118
1119       779,  784,  775,  778,  784,  762,  775,  784,  795,  776,
1120       780,  795,  773,  762,  795,  774,  770,  768,  782,  767,
1121       765,  773,  763,  783,  759,  786,  757,  756,  784,  754,
1122       752,  748,  746,  784,  745,  743,  741,  737,  735,  734,
1123       795,  798,  798,  798,  798,  798,  798,  798,  798,  798,
1124       798,  798,  798,  799,  799,  799,  799,  799,  799,  799,
1125       799,  799,  799,  799,  799,  800,  800,  800,  800,  800,
1126       800,  800,  800,  800,  800,  800,  800,  801,  801,  801,
1127       801,  801,  801,  801,  801,  801,  801,  801,  801,  802,
1128       802,  802,  802,  802,  802,  802,  802,  802,  802,  802,
1129
1130       802,  804,  804,  804,  732,  804,  804,  804,  805,  805,
1131       729,  805,  805,  806,  726,  806,  806,  806,  806,  806,
1132       806,  806,  806,  806,  806,  807,  807,  807,  807,  807,
1133       807,  807,  807,  807,  807,  807,  807,  808,  808,  808,
1134       808,  808,  808,  808,  808,  808,  808,  808,  808,  809,
1135       809,  724,  809,  809,  810,  810,  721,  810,  810,  810,
1136       811,  811,  720,  811,  811,  812,  812,  717,  812,  812,
1137       812,  813,  813,  813,  813,  813,  813,  813,  813,  813,
1138       813,  813,  813,  814,  814,  814,  814,  814,  814,  814,
1139       814,  814,  814,  814,  814,  815,  715,  815,  815,  815,
1140
1141       815,  815,  815,  815,  815,  815,  815,  816,  714,  711,
1142       816,  816,  816,  816,  816,  816,  816,  816,  816,  817,
1143       817,  817,  817,  817,  817,  817,  817,  817,  817,  817,
1144       817,  818,  708,  707,  818,  818,  818,  818,  818,  818,
1145       818,  818,  818,  819,  819,  700,  819,  819,  820,  820,
1146       820,  699,  820,  820,  820,  821,  821,  696,  821,  825,
1147       825,  695,  825,  825,  694,  693,  825,  827,  827,  690,
1148       827,  827,  689,  686,  827,  829,  829,  685,  829,  829,
1149       678,  677,  829,  830,  830,  674,  830,  830,  673,  672,
1150       830,  831,  831,  671,  831,  831,  668,  667,  831,  659,
1151
1152       658,  651,  650,  649,  648,  645,  644,  643,  642,  635,
1153       634,  633,  632,  631,  630,  623,  622,  617,  616,  615,
1154       614,  613,  612,  605,  604,  596,  595,  594,  592,  591,
1155       590,  571,  570,  569,  568,  567,  566,  559,  558,  557,
1156       556,  555,  554,  553,  552,  551,  550,  549,  548,  541,
1157       540,  539,  538,  537,  536,  526,  525,  524,  523,  521,
1158       520,  519,  500,  499,  498,  497,  496,  495,  494,  493,
1159       486,  485,  484,  483,  482,  481,  480,  479,  478,  477,
1160       476,  475,  474,  473,  466,  465,  464,  463,  462,  461,
1161       450,  449,  448,  447,  446,  445,  444,  443,  442,  428,
1162
1163       420,  419,  418,  417,  416,  415,  414,  413,  412,  405,
1164       404,  403,  402,  401,  400,  399,  398,  397,  396,  395,
1165       394,  393,  392,  391,  383,  382,  381,  380,  379,  378,
1166       368,  367,  365,  364,  363,  361,  360,  358,  352,  344,
1167       336,  332,  331,  330,  329,  326,  322,  318,  317,  316,
1168       315,  312,  311,  310,  309,  306,  302,  297,  296,  295,
1169       292,  281,  276,  274,  273,  272,  271,  270,  264,  247,
1170       242,  235,  234,  233,  232,  229,  228,  227,  226,  220,
1171       219,  217,  215,  214,  213,  206,  205,  203,  201,  200,
1172       199,  197,  195,  194,  193,  190,  184,  183,  182,  179,
1173
1174       174,  173,  171,  170,  169,  159,  157,  148,  147,  146,
1175       145,  144,  142,  124,  110,  109,  108,  107,  101,  100,
1176        99,   98,   97,   96,   95,   87,   86,   85,   84,   83,
1177        82,   81,   78,   77,   76,   75,   74,   73,   72,   71,
1178        70,   68,   56,   52,   49,   48,   47,   46,   45,   44,
1179        33,   32,   31,   30,   27,   23,  797,  797,  797,  797,
1180       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
1181       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
1182       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
1183       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
1184
1185       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
1186       797,  797,  797,  797,  797
1187     } ;
1188
1189 /* Table of booleans, true if rule could match eol. */
1190 static yyconst flex_int32_t yy_rule_can_match_eol[46] =
1191     {   0,
1192 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
1193     0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 
1194     1, 1, 1, 1, 0, 0,     };
1195
1196 /* The intent behind this definition is that it'll catch
1197  * any uses of REJECT which flex missed.
1198  */
1199 #define REJECT reject_used_but_not_detected
1200 #define yymore() yymore_used_but_not_detected
1201 #define YY_MORE_ADJ 0
1202 #define YY_RESTORE_YY_MORE_OFFSET
1203 #line 1 "bitbakescanner.l"
1204 /* bbf.flex 
1205
1206    written by Marc Singer
1207    6 January 2005
1208
1209    This program is free software; you can redistribute it and/or
1210    modify it under the terms of the GNU General Public License as
1211    published by the Free Software Foundation; either version 2 of the
1212    License, or (at your option) any later version.
1213
1214    This program is distributed in the hope that it will be useful, but
1215    WITHOUT ANY WARRANTY; without even the implied warranty of
1216    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1217    General Public License for more details.
1218
1219    You should have received a copy of the GNU General Public License
1220    along with this program; if not, write to the Free Software
1221    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
1222    USA.
1223
1224    DESCRIPTION
1225    -----------
1226
1227    flex lexer specification for a BitBake input file parser.
1228
1229    Unfortunately, flex doesn't welcome comments within the rule sets.
1230    I say unfortunately because this lexer is unreasonably complex and
1231    comments would make the code much easier to comprehend.
1232
1233    The BitBake grammar is not regular.  In order to interpret all
1234    of the available input files, the lexer maintains much state as it
1235    parses.  There are places where this lexer will emit tokens that
1236    are invalid.  The parser will tend to catch these. 
1237
1238    The lexer requires C++ at the moment.  The only reason for this has
1239    to do with a very small amount of managed state.  Producing a C
1240    lexer should be a reasonably easy task as long as the %reentrant
1241    option is used.
1242
1243
1244    NOTES
1245    -----
1246
1247    o RVALUES.  There are three kinds of RVALUES.  There are unquoted
1248      values, double quote enclosed strings, and single quote 
1249      strings.  Quoted strings may contain unescaped quotes (of either
1250      type), *and* any type may span more than one line by using a
1251      continuation '\' at the end of the line.  This requires us to
1252      recognize all types of values with a single expression.
1253      Moreover, the only reason to quote a value is to include
1254      trailing or leading whitespace.  Whitespace within a value is
1255      preserved, ugh.
1256
1257    o CLASSES.  C_ patterns define classes.  Classes ought not include
1258      a repitition operator, instead letting the reference to the class
1259      define the repitition count.
1260
1261      C_SS - symbol start
1262      C_SB - symbol body
1263      C_SP - whitespace
1264
1265 */
1266 #line 71 "bitbakescanner.l"
1267
1268 #include "token.h"
1269 #include "lexer.h"
1270 #include "bitbakeparser.h"
1271 #include <ctype.h>
1272
1273 extern void *bbparseAlloc(void *(*mallocProc)(size_t));
1274 extern void bbparseFree(void *p, void (*freeProc)(void*));
1275 extern void *bbparseAlloc(void *(*mallocProc)(size_t));
1276 extern void *bbparse(void*, int, token_t, lex_t*);
1277 extern void bbparseTrace(FILE *TraceFILE, char *zTracePrompt);
1278
1279 //static const char* rgbInput;
1280 //static size_t cbInput;
1281
1282
1283 int lineError;
1284 int errorParse;
1285
1286 enum {
1287   errorNone = 0,
1288   errorUnexpectedInput,
1289   errorUnsupportedFeature, 
1290 };
1291
1292 #define YY_EXTRA_TYPE lex_t*
1293
1294         /* Read from buffer */
1295 #define YY_INPUT(buf,result,max_size) \
1296  { yyextra->input(buf, &result, max_size); }
1297
1298 //#define YY_DECL static size_t yylex ()
1299
1300 #define ERROR(e) \
1301   do { lineError = yylineno; errorParse = e; yyterminate (); } while (0)
1302
1303 static const char* fixup_escapes (const char* sz);
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315 #line 1316 "<stdout>"
1316
1317 #define INITIAL 0
1318 #define S_DEF 1
1319 #define S_DEF_ARGS 2
1320 #define S_DEF_BODY 3
1321 #define S_FUNC 4
1322 #define S_INCLUDE 5
1323 #define S_INHERIT 6
1324 #define S_REQUIRE 7
1325 #define S_PROC 8
1326 #define S_RVALUE 9
1327 #define S_TASK 10
1328
1329 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1330  * down here because we want the user's section 1 to have been scanned first.
1331  * The user has a chance to override it with an option.
1332  */
1333 #include <unistd.h>
1334
1335 #ifndef YY_EXTRA_TYPE
1336 #define YY_EXTRA_TYPE void *
1337 #endif
1338
1339 /* Holds the entire state of the reentrant scanner. */
1340 struct yyguts_t
1341     {
1342
1343     /* User-defined. Not touched by flex. */
1344     YY_EXTRA_TYPE yyextra_r;
1345
1346     /* The rest are the same as the globals declared in the non-reentrant scanner. */
1347     FILE *yyin_r, *yyout_r;
1348     size_t yy_buffer_stack_top; /**< index of top of stack. */
1349     size_t yy_buffer_stack_max; /**< capacity of stack. */
1350     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
1351     char yy_hold_char;
1352     int yy_n_chars;
1353     int yyleng_r;
1354     char *yy_c_buf_p;
1355     int yy_init;
1356     int yy_start;
1357     int yy_did_buffer_switch_on_eof;
1358     int yy_start_stack_ptr;
1359     int yy_start_stack_depth;
1360     int *yy_start_stack;
1361     yy_state_type yy_last_accepting_state;
1362     char* yy_last_accepting_cpos;
1363
1364     int yylineno_r;
1365     int yy_flex_debug_r;
1366
1367     char *yytext_r;
1368     int yy_more_flag;
1369     int yy_more_len;
1370
1371     }; /* end struct yyguts_t */
1372
1373 /* Accessor methods to globals.
1374    These are made visible to non-reentrant scanners for convenience. */
1375
1376 int yylex_destroy (yyscan_t yyscanner );
1377
1378 int yyget_debug (yyscan_t yyscanner );
1379
1380 void yyset_debug (int debug_flag ,yyscan_t yyscanner );
1381
1382 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
1383
1384 void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
1385
1386 FILE *yyget_in (yyscan_t yyscanner );
1387
1388 void yyset_in  (FILE * in_str ,yyscan_t yyscanner );
1389
1390 FILE *yyget_out (yyscan_t yyscanner );
1391
1392 void yyset_out  (FILE * out_str ,yyscan_t yyscanner );
1393
1394 int yyget_leng (yyscan_t yyscanner );
1395
1396 char *yyget_text (yyscan_t yyscanner );
1397
1398 int yyget_lineno (yyscan_t yyscanner );
1399
1400 void yyset_lineno (int line_number ,yyscan_t yyscanner );
1401
1402 /* Macros after this point can all be overridden by user definitions in
1403  * section 1.
1404  */
1405
1406 #ifndef YY_SKIP_YYWRAP
1407 #ifdef __cplusplus
1408 extern "C" int yywrap (yyscan_t yyscanner );
1409 #else
1410 extern int yywrap (yyscan_t yyscanner );
1411 #endif
1412 #endif
1413
1414     static void yyunput (int c,char *buf_ptr  ,yyscan_t yyscanner);
1415     
1416 #ifndef yytext_ptr
1417 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
1418 #endif
1419
1420 #ifdef YY_NEED_STRLEN
1421 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
1422 #endif
1423
1424 #ifndef YY_NO_INPUT
1425
1426 #ifdef __cplusplus
1427 static int yyinput (yyscan_t yyscanner );
1428 #else
1429 static int input (yyscan_t yyscanner );
1430 #endif
1431
1432 #endif
1433
1434     static void yy_push_state (int new_state ,yyscan_t yyscanner);
1435     
1436     static void yy_pop_state (yyscan_t yyscanner );
1437     
1438     static int yy_top_state (yyscan_t yyscanner );
1439     
1440 /* Amount of stuff to slurp up with each read. */
1441 #ifndef YY_READ_BUF_SIZE
1442 #define YY_READ_BUF_SIZE 8192
1443 #endif
1444
1445 /* Copy whatever the last rule matched to the standard output. */
1446 #ifndef ECHO
1447 /* This used to be an fputs(), but since the string might contain NUL's,
1448  * we now use fwrite().
1449  */
1450 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1451 #endif
1452
1453 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1454  * is returned in "result".
1455  */
1456 #ifndef YY_INPUT
1457 #define YY_INPUT(buf,result,max_size) \
1458         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1459                 { \
1460                 int c = '*'; \
1461                 size_t n; \
1462                 for ( n = 0; n < max_size && \
1463                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1464                         buf[n] = (char) c; \
1465                 if ( c == '\n' ) \
1466                         buf[n++] = (char) c; \
1467                 if ( c == EOF && ferror( yyin ) ) \
1468                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1469                 result = n; \
1470                 } \
1471         else \
1472                 { \
1473                 errno=0; \
1474                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1475                         { \
1476                         if( errno != EINTR) \
1477                                 { \
1478                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1479                                 break; \
1480                                 } \
1481                         errno=0; \
1482                         clearerr(yyin); \
1483                         } \
1484                 }\
1485 \
1486
1487 #endif
1488
1489 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1490  * we don't want an extra ';' after the "return" because that will cause
1491  * some compilers to complain about unreachable statements.
1492  */
1493 #ifndef yyterminate
1494 #define yyterminate() return YY_NULL
1495 #endif
1496
1497 /* Number of entries by which start-condition stack grows. */
1498 #ifndef YY_START_STACK_INCR
1499 #define YY_START_STACK_INCR 25
1500 #endif
1501
1502 /* Report a fatal error. */
1503 #ifndef YY_FATAL_ERROR
1504 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
1505 #endif
1506
1507 /* end tables serialization structures and prototypes */
1508
1509 /* Default declaration of generated scanner - a define so the user can
1510  * easily add parameters.
1511  */
1512 #ifndef YY_DECL
1513 #define YY_DECL_IS_OURS 1
1514
1515 extern int yylex (yyscan_t yyscanner);
1516
1517 #define YY_DECL int yylex (yyscan_t yyscanner)
1518 #endif /* !YY_DECL */
1519
1520 /* Code executed at the beginning of each rule, after yytext and yyleng
1521  * have been set up.
1522  */
1523 #ifndef YY_USER_ACTION
1524 #define YY_USER_ACTION
1525 #endif
1526
1527 /* Code executed at the end of each rule. */
1528 #ifndef YY_BREAK
1529 #define YY_BREAK break;
1530 #endif
1531
1532 #define YY_RULE_SETUP \
1533         YY_USER_ACTION
1534
1535 /** The main scanner function which does all the work.
1536  */
1537 YY_DECL
1538 {
1539         register yy_state_type yy_current_state;
1540         register char *yy_cp, *yy_bp;
1541         register int yy_act;
1542     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1543
1544 #line 159 "bitbakescanner.l"
1545
1546
1547 #line 1548 "<stdout>"
1548
1549         if ( yyg->yy_init )
1550                 {
1551                 yyg->yy_init = 0;
1552
1553 #ifdef YY_USER_INIT
1554                 YY_USER_INIT;
1555 #endif
1556
1557                 if ( ! yyg->yy_start )
1558                         yyg->yy_start = 1;      /* first start state */
1559
1560                 if ( ! yyin )
1561                         yyin = stdin;
1562
1563                 if ( ! yyout )
1564                         yyout = stdout;
1565
1566                 if ( ! YY_CURRENT_BUFFER ) {
1567                         yyensure_buffer_stack (yyscanner);
1568                         YY_CURRENT_BUFFER_LVALUE =
1569                                 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1570                 }
1571
1572                 yy_load_buffer_state(yyscanner );
1573                 }
1574
1575         while ( 1 )             /* loops until end-of-file is reached */
1576                 {
1577                 yy_cp = yyg->yy_c_buf_p;
1578
1579                 /* Support of yytext. */
1580                 *yy_cp = yyg->yy_hold_char;
1581
1582                 /* yy_bp points to the position in yy_ch_buf of the start of
1583                  * the current run.
1584                  */
1585                 yy_bp = yy_cp;
1586
1587                 yy_current_state = yyg->yy_start;
1588 yy_match:
1589                 do
1590                         {
1591                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1592                         if ( yy_accept[yy_current_state] )
1593                                 {
1594                                 yyg->yy_last_accepting_state = yy_current_state;
1595                                 yyg->yy_last_accepting_cpos = yy_cp;
1596                                 }
1597                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1598                                 {
1599                                 yy_current_state = (int) yy_def[yy_current_state];
1600                                 if ( yy_current_state >= 798 )
1601                                         yy_c = yy_meta[(unsigned int) yy_c];
1602                                 }
1603                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1604                         ++yy_cp;
1605                         }
1606                 while ( yy_current_state != 797 );
1607                 yy_cp = yyg->yy_last_accepting_cpos;
1608                 yy_current_state = yyg->yy_last_accepting_state;
1609
1610 yy_find_action:
1611                 yy_act = yy_accept[yy_current_state];
1612
1613                 YY_DO_BEFORE_ACTION;
1614
1615                 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1616                         {
1617                         int yyl;
1618                         for ( yyl = 0; yyl < yyleng; ++yyl )
1619                                 if ( yytext[yyl] == '\n' )
1620                                            
1621     do{ yylineno++;
1622         yycolumn=0;
1623     }while(0)
1624 ;
1625                         }
1626
1627 do_action:      /* This label is used only to access EOF actions. */
1628
1629                 switch ( yy_act )
1630         { /* beginning of action switch */
1631                         case 0: /* must back up */
1632                         /* undo the effects of YY_DO_BEFORE_ACTION */
1633                         *yy_cp = yyg->yy_hold_char;
1634                         yy_cp = yyg->yy_last_accepting_cpos;
1635                         yy_current_state = yyg->yy_last_accepting_state;
1636                         goto yy_find_action;
1637
1638 case 1:
1639 YY_RULE_SETUP
1640 #line 161 "bitbakescanner.l"
1641 { BEGIN S_RVALUE;
1642                                   yyextra->accept (T_OP_APPEND); }
1643         YY_BREAK
1644 case 2:
1645 YY_RULE_SETUP
1646 #line 163 "bitbakescanner.l"
1647 { BEGIN S_RVALUE;
1648                                   yyextra->accept (T_OP_PREPEND); }
1649         YY_BREAK
1650 case 3:
1651 YY_RULE_SETUP
1652 #line 165 "bitbakescanner.l"
1653 { BEGIN S_RVALUE;
1654                                   yyextra->accept (T_OP_IMMEDIATE); }
1655         YY_BREAK
1656 case 4:
1657 YY_RULE_SETUP
1658 #line 167 "bitbakescanner.l"
1659 { BEGIN S_RVALUE;
1660                                   yyextra->accept (T_OP_ASSIGN); }
1661         YY_BREAK
1662 case 5:
1663 YY_RULE_SETUP
1664 #line 169 "bitbakescanner.l"
1665 { BEGIN S_RVALUE;
1666                                   yyextra->accept (T_OP_COND); }
1667         YY_BREAK
1668 case 6:
1669 /* rule 6 can match eol */
1670 YY_RULE_SETUP
1671 #line 172 "bitbakescanner.l"
1672 {  }
1673         YY_BREAK
1674 case 7:
1675 /* rule 7 can match eol */
1676 YY_RULE_SETUP
1677 #line 173 "bitbakescanner.l"
1678 { BEGIN INITIAL;
1679                                   size_t cb = yyleng;
1680                                   while (cb && isspace (yytext[cb - 1]))
1681                                       --cb;
1682                                   yytext[cb - 1] = 0;
1683                                   yyextra->accept (T_STRING, yytext + 1); }
1684         YY_BREAK
1685 case 8:
1686 /* rule 8 can match eol */
1687 YY_RULE_SETUP
1688 #line 179 "bitbakescanner.l"
1689 { BEGIN INITIAL;
1690                                   size_t cb = yyleng;
1691                                   while (cb && isspace (yytext[cb - 1]))
1692                                       --cb;
1693                                   yytext[cb - 1] = 0;
1694                                   yyextra->accept (T_STRING, yytext + 1); }
1695         YY_BREAK
1696 case 9:
1697 /* rule 9 can match eol */
1698 YY_RULE_SETUP
1699 #line 186 "bitbakescanner.l"
1700 { ERROR (errorUnexpectedInput);  }
1701         YY_BREAK
1702 case 10:
1703 /* rule 10 can match eol */
1704 YY_RULE_SETUP
1705 #line 187 "bitbakescanner.l"
1706 { BEGIN INITIAL;
1707                                   yyextra->accept (T_STRING, NULL); }
1708         YY_BREAK
1709 case 11:
1710 YY_RULE_SETUP
1711 #line 190 "bitbakescanner.l"
1712 { BEGIN S_INCLUDE;
1713                                   yyextra->accept (T_INCLUDE); }
1714         YY_BREAK
1715 case 12:
1716 YY_RULE_SETUP
1717 #line 192 "bitbakescanner.l"
1718 { BEGIN S_REQUIRE;
1719                                   yyextra->accept (T_REQUIRE); }
1720         YY_BREAK
1721 case 13:
1722 YY_RULE_SETUP
1723 #line 194 "bitbakescanner.l"
1724 { BEGIN S_INHERIT;
1725                                   yyextra->accept (T_INHERIT); }
1726         YY_BREAK
1727 case 14:
1728 YY_RULE_SETUP
1729 #line 196 "bitbakescanner.l"
1730 { BEGIN S_TASK;
1731                                   yyextra->accept (T_ADDTASK); }
1732         YY_BREAK
1733 case 15:
1734 YY_RULE_SETUP
1735 #line 198 "bitbakescanner.l"
1736 { yyextra->accept (T_ADDHANDLER); }
1737         YY_BREAK
1738 case 16:
1739 YY_RULE_SETUP
1740 #line 199 "bitbakescanner.l"
1741 { BEGIN S_FUNC;
1742                                   yyextra->accept (T_EXPORT_FUNC); }
1743         YY_BREAK
1744 case 17:
1745 YY_RULE_SETUP
1746 #line 201 "bitbakescanner.l"
1747 { yyextra->accept (T_BEFORE); }
1748         YY_BREAK
1749 case 18:
1750 YY_RULE_SETUP
1751 #line 202 "bitbakescanner.l"
1752 { yyextra->accept (T_AFTER); }
1753         YY_BREAK
1754 case 19:
1755 YY_RULE_SETUP
1756 #line 203 "bitbakescanner.l"
1757 { yyextra->accept (T_EXPORT); }
1758         YY_BREAK
1759 case 20:
1760 YY_RULE_SETUP
1761 #line 205 "bitbakescanner.l"
1762 { yyextra->accept (T_FAKEROOT); }
1763         YY_BREAK
1764 case 21:
1765 YY_RULE_SETUP
1766 #line 206 "bitbakescanner.l"
1767 { yyextra->accept (T_PYTHON); }
1768         YY_BREAK
1769 case 22:
1770 /* rule 22 can match eol */
1771 YY_RULE_SETUP
1772 #line 207 "bitbakescanner.l"
1773 { BEGIN S_PROC;
1774                                   yyextra->accept (T_PROC_OPEN); }
1775         YY_BREAK
1776 case 23:
1777 /* rule 23 can match eol */
1778 YY_RULE_SETUP
1779 #line 209 "bitbakescanner.l"
1780 { BEGIN INITIAL;
1781                                   yyextra->accept (T_PROC_CLOSE); }
1782         YY_BREAK
1783 case 24:
1784 /* rule 24 can match eol */
1785 YY_RULE_SETUP
1786 #line 211 "bitbakescanner.l"
1787 { yyextra->accept (T_PROC_BODY, yytext); }
1788         YY_BREAK
1789 case 25:
1790 YY_RULE_SETUP
1791 #line 213 "bitbakescanner.l"
1792 { BEGIN S_DEF; }
1793         YY_BREAK
1794 case 26:
1795 YY_RULE_SETUP
1796 #line 214 "bitbakescanner.l"
1797 { BEGIN S_DEF_ARGS;
1798                                   yyextra->accept (T_SYMBOL, yytext); }
1799         YY_BREAK
1800 case 27:
1801 YY_RULE_SETUP
1802 #line 216 "bitbakescanner.l"
1803 { yyextra->accept (T_DEF_ARGS, yytext); }
1804         YY_BREAK
1805 case 28:
1806 /* rule 28 can match eol */
1807 YY_RULE_SETUP
1808 #line 217 "bitbakescanner.l"
1809 { BEGIN S_DEF_BODY; }
1810         YY_BREAK
1811 case 29:
1812 /* rule 29 can match eol */
1813 YY_RULE_SETUP
1814 #line 218 "bitbakescanner.l"
1815 { yyextra->accept (T_DEF_BODY, yytext); }
1816         YY_BREAK
1817 case 30:
1818 /* rule 30 can match eol */
1819 YY_RULE_SETUP
1820 #line 219 "bitbakescanner.l"
1821 { yyextra->accept (T_DEF_BODY, yytext); }
1822         YY_BREAK
1823 case 31:
1824 YY_RULE_SETUP
1825 #line 220 "bitbakescanner.l"
1826 { BEGIN INITIAL; unput (yytext[0]); }
1827         YY_BREAK
1828 case 32:
1829 /* rule 32 can match eol */
1830 YY_RULE_SETUP
1831 #line 222 "bitbakescanner.l"
1832 { }
1833         YY_BREAK
1834 case 33:
1835 YY_RULE_SETUP
1836 #line 224 "bitbakescanner.l"
1837 { yyextra->accept (T_SYMBOL, yytext); }
1838         YY_BREAK
1839 case 34:
1840 YY_RULE_SETUP
1841 #line 225 "bitbakescanner.l"
1842 { yyextra->accept (T_VARIABLE, yytext); }
1843         YY_BREAK
1844 case 35:
1845 YY_RULE_SETUP
1846 #line 227 "bitbakescanner.l"
1847 { yyextra->accept (T_TSYMBOL, yytext); }
1848         YY_BREAK
1849 case 36:
1850 YY_RULE_SETUP
1851 #line 228 "bitbakescanner.l"
1852 { yyextra->accept (T_FSYMBOL, yytext); }
1853         YY_BREAK
1854 case 37:
1855 YY_RULE_SETUP
1856 #line 229 "bitbakescanner.l"
1857 { yyextra->accept (T_ISYMBOL, yytext); }
1858         YY_BREAK
1859 case 38:
1860 YY_RULE_SETUP
1861 #line 230 "bitbakescanner.l"
1862 { BEGIN INITIAL;
1863                                   yyextra->accept (T_ISYMBOL, yytext); }
1864         YY_BREAK
1865 case 39:
1866 YY_RULE_SETUP
1867 #line 232 "bitbakescanner.l"
1868 { BEGIN INITIAL;
1869                                   yyextra->accept (T_ISYMBOL, yytext); }
1870         YY_BREAK
1871 case 40:
1872 /* rule 40 can match eol */
1873 YY_RULE_SETUP
1874 #line 234 "bitbakescanner.l"
1875 { BEGIN INITIAL; }
1876         YY_BREAK
1877 case 41:
1878 /* rule 41 can match eol */
1879 YY_RULE_SETUP
1880 #line 235 "bitbakescanner.l"
1881 { BEGIN INITIAL; }
1882         YY_BREAK
1883 case 42:
1884 /* rule 42 can match eol */
1885 YY_RULE_SETUP
1886 #line 236 "bitbakescanner.l"
1887 { BEGIN INITIAL; }
1888         YY_BREAK
1889 case 43:
1890 /* rule 43 can match eol */
1891 YY_RULE_SETUP
1892 #line 238 "bitbakescanner.l"
1893 /* Insignificant whitespace */
1894         YY_BREAK
1895 case 44:
1896 YY_RULE_SETUP
1897 #line 240 "bitbakescanner.l"
1898 { ERROR (errorUnexpectedInput); }
1899         YY_BREAK
1900 /* Check for premature termination */
1901 case YY_STATE_EOF(INITIAL):
1902 case YY_STATE_EOF(S_DEF):
1903 case YY_STATE_EOF(S_DEF_ARGS):
1904 case YY_STATE_EOF(S_DEF_BODY):
1905 case YY_STATE_EOF(S_FUNC):
1906 case YY_STATE_EOF(S_INCLUDE):
1907 case YY_STATE_EOF(S_INHERIT):
1908 case YY_STATE_EOF(S_REQUIRE):
1909 case YY_STATE_EOF(S_PROC):
1910 case YY_STATE_EOF(S_RVALUE):
1911 case YY_STATE_EOF(S_TASK):
1912 #line 243 "bitbakescanner.l"
1913 { return T_EOF; }
1914         YY_BREAK
1915 case 45:
1916 YY_RULE_SETUP
1917 #line 245 "bitbakescanner.l"
1918 ECHO;
1919         YY_BREAK
1920 #line 1921 "<stdout>"
1921
1922         case YY_END_OF_BUFFER:
1923                 {
1924                 /* Amount of text matched not including the EOB char. */
1925                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1926
1927                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1928                 *yy_cp = yyg->yy_hold_char;
1929                 YY_RESTORE_YY_MORE_OFFSET
1930
1931                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1932                         {
1933                         /* We're scanning a new file or input source.  It's
1934                          * possible that this happened because the user
1935                          * just pointed yyin at a new source and called
1936                          * yylex().  If so, then we have to assure
1937                          * consistency between YY_CURRENT_BUFFER and our
1938                          * globals.  Here is the right place to do so, because
1939                          * this is the first action (other than possibly a
1940                          * back-up) that will match for the new input source.
1941                          */
1942                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1943                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1944                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1945                         }
1946
1947                 /* Note that here we test for yy_c_buf_p "<=" to the position
1948                  * of the first EOB in the buffer, since yy_c_buf_p will
1949                  * already have been incremented past the NUL character
1950                  * (since all states make transitions on EOB to the
1951                  * end-of-buffer state).  Contrast this with the test
1952                  * in input().
1953                  */
1954                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1955                         { /* This was really a NUL. */
1956                         yy_state_type yy_next_state;
1957
1958                         yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1959
1960                         yy_current_state = yy_get_previous_state( yyscanner );
1961
1962                         /* Okay, we're now positioned to make the NUL
1963                          * transition.  We couldn't have
1964                          * yy_get_previous_state() go ahead and do it
1965                          * for us because it doesn't know how to deal
1966                          * with the possibility of jamming (and we don't
1967                          * want to build jamming into it because then it
1968                          * will run more slowly).
1969                          */
1970
1971                         yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1972
1973                         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1974
1975                         if ( yy_next_state )
1976                                 {
1977                                 /* Consume the NUL. */
1978                                 yy_cp = ++yyg->yy_c_buf_p;
1979                                 yy_current_state = yy_next_state;
1980                                 goto yy_match;
1981                                 }
1982
1983                         else
1984                                 {
1985                                 yy_cp = yyg->yy_last_accepting_cpos;
1986                                 yy_current_state = yyg->yy_last_accepting_state;
1987                                 goto yy_find_action;
1988                                 }
1989                         }
1990
1991                 else switch ( yy_get_next_buffer( yyscanner ) )
1992                         {
1993                         case EOB_ACT_END_OF_FILE:
1994                                 {
1995                                 yyg->yy_did_buffer_switch_on_eof = 0;
1996
1997                                 if ( yywrap(yyscanner ) )
1998                                         {
1999                                         /* Note: because we've taken care in
2000                                          * yy_get_next_buffer() to have set up
2001                                          * yytext, we can now set up
2002                                          * yy_c_buf_p so that if some total
2003                                          * hoser (like flex itself) wants to
2004                                          * call the scanner after we return the
2005                                          * YY_NULL, it'll still work - another
2006                                          * YY_NULL will get returned.
2007                                          */
2008                                         yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
2009
2010                                         yy_act = YY_STATE_EOF(YY_START);
2011                                         goto do_action;
2012                                         }
2013
2014                                 else
2015                                         {
2016                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
2017                                                 YY_NEW_FILE;
2018                                         }
2019                                 break;
2020                                 }
2021
2022                         case EOB_ACT_CONTINUE_SCAN:
2023                                 yyg->yy_c_buf_p =
2024                                         yyg->yytext_ptr + yy_amount_of_matched_text;
2025
2026                                 yy_current_state = yy_get_previous_state( yyscanner );
2027
2028                                 yy_cp = yyg->yy_c_buf_p;
2029                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
2030                                 goto yy_match;
2031
2032                         case EOB_ACT_LAST_MATCH:
2033                                 yyg->yy_c_buf_p =
2034                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
2035
2036                                 yy_current_state = yy_get_previous_state( yyscanner );
2037
2038                                 yy_cp = yyg->yy_c_buf_p;
2039                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
2040                                 goto yy_find_action;
2041                         }
2042                 break;
2043                 }
2044
2045         default:
2046                 YY_FATAL_ERROR(
2047                         "fatal flex scanner internal error--no action found" );
2048         } /* end of action switch */
2049                 } /* end of scanning one token */
2050 } /* end of yylex */
2051
2052 /* yy_get_next_buffer - try to read in a new buffer
2053  *
2054  * Returns a code representing an action:
2055  *      EOB_ACT_LAST_MATCH -
2056  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2057  *      EOB_ACT_END_OF_FILE - end of file
2058  */
2059 static int yy_get_next_buffer (yyscan_t yyscanner)
2060 {
2061     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2062         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2063         register char *source = yyg->yytext_ptr;
2064         register int number_to_move, i;
2065         int ret_val;
2066
2067         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
2068                 YY_FATAL_ERROR(
2069                 "fatal flex scanner internal error--end of buffer missed" );
2070
2071         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2072                 { /* Don't try to fill the buffer, so this is an EOF. */
2073                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
2074                         {
2075                         /* We matched a single character, the EOB, so
2076                          * treat this as a final EOF.
2077                          */
2078                         return EOB_ACT_END_OF_FILE;
2079                         }
2080
2081                 else
2082                         {
2083                         /* We matched some text prior to the EOB, first
2084                          * process it.
2085                          */
2086                         return EOB_ACT_LAST_MATCH;
2087                         }
2088                 }
2089
2090         /* Try to read more data. */
2091
2092         /* First move last chars to start of buffer. */
2093         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
2094
2095         for ( i = 0; i < number_to_move; ++i )
2096                 *(dest++) = *(source++);
2097
2098         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2099                 /* don't do the read, it's not guaranteed to return an EOF,
2100                  * just force an EOF
2101                  */
2102                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
2103
2104         else
2105                 {
2106                         size_t num_to_read =
2107                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2108
2109                 while ( num_to_read <= 0 )
2110                         { /* Not enough room in the buffer - grow it. */
2111
2112                         /* just a shorter name for the current buffer */
2113                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
2114
2115                         int yy_c_buf_p_offset =
2116                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
2117
2118                         if ( b->yy_is_our_buffer )
2119                                 {
2120                                 int new_size = b->yy_buf_size * 2;
2121
2122                                 if ( new_size <= 0 )
2123                                         b->yy_buf_size += b->yy_buf_size / 8;
2124                                 else
2125                                         b->yy_buf_size *= 2;
2126
2127                                 b->yy_ch_buf = (char *)
2128                                         /* Include room in for 2 EOB chars. */
2129                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
2130                                 }
2131                         else
2132                                 /* Can't grow it, we don't own it. */
2133                                 b->yy_ch_buf = 0;
2134
2135                         if ( ! b->yy_ch_buf )
2136                                 YY_FATAL_ERROR(
2137                                 "fatal error - scanner input buffer overflow" );
2138
2139                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2140
2141                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2142                                                 number_to_move - 1;
2143
2144                         }
2145
2146                 if ( num_to_read > YY_READ_BUF_SIZE )
2147                         num_to_read = YY_READ_BUF_SIZE;
2148
2149                 /* Read in more data. */
2150                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2151                         yyg->yy_n_chars, num_to_read );
2152
2153                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2154                 }
2155
2156         if ( yyg->yy_n_chars == 0 )
2157                 {
2158                 if ( number_to_move == YY_MORE_ADJ )
2159                         {
2160                         ret_val = EOB_ACT_END_OF_FILE;
2161                         yyrestart(yyin  ,yyscanner);
2162                         }
2163
2164                 else
2165                         {
2166                         ret_val = EOB_ACT_LAST_MATCH;
2167                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2168                                 YY_BUFFER_EOF_PENDING;
2169                         }
2170                 }
2171
2172         else
2173                 ret_val = EOB_ACT_CONTINUE_SCAN;
2174
2175         yyg->yy_n_chars += number_to_move;
2176         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2177         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2178
2179         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2180
2181         return ret_val;
2182 }
2183
2184 /* yy_get_previous_state - get the state just before the EOB char was reached */
2185
2186     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
2187 {
2188         register yy_state_type yy_current_state;
2189         register char *yy_cp;
2190     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2191
2192         yy_current_state = yyg->yy_start;
2193
2194         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
2195                 {
2196                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2197                 if ( yy_accept[yy_current_state] )
2198                         {
2199                         yyg->yy_last_accepting_state = yy_current_state;
2200                         yyg->yy_last_accepting_cpos = yy_cp;
2201                         }
2202                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2203                         {
2204                         yy_current_state = (int) yy_def[yy_current_state];
2205                         if ( yy_current_state >= 798 )
2206                                 yy_c = yy_meta[(unsigned int) yy_c];
2207                         }
2208                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2209                 }
2210
2211         return yy_current_state;
2212 }
2213
2214 /* yy_try_NUL_trans - try to make a transition on the NUL character
2215  *
2216  * synopsis
2217  *      next_state = yy_try_NUL_trans( current_state );
2218  */
2219     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
2220 {
2221         register int yy_is_jam;
2222     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2223         register char *yy_cp = yyg->yy_c_buf_p;
2224
2225         register YY_CHAR yy_c = 1;
2226         if ( yy_accept[yy_current_state] )
2227                 {
2228                 yyg->yy_last_accepting_state = yy_current_state;
2229                 yyg->yy_last_accepting_cpos = yy_cp;
2230                 }
2231         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2232                 {
2233                 yy_current_state = (int) yy_def[yy_current_state];
2234                 if ( yy_current_state >= 798 )
2235                         yy_c = yy_meta[(unsigned int) yy_c];
2236                 }
2237         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2238         yy_is_jam = (yy_current_state == 797);
2239
2240         return yy_is_jam ? 0 : yy_current_state;
2241 }
2242
2243     static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
2244 {
2245         register char *yy_cp;
2246     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2247
2248     yy_cp = yyg->yy_c_buf_p;
2249
2250         /* undo effects of setting up yytext */
2251         *yy_cp = yyg->yy_hold_char;
2252
2253         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2254                 { /* need to shift things up to make room */
2255                 /* +2 for EOB chars. */
2256                 register int number_to_move = yyg->yy_n_chars + 2;
2257                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2258                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2259                 register char *source =
2260                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2261
2262                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2263                         *--dest = *--source;
2264
2265                 yy_cp += (int) (dest - source);
2266                 yy_bp += (int) (dest - source);
2267                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2268                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2269
2270                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2271                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2272                 }
2273
2274         *--yy_cp = (char) c;
2275
2276     if ( c == '\n' ){
2277         --yylineno;
2278     }
2279
2280         yyg->yytext_ptr = yy_bp;
2281         yyg->yy_hold_char = *yy_cp;
2282         yyg->yy_c_buf_p = yy_cp;
2283 }
2284
2285 #ifndef YY_NO_INPUT
2286 #ifdef __cplusplus
2287     static int yyinput (yyscan_t yyscanner)
2288 #else
2289     static int input  (yyscan_t yyscanner)
2290 #endif
2291
2292 {
2293         int c;
2294     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2295
2296         *yyg->yy_c_buf_p = yyg->yy_hold_char;
2297
2298         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2299                 {
2300                 /* yy_c_buf_p now points to the character we want to return.
2301                  * If this occurs *before* the EOB characters, then it's a
2302                  * valid NUL; if not, then we've hit the end of the buffer.
2303                  */
2304                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
2305                         /* This was really a NUL. */
2306                         *yyg->yy_c_buf_p = '\0';
2307
2308                 else
2309                         { /* need more input */
2310                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
2311                         ++yyg->yy_c_buf_p;
2312
2313                         switch ( yy_get_next_buffer( yyscanner ) )
2314                                 {
2315                                 case EOB_ACT_LAST_MATCH:
2316                                         /* This happens because yy_g_n_b()
2317                                          * sees that we've accumulated a
2318                                          * token and flags that we need to
2319                                          * try matching the token before
2320                                          * proceeding.  But for input(),
2321                                          * there's no matching to consider.
2322                                          * So convert the EOB_ACT_LAST_MATCH
2323                                          * to EOB_ACT_END_OF_FILE.
2324                                          */
2325
2326                                         /* Reset buffer status. */
2327                                         yyrestart(yyin ,yyscanner);
2328
2329                                         /*FALLTHROUGH*/
2330
2331                                 case EOB_ACT_END_OF_FILE:
2332                                         {
2333                                         if ( yywrap(yyscanner ) )
2334                                                 return EOF;
2335
2336                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
2337                                                 YY_NEW_FILE;
2338 #ifdef __cplusplus
2339                                         return yyinput(yyscanner);
2340 #else
2341                                         return input(yyscanner);
2342 #endif
2343                                         }
2344
2345                                 case EOB_ACT_CONTINUE_SCAN:
2346                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
2347                                         break;
2348                                 }
2349                         }
2350                 }
2351
2352         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
2353         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
2354         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
2355
2356         if ( c == '\n' )
2357                    
2358     do{ yylineno++;
2359         yycolumn=0;
2360     }while(0)
2361 ;
2362
2363         return c;
2364 }
2365 #endif  /* ifndef YY_NO_INPUT */
2366
2367 /** Immediately switch to a different input stream.
2368  * @param input_file A readable stream.
2369  * @param yyscanner The scanner object.
2370  * @note This function does not reset the start condition to @c INITIAL .
2371  */
2372     void yyrestart  (FILE * input_file , yyscan_t yyscanner)
2373 {
2374     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2375
2376         if ( ! YY_CURRENT_BUFFER ){
2377         yyensure_buffer_stack (yyscanner);
2378                 YY_CURRENT_BUFFER_LVALUE =
2379             yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
2380         }
2381
2382         yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
2383         yy_load_buffer_state(yyscanner );
2384 }
2385
2386 /** Switch to a different input buffer.
2387  * @param new_buffer The new input buffer.
2388  * @param yyscanner The scanner object.
2389  */
2390     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
2391 {
2392     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2393
2394         /* TODO. We should be able to replace this entire function body
2395          * with
2396          *              yypop_buffer_state();
2397          *              yypush_buffer_state(new_buffer);
2398      */
2399         yyensure_buffer_stack (yyscanner);
2400         if ( YY_CURRENT_BUFFER == new_buffer )
2401                 return;
2402
2403         if ( YY_CURRENT_BUFFER )
2404                 {
2405                 /* Flush out information for old buffer. */
2406                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2407                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2408                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2409                 }
2410
2411         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2412         yy_load_buffer_state(yyscanner );
2413
2414         /* We don't actually know whether we did this switch during
2415          * EOF (yywrap()) processing, but the only time this flag
2416          * is looked at is after yywrap() is called, so it's safe
2417          * to go ahead and always set it.
2418          */
2419         yyg->yy_did_buffer_switch_on_eof = 1;
2420 }
2421
2422 static void yy_load_buffer_state  (yyscan_t yyscanner)
2423 {
2424     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2425         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2426         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2427         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2428         yyg->yy_hold_char = *yyg->yy_c_buf_p;
2429 }
2430
2431 /** Allocate and initialize an input buffer state.
2432  * @param file A readable stream.
2433  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2434  * @param yyscanner The scanner object.
2435  * @return the allocated buffer state.
2436  */
2437     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
2438 {
2439         YY_BUFFER_STATE b;
2440     
2441         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2442         if ( ! b )
2443                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2444
2445         b->yy_buf_size = size;
2446
2447         /* yy_ch_buf has to be 2 characters longer than the size given because
2448          * we need to put in 2 end-of-buffer characters.
2449          */
2450         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ,yyscanner );
2451         if ( ! b->yy_ch_buf )
2452                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2453
2454         b->yy_is_our_buffer = 1;
2455
2456         yy_init_buffer(b,file ,yyscanner);
2457
2458         return b;
2459 }
2460
2461 /** Destroy the buffer.
2462  * @param b a buffer created with yy_create_buffer()
2463  * @param yyscanner The scanner object.
2464  */
2465     void yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
2466 {
2467     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2468
2469         if ( ! b )
2470                 return;
2471
2472         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2473                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2474
2475         if ( b->yy_is_our_buffer )
2476                 yyfree((void *) b->yy_ch_buf ,yyscanner );
2477
2478         yyfree((void *) b ,yyscanner );
2479 }
2480
2481 /* Initializes or reinitializes a buffer.
2482  * This function is sometimes called more than once on the same buffer,
2483  * such as during a yyrestart() or at EOF.
2484  */
2485     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
2486
2487 {
2488         int oerrno = errno;
2489     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2490
2491         yy_flush_buffer(b ,yyscanner);
2492
2493         b->yy_input_file = file;
2494         b->yy_fill_buffer = 1;
2495
2496     /* If b is the current buffer, then yy_init_buffer was _probably_
2497      * called from yyrestart() or through yy_get_next_buffer.
2498      * In that case, we don't want to reset the lineno or column.
2499      */
2500     if (b != YY_CURRENT_BUFFER){
2501         b->yy_bs_lineno = 1;
2502         b->yy_bs_column = 0;
2503     }
2504
2505         b->yy_is_interactive = 0;
2506     
2507         errno = oerrno;
2508 }
2509
2510 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2511  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2512  * @param yyscanner The scanner object.
2513  */
2514     void yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
2515 {
2516     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2517         if ( ! b )
2518                 return;
2519
2520         b->yy_n_chars = 0;
2521
2522         /* We always need two end-of-buffer characters.  The first causes
2523          * a transition to the end-of-buffer state.  The second causes
2524          * a jam in that state.
2525          */
2526         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2527         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2528
2529         b->yy_buf_pos = &b->yy_ch_buf[0];
2530
2531         b->yy_at_bol = 1;
2532         b->yy_buffer_status = YY_BUFFER_NEW;
2533
2534         if ( b == YY_CURRENT_BUFFER )
2535                 yy_load_buffer_state(yyscanner );
2536 }
2537
2538 /** Pushes the new state onto the stack. The new state becomes
2539  *  the current state. This function will allocate the stack
2540  *  if necessary.
2541  *  @param new_buffer The new state.
2542  *  @param yyscanner The scanner object.
2543  */
2544 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2545 {
2546     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2547         if (new_buffer == NULL)
2548                 return;
2549
2550         yyensure_buffer_stack(yyscanner);
2551
2552         /* This block is copied from yy_switch_to_buffer. */
2553         if ( YY_CURRENT_BUFFER )
2554                 {
2555                 /* Flush out information for old buffer. */
2556                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2557                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2558                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2559                 }
2560
2561         /* Only push if top exists. Otherwise, replace top. */
2562         if (YY_CURRENT_BUFFER)
2563                 yyg->yy_buffer_stack_top++;
2564         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2565
2566         /* copied from yy_switch_to_buffer. */
2567         yy_load_buffer_state(yyscanner );
2568         yyg->yy_did_buffer_switch_on_eof = 1;
2569 }
2570
2571 /** Removes and deletes the top of the stack, if present.
2572  *  The next element becomes the new top.
2573  *  @param yyscanner The scanner object.
2574  */
2575 void yypop_buffer_state (yyscan_t yyscanner)
2576 {
2577     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2578         if (!YY_CURRENT_BUFFER)
2579                 return;
2580
2581         yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
2582         YY_CURRENT_BUFFER_LVALUE = NULL;
2583         if (yyg->yy_buffer_stack_top > 0)
2584                 --yyg->yy_buffer_stack_top;
2585
2586         if (YY_CURRENT_BUFFER) {
2587                 yy_load_buffer_state(yyscanner );
2588                 yyg->yy_did_buffer_switch_on_eof = 1;
2589         }
2590 }
2591
2592 /* Allocates the stack if it does not exist.
2593  *  Guarantees space for at least one push.
2594  */
2595 static void yyensure_buffer_stack (yyscan_t yyscanner)
2596 {
2597         int num_to_alloc;
2598     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2599
2600         if (!yyg->yy_buffer_stack) {
2601
2602                 /* First allocation is just for 2 elements, since we don't know if this
2603                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2604                  * immediate realloc on the next call.
2605          */
2606                 num_to_alloc = 1;
2607                 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
2608                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2609                                                                 , yyscanner);
2610                 
2611                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2612                                 
2613                 yyg->yy_buffer_stack_max = num_to_alloc;
2614                 yyg->yy_buffer_stack_top = 0;
2615                 return;
2616         }
2617
2618         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
2619
2620                 /* Increase the buffer to prepare for a possible push. */
2621                 int grow_size = 8 /* arbitrary grow size */;
2622
2623                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
2624                 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
2625                                                                 (yyg->yy_buffer_stack,
2626                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2627                                                                 , yyscanner);
2628
2629                 /* zero only the new slots.*/
2630                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2631                 yyg->yy_buffer_stack_max = num_to_alloc;
2632         }
2633 }
2634
2635 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2636  * @param base the character buffer
2637  * @param size the size in bytes of the character buffer
2638  * @param yyscanner The scanner object.
2639  * @return the newly allocated buffer state object. 
2640  */
2641 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
2642 {
2643         YY_BUFFER_STATE b;
2644     
2645         if ( size < 2 ||
2646              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2647              base[size-1] != YY_END_OF_BUFFER_CHAR )
2648                 /* They forgot to leave room for the EOB's. */
2649                 return 0;
2650
2651         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2652         if ( ! b )
2653                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2654
2655         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2656         b->yy_buf_pos = b->yy_ch_buf = base;
2657         b->yy_is_our_buffer = 0;
2658         b->yy_input_file = 0;
2659         b->yy_n_chars = b->yy_buf_size;
2660         b->yy_is_interactive = 0;
2661         b->yy_at_bol = 1;
2662         b->yy_fill_buffer = 0;
2663         b->yy_buffer_status = YY_BUFFER_NEW;
2664
2665         yy_switch_to_buffer(b ,yyscanner );
2666
2667         return b;
2668 }
2669
2670 /** Setup the input buffer state to scan a string. The next call to yylex() will
2671  * scan from a @e copy of @a str.
2672  * @param str a NUL-terminated string to scan
2673  * @param yyscanner The scanner object.
2674  * @return the newly allocated buffer state object.
2675  * @note If you want to scan bytes that may contain NUL values, then use
2676  *       yy_scan_bytes() instead.
2677  */
2678 YY_BUFFER_STATE yy_scan_string (yyconst char * str , yyscan_t yyscanner)
2679 {
2680     
2681         return yy_scan_bytes(str,strlen(str) ,yyscanner);
2682 }
2683
2684 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2685  * scan from a @e copy of @a bytes.
2686  * @param bytes the byte buffer to scan
2687  * @param len the number of bytes in the buffer pointed to by @a bytes.
2688  * @param yyscanner The scanner object.
2689  * @return the newly allocated buffer state object.
2690  */
2691 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * bytes, int  len , yyscan_t yyscanner)
2692 {
2693         YY_BUFFER_STATE b;
2694         char *buf;
2695         yy_size_t n;
2696         int i;
2697     
2698         /* Get memory for full buffer, including space for trailing EOB's. */
2699         n = len + 2;
2700         buf = (char *) yyalloc(n ,yyscanner );
2701         if ( ! buf )
2702                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2703
2704         for ( i = 0; i < len; ++i )
2705                 buf[i] = bytes[i];
2706
2707         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2708
2709         b = yy_scan_buffer(buf,n ,yyscanner);
2710         if ( ! b )
2711                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2712
2713         /* It's okay to grow etc. this buffer, and we should throw it
2714          * away when we're done.
2715          */
2716         b->yy_is_our_buffer = 1;
2717
2718         return b;
2719 }
2720
2721     static void yy_push_state (int  new_state , yyscan_t yyscanner)
2722 {
2723     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2724         if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth )
2725                 {
2726                 yy_size_t new_size;
2727
2728                 yyg->yy_start_stack_depth += YY_START_STACK_INCR;
2729                 new_size = yyg->yy_start_stack_depth * sizeof( int );
2730
2731                 if ( ! yyg->yy_start_stack )
2732                         yyg->yy_start_stack = (int *) yyalloc(new_size ,yyscanner );
2733
2734                 else
2735                         yyg->yy_start_stack = (int *) yyrealloc((void *) yyg->yy_start_stack,new_size ,yyscanner );
2736
2737                 if ( ! yyg->yy_start_stack )
2738                         YY_FATAL_ERROR(
2739                         "out of memory expanding start-condition stack" );
2740                 }
2741
2742         yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START;
2743
2744         BEGIN(new_state);
2745 }
2746
2747     static void yy_pop_state  (yyscan_t yyscanner)
2748 {
2749     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2750         if ( --yyg->yy_start_stack_ptr < 0 )
2751                 YY_FATAL_ERROR( "start-condition stack underflow" );
2752
2753         BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]);
2754 }
2755
2756     static int yy_top_state  (yyscan_t yyscanner)
2757 {
2758     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2759         return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1];
2760 }
2761
2762 #ifndef YY_EXIT_FAILURE
2763 #define YY_EXIT_FAILURE 2
2764 #endif
2765
2766 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
2767 {
2768         (void) fprintf( stderr, "%s\n", msg );
2769         exit( YY_EXIT_FAILURE );
2770 }
2771
2772 /* Redefine yyless() so it works in section 3 code. */
2773
2774 #undef yyless
2775 #define yyless(n) \
2776         do \
2777                 { \
2778                 /* Undo effects of setting up yytext. */ \
2779         int yyless_macro_arg = (n); \
2780         YY_LESS_LINENO(yyless_macro_arg);\
2781                 yytext[yyleng] = yyg->yy_hold_char; \
2782                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2783                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2784                 *yyg->yy_c_buf_p = '\0'; \
2785                 yyleng = yyless_macro_arg; \
2786                 } \
2787         while ( 0 )
2788
2789 /* Accessor  methods (get/set functions) to struct members. */
2790
2791 /** Get the user-defined data for this scanner.
2792  * @param yyscanner The scanner object.
2793  */
2794 YY_EXTRA_TYPE yyget_extra  (yyscan_t yyscanner)
2795 {
2796     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2797     return yyextra;
2798 }
2799
2800 /** Get the current line number.
2801  * @param yyscanner The scanner object.
2802  */
2803 int yyget_lineno  (yyscan_t yyscanner)
2804 {
2805     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2806     
2807         if (! YY_CURRENT_BUFFER)
2808             return 0;
2809     
2810     return yylineno;
2811 }
2812
2813 /** Get the current column number.
2814  * @param yyscanner The scanner object.
2815  */
2816 int yyget_column  (yyscan_t yyscanner)
2817 {
2818     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2819     
2820         if (! YY_CURRENT_BUFFER)
2821             return 0;
2822     
2823     return yycolumn;
2824 }
2825
2826 /** Get the input stream.
2827  * @param yyscanner The scanner object.
2828  */
2829 FILE *yyget_in  (yyscan_t yyscanner)
2830 {
2831     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2832     return yyin;
2833 }
2834
2835 /** Get the output stream.
2836  * @param yyscanner The scanner object.
2837  */
2838 FILE *yyget_out  (yyscan_t yyscanner)
2839 {
2840     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2841     return yyout;
2842 }
2843
2844 /** Get the length of the current token.
2845  * @param yyscanner The scanner object.
2846  */
2847 int yyget_leng  (yyscan_t yyscanner)
2848 {
2849     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2850     return yyleng;
2851 }
2852
2853 /** Get the current token.
2854  * @param yyscanner The scanner object.
2855  */
2856
2857 char *yyget_text  (yyscan_t yyscanner)
2858 {
2859     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2860     return yytext;
2861 }
2862
2863 /** Set the user-defined data. This data is never touched by the scanner.
2864  * @param user_defined The data to be associated with this scanner.
2865  * @param yyscanner The scanner object.
2866  */
2867 void yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
2868 {
2869     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2870     yyextra = user_defined ;
2871 }
2872
2873 /** Set the current line number.
2874  * @param line_number
2875  * @param yyscanner The scanner object.
2876  */
2877 void yyset_lineno (int  line_number , yyscan_t yyscanner)
2878 {
2879     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2880
2881         /* lineno is only valid if an input buffer exists. */
2882         if (! YY_CURRENT_BUFFER )
2883            yy_fatal_error( "yyset_lineno called with no buffer" , yyscanner); 
2884     
2885     yylineno = line_number;
2886 }
2887
2888 /** Set the current column.
2889  * @param line_number
2890  * @param yyscanner The scanner object.
2891  */
2892 void yyset_column (int  column_no , yyscan_t yyscanner)
2893 {
2894     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2895
2896         /* column is only valid if an input buffer exists. */
2897         if (! YY_CURRENT_BUFFER )
2898            yy_fatal_error( "yyset_column called with no buffer" , yyscanner); 
2899     
2900     yycolumn = column_no;
2901 }
2902
2903 /** Set the input stream. This does not discard the current
2904  * input buffer.
2905  * @param in_str A readable stream.
2906  * @param yyscanner The scanner object.
2907  * @see yy_switch_to_buffer
2908  */
2909 void yyset_in (FILE *  in_str , yyscan_t yyscanner)
2910 {
2911     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2912     yyin = in_str ;
2913 }
2914
2915 void yyset_out (FILE *  out_str , yyscan_t yyscanner)
2916 {
2917     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2918     yyout = out_str ;
2919 }
2920
2921 int yyget_debug  (yyscan_t yyscanner)
2922 {
2923     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2924     return yy_flex_debug;
2925 }
2926
2927 void yyset_debug (int  bdebug , yyscan_t yyscanner)
2928 {
2929     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2930     yy_flex_debug = bdebug ;
2931 }
2932
2933 /* Accessor methods for yylval and yylloc */
2934
2935 static int yy_init_globals (yyscan_t yyscanner)
2936 {
2937     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2938     /* Initialization is the same as for the non-reentrant scanner.
2939        This function is called once per scanner lifetime. */
2940
2941     yyg->yy_buffer_stack = 0;
2942     yyg->yy_buffer_stack_top = 0;
2943     yyg->yy_buffer_stack_max = 0;
2944     yyg->yy_c_buf_p = (char *) 0;
2945     yyg->yy_init = 1;
2946     yyg->yy_start = 0;
2947     yyg->yy_start_stack_ptr = 0;
2948     yyg->yy_start_stack_depth = 0;
2949     yyg->yy_start_stack = (int *) 0;
2950
2951 /* Defined in main.c */
2952 #ifdef YY_STDINIT
2953     yyin = stdin;
2954     yyout = stdout;
2955 #else
2956     yyin = (FILE *) 0;
2957     yyout = (FILE *) 0;
2958 #endif
2959
2960     /* For future reference: Set errno on error, since we are called by
2961      * yylex_init()
2962      */
2963     return 0;
2964 }
2965
2966 /* User-visible API */
2967
2968 /* yylex_init is special because it creates the scanner itself, so it is
2969  * the ONLY reentrant function that doesn't take the scanner as the last argument.
2970  * That's why we explicitly handle the declaration, instead of using our macros.
2971  */
2972
2973 int yylex_init(yyscan_t* ptr_yy_globals)
2974
2975 {
2976     if (ptr_yy_globals == NULL){
2977         errno = EINVAL;
2978         return 1;
2979     }
2980
2981     *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2982
2983     if (*ptr_yy_globals == NULL){
2984         errno = ENOMEM;
2985         return 1;
2986     }
2987
2988     memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
2989
2990     return yy_init_globals ( *ptr_yy_globals );
2991 }
2992
2993 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2994 int yylex_destroy  (yyscan_t yyscanner)
2995 {
2996     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2997
2998     /* Pop the buffer stack, destroying each element. */
2999         while(YY_CURRENT_BUFFER){
3000                 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
3001                 YY_CURRENT_BUFFER_LVALUE = NULL;
3002                 yypop_buffer_state(yyscanner);
3003         }
3004
3005         /* Destroy the stack itself. */
3006         yyfree(yyg->yy_buffer_stack ,yyscanner);
3007         yyg->yy_buffer_stack = NULL;
3008
3009     /* Destroy the start condition stack. */
3010         yyfree(yyg->yy_start_stack ,yyscanner );
3011         yyg->yy_start_stack = NULL;
3012
3013     /* Destroy the main struct (reentrant only). */
3014     yyfree ( yyscanner , yyscanner );
3015     return 0;
3016 }
3017
3018 /*
3019  * Internal utility routines.
3020  */
3021
3022 #ifndef yytext_ptr
3023 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
3024 {
3025         register int i;
3026     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3027         for ( i = 0; i < n; ++i )
3028                 s1[i] = s2[i];
3029 }
3030 #endif
3031
3032 #ifdef YY_NEED_STRLEN
3033 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
3034 {
3035         register int n;
3036     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3037         for ( n = 0; s[n]; ++n )
3038                 ;
3039
3040         return n;
3041 }
3042 #endif
3043
3044 void *yyalloc (yy_size_t  size , yyscan_t yyscanner)
3045 {
3046         return (void *) malloc( size );
3047 }
3048
3049 void *yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
3050 {
3051         /* The cast to (char *) in the following accommodates both
3052          * implementations that use char* generic pointers, and those
3053          * that use void* generic pointers.  It works with the latter
3054          * because both ANSI C and C++ allow castless assignment from
3055          * any pointer type to void*, and deal with argument conversions
3056          * as though doing an assignment.
3057          */
3058         return (void *) realloc( (char *) ptr, size );
3059 }
3060
3061 void yyfree (void * ptr , yyscan_t yyscanner)
3062 {
3063         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
3064 }
3065
3066 #define YYTABLES_NAME "yytables"
3067
3068 #undef YY_NEW_FILE
3069 #undef YY_FLUSH_BUFFER
3070 #undef yy_set_bol
3071 #undef yy_new_buffer
3072 #undef yy_set_interactive
3073 #undef yytext_ptr
3074 #undef YY_DO_BEFORE_ACTION
3075
3076 #ifdef YY_DECL_IS_OURS
3077 #undef YY_DECL_IS_OURS
3078 #undef YY_DECL
3079 #endif
3080 #line 245 "bitbakescanner.l"
3081
3082
3083
3084 void lex_t::accept (int token, const char* sz) 
3085 {
3086     token_t t;
3087     memset (&t, 0, sizeof (t));
3088     t.copyString(sz);
3089
3090     /* tell lemon to parse the token */
3091     parse (parser, token, t, this);
3092 }
3093
3094 int lex_t::line ()const
3095 {
3096     return yyget_lineno (scanner);
3097 }
3098
3099 void parse (FILE* file, PyObject* data)
3100 {
3101     void* parser = bbparseAlloc (malloc);
3102     yyscan_t scanner;
3103     lex_t lex;
3104
3105     yylex_init (&scanner);
3106
3107     lex.parser = parser;
3108     lex.scanner = scanner;
3109     lex.file = file;
3110     lex.data = data;
3111     lex.parse = bbparse;
3112     yyset_extra (&lex, scanner);
3113
3114
3115     int result = yylex (scanner);
3116
3117     lex.accept (0);
3118     bbparseTrace (NULL, NULL);
3119
3120     if (result != T_EOF)
3121         printf ("premature end of file\n");
3122
3123     yylex_destroy (scanner);
3124     bbparseFree (parser, free);
3125 }
3126