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