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