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