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