Merged revisions 97849 via svnmerge from
[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 /* yy_get_next_buffer - try to read in a new buffer
1305  *
1306  * Returns a code representing an action:
1307  *      EOB_ACT_LAST_MATCH -
1308  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1309  *      EOB_ACT_END_OF_FILE - end of file
1310  */
1311 static int yy_get_next_buffer (yyscan_t yyscanner)
1312 {
1313     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1314         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1315         register char *source = yyg->yytext_ptr;
1316         register int number_to_move, i;
1317         int ret_val;
1318
1319         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1320                 YY_FATAL_ERROR(
1321                 "fatal flex scanner internal error--end of buffer missed" );
1322
1323         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1324                 { /* Don't try to fill the buffer, so this is an EOF. */
1325                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1326                         {
1327                         /* We matched a single character, the EOB, so
1328                          * treat this as a final EOF.
1329                          */
1330                         return EOB_ACT_END_OF_FILE;
1331                         }
1332
1333                 else
1334                         {
1335                         /* We matched some text prior to the EOB, first
1336                          * process it.
1337                          */
1338                         return EOB_ACT_LAST_MATCH;
1339                         }
1340                 }
1341
1342         /* Try to read more data. */
1343
1344         /* First move last chars to start of buffer. */
1345         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1346
1347         for ( i = 0; i < number_to_move; ++i )
1348                 *(dest++) = *(source++);
1349
1350         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1351                 /* don't do the read, it's not guaranteed to return an EOF,
1352                  * just force an EOF
1353                  */
1354                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1355
1356         else
1357                 {
1358                         int num_to_read =
1359                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1360
1361                 while ( num_to_read <= 0 )
1362                         { /* Not enough room in the buffer - grow it. */
1363
1364                         /* just a shorter name for the current buffer */
1365                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1366
1367                         int yy_c_buf_p_offset =
1368                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1369
1370                         if ( b->yy_is_our_buffer )
1371                                 {
1372                                 int new_size = b->yy_buf_size * 2;
1373
1374                                 if ( new_size <= 0 )
1375                                         b->yy_buf_size += b->yy_buf_size / 8;
1376                                 else
1377                                         b->yy_buf_size *= 2;
1378
1379                                 b->yy_ch_buf = (char *)
1380                                         /* Include room in for 2 EOB chars. */
1381                                         ast_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1382                                 }
1383                         else
1384                                 /* Can't grow it, we don't own it. */
1385                                 b->yy_ch_buf = 0;
1386
1387                         if ( ! b->yy_ch_buf )
1388                                 YY_FATAL_ERROR(
1389                                 "fatal error - scanner input buffer overflow" );
1390
1391                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1392
1393                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1394                                                 number_to_move - 1;
1395
1396                         }
1397
1398                 if ( num_to_read > YY_READ_BUF_SIZE )
1399                         num_to_read = YY_READ_BUF_SIZE;
1400
1401                 /* Read in more data. */
1402                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1403                         yyg->yy_n_chars, num_to_read );
1404
1405                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1406                 }
1407
1408         if ( yyg->yy_n_chars == 0 )
1409                 {
1410                 if ( number_to_move == YY_MORE_ADJ )
1411                         {
1412                         ret_val = EOB_ACT_END_OF_FILE;
1413                         ast_yyrestart(yyin  ,yyscanner);
1414                         }
1415
1416                 else
1417                         {
1418                         ret_val = EOB_ACT_LAST_MATCH;
1419                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1420                                 YY_BUFFER_EOF_PENDING;
1421                         }
1422                 }
1423
1424         else
1425                 ret_val = EOB_ACT_CONTINUE_SCAN;
1426
1427         yyg->yy_n_chars += number_to_move;
1428         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1429         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1430
1431         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1432
1433         return ret_val;
1434 }
1435
1436 /* yy_get_previous_state - get the state just before the EOB char was reached */
1437
1438     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1439 {
1440         register yy_state_type yy_current_state;
1441         register char *yy_cp;
1442     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1443
1444         yy_current_state = yyg->yy_start;
1445
1446         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1447                 {
1448                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1449                 if ( yy_accept[yy_current_state] )
1450                         {
1451                         yyg->yy_last_accepting_state = yy_current_state;
1452                         yyg->yy_last_accepting_cpos = yy_cp;
1453                         }
1454                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1455                         {
1456                         yy_current_state = (int) yy_def[yy_current_state];
1457                         if ( yy_current_state >= 58 )
1458                                 yy_c = yy_meta[(unsigned int) yy_c];
1459                         }
1460                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1461                 }
1462
1463         return yy_current_state;
1464 }
1465
1466 /* yy_try_NUL_trans - try to make a transition on the NUL character
1467  *
1468  * synopsis
1469  *      next_state = yy_try_NUL_trans( current_state );
1470  */
1471     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
1472 {
1473         register int yy_is_jam;
1474     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
1475         register char *yy_cp = yyg->yy_c_buf_p;
1476
1477         register YY_CHAR yy_c = 1;
1478         if ( yy_accept[yy_current_state] )
1479                 {
1480                 yyg->yy_last_accepting_state = yy_current_state;
1481                 yyg->yy_last_accepting_cpos = yy_cp;
1482                 }
1483         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1484                 {
1485                 yy_current_state = (int) yy_def[yy_current_state];
1486                 if ( yy_current_state >= 58 )
1487                         yy_c = yy_meta[(unsigned int) yy_c];
1488                 }
1489         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1490         yy_is_jam = (yy_current_state == 57);
1491
1492         return yy_is_jam ? 0 : yy_current_state;
1493 }
1494
1495     static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
1496 {
1497         register char *yy_cp;
1498     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1499
1500     yy_cp = yyg->yy_c_buf_p;
1501
1502         /* undo effects of setting up yytext */
1503         *yy_cp = yyg->yy_hold_char;
1504
1505         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1506                 { /* need to shift things up to make room */
1507                 /* +2 for EOB chars. */
1508                 register int number_to_move = yyg->yy_n_chars + 2;
1509                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1510                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1511                 register char *source =
1512                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1513
1514                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1515                         *--dest = *--source;
1516
1517                 yy_cp += (int) (dest - source);
1518                 yy_bp += (int) (dest - source);
1519                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1520                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1521
1522                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1523                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1524                 }
1525
1526         *--yy_cp = (char) c;
1527
1528         yyg->yytext_ptr = yy_bp;
1529         yyg->yy_hold_char = *yy_cp;
1530         yyg->yy_c_buf_p = yy_cp;
1531 }
1532
1533 #ifndef YY_NO_INPUT
1534 #ifdef __cplusplus
1535     static int yyinput (yyscan_t yyscanner)
1536 #else
1537     static int input  (yyscan_t yyscanner)
1538 #endif
1539
1540 {
1541         int c;
1542     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1543
1544         *yyg->yy_c_buf_p = yyg->yy_hold_char;
1545
1546         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1547                 {
1548                 /* yy_c_buf_p now points to the character we want to return.
1549                  * If this occurs *before* the EOB characters, then it's a
1550                  * valid NUL; if not, then we've hit the end of the buffer.
1551                  */
1552                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1553                         /* This was really a NUL. */
1554                         *yyg->yy_c_buf_p = '\0';
1555
1556                 else
1557                         { /* need more input */
1558                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1559                         ++yyg->yy_c_buf_p;
1560
1561                         switch ( yy_get_next_buffer( yyscanner ) )
1562                                 {
1563                                 case EOB_ACT_LAST_MATCH:
1564                                         /* This happens because yy_g_n_b()
1565                                          * sees that we've accumulated a
1566                                          * token and flags that we need to
1567                                          * try matching the token before
1568                                          * proceeding.  But for input(),
1569                                          * there's no matching to consider.
1570                                          * So convert the EOB_ACT_LAST_MATCH
1571                                          * to EOB_ACT_END_OF_FILE.
1572                                          */
1573
1574                                         /* Reset buffer status. */
1575                                         ast_yyrestart(yyin ,yyscanner);
1576
1577                                         /*FALLTHROUGH*/
1578
1579                                 case EOB_ACT_END_OF_FILE:
1580                                         {
1581                                         if ( ast_yywrap(yyscanner ) )
1582                                                 return EOF;
1583
1584                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
1585                                                 YY_NEW_FILE;
1586 #ifdef __cplusplus
1587                                         return yyinput(yyscanner);
1588 #else
1589                                         return input(yyscanner);
1590 #endif
1591                                         }
1592
1593                                 case EOB_ACT_CONTINUE_SCAN:
1594                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1595                                         break;
1596                                 }
1597                         }
1598                 }
1599
1600         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
1601         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
1602         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1603
1604         return c;
1605 }
1606 #endif  /* ifndef YY_NO_INPUT */
1607
1608 /** Immediately switch to a different input stream.
1609  * @param input_file A readable stream.
1610  * @param yyscanner The scanner object.
1611  * @note This function does not reset the start condition to @c INITIAL .
1612  */
1613     void ast_yyrestart  (FILE * input_file , yyscan_t yyscanner)
1614 {
1615     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1616
1617         if ( ! YY_CURRENT_BUFFER ){
1618         ast_yyensure_buffer_stack (yyscanner);
1619                 YY_CURRENT_BUFFER_LVALUE =
1620             ast_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1621         }
1622
1623         ast_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1624         ast_yy_load_buffer_state(yyscanner );
1625 }
1626
1627 /** Switch to a different input buffer.
1628  * @param new_buffer The new input buffer.
1629  * @param yyscanner The scanner object.
1630  */
1631     void ast_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
1632 {
1633     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1634
1635         /* TODO. We should be able to replace this entire function body
1636          * with
1637          *              ast_yypop_buffer_state();
1638          *              ast_yypush_buffer_state(new_buffer);
1639      */
1640         ast_yyensure_buffer_stack (yyscanner);
1641         if ( YY_CURRENT_BUFFER == new_buffer )
1642                 return;
1643
1644         if ( YY_CURRENT_BUFFER )
1645                 {
1646                 /* Flush out information for old buffer. */
1647                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1648                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1649                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1650                 }
1651
1652         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1653         ast_yy_load_buffer_state(yyscanner );
1654
1655         /* We don't actually know whether we did this switch during
1656          * EOF (ast_yywrap()) processing, but the only time this flag
1657          * is looked at is after ast_yywrap() is called, so it's safe
1658          * to go ahead and always set it.
1659          */
1660         yyg->yy_did_buffer_switch_on_eof = 1;
1661 }
1662
1663 static void ast_yy_load_buffer_state  (yyscan_t yyscanner)
1664 {
1665     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1666         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1667         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1668         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1669         yyg->yy_hold_char = *yyg->yy_c_buf_p;
1670 }
1671
1672 /** Allocate and initialize an input buffer state.
1673  * @param file A readable stream.
1674  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1675  * @param yyscanner The scanner object.
1676  * @return the allocated buffer state.
1677  */
1678     YY_BUFFER_STATE ast_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
1679 {
1680         YY_BUFFER_STATE b;
1681     
1682         b = (YY_BUFFER_STATE) ast_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1683         if ( ! b )
1684                 YY_FATAL_ERROR( "out of dynamic memory in ast_yy_create_buffer()" );
1685
1686         b->yy_buf_size = size;
1687
1688         /* yy_ch_buf has to be 2 characters longer than the size given because
1689          * we need to put in 2 end-of-buffer characters.
1690          */
1691         b->yy_ch_buf = (char *) ast_yyalloc(b->yy_buf_size + 2 ,yyscanner );
1692         if ( ! b->yy_ch_buf )
1693                 YY_FATAL_ERROR( "out of dynamic memory in ast_yy_create_buffer()" );
1694
1695         b->yy_is_our_buffer = 1;
1696
1697         ast_yy_init_buffer(b,file ,yyscanner);
1698
1699         return b;
1700 }
1701
1702 /** Destroy the buffer.
1703  * @param b a buffer created with ast_yy_create_buffer()
1704  * @param yyscanner The scanner object.
1705  */
1706     void ast_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1707 {
1708     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1709
1710         if ( ! b )
1711                 return;
1712
1713         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1714                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1715
1716         if ( b->yy_is_our_buffer )
1717                 ast_yyfree((void *) b->yy_ch_buf ,yyscanner );
1718
1719         ast_yyfree((void *) b ,yyscanner );
1720 }
1721
1722 #ifndef __cplusplus
1723 extern int isatty (int );
1724 #endif /* __cplusplus */
1725     
1726 /* Initializes or reinitializes a buffer.
1727  * This function is sometimes called more than once on the same buffer,
1728  * such as during a ast_yyrestart() or at EOF.
1729  */
1730     static void ast_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
1731
1732 {
1733         int oerrno = errno;
1734     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1735
1736         ast_yy_flush_buffer(b ,yyscanner);
1737
1738         b->yy_input_file = file;
1739         b->yy_fill_buffer = 1;
1740
1741     /* If b is the current buffer, then ast_yy_init_buffer was _probably_
1742      * called from ast_yyrestart() or through yy_get_next_buffer.
1743      * In that case, we don't want to reset the lineno or column.
1744      */
1745     if (b != YY_CURRENT_BUFFER){
1746         b->yy_bs_lineno = 1;
1747         b->yy_bs_column = 0;
1748     }
1749
1750         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1751     
1752         errno = oerrno;
1753 }
1754
1755 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1756  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1757  * @param yyscanner The scanner object.
1758  */
1759     void ast_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1760 {
1761     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1762         if ( ! b )
1763                 return;
1764
1765         b->yy_n_chars = 0;
1766
1767         /* We always need two end-of-buffer characters.  The first causes
1768          * a transition to the end-of-buffer state.  The second causes
1769          * a jam in that state.
1770          */
1771         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1772         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1773
1774         b->yy_buf_pos = &b->yy_ch_buf[0];
1775
1776         b->yy_at_bol = 1;
1777         b->yy_buffer_status = YY_BUFFER_NEW;
1778
1779         if ( b == YY_CURRENT_BUFFER )
1780                 ast_yy_load_buffer_state(yyscanner );
1781 }
1782
1783 /** Pushes the new state onto the stack. The new state becomes
1784  *  the current state. This function will allocate the stack
1785  *  if necessary.
1786  *  @param new_buffer The new state.
1787  *  @param yyscanner The scanner object.
1788  */
1789 void ast_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1790 {
1791     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1792         if (new_buffer == NULL)
1793                 return;
1794
1795         ast_yyensure_buffer_stack(yyscanner);
1796
1797         /* This block is copied from ast_yy_switch_to_buffer. */
1798         if ( YY_CURRENT_BUFFER )
1799                 {
1800                 /* Flush out information for old buffer. */
1801                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1802                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1803                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1804                 }
1805
1806         /* Only push if top exists. Otherwise, replace top. */
1807         if (YY_CURRENT_BUFFER)
1808                 yyg->yy_buffer_stack_top++;
1809         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1810
1811         /* copied from ast_yy_switch_to_buffer. */
1812         ast_yy_load_buffer_state(yyscanner );
1813         yyg->yy_did_buffer_switch_on_eof = 1;
1814 }
1815
1816 /** Removes and deletes the top of the stack, if present.
1817  *  The next element becomes the new top.
1818  *  @param yyscanner The scanner object.
1819  */
1820 void ast_yypop_buffer_state (yyscan_t yyscanner)
1821 {
1822     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1823         if (!YY_CURRENT_BUFFER)
1824                 return;
1825
1826         ast_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1827         YY_CURRENT_BUFFER_LVALUE = NULL;
1828         if (yyg->yy_buffer_stack_top > 0)
1829                 --yyg->yy_buffer_stack_top;
1830
1831         if (YY_CURRENT_BUFFER) {
1832                 ast_yy_load_buffer_state(yyscanner );
1833                 yyg->yy_did_buffer_switch_on_eof = 1;
1834         }
1835 }
1836
1837 /* Allocates the stack if it does not exist.
1838  *  Guarantees space for at least one push.
1839  */
1840 static void ast_yyensure_buffer_stack (yyscan_t yyscanner)
1841 {
1842         int num_to_alloc;
1843     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1844
1845         if (!yyg->yy_buffer_stack) {
1846
1847                 /* First allocation is just for 2 elements, since we don't know if this
1848                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1849                  * immediate realloc on the next call.
1850          */
1851                 num_to_alloc = 1;
1852                 yyg->yy_buffer_stack = (struct yy_buffer_state**)ast_yyalloc
1853                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1854                                                                 , yyscanner);
1855                 
1856                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1857                                 
1858                 yyg->yy_buffer_stack_max = num_to_alloc;
1859                 yyg->yy_buffer_stack_top = 0;
1860                 return;
1861         }
1862
1863         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
1864
1865                 /* Increase the buffer to prepare for a possible push. */
1866                 int grow_size = 8 /* arbitrary grow size */;
1867
1868                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1869                 yyg->yy_buffer_stack = (struct yy_buffer_state**)ast_yyrealloc
1870                                                                 (yyg->yy_buffer_stack,
1871                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1872                                                                 , yyscanner);
1873
1874                 /* zero only the new slots.*/
1875                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1876                 yyg->yy_buffer_stack_max = num_to_alloc;
1877         }
1878 }
1879
1880 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1881  * @param base the character buffer
1882  * @param size the size in bytes of the character buffer
1883  * @param yyscanner The scanner object.
1884  * @return the newly allocated buffer state object. 
1885  */
1886 YY_BUFFER_STATE ast_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
1887 {
1888         YY_BUFFER_STATE b;
1889     
1890         if ( size < 2 ||
1891              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1892              base[size-1] != YY_END_OF_BUFFER_CHAR )
1893                 /* They forgot to leave room for the EOB's. */
1894                 return 0;
1895
1896         b = (YY_BUFFER_STATE) ast_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1897         if ( ! b )
1898                 YY_FATAL_ERROR( "out of dynamic memory in ast_yy_scan_buffer()" );
1899
1900         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1901         b->yy_buf_pos = b->yy_ch_buf = base;
1902         b->yy_is_our_buffer = 0;
1903         b->yy_input_file = 0;
1904         b->yy_n_chars = b->yy_buf_size;
1905         b->yy_is_interactive = 0;
1906         b->yy_at_bol = 1;
1907         b->yy_fill_buffer = 0;
1908         b->yy_buffer_status = YY_BUFFER_NEW;
1909
1910         ast_yy_switch_to_buffer(b ,yyscanner );
1911
1912         return b;
1913 }
1914
1915 /** Setup the input buffer state to scan a string. The next call to ast_yylex() will
1916  * scan from a @e copy of @a str.
1917  * @param str a NUL-terminated string to scan
1918  * @param yyscanner The scanner object.
1919  * @return the newly allocated buffer state object.
1920  * @note If you want to scan bytes that may contain NUL values, then use
1921  *       ast_yy_scan_bytes() instead.
1922  */
1923 YY_BUFFER_STATE ast_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
1924 {
1925     
1926         return ast_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
1927 }
1928
1929 /** Setup the input buffer state to scan the given bytes. The next call to ast_yylex() will
1930  * scan from a @e copy of @a bytes.
1931  * @param bytes the byte buffer to scan
1932  * @param len the number of bytes in the buffer pointed to by @a bytes.
1933  * @param yyscanner The scanner object.
1934  * @return the newly allocated buffer state object.
1935  */
1936 YY_BUFFER_STATE ast_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
1937 {
1938         YY_BUFFER_STATE b;
1939         char *buf;
1940         yy_size_t n;
1941         int i;
1942     
1943         /* Get memory for full buffer, including space for trailing EOB's. */
1944         n = _yybytes_len + 2;
1945         buf = (char *) ast_yyalloc(n ,yyscanner );
1946         if ( ! buf )
1947                 YY_FATAL_ERROR( "out of dynamic memory in ast_yy_scan_bytes()" );
1948
1949         for ( i = 0; i < _yybytes_len; ++i )
1950                 buf[i] = yybytes[i];
1951
1952         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1953
1954         b = ast_yy_scan_buffer(buf,n ,yyscanner);
1955         if ( ! b )
1956                 YY_FATAL_ERROR( "bad buffer in ast_yy_scan_bytes()" );
1957
1958         /* It's okay to grow etc. this buffer, and we should throw it
1959          * away when we're done.
1960          */
1961         b->yy_is_our_buffer = 1;
1962
1963         return b;
1964 }
1965
1966 #ifndef YY_EXIT_FAILURE
1967 #define YY_EXIT_FAILURE 2
1968 #endif
1969
1970 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
1971 {
1972         (void) fprintf( stderr, "%s\n", msg );
1973         exit( YY_EXIT_FAILURE );
1974 }
1975
1976 /* Redefine yyless() so it works in section 3 code. */
1977
1978 #undef yyless
1979 #define yyless(n) \
1980         do \
1981                 { \
1982                 /* Undo effects of setting up yytext. */ \
1983         int yyless_macro_arg = (n); \
1984         YY_LESS_LINENO(yyless_macro_arg);\
1985                 yytext[yyleng] = yyg->yy_hold_char; \
1986                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1987                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1988                 *yyg->yy_c_buf_p = '\0'; \
1989                 yyleng = yyless_macro_arg; \
1990                 } \
1991         while ( 0 )
1992
1993 /* Accessor  methods (get/set functions) to struct members. */
1994
1995 /** Get the user-defined data for this scanner.
1996  * @param yyscanner The scanner object.
1997  */
1998 YY_EXTRA_TYPE ast_yyget_extra  (yyscan_t yyscanner)
1999 {
2000     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2001     return yyextra;
2002 }
2003
2004 /** Get the current line number.
2005  * @param yyscanner The scanner object.
2006  */
2007 int ast_yyget_lineno  (yyscan_t yyscanner)
2008 {
2009     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2010     
2011         if (! YY_CURRENT_BUFFER)
2012             return 0;
2013     
2014     return yylineno;
2015 }
2016
2017 /** Get the current column number.
2018  * @param yyscanner The scanner object.
2019  */
2020 int ast_yyget_column  (yyscan_t yyscanner)
2021 {
2022     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2023     
2024         if (! YY_CURRENT_BUFFER)
2025             return 0;
2026     
2027     return yycolumn;
2028 }
2029
2030 /** Get the input stream.
2031  * @param yyscanner The scanner object.
2032  */
2033 FILE *ast_yyget_in  (yyscan_t yyscanner)
2034 {
2035     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2036     return yyin;
2037 }
2038
2039 /** Get the output stream.
2040  * @param yyscanner The scanner object.
2041  */
2042 FILE *ast_yyget_out  (yyscan_t yyscanner)
2043 {
2044     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2045     return yyout;
2046 }
2047
2048 /** Get the length of the current token.
2049  * @param yyscanner The scanner object.
2050  */
2051 int ast_yyget_leng  (yyscan_t yyscanner)
2052 {
2053     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2054     return yyleng;
2055 }
2056
2057 /** Get the current token.
2058  * @param yyscanner The scanner object.
2059  */
2060
2061 char *ast_yyget_text  (yyscan_t yyscanner)
2062 {
2063     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2064     return yytext;
2065 }
2066
2067 /** Set the user-defined data. This data is never touched by the scanner.
2068  * @param user_defined The data to be associated with this scanner.
2069  * @param yyscanner The scanner object.
2070  */
2071 void ast_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
2072 {
2073     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2074     yyextra = user_defined ;
2075 }
2076
2077 /** Set the current line number.
2078  * @param line_number
2079  * @param yyscanner The scanner object.
2080  */
2081 void ast_yyset_lineno (int  line_number , yyscan_t yyscanner)
2082 {
2083     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2084
2085         /* lineno is only valid if an input buffer exists. */
2086         if (! YY_CURRENT_BUFFER )
2087            yy_fatal_error( "ast_yyset_lineno called with no buffer" , yyscanner); 
2088     
2089     yylineno = line_number;
2090 }
2091
2092 /** Set the current column.
2093  * @param line_number
2094  * @param yyscanner The scanner object.
2095  */
2096 void ast_yyset_column (int  column_no , yyscan_t yyscanner)
2097 {
2098     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2099
2100         /* column is only valid if an input buffer exists. */
2101         if (! YY_CURRENT_BUFFER )
2102            yy_fatal_error( "ast_yyset_column called with no buffer" , yyscanner); 
2103     
2104     yycolumn = column_no;
2105 }
2106
2107 /** Set the input stream. This does not discard the current
2108  * input buffer.
2109  * @param in_str A readable stream.
2110  * @param yyscanner The scanner object.
2111  * @see ast_yy_switch_to_buffer
2112  */
2113 void ast_yyset_in (FILE *  in_str , yyscan_t yyscanner)
2114 {
2115     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2116     yyin = in_str ;
2117 }
2118
2119 void ast_yyset_out (FILE *  out_str , yyscan_t yyscanner)
2120 {
2121     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2122     yyout = out_str ;
2123 }
2124
2125 int ast_yyget_debug  (yyscan_t yyscanner)
2126 {
2127     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2128     return yy_flex_debug;
2129 }
2130
2131 void ast_yyset_debug (int  bdebug , yyscan_t yyscanner)
2132 {
2133     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2134     yy_flex_debug = bdebug ;
2135 }
2136
2137 /* Accessor methods for yylval and yylloc */
2138
2139 YYSTYPE * ast_yyget_lval  (yyscan_t yyscanner)
2140 {
2141     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2142     return yylval;
2143 }
2144
2145 void ast_yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
2146 {
2147     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2148     yylval = yylval_param;
2149 }
2150
2151 YYLTYPE *ast_yyget_lloc  (yyscan_t yyscanner)
2152 {
2153     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2154     return yylloc;
2155 }
2156     
2157 void ast_yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
2158 {
2159     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2160     yylloc = yylloc_param;
2161 }
2162     
2163 /* User-visible API */
2164
2165 /* ast_yylex_init is special because it creates the scanner itself, so it is
2166  * the ONLY reentrant function that doesn't take the scanner as the last argument.
2167  * That's why we explicitly handle the declaration, instead of using our macros.
2168  */
2169
2170 int ast_yylex_init(yyscan_t* ptr_yy_globals)
2171
2172 {
2173     if (ptr_yy_globals == NULL){
2174         errno = EINVAL;
2175         return 1;
2176     }
2177
2178     *ptr_yy_globals = (yyscan_t) ast_yyalloc ( sizeof( struct yyguts_t ), NULL );
2179
2180     if (*ptr_yy_globals == NULL){
2181         errno = ENOMEM;
2182         return 1;
2183     }
2184
2185     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
2186     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2187
2188     return yy_init_globals ( *ptr_yy_globals );
2189 }
2190
2191 static int yy_init_globals (yyscan_t yyscanner)
2192 {
2193     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2194     /* Initialization is the same as for the non-reentrant scanner.
2195      * This function is called from ast_yylex_destroy(), so don't allocate here.
2196      */
2197
2198     yyg->yy_buffer_stack = 0;
2199     yyg->yy_buffer_stack_top = 0;
2200     yyg->yy_buffer_stack_max = 0;
2201     yyg->yy_c_buf_p = (char *) 0;
2202     yyg->yy_init = 0;
2203     yyg->yy_start = 0;
2204
2205     yyg->yy_start_stack_ptr = 0;
2206     yyg->yy_start_stack_depth = 0;
2207     yyg->yy_start_stack =  NULL;
2208
2209 /* Defined in main.c */
2210 #ifdef YY_STDINIT
2211     yyin = stdin;
2212     yyout = stdout;
2213 #else
2214     yyin = (FILE *) 0;
2215     yyout = (FILE *) 0;
2216 #endif
2217
2218     /* For future reference: Set errno on error, since we are called by
2219      * ast_yylex_init()
2220      */
2221     return 0;
2222 }
2223
2224 /* ast_yylex_destroy is for both reentrant and non-reentrant scanners. */
2225 int ast_yylex_destroy  (yyscan_t yyscanner)
2226 {
2227     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2228
2229     /* Pop the buffer stack, destroying each element. */
2230         while(YY_CURRENT_BUFFER){
2231                 ast_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2232                 YY_CURRENT_BUFFER_LVALUE = NULL;
2233                 ast_yypop_buffer_state(yyscanner);
2234         }
2235
2236         /* Destroy the stack itself. */
2237         ast_yyfree(yyg->yy_buffer_stack ,yyscanner);
2238         yyg->yy_buffer_stack = NULL;
2239
2240     /* Destroy the start condition stack. */
2241         ast_yyfree(yyg->yy_start_stack ,yyscanner );
2242         yyg->yy_start_stack = NULL;
2243
2244     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2245      * ast_yylex() is called, initialization will occur. */
2246     yy_init_globals( yyscanner);
2247
2248     /* Destroy the main struct (reentrant only). */
2249     ast_yyfree ( yyscanner , yyscanner );
2250     yyscanner = NULL;
2251     return 0;
2252 }
2253
2254 /*
2255  * Internal utility routines.
2256  */
2257
2258 #ifndef yytext_ptr
2259 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2260 {
2261         register int i;
2262         for ( i = 0; i < n; ++i )
2263                 s1[i] = s2[i];
2264 }
2265 #endif
2266
2267 #ifdef YY_NEED_STRLEN
2268 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2269 {
2270         register int n;
2271         for ( n = 0; s[n]; ++n )
2272                 ;
2273
2274         return n;
2275 }
2276 #endif
2277
2278 void *ast_yyalloc (yy_size_t  size , yyscan_t yyscanner)
2279 {
2280         return (void *) malloc( size );
2281 }
2282
2283 void *ast_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
2284 {
2285         /* The cast to (char *) in the following accommodates both
2286          * implementations that use char* generic pointers, and those
2287          * that use void* generic pointers.  It works with the latter
2288          * because both ANSI C and C++ allow castless assignment from
2289          * any pointer type to void*, and deal with argument conversions
2290          * as though doing an assignment.
2291          */
2292         return (void *) realloc( (char *) ptr, size );
2293 }
2294
2295 #define YYTABLES_NAME "yytables"
2296
2297 #line 229 "ast_expr2.fl"
2298
2299
2300
2301 /* I'm putting the interface routine to the whole parse here in the flexer input file
2302    mainly because of all the flexer initialization that has to be done. Shouldn't matter
2303    where it is, as long as it's somewhere. I didn't want to define a prototype for the
2304    ast_yy_scan_string in the .y file, because then, I'd have to define YY_BUFFER_STATE there...
2305         UGH! that would be inappropriate. */
2306
2307 int ast_yyparse(void *); /* need to/should define this prototype for the call to yyparse */
2308 int ast_yyerror(const char *, YYLTYPE *, struct parse_io *); /* likewise */
2309
2310 void ast_yyfree(void *ptr, yyscan_t yyscanner)
2311 {
2312       if (ptr) /* the normal generated ast_yyfree func just frees its first arg;
2313                     this get complaints on some systems, as sometimes this
2314                     arg is a nil ptr! It's usually not fatal, but is irritating! */
2315               free( (char *) ptr );
2316 }
2317
2318 int ast_expr(char *expr, char *buf, int length, struct ast_channel *chan)
2319 {
2320         struct parse_io io;
2321         int return_value = 0;
2322         
2323         memset(&io, 0, sizeof(io));
2324         io.string = expr;  /* to pass to the error routine */
2325         io.chan = chan;
2326         
2327         ast_yylex_init(&io.scanner);
2328         
2329         ast_yy_scan_string(expr, io.scanner);
2330         
2331         ast_yyparse ((void *) &io);
2332
2333         ast_yylex_destroy(io.scanner);
2334
2335         if (!io.val) {
2336                 if (length > 1) {
2337                         strcpy(buf, "0");
2338                         return_value = 1;
2339                 }
2340         } else {
2341                 if (io.val->type == AST_EXPR_number) {
2342                         int res_length;
2343
2344                         res_length = snprintf(buf, length, FP___PRINTF, io.val->u.i);
2345                         return_value = (res_length <= length) ? res_length : length;
2346                 } else {
2347                         if (io.val->u.s)
2348 #if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE_AEL)
2349                                 strncpy(buf, io.val->u.s, length - 1);
2350 #else /* !STANDALONE && !LOW_MEMORY */
2351                                 ast_copy_string(buf, io.val->u.s, length);
2352 #endif /* STANDALONE || LOW_MEMORY */
2353                         else
2354                                 buf[0] = 0;
2355                         return_value = strlen(buf);
2356                         if (io.val->u.s)
2357                                 free(io.val->u.s);
2358                 }
2359                 free(io.val);
2360         }
2361         return return_value;
2362 }
2363
2364
2365 char extra_error_message[4095];
2366 int extra_error_message_supplied = 0;
2367 void  ast_expr_register_extra_error_info(char *message);
2368 void  ast_expr_clear_extra_error_info(void);
2369
2370 void  ast_expr_register_extra_error_info(char *message)
2371 {
2372        extra_error_message_supplied=1;
2373        strcpy(extra_error_message, message);
2374 }
2375
2376 void  ast_expr_clear_extra_error_info(void)
2377 {
2378        extra_error_message_supplied=0;
2379        extra_error_message[0] = 0;
2380 }
2381
2382 static char *expr2_token_equivs1[] = 
2383 {
2384         "TOKEN",
2385         "TOK_COND",
2386         "TOK_COLONCOLON",
2387         "TOK_OR",
2388         "TOK_AND",
2389         "TOK_EQ",
2390         "TOK_GT",
2391         "TOK_LT",
2392         "TOK_GE",
2393         "TOK_LE",
2394         "TOK_NE",
2395         "TOK_PLUS",
2396         "TOK_MINUS",
2397         "TOK_MULT",
2398         "TOK_DIV",
2399         "TOK_MOD",
2400         "TOK_COMPL",
2401         "TOK_COLON",
2402         "TOK_EQTILDE",
2403         "TOK_COMMA",
2404         "TOK_RP",
2405         "TOK_LP"
2406 };
2407
2408 static char *expr2_token_equivs2[] = 
2409 {
2410         "<token>",
2411         "?",
2412         "::",
2413         "|",
2414         "&",
2415         "=",
2416         ">",
2417         "<",
2418         ">=",
2419         "<=",
2420         "!=",
2421         "+",
2422         "-",
2423         "*",
2424         "/",
2425         "%",
2426         "!",
2427         ":",
2428         "=~",
2429         ",",
2430         ")",
2431         "("
2432 };
2433
2434
2435 static char *expr2_token_subst(const char *mess)
2436 {
2437         /* calc a length, malloc, fill, and return; yyerror had better free it! */
2438         int len=0,i;
2439         const char *p;
2440         char *res, *s,*t;
2441         int expr2_token_equivs_entries = sizeof(expr2_token_equivs1)/sizeof(char*);
2442
2443         for (p=mess; *p; p++) {
2444                 for (i=0; i<expr2_token_equivs_entries; i++) {
2445                         if ( strncmp(p,expr2_token_equivs1[i],strlen(expr2_token_equivs1[i])) == 0 )
2446                         {
2447                                 len+=strlen(expr2_token_equivs2[i])+2;
2448                                 p += strlen(expr2_token_equivs1[i])-1;
2449                                 break;
2450                         }
2451                 }
2452                 len++;
2453         }
2454         res = (char*)malloc(len+1);
2455         res[0] = 0;
2456         s = res;
2457         for (p=mess; *p;) {
2458                 int found = 0;
2459                 for (i=0; i<expr2_token_equivs_entries; i++) {
2460                         if ( strncmp(p,expr2_token_equivs1[i],strlen(expr2_token_equivs1[i])) == 0 ) {
2461                                 *s++ = '\'';
2462                                 for (t=expr2_token_equivs2[i]; *t;) {
2463                                         *s++ = *t++;
2464                                 }
2465                                 *s++ = '\'';
2466                                 p += strlen(expr2_token_equivs1[i]);
2467                                 found = 1;
2468                                 break;
2469                         }
2470                 }
2471                 if( !found )
2472                         *s++ = *p++;
2473         }
2474         *s++ = 0;
2475         return res;
2476 }
2477
2478 int ast_yyerror (const char *s,  yyltype *loc, struct parse_io *parseio )
2479 {       
2480         struct yyguts_t * yyg = (struct yyguts_t*)(parseio->scanner);
2481         char spacebuf[8000]; /* best safe than sorry */
2482         char spacebuf2[8000]; /* best safe than sorry */
2483         int i=0;
2484         char *s2 = expr2_token_subst(s);
2485         spacebuf[0] = 0;
2486         
2487         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,
2488                                                                                                                                                                                                 which is the same thing as... get this:
2489                                                                                                         yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]->yy_bs_column
2490                                                                                                         I was tempted to just use yy_buf_pos in the STATE, but..., well:
2491                                                                                                                 a. the yy_buf_pos is the current position in the buffer, which
2492                                                                                                                         may not relate to the entire string/buffer because of the
2493                                                                                                                         buffering.
2494                                                                                                                 b. but, analysis of the situation is that when you use the
2495                                                                                                                         ast_yy_scan_string func, it creates a single buffer the size of
2496                                                                                                                         string, so the two would be the same... 
2497                                                                                                         so, in the end, the yycolumn macro is available, shorter, therefore easier. */
2498         spacebuf2[i++]='^';
2499         spacebuf2[i]= 0;
2500
2501 #ifdef STANDALONE3
2502         /* easier to read in the standalone version */
2503         printf("ast_yyerror(): %s syntax error: %s; Input:\n%s\n%s\n",  
2504                         (extra_error_message_supplied?extra_error_message:""), s2, parseio->string,spacebuf2);
2505 #else
2506         ast_log(LOG_WARNING,"ast_yyerror(): %s syntax error: %s; Input:\n%s\n%s\n",  
2507                         (extra_error_message_supplied?extra_error_message:""), s2, parseio->string,spacebuf2);
2508 #endif
2509 #ifndef STANDALONE
2510         ast_log(LOG_WARNING,"If you have questions, please refer to doc/channelvariables.txt in the asterisk source.\n");
2511 #endif
2512         free(s2);
2513         return(0);
2514 }
2515