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