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