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