7fba129b7c9706a291b855e009e930335fb63cb3
[asterisk/asterisk.git] / res / ael / ael_lex.c
1 #include "asterisk.h"
2
3 #line 2 "ael_lex.c"
4
5 #line 4 "ael_lex.c"
6
7 #define  YY_INT_ALIGNED short int
8
9 /* A lexical scanner generated by flex */
10
11 #define FLEX_SCANNER
12 #define YY_FLEX_MAJOR_VERSION 2
13 #define YY_FLEX_MINOR_VERSION 5
14 #define YY_FLEX_SUBMINOR_VERSION 35
15 #if YY_FLEX_SUBMINOR_VERSION > 0
16 #define FLEX_BETA
17 #endif
18
19 /* First, we deal with  platform-specific or compiler-specific issues. */
20
21 /* begin standard C headers. */
22 #include <stdio.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <stdlib.h>
26
27 /* end standard C headers. */
28
29 /* flex integer type definitions */
30
31 #ifndef FLEXINT_H
32 #define FLEXINT_H
33
34 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
35
36 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
37
38 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
39  * if you want the limit (max/min) macros for int types. 
40  */
41 #ifndef __STDC_LIMIT_MACROS
42 #define __STDC_LIMIT_MACROS 1
43 #endif
44
45 #include <inttypes.h>
46 typedef int8_t flex_int8_t;
47 typedef uint8_t flex_uint8_t;
48 typedef int16_t flex_int16_t;
49 typedef uint16_t flex_uint16_t;
50 typedef int32_t flex_int32_t;
51 typedef uint32_t flex_uint32_t;
52 #else
53 typedef signed char flex_int8_t;
54 typedef short int flex_int16_t;
55 typedef int flex_int32_t;
56 typedef unsigned char flex_uint8_t; 
57 typedef unsigned short int flex_uint16_t;
58 typedef unsigned int flex_uint32_t;
59 #endif /* ! C99 */
60
61 /* Limits of integral types. */
62 #ifndef INT8_MIN
63 #define INT8_MIN               (-128)
64 #endif
65 #ifndef INT16_MIN
66 #define INT16_MIN              (-32767-1)
67 #endif
68 #ifndef INT32_MIN
69 #define INT32_MIN              (-2147483647-1)
70 #endif
71 #ifndef INT8_MAX
72 #define INT8_MAX               (127)
73 #endif
74 #ifndef INT16_MAX
75 #define INT16_MAX              (32767)
76 #endif
77 #ifndef INT32_MAX
78 #define INT32_MAX              (2147483647)
79 #endif
80 #ifndef UINT8_MAX
81 #define UINT8_MAX              (255U)
82 #endif
83 #ifndef UINT16_MAX
84 #define UINT16_MAX             (65535U)
85 #endif
86 #ifndef UINT32_MAX
87 #define UINT32_MAX             (4294967295U)
88 #endif
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 954 "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 int ael_yyget_column  (yyscan_t yyscanner );
1058
1059 void ael_yyset_column (int column_no ,yyscan_t yyscanner );
1060
1061 YYSTYPE * ael_yyget_lval (yyscan_t yyscanner );
1062
1063 void ael_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
1064
1065        YYLTYPE *ael_yyget_lloc (yyscan_t yyscanner );
1066     
1067         void ael_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
1068     
1069 /* Macros after this point can all be overridden by user definitions in
1070  * section 1.
1071  */
1072
1073 #ifndef YY_SKIP_YYWRAP
1074 #ifdef __cplusplus
1075 extern "C" int ael_yywrap (yyscan_t yyscanner );
1076 #else
1077 extern int ael_yywrap (yyscan_t yyscanner );
1078 #endif
1079 #endif
1080
1081     static void yyunput (int c,char *buf_ptr  ,yyscan_t yyscanner);
1082     
1083 #ifndef yytext_ptr
1084 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
1085 #endif
1086
1087 #ifdef YY_NEED_STRLEN
1088 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
1089 #endif
1090
1091 #ifndef YY_NO_INPUT
1092
1093 #ifdef __cplusplus
1094 static int yyinput (yyscan_t yyscanner );
1095 #else
1096 static int input (yyscan_t yyscanner );
1097 #endif
1098
1099 #endif
1100
1101 /* Amount of stuff to slurp up with each read. */
1102 #ifndef YY_READ_BUF_SIZE
1103 #define YY_READ_BUF_SIZE 8192
1104 #endif
1105
1106 /* Copy whatever the last rule matched to the standard output. */
1107 #ifndef ECHO
1108 /* This used to be an fputs(), but since the string might contain NUL's,
1109  * we now use fwrite().
1110  */
1111 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
1112 #endif
1113
1114 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1115  * is returned in "result".
1116  */
1117 #ifndef YY_INPUT
1118 #define YY_INPUT(buf,result,max_size) \
1119         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1120                 { \
1121                 int c = '*'; \
1122                 unsigned n; \
1123                 for ( n = 0; n < max_size && \
1124                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1125                         buf[n] = (char) c; \
1126                 if ( c == '\n' ) \
1127                         buf[n++] = (char) c; \
1128                 if ( c == EOF && ferror( yyin ) ) \
1129                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1130                 result = n; \
1131                 } \
1132         else \
1133                 { \
1134                 errno=0; \
1135                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1136                         { \
1137                         if( errno != EINTR) \
1138                                 { \
1139                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1140                                 break; \
1141                                 } \
1142                         errno=0; \
1143                         clearerr(yyin); \
1144                         } \
1145                 }\
1146 \
1147
1148 #endif
1149
1150 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1151  * we don't want an extra ';' after the "return" because that will cause
1152  * some compilers to complain about unreachable statements.
1153  */
1154 #ifndef yyterminate
1155 #define yyterminate() return YY_NULL
1156 #endif
1157
1158 /* Number of entries by which start-condition stack grows. */
1159 #ifndef YY_START_STACK_INCR
1160 #define YY_START_STACK_INCR 25
1161 #endif
1162
1163 /* Report a fatal error. */
1164 #ifndef YY_FATAL_ERROR
1165 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
1166 #endif
1167
1168 /* end tables serialization structures and prototypes */
1169
1170 /* Default declaration of generated scanner - a define so the user can
1171  * easily add parameters.
1172  */
1173 #ifndef YY_DECL
1174 #define YY_DECL_IS_OURS 1
1175
1176 extern int ael_yylex \
1177                (YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
1178
1179 #define YY_DECL int ael_yylex \
1180                (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
1181 #endif /* !YY_DECL */
1182
1183 /* Code executed at the beginning of each rule, after yytext and yyleng
1184  * have been set up.
1185  */
1186 #ifndef YY_USER_ACTION
1187 #define YY_USER_ACTION
1188 #endif
1189
1190 /* Code executed at the end of each rule. */
1191 #ifndef YY_BREAK
1192 #define YY_BREAK break;
1193 #endif
1194
1195 #define YY_RULE_SETUP \
1196         YY_USER_ACTION
1197
1198 /** The main scanner function which does all the work.
1199  */
1200 YY_DECL
1201 {
1202         register yy_state_type yy_current_state;
1203         register char *yy_cp, *yy_bp;
1204         register int yy_act;
1205     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1206
1207 #line 217 "ael.flex"
1208
1209
1210 #line 1209 "ael_lex.c"
1211
1212     yylval = yylval_param;
1213
1214     yylloc = yylloc_param;
1215
1216         if ( !yyg->yy_init )
1217                 {
1218                 yyg->yy_init = 1;
1219
1220 #ifdef YY_USER_INIT
1221                 YY_USER_INIT;
1222 #endif
1223
1224                 if ( ! yyg->yy_start )
1225                         yyg->yy_start = 1;      /* first start state */
1226
1227                 if ( ! yyin )
1228                         yyin = stdin;
1229
1230                 if ( ! yyout )
1231                         yyout = stdout;
1232
1233                 if ( ! YY_CURRENT_BUFFER ) {
1234                         ael_yyensure_buffer_stack (yyscanner);
1235                         YY_CURRENT_BUFFER_LVALUE =
1236                                 ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1237                 }
1238
1239                 ael_yy_load_buffer_state(yyscanner );
1240                 }
1241
1242         while ( 1 )             /* loops until end-of-file is reached */
1243                 {
1244                 yyg->yy_more_len = 0;
1245                 if ( yyg->yy_more_flag )
1246                         {
1247                         yyg->yy_more_len = yyg->yy_c_buf_p - yyg->yytext_ptr;
1248                         yyg->yy_more_flag = 0;
1249                         }
1250                 yy_cp = yyg->yy_c_buf_p;
1251
1252                 /* Support of yytext. */
1253                 *yy_cp = yyg->yy_hold_char;
1254
1255                 /* yy_bp points to the position in yy_ch_buf of the start of
1256                  * the current run.
1257                  */
1258                 yy_bp = yy_cp;
1259
1260                 yy_current_state = yyg->yy_start;
1261 yy_match:
1262                 do
1263                         {
1264                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1265                         if ( yy_accept[yy_current_state] )
1266                                 {
1267                                 yyg->yy_last_accepting_state = yy_current_state;
1268                                 yyg->yy_last_accepting_cpos = yy_cp;
1269                                 }
1270                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1271                                 {
1272                                 yy_current_state = (int) yy_def[yy_current_state];
1273                                 if ( yy_current_state >= 285 )
1274                                         yy_c = yy_meta[(unsigned int) yy_c];
1275                                 }
1276                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1277                         ++yy_cp;
1278                         }
1279                 while ( yy_current_state != 284 );
1280                 yy_cp = yyg->yy_last_accepting_cpos;
1281                 yy_current_state = yyg->yy_last_accepting_state;
1282
1283 yy_find_action:
1284                 yy_act = yy_accept[yy_current_state];
1285
1286                 YY_DO_BEFORE_ACTION;
1287
1288 do_action:      /* This label is used only to access EOF actions. */
1289
1290                 switch ( yy_act )
1291         { /* beginning of action switch */
1292                         case 0: /* must back up */
1293                         /* undo the effects of YY_DO_BEFORE_ACTION */
1294                         *yy_cp = yyg->yy_hold_char;
1295                         yy_cp = yyg->yy_last_accepting_cpos;
1296                         yy_current_state = yyg->yy_last_accepting_state;
1297                         goto yy_find_action;
1298
1299 case 1:
1300 YY_RULE_SETUP
1301 #line 219 "ael.flex"
1302 { STORE_POS; return LC;}
1303         YY_BREAK
1304 case 2:
1305 YY_RULE_SETUP
1306 #line 220 "ael.flex"
1307 { STORE_POS; return RC;}
1308         YY_BREAK
1309 case 3:
1310 YY_RULE_SETUP
1311 #line 221 "ael.flex"
1312 { STORE_POS; return LP;}
1313         YY_BREAK
1314 case 4:
1315 YY_RULE_SETUP
1316 #line 222 "ael.flex"
1317 { STORE_POS; return RP;}
1318         YY_BREAK
1319 case 5:
1320 YY_RULE_SETUP
1321 #line 223 "ael.flex"
1322 { STORE_POS; return SEMI;}
1323         YY_BREAK
1324 case 6:
1325 YY_RULE_SETUP
1326 #line 224 "ael.flex"
1327 { STORE_POS; return EQ;}
1328         YY_BREAK
1329 case 7:
1330 YY_RULE_SETUP
1331 #line 225 "ael.flex"
1332 { STORE_POS; return COMMA;}
1333         YY_BREAK
1334 case 8:
1335 YY_RULE_SETUP
1336 #line 226 "ael.flex"
1337 { STORE_POS; return COLON;}
1338         YY_BREAK
1339 case 9:
1340 YY_RULE_SETUP
1341 #line 227 "ael.flex"
1342 { STORE_POS; return AMPER;}
1343         YY_BREAK
1344 case 10:
1345 YY_RULE_SETUP
1346 #line 228 "ael.flex"
1347 { STORE_POS; return BAR;}
1348         YY_BREAK
1349 case 11:
1350 YY_RULE_SETUP
1351 #line 229 "ael.flex"
1352 { STORE_POS; return EXTENMARK;}
1353         YY_BREAK
1354 case 12:
1355 YY_RULE_SETUP
1356 #line 230 "ael.flex"
1357 { STORE_POS; return AT;}
1358         YY_BREAK
1359 case 13:
1360 YY_RULE_SETUP
1361 #line 231 "ael.flex"
1362 {/*comment*/}
1363         YY_BREAK
1364 case 14:
1365 YY_RULE_SETUP
1366 #line 232 "ael.flex"
1367 { STORE_POS; return KW_CONTEXT;}
1368         YY_BREAK
1369 case 15:
1370 YY_RULE_SETUP
1371 #line 233 "ael.flex"
1372 { STORE_POS; return KW_ABSTRACT;}
1373         YY_BREAK
1374 case 16:
1375 YY_RULE_SETUP
1376 #line 234 "ael.flex"
1377 { STORE_POS; return KW_EXTEND;}
1378         YY_BREAK
1379 case 17:
1380 YY_RULE_SETUP
1381 #line 235 "ael.flex"
1382 { STORE_POS; return KW_MACRO;};
1383         YY_BREAK
1384 case 18:
1385 YY_RULE_SETUP
1386 #line 236 "ael.flex"
1387 { STORE_POS; return KW_GLOBALS;}
1388         YY_BREAK
1389 case 19:
1390 YY_RULE_SETUP
1391 #line 237 "ael.flex"
1392 { STORE_POS; return KW_LOCAL;}
1393         YY_BREAK
1394 case 20:
1395 YY_RULE_SETUP
1396 #line 238 "ael.flex"
1397 { STORE_POS; return KW_IGNOREPAT;}
1398         YY_BREAK
1399 case 21:
1400 YY_RULE_SETUP
1401 #line 239 "ael.flex"
1402 { STORE_POS; return KW_SWITCH;}
1403         YY_BREAK
1404 case 22:
1405 YY_RULE_SETUP
1406 #line 240 "ael.flex"
1407 { STORE_POS; return KW_IF;}
1408         YY_BREAK
1409 case 23:
1410 YY_RULE_SETUP
1411 #line 241 "ael.flex"
1412 { STORE_POS; return KW_IFTIME;}
1413         YY_BREAK
1414 case 24:
1415 YY_RULE_SETUP
1416 #line 242 "ael.flex"
1417 { STORE_POS; return KW_RANDOM;}
1418         YY_BREAK
1419 case 25:
1420 YY_RULE_SETUP
1421 #line 243 "ael.flex"
1422 { STORE_POS; return KW_REGEXTEN;}
1423         YY_BREAK
1424 case 26:
1425 YY_RULE_SETUP
1426 #line 244 "ael.flex"
1427 { STORE_POS; return KW_HINT;}
1428         YY_BREAK
1429 case 27:
1430 YY_RULE_SETUP
1431 #line 245 "ael.flex"
1432 { STORE_POS; return KW_ELSE;}
1433         YY_BREAK
1434 case 28:
1435 YY_RULE_SETUP
1436 #line 246 "ael.flex"
1437 { STORE_POS; return KW_GOTO;}
1438         YY_BREAK
1439 case 29:
1440 YY_RULE_SETUP
1441 #line 247 "ael.flex"
1442 { STORE_POS; return KW_JUMP;}
1443         YY_BREAK
1444 case 30:
1445 YY_RULE_SETUP
1446 #line 248 "ael.flex"
1447 { STORE_POS; return KW_RETURN;}
1448         YY_BREAK
1449 case 31:
1450 YY_RULE_SETUP
1451 #line 249 "ael.flex"
1452 { STORE_POS; return KW_BREAK;}
1453         YY_BREAK
1454 case 32:
1455 YY_RULE_SETUP
1456 #line 250 "ael.flex"
1457 { STORE_POS; return KW_CONTINUE;}
1458         YY_BREAK
1459 case 33:
1460 YY_RULE_SETUP
1461 #line 251 "ael.flex"
1462 { STORE_POS; return KW_FOR;}
1463         YY_BREAK
1464 case 34:
1465 YY_RULE_SETUP
1466 #line 252 "ael.flex"
1467 { STORE_POS; return KW_WHILE;}
1468         YY_BREAK
1469 case 35:
1470 YY_RULE_SETUP
1471 #line 253 "ael.flex"
1472 { STORE_POS; return KW_CASE;}
1473         YY_BREAK
1474 case 36:
1475 YY_RULE_SETUP
1476 #line 254 "ael.flex"
1477 { STORE_POS; return KW_DEFAULT;}
1478         YY_BREAK
1479 case 37:
1480 YY_RULE_SETUP
1481 #line 255 "ael.flex"
1482 { STORE_POS; return KW_PATTERN;}
1483         YY_BREAK
1484 case 38:
1485 YY_RULE_SETUP
1486 #line 256 "ael.flex"
1487 { STORE_POS; return KW_CATCH;}
1488         YY_BREAK
1489 case 39:
1490 YY_RULE_SETUP
1491 #line 257 "ael.flex"
1492 { STORE_POS; return KW_SWITCHES;}
1493         YY_BREAK
1494 case 40:
1495 YY_RULE_SETUP
1496 #line 258 "ael.flex"
1497 { STORE_POS; return KW_ESWITCHES;}
1498         YY_BREAK
1499 case 41:
1500 YY_RULE_SETUP
1501 #line 259 "ael.flex"
1502 { STORE_POS; return KW_INCLUDES;}
1503         YY_BREAK
1504 case 42:
1505 YY_RULE_SETUP
1506 #line 260 "ael.flex"
1507 { BEGIN(comment); my_col += 2; }
1508         YY_BREAK
1509 case 43:
1510 YY_RULE_SETUP
1511 #line 262 "ael.flex"
1512 { my_col += yyleng; }
1513         YY_BREAK
1514 case 44:
1515 /* rule 44 can match eol */
1516 YY_RULE_SETUP
1517 #line 263 "ael.flex"
1518 { ++my_lineno; my_col=1;}
1519         YY_BREAK
1520 case 45:
1521 YY_RULE_SETUP
1522 #line 264 "ael.flex"
1523 { my_col += yyleng; }
1524         YY_BREAK
1525 case 46:
1526 /* rule 46 can match eol */
1527 YY_RULE_SETUP
1528 #line 265 "ael.flex"
1529 { ++my_lineno; my_col=1;}
1530         YY_BREAK
1531 case 47:
1532 YY_RULE_SETUP
1533 #line 266 "ael.flex"
1534 { my_col += 2; BEGIN(INITIAL); } /* the nice thing about comments is that you know exactly what ends them */
1535         YY_BREAK
1536 case 48:
1537 /* rule 48 can match eol */
1538 YY_RULE_SETUP
1539 #line 268 "ael.flex"
1540 { my_lineno++; my_col = 1; }
1541         YY_BREAK
1542 case 49:
1543 YY_RULE_SETUP
1544 #line 269 "ael.flex"
1545 { my_col += yyleng; }
1546         YY_BREAK
1547 case 50:
1548 YY_RULE_SETUP
1549 #line 270 "ael.flex"
1550 { my_col += (yyleng*8)-(my_col%8); }
1551         YY_BREAK
1552 case 51:
1553 YY_RULE_SETUP
1554 #line 272 "ael.flex"
1555
1556       /* boy did I open a can of worms when I changed the lexical token "word". 
1557                  all the above keywords can be used as a beginning to a "word".-
1558                  before, a "word" would match a longer sequence than the above   
1559              keywords, and all would be well. But now "word" is a single char           
1560              and feeds into a statemachine sort of sequence from there on. So...
1561                  I added the {KEYWORD}? to the beginning of the word match sequence */
1562
1563                 if (!strcmp(yytext,"${")) {
1564                         parencount2 = 0;
1565                         pbcpos2 = 0;
1566                         pbcpush2('{');  /* push '{' so the last pcbpop (parencount2 = -1) will succeed */
1567                         BEGIN(curlystate);
1568                         yymore();
1569                 } else if (!strcmp(yytext,"$[")) {
1570                         parencount3 = 0;
1571                         pbcpos3 = 0;
1572                         pbcpush3('[');  /* push '[' so the last pcbpop (parencount3 = -1) will succeed */
1573                         BEGIN(brackstate);
1574                         yymore();
1575                 } else {
1576                     BEGIN(wordstate);
1577                         yymore();
1578                 }
1579         }
1580         YY_BREAK
1581 case 52:
1582 YY_RULE_SETUP
1583 #line 298 "ael.flex"
1584 { yymore(); /* Keep going */ }
1585         YY_BREAK
1586 case 53:
1587 YY_RULE_SETUP
1588 #line 299 "ael.flex"
1589 { yymore(); /* Keep going */ }
1590         YY_BREAK
1591 case 54:
1592 YY_RULE_SETUP
1593 #line 300 "ael.flex"
1594 { yymore(); /* Keep Going */ }
1595         YY_BREAK
1596 case 55:
1597 YY_RULE_SETUP
1598 #line 301 "ael.flex"
1599 { /* the beginning of a ${} construct. prepare and pop into curlystate */
1600                 parencount2 = 0;
1601                 pbcpos2 = 0;
1602                 pbcpush2('{');  /* push '{' so the last pcbpop (parencount2 = -1) will succeed */
1603                 BEGIN(curlystate);
1604                 yymore();
1605         }
1606         YY_BREAK
1607 case 56:
1608 YY_RULE_SETUP
1609 #line 308 "ael.flex"
1610 { /* the beginning of a $[] construct. prepare and pop into brackstate */
1611                 parencount3 = 0;
1612                 pbcpos3 = 0;
1613                 pbcpush3('[');  /* push '[' so the last pcbpop (parencount3 = -1) will succeed */
1614                 BEGIN(brackstate);
1615                 yymore();
1616         }
1617         YY_BREAK
1618 case 57:
1619 /* rule 57 can match eol */
1620 YY_RULE_SETUP
1621 #line 315 "ael.flex"
1622 {
1623                 /* a non-word constituent char, like a space, tab, curly, paren, etc */
1624                 char c = yytext[yyleng-1];
1625                 STORE_POS;
1626                 yylval->str = malloc(yyleng);
1627                 strncpy(yylval->str, yytext, yyleng);
1628                 yylval->str[yyleng-1] = 0;
1629                 unput(c);  /* put this ending char back in the stream */
1630                 BEGIN(0);
1631                 return word;
1632         }
1633         YY_BREAK
1634 case 58:
1635 /* rule 58 can match eol */
1636 YY_RULE_SETUP
1637 #line 328 "ael.flex"
1638 {
1639                 if ( pbcpop2('}') ) {   /* error */
1640                         STORE_LOC;
1641                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression: %s !\n", my_file, my_lineno, my_col, yytext);
1642                         BEGIN(0);
1643                         yylval->str = malloc(yyleng+1);
1644                         strncpy(yylval->str, yytext, yyleng);
1645                         yylval->str[yyleng] = 0;
1646                         return word;
1647                 }
1648                 parencount2--;
1649                 if ( parencount2 >= 0) {
1650                         yymore();
1651                 } else {
1652                         BEGIN(wordstate); /* Finished with the current ${} construct. Return to word gathering state */
1653                         yymore();
1654                 }
1655         }
1656         YY_BREAK
1657 case 59:
1658 /* rule 59 can match eol */
1659 YY_RULE_SETUP
1660 #line 347 "ael.flex"
1661
1662                 char c = yytext[yyleng-1];
1663                 if (c == '{')
1664                         parencount2++;
1665                 pbcpush2(c);
1666                 yymore();
1667         }
1668         YY_BREAK
1669 case 60:
1670 /* rule 60 can match eol */
1671 YY_RULE_SETUP
1672 #line 355 "ael.flex"
1673
1674                 char c = yytext[yyleng-1];
1675                 if ( pbcpop2(c))  { /* error */
1676                         STORE_LOC;
1677                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n",
1678                                 my_file, my_lineno, my_col, c);
1679                         BEGIN(0);
1680                         yylval->str = malloc(yyleng+1);
1681                         strncpy(yylval->str, yytext, yyleng);
1682                         yylval->str[yyleng] = 0;
1683                         return word;
1684                 }
1685                 yymore();
1686         }
1687         YY_BREAK
1688 case 61:
1689 /* rule 61 can match eol */
1690 YY_RULE_SETUP
1691 #line 371 "ael.flex"
1692 {
1693                 if ( pbcpop3(']') ) {   /* error */
1694                         STORE_LOC;
1695                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression: %s !\n", my_file, my_lineno, my_col, yytext);
1696                         BEGIN(0);
1697                         yylval->str = malloc(yyleng+1);
1698                         strncpy(yylval->str, yytext, yyleng);
1699                         yylval->str[yyleng] = 0;
1700                         return word;
1701                 }
1702                 parencount3--;
1703                 if ( parencount3 >= 0) {
1704                         yymore();
1705                 } else {
1706                         BEGIN(wordstate); /* Finished with the current ${} construct. Return to word gathering state */
1707                         yymore();
1708                 }
1709         }
1710         YY_BREAK
1711 case 62:
1712 /* rule 62 can match eol */
1713 YY_RULE_SETUP
1714 #line 390 "ael.flex"
1715
1716                 char c = yytext[yyleng-1];
1717                 if (c == '[')
1718                         parencount3++;
1719                 pbcpush3(c);
1720                 yymore();
1721         }
1722         YY_BREAK
1723 case 63:
1724 /* rule 63 can match eol */
1725 YY_RULE_SETUP
1726 #line 398 "ael.flex"
1727
1728                 char c = yytext[yyleng-1];
1729                 if ( pbcpop3(c))  { /* error */
1730                         STORE_LOC;
1731                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n",
1732                                 my_file, my_lineno, my_col, c);
1733                         BEGIN(0);
1734                         yylval->str = malloc(yyleng+1);
1735                         strncpy(yylval->str, yytext, yyleng);
1736                         yylval->str[yyleng] = 0;
1737                         return word;
1738                 }
1739                 yymore();
1740         }
1741         YY_BREAK
1742 /*
1743          * context used for arguments of if_head, random_head, switch_head,
1744          * for (last statement), while (XXX why not iftime_head ?).
1745          * End with the matching parentheses.
1746          * A comma at the top level is valid here, unlike in argg where it
1747          * is an argument separator so it must be returned as a token.
1748          */
1749 case 64:
1750 /* rule 64 can match eol */
1751 YY_RULE_SETUP
1752 #line 421 "ael.flex"
1753 {
1754                 if ( pbcpop(')') ) {    /* error */
1755                         STORE_LOC;
1756                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression: %s !\n", my_file, my_lineno, my_col, yytext);
1757                         BEGIN(0);
1758                         yylval->str = malloc(yyleng+1);
1759                         strncpy(yylval->str, yytext, yyleng);
1760                         yylval->str[yyleng] = 0;
1761                         prev_word = 0;
1762                         return word;
1763                 }
1764                 parencount--;
1765                 if ( parencount >= 0) {
1766                         yymore();
1767                 } else {
1768                         STORE_LOC;
1769                         yylval->str = malloc(yyleng);
1770                         strncpy(yylval->str, yytext, yyleng);
1771                         yylval->str[yyleng-1] = 0;
1772                         unput(')');
1773                         BEGIN(0);
1774                         return word;
1775                 }
1776         }
1777         YY_BREAK
1778 case 65:
1779 /* rule 65 can match eol */
1780 YY_RULE_SETUP
1781 #line 446 "ael.flex"
1782 {
1783                 char c = yytext[yyleng-1];
1784                 if (c == '(')
1785                         parencount++;
1786                 pbcpush(c);
1787                 yymore();
1788         }
1789         YY_BREAK
1790 case 66:
1791 /* rule 66 can match eol */
1792 YY_RULE_SETUP
1793 #line 454 "ael.flex"
1794 {
1795                 char c = yytext[yyleng-1];
1796                 if ( pbcpop(c))  { /* error */
1797                         STORE_LOC;
1798                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n",
1799                                 my_file, my_lineno, my_col, c);
1800                         BEGIN(0);
1801                         yylval->str = malloc(yyleng+1);
1802                         strncpy(yylval->str, yytext, yyleng);
1803                         yylval->str[yyleng] = 0;
1804                         return word;
1805                 }
1806                 yymore();
1807         }
1808         YY_BREAK
1809 /*
1810          * handlers for arguments to a macro or application calls.
1811          * We enter this context when we find the initial '(' and
1812          * stay here until we close all matching parentheses,
1813          * and find the comma (argument separator) or the closing ')'
1814          * of the (external) call, which happens when parencount == 0
1815          * before the decrement.
1816          */
1817 case 67:
1818 /* rule 67 can match eol */
1819 YY_RULE_SETUP
1820 #line 478 "ael.flex"
1821 {
1822                 char c = yytext[yyleng-1];
1823                 if (c == '(')
1824                         parencount++;
1825                 pbcpush(c);
1826                 yymore();
1827         }
1828         YY_BREAK
1829 case 68:
1830 /* rule 68 can match eol */
1831 YY_RULE_SETUP
1832 #line 486 "ael.flex"
1833 {
1834                 if ( pbcpop(')') ) { /* error */
1835                         STORE_LOC;
1836                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched ')' in expression!\n", my_file, my_lineno, my_col);
1837                         BEGIN(0);
1838                         yylval->str = malloc(yyleng+1);
1839                         strncpy(yylval->str, yytext, yyleng);
1840                         yylval->str[yyleng] = 0;
1841                         return word;
1842                 }
1843
1844                 parencount--;
1845                 if( parencount >= 0){
1846                         yymore();
1847                 } else {
1848                         STORE_LOC;
1849                         BEGIN(0);
1850                         if ( !strcmp(yytext, ")") )
1851                                 return RP;
1852                         yylval->str = malloc(yyleng);
1853                         strncpy(yylval->str, yytext, yyleng);
1854                         yylval->str[yyleng-1] = '\0'; /* trim trailing ')' */
1855                         unput(')');
1856                         return word;
1857                 }
1858         }
1859         YY_BREAK
1860 case 69:
1861 /* rule 69 can match eol */
1862 YY_RULE_SETUP
1863 #line 513 "ael.flex"
1864 {
1865                 if( parencount != 0) { /* ast_log(LOG_NOTICE,"Folding in a comma!\n"); */
1866                         yymore();
1867                 } else  {
1868                         STORE_LOC;
1869                         if( !strcmp(yytext,"," ) )
1870                                 return COMMA;
1871                         yylval->str = malloc(yyleng);
1872                         strncpy(yylval->str, yytext, yyleng);
1873                         yylval->str[yyleng-1] = '\0'; /* trim trailing ',' */
1874                         unput(',');
1875                         return word;
1876                 }
1877         }
1878         YY_BREAK
1879 case 70:
1880 /* rule 70 can match eol */
1881 YY_RULE_SETUP
1882 #line 528 "ael.flex"
1883 {
1884                 char c = yytext[yyleng-1];
1885                 if ( pbcpop(c) ) { /* error */
1886                         STORE_LOC;
1887                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n", my_file, my_lineno, my_col, c);
1888                         BEGIN(0);
1889                         yylval->str = malloc(yyleng+1);
1890                         strncpy(yylval->str, yytext, yyleng);
1891                         yylval->str[yyleng] = '\0';
1892                         return word;
1893                 }
1894                 yymore();
1895         }
1896         YY_BREAK
1897 /*
1898          * context used to find tokens in the right hand side of assignments,
1899          * or in the first and second operand of a 'for'. As above, match
1900          * commas and use ';' as a separator (hence return it as a separate token).
1901          */
1902 case 71:
1903 /* rule 71 can match eol */
1904 YY_RULE_SETUP
1905 #line 547 "ael.flex"
1906 {
1907                 char c = yytext[yyleng-1];
1908                 yymore();
1909                 pbcpush(c);
1910         }
1911         YY_BREAK
1912 case 72:
1913 /* rule 72 can match eol */
1914 YY_RULE_SETUP
1915 #line 553 "ael.flex"
1916 {
1917                 char c = yytext[yyleng-1];
1918                 if ( pbcpop(c) ) { /* error */
1919                         STORE_LOC;
1920                         ast_log(LOG_ERROR,"File=%s, line=%d, column=%d: Mismatched '%c' in expression!\n", my_file, my_lineno, my_col, c);
1921                         BEGIN(0);
1922                         yylval->str = malloc(yyleng+1);
1923                         strncpy(yylval->str, yytext, yyleng);
1924                         yylval->str[yyleng] = '\0';
1925                         return word;
1926                 }
1927                 yymore();
1928         }
1929         YY_BREAK
1930 case 73:
1931 /* rule 73 can match eol */
1932 YY_RULE_SETUP
1933 #line 567 "ael.flex"
1934 {
1935                 STORE_LOC;
1936                 yylval->str = malloc(yyleng);
1937                 strncpy(yylval->str, yytext, yyleng);
1938                 yylval->str[yyleng-1] = '\0'; /* trim trailing ';' */
1939                 unput(';');
1940                 BEGIN(0);
1941                 return word;
1942         }
1943         YY_BREAK
1944 case 74:
1945 /* rule 74 can match eol */
1946 YY_RULE_SETUP
1947 #line 577 "ael.flex"
1948 {
1949                 char fnamebuf[1024],*p1,*p2;
1950                 int glob_ret;
1951                 glob_t globbuf;        /* the current globbuf */
1952                 int globbuf_pos = -1;   /* where we are in the current globbuf */
1953                 globbuf.gl_offs = 0;    /* initialize it to silence gcc */
1954                 
1955                 p1 = strchr(yytext,'"');
1956                 p2 = strrchr(yytext,'"');
1957                 if ( include_stack_index >= MAX_INCLUDE_DEPTH ) {
1958                         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);
1959                 } else if ( (int)(p2-p1) > sizeof(fnamebuf) - 1 ) {
1960                         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);
1961                 } else {
1962                         strncpy(fnamebuf, p1+1, p2-p1-1);
1963                         fnamebuf[p2-p1-1] = 0;
1964                 if (fnamebuf[0] != '/') {
1965                    char fnamebuf2[1024];
1966                    snprintf(fnamebuf2,sizeof(fnamebuf2), "%s/%s", (char *)ast_config_AST_CONFIG_DIR, fnamebuf);
1967                    ast_copy_string(fnamebuf,fnamebuf2,sizeof(fnamebuf));
1968                 }
1969 #ifdef SOLARIS
1970                         glob_ret = glob(fnamebuf, GLOB_NOCHECK, NULL, &globbuf);
1971 #else
1972                         glob_ret = glob(fnamebuf, GLOB_NOMAGIC|GLOB_BRACE, NULL, &globbuf);
1973 #endif
1974                         if (glob_ret == GLOB_NOSPACE) {
1975                                 ast_log(LOG_WARNING,
1976                                         "Glob Expansion of pattern '%s' failed: Not enough memory\n", fnamebuf);
1977                         } else if (glob_ret  == GLOB_ABORTED) {
1978                                 ast_log(LOG_WARNING,
1979                                         "Glob Expansion of pattern '%s' failed: Read error\n", fnamebuf);
1980                         } else if (glob_ret  == GLOB_NOMATCH) {
1981                                 ast_log(LOG_WARNING,
1982                                         "Glob Expansion of pattern '%s' failed: No matches!\n", fnamebuf);
1983                         } else {
1984                           globbuf_pos = 0;
1985                         }
1986                 }
1987                 if (globbuf_pos > -1) {
1988                         setup_filestack(fnamebuf, sizeof(fnamebuf), &globbuf, 0, yyscanner, 1);
1989                 }
1990         }
1991         YY_BREAK
1992 case YY_STATE_EOF(INITIAL):
1993 case YY_STATE_EOF(paren):
1994 case YY_STATE_EOF(semic):
1995 case YY_STATE_EOF(argg):
1996 case YY_STATE_EOF(comment):
1997 case YY_STATE_EOF(curlystate):
1998 case YY_STATE_EOF(wordstate):
1999 case YY_STATE_EOF(brackstate):
2000 #line 622 "ael.flex"
2001 {
2002                 char fnamebuf[2048];
2003                 if (include_stack_index > 0 && include_stack[include_stack_index-1].globbuf_pos < include_stack[include_stack_index-1].globbuf.gl_pathc-1) {
2004                         ael_yy_delete_buffer(YY_CURRENT_BUFFER,yyscanner );
2005                         include_stack[include_stack_index-1].globbuf_pos++;
2006                         setup_filestack(fnamebuf, sizeof(fnamebuf), &include_stack[include_stack_index-1].globbuf, include_stack[include_stack_index-1].globbuf_pos, yyscanner, 0);
2007                         /* finish this */                       
2008                         
2009                 } else {
2010                         if (include_stack[include_stack_index].fname) {
2011                                 free(include_stack[include_stack_index].fname);
2012                                 include_stack[include_stack_index].fname = 0;
2013                         }
2014                         if (my_file) {
2015                                 free(my_file);
2016                                 my_file = 0;
2017                         }
2018                         if ( --include_stack_index < 0 ) {
2019                                 yyterminate();
2020                         } else {
2021                                 globfree(&include_stack[include_stack_index].globbuf);
2022                                 include_stack[include_stack_index].globbuf_pos = -1;
2023                                 
2024                                 ael_yy_delete_buffer(YY_CURRENT_BUFFER,yyscanner );
2025                                 ael_yy_switch_to_buffer(include_stack[include_stack_index].bufstate,yyscanner );
2026                                 my_lineno = include_stack[include_stack_index].lineno;
2027                                 my_col    = include_stack[include_stack_index].colno;
2028                                 my_file   = strdup(include_stack[include_stack_index].fname);
2029                         }
2030                 }
2031         }
2032         YY_BREAK
2033 case 75:
2034 /* rule 75 can match eol */
2035 YY_RULE_SETUP
2036 #line 654 "ael.flex"
2037 { /* default rule */ ast_log(LOG_ERROR,"Unhandled char(s): %s\n", yytext); }
2038         YY_BREAK
2039 case 76:
2040 YY_RULE_SETUP
2041 #line 656 "ael.flex"
2042 YY_FATAL_ERROR( "flex scanner jammed" );
2043         YY_BREAK
2044 #line 2043 "ael_lex.c"
2045
2046         case YY_END_OF_BUFFER:
2047                 {
2048                 /* Amount of text matched not including the EOB char. */
2049                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
2050
2051                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2052                 *yy_cp = yyg->yy_hold_char;
2053                 YY_RESTORE_YY_MORE_OFFSET
2054
2055                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2056                         {
2057                         /* We're scanning a new file or input source.  It's
2058                          * possible that this happened because the user
2059                          * just pointed yyin at a new source and called
2060                          * ael_yylex().  If so, then we have to assure
2061                          * consistency between YY_CURRENT_BUFFER and our
2062                          * globals.  Here is the right place to do so, because
2063                          * this is the first action (other than possibly a
2064                          * back-up) that will match for the new input source.
2065                          */
2066                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2067                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
2068                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2069                         }
2070
2071                 /* Note that here we test for yy_c_buf_p "<=" to the position
2072                  * of the first EOB in the buffer, since yy_c_buf_p will
2073                  * already have been incremented past the NUL character
2074                  * (since all states make transitions on EOB to the
2075                  * end-of-buffer state).  Contrast this with the test
2076                  * in input().
2077                  */
2078                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
2079                         { /* This was really a NUL. */
2080                         yy_state_type yy_next_state;
2081
2082                         yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
2083
2084                         yy_current_state = yy_get_previous_state( yyscanner );
2085
2086                         /* Okay, we're now positioned to make the NUL
2087                          * transition.  We couldn't have
2088                          * yy_get_previous_state() go ahead and do it
2089                          * for us because it doesn't know how to deal
2090                          * with the possibility of jamming (and we don't
2091                          * want to build jamming into it because then it
2092                          * will run more slowly).
2093                          */
2094
2095                         yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
2096
2097                         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
2098
2099                         if ( yy_next_state )
2100                                 {
2101                                 /* Consume the NUL. */
2102                                 yy_cp = ++yyg->yy_c_buf_p;
2103                                 yy_current_state = yy_next_state;
2104                                 goto yy_match;
2105                                 }
2106
2107                         else
2108                                 {
2109                                 yy_cp = yyg->yy_last_accepting_cpos;
2110                                 yy_current_state = yyg->yy_last_accepting_state;
2111                                 goto yy_find_action;
2112                                 }
2113                         }
2114
2115                 else switch ( yy_get_next_buffer( yyscanner ) )
2116                         {
2117                         case EOB_ACT_END_OF_FILE:
2118                                 {
2119                                 yyg->yy_did_buffer_switch_on_eof = 0;
2120
2121                                 if ( ael_yywrap(yyscanner ) )
2122                                         {
2123                                         /* Note: because we've taken care in
2124                                          * yy_get_next_buffer() to have set up
2125                                          * yytext, we can now set up
2126                                          * yy_c_buf_p so that if some total
2127                                          * hoser (like flex itself) wants to
2128                                          * call the scanner after we return the
2129                                          * YY_NULL, it'll still work - another
2130                                          * YY_NULL will get returned.
2131                                          */
2132                                         yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
2133
2134                                         yy_act = YY_STATE_EOF(YY_START);
2135                                         goto do_action;
2136                                         }
2137
2138                                 else
2139                                         {
2140                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
2141                                                 YY_NEW_FILE;
2142                                         }
2143                                 break;
2144                                 }
2145
2146                         case EOB_ACT_CONTINUE_SCAN:
2147                                 yyg->yy_c_buf_p =
2148                                         yyg->yytext_ptr + yy_amount_of_matched_text;
2149
2150                                 yy_current_state = yy_get_previous_state( yyscanner );
2151
2152                                 yy_cp = yyg->yy_c_buf_p;
2153                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
2154                                 goto yy_match;
2155
2156                         case EOB_ACT_LAST_MATCH:
2157                                 yyg->yy_c_buf_p =
2158                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
2159
2160                                 yy_current_state = yy_get_previous_state( yyscanner );
2161
2162                                 yy_cp = yyg->yy_c_buf_p;
2163                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
2164                                 goto yy_find_action;
2165                         }
2166                 break;
2167                 }
2168
2169         default:
2170                 YY_FATAL_ERROR(
2171                         "fatal flex scanner internal error--no action found" );
2172         } /* end of action switch */
2173                 } /* end of scanning one token */
2174 } /* end of ael_yylex */
2175
2176 /* yy_get_next_buffer - try to read in a new buffer
2177  *
2178  * Returns a code representing an action:
2179  *      EOB_ACT_LAST_MATCH -
2180  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2181  *      EOB_ACT_END_OF_FILE - end of file
2182  */
2183 static int yy_get_next_buffer (yyscan_t yyscanner)
2184 {
2185     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2186         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2187         register char *source = yyg->yytext_ptr;
2188         register int number_to_move, i;
2189         int ret_val;
2190
2191         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
2192                 YY_FATAL_ERROR(
2193                 "fatal flex scanner internal error--end of buffer missed" );
2194
2195         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2196                 { /* Don't try to fill the buffer, so this is an EOF. */
2197                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
2198                         {
2199                         /* We matched a single character, the EOB, so
2200                          * treat this as a final EOF.
2201                          */
2202                         return EOB_ACT_END_OF_FILE;
2203                         }
2204
2205                 else
2206                         {
2207                         /* We matched some text prior to the EOB, first
2208                          * process it.
2209                          */
2210                         return EOB_ACT_LAST_MATCH;
2211                         }
2212                 }
2213
2214         /* Try to read more data. */
2215
2216         /* First move last chars to start of buffer. */
2217         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
2218
2219         for ( i = 0; i < number_to_move; ++i )
2220                 *(dest++) = *(source++);
2221
2222         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2223                 /* don't do the read, it's not guaranteed to return an EOF,
2224                  * just force an EOF
2225                  */
2226                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
2227
2228         else
2229                 {
2230                         int num_to_read =
2231                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2232
2233                 while ( num_to_read <= 0 )
2234                         { /* Not enough room in the buffer - grow it. */
2235
2236                         /* just a shorter name for the current buffer */
2237                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
2238
2239                         int yy_c_buf_p_offset =
2240                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
2241
2242                         if ( b->yy_is_our_buffer )
2243                                 {
2244                                 int new_size = b->yy_buf_size * 2;
2245
2246                                 if ( new_size <= 0 )
2247                                         b->yy_buf_size += b->yy_buf_size / 8;
2248                                 else
2249                                         b->yy_buf_size *= 2;
2250
2251                                 b->yy_ch_buf = (char *)
2252                                         /* Include room in for 2 EOB chars. */
2253                                         ael_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
2254                                 }
2255                         else
2256                                 /* Can't grow it, we don't own it. */
2257                                 b->yy_ch_buf = 0;
2258
2259                         if ( ! b->yy_ch_buf )
2260                                 YY_FATAL_ERROR(
2261                                 "fatal error - scanner input buffer overflow" );
2262
2263                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2264
2265                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2266                                                 number_to_move - 1;
2267
2268                         }
2269
2270                 if ( num_to_read > YY_READ_BUF_SIZE )
2271                         num_to_read = YY_READ_BUF_SIZE;
2272
2273                 /* Read in more data. */
2274                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2275                         yyg->yy_n_chars, (size_t) num_to_read );
2276
2277                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2278                 }
2279
2280         if ( yyg->yy_n_chars == 0 )
2281                 {
2282                 if ( number_to_move == YY_MORE_ADJ )
2283                         {
2284                         ret_val = EOB_ACT_END_OF_FILE;
2285                         ael_yyrestart(yyin  ,yyscanner);
2286                         }
2287
2288                 else
2289                         {
2290                         ret_val = EOB_ACT_LAST_MATCH;
2291                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2292                                 YY_BUFFER_EOF_PENDING;
2293                         }
2294                 }
2295
2296         else
2297                 ret_val = EOB_ACT_CONTINUE_SCAN;
2298
2299         if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2300                 /* Extend the array by 50%, plus the number we really need. */
2301                 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
2302                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) ael_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
2303                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2304                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2305         }
2306
2307         yyg->yy_n_chars += number_to_move;
2308         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2309         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2310
2311         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2312
2313         return ret_val;
2314 }
2315
2316 /* yy_get_previous_state - get the state just before the EOB char was reached */
2317
2318     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
2319 {
2320         register yy_state_type yy_current_state;
2321         register char *yy_cp;
2322     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2323
2324         yy_current_state = yyg->yy_start;
2325
2326         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
2327                 {
2328                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2329                 if ( yy_accept[yy_current_state] )
2330                         {
2331                         yyg->yy_last_accepting_state = yy_current_state;
2332                         yyg->yy_last_accepting_cpos = yy_cp;
2333                         }
2334                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2335                         {
2336                         yy_current_state = (int) yy_def[yy_current_state];
2337                         if ( yy_current_state >= 285 )
2338                                 yy_c = yy_meta[(unsigned int) yy_c];
2339                         }
2340                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2341                 }
2342
2343         return yy_current_state;
2344 }
2345
2346 /* yy_try_NUL_trans - try to make a transition on the NUL character
2347  *
2348  * synopsis
2349  *      next_state = yy_try_NUL_trans( current_state );
2350  */
2351     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
2352 {
2353         register int yy_is_jam;
2354     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
2355         register char *yy_cp = yyg->yy_c_buf_p;
2356
2357         register YY_CHAR yy_c = 1;
2358         if ( yy_accept[yy_current_state] )
2359                 {
2360                 yyg->yy_last_accepting_state = yy_current_state;
2361                 yyg->yy_last_accepting_cpos = yy_cp;
2362                 }
2363         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2364                 {
2365                 yy_current_state = (int) yy_def[yy_current_state];
2366                 if ( yy_current_state >= 285 )
2367                         yy_c = yy_meta[(unsigned int) yy_c];
2368                 }
2369         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2370         yy_is_jam = (yy_current_state == 284);
2371
2372         return yy_is_jam ? 0 : yy_current_state;
2373 }
2374
2375     static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
2376 {
2377         register char *yy_cp;
2378     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2379
2380     yy_cp = yyg->yy_c_buf_p;
2381
2382         /* undo effects of setting up yytext */
2383         *yy_cp = yyg->yy_hold_char;
2384
2385         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2386                 { /* need to shift things up to make room */
2387                 /* +2 for EOB chars. */
2388                 register int number_to_move = yyg->yy_n_chars + 2;
2389                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2390                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2391                 register char *source =
2392                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2393
2394                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2395                         *--dest = *--source;
2396
2397                 yy_cp += (int) (dest - source);
2398                 yy_bp += (int) (dest - source);
2399                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2400                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2401
2402                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2403                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2404                 }
2405
2406         *--yy_cp = (char) c;
2407
2408         yyg->yytext_ptr = yy_bp;
2409         yyg->yy_hold_char = *yy_cp;
2410         yyg->yy_c_buf_p = yy_cp;
2411 }
2412
2413 #ifndef YY_NO_INPUT
2414 #ifdef __cplusplus
2415     static int yyinput (yyscan_t yyscanner)
2416 #else
2417     static int input  (yyscan_t yyscanner)
2418 #endif
2419
2420 {
2421         int c;
2422     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2423
2424         *yyg->yy_c_buf_p = yyg->yy_hold_char;
2425
2426         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2427                 {
2428                 /* yy_c_buf_p now points to the character we want to return.
2429                  * If this occurs *before* the EOB characters, then it's a
2430                  * valid NUL; if not, then we've hit the end of the buffer.
2431                  */
2432                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
2433                         /* This was really a NUL. */
2434                         *yyg->yy_c_buf_p = '\0';
2435
2436                 else
2437                         { /* need more input */
2438                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
2439                         ++yyg->yy_c_buf_p;
2440
2441                         switch ( yy_get_next_buffer( yyscanner ) )
2442                                 {
2443                                 case EOB_ACT_LAST_MATCH:
2444                                         /* This happens because yy_g_n_b()
2445                                          * sees that we've accumulated a
2446                                          * token and flags that we need to
2447                                          * try matching the token before
2448                                          * proceeding.  But for input(),
2449                                          * there's no matching to consider.
2450                                          * So convert the EOB_ACT_LAST_MATCH
2451                                          * to EOB_ACT_END_OF_FILE.
2452                                          */
2453
2454                                         /* Reset buffer status. */
2455                                         ael_yyrestart(yyin ,yyscanner);
2456
2457                                         /*FALLTHROUGH*/
2458
2459                                 case EOB_ACT_END_OF_FILE:
2460                                         {
2461                                         if ( ael_yywrap(yyscanner ) )
2462                                                 return EOF;
2463
2464                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
2465                                                 YY_NEW_FILE;
2466 #ifdef __cplusplus
2467                                         return yyinput(yyscanner);
2468 #else
2469                                         return input(yyscanner);
2470 #endif
2471                                         }
2472
2473                                 case EOB_ACT_CONTINUE_SCAN:
2474                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
2475                                         break;
2476                                 }
2477                         }
2478                 }
2479
2480         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
2481         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
2482         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
2483
2484         return c;
2485 }
2486 #endif  /* ifndef YY_NO_INPUT */
2487
2488 /** Immediately switch to a different input stream.
2489  * @param input_file A readable stream.
2490  * @param yyscanner The scanner object.
2491  * @note This function does not reset the start condition to @c INITIAL .
2492  */
2493     void ael_yyrestart  (FILE * input_file , yyscan_t yyscanner)
2494 {
2495     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2496
2497         if ( ! YY_CURRENT_BUFFER ){
2498         ael_yyensure_buffer_stack (yyscanner);
2499                 YY_CURRENT_BUFFER_LVALUE =
2500             ael_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
2501         }
2502
2503         ael_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
2504         ael_yy_load_buffer_state(yyscanner );
2505 }
2506
2507 /** Switch to a different input buffer.
2508  * @param new_buffer The new input buffer.
2509  * @param yyscanner The scanner object.
2510  */
2511     void ael_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
2512 {
2513     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2514
2515         /* TODO. We should be able to replace this entire function body
2516          * with
2517          *              ael_yypop_buffer_state();
2518          *              ael_yypush_buffer_state(new_buffer);
2519      */
2520         ael_yyensure_buffer_stack (yyscanner);
2521         if ( YY_CURRENT_BUFFER == new_buffer )
2522                 return;
2523
2524         if ( YY_CURRENT_BUFFER )
2525                 {
2526                 /* Flush out information for old buffer. */
2527                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2528                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2529                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2530                 }
2531
2532         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2533         ael_yy_load_buffer_state(yyscanner );
2534
2535         /* We don't actually know whether we did this switch during
2536          * EOF (ael_yywrap()) processing, but the only time this flag
2537          * is looked at is after ael_yywrap() is called, so it's safe
2538          * to go ahead and always set it.
2539          */
2540         yyg->yy_did_buffer_switch_on_eof = 1;
2541 }
2542
2543 static void ael_yy_load_buffer_state  (yyscan_t yyscanner)
2544 {
2545     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2546         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2547         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2548         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2549         yyg->yy_hold_char = *yyg->yy_c_buf_p;
2550 }
2551
2552 /** Allocate and initialize an input buffer state.
2553  * @param file A readable stream.
2554  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2555  * @param yyscanner The scanner object.
2556  * @return the allocated buffer state.
2557  */
2558     YY_BUFFER_STATE ael_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
2559 {
2560         YY_BUFFER_STATE b;
2561     
2562         b = (YY_BUFFER_STATE) ael_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2563         if ( ! b )
2564                 YY_FATAL_ERROR( "out of dynamic memory in ael_yy_create_buffer()" );
2565
2566         b->yy_buf_size = size;
2567
2568         /* yy_ch_buf has to be 2 characters longer than the size given because
2569          * we need to put in 2 end-of-buffer characters.
2570          */
2571         b->yy_ch_buf = (char *) ael_yyalloc(b->yy_buf_size + 2 ,yyscanner );
2572         if ( ! b->yy_ch_buf )
2573                 YY_FATAL_ERROR( "out of dynamic memory in ael_yy_create_buffer()" );
2574
2575         b->yy_is_our_buffer = 1;
2576
2577         ael_yy_init_buffer(b,file ,yyscanner);
2578
2579         return b;
2580 }
2581
2582 /** Destroy the buffer.
2583  * @param b a buffer created with ael_yy_create_buffer()
2584  * @param yyscanner The scanner object.
2585  */
2586     void ael_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
2587 {
2588     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2589
2590         if ( ! b )
2591                 return;
2592
2593         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2594                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2595
2596         if ( b->yy_is_our_buffer )
2597                 ael_yyfree((void *) b->yy_ch_buf ,yyscanner );
2598
2599         ael_yyfree((void *) b ,yyscanner );
2600 }
2601
2602 #ifndef __cplusplus
2603 extern int isatty (int );
2604 #endif /* __cplusplus */
2605     
2606 /* Initializes or reinitializes a buffer.
2607  * This function is sometimes called more than once on the same buffer,
2608  * such as during a ael_yyrestart() or at EOF.
2609  */
2610     static void ael_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
2611
2612 {
2613         int oerrno = errno;
2614     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2615
2616         ael_yy_flush_buffer(b ,yyscanner);
2617
2618         b->yy_input_file = file;
2619         b->yy_fill_buffer = 1;
2620
2621     /* If b is the current buffer, then ael_yy_init_buffer was _probably_
2622      * called from ael_yyrestart() or through yy_get_next_buffer.
2623      * In that case, we don't want to reset the lineno or column.
2624      */
2625     if (b != YY_CURRENT_BUFFER){
2626         b->yy_bs_lineno = 1;
2627         b->yy_bs_column = 0;
2628     }
2629
2630         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2631     
2632         errno = oerrno;
2633 }
2634
2635 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2636  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2637  * @param yyscanner The scanner object.
2638  */
2639     void ael_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
2640 {
2641     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2642         if ( ! b )
2643                 return;
2644
2645         b->yy_n_chars = 0;
2646
2647         /* We always need two end-of-buffer characters.  The first causes
2648          * a transition to the end-of-buffer state.  The second causes
2649          * a jam in that state.
2650          */
2651         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2652         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2653
2654         b->yy_buf_pos = &b->yy_ch_buf[0];
2655
2656         b->yy_at_bol = 1;
2657         b->yy_buffer_status = YY_BUFFER_NEW;
2658
2659         if ( b == YY_CURRENT_BUFFER )
2660                 ael_yy_load_buffer_state(yyscanner );
2661 }
2662
2663 /** Pushes the new state onto the stack. The new state becomes
2664  *  the current state. This function will allocate the stack
2665  *  if necessary.
2666  *  @param new_buffer The new state.
2667  *  @param yyscanner The scanner object.
2668  */
2669 void ael_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
2670 {
2671     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2672         if (new_buffer == NULL)
2673                 return;
2674
2675         ael_yyensure_buffer_stack(yyscanner);
2676
2677         /* This block is copied from ael_yy_switch_to_buffer. */
2678         if ( YY_CURRENT_BUFFER )
2679                 {
2680                 /* Flush out information for old buffer. */
2681                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
2682                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
2683                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
2684                 }
2685
2686         /* Only push if top exists. Otherwise, replace top. */
2687         if (YY_CURRENT_BUFFER)
2688                 yyg->yy_buffer_stack_top++;
2689         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2690
2691         /* copied from ael_yy_switch_to_buffer. */
2692         ael_yy_load_buffer_state(yyscanner );
2693         yyg->yy_did_buffer_switch_on_eof = 1;
2694 }
2695
2696 /** Removes and deletes the top of the stack, if present.
2697  *  The next element becomes the new top.
2698  *  @param yyscanner The scanner object.
2699  */
2700 void ael_yypop_buffer_state (yyscan_t yyscanner)
2701 {
2702     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2703         if (!YY_CURRENT_BUFFER)
2704                 return;
2705
2706         ael_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
2707         YY_CURRENT_BUFFER_LVALUE = NULL;
2708         if (yyg->yy_buffer_stack_top > 0)
2709                 --yyg->yy_buffer_stack_top;
2710
2711         if (YY_CURRENT_BUFFER) {
2712                 ael_yy_load_buffer_state(yyscanner );
2713                 yyg->yy_did_buffer_switch_on_eof = 1;
2714         }
2715 }
2716
2717 /* Allocates the stack if it does not exist.
2718  *  Guarantees space for at least one push.
2719  */
2720 static void ael_yyensure_buffer_stack (yyscan_t yyscanner)
2721 {
2722         int num_to_alloc;
2723     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2724
2725         if (!yyg->yy_buffer_stack) {
2726
2727                 /* First allocation is just for 2 elements, since we don't know if this
2728                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2729                  * immediate realloc on the next call.
2730          */
2731                 num_to_alloc = 1;
2732                 yyg->yy_buffer_stack = (struct yy_buffer_state**)ael_yyalloc
2733                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2734                                                                 , yyscanner);
2735                 if ( ! yyg->yy_buffer_stack )
2736                         YY_FATAL_ERROR( "out of dynamic memory in ael_yyensure_buffer_stack()" );
2737                                                                   
2738                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2739                                 
2740                 yyg->yy_buffer_stack_max = num_to_alloc;
2741                 yyg->yy_buffer_stack_top = 0;
2742                 return;
2743         }
2744
2745         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
2746
2747                 /* Increase the buffer to prepare for a possible push. */
2748                 int grow_size = 8 /* arbitrary grow size */;
2749
2750                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
2751                 yyg->yy_buffer_stack = (struct yy_buffer_state**)ael_yyrealloc
2752                                                                 (yyg->yy_buffer_stack,
2753                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2754                                                                 , yyscanner);
2755                 if ( ! yyg->yy_buffer_stack )
2756                         YY_FATAL_ERROR( "out of dynamic memory in ael_yyensure_buffer_stack()" );
2757
2758                 /* zero only the new slots.*/
2759                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
2760                 yyg->yy_buffer_stack_max = num_to_alloc;
2761         }
2762 }
2763
2764 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2765  * @param base the character buffer
2766  * @param size the size in bytes of the character buffer
2767  * @param yyscanner The scanner object.
2768  * @return the newly allocated buffer state object. 
2769  */
2770 YY_BUFFER_STATE ael_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
2771 {
2772         YY_BUFFER_STATE b;
2773     
2774         if ( size < 2 ||
2775              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2776              base[size-1] != YY_END_OF_BUFFER_CHAR )
2777                 /* They forgot to leave room for the EOB's. */
2778                 return 0;
2779
2780         b = (YY_BUFFER_STATE) ael_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
2781         if ( ! b )
2782                 YY_FATAL_ERROR( "out of dynamic memory in ael_yy_scan_buffer()" );
2783
2784         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2785         b->yy_buf_pos = b->yy_ch_buf = base;
2786         b->yy_is_our_buffer = 0;
2787         b->yy_input_file = 0;
2788         b->yy_n_chars = b->yy_buf_size;
2789         b->yy_is_interactive = 0;
2790         b->yy_at_bol = 1;
2791         b->yy_fill_buffer = 0;
2792         b->yy_buffer_status = YY_BUFFER_NEW;
2793
2794         ael_yy_switch_to_buffer(b ,yyscanner );
2795
2796         return b;
2797 }
2798
2799 /** Setup the input buffer state to scan a string. The next call to ael_yylex() will
2800  * scan from a @e copy of @a str.
2801  * @param yystr a NUL-terminated string to scan
2802  * @param yyscanner The scanner object.
2803  * @return the newly allocated buffer state object.
2804  * @note If you want to scan bytes that may contain NUL values, then use
2805  *       ael_yy_scan_bytes() instead.
2806  */
2807 YY_BUFFER_STATE ael_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
2808 {
2809     
2810         return ael_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
2811 }
2812
2813 /** Setup the input buffer state to scan the given bytes. The next call to ael_yylex() will
2814  * scan from a @e copy of @a bytes.
2815  * @param bytes the byte buffer to scan
2816  * @param len the number of bytes in the buffer pointed to by @a bytes.
2817  * @param yyscanner The scanner object.
2818  * @return the newly allocated buffer state object.
2819  */
2820 YY_BUFFER_STATE ael_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
2821 {
2822         YY_BUFFER_STATE b;
2823         char *buf;
2824         yy_size_t n;
2825         int i;
2826     
2827         /* Get memory for full buffer, including space for trailing EOB's. */
2828         n = _yybytes_len + 2;
2829         buf = (char *) ael_yyalloc(n ,yyscanner );
2830         if ( ! buf )
2831                 YY_FATAL_ERROR( "out of dynamic memory in ael_yy_scan_bytes()" );
2832
2833         for ( i = 0; i < _yybytes_len; ++i )
2834                 buf[i] = yybytes[i];
2835
2836         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2837
2838         b = ael_yy_scan_buffer(buf,n ,yyscanner);
2839         if ( ! b )
2840                 YY_FATAL_ERROR( "bad buffer in ael_yy_scan_bytes()" );
2841
2842         /* It's okay to grow etc. this buffer, and we should throw it
2843          * away when we're done.
2844          */
2845         b->yy_is_our_buffer = 1;
2846
2847         return b;
2848 }
2849
2850 #ifndef YY_EXIT_FAILURE
2851 #define YY_EXIT_FAILURE 2
2852 #endif
2853
2854 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
2855 {
2856         (void) fprintf( stderr, "%s\n", msg );
2857         exit( YY_EXIT_FAILURE );
2858 }
2859
2860 /* Redefine yyless() so it works in section 3 code. */
2861
2862 #undef yyless
2863 #define yyless(n) \
2864         do \
2865                 { \
2866                 /* Undo effects of setting up yytext. */ \
2867         int yyless_macro_arg = (n); \
2868         YY_LESS_LINENO(yyless_macro_arg);\
2869                 yytext[yyleng] = yyg->yy_hold_char; \
2870                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
2871                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
2872                 *yyg->yy_c_buf_p = '\0'; \
2873                 yyleng = yyless_macro_arg; \
2874                 } \
2875         while ( 0 )
2876
2877 /* Accessor  methods (get/set functions) to struct members. */
2878
2879 /** Get the user-defined data for this scanner.
2880  * @param yyscanner The scanner object.
2881  */
2882 YY_EXTRA_TYPE ael_yyget_extra  (yyscan_t yyscanner)
2883 {
2884     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2885     return yyextra;
2886 }
2887
2888 /** Get the current line number.
2889  * @param yyscanner The scanner object.
2890  */
2891 int ael_yyget_lineno  (yyscan_t yyscanner)
2892 {
2893     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2894     
2895         if (! YY_CURRENT_BUFFER)
2896             return 0;
2897     
2898     return yylineno;
2899 }
2900
2901 /** Get the current column number.
2902  * @param yyscanner The scanner object.
2903  */
2904 int ael_yyget_column  (yyscan_t yyscanner)
2905 {
2906     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2907     
2908         if (! YY_CURRENT_BUFFER)
2909             return 0;
2910     
2911     return yycolumn;
2912 }
2913
2914 /** Get the input stream.
2915  * @param yyscanner The scanner object.
2916  */
2917 FILE *ael_yyget_in  (yyscan_t yyscanner)
2918 {
2919     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2920     return yyin;
2921 }
2922
2923 /** Get the output stream.
2924  * @param yyscanner The scanner object.
2925  */
2926 FILE *ael_yyget_out  (yyscan_t yyscanner)
2927 {
2928     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2929     return yyout;
2930 }
2931
2932 /** Get the length of the current token.
2933  * @param yyscanner The scanner object.
2934  */
2935 int ael_yyget_leng  (yyscan_t yyscanner)
2936 {
2937     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2938     return yyleng;
2939 }
2940
2941 /** Get the current token.
2942  * @param yyscanner The scanner object.
2943  */
2944
2945 char *ael_yyget_text  (yyscan_t yyscanner)
2946 {
2947     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2948     return yytext;
2949 }
2950
2951 /** Set the user-defined data. This data is never touched by the scanner.
2952  * @param user_defined The data to be associated with this scanner.
2953  * @param yyscanner The scanner object.
2954  */
2955 void ael_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
2956 {
2957     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2958     yyextra = user_defined ;
2959 }
2960
2961 /** Set the current line number.
2962  * @param line_number
2963  * @param yyscanner The scanner object.
2964  */
2965 void ael_yyset_lineno (int  line_number , yyscan_t yyscanner)
2966 {
2967     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2968
2969         /* lineno is only valid if an input buffer exists. */
2970         if (! YY_CURRENT_BUFFER )
2971            yy_fatal_error( "ael_yyset_lineno called with no buffer" , yyscanner); 
2972     
2973     yylineno = line_number;
2974 }
2975
2976 /** Set the current column.
2977  * @param line_number
2978  * @param yyscanner The scanner object.
2979  */
2980 void ael_yyset_column (int  column_no , yyscan_t yyscanner)
2981 {
2982     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2983
2984         /* column is only valid if an input buffer exists. */
2985         if (! YY_CURRENT_BUFFER )
2986            yy_fatal_error( "ael_yyset_column called with no buffer" , yyscanner); 
2987     
2988     yycolumn = column_no;
2989 }
2990
2991 /** Set the input stream. This does not discard the current
2992  * input buffer.
2993  * @param in_str A readable stream.
2994  * @param yyscanner The scanner object.
2995  * @see ael_yy_switch_to_buffer
2996  */
2997 void ael_yyset_in (FILE *  in_str , yyscan_t yyscanner)
2998 {
2999     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3000     yyin = in_str ;
3001 }
3002
3003 void ael_yyset_out (FILE *  out_str , yyscan_t yyscanner)
3004 {
3005     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3006     yyout = out_str ;
3007 }
3008
3009 int ael_yyget_debug  (yyscan_t yyscanner)
3010 {
3011     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3012     return yy_flex_debug;
3013 }
3014
3015 void ael_yyset_debug (int  bdebug , yyscan_t yyscanner)
3016 {
3017     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3018     yy_flex_debug = bdebug ;
3019 }
3020
3021 /* Accessor methods for yylval and yylloc */
3022
3023 YYSTYPE * ael_yyget_lval  (yyscan_t yyscanner)
3024 {
3025     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3026     return yylval;
3027 }
3028
3029 void ael_yyset_lval (YYSTYPE *  yylval_param , yyscan_t yyscanner)
3030 {
3031     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3032     yylval = yylval_param;
3033 }
3034
3035 YYLTYPE *ael_yyget_lloc  (yyscan_t yyscanner)
3036 {
3037     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3038     return yylloc;
3039 }
3040     
3041 void ael_yyset_lloc (YYLTYPE *  yylloc_param , yyscan_t yyscanner)
3042 {
3043     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3044     yylloc = yylloc_param;
3045 }
3046     
3047 /* User-visible API */
3048
3049 /* ael_yylex_init is special because it creates the scanner itself, so it is
3050  * the ONLY reentrant function that doesn't take the scanner as the last argument.
3051  * That's why we explicitly handle the declaration, instead of using our macros.
3052  */
3053
3054 int ael_yylex_init(yyscan_t* ptr_yy_globals)
3055
3056 {
3057     if (ptr_yy_globals == NULL){
3058         errno = EINVAL;
3059         return 1;
3060     }
3061
3062     *ptr_yy_globals = (yyscan_t) ael_yyalloc ( sizeof( struct yyguts_t ), NULL );
3063
3064     if (*ptr_yy_globals == NULL){
3065         errno = ENOMEM;
3066         return 1;
3067     }
3068
3069     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
3070     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
3071
3072     return yy_init_globals ( *ptr_yy_globals );
3073 }
3074
3075 /* ael_yylex_init_extra has the same functionality as ael_yylex_init, but follows the
3076  * convention of taking the scanner as the last argument. Note however, that
3077  * this is a *pointer* to a scanner, as it will be allocated by this call (and
3078  * is the reason, too, why this function also must handle its own declaration).
3079  * The user defined value in the first argument will be available to ael_yyalloc in
3080  * the yyextra field.
3081  */
3082
3083 int ael_yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
3084
3085 {
3086     struct yyguts_t dummy_yyguts;
3087
3088     ael_yyset_extra (yy_user_defined, &dummy_yyguts);
3089
3090     if (ptr_yy_globals == NULL){
3091         errno = EINVAL;
3092         return 1;
3093     }
3094         
3095     *ptr_yy_globals = (yyscan_t) ael_yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
3096         
3097     if (*ptr_yy_globals == NULL){
3098         errno = ENOMEM;
3099         return 1;
3100     }
3101     
3102     /* By setting to 0xAA, we expose bugs in
3103     yy_init_globals. Leave at 0x00 for releases. */
3104     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
3105     
3106     ael_yyset_extra (yy_user_defined, *ptr_yy_globals);
3107     
3108     return yy_init_globals ( *ptr_yy_globals );
3109 }
3110
3111 static int yy_init_globals (yyscan_t yyscanner)
3112 {
3113     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3114     /* Initialization is the same as for the non-reentrant scanner.
3115      * This function is called from ael_yylex_destroy(), so don't allocate here.
3116      */
3117
3118     yyg->yy_buffer_stack = 0;
3119     yyg->yy_buffer_stack_top = 0;
3120     yyg->yy_buffer_stack_max = 0;
3121     yyg->yy_c_buf_p = (char *) 0;
3122     yyg->yy_init = 0;
3123     yyg->yy_start = 0;
3124
3125     yyg->yy_start_stack_ptr = 0;
3126     yyg->yy_start_stack_depth = 0;
3127     yyg->yy_start_stack =  NULL;
3128
3129 /* Defined in main.c */
3130 #ifdef YY_STDINIT
3131     yyin = stdin;
3132     yyout = stdout;
3133 #else
3134     yyin = (FILE *) 0;
3135     yyout = (FILE *) 0;
3136 #endif
3137
3138     /* For future reference: Set errno on error, since we are called by
3139      * ael_yylex_init()
3140      */
3141     return 0;
3142 }
3143
3144 /* ael_yylex_destroy is for both reentrant and non-reentrant scanners. */
3145 int ael_yylex_destroy  (yyscan_t yyscanner)
3146 {
3147     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3148
3149     /* Pop the buffer stack, destroying each element. */
3150         while(YY_CURRENT_BUFFER){
3151                 ael_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
3152                 YY_CURRENT_BUFFER_LVALUE = NULL;
3153                 ael_yypop_buffer_state(yyscanner);
3154         }
3155
3156         /* Destroy the stack itself. */
3157         ael_yyfree(yyg->yy_buffer_stack ,yyscanner);
3158         yyg->yy_buffer_stack = NULL;
3159
3160     /* Destroy the start condition stack. */
3161         ael_yyfree(yyg->yy_start_stack ,yyscanner );
3162         yyg->yy_start_stack = NULL;
3163
3164     /* Reset the globals. This is important in a non-reentrant scanner so the next time
3165      * ael_yylex() is called, initialization will occur. */
3166     yy_init_globals( yyscanner);
3167
3168     /* Destroy the main struct (reentrant only). */
3169     ael_yyfree ( yyscanner , yyscanner );
3170     yyscanner = NULL;
3171     return 0;
3172 }
3173
3174 /*
3175  * Internal utility routines.
3176  */
3177
3178 #ifndef yytext_ptr
3179 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
3180 {
3181         register int i;
3182         for ( i = 0; i < n; ++i )
3183                 s1[i] = s2[i];
3184 }
3185 #endif
3186
3187 #ifdef YY_NEED_STRLEN
3188 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
3189 {
3190         register int n;
3191         for ( n = 0; s[n]; ++n )
3192                 ;
3193
3194         return n;
3195 }
3196 #endif
3197
3198 void *ael_yyalloc (yy_size_t  size , yyscan_t yyscanner)
3199 {
3200         return (void *) malloc( size );
3201 }
3202
3203 void *ael_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
3204 {
3205         /* The cast to (char *) in the following accommodates both
3206          * implementations that use char* generic pointers, and those
3207          * that use void* generic pointers.  It works with the latter
3208          * because both ANSI C and C++ allow castless assignment from
3209          * any pointer type to void*, and deal with argument conversions
3210          * as though doing an assignment.
3211          */
3212         return (void *) realloc( (char *) ptr, size );
3213 }
3214
3215 #define YYTABLES_NAME "yytables"
3216
3217 #line 656 "ael.flex"
3218
3219
3220
3221 static void pbcpush(char x)
3222 {
3223         pbcstack[pbcpos++] = x;
3224 }
3225
3226 void ael_yyfree(void *ptr, yyscan_t yyscanner)
3227 {
3228         if (ptr)
3229                 free( (char*) ptr );
3230 }
3231
3232 static int pbcpop(char x)
3233 {
3234         if (   ( x == ')' && pbcstack[pbcpos-1] == '(' )
3235                 || ( x == ']' && pbcstack[pbcpos-1] == '[' )
3236                 || ( x == '}' && pbcstack[pbcpos-1] == '{' )) {
3237                 pbcpos--;
3238                 return 0;
3239         }
3240         return 1; /* error */
3241 }
3242
3243 static void pbcpush2(char x)
3244 {
3245         pbcstack2[pbcpos2++] = x;
3246 }
3247
3248 static int pbcpop2(char x)
3249 {
3250         if (   ( x == ')' && pbcstack2[pbcpos2-1] == '(' )
3251                 || ( x == ']' && pbcstack2[pbcpos2-1] == '[' )
3252                 || ( x == '}' && pbcstack2[pbcpos2-1] == '{' )) {
3253                 pbcpos2--;
3254                 return 0;
3255         }
3256         return 1; /* error */
3257 }
3258
3259 static void pbcpush3(char x)
3260 {
3261         pbcstack3[pbcpos3++] = x;
3262 }
3263
3264 static int pbcpop3(char x)
3265 {
3266         if (   ( x == ')' && pbcstack3[pbcpos3-1] == '(' )
3267                 || ( x == ']' && pbcstack3[pbcpos3-1] == '[' )
3268                 || ( x == '}' && pbcstack3[pbcpos3-1] == '{' )) {
3269                 pbcpos3--;
3270                 return 0;
3271         }
3272         return 1; /* error */
3273 }
3274
3275 static int c_prevword(void)
3276 {
3277         char *c = prev_word;
3278         if (c == NULL)
3279                 return 0;
3280         while ( *c ) {
3281                 switch (*c) {
3282                 case '{':
3283                 case '[':
3284                 case '(':
3285                         pbcpush(*c);
3286                         break;
3287                 case '}':
3288                 case ']':
3289                 case ')':
3290                         if (pbcpop(*c))
3291                                 return 1;
3292                         break;
3293                 }
3294                 c++;
3295         }
3296         return 0;
3297 }
3298
3299
3300 /*
3301  * The following three functions, reset_*, are used in the bison
3302  * code to switch context. As a consequence, we need to
3303  * declare them global and add a prototype so that the
3304  * compiler does not complain.
3305  *
3306  * NOTE: yyg is declared because it is used in the BEGIN macros,
3307  * though that should be hidden as the macro changes
3308  * depending on the flex options that we use - in particular,
3309  * %reentrant changes the way the macro is declared;
3310  * without %reentrant, BEGIN uses yystart instead of yyg
3311  */
3312
3313 void reset_parencount(yyscan_t yyscanner );
3314 void reset_parencount(yyscan_t yyscanner )
3315 {
3316         struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3317         parencount = 0;
3318         pbcpos = 0;
3319         pbcpush('(');   /* push '(' so the last pcbpop (parencount= -1) will succeed */
3320         c_prevword();
3321         BEGIN(paren);
3322 }
3323
3324 void reset_semicount(yyscan_t yyscanner );
3325 void reset_semicount(yyscan_t yyscanner )
3326 {
3327         struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3328         pbcpos = 0;
3329         BEGIN(semic);
3330 }
3331
3332 void reset_argcount(yyscan_t yyscanner );
3333 void reset_argcount(yyscan_t yyscanner )
3334 {
3335         struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3336         parencount = 0;
3337         pbcpos = 0;
3338         pbcpush('(');   /* push '(' so the last pcbpop (parencount= -1) will succeed */
3339         c_prevword();
3340         BEGIN(argg);
3341 }
3342
3343 /* used elsewhere, but some local vars */
3344 struct pval *ael2_parse(char *filename, int *errors)
3345 {
3346         struct pval *pvalue;
3347         struct parse_io *io;
3348         char *buffer;
3349         struct stat stats;
3350         FILE *fin;
3351
3352         /* extern int ael_yydebug; */
3353
3354         io = calloc(sizeof(struct parse_io),1);
3355         /* reset the global counters */
3356         prev_word = 0;
3357         my_lineno = 1;
3358         include_stack_index=0;
3359         my_col = 0;
3360         /* ael_yydebug = 1; */
3361         ael_yylex_init(&io->scanner);
3362         fin = fopen(filename,"r");
3363         if ( !fin ) {
3364                 ast_log(LOG_ERROR,"File %s could not be opened\n", filename);
3365                 *errors = 1;
3366                 return 0;
3367         }
3368         if (my_file)
3369                 free(my_file);
3370         my_file = strdup(filename);
3371         stat(filename, &stats);
3372         buffer = (char*)malloc(stats.st_size+2);
3373         if (fread(buffer, 1, stats.st_size, fin) != stats.st_size) {
3374                 ast_log(LOG_ERROR, "fread() failed: %s\n", strerror(errno));
3375         }                       
3376         buffer[stats.st_size]=0;
3377         fclose(fin);
3378
3379         ael_yy_scan_string (buffer ,io->scanner);
3380         ael_yyset_lineno(1 , io->scanner);
3381
3382         /* ael_yyset_in (fin , io->scanner);    OLD WAY */
3383
3384         ael_yyparse(io);
3385
3386
3387         pvalue = io->pval;
3388         *errors = io->syntax_error_count;
3389
3390         ael_yylex_destroy(io->scanner);
3391         free(buffer);
3392         free(io);
3393
3394         return pvalue;
3395 }
3396
3397 static void setup_filestack(char *fnamebuf2, int fnamebuf_siz, glob_t *globbuf, int globpos, yyscan_t yyscanner, int create)
3398 {
3399         struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
3400         int error, i;
3401         FILE *in1;
3402         char fnamebuf[2048];
3403
3404         if (globbuf && globbuf->gl_pathv && globbuf->gl_pathc > 0)
3405 #if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE_AEL)
3406                         strncpy(fnamebuf, globbuf->gl_pathv[globpos], fnamebuf_siz);
3407 #else
3408                         ast_copy_string(fnamebuf, globbuf->gl_pathv[globpos], fnamebuf_siz);
3409 #endif
3410         else {
3411                 ast_log(LOG_ERROR,"Include file name not present!\n");
3412                 return;
3413         }
3414         for (i=0; i<include_stack_index; i++) {
3415                 if ( !strcmp(fnamebuf,include_stack[i].fname )) {
3416                         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",
3417                                 my_file, my_lineno, my_col, fnamebuf);
3418                         break;
3419                 }
3420         }
3421         error = 1;
3422         if (i == include_stack_index)
3423                 error = 0;      /* we can use this file */
3424         if ( !error ) { /* valid file name */
3425                 /* relative vs. absolute */
3426                 if (fnamebuf[0] != '/')
3427                         snprintf(fnamebuf2, fnamebuf_siz, "%s/%s", ast_config_AST_CONFIG_DIR, fnamebuf);
3428                 else
3429 #if defined(STANDALONE) || defined(LOW_MEMORY) || defined(STANDALONE_AEL)
3430                         strncpy(fnamebuf2, fnamebuf, fnamebuf_siz);
3431 #else
3432                         ast_copy_string(fnamebuf2, fnamebuf, fnamebuf_siz);
3433 #endif
3434                 in1 = fopen( fnamebuf2, "r" );
3435
3436                 if ( ! in1 ) {
3437                         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);
3438                 } else {
3439                         char *buffer;
3440                         struct stat stats;
3441                         stat(fnamebuf2, &stats);
3442                         buffer = (char*)malloc(stats.st_size+1);
3443                         if (fread(buffer, 1, stats.st_size, in1) != stats.st_size) {
3444                                 ast_log(LOG_ERROR, "fread() failed: %s\n", strerror(errno));
3445                         }                       
3446                         buffer[stats.st_size] = 0;
3447                         ast_log(LOG_NOTICE,"  --Read in included file %s, %d chars\n",fnamebuf2, (int)stats.st_size);
3448                         fclose(in1);
3449                         if (include_stack[include_stack_index].fname) {
3450                                 free(include_stack[include_stack_index].fname);
3451                                 include_stack[include_stack_index].fname = 0;
3452                         }
3453                         include_stack[include_stack_index].fname = strdup(S_OR(my_file, "<none>"));
3454                         include_stack[include_stack_index].lineno = my_lineno;
3455                         include_stack[include_stack_index].colno = my_col+yyleng;
3456                         if (my_file)
3457                                 free(my_file);
3458                         my_file = strdup(fnamebuf2);
3459                         if (create)
3460                                 include_stack[include_stack_index].globbuf = *globbuf;
3461
3462                         include_stack[include_stack_index].globbuf_pos = 0;
3463
3464                         include_stack[include_stack_index].bufstate = YY_CURRENT_BUFFER;
3465                         if (create)
3466                                 include_stack_index++;
3467                         ael_yy_switch_to_buffer(ael_yy_scan_string (buffer ,yyscanner),yyscanner);
3468                         free(buffer);
3469                         my_lineno = 1;
3470                         my_col = 1;
3471                         BEGIN(INITIAL);
3472                 }
3473         }
3474 }
3475