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