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