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