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