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