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