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