Merged revisions 87168 via svnmerge from
[asterisk/asterisk.git] / res / ael / ael_lex.c
1 #line 2 "ael_lex.c"
2
3 #line 4 "ael_lex.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 31
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 #include "asterisk.h"
20 /* begin standard C headers. */
21 #include <stdio.h>
22 #include <string.h>
23 #include <errno.h>
24 #include <stdlib.h>
25
26 /* end standard C headers. */
27
28 /* flex integer type definitions */
29
30 #ifndef FLEXINT_H
31 #define FLEXINT_H
32
33 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
34
35 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
36 #include <inttypes.h>
37 typedef int8_t flex_int8_t;
38 typedef uint8_t flex_uint8_t;
39 typedef int16_t flex_int16_t;
40 typedef uint16_t flex_uint16_t;
41 typedef int32_t flex_int32_t;
42 typedef uint32_t flex_uint32_t;
43 #else
44 typedef signed char flex_int8_t;
45 typedef short int flex_int16_t;
46 typedef int flex_int32_t;
47 typedef unsigned char flex_uint8_t; 
48 typedef unsigned short int flex_uint16_t;
49 typedef unsigned int flex_uint32_t;
50 #endif /* ! C99 */
51
52 /* Limits of integral types. */
53 #ifndef INT8_MIN
54 #define INT8_MIN               (-128)
55 #endif
56 #ifndef INT16_MIN
57 #define INT16_MIN              (-32767-1)
58 #endif
59 #ifndef INT32_MIN
60 #define INT32_MIN              (-2147483647-1)
61 #endif
62 #ifndef INT8_MAX
63 #define INT8_MAX               (127)
64 #endif
65 #ifndef INT16_MAX
66 #define INT16_MAX              (32767)
67 #endif
68 #ifndef INT32_MAX
69 #define INT32_MAX              (2147483647)
70 #endif
71 #ifndef UINT8_MAX
72 #define UINT8_MAX              (255U)
73 #endif
74 #ifndef UINT16_MAX
75 #define UINT16_MAX             (65535U)
76 #endif
77 #ifndef UINT32_MAX
78 #define UINT32_MAX             (4294967295U)
79 #endif
80
81 #endif /* ! FLEXINT_H */
82
83 #ifdef __cplusplus
84
85 /* The "const" storage-class-modifier is valid. */
86 #define YY_USE_CONST
87
88 #else   /* ! __cplusplus */
89
90 #if __STDC__
91
92 #define YY_USE_CONST
93
94 #endif  /* __STDC__ */
95 #endif  /* ! __cplusplus */
96
97 #ifdef YY_USE_CONST
98 #define yyconst const
99 #else
100 #define yyconst
101 #endif
102
103 /* Returned upon end-of-file. */
104 #define YY_NULL 0
105
106 /* Promotes a possibly negative, possibly signed char to an unsigned
107  * integer for use as an array index.  If the signed char is negative,
108  * we want to instead treat it as an 8-bit unsigned char, hence the
109  * double cast.
110  */
111 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
112
113 /* An opaque pointer. */
114 #ifndef YY_TYPEDEF_YY_SCANNER_T
115 #define YY_TYPEDEF_YY_SCANNER_T
116 typedef void* yyscan_t;
117 #endif
118
119 /* For convenience, these vars (plus the bison vars far below)
120    are macros in the reentrant scanner. */
121 #define yyin yyg->yyin_r
122 #define yyout yyg->yyout_r
123 #define yyextra yyg->yyextra_r
124 #define yyleng yyg->yyleng_r
125 #define yytext yyg->yytext_r
126 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
127 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
128 #define yy_flex_debug yyg->yy_flex_debug_r
129
130 int ael_yylex_init (yyscan_t* scanner);
131
132 /* Enter a start condition.  This macro really ought to take a parameter,
133  * but we do it the disgusting crufty way forced on us by the ()-less
134  * definition of BEGIN.
135  */
136 #define BEGIN yyg->yy_start = 1 + 2 *
137
138 /* Translate the current start state into a value that can be later handed
139  * to BEGIN to return to the state.  The YYSTATE alias is for lex
140  * compatibility.
141  */
142 #define YY_START ((yyg->yy_start - 1) / 2)
143 #define YYSTATE YY_START
144
145 /* Action number for EOF rule of a given start state. */
146 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
147
148 /* Special action meaning "start processing a new file". */
149 #define YY_NEW_FILE ael_yyrestart(yyin ,yyscanner )
150
151 #define YY_END_OF_BUFFER_CHAR 0
152
153 /* Size of default input buffer. */
154 #ifndef YY_BUF_SIZE
155 #define YY_BUF_SIZE 16384
156 #endif
157
158 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
159 #define YY_TYPEDEF_YY_BUFFER_STATE
160 typedef struct yy_buffer_state *YY_BUFFER_STATE;
161 #endif
162
163 #define EOB_ACT_CONTINUE_SCAN 0
164 #define EOB_ACT_END_OF_FILE 1
165 #define EOB_ACT_LAST_MATCH 2
166
167     #define YY_LESS_LINENO(n)
168     
169 /* Return all but the first "n" matched characters back to the input stream. */
170 #define yyless(n) \
171         do \
172                 { \
173                 /* Undo effects of setting up yytext. */ \
174         int yyless_macro_arg = (n); \
175         YY_LESS_LINENO(yyless_macro_arg);\
176                 *yy_cp = yyg->yy_hold_char; \
177                 YY_RESTORE_YY_MORE_OFFSET \
178                 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
179                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
180                 } \
181         while ( 0 )
182
183 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
184
185 /* The following is because we cannot portably get our hands on size_t
186  * (without autoconf's help, which isn't available because we want
187  * flex-generated scanners to compile on their own).
188  */
189
190 #ifndef YY_TYPEDEF_YY_SIZE_T
191 #define YY_TYPEDEF_YY_SIZE_T
192 typedef unsigned int yy_size_t;
193 #endif
194
195 #ifndef YY_STRUCT_YY_BUFFER_STATE
196 #define YY_STRUCT_YY_BUFFER_STATE
197 struct yy_buffer_state
198         {
199         FILE *yy_input_file;
200
201         char *yy_ch_buf;                /* input buffer */
202         char *yy_buf_pos;               /* current position in input buffer */
203
204         /* Size of input buffer in bytes, not including room for EOB
205          * characters.
206          */
207         yy_size_t yy_buf_size;
208
209         /* Number of characters read into yy_ch_buf, not including EOB
210          * characters.
211          */
212         int yy_n_chars;
213
214         /* Whether we "own" the buffer - i.e., we know we created it,
215          * and can realloc() it to grow it, and should free() it to
216          * delete it.
217          */
218         int yy_is_our_buffer;
219
220         /* Whether this is an "interactive" input source; if so, and
221          * if we're using stdio for input, then we want to use getc()
222          * instead of fread(), to make sure we stop fetching input after
223          * each newline.
224          */
225         int yy_is_interactive;
226
227         /* Whether we're considered to be at the beginning of a line.
228          * If so, '^' rules will be active on the next match, otherwise
229          * not.
230          */
231         int yy_at_bol;
232
233     int yy_bs_lineno; /**< The line count. */
234     int yy_bs_column; /**< The column count. */
235     
236         /* Whether to try to fill the input buffer when we reach the
237          * end of it.
238          */
239         int yy_fill_buffer;
240
241         int yy_buffer_status;
242
243 #define YY_BUFFER_NEW 0
244 #define YY_BUFFER_NORMAL 1
245         /* When an EOF's been seen but there's still some text to process
246          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
247          * shouldn't try reading from the input source any more.  We might
248          * still have a bunch of tokens to match, though, because of
249          * possible backing-up.
250          *
251          * When we actually see the EOF, we change the status to "new"
252          * (via ael_yyrestart()), so that the user can continue scanning by
253          * just pointing yyin at a new input file.
254          */
255 #define YY_BUFFER_EOF_PENDING 2
256
257         };
258 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
259
260 /* We provide macros for accessing buffer states in case in the
261  * future we want to put the buffer states in a more general
262  * "scanner state".
263  *
264  * Returns the top of the stack, or NULL.
265  */
266 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
267                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
268                           : NULL)
269
270 /* Same as previous macro, but useful when we know that the buffer stack is not
271  * NULL or when we need an lvalue. For internal use only.
272  */
273 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
274
275 void ael_yyrestart (FILE *input_file ,yyscan_t yyscanner );
276 void ael_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
277 YY_BUFFER_STATE ael_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
278 void ael_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
279 void ael_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
280 void ael_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
281 void ael_yypop_buffer_state (yyscan_t yyscanner );
282
283 static void ael_yyensure_buffer_stack (yyscan_t yyscanner );
284 static void ael_yy_load_buffer_state (yyscan_t yyscanner );
285 static void ael_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
286
287 #define YY_FLUSH_BUFFER ael_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
288
289 YY_BUFFER_STATE ael_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
290 YY_BUFFER_STATE ael_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
291 YY_BUFFER_STATE ael_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
292
293 void *ael_yyalloc (yy_size_t ,yyscan_t yyscanner );
294 void *ael_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
295 void ael_yyfree (void * ,yyscan_t yyscanner );
296
297 #define yy_new_buffer ael_yy_create_buffer
298
299 #define yy_set_interactive(is_interactive) \
300         { \
301         if ( ! YY_CURRENT_BUFFER ){ \
302         ael_yyensure_buffer_stack (yyscanner); \
303                 YY_CURRENT_BUFFER_LVALUE =    \
304             ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
305         } \
306         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
307         }
308
309 #define yy_set_bol(at_bol) \
310         { \
311         if ( ! YY_CURRENT_BUFFER ){\
312         ael_yyensure_buffer_stack (yyscanner); \
313                 YY_CURRENT_BUFFER_LVALUE =    \
314             ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
315         } \
316         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
317         }
318
319 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
320
321 /* Begin user sect3 */
322
323 #define ael_yywrap(n) 1
324 #define YY_SKIP_YYWRAP
325
326 typedef unsigned char YY_CHAR;
327
328 typedef int yy_state_type;
329
330 #define yytext_ptr yytext_r
331
332 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
333 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
334 static int yy_get_next_buffer (yyscan_t yyscanner );
335 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
336
337 /* Done after the current pattern has been matched and before the
338  * corresponding action - sets up yytext.
339  */
340 #define YY_DO_BEFORE_ACTION \
341         yyg->yytext_ptr = yy_bp; \
342         yyg->yytext_ptr -= yyg->yy_more_len; \
343         yyleng = (size_t) (yy_cp - yyg->yytext_ptr); \
344         yyg->yy_hold_char = *yy_cp; \
345         *yy_cp = '\0'; \
346         yyg->yy_c_buf_p = yy_cp;
347
348 #define YY_NUM_RULES 63
349 #define YY_END_OF_BUFFER 64
350 /* This struct is not used in this scanner,
351    but its presence is necessary. */
352 struct yy_trans_info
353         {
354         flex_int32_t yy_verify;
355         flex_int32_t yy_nxt;
356         };
357 static yyconst flex_int16_t yy_accept[244] =
358     {   0,
359         0,    0,    0,    0,    0,    0,    0,    0,   43,   43,
360        64,   63,   50,   48,   49,   51,   51,    9,    3,    4,
361         7,   51,    8,    5,    6,   12,   51,   51,   51,   51,
362        51,   51,   51,   51,   51,   51,   51,   51,   51,   51,
363        51,   51,    1,   10,    2,   63,   53,   52,   63,   54,
364        63,   59,   60,   61,   63,   63,   55,   56,   57,   63,
365        58,   43,   44,   45,   50,   49,   51,   51,   42,   13,
366        11,   51,   51,   51,   51,   51,   51,   51,   51,   51,
367        51,   51,   51,   22,   51,   51,   51,   51,   51,   51,
368        51,   51,   51,   51,    0,   53,   52,    0,   54,   53,
369
370        52,   54,    0,   59,   60,   61,    0,   59,   60,   61,
371         0,   55,   56,   57,    0,   58,   55,   56,   57,   58,
372        43,   44,   45,   46,   45,   47,   51,   13,   13,   51,
373        51,   51,   51,   51,   51,   51,   51,   51,   33,   51,
374        51,   51,   51,   51,   51,   51,   51,   51,   51,   51,
375        51,   51,   51,   51,   51,   51,   51,   35,   51,   51,
376        51,   27,   51,   51,   51,   28,   26,   51,   51,   51,
377        29,   51,   51,   51,   51,   51,   51,   51,   51,   51,
378        51,   31,   38,   51,   51,   51,   51,   51,   51,   51,
379        51,   51,   19,   17,   51,   51,   51,   51,   51,   34,
380
381        51,   51,   51,   51,   51,   51,   16,   51,   23,   51,
382        51,   51,   24,   51,   30,   21,   51,   51,   14,   51,
383        36,   51,   18,   51,   51,   37,   51,   51,   51,   15,
384        32,   51,   51,   41,   25,   39,    0,   40,   20,    0,
385         0,   62,    0
386     } ;
387
388 static yyconst flex_int32_t yy_ec[256] =
389     {   0,
390         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
391         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
392         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
393         1,    4,    5,    6,    7,    5,    1,    8,    5,    9,
394        10,   11,    5,   12,    5,    5,   13,    5,    5,    5,
395         5,    5,    5,    5,    5,    5,    5,   14,   15,    5,
396        16,   17,    1,   18,    5,    5,    5,    5,    5,    5,
397         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
398         5,    5,    5,   19,    5,    5,    5,    5,    5,    5,
399        20,   21,   22,    1,    5,    1,   23,   24,   25,   26,
400
401        27,   28,   29,   30,   31,   32,   33,   34,   35,   36,
402        37,   38,    5,   39,   40,   41,   42,    5,   43,   44,
403         5,    5,   45,   46,   47,    1,    1,    1,    1,    1,
404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
405         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
408         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
409         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
410         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
411
412         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
413         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
414         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
415         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
416         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
417         1,    1,    1,    1,    1
418     } ;
419
420 static yyconst flex_int32_t yy_meta[48] =
421     {   0,
422         1,    1,    2,    1,    3,    4,    3,    1,    1,    1,
423         5,    1,    3,    1,    1,    1,    3,    1,    3,    3,
424         1,    3,    3,    3,    3,    3,    3,    3,    3,    3,
425         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
426         3,    3,    3,    3,    3,    1,    3
427     } ;
428
429 static yyconst flex_int16_t yy_base[257] =
430     {   0,
431         0,    0,   39,   42,   81,  120,  159,  198,   47,   54,
432       319,  985,  316,  985,  313,    0,  285,  985,  985,  985,
433       985,   42,  985,  985,  298,  985,  290,  274,   31,  285,
434        32,  274,   33,  279,   45,  267,  271,  284,  283,   48,
435       262,  274,  985,  985,  985,   73,  985,  985,   89,  985,
436       237,  985,  985,  985,  276,  315,  985,  985,  985,  354,
437       985,  300,  985,   66,  300,  297,    0,  264,    0,  401,
438       985,  259,  268,   64,  258,  265,  252,  247,  248,  249,
439       250,  242,  245,  261,  243,  253,  242,  251,  250,  233,
440       237,   51,  241,  240,  103,  985,  985,  137,  985,  142,
441
442       176,  181,  439,  985,  985,  985,  478,  517,  556,  595,
443       634,  985,  985,  985,  673,  985,  712,  751,  790,  829,
444       267,  985,  103,  985,  104,  985,  244,    0,  876,  227,
445       244,  239,  240,  223,  240,  235,  230,  233,    0,  232,
446       218,  213,  222,  214,  216,  211,  225,  205,  201,  215,
447       213,  197,  197,  203,  202,  196,  201,    0,  203,  100,
448       190,    0,  190,  194,  206,    0,    0,  192,  186,  182,
449         0,  188,  180,  189,  178,  170,  174,  187,  184,  167,
450       182,    0,    0,  156,  163,  161,  169,  167,  158,  161,
451       156,  152,    0,    0,  138,  141,  134,  137,  136,    0,
452
453       135,  135,  115,  113,  113,  123,    0,  109,    0,  107,
454       117,  107,    0,  112,    0,  111,  110,   92,    0,  105,
455         0,   95,    0,   85,   60,    0,   61,   48,  117,    0,
456         0,   45,   37,    0,    0,    0,  168,    0,    0,    0,
457        50,  985,  985,  922,  927,  932,  937,  940,  945,  950,
458       955,  960,  964,  969,  974,  979
459     } ;
460
461 static yyconst flex_int16_t yy_def[257] =
462     {   0,
463       243,    1,  244,  244,  245,  245,  246,  246,  247,  247,
464       243,  243,  243,  243,  243,  248,  248,  243,  243,  243,
465       243,  248,  243,  243,  243,  243,  248,  248,  248,  248,
466       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
467       248,  248,  243,  243,  243,  249,  243,  243,  249,  243,
468       250,  243,  243,  243,  250,  251,  243,  243,  243,  251,
469       243,  252,  243,  253,  243,  243,  248,  248,  248,  254,
470       243,  248,  248,  248,  248,  248,  248,  248,  248,  248,
471       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
472       248,  248,  248,  248,  249,  243,  243,  249,  243,  249,
473
474       249,  249,  250,  243,  243,  243,  250,  250,  250,  250,
475       251,  243,  243,  243,  251,  243,  251,  251,  251,  251,
476       252,  243,  253,  243,  253,  243,  248,  255,  254,  248,
477       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
478       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
479       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
480       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
481       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
482       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
483       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
484
485       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
486       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
487       248,  248,  248,  248,  248,  248,  248,  248,  248,  248,
488       248,  248,  248,  248,  248,  248,  243,  248,  248,  256,
489       256,  243,    0,  243,  243,  243,  243,  243,  243,  243,
490       243,  243,  243,  243,  243,  243
491     } ;
492
493 static yyconst flex_int16_t yy_nxt[1033] =
494     {   0,
495        12,   13,   14,   15,   16,   16,   17,   18,   19,   20,
496        16,   21,   22,   23,   24,   25,   16,   26,   16,   16,
497        12,   16,   27,   28,   29,   30,   31,   32,   33,   34,
498        35,   36,   16,   37,   38,   16,   16,   39,   40,   41,
499        16,   16,   42,   16,   43,   44,   45,   47,   48,   63,
500        47,   48,   69,   74,   70,  242,   63,   64,   47,   49,
501        50,   47,   49,   50,   64,   77,   81,   75,  124,   82,
502        91,   78,   84,   85,   92,   79,  125,  239,  126,  151,
503        86,   96,   97,   47,  238,   50,   47,  236,   50,   52,
504        53,  152,   96,   98,   99,   54,  235,  100,  101,  234,
505
506        52,   55,   53,  132,  133,  124,  124,  233,  100,   98,
507       102,   96,   97,  243,  125,  243,  243,   96,  237,   99,
508       237,  232,   96,   98,   99,   52,  184,   53,   52,   53,
509       185,  231,  230,  100,   54,  102,  229,  228,  227,   52,
510        55,   53,  226,  225,  224,  100,  101,   96,  223,   99,
511        96,   97,  222,  221,  220,  219,  100,   98,  102,  218,
512       217,   96,   98,   99,   52,  216,   53,   57,   58,  237,
513        59,  237,  215,  240,  214,  213,  212,  211,   57,   60,
514        61,  100,  210,  102,   96,   97,   96,  209,   99,   96,
515        97,  208,  207,  206,  205,   96,   98,   99,  204,  203,
516
517        96,   98,   99,   57,  202,   61,   57,   58,  201,   59,
518       200,  199,  198,  197,  196,  195,  194,   57,   60,   61,
519        96,  193,   99,  192,  191,   96,  190,   99,  189,  188,
520       187,  186,  183,  182,  181,  180,  179,  178,  177,  176,
521       175,  174,   57,  173,   61,  104,  105,  172,  171,  170,
522       169,  106,  168,  167,  166,  165,  104,  107,  105,  164,
523       163,  162,  161,  160,  159,  158,  157,  156,  155,  122,
524       154,  153,  150,  149,  148,  147,  146,  145,  144,  143,
525       142,  104,  141,  105,  108,  109,  140,  139,  138,  137,
526       110,  136,  135,  134,  131,  108,  107,  109,  130,  127,
527
528        66,   65,  122,   94,   93,   90,   89,   88,   87,   83,
529        80,   76,   73,   72,   71,   68,   66,   65,  243,  243,
530       108,  243,  109,  112,  113,  243,  114,  243,  243,  243,
531       243,  243,  243,  243,  112,  115,  116,  243,  243,  243,
532       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
533       243,  243,  243,  243,  243,  243,  243,  243,  243,  112,
534       243,  116,  117,  118,  243,  119,  243,  243,  243,  243,
535       243,  243,  243,  117,  115,  120,  243,  243,  243,  243,
536       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
537       243,  243,  243,  243,  243,  243,  243,  243,  117,  243,
538
539       120,  128,  128,  243,  128,  243,  243,  243,  128,  128,
540       128,  243,  128,  243,  128,  128,  128,  243,  128,  243,
541       243,  128,  243,  243,  243,  243,  243,  243,  243,  243,
542       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
543       243,  243,  243,  243,  243,  243,  128,  104,  105,  243,
544       243,  243,  243,  106,  243,  243,  243,  243,  104,  107,
545       105,  243,  243,  243,  243,  243,  243,  243,  243,  243,
546       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
547       243,  243,  243,  104,  243,  105,  108,  109,  243,  243,
548       243,  243,  110,  243,  243,  243,  243,  108,  107,  109,
549
550       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
551       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
552       243,  243,  108,  243,  109,  104,  105,  243,  243,  243,
553       243,  106,  243,  243,  243,  243,  104,  107,  105,  243,
554       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
555       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
556       243,  104,  243,  105,  104,  105,  243,  243,  243,  243,
557       106,  243,  243,  243,  243,  104,  107,  105,  243,  243,
558       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
559       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
560
561       104,  243,  105,  104,  105,  243,  243,  243,  243,  106,
562       243,  243,  243,  243,  104,  107,  105,  243,  243,  243,
563       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
564       243,  243,  243,  243,  243,  243,  243,  243,  243,  104,
565       243,  105,  112,  113,  243,  114,  243,  243,  243,  243,
566       243,  243,  243,  112,  115,  116,  243,  243,  243,  243,
567       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
568       243,  243,  243,  243,  243,  243,  243,  243,  112,  243,
569       116,  117,  118,  243,  119,  243,  243,  243,  243,  243,
570       243,  243,  117,  115,  120,  243,  243,  243,  243,  243,
571
572       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
573       243,  243,  243,  243,  243,  243,  243,  117,  243,  120,
574       112,  113,  243,  114,  243,  243,  243,  243,  243,  243,
575       243,  112,  115,  116,  243,  243,  243,  243,  243,  243,
576       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
577       243,  243,  243,  243,  243,  243,  112,  243,  116,  112,
578       113,  243,  114,  243,  243,  243,  243,  243,  243,  243,
579       112,  115,  116,  243,  243,  243,  243,  243,  243,  243,
580       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
581       243,  243,  243,  243,  243,  112,  243,  116,  112,  113,
582
583       243,  114,  243,  243,  243,  243,  243,  243,  243,  112,
584       115,  116,  243,  243,  243,  243,  243,  243,  243,  243,
585       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
586       243,  243,  243,  243,  112,  243,  116,  112,  113,  243,
587       114,  243,  243,  243,  243,  243,  243,  243,  112,  115,
588       116,  243,  243,  243,  243,  243,  243,  243,  243,  243,
589       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
590       243,  243,  243,  112,  243,  116,  128,  128,  243,  128,
591       243,  243,  243,  128,  128,  128,  243,  128,  243,  128,
592       128,  128,  243,  128,  243,  243,  128,  243,  243,  243,
593
594       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
595       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
596       243,  128,   46,   46,   46,   46,   46,   51,   51,   51,
597        51,   51,   56,   56,   56,   56,   56,   62,   62,   62,
598        62,   62,   67,   67,   67,   95,   95,   95,   95,   95,
599       103,  103,  103,  103,  103,  111,  111,  111,  111,  111,
600       121,  121,  121,  121,  123,  123,  123,  123,  123,  129,
601       243,  129,  129,  129,  128,  243,  128,  128,  128,  241,
602       241,  241,  243,  241,   11,  243,  243,  243,  243,  243,
603       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
604
605       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
606       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
607       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
608       243,  243
609     } ;
610
611 static yyconst flex_int16_t yy_chk[1033] =
612     {   0,
613         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
614         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
615         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
616         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
617         1,    1,    1,    1,    1,    1,    1,    3,    3,    9,
618         4,    4,   22,   29,   22,  241,   10,    9,    3,    3,
619         3,    4,    4,    4,   10,   31,   33,   29,   64,   33,
620        40,   31,   35,   35,   40,   31,   64,  233,   64,   92,
621        35,   46,   46,    3,  232,    3,    4,  228,    4,    5,
622         5,   92,   46,   46,   46,    5,  227,   49,   49,  225,
623
624         5,    5,    5,   74,   74,  123,  125,  224,   49,   49,
625        49,   95,   95,  123,  125,  123,  125,   46,  229,   46,
626       229,  222,   95,   95,   95,    5,  160,    5,    6,    6,
627       160,  220,  218,   49,    6,   49,  217,  216,  214,    6,
628         6,    6,  212,  211,  210,   98,   98,   95,  208,   95,
629       100,  100,  206,  205,  204,  203,   98,   98,   98,  202,
630       201,  100,  100,  100,    6,  199,    6,    7,    7,  237,
631         7,  237,  198,  237,  197,  196,  195,  192,    7,    7,
632         7,   98,  191,   98,  101,  101,  100,  190,  100,  102,
633       102,  189,  188,  187,  186,  101,  101,  101,  185,  184,
634
635       102,  102,  102,    7,  181,    7,    8,    8,  180,    8,
636       179,  178,  177,  176,  175,  174,  173,    8,    8,    8,
637       101,  172,  101,  170,  169,  102,  168,  102,  165,  164,
638       163,  161,  159,  157,  156,  155,  154,  153,  152,  151,
639       150,  149,    8,  148,    8,   51,   51,  147,  146,  145,
640       144,   51,  143,  142,  141,  140,   51,   51,   51,  138,
641       137,  136,  135,  134,  133,  132,  131,  130,  127,  121,
642        94,   93,   91,   90,   89,   88,   87,   86,   85,   84,
643        83,   51,   82,   51,   55,   55,   81,   80,   79,   78,
644        55,   77,   76,   75,   73,   55,   55,   55,   72,   68,
645
646        66,   65,   62,   42,   41,   39,   38,   37,   36,   34,
647        32,   30,   28,   27,   25,   17,   15,   13,   11,    0,
648        55,    0,   55,   56,   56,    0,   56,    0,    0,    0,
649         0,    0,    0,    0,   56,   56,   56,    0,    0,    0,
650         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
651         0,    0,    0,    0,    0,    0,    0,    0,    0,   56,
652         0,   56,   60,   60,    0,   60,    0,    0,    0,    0,
653         0,    0,    0,   60,   60,   60,    0,    0,    0,    0,
654         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
655         0,    0,    0,    0,    0,    0,    0,    0,   60,    0,
656
657        60,   70,   70,    0,   70,    0,    0,    0,   70,   70,
658        70,    0,   70,    0,   70,   70,   70,    0,   70,    0,
659         0,   70,    0,    0,    0,    0,    0,    0,    0,    0,
660         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
661         0,    0,    0,    0,    0,    0,   70,  103,  103,    0,
662         0,    0,    0,  103,    0,    0,    0,    0,  103,  103,
663       103,    0,    0,    0,    0,    0,    0,    0,    0,    0,
664         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
665         0,    0,    0,  103,    0,  103,  107,  107,    0,    0,
666         0,    0,  107,    0,    0,    0,    0,  107,  107,  107,
667
668         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
669         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
670         0,    0,  107,    0,  107,  108,  108,    0,    0,    0,
671         0,  108,    0,    0,    0,    0,  108,  108,  108,    0,
672         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
673         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
674         0,  108,    0,  108,  109,  109,    0,    0,    0,    0,
675       109,    0,    0,    0,    0,  109,  109,  109,    0,    0,
676         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
677         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
678
679       109,    0,  109,  110,  110,    0,    0,    0,    0,  110,
680         0,    0,    0,    0,  110,  110,  110,    0,    0,    0,
681         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
682         0,    0,    0,    0,    0,    0,    0,    0,    0,  110,
683         0,  110,  111,  111,    0,  111,    0,    0,    0,    0,
684         0,    0,    0,  111,  111,  111,    0,    0,    0,    0,
685         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
686         0,    0,    0,    0,    0,    0,    0,    0,  111,    0,
687       111,  115,  115,    0,  115,    0,    0,    0,    0,    0,
688         0,    0,  115,  115,  115,    0,    0,    0,    0,    0,
689
690         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
691         0,    0,    0,    0,    0,    0,    0,  115,    0,  115,
692       117,  117,    0,  117,    0,    0,    0,    0,    0,    0,
693         0,  117,  117,  117,    0,    0,    0,    0,    0,    0,
694         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
695         0,    0,    0,    0,    0,    0,  117,    0,  117,  118,
696       118,    0,  118,    0,    0,    0,    0,    0,    0,    0,
697       118,  118,  118,    0,    0,    0,    0,    0,    0,    0,
698         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
699         0,    0,    0,    0,    0,  118,    0,  118,  119,  119,
700
701         0,  119,    0,    0,    0,    0,    0,    0,    0,  119,
702       119,  119,    0,    0,    0,    0,    0,    0,    0,    0,
703         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
704         0,    0,    0,    0,  119,    0,  119,  120,  120,    0,
705       120,    0,    0,    0,    0,    0,    0,    0,  120,  120,
706       120,    0,    0,    0,    0,    0,    0,    0,    0,    0,
707         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
708         0,    0,    0,  120,    0,  120,  129,  129,    0,  129,
709         0,    0,    0,  129,  129,  129,    0,  129,    0,  129,
710       129,  129,    0,  129,    0,    0,  129,    0,    0,    0,
711
712         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
713         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
714         0,  129,  244,  244,  244,  244,  244,  245,  245,  245,
715       245,  245,  246,  246,  246,  246,  246,  247,  247,  247,
716       247,  247,  248,  248,  248,  249,  249,  249,  249,  249,
717       250,  250,  250,  250,  250,  251,  251,  251,  251,  251,
718       252,  252,  252,  252,  253,  253,  253,  253,  253,  254,
719         0,  254,  254,  254,  255,    0,  255,  255,  255,  256,
720       256,  256,    0,  256,  243,  243,  243,  243,  243,  243,
721       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
722
723       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
724       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
725       243,  243,  243,  243,  243,  243,  243,  243,  243,  243,
726       243,  243
727     } ;
728
729 /* The intent behind this definition is that it'll catch
730  * any uses of REJECT which flex missed.
731  */
732 #define REJECT reject_used_but_not_detected
733 #define yymore() (yyg->yy_more_flag = 1)
734 #define YY_MORE_ADJ yyg->yy_more_len
735 #define YY_RESTORE_YY_MORE_OFFSET
736 #line 1 "ael.flex"
737 /*
738  * Asterisk -- An open source telephony toolkit.
739  *
740  * Copyright (C) 2006, Digium, Inc.
741  *
742  * Steve Murphy <murf@parsetree.com>
743  *
744  * See http://www.asterisk.org for more information about
745  * the Asterisk project. Please do not directly contact
746  * any of the maintainers of this project for assistance;
747  * the project provides a web site, mailing lists and IRC
748  * channels for your use.
749  *
750  * This program is free software, distributed under the terms of
751  * the GNU General Public License Version 2. See the LICENSE file
752  * at the top of the source tree.
753  */
754 /*! \file
755  *
756  * \brief Flex scanner description of tokens used in AEL2 .
757  *
758  */
759 /*
760  * Start with flex options:
761  *
762  * %x describes the contexts we have: paren, semic and argg, plus INITIAL
763  */
764
765 /* prefix used for various globally-visible functions and variables.
766  * This renames also ael_yywrap, but since we do not use it, we just
767  * add option noyywrap to remove it.
768  */
769 /* batch gives a bit more performance if we are using it in
770  * a non-interactive mode. We probably don't care much.
771  */
772 /* outfile is the filename to be used instead of lex.yy.c */
773 /*
774  * These are not supported in flex 2.5.4, but we need them
775  * at the moment:
776  * reentrant produces a thread-safe parser. Not 100% sure that
777  * we require it, though.
778  * bison-bridge passes an additional yylval argument to ael_yylex().
779  * bison-locations is probably not needed.
780  */
781 #line 59 "ael.flex"
782 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
783
784 #include <sys/types.h>
785 #include <sys/stat.h>
786 #include <unistd.h>
787
788 #if defined(__Darwin__) || defined(__CYGWIN__)
789 #define GLOB_ABORTED GLOB_ABEND
790 #endif
791 # include <glob.h>
792
793 #include "asterisk/logger.h"
794 #include "asterisk/utils.h"
795 #include "ael/ael.tab.h"
796 #include "asterisk/ael_structs.h"
797
798 /*
799  * A stack to keep track of matching brackets ( [ { } ] )
800  */
801 static char pbcstack[400];      /* XXX missing size checks */
802 static int pbcpos = 0;
803 static void pbcpush(char x);
804 static int pbcpop(char x);
805
806 static int parencount = 0;
807
808 /*
809  * current line, column and filename, updated as we read the input.
810  */
811 static int my_lineno = 1;       /* current line in the source */
812 static int my_col = 1;          /* current column in the source */
813 char *my_file = 0;              /* used also in the bison code */
814 char *prev_word;                /* XXX document it */
815
816 #define MAX_INCLUDE_DEPTH 50
817
818 /*
819  * flex is not too smart, and generates global functions
820  * without prototypes so the compiler may complain.
821  * To avoid that, we declare the prototypes here,
822  * even though these functions are not used.
823  */
824 int ael_yyget_column  (yyscan_t yyscanner);
825 void ael_yyset_column (int  column_no , yyscan_t yyscanner);
826
827 int ael_yyparse (struct parse_io *);
828
829 /*
830  * A stack to process include files.
831  * As we switch into the new file we need to store the previous
832  * state to restore it later.
833  */
834 struct stackelement {
835         char *fname;
836         int lineno;
837         int colno;
838         glob_t globbuf;        /* the current globbuf */
839         int globbuf_pos;   /* where we are in the current globbuf */
840         YY_BUFFER_STATE bufstate;
841 };
842
843 static struct stackelement  include_stack[MAX_INCLUDE_DEPTH];
844 static int include_stack_index = 0;
845 static void setup_filestack(char *fnamebuf, int fnamebuf_siz, glob_t *globbuf, int globpos, yyscan_t xscan, int create);
846
847 /*
848  * if we use the @n feature of bison, we must supply the start/end
849  * location of tokens in the structure pointed by yylloc.
850  * Simple tokens are just assumed to be on the same line, so
851  * the line number is constant, and the column is incremented
852  * by the length of the token.
853  */
854 #ifdef FLEX_BETA        /* set for 2.5.33 */
855
856 /* compute the total number of lines and columns in the text
857  * passed as argument.
858  */
859 static void pbcwhere(const char *text, int *line, int *col )
860 {
861         int loc_line = *line;
862         int loc_col = *col;
863         char c;
864         while ( (c = *text++) ) {
865                 if ( c == '\t' ) {
866                         loc_col += 8 - (loc_col % 8);
867                 } else if ( c == '\n' ) {
868                         loc_line++;
869                         loc_col = 1;
870                 } else
871                         loc_col++;
872         }
873         *line = loc_line;
874         *col = loc_col;
875 }
876
877 #define STORE_POS do {                                                  \
878                 yylloc->first_line = yylloc->last_line = my_lineno;     \
879                 yylloc->first_column=my_col;                            \
880                 yylloc->last_column=my_col+yyleng-1;                    \
881                 my_col+=yyleng;                                         \
882         } while (0)
883
884 #define STORE_LOC do {                                  \
885                 yylloc->first_line = my_lineno;         \
886                 yylloc->first_column=my_col;            \
887                 pbcwhere(yytext, &my_lineno, &my_col);  \
888                 yylloc->last_line = my_lineno;          \
889                 yylloc->last_column = my_col - 1;       \
890         } while (0)
891 #else
892 #define STORE_POS
893 #define STORE_LOC
894 #endif
895 #line 895 "ael_lex.c"
896
897 #define INITIAL 0
898 #define paren 1
899 #define semic 2
900 #define argg 3
901 #define comment 4
902
903 #ifndef YY_NO_UNISTD_H
904 /* Special case for "unistd.h", since it is non-ANSI. We include it way
905  * down here because we want the user's section 1 to have been scanned first.
906  * The user has a chance to override it with an option.
907  */
908 #include <unistd.h>
909 #endif
910
911 #ifndef YY_EXTRA_TYPE
912 #define YY_EXTRA_TYPE void *
913 #endif
914
915 /* Holds the entire state of the reentrant scanner. */
916 struct yyguts_t
917     {
918
919     /* User-defined. Not touched by flex. */
920     YY_EXTRA_TYPE yyextra_r;
921
922     /* The rest are the same as the globals declared in the non-reentrant scanner. */
923     FILE *yyin_r, *yyout_r;
924     size_t yy_buffer_stack_top; /**< index of top of stack. */
925     size_t yy_buffer_stack_max; /**< capacity of stack. */
926     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
927     char yy_hold_char;
928     int yy_n_chars;
929     int yyleng_r;
930     char *yy_c_buf_p;
931     int yy_init;
932     int yy_start;
933     int yy_did_buffer_switch_on_eof;
934     int yy_start_stack_ptr;
935     int yy_start_stack_depth;
936     int *yy_start_stack;
937     yy_state_type yy_last_accepting_state;
938     char* yy_last_accepting_cpos;
939
940     int yylineno_r;
941     int yy_flex_debug_r;
942
943     char *yytext_r;
944     int yy_more_flag;
945     int yy_more_len;
946
947     YYSTYPE * yylval_r;
948
949     YYLTYPE * yylloc_r;
950
951     }; /* end struct yyguts_t */
952
953 static int yy_init_globals (yyscan_t yyscanner );
954
955     /* This must go here because YYSTYPE and YYLTYPE are included
956      * from bison output in section 1.*/
957     #    define yylval yyg->yylval_r
958     
959     #    define yylloc yyg->yylloc_r
960     
961 /* Accessor methods to globals.
962    These are made visible to non-reentrant scanners for convenience. */
963
964 int ael_yylex_destroy (yyscan_t yyscanner );
965
966 int ael_yyget_debug (yyscan_t yyscanner );
967
968 void ael_yyset_debug (int debug_flag ,yyscan_t yyscanner );
969
970 YY_EXTRA_TYPE ael_yyget_extra (yyscan_t yyscanner );
971
972 void ael_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
973
974 FILE *ael_yyget_in (yyscan_t yyscanner );
975
976 void ael_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
977
978 FILE *ael_yyget_out (yyscan_t yyscanner );
979
980 void ael_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
981
982 int ael_yyget_leng (yyscan_t yyscanner );
983
984 char *ael_yyget_text (yyscan_t yyscanner );
985
986 int ael_yyget_lineno (yyscan_t yyscanner );
987
988 void ael_yyset_lineno (int line_number ,yyscan_t yyscanner );
989
990 YYSTYPE * ael_yyget_lval (yyscan_t yyscanner );
991
992 void ael_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
993
994        YYLTYPE *ael_yyget_lloc (yyscan_t yyscanner );
995     
996         void ael_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
997     
998 /* Macros after this point can all be overridden by user definitions in
999  * section 1.
1000  */
1001
1002 #ifndef YY_SKIP_YYWRAP
1003 #ifdef __cplusplus
1004 extern "C" int ael_yywrap (yyscan_t yyscanner );
1005 #else
1006 extern int ael_yywrap (yyscan_t yyscanner );
1007 #endif
1008 #endif
1009
1010     static void yyunput (int c,char *buf_ptr  ,yyscan_t yyscanner);
1011     
1012 #ifndef yytext_ptr
1013 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
1014 #endif
1015
1016 #ifdef YY_NEED_STRLEN
1017 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
1018 #endif
1019
1020 #ifndef YY_NO_INPUT
1021
1022 #ifdef __cplusplus
1023 static int yyinput (yyscan_t yyscanner );
1024 #else
1025 static int input (yyscan_t yyscanner );
1026 #endif
1027
1028 #endif
1029
1030 /* Amount of stuff to slurp up with each read. */
1031 #ifndef YY_READ_BUF_SIZE
1032 #define YY_READ_BUF_SIZE 8192
1033 #endif
1034
1035 /* Copy whatever the last rule matched to the standard output. */
1036 #ifndef ECHO
1037 /* This used to be an fputs(), but since the string might contain NUL's,
1038  * we now use fwrite().
1039  */
1040 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1041 #endif
1042
1043 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1044  * is returned in "result".
1045  */
1046 #ifndef YY_INPUT
1047 #define YY_INPUT(buf,result,max_size) \
1048         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1049                 { \
1050                 int c = '*'; \
1051                 size_t n; \
1052                 for ( n = 0; n < max_size && \
1053                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1054                         buf[n] = (char) c; \
1055                 if ( c == '\n' ) \
1056                         buf[n++] = (char) c; \
1057                 if ( c == EOF && ferror( yyin ) ) \
1058                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1059                 result = n; \
1060                 } \
1061         else \
1062                 { \
1063                 errno=0; \
1064                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1065                         { \
1066                         if( errno != EINTR) \
1067                                 { \
1068                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1069                                 break; \
1070                                 } \
1071                         errno=0; \
1072                         clearerr(yyin); \
1073                         } \
1074                 }\
1075 \
1076
1077 #endif
1078
1079 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1080  * we don't want an extra ';' after the "return" because that will cause
1081  * some compilers to complain about unreachable statements.
1082  */
1083 #ifndef yyterminate
1084 #define yyterminate() return YY_NULL
1085 #endif
1086
1087 /* Number of entries by which start-condition stack grows. */
1088 #ifndef YY_START_STACK_INCR
1089 #define YY_START_STACK_INCR 25
1090 #endif
1091
1092 /* Report a fatal error. */
1093 #ifndef YY_FATAL_ERROR
1094 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
1095 #endif
1096
1097 /* end tables serialization structures and prototypes */
1098
1099 /* Default declaration of generated scanner - a define so the user can
1100  * easily add parameters.
1101  */
1102 #ifndef YY_DECL
1103 #define YY_DECL_IS_OURS 1
1104
1105 extern int ael_yylex \
1106                (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
1107
1108 #define YY_DECL int ael_yylex \
1109                (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
1110 #endif /* !YY_DECL */
1111
1112 /* Code executed at the beginning of each rule, after yytext and yyleng
1113  * have been set up.
1114  */
1115 #ifndef YY_USER_ACTION
1116 #define YY_USER_ACTION
1117 #endif
1118
1119 /* Code executed at the end of each rule. */
1120 #ifndef YY_BREAK
1121 #define YY_BREAK break;
1122 #endif
1123
1124 #define YY_RULE_SETUP \
1125         YY_USER_ACTION
1126
1127 /** The main scanner function which does all the work.
1128  */
1129 YY_DECL
1130 {
1131         register yy_state_type yy_current_state;
1132         register char *yy_cp, *yy_bp;
1133         register int yy_act;
1134     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1135
1136 #line 181 "ael.flex"
1137
1138
1139 #line 1139 "ael_lex.c"
1140
1141     yylval = yylval_param;
1142
1143     yylloc = yylloc_param;
1144
1145         if ( yyg->yy_init )
1146                 {
1147                 yyg->yy_init = 0;
1148
1149 #ifdef YY_USER_INIT
1150                 YY_USER_INIT;
1151 #endif
1152
1153                 if ( ! yyg->yy_start )
1154                         yyg->yy_start = 1;      /* first start state */
1155
1156                 if ( ! yyin )
1157                         yyin = stdin;
1158
1159                 if ( ! yyout )
1160                         yyout = stdout;
1161
1162                 if ( ! YY_CURRENT_BUFFER ) {
1163                         ael_yyensure_buffer_stack (yyscanner);
1164                         YY_CURRENT_BUFFER_LVALUE =
1165                                 ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1166                 }
1167
1168                 ael_yy_load_buffer_state(yyscanner );
1169                 }
1170
1171         while ( 1 )             /* loops until end-of-file is reached */
1172                 {
1173                 yyg->yy_more_len = 0;
1174                 if ( yyg->yy_more_flag )
1175                         {
1176                         yyg->yy_more_len = yyg->yy_c_buf_p - yyg->yytext_ptr;
1177                         yyg->yy_more_flag = 0;
1178                         }
1179                 yy_cp = yyg->yy_c_buf_p;
1180
1181                 /* Support of yytext. */
1182                 *yy_cp = yyg->yy_hold_char;
1183
1184                 /* yy_bp points to the position in yy_ch_buf of the start of
1185                  * the current run.
1186                  */
1187                 yy_bp = yy_cp;
1188
1189                 yy_current_state = yyg->yy_start;
1190 yy_match:
1191                 do
1192                         {
1193                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1194                         if ( yy_accept[yy_current_state] )
1195                                 {
1196                                 yyg->yy_last_accepting_state = yy_current_state;
1197                                 yyg->yy_last_accepting_cpos = yy_cp;
1198                                 }
1199                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1200                                 {
1201                                 yy_current_state = (int) yy_def[yy_current_state];
1202                                 if ( yy_current_state >= 244 )
1203                                         yy_c = yy_meta[(unsigned int) yy_c];
1204                                 }
1205                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1206                         ++yy_cp;
1207                         }
1208                 while ( yy_current_state != 243 );
1209                 yy_cp = yyg->yy_last_accepting_cpos;
1210                 yy_current_state = yyg->yy_last_accepting_state;
1211
1212 yy_find_action:
1213                 yy_act = yy_accept[yy_current_state];
1214
1215                 YY_DO_BEFORE_ACTION;
1216
1217 do_action:      /* This label is used only to access EOF actions. */
1218
1219                 switch ( yy_act )
1220         { /* beginning of action switch */
1221                         case 0: /* must back up */
1222                         /* undo the effects of YY_DO_BEFORE_ACTION */
1223                         *yy_cp = yyg->yy_hold_char;
1224                         yy_cp = yyg->yy_last_accepting_cpos;
1225                         yy_current_state = yyg->yy_last_accepting_state;
1226                         goto yy_find_action;
1227
1228 case 1:
1229 YY_RULE_SETUP
1230 #line 183 "ael.flex"
1231 { STORE_POS; return LC;}
1232         YY_BREAK
1233 case 2:
1234 YY_RULE_SETUP
1235 #line 184 "ael.flex"
1236 { STORE_POS; return RC;}
1237         YY_BREAK
1238 case 3:
1239 YY_RULE_SETUP
1240 #line 185 "ael.flex"
1241 { STORE_POS; return LP;}
1242         YY_BREAK
1243 case 4:
1244 YY_RULE_SETUP
1245 #line 186 "ael.flex"
1246 { STORE_POS; return RP;}
1247         YY_BREAK
1248 case 5:
1249 YY_RULE_SETUP
1250 #line 187 "ael.flex"
1251 { STORE_POS; return SEMI;}
1252         YY_BREAK
1253 case 6:
1254 YY_RULE_SETUP
1255 #line 188 "ael.flex"
1256 { STORE_POS; return EQ;}
1257         YY_BREAK
1258 case 7:
1259 YY_RULE_SETUP
1260 #line 189 "ael.flex"
1261 { STORE_POS; return COMMA;}
1262         YY_BREAK
1263 case 8:
1264 YY_RULE_SETUP
1265 #line 190 "ael.flex"
1266 { STORE_POS; return COLON;}
1267         YY_BREAK
1268 case 9:
1269 YY_RULE_SETUP
1270 #line 191 "ael.flex"
1271 { STORE_POS; return AMPER;}
1272         YY_BREAK
1273 case 10:
1274 YY_RULE_SETUP
1275 #line 192 "ael.flex"
1276 { STORE_POS; return BAR;}
1277         YY_BREAK
1278 case 11:
1279 YY_RULE_SETUP
1280 #line 193 "ael.flex"
1281 { STORE_POS; return EXTENMARK;}
1282         YY_BREAK
1283 case 12:
1284 YY_RULE_SETUP
1285 #line 194 "ael.flex"
1286 { STORE_POS; return AT;}
1287         YY_BREAK
1288 case 13:
1289 YY_RULE_SETUP
1290 #line 195 "ael.flex"
1291 {/*comment*/}
1292         YY_BREAK
1293 case 14:
1294 YY_RULE_SETUP
1295 #line 196 "ael.flex"
1296 { STORE_POS; return KW_CONTEXT;}
1297         YY_BREAK
1298 case 15:
1299 YY_RULE_SETUP
1300 #line 197 "ael.flex"
1301 { STORE_POS; return KW_ABSTRACT;}
1302         YY_BREAK
1303 case 16:
1304 YY_RULE_SETUP
1305 #line 198 "ael.flex"
1306 { STORE_POS; return KW_EXTEND;}
1307         YY_BREAK
1308 case 17:
1309 YY_RULE_SETUP
1310 #line 199 "ael.flex"
1311 { STORE_POS; return KW_MACRO;};
1312         YY_BREAK
1313 case 18:
1314 YY_RULE_SETUP
1315 #line 200 "ael.flex"
1316 { STORE_POS; return KW_GLOBALS;}
1317         YY_BREAK
1318 case 19:
1319 YY_RULE_SETUP
1320 #line 201 "ael.flex"
1321 { STORE_POS; return KW_LOCAL;}
1322         YY_BREAK
1323 case 20:
1324 YY_RULE_SETUP
1325 #line 202 "ael.flex"
1326 { STORE_POS; return KW_IGNOREPAT;}
1327         YY_BREAK
1328 case 21:
1329 YY_RULE_SETUP
1330 #line 203 "ael.flex"
1331 { STORE_POS; return KW_SWITCH;}
1332         YY_BREAK
1333 case 22:
1334 YY_RULE_SETUP
1335 #line 204 "ael.flex"
1336 { STORE_POS; return KW_IF;}
1337         YY_BREAK
1338 case 23:
1339 YY_RULE_SETUP
1340 #line 205 "ael.flex"
1341 { STORE_POS; return KW_IFTIME;}
1342         YY_BREAK
1343 case 24:
1344 YY_RULE_SETUP
1345 #line 206 "ael.flex"
1346 { STORE_POS; return KW_RANDOM;}
1347         YY_BREAK
1348 case 25:
1349 YY_RULE_SETUP
1350 #line 207 "ael.flex"
1351 { STORE_POS; return KW_REGEXTEN;}
1352         YY_BREAK
1353 case 26:
1354 YY_RULE_SETUP
1355 #line 208 "ael.flex"
1356 { STORE_POS; return KW_HINT;}
1357         YY_BREAK
1358 case 27:
1359 YY_RULE_SETUP
1360 #line 209 "ael.flex"
1361 { STORE_POS; return KW_ELSE;}
1362         YY_BREAK
1363 case 28:
1364 YY_RULE_SETUP
1365 #line 210 "ael.flex"
1366 { STORE_POS; return KW_GOTO;}
1367         YY_BREAK
1368 case 29:
1369 YY_RULE_SETUP
1370 #line 211 "ael.flex"
1371 { STORE_POS; return KW_JUMP;}
1372         YY_BREAK
1373 case 30:
1374 YY_RULE_SETUP
1375 #line 212 "ael.flex"
1376 { STORE_POS; return KW_RETURN;}
1377         YY_BREAK
1378 case 31:
1379 YY_RULE_SETUP
1380 #line 213 "ael.flex"
1381 { STORE_POS; return KW_BREAK;}
1382         YY_BREAK
1383 case 32:
1384 YY_RULE_SETUP
1385 #line 214 "ael.flex"
1386 { STORE_POS; return KW_CONTINUE;}
1387         YY_BREAK
1388 case 33:
1389 YY_RULE_SETUP
1390 #line 215 "ael.flex"
1391 { STORE_POS; return KW_FOR;}
1392         YY_BREAK
1393 case 34:
1394 YY_RULE_SETUP
1395 #line 216 "ael.flex"
1396 { STORE_POS; return KW_WHILE;}
1397         YY_BREAK
1398 case 35:
1399 YY_RULE_SETUP
1400 #line 217 "ael.flex"
1401 { STORE_POS; return KW_CASE;}
1402         YY_BREAK
1403 case 36:
1404 YY_RULE_SETUP
1405 #line 218 "ael.flex"
1406 { STORE_POS; return KW_DEFAULT;}
1407         YY_BREAK
1408 case 37:
1409 YY_RULE_SETUP
1410 #line 219 "ael.flex"
1411 { STORE_POS; return KW_PATTERN;}
1412         YY_BREAK
1413 case 38:
1414 YY_RULE_SETUP
1415 #line 220 "ael.flex"
1416 { STORE_POS; return KW_CATCH;}
1417         YY_BREAK
1418 case 39:
1419 YY_RULE_SETUP
1420 #line 221 "ael.flex"
1421 { STORE_POS; return KW_SWITCHES;}
1422         YY_BREAK
1423 case 40:
1424 YY_RULE_SETUP
1425 #line 222 "ael.flex"
1426 { STORE_POS; return KW_ESWITCHES;}
1427         YY_BREAK
1428 case 41:
1429 YY_RULE_SETUP
1430 #line 223 "ael.flex"
1431 { STORE_POS; return KW_INCLUDES;}
1432         YY_BREAK
1433 case 42:
1434 YY_RULE_SETUP
1435 #line 224 "ael.flex"
1436 { BEGIN(comment); my_col += 2; }
1437         YY_BREAK
1438 case 43:
1439 YY_RULE_SETUP
1440 #line 226 "ael.flex"
1441 { my_col += yyleng; }
1442         YY_BREAK
1443 case 44:
1444 /* rule 44 can match eol */
1445 YY_RULE_SETUP
1446 #line 227 "ael.flex"
1447 { ++my_lineno; my_col=1;}
1448         YY_BREAK
1449 case 45:
1450 YY_RULE_SETUP
1451 #line 228 "ael.flex"
1452 { my_col += yyleng; }
1453         YY_BREAK
1454 case 46:
1455 /* rule 46 can match eol */
1456 YY_RULE_SETUP
1457 #line 229 "ael.flex"
1458 { ++my_lineno; my_col=1;}
1459         YY_BREAK
1460 case 47:
1461 YY_RULE_SETUP
1462 #line 230 "ael.flex"
1463 { my_col += 2; BEGIN(INITIAL); }
1464         YY_BREAK
1465 case 48:
1466 /* rule 48 can match eol */
1467 YY_RULE_SETUP
1468 #line 232 "ael.flex"
1469 { my_lineno++; my_col = 1; }
1470         YY_BREAK
1471 case 49:
1472 YY_RULE_SETUP
1473 #line 233 "ael.flex"
1474 { my_col += yyleng; }
1475         YY_BREAK
1476 case 50:
1477 YY_RULE_SETUP
1478 #line 234 "ael.flex"
1479 { my_col += (yyleng*8)-(my_col%8); }
1480         YY_BREAK
1481 case 51:
1482 YY_RULE_SETUP
1483 #line 236 "ael.flex"
1484 {
1485                 STORE_POS;
1486                 yylval->str = strdup(yytext);
1487                 prev_word = yylval->str;
1488                 return word;
1489         }
1490         YY_BREAK
1491 /*
1492          * context used for arguments of if_head, random_head, switch_head,
1493          * for (last statement), while (XXX why not iftime_head ?).
1494          * End with the matching parentheses.
1495          * A comma at the top level is valid here, unlike in argg where it
1496          * is an argument separator so it must be returned as a token.
1497          */
1498 case 52:
1499 /* rule 52 can match eol */
1500 YY_RULE_SETUP
1501 #line 252 "ael.flex"
1502 {
1503                 if ( pbcpop(')') ) {    /* error */
1504                         STORE_LOC;
1505                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression: %s !\n", my_file, my_lineno, my_col, yytext);
1506                         BEGIN(0);
1507                         yylval->str = strdup(yytext);
1508                         prev_word = 0;
1509                         return word;
1510                 }
1511                 parencount--;
1512                 if ( parencount >= 0) {
1513                         yymore();
1514                 } else {
1515                         STORE_LOC;
1516                         yylval->str = strdup(yytext);
1517                         yylval->str[yyleng-1] = '\0'; /* trim trailing ')' */
1518                         unput(')');
1519                         BEGIN(0);
1520                         return word;
1521                 }
1522         }
1523         YY_BREAK
1524 case 53:
1525 /* rule 53 can match eol */
1526 YY_RULE_SETUP
1527 #line 274 "ael.flex"
1528 {
1529                 char c = yytext[yyleng-1];
1530                 if (c == '(')
1531                         parencount++;
1532                 pbcpush(c);
1533                 yymore();
1534         }
1535         YY_BREAK
1536 case 54:
1537 /* rule 54 can match eol */
1538 YY_RULE_SETUP
1539 #line 282 "ael.flex"
1540 {
1541                 char c = yytext[yyleng-1];
1542                 if ( pbcpop(c))  { /* error */
1543                         STORE_LOC;
1544                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n",
1545                                 my_file, my_lineno, my_col, c);
1546                         BEGIN(0);
1547                         yylval->str = strdup(yytext);
1548                         return word;
1549                 }
1550                 yymore();
1551         }
1552         YY_BREAK
1553 /*
1554          * handlers for arguments to a macro or application calls.
1555          * We enter this context when we find the initial '(' and
1556          * stay here until we close all matching parentheses,
1557          * and find the comma (argument separator) or the closing ')'
1558          * of the (external) call, which happens when parencount == 0
1559          * before the decrement.
1560          */
1561 case 55:
1562 /* rule 55 can match eol */
1563 YY_RULE_SETUP
1564 #line 304 "ael.flex"
1565 {
1566                 char c = yytext[yyleng-1];
1567                 if (c == '(')
1568                         parencount++;
1569                 pbcpush(c);
1570                 yymore();
1571         }
1572         YY_BREAK
1573 case 56:
1574 /* rule 56 can match eol */
1575 YY_RULE_SETUP
1576 #line 312 "ael.flex"
1577 {
1578                 if ( pbcpop(')') ) { /* error */
1579                         STORE_LOC;
1580                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression!\n", my_file, my_lineno, my_col);
1581                         BEGIN(0);
1582                         yylval->str = strdup(yytext);
1583                         return word;
1584                 }
1585
1586                 parencount--;
1587                 if( parencount >= 0){
1588                         yymore();
1589                 } else {
1590                         STORE_LOC;
1591                         BEGIN(0);
1592                         if ( !strcmp(yytext, ")") )
1593                                 return RP;
1594                         yylval->str = strdup(yytext);
1595                         yylval->str[yyleng-1] = '\0'; /* trim trailing ')' */
1596                         unput(')');
1597                         return word;
1598                 }
1599         }
1600         YY_BREAK
1601 case 57:
1602 /* rule 57 can match eol */
1603 YY_RULE_SETUP
1604 #line 336 "ael.flex"
1605 {
1606                 if( parencount != 0) { /* printf("Folding in a comma!\n"); */
1607                         yymore();
1608                 } else  {
1609                         STORE_LOC;
1610                         if( !strcmp(yytext,"," ) )
1611                                 return COMMA;
1612                         yylval->str = strdup(yytext);
1613                         yylval->str[yyleng-1] = '\0';
1614                         unput(',');
1615                         return word;
1616                 }
1617         }
1618         YY_BREAK
1619 case 58:
1620 /* rule 58 can match eol */
1621 YY_RULE_SETUP
1622 #line 350 "ael.flex"
1623 {
1624                 char c = yytext[yyleng-1];
1625                 if ( pbcpop(c) ) { /* error */
1626                         STORE_LOC;
1627                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n", my_file, my_lineno, my_col, c);
1628                         BEGIN(0);
1629                         yylval->str = strdup(yytext);
1630                         return word;
1631                 }
1632                 yymore();
1633         }
1634         YY_BREAK
1635 /*
1636          * context used to find tokens in the right hand side of assignments,
1637          * or in the first and second operand of a 'for'. As above, match
1638          * commas and use ';' as a separator (hence return it as a separate token).
1639          */
1640 case 59:
1641 /* rule 59 can match eol */
1642 YY_RULE_SETUP
1643 #line 367 "ael.flex"
1644 {
1645                 char c = yytext[yyleng-1];
1646                 yymore();
1647                 pbcpush(c);
1648         }
1649         YY_BREAK
1650 case 60:
1651 /* rule 60 can match eol */
1652 YY_RULE_SETUP
1653 #line 373 "ael.flex"
1654 {
1655                 char c = yytext[yyleng-1];
1656                 if ( pbcpop(c) ) { /* error */
1657                         STORE_LOC;
1658                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n", my_file, my_lineno, my_col, c);
1659                         BEGIN(0);
1660                         yylval->str = strdup(yytext);
1661                         return word;
1662                 }
1663                 yymore();
1664         }
1665         YY_BREAK
1666 case 61:
1667 /* rule 61 can match eol */
1668 YY_RULE_SETUP
1669 #line 385 "ael.flex"
1670 {
1671                 STORE_LOC;
1672                 yylval->str = strdup(yytext);
1673                 yylval->str[yyleng-1] = '\0';
1674                 unput(';');
1675                 BEGIN(0);
1676                 return word;
1677         }
1678         YY_BREAK
1679 case 62:
1680 /* rule 62 can match eol */
1681 YY_RULE_SETUP
1682 #line 394 "ael.flex"
1683 {
1684                 char fnamebuf[1024],*p1,*p2;
1685                 int glob_ret;
1686                 glob_t globbuf;        /* the current globbuf */
1687                 int globbuf_pos = -1;   /* where we are in the current globbuf */
1688                 globbuf.gl_offs = 0;    /* initialize it to silence gcc */
1689                 
1690                 p1 = strchr(yytext,'"');
1691                 p2 = strrchr(yytext,'"');
1692                 if ( include_stack_index >= MAX_INCLUDE_DEPTH ) {
1693                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Includes nested too deeply! Wow!!! How did you do that?\n", my_file, my_lineno, my_col);
1694                 } else if ( (int)(p2-p1) > sizeof(fnamebuf) - 1 ) {
1695                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Filename is incredibly way too long (%d chars!). Inclusion ignored!\n", my_file, my_lineno, my_col, yyleng - 10);
1696                 } else {
1697                         strncpy(fnamebuf, p1+1, p2-p1-1);
1698                         fnamebuf[p2-p1-1] = 0;
1699                 if (fnamebuf[0] != '/') {
1700                    char fnamebuf2[1024];
1701                    snprintf(fnamebuf2,sizeof(fnamebuf2), "%s/%s", (char *)ast_config_AST_CONFIG_DIR, fnamebuf);
1702                    ast_copy_string(fnamebuf,fnamebuf2,sizeof(fnamebuf));
1703                 }
1704 #ifdef SOLARIS
1705                         glob_ret = glob(fnamebuf, GLOB_NOCHECK, NULL, &globbuf);
1706 #else
1707                         glob_ret = glob(fnamebuf, GLOB_NOMAGIC|GLOB_BRACE, NULL, &globbuf);
1708 #endif
1709                         if (glob_ret == GLOB_NOSPACE) {
1710                                 ast_log(LOG_WARNING,
1711                                         "Glob Expansion of pattern '%s' failed: Not enough memory\n", fnamebuf);
1712                         } else if (glob_ret  == GLOB_ABORTED) {
1713                                 ast_log(LOG_WARNING,
1714                                         "Glob Expansion of pattern '%s' failed: Read error\n", fnamebuf);
1715                         } else if (glob_ret  == GLOB_NOMATCH) {
1716                                 ast_log(LOG_WARNING,
1717                                         "Glob Expansion of pattern '%s' failed: No matches!\n", fnamebuf);
1718                         } else {
1719                           globbuf_pos = 0;
1720                         }
1721                 }
1722                 if (globbuf_pos > -1) {
1723                         setup_filestack(fnamebuf, sizeof(fnamebuf), &globbuf, 0, yyscanner, 1);
1724                 }
1725         }
1726         YY_BREAK
1727 case YY_STATE_EOF(INITIAL):
1728 case YY_STATE_EOF(paren):
1729 case YY_STATE_EOF(semic):
1730 case YY_STATE_EOF(argg):
1731 case YY_STATE_EOF(comment):
1732 #line 439 "ael.flex"
1733 {
1734                 char fnamebuf[2048];
1735                 if (include_stack_index > 0 && include_stack[include_stack_index-1].globbuf_pos < include_stack[include_stack_index-1].globbuf.gl_pathc-1) {
1736                         free(my_file);
1737                         my_file = 0;
1738                         ael_yy_delete_buffer(YY_CURRENT_BUFFER,yyscanner );
1739                         include_stack[include_stack_index-1].globbuf_pos++;
1740                         setup_filestack(fnamebuf, sizeof(fnamebuf), &include_stack[include_stack_index-1].globbuf, include_stack[include_stack_index-1].globbuf_pos, yyscanner, 0);
1741                         /* finish this */                       
1742                         
1743                 } else {
1744                         if (include_stack[include_stack_index].fname) {
1745                                 free(include_stack[include_stack_index].fname);
1746                                 include_stack[include_stack_index].fname = 0;
1747                         }
1748                         if ( --include_stack_index < 0 ) {
1749                                 yyterminate();
1750                         } else {
1751                                 if (my_file) {
1752                                         free(my_file);
1753                                         my_file = 0;
1754                                 }
1755                                 globfree(&include_stack[include_stack_index].globbuf);
1756                                 include_stack[include_stack_index].globbuf_pos = -1;
1757                                 
1758                                 ael_yy_delete_buffer(YY_CURRENT_BUFFER,yyscanner );
1759                                 ael_yy_switch_to_buffer(include_stack[include_stack_index].bufstate,yyscanner );
1760                                 my_lineno = include_stack[include_stack_index].lineno;
1761                                 my_col    = include_stack[include_stack_index].colno;
1762                                 my_file   = strdup(include_stack[include_stack_index].fname);
1763                         }
1764                 }
1765         }
1766         YY_BREAK
1767 case 63:
1768 YY_RULE_SETUP
1769 #line 473 "ael.flex"
1770 ECHO;
1771         YY_BREAK
1772 #line 1772 "ael_lex.c"
1773
1774         case YY_END_OF_BUFFER:
1775                 {
1776                 /* Amount of text matched not including the EOB char. */
1777                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1778
1779                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1780                 *yy_cp = yyg->yy_hold_char;
1781                 YY_RESTORE_YY_MORE_OFFSET
1782
1783                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1784                         {
1785                         /* We're scanning a new file or input source.  It's
1786                          * possible that this happened because the user
1787                          * just pointed yyin at a new source and called
1788                          * ael_yylex().  If so, then we have to assure
1789                          * consistency between YY_CURRENT_BUFFER and our
1790                          * globals.  Here is the right place to do so, because
1791                          * this is the first action (other than possibly a
1792                          * back-up) that will match for the new input source.
1793                          */
1794                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1795                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1796                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1797                         }
1798
1799                 /* Note that here we test for yy_c_buf_p "<=" to the position
1800                  * of the first EOB in the buffer, since yy_c_buf_p will
1801                  * already have been incremented past the NUL character
1802                  * (since all states make transitions on EOB to the
1803                  * end-of-buffer state).  Contrast this with the test
1804                  * in input().
1805                  */
1806                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1807                         { /* This was really a NUL. */
1808                         yy_state_type yy_next_state;
1809
1810                         yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1811
1812                         yy_current_state = yy_get_previous_state( yyscanner );
1813
1814                         /* Okay, we're now positioned to make the NUL
1815                          * transition.  We couldn't have
1816                          * yy_get_previous_state() go ahead and do it
1817                          * for us because it doesn't know how to deal
1818                          * with the possibility of jamming (and we don't
1819                          * want to build jamming into it because then it
1820                          * will run more slowly).
1821                          */
1822
1823                         yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1824
1825                         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1826
1827                         if ( yy_next_state )
1828                                 {
1829                                 /* Consume the NUL. */
1830                                 yy_cp = ++yyg->yy_c_buf_p;
1831                                 yy_current_state = yy_next_state;
1832                                 goto yy_match;
1833                                 }
1834
1835                         else
1836                                 {
1837                                 yy_cp = yyg->yy_last_accepting_cpos;
1838                                 yy_current_state = yyg->yy_last_accepting_state;
1839                                 goto yy_find_action;
1840                                 }
1841                         }
1842
1843                 else switch ( yy_get_next_buffer( yyscanner ) )
1844                         {
1845                         case EOB_ACT_END_OF_FILE:
1846                                 {
1847                                 yyg->yy_did_buffer_switch_on_eof = 0;
1848
1849                                 if ( ael_yywrap(yyscanner ) )
1850                                         {
1851                                         /* Note: because we've taken care in
1852                                          * yy_get_next_buffer() to have set up
1853                                          * yytext, we can now set up
1854                                          * yy_c_buf_p so that if some total
1855                                          * hoser (like flex itself) wants to
1856                                          * call the scanner after we return the
1857                                          * YY_NULL, it'll still work - another
1858                                          * YY_NULL will get returned.
1859                                          */
1860                                         yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1861
1862                                         yy_act = YY_STATE_EOF(YY_START);
1863                                         goto do_action;
1864                                         }
1865
1866                                 else
1867                                         {
1868                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
1869                                                 YY_NEW_FILE;
1870                                         }
1871                                 break;
1872                                 }
1873
1874                         case EOB_ACT_CONTINUE_SCAN:
1875                                 yyg->yy_c_buf_p =
1876                                         yyg->yytext_ptr + yy_amount_of_matched_text;
1877
1878                                 yy_current_state = yy_get_previous_state( yyscanner );
1879
1880                                 yy_cp = yyg->yy_c_buf_p;
1881                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1882                                 goto yy_match;
1883
1884                         case EOB_ACT_LAST_MATCH:
1885                                 yyg->yy_c_buf_p =
1886                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1887
1888                                 yy_current_state = yy_get_previous_state( yyscanner );
1889
1890                                 yy_cp = yyg->yy_c_buf_p;
1891                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1892                                 goto yy_find_action;
1893                         }
1894                 break;
1895                 }
1896
1897         default:
1898                 YY_FATAL_ERROR(
1899                         "fatal flex scanner internal error--no action found" );
1900         } /* end of action switch */
1901                 } /* end of scanning one token */
1902 } /* end of ael_yylex */
1903
1904 /* yy_get_next_buffer - try to read in a new buffer
1905  *
1906  * Returns a code representing an action:
1907  *      EOB_ACT_LAST_MATCH -
1908  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1909  *      EOB_ACT_END_OF_FILE - end of file
1910  */
1911 static int yy_get_next_buffer (yyscan_t yyscanner)
1912 {
1913     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1914         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1915         register char *source = yyg->yytext_ptr;
1916         register int number_to_move, i;
1917         int ret_val;
1918
1919         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1920                 YY_FATAL_ERROR(
1921                 "fatal flex scanner internal error--end of buffer missed" );
1922
1923         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1924                 { /* Don't try to fill the buffer, so this is an EOF. */
1925                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1926                         {
1927                         /* We matched a single character, the EOB, so
1928                          * treat this as a final EOF.
1929                          */
1930                         return EOB_ACT_END_OF_FILE;
1931                         }
1932
1933                 else
1934                         {
1935                         /* We matched some text prior to the EOB, first
1936                          * process it.
1937                          */
1938                         return EOB_ACT_LAST_MATCH;
1939                         }
1940                 }
1941
1942         /* Try to read more data. */
1943
1944         /* First move last chars to start of buffer. */
1945         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1946
1947         for ( i = 0; i < number_to_move; ++i )
1948                 *(dest++) = *(source++);
1949
1950         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1951                 /* don't do the read, it's not guaranteed to return an EOF,
1952                  * just force an EOF
1953                  */
1954                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1955
1956         else
1957                 {
1958                         int num_to_read =
1959                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1960
1961                 while ( num_to_read <= 0 )
1962                         { /* Not enough room in the buffer - grow it. */
1963
1964                         /* just a shorter name for the current buffer */
1965                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1966
1967                         int yy_c_buf_p_offset =
1968                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1969
1970                         if ( b->yy_is_our_buffer )
1971                                 {
1972                                 int new_size = b->yy_buf_size * 2;
1973
1974                                 if ( new_size <= 0 )
1975                                         b->yy_buf_size += b->yy_buf_size / 8;
1976                                 else
1977                                         b->yy_buf_size *= 2;
1978
1979                                 b->yy_ch_buf = (char *)
1980                                         /* Include room in for 2 EOB chars. */
1981                                         ael_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1982                                 }
1983                         else
1984                                 /* Can't grow it, we don't own it. */
1985                                 b->yy_ch_buf = 0;
1986
1987                         if ( ! b->yy_ch_buf )
1988                                 YY_FATAL_ERROR(
1989                                 "fatal error - scanner input buffer overflow" );
1990
1991                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1992
1993                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1994                                                 number_to_move - 1;
1995
1996                         }
1997
1998                 if ( num_to_read > YY_READ_BUF_SIZE )
1999                         num_to_read = YY_READ_BUF_SIZE;
2000
2001                 /* Read in more data. */
2002                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2003                         yyg->yy_n_chars, num_to_read );
2004
2005                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2006                 }
2007
2008         if ( yyg->yy_n_chars == 0 )
2009                 {
2010                 if ( number_to_move == YY_MORE_ADJ )
2011                         {
2012                         ret_val = EOB_ACT_END_OF_FILE;
2013                         ael_yyrestart(yyin  ,yyscanner);
2014                         }
2015
2016                 else
2017                         {
2018                         ret_val = EOB_ACT_LAST_MATCH;
2019                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2020                                 YY_BUFFER_EOF_PENDING;
2021                         }
2022                 }
2023
2024         else
2025                 ret_val = EOB_ACT_CONTINUE_SCAN;
2026
2027         yyg->yy_n_chars += number_to_move;
2028         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2029         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2030
2031         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2032
2033         return ret_val;
2034 }
2035
2036 /* yy_get_previous_state - get the state just before the EOB char was reached */
2037
2038     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
2039 {
2040         register yy_state_type yy_current_state;
2041         register char *yy_cp;
2042     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2043
2044         yy_current_state = yyg->yy_start;
2045
2046         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
2047                 {
2048                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2049                 if ( yy_accept[yy_current_state] )
2050                         {
2051                         yyg->yy_last_accepting_state = yy_current_state;
2052                         yyg->yy_last_accepting_cpos = yy_cp;
2053                         }
2054                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2055                         {
2056                         yy_current_state = (int) yy_def[yy_current_state];
2057                         if ( yy_current_state >= 244 )
2058                                 yy_c = yy_meta[(unsigned int) yy_c];
2059                         }
2060                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2061                 }
2062
2063         return yy_current_state;
2064 }
2065
2066 /* yy_try_NUL_trans - try to make a transition on the NUL character
2067  *
2068  * synopsis
2069  *      next_state = yy_try_NUL_trans( current_state );
2070  */
2071     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
2072 {
2073         register int yy_is_jam;
2074     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2075         register char *yy_cp = yyg->yy_c_buf_p;
2076
2077         register YY_CHAR yy_c = 1;
2078         if ( yy_accept[yy_current_state] )
2079                 {
2080                 yyg->yy_last_accepting_state = yy_current_state;
2081                 yyg->yy_last_accepting_cpos = yy_cp;
2082                 }
2083         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2084                 {
2085                 yy_current_state = (int) yy_def[yy_current_state];
2086                 if ( yy_current_state >= 244 )
2087                         yy_c = yy_meta[(unsigned int) yy_c];
2088                 }
2089         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2090         yy_is_jam = (yy_current_state == 243);
2091
2092         return yy_is_jam ? 0 : yy_current_state;
2093 }
2094
2095     static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
2096 {
2097         register char *yy_cp;
2098     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2099
2100     yy_cp = yyg->yy_c_buf_p;
2101
2102         /* undo effects of setting up yytext */
2103         *yy_cp = yyg->yy_hold_char;
2104
2105         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2106                 { /* need to shift things up to make room */
2107                 /* +2 for EOB chars. */
2108                 register int number_to_move = yyg->yy_n_chars + 2;
2109                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2110                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2111                 register char *source =
2112                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2113
2114                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2115                         *--dest = *--source;
2116
2117                 yy_cp += (int) (dest - source);
2118                 yy_bp += (int) (dest - source);
2119                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2120                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2121
2122                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2123                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2124                 }
2125
2126         *--yy_cp = (char) c;
2127
2128         yyg->yytext_ptr = yy_bp;
2129         yyg->yy_hold_char = *yy_cp;
2130         yyg->yy_c_buf_p = yy_cp;
2131 }
2132
2133 #ifndef YY_NO_INPUT
2134 #ifdef __cplusplus
2135     static int yyinput (yyscan_t yyscanner)
2136 #else
2137     static int input  (yyscan_t yyscanner)
2138 #endif
2139
2140 {
2141         int c;
2142     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2143
2144         *yyg->yy_c_buf_p = yyg->yy_hold_char;
2145
2146         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2147                 {
2148                 /* yy_c_buf_p now points to the character we want to return.
2149                  * If this occurs *before* the EOB characters, then it's a
2150                  * valid NUL; if not, then we've hit the end of the buffer.
2151                  */
2152                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
2153                         /* This was really a NUL. */
2154                         *yyg->yy_c_buf_p = '\0';
2155
2156                 else
2157                         { /* need more input */
2158                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
2159                         ++yyg->yy_c_buf_p;
2160
2161                         switch ( yy_get_next_buffer( yyscanner ) )
2162                                 {
2163                                 case EOB_ACT_LAST_MATCH:
2164                                         /* This happens because yy_g_n_b()
2165                                          * sees that we've accumulated a
2166                                          * token and flags that we need to
2167                                          * try matching the token before
2168                                          * proceeding.  But for input(),
2169                                          * there's no matching to consider.
2170                                          * So convert the EOB_ACT_LAST_MATCH
2171                                          * to EOB_ACT_END_OF_FILE.
2172                                          */
2173
2174                                         /* Reset buffer status. */
2175                                         ael_yyrestart(yyin ,yyscanner);
2176
2177                                         /*FALLTHROUGH*/
2178
2179                                 case EOB_ACT_END_OF_FILE:
2180                                         {
2181                                         if ( ael_yywrap(yyscanner ) )
2182                                                 return EOF;
2183
2184                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
2185                                                 YY_NEW_FILE;
2186 #ifdef __cplusplus
2187                                         return yyinput(yyscanner);
2188 #else
2189                                         return input(yyscanner);
2190 #endif
2191                                         }
2192
2193                                 case EOB_ACT_CONTINUE_SCAN:
2194                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
2195                                         break;
2196                                 }
2197                         }
2198                 }
2199
2200         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
2201         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
2202         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
2203
2204         return c;
2205 }
2206 #endif  /* ifndef YY_NO_INPUT */
2207
2208 /** Immediately switch to a different input stream.
2209  * @param input_file A readable stream.
2210  * @param yyscanner The scanner object.
2211  * @note This function does not reset the start condition to @c INITIAL .
2212  */
2213     void ael_yyrestart  (FILE * input_file , yyscan_t yyscanner)
2214 {
2215     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2216
2217         if ( ! YY_CURRENT_BUFFER ){
2218         ael_yyensure_buffer_stack (yyscanner);
2219                 YY_CURRENT_BUFFER_LVALUE =
2220             ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
2221         }
2222
2223         ael_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
2224         ael_yy_load_buffer_state(yyscanner );
2225 }
2226
2227 /** Switch to a different input buffer.
2228  * @param new_buffer The new input buffer.
2229  * @param yyscanner The scanner object.
2230  */
2231     void ael_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
2232 {
2233     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2234
2235         /* TODO. We should be able to replace this entire function body
2236          * with
2237          *              ael_yypop_buffer_state();
2238          *              ael_yypush_buffer_state(new_buffer);
2239      */
2240         ael_yyensure_buffer_stack (yyscanner);
2241         if ( YY_CURRENT_BUFFER == new_buffer )
2242                 return;
2243
2244         if ( YY_CURRENT_BUFFER )
2245                 {
2246                 /* Flush out information for old buffer. */
2247                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2248                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2249                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2250                 }
2251
2252         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2253         ael_yy_load_buffer_state(yyscanner );
2254
2255         /* We don't actually know whether we did this switch during
2256          * EOF (ael_yywrap()) processing, but the only time this flag
2257          * is looked at is after ael_yywrap() is called, so it's safe
2258          * to go ahead and always set it.
2259          */
2260         yyg->yy_did_buffer_switch_on_eof = 1;
2261 }
2262
2263 static void ael_yy_load_buffer_state  (yyscan_t yyscanner)
2264 {
2265     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2266         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2267         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2268         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2269         yyg->yy_hold_char = *yyg->yy_c_buf_p;
2270 }
2271
2272 /** Allocate and initialize an input buffer state.
2273  * @param file A readable stream.
2274  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2275  * @param yyscanner The scanner object.
2276  * @return the allocated buffer state.
2277  */
2278     YY_BUFFER_STATE ael_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
2279 {
2280         YY_BUFFER_STATE b;
2281     
2282         b = (YY_BUFFER_STATE) ael_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2283         if ( ! b )
2284                 YY_FATAL_ERROR( "out of dynamic memory in ael_yy_create_buffer()" );
2285
2286         b->yy_buf_size = size;
2287
2288         /* yy_ch_buf has to be 2 characters longer than the size given because
2289          * we need to put in 2 end-of-buffer characters.
2290          */
2291         b->yy_ch_buf = (char *) ael_yyalloc(b->yy_buf_size + 2 ,yyscanner );
2292         if ( ! b->yy_ch_buf )
2293                 YY_FATAL_ERROR( "out of dynamic memory in ael_yy_create_buffer()" );
2294
2295         b->yy_is_our_buffer = 1;
2296
2297         ael_yy_init_buffer(b,file ,yyscanner);
2298
2299         return b;
2300 }
2301
2302 /** Destroy the buffer.
2303  * @param b a buffer created with ael_yy_create_buffer()
2304  * @param yyscanner The scanner object.
2305  */
2306     void ael_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
2307 {
2308     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2309
2310         if ( ! b )
2311                 return;
2312
2313         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2314                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2315
2316         if ( b->yy_is_our_buffer )
2317                 ael_yyfree((void *) b->yy_ch_buf ,yyscanner );
2318
2319         ael_yyfree((void *) b ,yyscanner );
2320 }
2321
2322 #ifndef __cplusplus
2323 extern int isatty (int );
2324 #endif /* __cplusplus */
2325     
2326 /* Initializes or reinitializes a buffer.
2327  * This function is sometimes called more than once on the same buffer,
2328  * such as during a ael_yyrestart() or at EOF.
2329  */
2330     static void ael_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
2331
2332 {
2333         int oerrno = errno;
2334     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2335
2336         ael_yy_flush_buffer(b ,yyscanner);
2337
2338         b->yy_input_file = file;
2339         b->yy_fill_buffer = 1;
2340
2341     /* If b is the current buffer, then ael_yy_init_buffer was _probably_
2342      * called from ael_yyrestart() or through yy_get_next_buffer.
2343      * In that case, we don't want to reset the lineno or column.
2344      */
2345     if (b != YY_CURRENT_BUFFER){
2346         b->yy_bs_lineno = 1;
2347         b->yy_bs_column = 0;
2348     }
2349
2350         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2351     
2352         errno = oerrno;
2353 }
2354
2355 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2356  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2357  * @param yyscanner The scanner object.
2358  */
2359     void ael_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
2360 {
2361     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2362         if ( ! b )
2363                 return;
2364
2365         b->yy_n_chars = 0;
2366
2367         /* We always need two end-of-buffer characters.  The first causes
2368          * a transition to the end-of-buffer state.  The second causes
2369          * a jam in that state.
2370          */
2371         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2372         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2373
2374         b->yy_buf_pos = &b->yy_ch_buf[0];
2375
2376         b->yy_at_bol = 1;
2377         b->yy_buffer_status = YY_BUFFER_NEW;
2378
2379         if ( b == YY_CURRENT_BUFFER )
2380                 ael_yy_load_buffer_state(yyscanner );
2381 }
2382
2383 /** Pushes the new state onto the stack. The new state becomes
2384  *  the current state. This function will allocate the stack
2385  *  if necessary.
2386  *  @param new_buffer The new state.
2387  *  @param yyscanner The scanner object.
2388  */
2389 void ael_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2390 {
2391     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2392         if (new_buffer == NULL)
2393                 return;
2394
2395         ael_yyensure_buffer_stack(yyscanner);
2396
2397         /* This block is copied from ael_yy_switch_to_buffer. */
2398         if ( YY_CURRENT_BUFFER )
2399                 {
2400                 /* Flush out information for old buffer. */
2401                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2402                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2403                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2404                 }
2405
2406         /* Only push if top exists. Otherwise, replace top. */
2407         if (YY_CURRENT_BUFFER)
2408                 yyg->yy_buffer_stack_top++;
2409         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2410
2411         /* copied from ael_yy_switch_to_buffer. */
2412         ael_yy_load_buffer_state(yyscanner );
2413         yyg->yy_did_buffer_switch_on_eof = 1;
2414 }
2415
2416 /** Removes and deletes the top of the stack, if present.
2417  *  The next element becomes the new top.
2418  *  @param yyscanner The scanner object.
2419  */
2420 void ael_yypop_buffer_state (yyscan_t yyscanner)
2421 {
2422     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2423         if (!YY_CURRENT_BUFFER)
2424                 return;
2425
2426         ael_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
2427         YY_CURRENT_BUFFER_LVALUE = NULL;
2428         if (yyg->yy_buffer_stack_top > 0)
2429                 --yyg->yy_buffer_stack_top;
2430
2431         if (YY_CURRENT_BUFFER) {
2432                 ael_yy_load_buffer_state(yyscanner );
2433                 yyg->yy_did_buffer_switch_on_eof = 1;
2434         }
2435 }
2436
2437 /* Allocates the stack if it does not exist.
2438  *  Guarantees space for at least one push.
2439  */
2440 static void ael_yyensure_buffer_stack (yyscan_t yyscanner)
2441 {
2442         int num_to_alloc;
2443     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2444
2445         if (!yyg->yy_buffer_stack) {
2446
2447                 /* First allocation is just for 2 elements, since we don't know if this
2448                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2449                  * immediate realloc on the next call.
2450          */
2451                 num_to_alloc = 1;
2452                 yyg->yy_buffer_stack = (struct yy_buffer_state**)ael_yyalloc
2453                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2454                                                                 , yyscanner);
2455                 
2456                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2457                                 
2458                 yyg->yy_buffer_stack_max = num_to_alloc;
2459                 yyg->yy_buffer_stack_top = 0;
2460                 return;
2461         }
2462
2463         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
2464
2465                 /* Increase the buffer to prepare for a possible push. */
2466                 int grow_size = 8 /* arbitrary grow size */;
2467
2468                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
2469                 yyg->yy_buffer_stack = (struct yy_buffer_state**)ael_yyrealloc
2470                                                                 (yyg->yy_buffer_stack,
2471                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2472                                                                 , yyscanner);
2473
2474                 /* zero only the new slots.*/
2475                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2476                 yyg->yy_buffer_stack_max = num_to_alloc;
2477         }
2478 }
2479
2480 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2481  * @param base the character buffer
2482  * @param size the size in bytes of the character buffer
2483  * @param yyscanner The scanner object.
2484  * @return the newly allocated buffer state object. 
2485  */
2486 YY_BUFFER_STATE ael_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
2487 {
2488         YY_BUFFER_STATE b;
2489     
2490         if ( size < 2 ||
2491              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2492              base[size-1] != YY_END_OF_BUFFER_CHAR )
2493                 /* They forgot to leave room for the EOB's. */
2494                 return 0;
2495
2496         b = (YY_BUFFER_STATE) ael_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2497         if ( ! b )
2498                 YY_FATAL_ERROR( "out of dynamic memory in ael_yy_scan_buffer()" );
2499
2500         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2501         b->yy_buf_pos = b->yy_ch_buf = base;
2502         b->yy_is_our_buffer = 0;
2503         b->yy_input_file = 0;
2504         b->yy_n_chars = b->yy_buf_size;
2505         b->yy_is_interactive = 0;
2506         b->yy_at_bol = 1;
2507         b->yy_fill_buffer = 0;
2508         b->yy_buffer_status = YY_BUFFER_NEW;
2509
2510         ael_yy_switch_to_buffer(b ,yyscanner );
2511
2512         return b;
2513 }
2514
2515 /** Setup the input buffer state to scan a string. The next call to ael_yylex() will
2516  * scan from a @e copy of @a str.
2517  * @param str a NUL-terminated string to scan
2518  * @param yyscanner The scanner object.
2519  * @return the newly allocated buffer state object.
2520  * @note If you want to scan bytes that may contain NUL values, then use
2521  *       ael_yy_scan_bytes() instead.
2522  */
2523 YY_BUFFER_STATE ael_yy_scan_string (yyconst char * yy_str , yyscan_t yyscanner)
2524 {
2525     
2526         return ael_yy_scan_bytes(yy_str,strlen(yy_str) ,yyscanner);
2527 }
2528
2529 /** Setup the input buffer state to scan the given bytes. The next call to ael_yylex() will
2530  * scan from a @e copy of @a bytes.
2531  * @param bytes the byte buffer to scan
2532  * @param len the number of bytes in the buffer pointed to by @a bytes.
2533  * @param yyscanner The scanner object.
2534  * @return the newly allocated buffer state object.
2535  */
2536 YY_BUFFER_STATE ael_yy_scan_bytes  (yyconst char * bytes, int  len , yyscan_t yyscanner)
2537 {
2538         YY_BUFFER_STATE b;
2539         char *buf;
2540         yy_size_t n;
2541         int i;
2542     
2543         /* Get memory for full buffer, including space for trailing EOB's. */
2544         n = len + 2;
2545         buf = (char *) ael_yyalloc(n ,yyscanner );
2546         if ( ! buf )
2547                 YY_FATAL_ERROR( "out of dynamic memory in ael_yy_scan_bytes()" );
2548
2549         for ( i = 0; i < len; ++i )
2550                 buf[i] = bytes[i];
2551
2552         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2553
2554         b = ael_yy_scan_buffer(buf,n ,yyscanner);
2555         if ( ! b )
2556                 YY_FATAL_ERROR( "bad buffer in ael_yy_scan_bytes()" );
2557
2558         /* It's okay to grow etc. this buffer, and we should throw it
2559          * away when we're done.
2560          */
2561         b->yy_is_our_buffer = 1;
2562
2563         return b;
2564 }
2565
2566 #ifndef YY_EXIT_FAILURE
2567 #define YY_EXIT_FAILURE 2
2568 #endif
2569
2570 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
2571 {
2572         (void) fprintf( stderr, "%s\n", msg );
2573         exit( YY_EXIT_FAILURE );
2574 }
2575
2576 /* Redefine yyless() so it works in section 3 code. */
2577
2578 #undef yyless
2579 #define yyless(n) \
2580         do \
2581                 { \
2582                 /* Undo effects of setting up yytext. */ \
2583         int yyless_macro_arg = (n); \
2584         YY_LESS_LINENO(yyless_macro_arg);\
2585                 yytext[yyleng] = yyg->yy_hold_char; \
2586                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2587                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2588                 *yyg->yy_c_buf_p = '\0'; \
2589                 yyleng = yyless_macro_arg; \
2590                 } \
2591         while ( 0 )
2592
2593 /* Accessor  methods (get/set functions) to struct members. */
2594
2595 /** Get the user-defined data for this scanner.
2596  * @param yyscanner The scanner object.
2597  */
2598 YY_EXTRA_TYPE ael_yyget_extra  (yyscan_t yyscanner)
2599 {
2600     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2601     return yyextra;
2602 }
2603
2604 /** Get the current line number.
2605  * @param yyscanner The scanner object.
2606  */
2607 int ael_yyget_lineno  (yyscan_t yyscanner)
2608 {
2609     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2610     
2611         if (! YY_CURRENT_BUFFER)
2612             return 0;
2613     
2614     return yylineno;
2615 }
2616
2617 /** Get the current column number.
2618  * @param yyscanner The scanner object.
2619  */
2620 int ael_yyget_column  (yyscan_t yyscanner)
2621 {
2622     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2623     
2624         if (! YY_CURRENT_BUFFER)
2625             return 0;
2626     
2627     return yycolumn;
2628 }
2629
2630 /** Get the input stream.
2631  * @param yyscanner The scanner object.
2632  */
2633 FILE *ael_yyget_in  (yyscan_t yyscanner)
2634 {
2635     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2636     return yyin;
2637 }
2638
2639 /** Get the output stream.
2640  * @param yyscanner The scanner object.
2641  */
2642 FILE *ael_yyget_out  (yyscan_t yyscanner)
2643 {
2644     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2645     return yyout;
2646 }
2647
2648 /** Get the length of the current token.
2649  * @param yyscanner The scanner object.
2650  */
2651 int ael_yyget_leng  (yyscan_t yyscanner)
2652 {
2653     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2654     return yyleng;
2655 }
2656
2657 /** Get the current token.
2658  * @param yyscanner The scanner object.
2659  */
2660
2661 char *ael_yyget_text  (yyscan_t yyscanner)
2662 {
2663     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2664     return yytext;
2665 }
2666
2667 /** Set the user-defined data. This data is never touched by the scanner.
2668  * @param user_defined The data to be associated with this scanner.
2669  * @param yyscanner The scanner object.
2670  */
2671 void ael_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
2672 {
2673     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2674     yyextra = user_defined ;
2675 }
2676
2677 /** Set the current line number.
2678  * @param line_number
2679  * @param yyscanner The scanner object.
2680  */
2681 void ael_yyset_lineno (int  line_number , yyscan_t yyscanner)
2682 {
2683     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2684
2685         /* lineno is only valid if an input buffer exists. */
2686         if (! YY_CURRENT_BUFFER )
2687            yy_fatal_error( "ael_yyset_lineno called with no buffer" , yyscanner); 
2688     
2689     yylineno = line_number;
2690 }
2691
2692 /** Set the current column.
2693  * @param line_number
2694  * @param yyscanner The scanner object.
2695  */
2696 void ael_yyset_column (int  column_no , yyscan_t yyscanner)
2697 {
2698     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2699
2700         /* column is only valid if an input buffer exists. */
2701         if (! YY_CURRENT_BUFFER )
2702            yy_fatal_error( "ael_yyset_column called with no buffer" , yyscanner); 
2703     
2704     yycolumn = column_no;
2705 }
2706
2707 /** Set the input stream. This does not discard the current
2708  * input buffer.
2709  * @param in_str A readable stream.
2710  * @param yyscanner The scanner object.
2711  * @see ael_yy_switch_to_buffer
2712  */
2713 void ael_yyset_in (FILE *  in_str , yyscan_t yyscanner)
2714 {
2715     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2716     yyin = in_str ;
2717 }
2718
2719 void ael_yyset_out (FILE *  out_str , yyscan_t yyscanner)
2720 {
2721     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2722     yyout = out_str ;
2723 }
2724
2725 int ael_yyget_debug  (yyscan_t yyscanner)
2726 {
2727     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2728     return yy_flex_debug;
2729 }
2730
2731 void ael_yyset_debug (int  bdebug , yyscan_t yyscanner)
2732 {
2733     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2734     yy_flex_debug = bdebug ;
2735 }
2736
2737 /* Accessor methods for yylval and yylloc */
2738
2739 YYSTYPE * ael_yyget_lval  (yyscan_t yyscanner)
2740 {
2741     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2742     return yylval;
2743 }
2744
2745 void ael_yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
2746 {
2747     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2748     yylval = yylval_param;
2749 }
2750
2751 YYLTYPE *ael_yyget_lloc  (yyscan_t yyscanner)
2752 {
2753     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2754     return yylloc;
2755 }
2756     
2757 void ael_yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
2758 {
2759     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2760     yylloc = yylloc_param;
2761 }
2762     
2763 static int yy_init_globals (yyscan_t yyscanner)
2764 {
2765     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2766     /* Initialization is the same as for the non-reentrant scanner.
2767        This function is called once per scanner lifetime. */
2768
2769     yyg->yy_buffer_stack = 0;
2770     yyg->yy_buffer_stack_top = 0;
2771     yyg->yy_buffer_stack_max = 0;
2772     yyg->yy_c_buf_p = (char *) 0;
2773     yyg->yy_init = 1;
2774     yyg->yy_start = 0;
2775     yyg->yy_start_stack_ptr = 0;
2776     yyg->yy_start_stack_depth = 0;
2777     yyg->yy_start_stack = (int *) 0;
2778
2779 /* Defined in main.c */
2780 #ifdef YY_STDINIT
2781     yyin = stdin;
2782     yyout = stdout;
2783 #else
2784     yyin = (FILE *) 0;
2785     yyout = (FILE *) 0;
2786 #endif
2787
2788     /* For future reference: Set errno on error, since we are called by
2789      * ael_yylex_init()
2790      */
2791     return 0;
2792 }
2793
2794 /* User-visible API */
2795
2796 /* ael_yylex_init is special because it creates the scanner itself, so it is
2797  * the ONLY reentrant function that doesn't take the scanner as the last argument.
2798  * That's why we explicitly handle the declaration, instead of using our macros.
2799  */
2800
2801 int ael_yylex_init(yyscan_t* ptr_yy_globals)
2802
2803 {
2804     if (ptr_yy_globals == NULL){
2805         errno = EINVAL;
2806         return 1;
2807     }
2808
2809     *ptr_yy_globals = (yyscan_t) ael_yyalloc ( sizeof( struct yyguts_t ), NULL );
2810
2811     if (*ptr_yy_globals == NULL){
2812         errno = ENOMEM;
2813         return 1;
2814     }
2815
2816     memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
2817
2818     return yy_init_globals ( *ptr_yy_globals );
2819 }
2820
2821 /* ael_yylex_destroy is for both reentrant and non-reentrant scanners. */
2822 int ael_yylex_destroy  (yyscan_t yyscanner)
2823 {
2824     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2825
2826     /* Pop the buffer stack, destroying each element. */
2827         while(YY_CURRENT_BUFFER){
2828                 ael_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2829                 YY_CURRENT_BUFFER_LVALUE = NULL;
2830                 ael_yypop_buffer_state(yyscanner);
2831         }
2832
2833         /* Destroy the stack itself. */
2834         ael_yyfree(yyg->yy_buffer_stack ,yyscanner);
2835         yyg->yy_buffer_stack = NULL;
2836
2837     /* Destroy the start condition stack. */
2838         ael_yyfree(yyg->yy_start_stack ,yyscanner );
2839         yyg->yy_start_stack = NULL;
2840
2841     /* Destroy the main struct (reentrant only). */
2842     ael_yyfree ( yyscanner , yyscanner );
2843     return 0;
2844 }
2845
2846 /*
2847  * Internal utility routines.
2848  */
2849
2850 #ifndef yytext_ptr
2851 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2852 {
2853         register int i;
2854     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2855         for ( i = 0; i < n; ++i )
2856                 s1[i] = s2[i];
2857 }
2858 #endif
2859
2860 #ifdef YY_NEED_STRLEN
2861 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2862 {
2863         register int n;
2864     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2865         for ( n = 0; s[n]; ++n )
2866                 ;
2867
2868         return n;
2869 }
2870 #endif
2871
2872 void *ael_yyalloc (yy_size_t  size , yyscan_t yyscanner)
2873 {
2874         return (void *) malloc( size );
2875 }
2876
2877 void *ael_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
2878 {
2879         /* The cast to (char *) in the following accommodates both
2880          * implementations that use char* generic pointers, and those
2881          * that use void* generic pointers.  It works with the latter
2882          * because both ANSI C and C++ allow castless assignment from
2883          * any pointer type to void*, and deal with argument conversions
2884          * as though doing an assignment.
2885          */
2886         return (void *) realloc( (char *) ptr, size );
2887 }
2888
2889 void ael_yyfree (void * ptr , yyscan_t yyscanner)
2890 {
2891         free( (char *) ptr );   /* see ael_yyrealloc() for (char *) cast */
2892 }
2893
2894 #define YYTABLES_NAME "yytables"
2895
2896 #undef YY_NEW_FILE
2897 #undef YY_FLUSH_BUFFER
2898 #undef yy_set_bol
2899 #undef yy_new_buffer
2900 #undef yy_set_interactive
2901 #undef yytext_ptr
2902 #undef YY_DO_BEFORE_ACTION
2903
2904 #ifdef YY_DECL_IS_OURS
2905 #undef YY_DECL_IS_OURS
2906 #undef YY_DECL
2907 #endif
2908 #line 473 "ael.flex"
2909
2910
2911
2912 static void pbcpush(char x)
2913 {
2914         pbcstack[pbcpos++] = x;
2915 }
2916
2917 static int pbcpop(char x)
2918 {
2919         if (   ( x == ')' && pbcstack[pbcpos-1] == '(' )
2920                 || ( x == ']' && pbcstack[pbcpos-1] == '[' )
2921                 || ( x == '}' && pbcstack[pbcpos-1] == '{' )) {
2922                 pbcpos--;
2923                 return 0;
2924         }
2925         return 1; /* error */
2926 }
2927
2928 static int c_prevword(void)
2929 {
2930         char *c = prev_word;
2931         if (c == NULL)
2932                 return 0;
2933         while ( *c ) {
2934                 switch (*c) {
2935                 case '{':
2936                 case '[':
2937                 case '(':
2938                         pbcpush(*c);
2939                         break;
2940                 case '}':
2941                 case ']':
2942                 case ')':
2943                         if (pbcpop(*c))
2944                                 return 1;
2945                         break;
2946                 }
2947                 c++;
2948         }
2949         return 0;
2950 }
2951
2952
2953 /*
2954  * The following three functions, reset_*, are used in the bison
2955  * code to switch context. As a consequence, we need to
2956  * declare them global and add a prototype so that the
2957  * compiler does not complain.
2958  *
2959  * NOTE: yyg is declared because it is used in the BEGIN macros,
2960  * though that should be hidden as the macro changes
2961  * depending on the flex options that we use - in particular,
2962  * %reentrant changes the way the macro is declared;
2963  * without %reentrant, BEGIN uses yystart instead of yyg
2964  */
2965
2966 void reset_parencount(yyscan_t yyscanner );
2967 void reset_parencount(yyscan_t yyscanner )
2968 {
2969         struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2970         parencount = 0;
2971         pbcpos = 0;
2972         pbcpush('(');   /* push '(' so the last pcbpop (parencount= -1) will succeed */
2973         c_prevword();
2974         BEGIN(paren);
2975 }
2976
2977 void reset_semicount(yyscan_t yyscanner );
2978 void reset_semicount(yyscan_t yyscanner )
2979 {
2980         struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2981         pbcpos = 0;
2982         BEGIN(semic);
2983 }
2984
2985 void reset_argcount(yyscan_t yyscanner );
2986 void reset_argcount(yyscan_t yyscanner )
2987 {
2988         struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2989         parencount = 0;
2990         pbcpos = 0;
2991         pbcpush('(');   /* push '(' so the last pcbpop (parencount= -1) will succeed */
2992         c_prevword();
2993         BEGIN(argg);
2994 }
2995
2996 /* used elsewhere, but some local vars */
2997 struct pval *ael2_parse(char *filename, int *errors)
2998 {
2999         struct pval *pval;
3000         struct parse_io *io;
3001         char *buffer;
3002         struct stat stats;
3003         FILE *fin;
3004
3005         /* extern int ael_yydebug; */
3006
3007         io = calloc(sizeof(struct parse_io),1);
3008         /* reset the global counters */
3009         prev_word = 0;
3010         my_lineno = 1;
3011         include_stack_index=0;
3012         my_col = 0;
3013         /* ael_yydebug = 1; */
3014         ael_yylex_init(&io->scanner);
3015         fin = fopen(filename,"r");
3016         if ( !fin ) {
3017                 ast_log(LOG_ERROR,"File %s could not be opened\n", filename);
3018                 *errors = 1;
3019                 return 0;
3020         }
3021         if (my_file)
3022                 free(my_file);
3023         my_file = strdup(filename);
3024         stat(filename, &stats);
3025         buffer = (char*)malloc(stats.st_size+2);
3026         fread(buffer, 1, stats.st_size, fin);
3027         buffer[stats.st_size]=0;
3028         fclose(fin);
3029
3030         ael_yy_scan_string (buffer ,io->scanner);
3031         ael_yyset_lineno(1 , io->scanner);
3032
3033         /* ael_yyset_in (fin , io->scanner);    OLD WAY */
3034
3035         ael_yyparse(io);
3036
3037
3038         pval = io->pval;
3039         *errors = io->syntax_error_count;
3040
3041         ael_yylex_destroy(io->scanner);
3042         free(buffer);
3043         free(io);
3044
3045         return pval;
3046 }
3047
3048 static void setup_filestack(char *fnamebuf2, int fnamebuf_siz, glob_t *globbuf, int globpos, yyscan_t yyscanner, int create)
3049 {
3050         struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3051         int error, i;
3052         FILE *in1;
3053         char fnamebuf[2048];
3054
3055         if (globbuf && globbuf->gl_pathv && globbuf->gl_pathc > 0)
3056 #if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE_AEL)
3057                         strncpy(fnamebuf, globbuf->gl_pathv[globpos], fnamebuf_siz);
3058 #else
3059                         ast_copy_string(fnamebuf, globbuf->gl_pathv[globpos], fnamebuf_siz);
3060 #endif
3061         else {
3062                 ast_log(LOG_ERROR,"Include file name not present!\n");
3063                 return;
3064         }
3065         for (i=0; i<include_stack_index; i++) {
3066                 if ( !strcmp(fnamebuf,include_stack[i].fname )) {
3067                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Nice Try!!! But %s has already been included (perhaps by another file), and would cause an infinite loop of file inclusions!!! Include directive ignored\n",
3068                                 my_file, my_lineno, my_col, fnamebuf);
3069                         break;
3070                 }
3071         }
3072         error = 1;
3073         if (i == include_stack_index)
3074                 error = 0;      /* we can use this file */
3075         if ( !error ) { /* valid file name */
3076                 /* relative vs. absolute */
3077                 if (fnamebuf[0] != '/')
3078                         snprintf(fnamebuf2, fnamebuf_siz, "%s/%s", ast_config_AST_CONFIG_DIR, fnamebuf);
3079                 else
3080 #if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE_AEL)
3081                         strncpy(fnamebuf2, fnamebuf, fnamebuf_siz);
3082 #else
3083                         ast_copy_string(fnamebuf2, fnamebuf, fnamebuf_siz);
3084 #endif
3085                 in1 = fopen( fnamebuf2, "r" );
3086
3087                 if ( ! in1 ) {
3088                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Couldn't find the include file: %s; ignoring the Include directive!\n", my_file, my_lineno, my_col, fnamebuf2);
3089                 } else {
3090                         char *buffer;
3091                         struct stat stats;
3092                         stat(fnamebuf2, &stats);
3093                         buffer = (char*)malloc(stats.st_size+1);
3094                         fread(buffer, 1, stats.st_size, in1);
3095                         buffer[stats.st_size] = 0;
3096                         ast_log(LOG_NOTICE,"  --Read in included file %s, %d chars\n",fnamebuf2, (int)stats.st_size);
3097                         fclose(in1);
3098                         if (my_file)
3099                                 free(my_file);
3100                         my_file = strdup(fnamebuf2);
3101                         include_stack[include_stack_index].fname = strdup(my_file);
3102                         include_stack[include_stack_index].lineno = my_lineno;
3103                         include_stack[include_stack_index].colno = my_col+yyleng;
3104                         if (create)
3105                                 include_stack[include_stack_index].globbuf = *globbuf;
3106
3107                         include_stack[include_stack_index].globbuf_pos = 0;
3108
3109                         include_stack[include_stack_index].bufstate = YY_CURRENT_BUFFER;
3110                         if (create)
3111                                 include_stack_index++;
3112                         ael_yy_switch_to_buffer(ael_yy_scan_string (buffer ,yyscanner),yyscanner);
3113                         free(buffer);
3114                         my_lineno = 1;
3115                         my_col = 1;
3116                         BEGIN(INITIAL);
3117                 }
3118         }
3119 }
3120