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