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