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