BadVPN – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 #line 2 "generated//flex_BPredicate.c"
2  
3 #line 4 "generated//flex_BPredicate.c"
4  
5 #define YY_INT_ALIGNED short int
6  
7 /* A lexical scanner generated by flex */
8  
9 #define FLEX_SCANNER
10 #define YY_FLEX_MAJOR_VERSION 2
11 #define YY_FLEX_MINOR_VERSION 5
12 #define YY_FLEX_SUBMINOR_VERSION 37
13 #if YY_FLEX_SUBMINOR_VERSION > 0
14 #define FLEX_BETA
15 #endif
16  
17 /* First, we deal with platform-specific or compiler-specific issues. */
18  
19 /* begin standard C headers. */
20 #include <stdio.h>
21 #include <string.h>
22 #include <errno.h>
23 #include <stdlib.h>
24  
25 /* end standard C headers. */
26  
27 /* flex integer type definitions */
28  
29 #ifndef FLEXINT_H
30 #define FLEXINT_H
31  
32 /* C99 systems have <stdint.h>. Non-C99 systems may or may not. */
33  
34 #if 1
35  
36 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
37 * if you want the limit (max/min) macros for int types.
38 */
39 #ifndef __STDC_LIMIT_MACROS
40 #define __STDC_LIMIT_MACROS 1
41 #endif
42  
43 #include <stdint.h>
44 typedef int8_t flex_int8_t;
45 typedef uint8_t flex_uint8_t;
46 typedef int16_t flex_int16_t;
47 typedef uint16_t flex_uint16_t;
48 typedef int32_t flex_int32_t;
49 typedef uint32_t flex_uint32_t;
50 #else
51 typedef signed char flex_int8_t;
52 typedef short int flex_int16_t;
53 typedef int flex_int32_t;
54 typedef unsigned char flex_uint8_t;
55 typedef unsigned short int flex_uint16_t;
56 typedef unsigned int flex_uint32_t;
57  
58 /* Limits of integral types. */
59 #ifndef INT8_MIN
60 #define INT8_MIN (-128)
61 #endif
62 #ifndef INT16_MIN
63 #define INT16_MIN (-32767-1)
64 #endif
65 #ifndef INT32_MIN
66 #define INT32_MIN (-2147483647-1)
67 #endif
68 #ifndef INT8_MAX
69 #define INT8_MAX (127)
70 #endif
71 #ifndef INT16_MAX
72 #define INT16_MAX (32767)
73 #endif
74 #ifndef INT32_MAX
75 #define INT32_MAX (2147483647)
76 #endif
77 #ifndef UINT8_MAX
78 #define UINT8_MAX (255U)
79 #endif
80 #ifndef UINT16_MAX
81 #define UINT16_MAX (65535U)
82 #endif
83 #ifndef UINT32_MAX
84 #define UINT32_MAX (4294967295U)
85 #endif
86  
87 #endif /* ! C99 */
88  
89 #endif /* ! FLEXINT_H */
90  
91 #ifdef __cplusplus
92  
93 /* The "const" storage-class-modifier is valid. */
94 #define YY_USE_CONST
95  
96 #else /* ! __cplusplus */
97  
98 /* C99 requires __STDC__ to be defined as 1. */
99 #if defined (__STDC__)
100  
101 #define YY_USE_CONST
102  
103 #endif /* defined (__STDC__) */
104 #endif /* ! __cplusplus */
105  
106 #ifdef YY_USE_CONST
107 #define yyconst const
108 #else
109 #define yyconst
110 #endif
111  
112 /* Returned upon end-of-file. */
113 #define YY_NULL 0
114  
115 /* Promotes a possibly negative, possibly signed char to an unsigned
116 * integer for use as an array index. If the signed char is negative,
117 * we want to instead treat it as an 8-bit unsigned char, hence the
118 * double cast.
119 */
120 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
121  
122 /* An opaque pointer. */
123 #ifndef YY_TYPEDEF_YY_SCANNER_T
124 #define YY_TYPEDEF_YY_SCANNER_T
125 typedef void* yyscan_t;
126 #endif
127  
128 /* For convenience, these vars (plus the bison vars far below)
129 are macros in the reentrant scanner. */
130 #define yyin yyg->yyin_r
131 #define yyout yyg->yyout_r
132 #define yyextra yyg->yyextra_r
133 #define yyleng yyg->yyleng_r
134 #define yytext yyg->yytext_r
135 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
136 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
137 #define yy_flex_debug yyg->yy_flex_debug_r
138  
139 /* Enter a start condition. This macro really ought to take a parameter,
140 * but we do it the disgusting crufty way forced on us by the ()-less
141 * definition of BEGIN.
142 */
143 #define BEGIN yyg->yy_start = 1 + 2 *
144  
145 /* Translate the current start state into a value that can be later handed
146 * to BEGIN to return to the state. The YYSTATE alias is for lex
147 * compatibility.
148 */
149 #define YY_START ((yyg->yy_start - 1) / 2)
150 #define YYSTATE YY_START
151  
152 /* Action number for EOF rule of a given start state. */
153 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
154  
155 /* Special action meaning "start processing a new file". */
156 #define YY_NEW_FILE yyrestart(yyin ,yyscanner )
157  
158 #define YY_END_OF_BUFFER_CHAR 0
159  
160 /* Size of default input buffer. */
161 #ifndef YY_BUF_SIZE
162 #define YY_BUF_SIZE 16384
163 #endif
164  
165 /* The state buf must be large enough to hold one state per character in the main buffer.
166 */
167 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
168  
169 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
170 #define YY_TYPEDEF_YY_BUFFER_STATE
171 typedef struct yy_buffer_state *YY_BUFFER_STATE;
172 #endif
173  
174 #ifndef YY_TYPEDEF_YY_SIZE_T
175 #define YY_TYPEDEF_YY_SIZE_T
176 typedef size_t yy_size_t;
177 #endif
178  
179 #define EOB_ACT_CONTINUE_SCAN 0
180 #define EOB_ACT_END_OF_FILE 1
181 #define EOB_ACT_LAST_MATCH 2
182  
183 #define YY_LESS_LINENO(n)
184  
185 /* Return all but the first "n" matched characters back to the input stream. */
186 #define yyless(n) \
187 do \
188 { \
189 /* Undo effects of setting up yytext. */ \
190 int yyless_macro_arg = (n); \
191 YY_LESS_LINENO(yyless_macro_arg);\
192 *yy_cp = yyg->yy_hold_char; \
193 YY_RESTORE_YY_MORE_OFFSET \
194 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
196 } \
197 while ( 0 )
198  
199 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
200  
201 #ifndef YY_STRUCT_YY_BUFFER_STATE
202 #define YY_STRUCT_YY_BUFFER_STATE
203 struct yy_buffer_state
204 {
205 FILE *yy_input_file;
206  
207 char *yy_ch_buf; /* input buffer */
208 char *yy_buf_pos; /* current position in input buffer */
209  
210 /* Size of input buffer in bytes, not including room for EOB
211 * characters.
212 */
213 yy_size_t yy_buf_size;
214  
215 /* Number of characters read into yy_ch_buf, not including EOB
216 * characters.
217 */
218 yy_size_t yy_n_chars;
219  
220 /* Whether we "own" the buffer - i.e., we know we created it,
221 * and can realloc() it to grow it, and should free() it to
222 * delete it.
223 */
224 int yy_is_our_buffer;
225  
226 /* Whether this is an "interactive" input source; if so, and
227 * if we're using stdio for input, then we want to use getc()
228 * instead of fread(), to make sure we stop fetching input after
229 * each newline.
230 */
231 int yy_is_interactive;
232  
233 /* Whether we're considered to be at the beginning of a line.
234 * If so, '^' rules will be active on the next match, otherwise
235 * not.
236 */
237 int yy_at_bol;
238  
239 int yy_bs_lineno; /**< The line count. */
240 int yy_bs_column; /**< The column count. */
241  
242 /* Whether to try to fill the input buffer when we reach the
243 * end of it.
244 */
245 int yy_fill_buffer;
246  
247 int yy_buffer_status;
248  
249 #define YY_BUFFER_NEW 0
250 #define YY_BUFFER_NORMAL 1
251 /* When an EOF's been seen but there's still some text to process
252 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
253 * shouldn't try reading from the input source any more. We might
254 * still have a bunch of tokens to match, though, because of
255 * possible backing-up.
256 *
257 * When we actually see the EOF, we change the status to "new"
258 * (via yyrestart()), so that the user can continue scanning by
259 * just pointing yyin at a new input file.
260 */
261 #define YY_BUFFER_EOF_PENDING 2
262  
263 };
264 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
265  
266 /* We provide macros for accessing buffer states in case in the
267 * future we want to put the buffer states in a more general
268 * "scanner state".
269 *
270 * Returns the top of the stack, or NULL.
271 */
272 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
273 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
274 : NULL)
275  
276 /* Same as previous macro, but useful when we know that the buffer stack is not
277 * NULL or when we need an lvalue. For internal use only.
278 */
279 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
280  
281 void yyrestart (FILE *input_file ,yyscan_t yyscanner );
282 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
283 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
284 void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
285 void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
286 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
287 void yypop_buffer_state (yyscan_t yyscanner );
288  
289 static void yyensure_buffer_stack (yyscan_t yyscanner );
290 static void yy_load_buffer_state (yyscan_t yyscanner );
291 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
292  
293 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
294  
295 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
296 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
297 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
298  
299 void *yyalloc (yy_size_t ,yyscan_t yyscanner );
300 void *yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
301 void yyfree (void * ,yyscan_t yyscanner );
302  
303 #define yy_new_buffer yy_create_buffer
304  
305 #define yy_set_interactive(is_interactive) \
306 { \
307 if ( ! YY_CURRENT_BUFFER ){ \
308 yyensure_buffer_stack (yyscanner); \
309 YY_CURRENT_BUFFER_LVALUE = \
310 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
311 } \
312 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
313 }
314  
315 #define yy_set_bol(at_bol) \
316 { \
317 if ( ! YY_CURRENT_BUFFER ){\
318 yyensure_buffer_stack (yyscanner); \
319 YY_CURRENT_BUFFER_LVALUE = \
320 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
321 } \
322 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
323 }
324  
325 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
326  
327 /* Begin user sect3 */
328  
329 #define yywrap(yyscanner) 1
330 #define YY_SKIP_YYWRAP
331  
332 typedef unsigned char YY_CHAR;
333  
334 typedef int yy_state_type;
335  
336 #define yytext_ptr yytext_r
337  
338 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
339 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
340 static int yy_get_next_buffer (yyscan_t yyscanner );
341 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
342  
343 /* Done after the current pattern has been matched and before the
344 * corresponding action - sets up yytext.
345 */
346 #define YY_DO_BEFORE_ACTION \
347 yyg->yytext_ptr = yy_bp; \
348 yyleng = (size_t) (yy_cp - yy_bp); \
349 yyg->yy_hold_char = *yy_cp; \
350 *yy_cp = '\0'; \
351 yyg->yy_c_buf_p = yy_cp;
352  
353 #define YY_NUM_RULES 13
354 #define YY_END_OF_BUFFER 14
355 /* This struct is not used in this scanner,
356 but its presence is necessary. */
357 struct yy_trans_info
358 {
359 flex_int32_t yy_verify;
360 flex_int32_t yy_nxt;
361 };
362 static yyconst flex_int16_t yy_accept[34] =
363 { 0,
364 0, 0, 14, 12, 11, 11, 12, 1, 2, 3,
365 9, 9, 9, 9, 9, 9, 11, 0, 10, 9,
366 9, 9, 5, 9, 9, 4, 6, 9, 9, 9,
367 7, 8, 0
368 } ;
369  
370 static yyconst flex_int32_t yy_ec[256] =
371 { 0,
372 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
373 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
374 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
375 1, 2, 1, 4, 1, 1, 1, 1, 1, 5,
376 6, 1, 1, 7, 1, 1, 1, 8, 8, 8,
377 8, 8, 8, 8, 8, 8, 8, 1, 1, 1,
378 1, 1, 1, 1, 9, 8, 8, 10, 8, 8,
379 8, 8, 8, 8, 8, 8, 8, 11, 12, 8,
380 8, 13, 8, 14, 8, 8, 8, 8, 8, 8,
381 1, 1, 1, 1, 8, 1, 15, 8, 8, 8,
382  
383 16, 17, 8, 8, 8, 8, 8, 18, 8, 8,
384 8, 8, 8, 19, 20, 21, 22, 8, 8, 8,
385 8, 8, 1, 1, 1, 1, 1, 1, 1, 1,
386 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
387 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
388 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
389 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
390 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
391 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
392 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
393  
394 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
395 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
396 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
397 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
398 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
399 1, 1, 1, 1, 1
400 } ;
401  
402 static yyconst flex_int32_t yy_meta[23] =
403 { 0,
404 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
405 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
406 2, 2
407 } ;
408  
409 static yyconst flex_int16_t yy_base[36] =
410 { 0,
411 0, 0, 46, 47, 21, 23, 41, 47, 47, 47,
412 0, 33, 31, 29, 26, 21, 25, 35, 47, 0,
413 28, 23, 0, 18, 13, 0, 0, 14, 17, 16,
414 0, 0, 47, 28, 29
415 } ;
416  
417 static yyconst flex_int16_t yy_def[36] =
418 { 0,
419 33, 1, 33, 33, 33, 33, 34, 33, 33, 33,
420 35, 35, 35, 35, 35, 35, 33, 34, 33, 35,
421 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
422 35, 35, 0, 33, 33
423 } ;
424  
425 static yyconst flex_int16_t yy_nxt[70] =
426 { 0,
427 4, 5, 6, 7, 8, 9, 10, 11, 12, 11,
428 13, 14, 11, 11, 11, 11, 15, 11, 11, 11,
429 16, 11, 17, 17, 17, 17, 17, 17, 18, 18,
430 20, 32, 31, 30, 29, 28, 27, 26, 19, 25,
431 24, 23, 22, 21, 19, 33, 3, 33, 33, 33,
432 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
433 33, 33, 33, 33, 33, 33, 33, 33, 33
434 } ;
435  
436 static yyconst flex_int16_t yy_chk[70] =
437 { 0,
438 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
439 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
440 1, 1, 5, 5, 6, 6, 17, 17, 34, 34,
441 35, 30, 29, 28, 25, 24, 22, 21, 18, 16,
442 15, 14, 13, 12, 7, 3, 33, 33, 33, 33,
443 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
444 33, 33, 33, 33, 33, 33, 33, 33, 33
445 } ;
446  
447 /* The intent behind this definition is that it'll catch
448 * any uses of REJECT which flex missed.
449 */
450 #define REJECT reject_used_but_not_detected
451 #define yymore() yymore_used_but_not_detected
452 #define YY_MORE_ADJ 0
453 #define YY_RESTORE_YY_MORE_OFFSET
454 #line 1 "predicate/BPredicate.l"
455 /**
456 * @file BPredicate.l
457 * @author Ambroz Bizjak <ambrop7@gmail.com>
458 *
459 * @section LICENSE
460 *
461 * Redistribution and use in source and binary forms, with or without
462 * modification, are permitted provided that the following conditions are met:
463 * 1. Redistributions of source code must retain the above copyright
464 * notice, this list of conditions and the following disclaimer.
465 * 2. Redistributions in binary form must reproduce the above copyright
466 * notice, this list of conditions and the following disclaimer in the
467 * documentation and/or other materials provided with the distribution.
468 * 3. Neither the name of the author nor the
469 * names of its contributors may be used to endorse or promote products
470 * derived from this software without specific prior written permission.
471 *
472 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
473 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
474 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
475 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
476 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
477 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
478 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
479 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
480 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
481 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
482 *
483 * @section DESCRIPTION
484 *
485 * {@link BPredicate} lexer file.
486 */
487 #line 35 "predicate/BPredicate.l"
488  
489 #include <string.h>
490 #include <stdlib.h>
491  
492 #include <predicate/LexMemoryBufferInput.h>
493 #include <predicate/BPredicate_internal.h>
494  
495 #include <generated/bison_BPredicate.h>
496  
497 #define YY_INPUT(buffer, res, max_size) \
498 int bytes_read = LexMemoryBufferInput_Read((LexMemoryBufferInput *)yyget_extra(yyscanner), buffer, max_size); \
499 res = (bytes_read == 0 ? YY_NULL : bytes_read);
500  
501 #define YY_NO_UNISTD_H 1
502 #line 503 "generated//flex_BPredicate.c"
503  
504 #define INITIAL 0
505  
506 #ifndef YY_NO_UNISTD_H
507 /* Special case for "unistd.h", since it is non-ANSI. We include it way
508 * down here because we want the user's section 1 to have been scanned first.
509 * The user has a chance to override it with an option.
510 */
511 #include <unistd.h>
512 #endif
513  
514 #ifndef YY_EXTRA_TYPE
515 #define YY_EXTRA_TYPE void *
516 #endif
517  
518 /* Holds the entire state of the reentrant scanner. */
519 struct yyguts_t
520 {
521  
522 /* User-defined. Not touched by flex. */
523 YY_EXTRA_TYPE yyextra_r;
524  
525 /* The rest are the same as the globals declared in the non-reentrant scanner. */
526 FILE *yyin_r, *yyout_r;
527 size_t yy_buffer_stack_top; /**< index of top of stack. */
528 size_t yy_buffer_stack_max; /**< capacity of stack. */
529 YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
530 char yy_hold_char;
531 yy_size_t yy_n_chars;
532 yy_size_t yyleng_r;
533 char *yy_c_buf_p;
534 int yy_init;
535 int yy_start;
536 int yy_did_buffer_switch_on_eof;
537 int yy_start_stack_ptr;
538 int yy_start_stack_depth;
539 int *yy_start_stack;
540 yy_state_type yy_last_accepting_state;
541 char* yy_last_accepting_cpos;
542  
543 int yylineno_r;
544 int yy_flex_debug_r;
545  
546 char *yytext_r;
547 int yy_more_flag;
548 int yy_more_len;
549  
550 YYSTYPE * yylval_r;
551  
552 YYLTYPE * yylloc_r;
553  
554 }; /* end struct yyguts_t */
555  
556 static int yy_init_globals (yyscan_t yyscanner );
557  
558 /* This must go here because YYSTYPE and YYLTYPE are included
559 * from bison output in section 1.*/
560 # define yylval yyg->yylval_r
561  
562 # define yylloc yyg->yylloc_r
563  
564 int yylex_init (yyscan_t* scanner);
565  
566 int yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
567  
568 /* Accessor methods to globals.
569 These are made visible to non-reentrant scanners for convenience. */
570  
571 int yylex_destroy (yyscan_t yyscanner );
572  
573 int yyget_debug (yyscan_t yyscanner );
574  
575 void yyset_debug (int debug_flag ,yyscan_t yyscanner );
576  
577 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
578  
579 void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
580  
581 FILE *yyget_in (yyscan_t yyscanner );
582  
583 void yyset_in (FILE * in_str ,yyscan_t yyscanner );
584  
585 FILE *yyget_out (yyscan_t yyscanner );
586  
587 void yyset_out (FILE * out_str ,yyscan_t yyscanner );
588  
589 yy_size_t yyget_leng (yyscan_t yyscanner );
590  
591 char *yyget_text (yyscan_t yyscanner );
592  
593 int yyget_lineno (yyscan_t yyscanner );
594  
595 void yyset_lineno (int line_number ,yyscan_t yyscanner );
596  
597 int yyget_column (yyscan_t yyscanner );
598  
599 void yyset_column (int column_no ,yyscan_t yyscanner );
600  
601 YYSTYPE * yyget_lval (yyscan_t yyscanner );
602  
603 void yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
604  
605 YYLTYPE *yyget_lloc (yyscan_t yyscanner );
606  
607 void yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
608  
609 /* Macros after this point can all be overridden by user definitions in
610 * section 1.
611 */
612  
613 #ifndef YY_SKIP_YYWRAP
614 #ifdef __cplusplus
615 extern "C" int yywrap (yyscan_t yyscanner );
616 #else
617 extern int yywrap (yyscan_t yyscanner );
618 #endif
619 #endif
620  
621 static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);
622  
623 #ifndef yytext_ptr
624 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
625 #endif
626  
627 #ifdef YY_NEED_STRLEN
628 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
629 #endif
630  
631 #ifndef YY_NO_INPUT
632  
633 #ifdef __cplusplus
634 static int yyinput (yyscan_t yyscanner );
635 #else
636 static int input (yyscan_t yyscanner );
637 #endif
638  
639 #endif
640  
641 static void yy_push_state (int new_state ,yyscan_t yyscanner);
642  
643 static void yy_pop_state (yyscan_t yyscanner );
644  
645 static int yy_top_state (yyscan_t yyscanner );
646  
647 /* Amount of stuff to slurp up with each read. */
648 #ifndef YY_READ_BUF_SIZE
649 #define YY_READ_BUF_SIZE 8192
650 #endif
651  
652 /* Copy whatever the last rule matched to the standard output. */
653 #ifndef ECHO
654 /* This used to be an fputs(), but since the string might contain NUL's,
655 * we now use fwrite().
656 */
657 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
658 #endif
659  
660 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
661 * is returned in "result".
662 */
663 #ifndef YY_INPUT
664 #define YY_INPUT(buf,result,max_size) \
665 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
666 { \
667 int c = '*'; \
668 size_t n; \
669 for ( n = 0; n < max_size && \
670 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
671 buf[n] = (char) c; \
672 if ( c == '\n' ) \
673 buf[n++] = (char) c; \
674 if ( c == EOF && ferror( yyin ) ) \
675 YY_FATAL_ERROR( "input in flex scanner failed" ); \
676 result = n; \
677 } \
678 else \
679 { \
680 errno=0; \
681 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
682 { \
683 if( errno != EINTR) \
684 { \
685 YY_FATAL_ERROR( "input in flex scanner failed" ); \
686 break; \
687 } \
688 errno=0; \
689 clearerr(yyin); \
690 } \
691 }\
692 \
693  
694 #endif
695  
696 /* No semi-colon after return; correct usage is to write "yyterminate();" -
697 * we don't want an extra ';' after the "return" because that will cause
698 * some compilers to complain about unreachable statements.
699 */
700 #ifndef yyterminate
701 #define yyterminate() return YY_NULL
702 #endif
703  
704 /* Number of entries by which start-condition stack grows. */
705 #ifndef YY_START_STACK_INCR
706 #define YY_START_STACK_INCR 25
707 #endif
708  
709 /* Report a fatal error. */
710 #ifndef YY_FATAL_ERROR
711 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
712 #endif
713  
714 /* end tables serialization structures and prototypes */
715  
716 /* Default declaration of generated scanner - a define so the user can
717 * easily add parameters.
718 */
719 #ifndef YY_DECL
720 #define YY_DECL_IS_OURS 1
721  
722 extern int yylex \
723 (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
724  
725 #define YY_DECL int yylex \
726 (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
727 #endif /* !YY_DECL */
728  
729 /* Code executed at the beginning of each rule, after yytext and yyleng
730 * have been set up.
731 */
732 #ifndef YY_USER_ACTION
733 #define YY_USER_ACTION
734 #endif
735  
736 /* Code executed at the end of each rule. */
737 #ifndef YY_BREAK
738 #define YY_BREAK break;
739 #endif
740  
741 #define YY_RULE_SETUP \
742 YY_USER_ACTION
743  
744 /** The main scanner function which does all the work.
745 */
746 YY_DECL
747 {
748 register yy_state_type yy_current_state;
749 register char *yy_cp, *yy_bp;
750 register int yy_act;
751 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
752  
753 #line 52 "predicate/BPredicate.l"
754  
755 #line 756 "generated//flex_BPredicate.c"
756  
757 yylval = yylval_param;
758  
759 yylloc = yylloc_param;
760  
761 if ( !yyg->yy_init )
762 {
763 yyg->yy_init = 1;
764  
765 #ifdef YY_USER_INIT
766 YY_USER_INIT;
767 #endif
768  
769 if ( ! yyg->yy_start )
770 yyg->yy_start = 1; /* first start state */
771  
772 if ( ! yyin )
773 yyin = stdin;
774  
775 if ( ! yyout )
776 yyout = stdout;
777  
778 if ( ! YY_CURRENT_BUFFER ) {
779 yyensure_buffer_stack (yyscanner);
780 YY_CURRENT_BUFFER_LVALUE =
781 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
782 }
783  
784 yy_load_buffer_state(yyscanner );
785 }
786  
787 while ( 1 ) /* loops until end-of-file is reached */
788 {
789 yy_cp = yyg->yy_c_buf_p;
790  
791 /* Support of yytext. */
792 *yy_cp = yyg->yy_hold_char;
793  
794 /* yy_bp points to the position in yy_ch_buf of the start of
795 * the current run.
796 */
797 yy_bp = yy_cp;
798  
799 yy_current_state = yyg->yy_start;
800 yy_match:
801 do
802 {
803 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
804 if ( yy_accept[yy_current_state] )
805 {
806 yyg->yy_last_accepting_state = yy_current_state;
807 yyg->yy_last_accepting_cpos = yy_cp;
808 }
809 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
810 {
811 yy_current_state = (int) yy_def[yy_current_state];
812 if ( yy_current_state >= 34 )
813 yy_c = yy_meta[(unsigned int) yy_c];
814 }
815 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
816 ++yy_cp;
817 }
818 while ( yy_current_state != 33 );
819 yy_cp = yyg->yy_last_accepting_cpos;
820 yy_current_state = yyg->yy_last_accepting_state;
821  
822 yy_find_action:
823 yy_act = yy_accept[yy_current_state];
824  
825 YY_DO_BEFORE_ACTION;
826  
827 do_action: /* This label is used only to access EOF actions. */
828  
829 switch ( yy_act )
830 { /* beginning of action switch */
831 case 0: /* must back up */
832 /* undo the effects of YY_DO_BEFORE_ACTION */
833 *yy_cp = yyg->yy_hold_char;
834 yy_cp = yyg->yy_last_accepting_cpos;
835 yy_current_state = yyg->yy_last_accepting_state;
836 goto yy_find_action;
837  
838 case 1:
839 YY_RULE_SETUP
840 #line 53 "predicate/BPredicate.l"
841 return SPAR;
842 YY_BREAK
843 case 2:
844 YY_RULE_SETUP
845 #line 54 "predicate/BPredicate.l"
846 return EPAR;
847 YY_BREAK
848 case 3:
849 YY_RULE_SETUP
850 #line 55 "predicate/BPredicate.l"
851 return COMMA;
852 YY_BREAK
853 case 4:
854 YY_RULE_SETUP
855 #line 56 "predicate/BPredicate.l"
856 return AND;
857 YY_BREAK
858 case 5:
859 YY_RULE_SETUP
860 #line 57 "predicate/BPredicate.l"
861 return OR;
862 YY_BREAK
863 case 6:
864 YY_RULE_SETUP
865 #line 58 "predicate/BPredicate.l"
866 return NOT;
867 YY_BREAK
868 case 7:
869 YY_RULE_SETUP
870 #line 59 "predicate/BPredicate.l"
871 return CONSTANT_TRUE;
872 YY_BREAK
873 case 8:
874 YY_RULE_SETUP
875 #line 60 "predicate/BPredicate.l"
876 return CONSTANT_FALSE;
877 YY_BREAK
878 case 9:
879 YY_RULE_SETUP
880 #line 61 "predicate/BPredicate.l"
881 {
882 int l = strlen(yytext);
883 char *p = (char *)malloc(l + 1);
884 if (p) {
885 memcpy(p, yytext, l);
886 p[l] = '\0';
887 }
888 yylval->text = p;
889 return NAME;
890 }
891 YY_BREAK
892 case 10:
893 /* rule 10 can match eol */
894 YY_RULE_SETUP
895 #line 71 "predicate/BPredicate.l"
896 {
897 int l = strlen(yytext);
898 char *p = (char *)malloc(l - 1);
899 if (p) {
900 memcpy(p, yytext + 1, l - 2);
901 p[l - 2] = '\0';
902 }
903 yylval->text = p;
904 return STRING;
905 }
906 YY_BREAK
907 case 11:
908 /* rule 11 can match eol */
909 YY_RULE_SETUP
910 #line 81 "predicate/BPredicate.l"
911 ;
912 YY_BREAK
913 case 12:
914 YY_RULE_SETUP
915 #line 82 "predicate/BPredicate.l"
916 LexMemoryBufferInput_SetError((LexMemoryBufferInput *)yyget_extra(yyscanner)); return 0; // remember failure and report EOF
917 YY_BREAK
918 case 13:
919 YY_RULE_SETUP
920 #line 83 "predicate/BPredicate.l"
921 ECHO;
922 YY_BREAK
923 #line 924 "generated//flex_BPredicate.c"
924 case YY_STATE_EOF(INITIAL):
925 yyterminate();
926  
927 case YY_END_OF_BUFFER:
928 {
929 /* Amount of text matched not including the EOB char. */
930 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
931  
932 /* Undo the effects of YY_DO_BEFORE_ACTION. */
933 *yy_cp = yyg->yy_hold_char;
934 YY_RESTORE_YY_MORE_OFFSET
935  
936 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
937 {
938 /* We're scanning a new file or input source. It's
939 * possible that this happened because the user
940 * just pointed yyin at a new source and called
941 * yylex(). If so, then we have to assure
942 * consistency between YY_CURRENT_BUFFER and our
943 * globals. Here is the right place to do so, because
944 * this is the first action (other than possibly a
945 * back-up) that will match for the new input source.
946 */
947 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
948 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
949 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
950 }
951  
952 /* Note that here we test for yy_c_buf_p "<=" to the position
953 * of the first EOB in the buffer, since yy_c_buf_p will
954 * already have been incremented past the NUL character
955 * (since all states make transitions on EOB to the
956 * end-of-buffer state). Contrast this with the test
957 * in input().
958 */
959 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
960 { /* This was really a NUL. */
961 yy_state_type yy_next_state;
962  
963 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
964  
965 yy_current_state = yy_get_previous_state( yyscanner );
966  
967 /* Okay, we're now positioned to make the NUL
968 * transition. We couldn't have
969 * yy_get_previous_state() go ahead and do it
970 * for us because it doesn't know how to deal
971 * with the possibility of jamming (and we don't
972 * want to build jamming into it because then it
973 * will run more slowly).
974 */
975  
976 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
977  
978 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
979  
980 if ( yy_next_state )
981 {
982 /* Consume the NUL. */
983 yy_cp = ++yyg->yy_c_buf_p;
984 yy_current_state = yy_next_state;
985 goto yy_match;
986 }
987  
988 else
989 {
990 yy_cp = yyg->yy_last_accepting_cpos;
991 yy_current_state = yyg->yy_last_accepting_state;
992 goto yy_find_action;
993 }
994 }
995  
996 else switch ( yy_get_next_buffer( yyscanner ) )
997 {
998 case EOB_ACT_END_OF_FILE:
999 {
1000 yyg->yy_did_buffer_switch_on_eof = 0;
1001  
1002 if ( yywrap(yyscanner ) )
1003 {
1004 /* Note: because we've taken care in
1005 * yy_get_next_buffer() to have set up
1006 * yytext, we can now set up
1007 * yy_c_buf_p so that if some total
1008 * hoser (like flex itself) wants to
1009 * call the scanner after we return the
1010 * YY_NULL, it'll still work - another
1011 * YY_NULL will get returned.
1012 */
1013 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1014  
1015 yy_act = YY_STATE_EOF(YY_START);
1016 goto do_action;
1017 }
1018  
1019 else
1020 {
1021 if ( ! yyg->yy_did_buffer_switch_on_eof )
1022 YY_NEW_FILE;
1023 }
1024 break;
1025 }
1026  
1027 case EOB_ACT_CONTINUE_SCAN:
1028 yyg->yy_c_buf_p =
1029 yyg->yytext_ptr + yy_amount_of_matched_text;
1030  
1031 yy_current_state = yy_get_previous_state( yyscanner );
1032  
1033 yy_cp = yyg->yy_c_buf_p;
1034 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1035 goto yy_match;
1036  
1037 case EOB_ACT_LAST_MATCH:
1038 yyg->yy_c_buf_p =
1039 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1040  
1041 yy_current_state = yy_get_previous_state( yyscanner );
1042  
1043 yy_cp = yyg->yy_c_buf_p;
1044 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1045 goto yy_find_action;
1046 }
1047 break;
1048 }
1049  
1050 default:
1051 YY_FATAL_ERROR(
1052 "fatal flex scanner internal error--no action found" );
1053 } /* end of action switch */
1054 } /* end of scanning one token */
1055 } /* end of yylex */
1056  
1057 /* yy_get_next_buffer - try to read in a new buffer
1058 *
1059 * Returns a code representing an action:
1060 * EOB_ACT_LAST_MATCH -
1061 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1062 * EOB_ACT_END_OF_FILE - end of file
1063 */
1064 static int yy_get_next_buffer (yyscan_t yyscanner)
1065 {
1066 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1067 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1068 register char *source = yyg->yytext_ptr;
1069 register int number_to_move, i;
1070 int ret_val;
1071  
1072 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1073 YY_FATAL_ERROR(
1074 "fatal flex scanner internal error--end of buffer missed" );
1075  
1076 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1077 { /* Don't try to fill the buffer, so this is an EOF. */
1078 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1079 {
1080 /* We matched a single character, the EOB, so
1081 * treat this as a final EOF.
1082 */
1083 return EOB_ACT_END_OF_FILE;
1084 }
1085  
1086 else
1087 {
1088 /* We matched some text prior to the EOB, first
1089 * process it.
1090 */
1091 return EOB_ACT_LAST_MATCH;
1092 }
1093 }
1094  
1095 /* Try to read more data. */
1096  
1097 /* First move last chars to start of buffer. */
1098 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1099  
1100 for ( i = 0; i < number_to_move; ++i )
1101 *(dest++) = *(source++);
1102  
1103 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1104 /* don't do the read, it's not guaranteed to return an EOF,
1105 * just force an EOF
1106 */
1107 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1108  
1109 else
1110 {
1111 yy_size_t num_to_read =
1112 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1113  
1114 while ( num_to_read <= 0 )
1115 { /* Not enough room in the buffer - grow it. */
1116  
1117 /* just a shorter name for the current buffer */
1118 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1119  
1120 int yy_c_buf_p_offset =
1121 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1122  
1123 if ( b->yy_is_our_buffer )
1124 {
1125 yy_size_t new_size = b->yy_buf_size * 2;
1126  
1127 if ( new_size <= 0 )
1128 b->yy_buf_size += b->yy_buf_size / 8;
1129 else
1130 b->yy_buf_size *= 2;
1131  
1132 b->yy_ch_buf = (char *)
1133 /* Include room in for 2 EOB chars. */
1134 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1135 }
1136 else
1137 /* Can't grow it, we don't own it. */
1138 b->yy_ch_buf = 0;
1139  
1140 if ( ! b->yy_ch_buf )
1141 YY_FATAL_ERROR(
1142 "fatal error - scanner input buffer overflow" );
1143  
1144 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1145  
1146 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1147 number_to_move - 1;
1148  
1149 }
1150  
1151 if ( num_to_read > YY_READ_BUF_SIZE )
1152 num_to_read = YY_READ_BUF_SIZE;
1153  
1154 /* Read in more data. */
1155 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1156 yyg->yy_n_chars, num_to_read );
1157  
1158 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1159 }
1160  
1161 if ( yyg->yy_n_chars == 0 )
1162 {
1163 if ( number_to_move == YY_MORE_ADJ )
1164 {
1165 ret_val = EOB_ACT_END_OF_FILE;
1166 yyrestart(yyin ,yyscanner);
1167 }
1168  
1169 else
1170 {
1171 ret_val = EOB_ACT_LAST_MATCH;
1172 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1173 YY_BUFFER_EOF_PENDING;
1174 }
1175 }
1176  
1177 else
1178 ret_val = EOB_ACT_CONTINUE_SCAN;
1179  
1180 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1181 /* Extend the array by 50%, plus the number we really need. */
1182 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1183 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1184 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1185 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1186 }
1187  
1188 yyg->yy_n_chars += number_to_move;
1189 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1190 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1191  
1192 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1193  
1194 return ret_val;
1195 }
1196  
1197 /* yy_get_previous_state - get the state just before the EOB char was reached */
1198  
1199 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1200 {
1201 register yy_state_type yy_current_state;
1202 register char *yy_cp;
1203 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1204  
1205 yy_current_state = yyg->yy_start;
1206  
1207 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1208 {
1209 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1210 if ( yy_accept[yy_current_state] )
1211 {
1212 yyg->yy_last_accepting_state = yy_current_state;
1213 yyg->yy_last_accepting_cpos = yy_cp;
1214 }
1215 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1216 {
1217 yy_current_state = (int) yy_def[yy_current_state];
1218 if ( yy_current_state >= 34 )
1219 yy_c = yy_meta[(unsigned int) yy_c];
1220 }
1221 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1222 }
1223  
1224 return yy_current_state;
1225 }
1226  
1227 /* yy_try_NUL_trans - try to make a transition on the NUL character
1228 *
1229 * synopsis
1230 * next_state = yy_try_NUL_trans( current_state );
1231 */
1232 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1233 {
1234 register int yy_is_jam;
1235 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
1236 register char *yy_cp = yyg->yy_c_buf_p;
1237  
1238 register YY_CHAR yy_c = 1;
1239 if ( yy_accept[yy_current_state] )
1240 {
1241 yyg->yy_last_accepting_state = yy_current_state;
1242 yyg->yy_last_accepting_cpos = yy_cp;
1243 }
1244 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1245 {
1246 yy_current_state = (int) yy_def[yy_current_state];
1247 if ( yy_current_state >= 34 )
1248 yy_c = yy_meta[(unsigned int) yy_c];
1249 }
1250 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1251 yy_is_jam = (yy_current_state == 33);
1252  
1253 (void)yyg;
1254 return yy_is_jam ? 0 : yy_current_state;
1255 }
1256  
1257 static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
1258 {
1259 register char *yy_cp;
1260 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1261  
1262 yy_cp = yyg->yy_c_buf_p;
1263  
1264 /* undo effects of setting up yytext */
1265 *yy_cp = yyg->yy_hold_char;
1266  
1267 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1268 { /* need to shift things up to make room */
1269 /* +2 for EOB chars. */
1270 register yy_size_t number_to_move = yyg->yy_n_chars + 2;
1271 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1272 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1273 register char *source =
1274 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1275  
1276 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1277 *--dest = *--source;
1278  
1279 yy_cp += (int) (dest - source);
1280 yy_bp += (int) (dest - source);
1281 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1282 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1283  
1284 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1285 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1286 }
1287  
1288 *--yy_cp = (char) c;
1289  
1290 yyg->yytext_ptr = yy_bp;
1291 yyg->yy_hold_char = *yy_cp;
1292 yyg->yy_c_buf_p = yy_cp;
1293 }
1294  
1295 #ifndef YY_NO_INPUT
1296 #ifdef __cplusplus
1297 static int yyinput (yyscan_t yyscanner)
1298 #else
1299 static int input (yyscan_t yyscanner)
1300 #endif
1301  
1302 {
1303 int c;
1304 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1305  
1306 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1307  
1308 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1309 {
1310 /* yy_c_buf_p now points to the character we want to return.
1311 * If this occurs *before* the EOB characters, then it's a
1312 * valid NUL; if not, then we've hit the end of the buffer.
1313 */
1314 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1315 /* This was really a NUL. */
1316 *yyg->yy_c_buf_p = '\0';
1317  
1318 else
1319 { /* need more input */
1320 yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1321 ++yyg->yy_c_buf_p;
1322  
1323 switch ( yy_get_next_buffer( yyscanner ) )
1324 {
1325 case EOB_ACT_LAST_MATCH:
1326 /* This happens because yy_g_n_b()
1327 * sees that we've accumulated a
1328 * token and flags that we need to
1329 * try matching the token before
1330 * proceeding. But for input(),
1331 * there's no matching to consider.
1332 * So convert the EOB_ACT_LAST_MATCH
1333 * to EOB_ACT_END_OF_FILE.
1334 */
1335  
1336 /* Reset buffer status. */
1337 yyrestart(yyin ,yyscanner);
1338  
1339 /*FALLTHROUGH*/
1340  
1341 case EOB_ACT_END_OF_FILE:
1342 {
1343 if ( yywrap(yyscanner ) )
1344 return EOF;
1345  
1346 if ( ! yyg->yy_did_buffer_switch_on_eof )
1347 YY_NEW_FILE;
1348 #ifdef __cplusplus
1349 return yyinput(yyscanner);
1350 #else
1351 return input(yyscanner);
1352 #endif
1353 }
1354  
1355 case EOB_ACT_CONTINUE_SCAN:
1356 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1357 break;
1358 }
1359 }
1360 }
1361  
1362 c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
1363 *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
1364 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1365  
1366 return c;
1367 }
1368 #endif /* ifndef YY_NO_INPUT */
1369  
1370 /** Immediately switch to a different input stream.
1371 * @param input_file A readable stream.
1372 * @param yyscanner The scanner object.
1373 * @note This function does not reset the start condition to @c INITIAL .
1374 */
1375 void yyrestart (FILE * input_file , yyscan_t yyscanner)
1376 {
1377 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1378  
1379 if ( ! YY_CURRENT_BUFFER ){
1380 yyensure_buffer_stack (yyscanner);
1381 YY_CURRENT_BUFFER_LVALUE =
1382 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1383 }
1384  
1385 yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1386 yy_load_buffer_state(yyscanner );
1387 }
1388  
1389 /** Switch to a different input buffer.
1390 * @param new_buffer The new input buffer.
1391 * @param yyscanner The scanner object.
1392 */
1393 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1394 {
1395 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1396  
1397 /* TODO. We should be able to replace this entire function body
1398 * with
1399 * yypop_buffer_state();
1400 * yypush_buffer_state(new_buffer);
1401 */
1402 yyensure_buffer_stack (yyscanner);
1403 if ( YY_CURRENT_BUFFER == new_buffer )
1404 return;
1405  
1406 if ( YY_CURRENT_BUFFER )
1407 {
1408 /* Flush out information for old buffer. */
1409 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1410 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1411 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1412 }
1413  
1414 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1415 yy_load_buffer_state(yyscanner );
1416  
1417 /* We don't actually know whether we did this switch during
1418 * EOF (yywrap()) processing, but the only time this flag
1419 * is looked at is after yywrap() is called, so it's safe
1420 * to go ahead and always set it.
1421 */
1422 yyg->yy_did_buffer_switch_on_eof = 1;
1423 }
1424  
1425 static void yy_load_buffer_state (yyscan_t yyscanner)
1426 {
1427 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1428 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1429 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1430 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1431 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1432 }
1433  
1434 /** Allocate and initialize an input buffer state.
1435 * @param file A readable stream.
1436 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1437 * @param yyscanner The scanner object.
1438 * @return the allocated buffer state.
1439 */
1440 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)
1441 {
1442 YY_BUFFER_STATE b;
1443  
1444 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1445 if ( ! b )
1446 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1447  
1448 b->yy_buf_size = size;
1449  
1450 /* yy_ch_buf has to be 2 characters longer than the size given because
1451 * we need to put in 2 end-of-buffer characters.
1452 */
1453 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ,yyscanner );
1454 if ( ! b->yy_ch_buf )
1455 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1456  
1457 b->yy_is_our_buffer = 1;
1458  
1459 yy_init_buffer(b,file ,yyscanner);
1460  
1461 return b;
1462 }
1463  
1464 /** Destroy the buffer.
1465 * @param b a buffer created with yy_create_buffer()
1466 * @param yyscanner The scanner object.
1467 */
1468 void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1469 {
1470 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1471  
1472 if ( ! b )
1473 return;
1474  
1475 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1476 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1477  
1478 if ( b->yy_is_our_buffer )
1479 yyfree((void *) b->yy_ch_buf ,yyscanner );
1480  
1481 yyfree((void *) b ,yyscanner );
1482 }
1483  
1484 /* Initializes or reinitializes a buffer.
1485 * This function is sometimes called more than once on the same buffer,
1486 * such as during a yyrestart() or at EOF.
1487 */
1488 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1489  
1490 {
1491 int oerrno = errno;
1492 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1493  
1494 yy_flush_buffer(b ,yyscanner);
1495  
1496 b->yy_input_file = file;
1497 b->yy_fill_buffer = 1;
1498  
1499 /* If b is the current buffer, then yy_init_buffer was _probably_
1500 * called from yyrestart() or through yy_get_next_buffer.
1501 * In that case, we don't want to reset the lineno or column.
1502 */
1503 if (b != YY_CURRENT_BUFFER){
1504 b->yy_bs_lineno = 1;
1505 b->yy_bs_column = 0;
1506 }
1507  
1508 b->yy_is_interactive = 0;
1509  
1510 errno = oerrno;
1511 }
1512  
1513 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1514 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1515 * @param yyscanner The scanner object.
1516 */
1517 void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1518 {
1519 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1520 if ( ! b )
1521 return;
1522  
1523 b->yy_n_chars = 0;
1524  
1525 /* We always need two end-of-buffer characters. The first causes
1526 * a transition to the end-of-buffer state. The second causes
1527 * a jam in that state.
1528 */
1529 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1530 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1531  
1532 b->yy_buf_pos = &b->yy_ch_buf[0];
1533  
1534 b->yy_at_bol = 1;
1535 b->yy_buffer_status = YY_BUFFER_NEW;
1536  
1537 if ( b == YY_CURRENT_BUFFER )
1538 yy_load_buffer_state(yyscanner );
1539 }
1540  
1541 /** Pushes the new state onto the stack. The new state becomes
1542 * the current state. This function will allocate the stack
1543 * if necessary.
1544 * @param new_buffer The new state.
1545 * @param yyscanner The scanner object.
1546 */
1547 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1548 {
1549 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1550 if (new_buffer == NULL)
1551 return;
1552  
1553 yyensure_buffer_stack(yyscanner);
1554  
1555 /* This block is copied from yy_switch_to_buffer. */
1556 if ( YY_CURRENT_BUFFER )
1557 {
1558 /* Flush out information for old buffer. */
1559 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1560 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1561 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1562 }
1563  
1564 /* Only push if top exists. Otherwise, replace top. */
1565 if (YY_CURRENT_BUFFER)
1566 yyg->yy_buffer_stack_top++;
1567 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1568  
1569 /* copied from yy_switch_to_buffer. */
1570 yy_load_buffer_state(yyscanner );
1571 yyg->yy_did_buffer_switch_on_eof = 1;
1572 }
1573  
1574 /** Removes and deletes the top of the stack, if present.
1575 * The next element becomes the new top.
1576 * @param yyscanner The scanner object.
1577 */
1578 void yypop_buffer_state (yyscan_t yyscanner)
1579 {
1580 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1581 if (!YY_CURRENT_BUFFER)
1582 return;
1583  
1584 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1585 YY_CURRENT_BUFFER_LVALUE = NULL;
1586 if (yyg->yy_buffer_stack_top > 0)
1587 --yyg->yy_buffer_stack_top;
1588  
1589 if (YY_CURRENT_BUFFER) {
1590 yy_load_buffer_state(yyscanner );
1591 yyg->yy_did_buffer_switch_on_eof = 1;
1592 }
1593 }
1594  
1595 /* Allocates the stack if it does not exist.
1596 * Guarantees space for at least one push.
1597 */
1598 static void yyensure_buffer_stack (yyscan_t yyscanner)
1599 {
1600 yy_size_t num_to_alloc;
1601 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1602  
1603 if (!yyg->yy_buffer_stack) {
1604  
1605 /* First allocation is just for 2 elements, since we don't know if this
1606 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1607 * immediate realloc on the next call.
1608 */
1609 num_to_alloc = 1;
1610 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc
1611 (num_to_alloc * sizeof(struct yy_buffer_state*)
1612 , yyscanner);
1613 if ( ! yyg->yy_buffer_stack )
1614 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1615  
1616 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1617  
1618 yyg->yy_buffer_stack_max = num_to_alloc;
1619 yyg->yy_buffer_stack_top = 0;
1620 return;
1621 }
1622  
1623 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
1624  
1625 /* Increase the buffer to prepare for a possible push. */
1626 int grow_size = 8 /* arbitrary grow size */;
1627  
1628 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1629 yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc
1630 (yyg->yy_buffer_stack,
1631 num_to_alloc * sizeof(struct yy_buffer_state*)
1632 , yyscanner);
1633 if ( ! yyg->yy_buffer_stack )
1634 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1635  
1636 /* zero only the new slots.*/
1637 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1638 yyg->yy_buffer_stack_max = num_to_alloc;
1639 }
1640 }
1641  
1642 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1643 * @param base the character buffer
1644 * @param size the size in bytes of the character buffer
1645 * @param yyscanner The scanner object.
1646 * @return the newly allocated buffer state object.
1647 */
1648 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
1649 {
1650 YY_BUFFER_STATE b;
1651  
1652 if ( size < 2 ||
1653 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1654 base[size-1] != YY_END_OF_BUFFER_CHAR )
1655 /* They forgot to leave room for the EOB's. */
1656 return 0;
1657  
1658 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1659 if ( ! b )
1660 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1661  
1662 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1663 b->yy_buf_pos = b->yy_ch_buf = base;
1664 b->yy_is_our_buffer = 0;
1665 b->yy_input_file = 0;
1666 b->yy_n_chars = b->yy_buf_size;
1667 b->yy_is_interactive = 0;
1668 b->yy_at_bol = 1;
1669 b->yy_fill_buffer = 0;
1670 b->yy_buffer_status = YY_BUFFER_NEW;
1671  
1672 yy_switch_to_buffer(b ,yyscanner );
1673  
1674 return b;
1675 }
1676  
1677 /** Setup the input buffer state to scan a string. The next call to yylex() will
1678 * scan from a @e copy of @a str.
1679 * @param yystr a NUL-terminated string to scan
1680 * @param yyscanner The scanner object.
1681 * @return the newly allocated buffer state object.
1682 * @note If you want to scan bytes that may contain NUL values, then use
1683 * yy_scan_bytes() instead.
1684 */
1685 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
1686 {
1687  
1688 return yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
1689 }
1690  
1691 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1692 * scan from a @e copy of @a bytes.
1693 * @param yybytes the byte buffer to scan
1694 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1695 * @param yyscanner The scanner object.
1696 * @return the newly allocated buffer state object.
1697 */
1698 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner)
1699 {
1700 YY_BUFFER_STATE b;
1701 char *buf;
1702 yy_size_t n;
1703 int i;
1704  
1705 /* Get memory for full buffer, including space for trailing EOB's. */
1706 n = _yybytes_len + 2;
1707 buf = (char *) yyalloc(n ,yyscanner );
1708 if ( ! buf )
1709 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1710  
1711 for ( i = 0; i < _yybytes_len; ++i )
1712 buf[i] = yybytes[i];
1713  
1714 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1715  
1716 b = yy_scan_buffer(buf,n ,yyscanner);
1717 if ( ! b )
1718 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1719  
1720 /* It's okay to grow etc. this buffer, and we should throw it
1721 * away when we're done.
1722 */
1723 b->yy_is_our_buffer = 1;
1724  
1725 return b;
1726 }
1727  
1728 static void yy_push_state (int new_state , yyscan_t yyscanner)
1729 {
1730 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1731 if ( yyg->yy_start_stack_ptr >= yyg->yy_start_stack_depth )
1732 {
1733 yy_size_t new_size;
1734  
1735 yyg->yy_start_stack_depth += YY_START_STACK_INCR;
1736 new_size = yyg->yy_start_stack_depth * sizeof( int );
1737  
1738 if ( ! yyg->yy_start_stack )
1739 yyg->yy_start_stack = (int *) yyalloc(new_size ,yyscanner );
1740  
1741 else
1742 yyg->yy_start_stack = (int *) yyrealloc((void *) yyg->yy_start_stack,new_size ,yyscanner );
1743  
1744 if ( ! yyg->yy_start_stack )
1745 YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
1746 }
1747  
1748 yyg->yy_start_stack[yyg->yy_start_stack_ptr++] = YY_START;
1749  
1750 BEGIN(new_state);
1751 }
1752  
1753 static void yy_pop_state (yyscan_t yyscanner)
1754 {
1755 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1756 if ( --yyg->yy_start_stack_ptr < 0 )
1757 YY_FATAL_ERROR( "start-condition stack underflow" );
1758  
1759 BEGIN(yyg->yy_start_stack[yyg->yy_start_stack_ptr]);
1760 }
1761  
1762 static int yy_top_state (yyscan_t yyscanner)
1763 {
1764 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1765 return yyg->yy_start_stack[yyg->yy_start_stack_ptr - 1];
1766 }
1767  
1768 #ifndef YY_EXIT_FAILURE
1769 #define YY_EXIT_FAILURE 2
1770 #endif
1771  
1772 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
1773 {
1774 (void) fprintf( stderr, "%s\n", msg );
1775 exit( YY_EXIT_FAILURE );
1776 }
1777  
1778 /* Redefine yyless() so it works in section 3 code. */
1779  
1780 #undef yyless
1781 #define yyless(n) \
1782 do \
1783 { \
1784 /* Undo effects of setting up yytext. */ \
1785 int yyless_macro_arg = (n); \
1786 YY_LESS_LINENO(yyless_macro_arg);\
1787 yytext[yyleng] = yyg->yy_hold_char; \
1788 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1789 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1790 *yyg->yy_c_buf_p = '\0'; \
1791 yyleng = yyless_macro_arg; \
1792 } \
1793 while ( 0 )
1794  
1795 /* Accessor methods (get/set functions) to struct members. */
1796  
1797 /** Get the user-defined data for this scanner.
1798 * @param yyscanner The scanner object.
1799 */
1800 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
1801 {
1802 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1803 return yyextra;
1804 }
1805  
1806 /** Get the current line number.
1807 * @param yyscanner The scanner object.
1808 */
1809 int yyget_lineno (yyscan_t yyscanner)
1810 {
1811 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1812  
1813 if (! YY_CURRENT_BUFFER)
1814 return 0;
1815  
1816 return yylineno;
1817 }
1818  
1819 /** Get the current column number.
1820 * @param yyscanner The scanner object.
1821 */
1822 int yyget_column (yyscan_t yyscanner)
1823 {
1824 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1825  
1826 if (! YY_CURRENT_BUFFER)
1827 return 0;
1828  
1829 return yycolumn;
1830 }
1831  
1832 /** Get the input stream.
1833 * @param yyscanner The scanner object.
1834 */
1835 FILE *yyget_in (yyscan_t yyscanner)
1836 {
1837 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1838 return yyin;
1839 }
1840  
1841 /** Get the output stream.
1842 * @param yyscanner The scanner object.
1843 */
1844 FILE *yyget_out (yyscan_t yyscanner)
1845 {
1846 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1847 return yyout;
1848 }
1849  
1850 /** Get the length of the current token.
1851 * @param yyscanner The scanner object.
1852 */
1853 yy_size_t yyget_leng (yyscan_t yyscanner)
1854 {
1855 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1856 return yyleng;
1857 }
1858  
1859 /** Get the current token.
1860 * @param yyscanner The scanner object.
1861 */
1862  
1863 char *yyget_text (yyscan_t yyscanner)
1864 {
1865 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1866 return yytext;
1867 }
1868  
1869 /** Set the user-defined data. This data is never touched by the scanner.
1870 * @param user_defined The data to be associated with this scanner.
1871 * @param yyscanner The scanner object.
1872 */
1873 void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1874 {
1875 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1876 yyextra = user_defined ;
1877 }
1878  
1879 /** Set the current line number.
1880 * @param line_number
1881 * @param yyscanner The scanner object.
1882 */
1883 void yyset_lineno (int line_number , yyscan_t yyscanner)
1884 {
1885 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1886  
1887 /* lineno is only valid if an input buffer exists. */
1888 if (! YY_CURRENT_BUFFER )
1889 YY_FATAL_ERROR( "yyset_lineno called with no buffer" );
1890  
1891 yylineno = line_number;
1892 }
1893  
1894 /** Set the current column.
1895 * @param line_number
1896 * @param yyscanner The scanner object.
1897 */
1898 void yyset_column (int column_no , yyscan_t yyscanner)
1899 {
1900 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1901  
1902 /* column is only valid if an input buffer exists. */
1903 if (! YY_CURRENT_BUFFER )
1904 YY_FATAL_ERROR( "yyset_column called with no buffer" );
1905  
1906 yycolumn = column_no;
1907 }
1908  
1909 /** Set the input stream. This does not discard the current
1910 * input buffer.
1911 * @param in_str A readable stream.
1912 * @param yyscanner The scanner object.
1913 * @see yy_switch_to_buffer
1914 */
1915 void yyset_in (FILE * in_str , yyscan_t yyscanner)
1916 {
1917 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1918 yyin = in_str ;
1919 }
1920  
1921 void yyset_out (FILE * out_str , yyscan_t yyscanner)
1922 {
1923 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1924 yyout = out_str ;
1925 }
1926  
1927 int yyget_debug (yyscan_t yyscanner)
1928 {
1929 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1930 return yy_flex_debug;
1931 }
1932  
1933 void yyset_debug (int bdebug , yyscan_t yyscanner)
1934 {
1935 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1936 yy_flex_debug = bdebug ;
1937 }
1938  
1939 /* Accessor methods for yylval and yylloc */
1940  
1941 YYSTYPE * yyget_lval (yyscan_t yyscanner)
1942 {
1943 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1944 return yylval;
1945 }
1946  
1947 void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)
1948 {
1949 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1950 yylval = yylval_param;
1951 }
1952  
1953 YYLTYPE *yyget_lloc (yyscan_t yyscanner)
1954 {
1955 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1956 return yylloc;
1957 }
1958  
1959 void yyset_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner)
1960 {
1961 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1962 yylloc = yylloc_param;
1963 }
1964  
1965 /* User-visible API */
1966  
1967 /* yylex_init is special because it creates the scanner itself, so it is
1968 * the ONLY reentrant function that doesn't take the scanner as the last argument.
1969 * That's why we explicitly handle the declaration, instead of using our macros.
1970 */
1971  
1972 int yylex_init(yyscan_t* ptr_yy_globals)
1973  
1974 {
1975 if (ptr_yy_globals == NULL){
1976 errno = EINVAL;
1977 return 1;
1978 }
1979  
1980 *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
1981  
1982 if (*ptr_yy_globals == NULL){
1983 errno = ENOMEM;
1984 return 1;
1985 }
1986  
1987 /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
1988 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
1989  
1990 return yy_init_globals ( *ptr_yy_globals );
1991 }
1992  
1993 /* yylex_init_extra has the same functionality as yylex_init, but follows the
1994 * convention of taking the scanner as the last argument. Note however, that
1995 * this is a *pointer* to a scanner, as it will be allocated by this call (and
1996 * is the reason, too, why this function also must handle its own declaration).
1997 * The user defined value in the first argument will be available to yyalloc in
1998 * the yyextra field.
1999 */
2000  
2001 int yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
2002  
2003 {
2004 struct yyguts_t dummy_yyguts;
2005  
2006 yyset_extra (yy_user_defined, &dummy_yyguts);
2007  
2008 if (ptr_yy_globals == NULL){
2009 errno = EINVAL;
2010 return 1;
2011 }
2012  
2013 *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
2014  
2015 if (*ptr_yy_globals == NULL){
2016 errno = ENOMEM;
2017 return 1;
2018 }
2019  
2020 /* By setting to 0xAA, we expose bugs in
2021 yy_init_globals. Leave at 0x00 for releases. */
2022 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2023  
2024 yyset_extra (yy_user_defined, *ptr_yy_globals);
2025  
2026 return yy_init_globals ( *ptr_yy_globals );
2027 }
2028  
2029 static int yy_init_globals (yyscan_t yyscanner)
2030 {
2031 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2032 /* Initialization is the same as for the non-reentrant scanner.
2033 * This function is called from yylex_destroy(), so don't allocate here.
2034 */
2035  
2036 yyg->yy_buffer_stack = 0;
2037 yyg->yy_buffer_stack_top = 0;
2038 yyg->yy_buffer_stack_max = 0;
2039 yyg->yy_c_buf_p = (char *) 0;
2040 yyg->yy_init = 0;
2041 yyg->yy_start = 0;
2042  
2043 yyg->yy_start_stack_ptr = 0;
2044 yyg->yy_start_stack_depth = 0;
2045 yyg->yy_start_stack = NULL;
2046  
2047 /* Defined in main.c */
2048 #ifdef YY_STDINIT
2049 yyin = stdin;
2050 yyout = stdout;
2051 #else
2052 yyin = (FILE *) 0;
2053 yyout = (FILE *) 0;
2054 #endif
2055  
2056 /* For future reference: Set errno on error, since we are called by
2057 * yylex_init()
2058 */
2059 return 0;
2060 }
2061  
2062 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2063 int yylex_destroy (yyscan_t yyscanner)
2064 {
2065 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2066  
2067 /* Pop the buffer stack, destroying each element. */
2068 while(YY_CURRENT_BUFFER){
2069 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2070 YY_CURRENT_BUFFER_LVALUE = NULL;
2071 yypop_buffer_state(yyscanner);
2072 }
2073  
2074 /* Destroy the stack itself. */
2075 yyfree(yyg->yy_buffer_stack ,yyscanner);
2076 yyg->yy_buffer_stack = NULL;
2077  
2078 /* Destroy the start condition stack. */
2079 yyfree(yyg->yy_start_stack ,yyscanner );
2080 yyg->yy_start_stack = NULL;
2081  
2082 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2083 * yylex() is called, initialization will occur. */
2084 yy_init_globals( yyscanner);
2085  
2086 /* Destroy the main struct (reentrant only). */
2087 yyfree ( yyscanner , yyscanner );
2088 yyscanner = NULL;
2089 return 0;
2090 }
2091  
2092 /*
2093 * Internal utility routines.
2094 */
2095  
2096 #ifndef yytext_ptr
2097 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2098 {
2099 register int i;
2100 for ( i = 0; i < n; ++i )
2101 s1[i] = s2[i];
2102 }
2103 #endif
2104  
2105 #ifdef YY_NEED_STRLEN
2106 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2107 {
2108 register int n;
2109 for ( n = 0; s[n]; ++n )
2110 ;
2111  
2112 return n;
2113 }
2114 #endif
2115  
2116 void *yyalloc (yy_size_t size , yyscan_t yyscanner)
2117 {
2118 return (void *) malloc( size );
2119 }
2120  
2121 void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
2122 {
2123 /* The cast to (char *) in the following accommodates both
2124 * implementations that use char* generic pointers, and those
2125 * that use void* generic pointers. It works with the latter
2126 * because both ANSI C and C++ allow castless assignment from
2127 * any pointer type to void*, and deal with argument conversions
2128 * as though doing an assignment.
2129 */
2130 return (void *) realloc( (char *) ptr, size );
2131 }
2132  
2133 void yyfree (void * ptr , yyscan_t yyscanner)
2134 {
2135 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2136 }
2137  
2138 #define YYTABLES_NAME "yytables"
2139  
2140 #line 83 "predicate/BPredicate.l"
2141  
2142  
2143