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