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