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