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