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