remove useless 'extern' declaration
[asterisk/asterisk.git] / pbx / ael / ael.tab.c
1 /* A Bison parser, made by GNU Bison 2.1.  */
2
3 /* Skeleton parser for Yacc-like parsing with Bison,
4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2, or (at your option)
9    any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street, Fifth Floor,
19    Boston, MA 02110-1301, USA.  */
20
21 /* As a special exception, when this file is copied by Bison into a
22    Bison output file, you may use that output file without restriction.
23    This special exception was added by the Free Software Foundation
24    in version 1.24 of Bison.  */
25
26 /* Written by Richard Stallman by simplifying the original so called
27    ``semantic'' parser.  */
28
29 /* All symbols defined below should begin with yy or YY, to avoid
30    infringing on user name space.  This should be done even for local
31    variables, as they might otherwise be expanded by user macros.
32    There are some unavoidable exceptions within include files to
33    define necessary library symbols; they are noted "INFRINGES ON
34    USER NAME SPACE" below.  */
35
36 /* Identify Bison output.  */
37 #define YYBISON 1
38
39 /* Bison version.  */
40 #define YYBISON_VERSION "2.1"
41
42 /* Skeleton name.  */
43 #define YYSKELETON_NAME "yacc.c"
44
45 /* Pure parsers.  */
46 #define YYPURE 1
47
48 /* Using locations.  */
49 #define YYLSP_NEEDED 1
50
51 /* Substitute the variable and function names.  */
52 #define yyparse ael_yyparse
53 #define yylex   ael_yylex
54 #define yyerror ael_yyerror
55 #define yylval  ael_yylval
56 #define yychar  ael_yychar
57 #define yydebug ael_yydebug
58 #define yynerrs ael_yynerrs
59 #define yylloc ael_yylloc
60
61 /* Tokens.  */
62 #ifndef YYTOKENTYPE
63 # define YYTOKENTYPE
64    /* Put the tokens into the symbol table, so that GDB and other debuggers
65       know about them.  */
66    enum yytokentype {
67      KW_CONTEXT = 258,
68      LC = 259,
69      RC = 260,
70      LP = 261,
71      RP = 262,
72      SEMI = 263,
73      EQ = 264,
74      COMMA = 265,
75      COLON = 266,
76      AMPER = 267,
77      BAR = 268,
78      AT = 269,
79      KW_MACRO = 270,
80      KW_GLOBALS = 271,
81      KW_IGNOREPAT = 272,
82      KW_SWITCH = 273,
83      KW_IF = 274,
84      KW_IFTIME = 275,
85      KW_ELSE = 276,
86      KW_RANDOM = 277,
87      KW_ABSTRACT = 278,
88      EXTENMARK = 279,
89      KW_GOTO = 280,
90      KW_JUMP = 281,
91      KW_RETURN = 282,
92      KW_BREAK = 283,
93      KW_CONTINUE = 284,
94      KW_REGEXTEN = 285,
95      KW_HINT = 286,
96      KW_FOR = 287,
97      KW_WHILE = 288,
98      KW_CASE = 289,
99      KW_PATTERN = 290,
100      KW_DEFAULT = 291,
101      KW_CATCH = 292,
102      KW_SWITCHES = 293,
103      KW_ESWITCHES = 294,
104      KW_INCLUDES = 295,
105      word = 296
106    };
107 #endif
108 /* Tokens.  */
109 #define KW_CONTEXT 258
110 #define LC 259
111 #define RC 260
112 #define LP 261
113 #define RP 262
114 #define SEMI 263
115 #define EQ 264
116 #define COMMA 265
117 #define COLON 266
118 #define AMPER 267
119 #define BAR 268
120 #define AT 269
121 #define KW_MACRO 270
122 #define KW_GLOBALS 271
123 #define KW_IGNOREPAT 272
124 #define KW_SWITCH 273
125 #define KW_IF 274
126 #define KW_IFTIME 275
127 #define KW_ELSE 276
128 #define KW_RANDOM 277
129 #define KW_ABSTRACT 278
130 #define EXTENMARK 279
131 #define KW_GOTO 280
132 #define KW_JUMP 281
133 #define KW_RETURN 282
134 #define KW_BREAK 283
135 #define KW_CONTINUE 284
136 #define KW_REGEXTEN 285
137 #define KW_HINT 286
138 #define KW_FOR 287
139 #define KW_WHILE 288
140 #define KW_CASE 289
141 #define KW_PATTERN 290
142 #define KW_DEFAULT 291
143 #define KW_CATCH 292
144 #define KW_SWITCHES 293
145 #define KW_ESWITCHES 294
146 #define KW_INCLUDES 295
147 #define word 296
148
149
150
151
152 /* Copy the first part of user declarations.  */
153 #line 1 "ael.y"
154
155 /*
156  * Asterisk -- An open source telephony toolkit.
157  *
158  * Copyright (C) 2006, Digium, Inc.
159  *
160  * Steve Murphy <murf@parsetree.com>
161  *
162  * See http://www.asterisk.org for more information about
163  * the Asterisk project. Please do not directly contact
164  * any of the maintainers of this project for assistance;
165  * the project provides a web site, mailing lists and IRC
166  * channels for your use.
167  *
168  * This program is free software, distributed under the terms of
169  * the GNU General Public License Version 2. See the LICENSE file
170  * at the top of the source tree.
171  */
172 /*! \file
173  *
174  * \brief Bison Grammar description of AEL2.
175  *
176  */
177 #include <stdio.h>
178 #include <stdlib.h>
179 #include <string.h>
180 #include "asterisk/logger.h"
181 #include "asterisk/ael_structs.h"
182
183 static pval * linku1(pval *head, pval *tail);
184
185 void reset_parencount(yyscan_t yyscanner);
186 void reset_semicount(yyscan_t yyscanner);
187 void reset_argcount(yyscan_t yyscanner );
188
189 #define YYLEX_PARAM ((struct parse_io *)parseio)->scanner
190 #define YYERROR_VERBOSE 1
191
192 extern char *my_file;
193 #ifdef AAL_ARGCHECK
194 int ael_is_funcname(char *name);
195 #endif
196 static char *ael_token_subst(char *mess);
197
198
199
200 /* Enabling traces.  */
201 #ifndef YYDEBUG
202 # define YYDEBUG 0
203 #endif
204
205 /* Enabling verbose error messages.  */
206 #ifdef YYERROR_VERBOSE
207 # undef YYERROR_VERBOSE
208 # define YYERROR_VERBOSE 1
209 #else
210 # define YYERROR_VERBOSE 1
211 #endif
212
213 /* Enabling the token table.  */
214 #ifndef YYTOKEN_TABLE
215 # define YYTOKEN_TABLE 0
216 #endif
217
218 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
219 #line 48 "ael.y"
220 typedef union YYSTYPE {
221         int     intval;         /* integer value, typically flags */
222         char    *str;           /* strings */
223         struct pval *pval;      /* full objects */
224 } YYSTYPE;
225 /* Line 196 of yacc.c.  */
226 #line 227 "ael.tab.c"
227 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
228 # define YYSTYPE_IS_DECLARED 1
229 # define YYSTYPE_IS_TRIVIAL 1
230 #endif
231
232 #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
233 typedef struct YYLTYPE
234 {
235   int first_line;
236   int first_column;
237   int last_line;
238   int last_column;
239 } YYLTYPE;
240 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
241 # define YYLTYPE_IS_DECLARED 1
242 # define YYLTYPE_IS_TRIVIAL 1
243 #endif
244
245
246 /* Copy the second part of user declarations.  */
247 #line 54 "ael.y"
248
249         /* declaring these AFTER the union makes things a lot simpler! */
250 void yyerror(YYLTYPE *locp, struct parse_io *parseio, char const *s);
251 int ael_yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , void * yyscanner);
252
253 /* create a new object with start-end marker */
254 static pval *npval(pvaltype type, int first_line, int last_line,
255         int first_column, int last_column);
256
257 /* create a new object with start-end marker, simplified interface.
258  * Must be declared here because YYLTYPE is not known before
259  */
260 static pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last);
261
262 /* another frontend for npval, this time for a string */
263 static pval *nword(char *string, YYLTYPE *pos);
264
265 /* update end position of an object, return the object */
266 static pval *update_last(pval *, YYLTYPE *);
267
268
269 /* Line 219 of yacc.c.  */
270 #line 271 "ael.tab.c"
271
272 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
273 # define YYSIZE_T __SIZE_TYPE__
274 #endif
275 #if ! defined (YYSIZE_T) && defined (size_t)
276 # define YYSIZE_T size_t
277 #endif
278 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
279 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
280 # define YYSIZE_T size_t
281 #endif
282 #if ! defined (YYSIZE_T)
283 # define YYSIZE_T unsigned int
284 #endif
285
286 #ifndef YY_
287 # if YYENABLE_NLS
288 #  if ENABLE_NLS
289 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
290 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
291 #  endif
292 # endif
293 # ifndef YY_
294 #  define YY_(msgid) msgid
295 # endif
296 #endif
297
298 #if ! defined (yyoverflow) || YYERROR_VERBOSE
299
300 /* The parser invokes alloca or malloc; define the necessary symbols.  */
301
302 # ifdef YYSTACK_USE_ALLOCA
303 #  if YYSTACK_USE_ALLOCA
304 #   ifdef __GNUC__
305 #    define YYSTACK_ALLOC __builtin_alloca
306 #   else
307 #    define YYSTACK_ALLOC alloca
308 #    if defined (__STDC__) || defined (__cplusplus)
309 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
310 #     define YYINCLUDED_STDLIB_H
311 #    endif
312 #   endif
313 #  endif
314 # endif
315
316 # ifdef YYSTACK_ALLOC
317    /* Pacify GCC's `empty if-body' warning. */
318 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
319 #  ifndef YYSTACK_ALLOC_MAXIMUM
320     /* The OS might guarantee only one guard page at the bottom of the stack,
321        and a page size can be as small as 4096 bytes.  So we cannot safely
322        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
323        to allow for a few compiler-allocated temporary stack slots.  */
324 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
325 #  endif
326 # else
327 #  define YYSTACK_ALLOC YYMALLOC
328 #  define YYSTACK_FREE YYFREE
329 #  ifndef YYSTACK_ALLOC_MAXIMUM
330 #   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
331 #  endif
332 #  ifdef __cplusplus
333 extern "C" {
334 #  endif
335 #  ifndef YYMALLOC
336 #   define YYMALLOC malloc
337 #   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
338         && (defined (__STDC__) || defined (__cplusplus)))
339 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
340 #   endif
341 #  endif
342 #  ifndef YYFREE
343 #   define YYFREE free
344 #   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
345         && (defined (__STDC__) || defined (__cplusplus)))
346 void free (void *); /* INFRINGES ON USER NAME SPACE */
347 #   endif
348 #  endif
349 #  ifdef __cplusplus
350 }
351 #  endif
352 # endif
353 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
354
355
356 #if (! defined (yyoverflow) \
357      && (! defined (__cplusplus) \
358          || (defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
359              && defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
360
361 /* A type that is properly aligned for any stack member.  */
362 union yyalloc
363 {
364   short int yyss;
365   YYSTYPE yyvs;
366     YYLTYPE yyls;
367 };
368
369 /* The size of the maximum gap between one aligned stack and the next.  */
370 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
371
372 /* The size of an array large to enough to hold all stacks, each with
373    N elements.  */
374 # define YYSTACK_BYTES(N) \
375      ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE))  \
376       + 2 * YYSTACK_GAP_MAXIMUM)
377
378 /* Copy COUNT objects from FROM to TO.  The source and destination do
379    not overlap.  */
380 # ifndef YYCOPY
381 #  if defined (__GNUC__) && 1 < __GNUC__
382 #   define YYCOPY(To, From, Count) \
383       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
384 #  else
385 #   define YYCOPY(To, From, Count)              \
386       do                                        \
387         {                                       \
388           YYSIZE_T yyi;                         \
389           for (yyi = 0; yyi < (Count); yyi++)   \
390             (To)[yyi] = (From)[yyi];            \
391         }                                       \
392       while (0)
393 #  endif
394 # endif
395
396 /* Relocate STACK from its old location to the new one.  The
397    local variables YYSIZE and YYSTACKSIZE give the old and new number of
398    elements in the stack, and YYPTR gives the new location of the
399    stack.  Advance YYPTR to a properly aligned location for the next
400    stack.  */
401 # define YYSTACK_RELOCATE(Stack)                                        \
402     do                                                                  \
403       {                                                                 \
404         YYSIZE_T yynewbytes;                                            \
405         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
406         Stack = &yyptr->Stack;                                          \
407         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
408         yyptr += yynewbytes / sizeof (*yyptr);                          \
409       }                                                                 \
410     while (0)
411
412 #endif
413
414 #if defined (__STDC__) || defined (__cplusplus)
415    typedef signed char yysigned_char;
416 #else
417    typedef short int yysigned_char;
418 #endif
419
420 /* YYFINAL -- State number of the termination state. */
421 #define YYFINAL  14
422 /* YYLAST -- Last index in YYTABLE.  */
423 #define YYLAST   505
424
425 /* YYNTOKENS -- Number of terminals. */
426 #define YYNTOKENS  42
427 /* YYNNTS -- Number of nonterminals. */
428 #define YYNNTS  58
429 /* YYNRULES -- Number of rules. */
430 #define YYNRULES  150
431 /* YYNRULES -- Number of states. */
432 #define YYNSTATES  340
433
434 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
435 #define YYUNDEFTOK  2
436 #define YYMAXUTOK   296
437
438 #define YYTRANSLATE(YYX)                                                \
439   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
440
441 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
442 static const unsigned char yytranslate[] =
443 {
444        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
445        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
446        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
447        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
448        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
449        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
450        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
451        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
452        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
453        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
454        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
455        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
456        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
457        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
458        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
459        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
460        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
461        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
462        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
463        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
464        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
465        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
466        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
467        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
468        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
469        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
470        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
471       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
472       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
473       35,    36,    37,    38,    39,    40,    41
474 };
475
476 #if YYDEBUG
477 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
478    YYRHS.  */
479 static const unsigned short int yyprhs[] =
480 {
481        0,     0,     3,     5,     7,    10,    13,    15,    17,    19,
482       21,    23,    25,    30,    32,    33,    42,    50,    58,    65,
483       70,    74,    76,    79,    82,    83,    89,    91,    95,    98,
484      101,   105,   107,   109,   112,   115,   117,   119,   121,   123,
485      125,   126,   132,   135,   137,   142,   146,   151,   159,   168,
486      170,   173,   176,   177,   183,   184,   190,   205,   216,   218,
487      221,   223,   226,   230,   232,   235,   239,   240,   247,   251,
488      252,   258,   262,   266,   269,   270,   271,   272,   285,   286,
489      293,   296,   300,   304,   307,   310,   311,   317,   320,   323,
490      326,   330,   334,   338,   340,   343,   344,   346,   350,   354,
491      360,   366,   372,   378,   380,   384,   390,   394,   400,   404,
492      405,   411,   415,   416,   420,   424,   427,   429,   430,   432,
493      433,   437,   439,   442,   447,   451,   456,   460,   463,   467,
494      469,   472,   474,   480,   483,   486,   490,   493,   496,   500,
495      503,   506,   521,   532,   536,   552,   564,   567,   569,   571,
496      576
497 };
498
499 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
500 static const yysigned_char yyrhs[] =
501 {
502       43,     0,    -1,    44,    -1,    45,    -1,    44,    45,    -1,
503       44,     1,    -1,    47,    -1,    49,    -1,    50,    -1,     8,
504       -1,    41,    -1,    36,    -1,    48,     3,    46,    55,    -1,
505       23,    -1,    -1,    15,    41,     6,    54,     7,     4,    91,
506        5,    -1,    15,    41,     6,    54,     7,     4,     5,    -1,
507       15,    41,     6,     7,     4,    91,     5,    -1,    15,    41,
508        6,     7,     4,     5,    -1,    16,     4,    51,     5,    -1,
509       16,     4,     5,    -1,    52,    -1,    51,    52,    -1,    51,
510        1,    -1,    -1,    41,     9,    53,    41,     8,    -1,    41,
511       -1,    54,    10,    41,    -1,    54,     1,    -1,     4,     5,
512       -1,     4,    56,     5,    -1,    57,    -1,     1,    -1,    56,
513       57,    -1,    56,     1,    -1,    60,    -1,    99,    -1,    93,
514       -1,    94,    -1,    59,    -1,    -1,    41,     9,    58,    41,
515        8,    -1,    41,     1,    -1,     8,    -1,    17,    24,    41,
516        8,    -1,    41,    24,    72,    -1,    30,    41,    24,    72,
517       -1,    31,     6,    68,     7,    41,    24,    72,    -1,    30,
518       31,     6,    68,     7,    41,    24,    72,    -1,    72,    -1,
519       61,    72,    -1,    61,     1,    -1,    -1,    19,     6,    63,
520       67,     7,    -1,    -1,    22,     6,    65,    67,     7,    -1,
521       20,     6,    68,    11,    68,    11,    68,    13,    68,    13,
522       68,    13,    68,     7,    -1,    20,     6,    41,    13,    68,
523       13,    68,    13,    68,     7,    -1,    41,    -1,    41,    41,
524       -1,    41,    -1,    41,    41,    -1,    41,    41,    41,    -1,
525       41,    -1,    41,    41,    -1,    41,    11,    41,    -1,    -1,
526       18,     6,    71,    41,     7,     4,    -1,     4,    61,     5,
527       -1,    -1,    41,     9,    73,    41,     8,    -1,    25,    80,
528        8,    -1,    26,    81,     8,    -1,    41,    11,    -1,    -1,
529       -1,    -1,    32,     6,    74,    41,     8,    75,    41,     8,
530       76,    41,     7,    72,    -1,    -1,    33,     6,    77,    41,
531        7,    72,    -1,    70,     5,    -1,    70,    89,     5,    -1,
532       12,    82,     8,    -1,    86,     8,    -1,    41,     8,    -1,
533       -1,    86,     9,    78,    41,     8,    -1,    28,     8,    -1,
534       27,     8,    -1,    29,     8,    -1,    64,    72,    79,    -1,
535       62,    72,    79,    -1,    66,    72,    79,    -1,     8,    -1,
536       21,    72,    -1,    -1,    69,    -1,    69,    13,    69,    -1,
537       69,    10,    69,    -1,    69,    13,    69,    13,    69,    -1,
538       69,    10,    69,    10,    69,    -1,    36,    13,    69,    13,
539       69,    -1,    36,    10,    69,    10,    69,    -1,    69,    -1,
540       69,    10,    69,    -1,    69,    10,    41,    14,    41,    -1,
541       69,    14,    69,    -1,    69,    10,    41,    14,    36,    -1,
542       69,    14,    36,    -1,    -1,    41,     6,    83,    88,     7,
543       -1,    41,     6,     7,    -1,    -1,    41,     6,    85,    -1,
544       84,    88,     7,    -1,    84,     7,    -1,    41,    -1,    -1,
545       67,    -1,    -1,    88,    10,    87,    -1,    90,    -1,    89,
546       90,    -1,    34,    41,    11,    61,    -1,    36,    11,    61,
547       -1,    35,    41,    11,    61,    -1,    34,    41,    11,    -1,
548       36,    11,    -1,    35,    41,    11,    -1,    92,    -1,    91,
549       92,    -1,    72,    -1,    37,    41,     4,    61,     5,    -1,
550       38,    95,    -1,    39,    95,    -1,     4,    96,     5,    -1,
551        4,     5,    -1,    41,     8,    -1,    96,    41,     8,    -1,
552       96,     1,    -1,    98,     8,    -1,    98,    13,    68,    11,
553       68,    11,    68,    13,    68,    13,    68,    13,    68,     8,
554       -1,    98,    13,    41,    13,    68,    13,    68,    13,    68,
555        8,    -1,    97,    98,     8,    -1,    97,    98,    13,    68,
556       11,    68,    11,    68,    13,    68,    13,    68,    13,    68,
557        8,    -1,    97,    98,    13,    41,    13,    68,    13,    68,
558       13,    68,     8,    -1,    97,     1,    -1,    41,    -1,    36,
559       -1,    40,     4,    97,     5,    -1,    40,     4,     5,    -1
560 };
561
562 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
563 static const unsigned short int yyrline[] =
564 {
565        0,   176,   176,   179,   180,   181,   184,   185,   186,   187,
566      190,   191,   194,   202,   203,   206,   209,   212,   216,   221,
567      224,   228,   229,   230,   233,   233,   239,   240,   241,   244,
568      245,   248,   249,   250,   251,   254,   255,   256,   257,   258,
569      259,   259,   263,   264,   267,   272,   276,   281,   286,   295,
570      296,   297,   300,   300,   305,   305,   310,   323,   339,   340,
571      347,   348,   353,   361,   362,   366,   372,   372,   380,   383,
572      383,   387,   390,   393,   396,   397,   398,   396,   404,   404,
573      408,   410,   413,   415,   417,   420,   420,   453,   454,   455,
574      456,   460,   464,   468,   471,   472,   477,   478,   481,   484,
575      488,   492,   496,   503,   506,   509,   513,   517,   521,   527,
576      527,   532,   540,   540,   551,   558,   561,   562,   565,   566,
577      569,   572,   573,   576,   580,   584,   588,   591,   594,   599,
578      600,   603,   604,   610,   615,   620,   621,   624,   625,   626,
579      629,   630,   643,   651,   652,   666,   677,   680,   681,   684,
580      687
581 };
582 #endif
583
584 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
585 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
586    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
587 static const char *const yytname[] =
588 {
589   "$end", "error", "$undefined", "KW_CONTEXT", "LC", "RC", "LP", "RP",
590   "SEMI", "EQ", "COMMA", "COLON", "AMPER", "BAR", "AT", "KW_MACRO",
591   "KW_GLOBALS", "KW_IGNOREPAT", "KW_SWITCH", "KW_IF", "KW_IFTIME",
592   "KW_ELSE", "KW_RANDOM", "KW_ABSTRACT", "EXTENMARK", "KW_GOTO", "KW_JUMP",
593   "KW_RETURN", "KW_BREAK", "KW_CONTINUE", "KW_REGEXTEN", "KW_HINT",
594   "KW_FOR", "KW_WHILE", "KW_CASE", "KW_PATTERN", "KW_DEFAULT", "KW_CATCH",
595   "KW_SWITCHES", "KW_ESWITCHES", "KW_INCLUDES", "word", "$accept", "file",
596   "objects", "object", "word_or_default", "context", "opt_abstract",
597   "macro", "globals", "global_statements", "global_statement", "@1",
598   "arglist", "elements_block", "elements", "element", "@2", "ignorepat",
599   "extension", "statements", "if_head", "@3", "random_head", "@4",
600   "iftime_head", "word_list", "word3_list", "goto_word", "switch_head",
601   "@5", "statement", "@6", "@7", "@8", "@9", "@10", "@11", "opt_else",
602   "target", "jumptarget", "macro_call", "@12", "application_call_head",
603   "@13", "application_call", "opt_word", "eval_arglist", "case_statements",
604   "case_statement", "macro_statements", "macro_statement", "switches",
605   "eswitches", "switchlist_block", "switchlist", "includeslist",
606   "includedname", "includes", 0
607 };
608 #endif
609
610 # ifdef YYPRINT
611 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
612    token YYLEX-NUM.  */
613 static const unsigned short int yytoknum[] =
614 {
615        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
616      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
617      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
618      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
619      295,   296
620 };
621 # endif
622
623 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
624 static const unsigned char yyr1[] =
625 {
626        0,    42,    43,    44,    44,    44,    45,    45,    45,    45,
627       46,    46,    47,    48,    48,    49,    49,    49,    49,    50,
628       50,    51,    51,    51,    53,    52,    54,    54,    54,    55,
629       55,    56,    56,    56,    56,    57,    57,    57,    57,    57,
630       58,    57,    57,    57,    59,    60,    60,    60,    60,    61,
631       61,    61,    63,    62,    65,    64,    66,    66,    67,    67,
632       68,    68,    68,    69,    69,    69,    71,    70,    72,    73,
633       72,    72,    72,    72,    74,    75,    76,    72,    77,    72,
634       72,    72,    72,    72,    72,    78,    72,    72,    72,    72,
635       72,    72,    72,    72,    79,    79,    80,    80,    80,    80,
636       80,    80,    80,    81,    81,    81,    81,    81,    81,    83,
637       82,    82,    85,    84,    86,    86,    87,    87,    88,    88,
638       88,    89,    89,    90,    90,    90,    90,    90,    90,    91,
639       91,    92,    92,    93,    94,    95,    95,    96,    96,    96,
640       97,    97,    97,    97,    97,    97,    97,    98,    98,    99,
641       99
642 };
643
644 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
645 static const unsigned char yyr2[] =
646 {
647        0,     2,     1,     1,     2,     2,     1,     1,     1,     1,
648        1,     1,     4,     1,     0,     8,     7,     7,     6,     4,
649        3,     1,     2,     2,     0,     5,     1,     3,     2,     2,
650        3,     1,     1,     2,     2,     1,     1,     1,     1,     1,
651        0,     5,     2,     1,     4,     3,     4,     7,     8,     1,
652        2,     2,     0,     5,     0,     5,    14,    10,     1,     2,
653        1,     2,     3,     1,     2,     3,     0,     6,     3,     0,
654        5,     3,     3,     2,     0,     0,     0,    12,     0,     6,
655        2,     3,     3,     2,     2,     0,     5,     2,     2,     2,
656        3,     3,     3,     1,     2,     0,     1,     3,     3,     5,
657        5,     5,     5,     1,     3,     5,     3,     5,     3,     0,
658        5,     3,     0,     3,     3,     2,     1,     0,     1,     0,
659        3,     1,     2,     4,     3,     4,     3,     2,     3,     1,
660        2,     1,     5,     2,     2,     3,     2,     2,     3,     2,
661        2,    14,    10,     3,    15,    11,     2,     1,     1,     4,
662        3
663 };
664
665 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
666    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
667    means the default is an error.  */
668 static const unsigned char yydefact[] =
669 {
670       14,     9,     0,     0,    13,     0,     0,     3,     6,     0,
671        7,     8,     0,     0,     1,     5,     4,     0,     0,    20,
672        0,     0,    21,    11,    10,     0,     0,    26,     0,    24,
673       23,    19,    22,     0,    12,     0,    28,     0,     0,     0,
674       32,    29,    43,     0,     0,     0,     0,     0,     0,     0,
675        0,    31,    39,    35,    37,    38,    36,     0,    18,    93,
676        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
677        0,     0,     0,     0,     0,     0,     0,     0,   131,   119,
678        0,     0,   129,     0,    27,     0,     0,     0,     0,     0,
679        0,   133,   134,     0,    42,    40,     0,    34,    30,    33,
680        0,    49,     0,     0,    66,    52,     0,    54,     0,    63,
681       96,     0,   103,     0,    88,    87,    89,    74,    78,     0,
682      112,    84,    69,    73,    95,    95,    95,    80,     0,     0,
683        0,     0,   121,   115,    58,   118,     0,    83,    85,    17,
684      130,    16,     0,    25,     0,     0,     0,    60,     0,   136,
685        0,     0,   150,   148,   147,     0,     0,     0,    45,    51,
686       68,    50,   109,    82,     0,     0,    60,     0,     0,     0,
687        0,     0,    64,     0,     0,    71,     0,     0,    72,     0,
688        0,     0,   113,     0,     0,    91,    90,    92,     0,     0,
689      127,    81,   122,    59,   114,   117,     0,    15,    44,     0,
690       46,    61,     0,   137,   139,   135,     0,   146,   149,     0,
691      140,     0,     0,   111,   119,     0,     0,     0,     0,     0,
692        0,     0,    65,    98,    97,    63,   104,   108,   106,     0,
693        0,     0,     0,    94,   126,   128,     0,   116,   120,     0,
694        0,    62,     0,   138,   143,     0,    60,     0,    41,     0,
695        0,    53,     0,     0,    55,     0,     0,     0,     0,     0,
696       75,     0,   132,    70,     0,     0,    86,     0,     0,    60,
697        0,     0,     0,   110,    67,     0,     0,   102,   101,   100,
698       99,   107,   105,     0,    79,     0,    47,     0,     0,     0,
699        0,     0,     0,     0,    48,     0,     0,     0,     0,     0,
700        0,    76,     0,     0,     0,     0,     0,     0,     0,     0,
701        0,     0,     0,    57,     0,     0,     0,     0,     0,     0,
702        0,     0,     0,     0,   142,     0,     0,    77,   145,     0,
703        0,     0,     0,     0,    56,     0,     0,     0,   141,   144
704 };
705
706 /* YYDEFGOTO[NTERM-NUM]. */
707 static const short int yydefgoto[] =
708 {
709       -1,     5,     6,     7,    25,     8,     9,    10,    11,    21,
710       22,    39,    28,    34,    50,    51,   157,    52,    53,   100,
711       74,   165,    75,   168,    76,   135,   148,   110,    77,   164,
712      101,   183,   179,   283,   308,   180,   196,   185,   111,   113,
713      103,   214,    79,   182,    80,   238,   136,   131,   132,    81,
714       82,    54,    55,    91,   151,   155,   156,    56
715 };
716
717 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
718    STATE-NUM.  */
719 #define YYPACT_NINF -180
720 static const short int yypact[] =
721 {
722      132,  -180,   -31,    19,  -180,    76,   105,  -180,  -180,    77,
723     -180,  -180,    10,     8,  -180,  -180,  -180,    73,    11,  -180,
724      103,     3,  -180,  -180,  -180,   112,   133,  -180,    20,  -180,
725     -180,  -180,  -180,   283,  -180,   360,  -180,   139,   116,   117,
726     -180,  -180,  -180,    94,   -16,   138,   160,   160,   161,    95,
727      336,  -180,  -180,  -180,  -180,  -180,  -180,   464,  -180,  -180,
728      131,   167,   168,   178,   179,    74,   145,   171,   180,   181,
729      184,   185,   146,    25,   464,   464,   464,    23,  -180,    12,
730       81,   386,  -180,   412,  -180,   187,   151,   191,   174,   158,
731        9,  -180,  -180,     1,  -180,  -180,   464,  -180,  -180,  -180,
732      277,  -180,   194,   199,  -180,  -180,   169,  -180,    16,    13,
733       22,   207,    56,   208,  -180,  -180,  -180,  -180,  -180,   198,
734     -180,  -180,  -180,  -180,   200,   200,   200,  -180,   183,   186,
735      214,    63,  -180,  -180,   193,  -180,   124,  -180,  -180,  -180,
736     -180,  -180,   438,  -180,   211,   158,   464,   195,   221,  -180,
737      229,     4,  -180,  -180,  -180,     2,   114,   197,  -180,  -180,
738     -180,  -180,   235,  -180,   204,   205,    60,   237,   205,   145,
739      145,   212,  -180,   145,   145,  -180,   213,   100,  -180,   215,
740      219,   464,  -180,   222,   464,  -180,  -180,  -180,   238,   241,
741      464,  -180,  -180,  -180,  -180,   228,   236,  -180,  -180,   248,
742     -180,   242,   246,  -180,  -180,  -180,   254,  -180,  -180,   137,
743     -180,   249,   262,  -180,   205,   269,   272,   158,   158,   285,
744      284,   280,  -180,   288,   294,     6,  -180,  -180,  -180,   293,
745      309,   307,   312,  -180,   464,   464,    59,  -180,  -180,   320,
746      276,  -180,   306,  -180,  -180,   290,    61,   327,  -180,   173,
747      338,  -180,   330,   334,  -180,   145,   145,   145,   145,   135,
748     -180,   464,  -180,  -180,   134,   239,  -180,   322,   464,    62,
749      339,   158,   158,  -180,  -180,   158,   158,  -180,  -180,  -180,
750     -180,  -180,  -180,   308,  -180,   464,  -180,   158,   158,   341,
751      340,   342,   343,   344,  -180,   345,   346,   158,   158,   158,
752      158,  -180,   158,   158,   347,   348,   352,   349,   328,   350,
753      357,   158,   158,  -180,   158,   364,   158,   158,   365,   368,
754      370,   464,   376,   382,  -180,   158,   158,  -180,  -180,   158,
755      383,   392,   387,   158,  -180,   158,   394,   395,  -180,  -180
756 };
757
758 /* YYPGOTO[NTERM-NUM].  */
759 static const short int yypgoto[] =
760 {
761     -180,  -180,  -180,   401,  -180,  -180,  -180,  -180,  -180,  -180,
762      326,  -180,  -180,  -180,  -180,   359,  -180,  -180,  -180,  -179,
763     -180,  -180,  -180,  -180,  -180,   -96,   -94,   -44,  -180,  -180,
764      -35,  -180,  -180,  -180,  -180,  -180,  -180,   -43,  -180,  -180,
765     -180,  -180,  -180,  -180,  -180,  -180,   196,  -180,   291,   353,
766      -80,  -180,  -180,   374,  -180,  -180,   270,  -180
767 };
768
769 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
770    positive, shift that token.  If negative, reduce the rule which
771    number is the opposite.  If zero, do what YYDEFACT says.
772    If YYTABLE_NINF, syntax error.  */
773 #define YYTABLE_NINF -126
774 static const short int yytable[] =
775 {
776       78,   140,   231,   207,    30,   204,   152,   208,    31,   205,
777       12,   236,   167,    19,   149,    87,    18,   171,    26,   133,
778      259,    36,   112,    13,   171,    88,   169,    37,   127,   170,
779       38,   120,   173,   121,   122,   174,   123,   153,   153,   124,
780      125,   126,   154,   154,    20,   206,    78,   172,    78,    20,
781      150,   199,    27,   134,   172,   264,   265,   128,   129,   130,
782      159,   158,   140,    57,  -124,   161,   176,    59,   191,   216,
783      177,    60,   219,   217,   271,   287,    14,    61,    62,    63,
784       17,    64,   186,   187,    65,    66,    67,    68,    69,   137,
785      138,    70,    71,  -124,  -124,  -124,    94,   128,   129,   130,
786       73,   201,   201,   201,    95,    -2,    15,    78,   -14,    23,
787      108,   200,    29,     1,    24,   109,    33,   247,    86,    96,
788        2,     3,   210,   252,   253,   220,   221,   211,     4,   223,
789      224,   194,   226,   228,   195,   159,   227,    35,    57,  -123,
790        1,   109,    59,    83,    89,   244,    60,     2,     3,   233,
791      245,   270,    61,    62,    63,     4,    64,    84,    85,    65,
792       66,    67,    68,    69,    90,    93,    70,    71,  -123,  -123,
793     -123,   281,   102,   104,   105,    73,   282,   289,   290,   114,
794      273,   291,   292,   195,   106,   107,   109,   119,   115,   116,
795      117,   118,   144,   295,   296,   143,   161,   145,   146,   147,
796      162,   161,   181,   304,   305,   306,   307,   163,   309,   310,
797      166,   277,   278,   279,   280,   175,   178,   318,   319,   198,
798      320,   184,   322,   323,   188,   190,   284,   189,   202,   161,
799      161,   330,   331,   286,   193,   332,   201,   203,   212,   336,
800      159,   337,   213,    57,  -125,   215,   134,    59,   218,   234,
801      294,    60,   235,   222,   225,   240,   229,    61,    62,    63,
802      230,    64,   243,   232,    65,    66,    67,    68,    69,   237,
803      248,    70,    71,  -125,  -125,  -125,   250,   239,   159,   251,
804       73,    57,   160,   241,    40,    59,   327,   242,    41,    60,
805      246,    42,   254,   256,   255,    61,    62,    63,   257,    64,
806       43,   260,    65,    66,    67,    68,    69,   258,   159,    70,
807       71,    57,   262,    44,    45,    59,   261,   267,    73,    60,
808      263,    46,    47,    48,    49,    61,    62,    63,   266,    64,
809      268,   269,    65,    66,    67,    68,    69,    97,   272,    70,
810       71,    98,   274,   275,    42,   276,   285,    32,    73,   293,
811      288,   298,   301,    43,   297,   299,   300,   303,   302,   313,
812      311,   312,   314,   316,    57,    58,    44,    45,    59,   315,
813      317,   321,    60,   324,    46,    47,    48,    49,    61,    62,
814       63,   325,    64,   326,   328,    65,    66,    67,    68,    69,
815       57,   139,    70,    71,    59,   329,   333,    72,    60,   334,
816      335,    73,   338,   339,    61,    62,    63,    16,    64,    99,
817      249,    65,    66,    67,    68,    69,    57,   141,    70,    71,
818       59,    92,   192,    72,    60,   209,     0,    73,     0,     0,
819       61,    62,    63,     0,    64,     0,   142,    65,    66,    67,
820       68,    69,    57,   197,    70,    71,    59,     0,     0,    72,
821       60,     0,     0,    73,     0,     0,    61,    62,    63,     0,
822       64,     0,     0,    65,    66,    67,    68,    69,    57,     0,
823       70,    71,    59,     0,     0,    72,    60,     0,     0,    73,
824        0,     0,    61,    62,    63,     0,    64,     0,     0,    65,
825       66,    67,    68,    69,     0,     0,    70,    71,     0,     0,
826        0,     0,     0,     0,     0,    73
827 };
828
829 static const short int yycheck[] =
830 {
831       35,    81,   181,     1,     1,     1,     5,     5,     5,     5,
832       41,   190,   106,     5,     5,    31,     6,    11,     7,     7,
833       14,     1,    66,     4,    11,    41,    10,     7,     5,    13,
834       10,     6,    10,     8,     9,    13,    11,    36,    36,    74,
835       75,    76,    41,    41,    41,    41,    81,    41,    83,    41,
836       41,   145,    41,    41,    41,   234,   235,    34,    35,    36,
837        1,    96,   142,     4,     5,   100,    10,     8,     5,   165,
838       14,    12,   168,    13,    13,    13,     0,    18,    19,    20,
839        3,    22,   125,   126,    25,    26,    27,    28,    29,     8,
840        9,    32,    33,    34,    35,    36,     1,    34,    35,    36,
841       41,    41,    41,    41,     9,     0,     1,   142,     3,    36,
842       36,   146,     9,     8,    41,    41,     4,   211,    24,    24,
843       15,    16,     8,   217,   218,   169,   170,    13,    23,   173,
844      174,     7,   176,   177,    10,     1,    36,     4,     4,     5,
845        8,    41,     8,     4,     6,     8,    12,    15,    16,   184,
846       13,   245,    18,    19,    20,    23,    22,    41,    41,    25,
847       26,    27,    28,    29,     4,     4,    32,    33,    34,    35,
848       36,    36,    41,     6,     6,    41,    41,   271,   272,     8,
849        7,   275,   276,    10,     6,     6,    41,    41,     8,     8,
850        6,     6,    41,   287,   288,     8,   231,     6,    24,    41,
851        6,   236,     4,   297,   298,   299,   300,     8,   302,   303,
852       41,   255,   256,   257,   258,     8,     8,   311,   312,     8,
853      314,    21,   316,   317,    41,    11,   261,    41,     7,   264,
854      265,   325,   326,   268,    41,   329,    41,     8,    41,   333,
855        1,   335,     7,     4,     5,    41,    41,     8,    11,    11,
856      285,    12,    11,    41,    41,     7,    41,    18,    19,    20,
857       41,    22,     8,    41,    25,    26,    27,    28,    29,    41,
858        8,    32,    33,    34,    35,    36,     7,    41,     1,     7,
859       41,     4,     5,    41,     1,     8,   321,    41,     5,    12,
860       41,     8,     7,    13,    10,    18,    19,    20,    10,    22,
861       17,     8,    25,    26,    27,    28,    29,    13,     1,    32,
862       33,     4,     5,    30,    31,     8,     7,    41,    41,    12,
863        8,    38,    39,    40,    41,    18,    19,    20,     8,    22,
864       24,    41,    25,    26,    27,    28,    29,     1,    11,    32,
865       33,     5,     4,    13,     8,    11,    24,    21,    41,    41,
866       11,    11,     8,    17,    13,    13,    13,    11,    13,     7,
867       13,    13,    13,    13,     4,     5,    30,    31,     8,    41,
868       13,     7,    12,     8,    38,    39,    40,    41,    18,    19,
869       20,    13,    22,    13,     8,    25,    26,    27,    28,    29,
870        4,     5,    32,    33,     8,    13,    13,    37,    12,     7,
871       13,    41,     8,     8,    18,    19,    20,     6,    22,    50,
872      214,    25,    26,    27,    28,    29,     4,     5,    32,    33,
873        8,    47,   131,    37,    12,   155,    -1,    41,    -1,    -1,
874       18,    19,    20,    -1,    22,    -1,    83,    25,    26,    27,
875       28,    29,     4,     5,    32,    33,     8,    -1,    -1,    37,
876       12,    -1,    -1,    41,    -1,    -1,    18,    19,    20,    -1,
877       22,    -1,    -1,    25,    26,    27,    28,    29,     4,    -1,
878       32,    33,     8,    -1,    -1,    37,    12,    -1,    -1,    41,
879       -1,    -1,    18,    19,    20,    -1,    22,    -1,    -1,    25,
880       26,    27,    28,    29,    -1,    -1,    32,    33,    -1,    -1,
881       -1,    -1,    -1,    -1,    -1,    41
882 };
883
884 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
885    symbol of state STATE-NUM.  */
886 static const unsigned char yystos[] =
887 {
888        0,     8,    15,    16,    23,    43,    44,    45,    47,    48,
889       49,    50,    41,     4,     0,     1,    45,     3,     6,     5,
890       41,    51,    52,    36,    41,    46,     7,    41,    54,     9,
891        1,     5,    52,     4,    55,     4,     1,     7,    10,    53,
892        1,     5,     8,    17,    30,    31,    38,    39,    40,    41,
893       56,    57,    59,    60,    93,    94,    99,     4,     5,     8,
894       12,    18,    19,    20,    22,    25,    26,    27,    28,    29,
895       32,    33,    37,    41,    62,    64,    66,    70,    72,    84,
896       86,    91,    92,     4,    41,    41,    24,    31,    41,     6,
897        4,    95,    95,     4,     1,     9,    24,     1,     5,    57,
898       61,    72,    41,    82,     6,     6,     6,     6,    36,    41,
899       69,    80,    69,    81,     8,     8,     8,     6,     6,    41,
900        6,     8,     9,    11,    72,    72,    72,     5,    34,    35,
901       36,    89,    90,     7,    41,    67,    88,     8,     9,     5,
902       92,     5,    91,     8,    41,     6,    24,    41,    68,     5,
903       41,    96,     5,    36,    41,    97,    98,    58,    72,     1,
904        5,    72,     6,     8,    71,    63,    41,    68,    65,    10,
905       13,    11,    41,    10,    13,     8,    10,    14,     8,    74,
906       77,     4,    85,    73,    21,    79,    79,    79,    41,    41,
907       11,     5,    90,    41,     7,    10,    78,     5,     8,    68,
908       72,    41,     7,     8,     1,     5,    41,     1,     5,    98,
909        8,    13,    41,     7,    83,    41,    67,    13,    11,    67,
910       69,    69,    41,    69,    69,    41,    69,    36,    69,    41,
911       41,    61,    41,    72,    11,    11,    61,    41,    87,    41,
912        7,    41,    41,     8,     8,    13,    41,    68,     8,    88,
913        7,     7,    68,    68,     7,    10,    13,    10,    13,    14,
914        8,     7,     5,     8,    61,    61,     8,    41,    24,    41,
915       68,    13,    11,     7,     4,    13,    11,    69,    69,    69,
916       69,    36,    41,    75,    72,    24,    72,    13,    11,    68,
917       68,    68,    68,    41,    72,    68,    68,    13,    11,    13,
918       13,     8,    13,    11,    68,    68,    68,    68,    76,    68,
919       68,    13,    13,     7,    13,    41,    13,    13,    68,    68,
920       68,     7,    68,    68,     8,    13,    13,    72,     8,    13,
921       68,    68,    68,    13,     7,    13,    68,    68,     8,     8
922 };
923
924 #define yyerrok         (yyerrstatus = 0)
925 #define yyclearin       (yychar = YYEMPTY)
926 #define YYEMPTY         (-2)
927 #define YYEOF           0
928
929 #define YYACCEPT        goto yyacceptlab
930 #define YYABORT         goto yyabortlab
931 #define YYERROR         goto yyerrorlab
932
933
934 /* Like YYERROR except do call yyerror.  This remains here temporarily
935    to ease the transition to the new meaning of YYERROR, for GCC.
936    Once GCC version 2 has supplanted version 1, this can go.  */
937
938 #define YYFAIL          goto yyerrlab
939
940 #define YYRECOVERING()  (!!yyerrstatus)
941
942 #define YYBACKUP(Token, Value)                                  \
943 do                                                              \
944   if (yychar == YYEMPTY && yylen == 1)                          \
945     {                                                           \
946       yychar = (Token);                                         \
947       yylval = (Value);                                         \
948       yytoken = YYTRANSLATE (yychar);                           \
949       YYPOPSTACK;                                               \
950       goto yybackup;                                            \
951     }                                                           \
952   else                                                          \
953     {                                                           \
954       yyerror (&yylloc, parseio, YY_("syntax error: cannot back up")); \
955       YYERROR;                                                  \
956     }                                                           \
957 while (0)
958
959
960 #define YYTERROR        1
961 #define YYERRCODE       256
962
963
964 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
965    If N is 0, then set CURRENT to the empty location which ends
966    the previous symbol: RHS[0] (always defined).  */
967
968 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
969 #ifndef YYLLOC_DEFAULT
970 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
971     do                                                                  \
972       if (N)                                                            \
973         {                                                               \
974           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
975           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
976           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
977           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
978         }                                                               \
979       else                                                              \
980         {                                                               \
981           (Current).first_line   = (Current).last_line   =              \
982             YYRHSLOC (Rhs, 0).last_line;                                \
983           (Current).first_column = (Current).last_column =              \
984             YYRHSLOC (Rhs, 0).last_column;                              \
985         }                                                               \
986     while (0)
987 #endif
988
989
990 /* YY_LOCATION_PRINT -- Print the location on the stream.
991    This macro was not mandated originally: define only if we know
992    we won't break user code: when these are the locations we know.  */
993
994 #ifndef YY_LOCATION_PRINT
995 # if YYLTYPE_IS_TRIVIAL
996 #  define YY_LOCATION_PRINT(File, Loc)                  \
997      fprintf (File, "%d.%d-%d.%d",                      \
998               (Loc).first_line, (Loc).first_column,     \
999               (Loc).last_line,  (Loc).last_column)
1000 # else
1001 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1002 # endif
1003 #endif
1004
1005
1006 /* YYLEX -- calling `yylex' with the right arguments.  */
1007
1008 #ifdef YYLEX_PARAM
1009 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
1010 #else
1011 # define YYLEX yylex (&yylval, &yylloc)
1012 #endif
1013
1014 /* Enable debugging if requested.  */
1015 #if YYDEBUG
1016
1017 # ifndef YYFPRINTF
1018 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1019 #  define YYFPRINTF fprintf
1020 # endif
1021
1022 # define YYDPRINTF(Args)                        \
1023 do {                                            \
1024   if (yydebug)                                  \
1025     YYFPRINTF Args;                             \
1026 } while (0)
1027
1028 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
1029 do {                                                            \
1030   if (yydebug)                                                  \
1031     {                                                           \
1032       YYFPRINTF (stderr, "%s ", Title);                         \
1033       yysymprint (stderr,                                       \
1034                   Type, Value, Location);       \
1035       YYFPRINTF (stderr, "\n");                                 \
1036     }                                                           \
1037 } while (0)
1038
1039 /*------------------------------------------------------------------.
1040 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1041 | TOP (included).                                                   |
1042 `------------------------------------------------------------------*/
1043
1044 #if defined (__STDC__) || defined (__cplusplus)
1045 static void
1046 yy_stack_print (short int *bottom, short int *top)
1047 #else
1048 static void
1049 yy_stack_print (bottom, top)
1050     short int *bottom;
1051     short int *top;
1052 #endif
1053 {
1054   YYFPRINTF (stderr, "Stack now");
1055   for (/* Nothing. */; bottom <= top; ++bottom)
1056     YYFPRINTF (stderr, " %d", *bottom);
1057   YYFPRINTF (stderr, "\n");
1058 }
1059
1060 # define YY_STACK_PRINT(Bottom, Top)                            \
1061 do {                                                            \
1062   if (yydebug)                                                  \
1063     yy_stack_print ((Bottom), (Top));                           \
1064 } while (0)
1065
1066
1067 /*------------------------------------------------.
1068 | Report that the YYRULE is going to be reduced.  |
1069 `------------------------------------------------*/
1070
1071 #if defined (__STDC__) || defined (__cplusplus)
1072 static void
1073 yy_reduce_print (int yyrule)
1074 #else
1075 static void
1076 yy_reduce_print (yyrule)
1077     int yyrule;
1078 #endif
1079 {
1080   int yyi;
1081   unsigned long int yylno = yyrline[yyrule];
1082   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
1083              yyrule - 1, yylno);
1084   /* Print the symbols being reduced, and their result.  */
1085   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1086     YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1087   YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
1088 }
1089
1090 # define YY_REDUCE_PRINT(Rule)          \
1091 do {                                    \
1092   if (yydebug)                          \
1093     yy_reduce_print (Rule);             \
1094 } while (0)
1095
1096 /* Nonzero means print parse trace.  It is left uninitialized so that
1097    multiple parsers can coexist.  */
1098 int yydebug;
1099 #else /* !YYDEBUG */
1100 # define YYDPRINTF(Args)
1101 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1102 # define YY_STACK_PRINT(Bottom, Top)
1103 # define YY_REDUCE_PRINT(Rule)
1104 #endif /* !YYDEBUG */
1105
1106
1107 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1108 #ifndef YYINITDEPTH
1109 # define YYINITDEPTH 200
1110 #endif
1111
1112 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1113    if the built-in stack extension method is used).
1114
1115    Do not make this value too large; the results are undefined if
1116    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1117    evaluated with infinite-precision integer arithmetic.  */
1118
1119 #ifndef YYMAXDEPTH
1120 # define YYMAXDEPTH 10000
1121 #endif
1122
1123 \f
1124
1125 #if YYERROR_VERBOSE
1126
1127 # ifndef yystrlen
1128 #  if defined (__GLIBC__) && defined (_STRING_H)
1129 #   define yystrlen strlen
1130 #  else
1131 /* Return the length of YYSTR.  */
1132 static YYSIZE_T
1133 #   if defined (__STDC__) || defined (__cplusplus)
1134 yystrlen (const char *yystr)
1135 #   else
1136 yystrlen (yystr)
1137      const char *yystr;
1138 #   endif
1139 {
1140   const char *yys = yystr;
1141
1142   while (*yys++ != '\0')
1143     continue;
1144
1145   return yys - yystr - 1;
1146 }
1147 #  endif
1148 # endif
1149
1150 # ifndef yystpcpy
1151 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1152 #   define yystpcpy stpcpy
1153 #  else
1154 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1155    YYDEST.  */
1156 static char *
1157 #   if defined (__STDC__) || defined (__cplusplus)
1158 yystpcpy (char *yydest, const char *yysrc)
1159 #   else
1160 yystpcpy (yydest, yysrc)
1161      char *yydest;
1162      const char *yysrc;
1163 #   endif
1164 {
1165   char *yyd = yydest;
1166   const char *yys = yysrc;
1167
1168   while ((*yyd++ = *yys++) != '\0')
1169     continue;
1170
1171   return yyd - 1;
1172 }
1173 #  endif
1174 # endif
1175
1176 # ifndef yytnamerr
1177 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1178    quotes and backslashes, so that it's suitable for yyerror.  The
1179    heuristic is that double-quoting is unnecessary unless the string
1180    contains an apostrophe, a comma, or backslash (other than
1181    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1182    null, do not copy; instead, return the length of what the result
1183    would have been.  */
1184 static YYSIZE_T
1185 yytnamerr (char *yyres, const char *yystr)
1186 {
1187   if (*yystr == '"')
1188     {
1189       size_t yyn = 0;
1190       char const *yyp = yystr;
1191
1192       for (;;)
1193         switch (*++yyp)
1194           {
1195           case '\'':
1196           case ',':
1197             goto do_not_strip_quotes;
1198
1199           case '\\':
1200             if (*++yyp != '\\')
1201               goto do_not_strip_quotes;
1202             /* Fall through.  */
1203           default:
1204             if (yyres)
1205               yyres[yyn] = *yyp;
1206             yyn++;
1207             break;
1208
1209           case '"':
1210             if (yyres)
1211               yyres[yyn] = '\0';
1212             return yyn;
1213           }
1214     do_not_strip_quotes: ;
1215     }
1216
1217   if (! yyres)
1218     return yystrlen (yystr);
1219
1220   return yystpcpy (yyres, yystr) - yyres;
1221 }
1222 # endif
1223
1224 #endif /* YYERROR_VERBOSE */
1225
1226 \f
1227
1228 #if YYDEBUG
1229 /*--------------------------------.
1230 | Print this symbol on YYOUTPUT.  |
1231 `--------------------------------*/
1232
1233 #if defined (__STDC__) || defined (__cplusplus)
1234 static void
1235 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1236 #else
1237 static void
1238 yysymprint (yyoutput, yytype, yyvaluep, yylocationp)
1239     FILE *yyoutput;
1240     int yytype;
1241     YYSTYPE *yyvaluep;
1242     YYLTYPE *yylocationp;
1243 #endif
1244 {
1245   /* Pacify ``unused variable'' warnings.  */
1246   (void) yyvaluep;
1247   (void) yylocationp;
1248
1249   if (yytype < YYNTOKENS)
1250     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1251   else
1252     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1253
1254   YY_LOCATION_PRINT (yyoutput, *yylocationp);
1255   YYFPRINTF (yyoutput, ": ");
1256
1257 # ifdef YYPRINT
1258   if (yytype < YYNTOKENS)
1259     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1260 # endif
1261   switch (yytype)
1262     {
1263       default:
1264         break;
1265     }
1266   YYFPRINTF (yyoutput, ")");
1267 }
1268
1269 #endif /* ! YYDEBUG */
1270 /*-----------------------------------------------.
1271 | Release the memory associated to this symbol.  |
1272 `-----------------------------------------------*/
1273
1274 #if defined (__STDC__) || defined (__cplusplus)
1275 static void
1276 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1277 #else
1278 static void
1279 yydestruct (yymsg, yytype, yyvaluep, yylocationp)
1280     const char *yymsg;
1281     int yytype;
1282     YYSTYPE *yyvaluep;
1283     YYLTYPE *yylocationp;
1284 #endif
1285 {
1286   /* Pacify ``unused variable'' warnings.  */
1287   (void) yyvaluep;
1288   (void) yylocationp;
1289
1290   if (!yymsg)
1291     yymsg = "Deleting";
1292   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1293
1294   switch (yytype)
1295     {
1296       case 41: /* "word" */
1297 #line 171 "ael.y"
1298         { free((yyvaluep->str));};
1299 #line 1300 "ael.tab.c"
1300         break;
1301       case 44: /* "objects" */
1302 #line 158 "ael.y"
1303         {
1304                 destroy_pval((yyvaluep->pval));
1305                 prev_word=0;
1306         };
1307 #line 1308 "ael.tab.c"
1308         break;
1309       case 45: /* "object" */
1310 #line 158 "ael.y"
1311         {
1312                 destroy_pval((yyvaluep->pval));
1313                 prev_word=0;
1314         };
1315 #line 1316 "ael.tab.c"
1316         break;
1317       case 46: /* "word_or_default" */
1318 #line 171 "ael.y"
1319         { free((yyvaluep->str));};
1320 #line 1321 "ael.tab.c"
1321         break;
1322       case 47: /* "context" */
1323 #line 158 "ael.y"
1324         {
1325                 destroy_pval((yyvaluep->pval));
1326                 prev_word=0;
1327         };
1328 #line 1329 "ael.tab.c"
1329         break;
1330       case 49: /* "macro" */
1331 #line 158 "ael.y"
1332         {
1333                 destroy_pval((yyvaluep->pval));
1334                 prev_word=0;
1335         };
1336 #line 1337 "ael.tab.c"
1337         break;
1338       case 50: /* "globals" */
1339 #line 158 "ael.y"
1340         {
1341                 destroy_pval((yyvaluep->pval));
1342                 prev_word=0;
1343         };
1344 #line 1345 "ael.tab.c"
1345         break;
1346       case 51: /* "global_statements" */
1347 #line 158 "ael.y"
1348         {
1349                 destroy_pval((yyvaluep->pval));
1350                 prev_word=0;
1351         };
1352 #line 1353 "ael.tab.c"
1353         break;
1354       case 52: /* "global_statement" */
1355 #line 158 "ael.y"
1356         {
1357                 destroy_pval((yyvaluep->pval));
1358                 prev_word=0;
1359         };
1360 #line 1361 "ael.tab.c"
1361         break;
1362       case 54: /* "arglist" */
1363 #line 158 "ael.y"
1364         {
1365                 destroy_pval((yyvaluep->pval));
1366                 prev_word=0;
1367         };
1368 #line 1369 "ael.tab.c"
1369         break;
1370       case 55: /* "elements_block" */
1371 #line 158 "ael.y"
1372         {
1373                 destroy_pval((yyvaluep->pval));
1374                 prev_word=0;
1375         };
1376 #line 1377 "ael.tab.c"
1377         break;
1378       case 56: /* "elements" */
1379 #line 158 "ael.y"
1380         {
1381                 destroy_pval((yyvaluep->pval));
1382                 prev_word=0;
1383         };
1384 #line 1385 "ael.tab.c"
1385         break;
1386       case 57: /* "element" */
1387 #line 158 "ael.y"
1388         {
1389                 destroy_pval((yyvaluep->pval));
1390                 prev_word=0;
1391         };
1392 #line 1393 "ael.tab.c"
1393         break;
1394       case 59: /* "ignorepat" */
1395 #line 158 "ael.y"
1396         {
1397                 destroy_pval((yyvaluep->pval));
1398                 prev_word=0;
1399         };
1400 #line 1401 "ael.tab.c"
1401         break;
1402       case 60: /* "extension" */
1403 #line 158 "ael.y"
1404         {
1405                 destroy_pval((yyvaluep->pval));
1406                 prev_word=0;
1407         };
1408 #line 1409 "ael.tab.c"
1409         break;
1410       case 61: /* "statements" */
1411 #line 158 "ael.y"
1412         {
1413                 destroy_pval((yyvaluep->pval));
1414                 prev_word=0;
1415         };
1416 #line 1417 "ael.tab.c"
1417         break;
1418       case 62: /* "if_head" */
1419 #line 158 "ael.y"
1420         {
1421                 destroy_pval((yyvaluep->pval));
1422                 prev_word=0;
1423         };
1424 #line 1425 "ael.tab.c"
1425         break;
1426       case 64: /* "random_head" */
1427 #line 158 "ael.y"
1428         {
1429                 destroy_pval((yyvaluep->pval));
1430                 prev_word=0;
1431         };
1432 #line 1433 "ael.tab.c"
1433         break;
1434       case 66: /* "iftime_head" */
1435 #line 158 "ael.y"
1436         {
1437                 destroy_pval((yyvaluep->pval));
1438                 prev_word=0;
1439         };
1440 #line 1441 "ael.tab.c"
1441         break;
1442       case 67: /* "word_list" */
1443 #line 171 "ael.y"
1444         { free((yyvaluep->str));};
1445 #line 1446 "ael.tab.c"
1446         break;
1447       case 68: /* "word3_list" */
1448 #line 171 "ael.y"
1449         { free((yyvaluep->str));};
1450 #line 1451 "ael.tab.c"
1451         break;
1452       case 69: /* "goto_word" */
1453 #line 171 "ael.y"
1454         { free((yyvaluep->str));};
1455 #line 1456 "ael.tab.c"
1456         break;
1457       case 70: /* "switch_head" */
1458 #line 158 "ael.y"
1459         {
1460                 destroy_pval((yyvaluep->pval));
1461                 prev_word=0;
1462         };
1463 #line 1464 "ael.tab.c"
1464         break;
1465       case 72: /* "statement" */
1466 #line 158 "ael.y"
1467         {
1468                 destroy_pval((yyvaluep->pval));
1469                 prev_word=0;
1470         };
1471 #line 1472 "ael.tab.c"
1472         break;
1473       case 79: /* "opt_else" */
1474 #line 158 "ael.y"
1475         {
1476                 destroy_pval((yyvaluep->pval));
1477                 prev_word=0;
1478         };
1479 #line 1480 "ael.tab.c"
1480         break;
1481       case 80: /* "target" */
1482 #line 158 "ael.y"
1483         {
1484                 destroy_pval((yyvaluep->pval));
1485                 prev_word=0;
1486         };
1487 #line 1488 "ael.tab.c"
1488         break;
1489       case 81: /* "jumptarget" */
1490 #line 158 "ael.y"
1491         {
1492                 destroy_pval((yyvaluep->pval));
1493                 prev_word=0;
1494         };
1495 #line 1496 "ael.tab.c"
1496         break;
1497       case 82: /* "macro_call" */
1498 #line 158 "ael.y"
1499         {
1500                 destroy_pval((yyvaluep->pval));
1501                 prev_word=0;
1502         };
1503 #line 1504 "ael.tab.c"
1504         break;
1505       case 84: /* "application_call_head" */
1506 #line 158 "ael.y"
1507         {
1508                 destroy_pval((yyvaluep->pval));
1509                 prev_word=0;
1510         };
1511 #line 1512 "ael.tab.c"
1512         break;
1513       case 86: /* "application_call" */
1514 #line 158 "ael.y"
1515         {
1516                 destroy_pval((yyvaluep->pval));
1517                 prev_word=0;
1518         };
1519 #line 1520 "ael.tab.c"
1520         break;
1521       case 87: /* "opt_word" */
1522 #line 171 "ael.y"
1523         { free((yyvaluep->str));};
1524 #line 1525 "ael.tab.c"
1525         break;
1526       case 88: /* "eval_arglist" */
1527 #line 158 "ael.y"
1528         {
1529                 destroy_pval((yyvaluep->pval));
1530                 prev_word=0;
1531         };
1532 #line 1533 "ael.tab.c"
1533         break;
1534       case 89: /* "case_statements" */
1535 #line 158 "ael.y"
1536         {
1537                 destroy_pval((yyvaluep->pval));
1538                 prev_word=0;
1539         };
1540 #line 1541 "ael.tab.c"
1541         break;
1542       case 90: /* "case_statement" */
1543 #line 158 "ael.y"
1544         {
1545                 destroy_pval((yyvaluep->pval));
1546                 prev_word=0;
1547         };
1548 #line 1549 "ael.tab.c"
1549         break;
1550       case 91: /* "macro_statements" */
1551 #line 158 "ael.y"
1552         {
1553                 destroy_pval((yyvaluep->pval));
1554                 prev_word=0;
1555         };
1556 #line 1557 "ael.tab.c"
1557         break;
1558       case 92: /* "macro_statement" */
1559 #line 158 "ael.y"
1560         {
1561                 destroy_pval((yyvaluep->pval));
1562                 prev_word=0;
1563         };
1564 #line 1565 "ael.tab.c"
1565         break;
1566       case 93: /* "switches" */
1567 #line 158 "ael.y"
1568         {
1569                 destroy_pval((yyvaluep->pval));
1570                 prev_word=0;
1571         };
1572 #line 1573 "ael.tab.c"
1573         break;
1574       case 94: /* "eswitches" */
1575 #line 158 "ael.y"
1576         {
1577                 destroy_pval((yyvaluep->pval));
1578                 prev_word=0;
1579         };
1580 #line 1581 "ael.tab.c"
1581         break;
1582       case 95: /* "switchlist_block" */
1583 #line 158 "ael.y"
1584         {
1585                 destroy_pval((yyvaluep->pval));
1586                 prev_word=0;
1587         };
1588 #line 1589 "ael.tab.c"
1589         break;
1590       case 96: /* "switchlist" */
1591 #line 158 "ael.y"
1592         {
1593                 destroy_pval((yyvaluep->pval));
1594                 prev_word=0;
1595         };
1596 #line 1597 "ael.tab.c"
1597         break;
1598       case 97: /* "includeslist" */
1599 #line 158 "ael.y"
1600         {
1601                 destroy_pval((yyvaluep->pval));
1602                 prev_word=0;
1603         };
1604 #line 1605 "ael.tab.c"
1605         break;
1606       case 98: /* "includedname" */
1607 #line 171 "ael.y"
1608         { free((yyvaluep->str));};
1609 #line 1610 "ael.tab.c"
1610         break;
1611       case 99: /* "includes" */
1612 #line 158 "ael.y"
1613         {
1614                 destroy_pval((yyvaluep->pval));
1615                 prev_word=0;
1616         };
1617 #line 1618 "ael.tab.c"
1618         break;
1619
1620       default:
1621         break;
1622     }
1623 }
1624 \f
1625
1626 /* Prevent warnings from -Wmissing-prototypes.  */
1627
1628 #ifdef YYPARSE_PARAM
1629 # if defined (__STDC__) || defined (__cplusplus)
1630 int yyparse (void *YYPARSE_PARAM);
1631 # else
1632 int yyparse ();
1633 # endif
1634 #else /* ! YYPARSE_PARAM */
1635 #if defined (__STDC__) || defined (__cplusplus)
1636 int yyparse (struct parse_io *parseio);
1637 #else
1638 int yyparse ();
1639 #endif
1640 #endif /* ! YYPARSE_PARAM */
1641
1642
1643
1644
1645
1646
1647 /*----------.
1648 | yyparse.  |
1649 `----------*/
1650
1651 #ifdef YYPARSE_PARAM
1652 # if defined (__STDC__) || defined (__cplusplus)
1653 int yyparse (void *YYPARSE_PARAM)
1654 # else
1655 int yyparse (YYPARSE_PARAM)
1656   void *YYPARSE_PARAM;
1657 # endif
1658 #else /* ! YYPARSE_PARAM */
1659 #if defined (__STDC__) || defined (__cplusplus)
1660 int
1661 yyparse (struct parse_io *parseio)
1662 #else
1663 int
1664 yyparse (parseio)
1665     struct parse_io *parseio;
1666 #endif
1667 #endif
1668 {
1669   /* The look-ahead symbol.  */
1670 int yychar;
1671
1672 /* The semantic value of the look-ahead symbol.  */
1673 YYSTYPE yylval;
1674
1675 /* Number of syntax errors so far.  */
1676 int yynerrs;
1677 /* Location data for the look-ahead symbol.  */
1678 YYLTYPE yylloc;
1679
1680   int yystate;
1681   int yyn;
1682   int yyresult;
1683   /* Number of tokens to shift before error messages enabled.  */
1684   int yyerrstatus;
1685   /* Look-ahead token as an internal (translated) token number.  */
1686   int yytoken = 0;
1687
1688   /* Three stacks and their tools:
1689      `yyss': related to states,
1690      `yyvs': related to semantic values,
1691      `yyls': related to locations.
1692
1693      Refer to the stacks thru separate pointers, to allow yyoverflow
1694      to reallocate them elsewhere.  */
1695
1696   /* The state stack.  */
1697   short int yyssa[YYINITDEPTH];
1698   short int *yyss = yyssa;
1699   short int *yyssp;
1700
1701   /* The semantic value stack.  */
1702   YYSTYPE yyvsa[YYINITDEPTH];
1703   YYSTYPE *yyvs = yyvsa;
1704   YYSTYPE *yyvsp;
1705
1706   /* The location stack.  */
1707   YYLTYPE yylsa[YYINITDEPTH];
1708   YYLTYPE *yyls = yylsa;
1709   YYLTYPE *yylsp;
1710   /* The locations where the error started and ended. */
1711   YYLTYPE yyerror_range[2];
1712
1713 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
1714
1715   YYSIZE_T yystacksize = YYINITDEPTH;
1716
1717   /* The variables used to return semantic value and location from the
1718      action routines.  */
1719   YYSTYPE yyval;
1720   YYLTYPE yyloc;
1721
1722   /* When reducing, the number of symbols on the RHS of the reduced
1723      rule.  */
1724   int yylen;
1725
1726   YYDPRINTF ((stderr, "Starting parse\n"));
1727
1728   yystate = 0;
1729   yyerrstatus = 0;
1730   yynerrs = 0;
1731   yychar = YYEMPTY;             /* Cause a token to be read.  */
1732
1733   /* Initialize stack pointers.
1734      Waste one element of value and location stack
1735      so that they stay on the same level as the state stack.
1736      The wasted elements are never initialized.  */
1737
1738   yyssp = yyss;
1739   yyvsp = yyvs;
1740   yylsp = yyls;
1741 #if YYLTYPE_IS_TRIVIAL
1742   /* Initialize the default location before parsing starts.  */
1743   yylloc.first_line   = yylloc.last_line   = 1;
1744   yylloc.first_column = yylloc.last_column = 0;
1745 #endif
1746
1747   goto yysetstate;
1748
1749 /*------------------------------------------------------------.
1750 | yynewstate -- Push a new state, which is found in yystate.  |
1751 `------------------------------------------------------------*/
1752  yynewstate:
1753   /* In all cases, when you get here, the value and location stacks
1754      have just been pushed. so pushing a state here evens the stacks.
1755      */
1756   yyssp++;
1757
1758  yysetstate:
1759   *yyssp = yystate;
1760
1761   if (yyss + yystacksize - 1 <= yyssp)
1762     {
1763       /* Get the current used size of the three stacks, in elements.  */
1764       YYSIZE_T yysize = yyssp - yyss + 1;
1765
1766 #ifdef yyoverflow
1767       {
1768         /* Give user a chance to reallocate the stack. Use copies of
1769            these so that the &'s don't force the real ones into
1770            memory.  */
1771         YYSTYPE *yyvs1 = yyvs;
1772         short int *yyss1 = yyss;
1773         YYLTYPE *yyls1 = yyls;
1774
1775         /* Each stack pointer address is followed by the size of the
1776            data in use in that stack, in bytes.  This used to be a
1777            conditional around just the two extra args, but that might
1778            be undefined if yyoverflow is a macro.  */
1779         yyoverflow (YY_("memory exhausted"),
1780                     &yyss1, yysize * sizeof (*yyssp),
1781                     &yyvs1, yysize * sizeof (*yyvsp),
1782                     &yyls1, yysize * sizeof (*yylsp),
1783                     &yystacksize);
1784         yyls = yyls1;
1785         yyss = yyss1;
1786         yyvs = yyvs1;
1787       }
1788 #else /* no yyoverflow */
1789 # ifndef YYSTACK_RELOCATE
1790       goto yyexhaustedlab;
1791 # else
1792       /* Extend the stack our own way.  */
1793       if (YYMAXDEPTH <= yystacksize)
1794         goto yyexhaustedlab;
1795       yystacksize *= 2;
1796       if (YYMAXDEPTH < yystacksize)
1797         yystacksize = YYMAXDEPTH;
1798
1799       {
1800         short int *yyss1 = yyss;
1801         union yyalloc *yyptr =
1802           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1803         if (! yyptr)
1804           goto yyexhaustedlab;
1805         YYSTACK_RELOCATE (yyss);
1806         YYSTACK_RELOCATE (yyvs);
1807         YYSTACK_RELOCATE (yyls);
1808 #  undef YYSTACK_RELOCATE
1809         if (yyss1 != yyssa)
1810           YYSTACK_FREE (yyss1);
1811       }
1812 # endif
1813 #endif /* no yyoverflow */
1814
1815       yyssp = yyss + yysize - 1;
1816       yyvsp = yyvs + yysize - 1;
1817       yylsp = yyls + yysize - 1;
1818
1819       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1820                   (unsigned long int) yystacksize));
1821
1822       if (yyss + yystacksize - 1 <= yyssp)
1823         YYABORT;
1824     }
1825
1826   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1827
1828   goto yybackup;
1829
1830 /*-----------.
1831 | yybackup.  |
1832 `-----------*/
1833 yybackup:
1834
1835 /* Do appropriate processing given the current state.  */
1836 /* Read a look-ahead token if we need one and don't already have one.  */
1837 /* yyresume: */
1838
1839   /* First try to decide what to do without reference to look-ahead token.  */
1840
1841   yyn = yypact[yystate];
1842   if (yyn == YYPACT_NINF)
1843     goto yydefault;
1844
1845   /* Not known => get a look-ahead token if don't already have one.  */
1846
1847   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1848   if (yychar == YYEMPTY)
1849     {
1850       YYDPRINTF ((stderr, "Reading a token: "));
1851       yychar = YYLEX;
1852     }
1853
1854   if (yychar <= YYEOF)
1855     {
1856       yychar = yytoken = YYEOF;
1857       YYDPRINTF ((stderr, "Now at end of input.\n"));
1858     }
1859   else
1860     {
1861       yytoken = YYTRANSLATE (yychar);
1862       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1863     }
1864
1865   /* If the proper action on seeing token YYTOKEN is to reduce or to
1866      detect an error, take that action.  */
1867   yyn += yytoken;
1868   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1869     goto yydefault;
1870   yyn = yytable[yyn];
1871   if (yyn <= 0)
1872     {
1873       if (yyn == 0 || yyn == YYTABLE_NINF)
1874         goto yyerrlab;
1875       yyn = -yyn;
1876       goto yyreduce;
1877     }
1878
1879   if (yyn == YYFINAL)
1880     YYACCEPT;
1881
1882   /* Shift the look-ahead token.  */
1883   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1884
1885   /* Discard the token being shifted unless it is eof.  */
1886   if (yychar != YYEOF)
1887     yychar = YYEMPTY;
1888
1889   *++yyvsp = yylval;
1890   *++yylsp = yylloc;
1891
1892   /* Count tokens shifted since error; after three, turn off error
1893      status.  */
1894   if (yyerrstatus)
1895     yyerrstatus--;
1896
1897   yystate = yyn;
1898   goto yynewstate;
1899
1900
1901 /*-----------------------------------------------------------.
1902 | yydefault -- do the default action for the current state.  |
1903 `-----------------------------------------------------------*/
1904 yydefault:
1905   yyn = yydefact[yystate];
1906   if (yyn == 0)
1907     goto yyerrlab;
1908   goto yyreduce;
1909
1910
1911 /*-----------------------------.
1912 | yyreduce -- Do a reduction.  |
1913 `-----------------------------*/
1914 yyreduce:
1915   /* yyn is the number of a rule to reduce with.  */
1916   yylen = yyr2[yyn];
1917
1918   /* If YYLEN is nonzero, implement the default value of the action:
1919      `$$ = $1'.
1920
1921      Otherwise, the following line sets YYVAL to garbage.
1922      This behavior is undocumented and Bison
1923      users should not rely upon it.  Assigning to YYVAL
1924      unconditionally makes the parser a bit smaller, and it avoids a
1925      GCC warning that YYVAL may be used uninitialized.  */
1926   yyval = yyvsp[1-yylen];
1927
1928   /* Default location. */
1929   YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);
1930   YY_REDUCE_PRINT (yyn);
1931   switch (yyn)
1932     {
1933         case 2:
1934 #line 176 "ael.y"
1935     { (yyval.pval) = parseio->pval = (yyvsp[0].pval); ;}
1936     break;
1937
1938   case 3:
1939 #line 179 "ael.y"
1940     {(yyval.pval)=(yyvsp[0].pval);;}
1941     break;
1942
1943   case 4:
1944 #line 180 "ael.y"
1945     { (yyval.pval) = linku1((yyvsp[-1].pval), (yyvsp[0].pval)); ;}
1946     break;
1947
1948   case 5:
1949 #line 181 "ael.y"
1950     {(yyval.pval)=(yyvsp[-1].pval);;}
1951     break;
1952
1953   case 6:
1954 #line 184 "ael.y"
1955     {(yyval.pval)=(yyvsp[0].pval);;}
1956     break;
1957
1958   case 7:
1959 #line 185 "ael.y"
1960     {(yyval.pval)=(yyvsp[0].pval);;}
1961     break;
1962
1963   case 8:
1964 #line 186 "ael.y"
1965     {(yyval.pval)=(yyvsp[0].pval);;}
1966     break;
1967
1968   case 9:
1969 #line 187 "ael.y"
1970     {(yyval.pval)=0;/* allow older docs to be read */;}
1971     break;
1972
1973   case 10:
1974 #line 190 "ael.y"
1975     { (yyval.str) = (yyvsp[0].str); ;}
1976     break;
1977
1978   case 11:
1979 #line 191 "ael.y"
1980     { (yyval.str) = strdup("default"); ;}
1981     break;
1982
1983   case 12:
1984 #line 194 "ael.y"
1985     {
1986                 (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[-3]), &(yylsp[0]));
1987                 (yyval.pval)->u1.str = (yyvsp[-1].str);
1988                 (yyval.pval)->u2.statements = (yyvsp[0].pval);
1989                 (yyval.pval)->u3.abstract = (yyvsp[-3].intval); ;}
1990     break;
1991
1992   case 13:
1993 #line 202 "ael.y"
1994     { (yyval.intval) = 1; ;}
1995     break;
1996
1997   case 14:
1998 #line 203 "ael.y"
1999     { (yyval.intval) = 0; ;}
2000     break;
2001
2002   case 15:
2003 #line 206 "ael.y"
2004     {
2005                 (yyval.pval) = npval2(PV_MACRO, &(yylsp[-7]), &(yylsp[0]));
2006                 (yyval.pval)->u1.str = (yyvsp[-6].str); (yyval.pval)->u2.arglist = (yyvsp[-4].pval); (yyval.pval)->u3.macro_statements = (yyvsp[-1].pval); ;}
2007     break;
2008
2009   case 16:
2010 #line 209 "ael.y"
2011     {
2012                 (yyval.pval) = npval2(PV_MACRO, &(yylsp[-6]), &(yylsp[0]));
2013                 (yyval.pval)->u1.str = (yyvsp[-5].str); (yyval.pval)->u2.arglist = (yyvsp[-3].pval); ;}
2014     break;
2015
2016   case 17:
2017 #line 212 "ael.y"
2018     {
2019                 (yyval.pval) = npval2(PV_MACRO, &(yylsp[-6]), &(yylsp[0]));
2020                 (yyval.pval)->u1.str = (yyvsp[-5].str);
2021                 (yyval.pval)->u3.macro_statements = (yyvsp[-1].pval); ;}
2022     break;
2023
2024   case 18:
2025 #line 216 "ael.y"
2026     {
2027                 (yyval.pval) = npval2(PV_MACRO, &(yylsp[-5]), &(yylsp[0]));
2028                 (yyval.pval)->u1.str = (yyvsp[-4].str); ;}
2029     break;
2030
2031   case 19:
2032 #line 221 "ael.y"
2033     {
2034                 (yyval.pval) = npval2(PV_GLOBALS, &(yylsp[-3]), &(yylsp[0]));
2035                 (yyval.pval)->u1.statements = (yyvsp[-1].pval);;}
2036     break;
2037
2038   case 20:
2039 #line 224 "ael.y"
2040     { /* empty globals is OK */
2041                 (yyval.pval) = npval2(PV_GLOBALS, &(yylsp[-2]), &(yylsp[0])); ;}
2042     break;
2043
2044   case 21:
2045 #line 228 "ael.y"
2046     {(yyval.pval)=(yyvsp[0].pval);;}
2047     break;
2048
2049   case 22:
2050 #line 229 "ael.y"
2051     {(yyval.pval) = linku1((yyvsp[-1].pval), (yyvsp[0].pval)); ;}
2052     break;
2053
2054   case 23:
2055 #line 230 "ael.y"
2056     {(yyval.pval)=(yyvsp[-1].pval);;}
2057     break;
2058
2059   case 24:
2060 #line 233 "ael.y"
2061     { reset_semicount(parseio->scanner); ;}
2062     break;
2063
2064   case 25:
2065 #line 233 "ael.y"
2066     {
2067                 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[-4]), &(yylsp[0]));
2068                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2069                 (yyval.pval)->u2.val = (yyvsp[-1].str); ;}
2070     break;
2071
2072   case 26:
2073 #line 239 "ael.y"
2074     { (yyval.pval) = nword((yyvsp[0].str), &(yylsp[0])); ;}
2075     break;
2076
2077   case 27:
2078 #line 240 "ael.y"
2079     { (yyval.pval) = linku1((yyvsp[-2].pval), nword((yyvsp[0].str), &(yylsp[0]))); ;}
2080     break;
2081
2082   case 28:
2083 #line 241 "ael.y"
2084     {(yyval.pval)=(yyvsp[-1].pval);;}
2085     break;
2086
2087   case 29:
2088 #line 244 "ael.y"
2089     { (yyval.pval) = NULL; ;}
2090     break;
2091
2092   case 30:
2093 #line 245 "ael.y"
2094     { (yyval.pval) = (yyvsp[-1].pval); ;}
2095     break;
2096
2097   case 31:
2098 #line 248 "ael.y"
2099     { (yyval.pval)=(yyvsp[0].pval);;}
2100     break;
2101
2102   case 32:
2103 #line 249 "ael.y"
2104     {(yyval.pval)=0;;}
2105     break;
2106
2107   case 33:
2108 #line 250 "ael.y"
2109     { (yyval.pval) = linku1((yyvsp[-1].pval), (yyvsp[0].pval)); ;}
2110     break;
2111
2112   case 34:
2113 #line 251 "ael.y"
2114     { (yyval.pval)=(yyvsp[-1].pval);;}
2115     break;
2116
2117   case 35:
2118 #line 254 "ael.y"
2119     {(yyval.pval)=(yyvsp[0].pval);;}
2120     break;
2121
2122   case 36:
2123 #line 255 "ael.y"
2124     {(yyval.pval)=(yyvsp[0].pval);;}
2125     break;
2126
2127   case 37:
2128 #line 256 "ael.y"
2129     {(yyval.pval)=(yyvsp[0].pval);;}
2130     break;
2131
2132   case 38:
2133 #line 257 "ael.y"
2134     {(yyval.pval)=(yyvsp[0].pval);;}
2135     break;
2136
2137   case 39:
2138 #line 258 "ael.y"
2139     {(yyval.pval)=(yyvsp[0].pval);;}
2140     break;
2141
2142   case 40:
2143 #line 259 "ael.y"
2144     { reset_semicount(parseio->scanner); ;}
2145     break;
2146
2147   case 41:
2148 #line 259 "ael.y"
2149     {
2150                 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[-4]), &(yylsp[0]));
2151                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2152                 (yyval.pval)->u2.val = (yyvsp[-1].str); ;}
2153     break;
2154
2155   case 42:
2156 #line 263 "ael.y"
2157     {free((yyvsp[-1].str)); (yyval.pval)=0;;}
2158     break;
2159
2160   case 43:
2161 #line 264 "ael.y"
2162     {(yyval.pval)=0;/* allow older docs to be read */;}
2163     break;
2164
2165   case 44:
2166 #line 267 "ael.y"
2167     {
2168                 (yyval.pval) = npval2(PV_IGNOREPAT, &(yylsp[-3]), &(yylsp[0]));
2169                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2170     break;
2171
2172   case 45:
2173 #line 272 "ael.y"
2174     {
2175                 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[-2]), &(yylsp[0]));
2176                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2177                 (yyval.pval)->u2.statements = (yyvsp[0].pval); ;}
2178     break;
2179
2180   case 46:
2181 #line 276 "ael.y"
2182     {
2183                 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[-3]), &(yylsp[0]));
2184                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2185                 (yyval.pval)->u2.statements = (yyvsp[0].pval);
2186                 (yyval.pval)->u4.regexten=1;;}
2187     break;
2188
2189   case 47:
2190 #line 281 "ael.y"
2191     {
2192                 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[-6]), &(yylsp[0]));
2193                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2194                 (yyval.pval)->u2.statements = (yyvsp[0].pval);
2195                 (yyval.pval)->u3.hints = (yyvsp[-4].str);;}
2196     break;
2197
2198   case 48:
2199 #line 286 "ael.y"
2200     {
2201                 (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[-7]), &(yylsp[0]));
2202                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2203                 (yyval.pval)->u2.statements = (yyvsp[0].pval);
2204                 (yyval.pval)->u4.regexten=1;
2205                 (yyval.pval)->u3.hints = (yyvsp[-4].str);;}
2206     break;
2207
2208   case 49:
2209 #line 295 "ael.y"
2210     {(yyval.pval)=(yyvsp[0].pval);;}
2211     break;
2212
2213   case 50:
2214 #line 296 "ael.y"
2215     { (yyval.pval) = linku1((yyvsp[-1].pval), (yyvsp[0].pval)); ;}
2216     break;
2217
2218   case 51:
2219 #line 297 "ael.y"
2220     {(yyval.pval)=(yyvsp[-1].pval);;}
2221     break;
2222
2223   case 52:
2224 #line 300 "ael.y"
2225     { reset_parencount(parseio->scanner); ;}
2226     break;
2227
2228   case 53:
2229 #line 300 "ael.y"
2230     {
2231                 (yyval.pval)= npval2(PV_IF, &(yylsp[-4]), &(yylsp[0]));
2232                 (yyval.pval)->u1.str = (yyvsp[-1].str); ;}
2233     break;
2234
2235   case 54:
2236 #line 305 "ael.y"
2237     { reset_parencount(parseio->scanner); ;}
2238     break;
2239
2240   case 55:
2241 #line 305 "ael.y"
2242     {
2243                 (yyval.pval) = npval2(PV_RANDOM, &(yylsp[-4]), &(yylsp[0]));
2244                 (yyval.pval)->u1.str=(yyvsp[-1].str);;}
2245     break;
2246
2247   case 56:
2248 #line 311 "ael.y"
2249     {
2250                 (yyval.pval) = npval2(PV_IFTIME, &(yylsp[-13]), &(yylsp[-13]));
2251                 (yyval.pval)->u1.list = npval2(PV_WORD, &(yylsp[-11]), &(yylsp[-7]));
2252                 asprintf(&((yyval.pval)->u1.list->u1.str), "%s:%s:%s", (yyvsp[-11].str), (yyvsp[-9].str), (yyvsp[-7].str));
2253                 free((yyvsp[-11].str));
2254                 free((yyvsp[-9].str));
2255                 free((yyvsp[-7].str));
2256                 (yyval.pval)->u1.list->next = nword((yyvsp[-5].str), &(yylsp[-5]));
2257                 (yyval.pval)->u1.list->next->next = nword((yyvsp[-3].str), &(yylsp[-3]));
2258                 (yyval.pval)->u1.list->next->next->next = nword((yyvsp[-1].str), &(yylsp[-1]));
2259                 prev_word = 0;
2260         ;}
2261     break;
2262
2263   case 57:
2264 #line 323 "ael.y"
2265     {
2266                 (yyval.pval) = npval2(PV_IFTIME, &(yylsp[-9]), &(yylsp[-5])); /* XXX @5 or greater ? */
2267                 (yyval.pval)->u1.list = nword((yyvsp[-7].str), &(yylsp[-7]));
2268                 (yyval.pval)->u1.list->next = nword((yyvsp[-5].str), &(yylsp[-5]));
2269                 (yyval.pval)->u1.list->next->next = nword((yyvsp[-3].str), &(yylsp[-3]));
2270                 (yyval.pval)->u1.list->next->next->next = nword((yyvsp[-1].str), &(yylsp[-1]));
2271                 prev_word = 0;
2272         ;}
2273     break;
2274
2275   case 58:
2276 #line 339 "ael.y"
2277     { (yyval.str) = (yyvsp[0].str);;}
2278     break;
2279
2280   case 59:
2281 #line 340 "ael.y"
2282     {
2283                 asprintf(&((yyval.str)), "%s%s", (yyvsp[-1].str), (yyvsp[0].str));
2284                 free((yyvsp[-1].str));
2285                 free((yyvsp[0].str));
2286                 prev_word = (yyval.str);;}
2287     break;
2288
2289   case 60:
2290 #line 347 "ael.y"
2291     { (yyval.str) = (yyvsp[0].str);;}
2292     break;
2293
2294   case 61:
2295 #line 348 "ael.y"
2296     {
2297                 asprintf(&((yyval.str)), "%s%s", (yyvsp[-1].str), (yyvsp[0].str));
2298                 free((yyvsp[-1].str));
2299                 free((yyvsp[0].str));
2300                 prev_word = (yyval.str);;}
2301     break;
2302
2303   case 62:
2304 #line 353 "ael.y"
2305     {
2306                 asprintf(&((yyval.str)), "%s%s%s", (yyvsp[-2].str), (yyvsp[-1].str), (yyvsp[0].str));
2307                 free((yyvsp[-2].str));
2308                 free((yyvsp[-1].str));
2309                 free((yyvsp[0].str));
2310                 prev_word=(yyval.str);;}
2311     break;
2312
2313   case 63:
2314 #line 361 "ael.y"
2315     { (yyval.str) = (yyvsp[0].str);;}
2316     break;
2317
2318   case 64:
2319 #line 362 "ael.y"
2320     {
2321                 asprintf(&((yyval.str)), "%s%s", (yyvsp[-1].str), (yyvsp[0].str));
2322                 free((yyvsp[-1].str));
2323                 free((yyvsp[0].str));;}
2324     break;
2325
2326   case 65:
2327 #line 366 "ael.y"
2328     {
2329                 asprintf(&((yyval.str)), "%s:%s", (yyvsp[-2].str), (yyvsp[0].str));
2330                 free((yyvsp[-2].str));
2331                 free((yyvsp[0].str));;}
2332     break;
2333
2334   case 66:
2335 #line 372 "ael.y"
2336     { reset_parencount(parseio->scanner); ;}
2337     break;
2338
2339   case 67:
2340 #line 372 "ael.y"
2341     {
2342                 (yyval.pval) = npval2(PV_SWITCH, &(yylsp[-5]), &(yylsp[0]));
2343                 (yyval.pval)->u1.str = (yyvsp[-2].str); ;}
2344     break;
2345
2346   case 68:
2347 #line 380 "ael.y"
2348     {
2349                 (yyval.pval) = npval2(PV_STATEMENTBLOCK, &(yylsp[-2]), &(yylsp[0]));
2350                 (yyval.pval)->u1.list = (yyvsp[-1].pval); ;}
2351     break;
2352
2353   case 69:
2354 #line 383 "ael.y"
2355     {reset_semicount(parseio->scanner);;}
2356     break;
2357
2358   case 70:
2359 #line 383 "ael.y"
2360     {
2361                 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[-4]), &(yylsp[0]));
2362                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2363                 (yyval.pval)->u2.val = (yyvsp[-1].str); ;}
2364     break;
2365
2366   case 71:
2367 #line 387 "ael.y"
2368     {
2369                 (yyval.pval) = npval2(PV_GOTO, &(yylsp[-2]), &(yylsp[0]));
2370                 (yyval.pval)->u1.list = (yyvsp[-1].pval);;}
2371     break;
2372
2373   case 72:
2374 #line 390 "ael.y"
2375     {
2376                 (yyval.pval) = npval2(PV_GOTO, &(yylsp[-2]), &(yylsp[0]));
2377                 (yyval.pval)->u1.list = (yyvsp[-1].pval);;}
2378     break;
2379
2380   case 73:
2381 #line 393 "ael.y"
2382     {
2383                 (yyval.pval) = npval2(PV_LABEL, &(yylsp[-1]), &(yylsp[0]));
2384                 (yyval.pval)->u1.str = (yyvsp[-1].str); ;}
2385     break;
2386
2387   case 74:
2388 #line 396 "ael.y"
2389     {reset_semicount(parseio->scanner);;}
2390     break;
2391
2392   case 75:
2393 #line 397 "ael.y"
2394     {reset_semicount(parseio->scanner);;}
2395     break;
2396
2397   case 76:
2398 #line 398 "ael.y"
2399     {reset_parencount(parseio->scanner);;}
2400     break;
2401
2402   case 77:
2403 #line 398 "ael.y"
2404     {
2405                 (yyval.pval) = npval2(PV_FOR, &(yylsp[-11]), &(yylsp[0]));
2406                 (yyval.pval)->u1.for_init = (yyvsp[-8].str);
2407                 (yyval.pval)->u2.for_test=(yyvsp[-5].str);
2408                 (yyval.pval)->u3.for_inc = (yyvsp[-2].str);
2409                 (yyval.pval)->u4.for_statements = (yyvsp[0].pval);;}
2410     break;
2411
2412   case 78:
2413 #line 404 "ael.y"
2414     {reset_parencount(parseio->scanner);;}
2415     break;
2416
2417   case 79:
2418 #line 404 "ael.y"
2419     {
2420                 (yyval.pval) = npval2(PV_WHILE, &(yylsp[-5]), &(yylsp[0]));
2421                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2422                 (yyval.pval)->u2.statements = (yyvsp[0].pval); ;}
2423     break;
2424
2425   case 80:
2426 #line 408 "ael.y"
2427     {
2428                 (yyval.pval) = update_last((yyvsp[-1].pval), &(yylsp[0])); ;}
2429     break;
2430
2431   case 81:
2432 #line 410 "ael.y"
2433     {
2434                 (yyval.pval) = update_last((yyvsp[-2].pval), &(yylsp[0]));
2435                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);;}
2436     break;
2437
2438   case 82:
2439 #line 413 "ael.y"
2440     {
2441                 (yyval.pval) = update_last((yyvsp[-1].pval), &(yylsp[-1])); ;}
2442     break;
2443
2444   case 83:
2445 #line 415 "ael.y"
2446     {
2447                 (yyval.pval) = update_last((yyvsp[-1].pval), &(yylsp[0])); ;}
2448     break;
2449
2450   case 84:
2451 #line 417 "ael.y"
2452     {
2453                 (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[-1]), &(yylsp[0]));
2454                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2455     break;
2456
2457   case 85:
2458 #line 420 "ael.y"
2459     {reset_semicount(parseio->scanner);;}
2460     break;
2461
2462   case 86:
2463 #line 420 "ael.y"
2464     {
2465                 char *bufx;
2466                 int tot=0;
2467                 pval *pptr;
2468                 (yyval.pval) = npval2(PV_VARDEC, &(yylsp[-4]), &(yylsp[0]));
2469                 (yyval.pval)->u2.val=(yyvsp[-1].str);
2470                 /* rebuild the original string-- this is not an app call, it's an unwrapped vardec, with a func call on the LHS */
2471                 /* string to big to fit in the buffer? */
2472                 tot+=strlen((yyvsp[-4].pval)->u1.str);
2473                 for(pptr=(yyvsp[-4].pval)->u2.arglist;pptr;pptr=pptr->next) {
2474                         tot+=strlen(pptr->u1.str);
2475                         tot++; /* for a sep like a comma */
2476                 }
2477                 tot+=4; /* for safety */
2478                 bufx = calloc(1, tot);
2479                 strcpy(bufx,(yyvsp[-4].pval)->u1.str);
2480                 strcat(bufx,"(");
2481                 /* XXX need to advance the pointer or the loop is very inefficient */
2482                 for (pptr=(yyvsp[-4].pval)->u2.arglist;pptr;pptr=pptr->next) {
2483                         if ( pptr != (yyvsp[-4].pval)->u2.arglist )
2484                                 strcat(bufx,",");
2485                         strcat(bufx,pptr->u1.str);
2486                 }
2487                 strcat(bufx,")");
2488 #ifdef AAL_ARGCHECK
2489                 if ( !ael_is_funcname((yyvsp[-4].pval)->u1.str) )
2490                         ast_log(LOG_WARNING, "==== File: %s, Line %d, Cols: %d-%d: Function call? The name %s is not in my internal list of function names\n",
2491                                 my_file, (yylsp[-4]).first_line, (yylsp[-4]).first_column, (yylsp[-4]).last_column, (yyvsp[-4].pval)->u1.str);
2492 #endif
2493                 (yyval.pval)->u1.str = bufx;
2494                 destroy_pval((yyvsp[-4].pval)); /* the app call it is not, get rid of that chain */
2495                 prev_word = 0;
2496         ;}
2497     break;
2498
2499   case 87:
2500 #line 453 "ael.y"
2501     { (yyval.pval) = npval2(PV_BREAK, &(yylsp[-1]), &(yylsp[0])); ;}
2502     break;
2503
2504   case 88:
2505 #line 454 "ael.y"
2506     { (yyval.pval) = npval2(PV_RETURN, &(yylsp[-1]), &(yylsp[0])); ;}
2507     break;
2508
2509   case 89:
2510 #line 455 "ael.y"
2511     { (yyval.pval) = npval2(PV_CONTINUE, &(yylsp[-1]), &(yylsp[0])); ;}
2512     break;
2513
2514   case 90:
2515 #line 456 "ael.y"
2516     {
2517                 (yyval.pval) = update_last((yyvsp[-2].pval), &(yylsp[-1])); /* XXX probably @3... */
2518                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);
2519                 (yyval.pval)->u3.else_statements = (yyvsp[0].pval);;}
2520     break;
2521
2522   case 91:
2523 #line 460 "ael.y"
2524     {
2525                 (yyval.pval) = update_last((yyvsp[-2].pval), &(yylsp[-1])); /* XXX probably @3... */
2526                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);
2527                 (yyval.pval)->u3.else_statements = (yyvsp[0].pval);;}
2528     break;
2529
2530   case 92:
2531 #line 464 "ael.y"
2532     {
2533                 (yyval.pval) = update_last((yyvsp[-2].pval), &(yylsp[-1])); /* XXX probably @3... */
2534                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);
2535                 (yyval.pval)->u3.else_statements = (yyvsp[0].pval);;}
2536     break;
2537
2538   case 93:
2539 #line 468 "ael.y"
2540     { (yyval.pval)=0; ;}
2541     break;
2542
2543   case 94:
2544 #line 471 "ael.y"
2545     { (yyval.pval) = (yyvsp[0].pval); ;}
2546     break;
2547
2548   case 95:
2549 #line 472 "ael.y"
2550     { (yyval.pval) = NULL ; ;}
2551     break;
2552
2553   case 96:
2554 #line 477 "ael.y"
2555     { (yyval.pval) = nword((yyvsp[0].str), &(yylsp[0])); ;}
2556     break;
2557
2558   case 97:
2559 #line 478 "ael.y"
2560     {
2561                 (yyval.pval) = nword((yyvsp[-2].str), &(yylsp[-2]));
2562                 (yyval.pval)->next = nword((yyvsp[0].str), &(yylsp[0])); ;}
2563     break;
2564
2565   case 98:
2566 #line 481 "ael.y"
2567     {
2568                 (yyval.pval) = nword((yyvsp[-2].str), &(yylsp[-2]));
2569                 (yyval.pval)->next = nword((yyvsp[0].str), &(yylsp[0])); ;}
2570     break;
2571
2572   case 99:
2573 #line 484 "ael.y"
2574     {
2575                 (yyval.pval) = nword((yyvsp[-4].str), &(yylsp[-4]));
2576                 (yyval.pval)->next = nword((yyvsp[-2].str), &(yylsp[-2]));
2577                 (yyval.pval)->next->next = nword((yyvsp[0].str), &(yylsp[0])); ;}
2578     break;
2579
2580   case 100:
2581 #line 488 "ael.y"
2582     {
2583                 (yyval.pval) = nword((yyvsp[-4].str), &(yylsp[-4]));
2584                 (yyval.pval)->next = nword((yyvsp[-2].str), &(yylsp[-2]));
2585                 (yyval.pval)->next->next = nword((yyvsp[0].str), &(yylsp[0])); ;}
2586     break;
2587
2588   case 101:
2589 #line 492 "ael.y"
2590     {
2591                 (yyval.pval) = nword(strdup("default"), &(yylsp[-4]));
2592                 (yyval.pval)->next = nword((yyvsp[-2].str), &(yylsp[-2]));
2593                 (yyval.pval)->next->next = nword((yyvsp[0].str), &(yylsp[0])); ;}
2594     break;
2595
2596   case 102:
2597 #line 496 "ael.y"
2598     {
2599                 (yyval.pval) = nword(strdup("default"), &(yylsp[-4]));
2600                 (yyval.pval)->next = nword((yyvsp[-2].str), &(yylsp[-2]));
2601                 (yyval.pval)->next->next = nword((yyvsp[0].str), &(yylsp[0])); ;}
2602     break;
2603
2604   case 103:
2605 #line 503 "ael.y"
2606     {
2607                 (yyval.pval) = nword((yyvsp[0].str), &(yylsp[0]));
2608                 (yyval.pval)->next = nword(strdup("1"), &(yylsp[0])); ;}
2609     break;
2610
2611   case 104:
2612 #line 506 "ael.y"
2613     {
2614                 (yyval.pval) = nword((yyvsp[-2].str), &(yylsp[-2]));
2615                 (yyval.pval)->next = nword((yyvsp[0].str), &(yylsp[0])); ;}
2616     break;
2617
2618   case 105:
2619 #line 509 "ael.y"
2620     {   /* XXX they are stored in a different order */
2621                 (yyval.pval) = nword((yyvsp[0].str), &(yylsp[0]));
2622                 (yyval.pval)->next = nword((yyvsp[-4].str), &(yylsp[-4]));
2623                 (yyval.pval)->next->next = nword((yyvsp[-2].str), &(yylsp[-2])); ;}
2624     break;
2625
2626   case 106:
2627 #line 513 "ael.y"
2628     {
2629                 (yyval.pval) = nword((yyvsp[0].str), &(yylsp[0]));
2630                 (yyval.pval)->next = nword((yyvsp[-2].str), &(yylsp[-2]));
2631                 (yyval.pval)->next->next = nword(strdup("1"), &(yylsp[0])); ;}
2632     break;
2633
2634   case 107:
2635 #line 517 "ael.y"
2636     {
2637                 (yyval.pval) = nword(strdup("default"), &(yylsp[-4]));
2638                 (yyval.pval)->next = nword((yyvsp[-4].str), &(yylsp[-4]));
2639                 (yyval.pval)->next->next = nword((yyvsp[-2].str), &(yylsp[-2])); ;}
2640     break;
2641
2642   case 108:
2643 #line 521 "ael.y"
2644     {
2645                 (yyval.pval) = nword(strdup("default"), &(yylsp[-2]));
2646                 (yyval.pval)->next = nword((yyvsp[-2].str), &(yylsp[0]));
2647                 (yyval.pval)->next->next = nword( strdup("1"), &(yylsp[0])); ;}
2648     break;
2649
2650   case 109:
2651 #line 527 "ael.y"
2652     {reset_argcount(parseio->scanner);;}
2653     break;
2654
2655   case 110:
2656 #line 527 "ael.y"
2657     {
2658                 /* XXX original code had @2 but i think we need @5 */
2659                 (yyval.pval) = npval2(PV_MACRO_CALL, &(yylsp[-4]), &(yylsp[0]));
2660                 (yyval.pval)->u1.str = (yyvsp[-4].str);
2661                 (yyval.pval)->u2.arglist = (yyvsp[-1].pval);;}
2662     break;
2663
2664   case 111:
2665 #line 532 "ael.y"
2666     {
2667                 (yyval.pval)= npval2(PV_MACRO_CALL, &(yylsp[-2]), &(yylsp[0]));
2668                 (yyval.pval)->u1.str = (yyvsp[-2].str); ;}
2669     break;
2670
2671   case 112:
2672 #line 540 "ael.y"
2673     {reset_argcount(parseio->scanner);;}
2674     break;
2675
2676   case 113:
2677 #line 540 "ael.y"
2678     {
2679                 if (strcasecmp((yyvsp[-2].str),"goto") == 0) {
2680                         (yyval.pval) = npval2(PV_GOTO, &(yylsp[-2]), &(yylsp[-1]));
2681                         free((yyvsp[-2].str)); /* won't be using this */
2682                         ast_log(LOG_WARNING, "==== File: %s, Line %d, Cols: %d-%d: Suggestion: Use the goto statement instead of the Goto() application call in AEL.\n", my_file, (yylsp[-2]).first_line, (yylsp[-2]).first_column, (yylsp[-2]).last_column );
2683                 } else {
2684                         (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[-2]), &(yylsp[-1]));
2685                         (yyval.pval)->u1.str = (yyvsp[-2].str);
2686                 } ;}
2687     break;
2688
2689   case 114:
2690 #line 551 "ael.y"
2691     {
2692                 (yyval.pval) = update_last((yyvsp[-2].pval), &(yylsp[0]));
2693                 if( (yyval.pval)->type == PV_GOTO )
2694                         (yyval.pval)->u1.list = (yyvsp[-1].pval);
2695                 else
2696                         (yyval.pval)->u2.arglist = (yyvsp[-1].pval);
2697         ;}
2698     break;
2699
2700   case 115:
2701 #line 558 "ael.y"
2702     { (yyval.pval) = update_last((yyvsp[-1].pval), &(yylsp[0])); ;}
2703     break;
2704
2705   case 116:
2706 #line 561 "ael.y"
2707     { (yyval.str) = (yyvsp[0].str) ;}
2708     break;
2709
2710   case 117:
2711 #line 562 "ael.y"
2712     { (yyval.str) = strdup(""); ;}
2713     break;
2714
2715   case 118:
2716 #line 565 "ael.y"
2717     { (yyval.pval) = nword((yyvsp[0].str), &(yylsp[0])); ;}
2718     break;
2719
2720   case 119:
2721 #line 566 "ael.y"
2722     {
2723                 (yyval.pval)= npval(PV_WORD,0/*@1.first_line*/,0/*@1.last_line*/,0/* @1.first_column*/, 0/*@1.last_column*/);
2724                 (yyval.pval)->u1.str = strdup(""); ;}
2725     break;
2726
2727   case 120:
2728 #line 569 "ael.y"
2729     { (yyval.pval) = linku1((yyvsp[-2].pval), nword((yyvsp[0].str), &(yylsp[0]))); ;}
2730     break;
2731
2732   case 121:
2733 #line 572 "ael.y"
2734     {(yyval.pval)=(yyvsp[0].pval);;}
2735     break;
2736
2737   case 122:
2738 #line 573 "ael.y"
2739     { (yyval.pval) = linku1((yyvsp[-1].pval), (yyvsp[0].pval)); ;}
2740     break;
2741
2742   case 123:
2743 #line 576 "ael.y"
2744     {
2745                 (yyval.pval) = npval2(PV_CASE, &(yylsp[-3]), &(yylsp[-1])); /* XXX 3 or 4 ? */
2746                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2747                 (yyval.pval)->u2.statements = (yyvsp[0].pval);;}
2748     break;
2749
2750   case 124:
2751 #line 580 "ael.y"
2752     {
2753                 (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[-2]), &(yylsp[0]));
2754                 (yyval.pval)->u1.str = NULL;
2755                 (yyval.pval)->u2.statements = (yyvsp[0].pval);;}
2756     break;
2757
2758   case 125:
2759 #line 584 "ael.y"
2760     {
2761                 (yyval.pval) = npval2(PV_PATTERN, &(yylsp[-3]), &(yylsp[0])); /* XXX@3 or @4 ? */
2762                 (yyval.pval)->u1.str = (yyvsp[-2].str);
2763                 (yyval.pval)->u2.statements = (yyvsp[0].pval);;}
2764     break;
2765
2766   case 126:
2767 #line 588 "ael.y"
2768     {
2769                 (yyval.pval) = npval2(PV_CASE, &(yylsp[-2]), &(yylsp[0]));
2770                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2771     break;
2772
2773   case 127:
2774 #line 591 "ael.y"
2775     {
2776                 (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[-1]), &(yylsp[0]));
2777                 (yyval.pval)->u1.str = NULL;;}
2778     break;
2779
2780   case 128:
2781 #line 594 "ael.y"
2782     {
2783                 (yyval.pval) = npval2(PV_PATTERN, &(yylsp[-2]), &(yylsp[0]));
2784                 (yyval.pval)->u1.str = (yyvsp[-1].str);;}
2785     break;
2786
2787   case 129:
2788 #line 599 "ael.y"
2789     {(yyval.pval) = (yyvsp[0].pval);;}
2790     break;
2791
2792   case 130:
2793 #line 600 "ael.y"
2794     { (yyval.pval) = linku1((yyvsp[-1].pval), (yyvsp[0].pval)); ;}
2795     break;
2796
2797   case 131:
2798 #line 603 "ael.y"
2799     {(yyval.pval)=(yyvsp[0].pval);;}
2800     break;
2801
2802   case 132:
2803 #line 604 "ael.y"
2804     {
2805                 (yyval.pval) = npval2(PV_CATCH, &(yylsp[-4]), &(yylsp[0]));
2806                 (yyval.pval)->u1.str = (yyvsp[-3].str);
2807                 (yyval.pval)->u2.statements = (yyvsp[-1].pval);;}
2808     break;
2809
2810   case 133:
2811 #line 610 "ael.y"
2812     {
2813                 (yyval.pval) = npval2(PV_SWITCHES, &(yylsp[-1]), &(yylsp[0]));
2814                 (yyval.pval)->u1.list = (yyvsp[0].pval); ;}
2815     break;
2816
2817   case 134:
2818 #line 615 "ael.y"
2819     {
2820                 (yyval.pval) = npval2(PV_ESWITCHES, &(yylsp[-1]), &(yylsp[0]));
2821                 (yyval.pval)->u1.list = (yyvsp[0].pval); ;}
2822     break;
2823
2824   case 135:
2825 #line 620 "ael.y"
2826     { (yyval.pval) = (yyvsp[-1].pval); ;}
2827     break;
2828
2829   case 136:
2830 #line 621 "ael.y"
2831     { (yyval.pval) = NULL; ;}
2832     break;
2833
2834   case 137:
2835 #line 624 "ael.y"
2836     { (yyval.pval) = nword((yyvsp[-1].str), &(yylsp[-1])); ;}
2837     break;
2838
2839   case 138:
2840 #line 625 "ael.y"
2841     { (yyval.pval) = linku1((yyvsp[-2].pval), nword((yyvsp[-1].str), &(yylsp[-1]))); ;}
2842     break;
2843
2844   case 139:
2845 #line 626 "ael.y"
2846     {(yyval.pval)=(yyvsp[-1].pval);;}
2847     break;
2848
2849   case 140:
2850 #line 629 "ael.y"
2851     { (yyval.pval) = nword((yyvsp[-1].str), &(yylsp[-1])); ;}
2852     break;
2853
2854   case 141:
2855 #line 631 "ael.y"
2856     {
2857                 (yyval.pval) = nword((yyvsp[-13].str), &(yylsp[-13]));
2858                 (yyval.pval)->u2.arglist = npval2(PV_WORD, &(yylsp[-11]), &(yylsp[-7]));
2859                 asprintf( &((yyval.pval)->u2.arglist->u1.str), "%s:%s:%s", (yyvsp[-11].str), (yyvsp[-9].str), (yyvsp[-7].str));
2860                 free((yyvsp[-11].str));
2861                 free((yyvsp[-9].str));
2862                 free((yyvsp[-7].str));
2863                 (yyval.pval)->u2.arglist->next = nword((yyvsp[-5].str), &(yylsp[-5]));
2864                 (yyval.pval)->u2.arglist->next->next = nword((yyvsp[-3].str), &(yylsp[-3]));
2865                 (yyval.pval)->u2.arglist->next->next->next = nword((yyvsp[-1].str), &(yylsp[-1]));
2866                 prev_word=0;
2867         ;}
2868     break;
2869
2870   case 142:
2871 #line 643 "ael.y"
2872     {
2873                 (yyval.pval) = nword((yyvsp[-9].str), &(yylsp[-9]));
2874                 (yyval.pval)->u2.arglist = nword((yyvsp[-7].str), &(yylsp[-7]));
2875                 (yyval.pval)->u2.arglist->next = nword((yyvsp[-5].str), &(yylsp[-5]));
2876                 (yyval.pval)->u2.arglist->next->next = nword((yyvsp[-3].str), &(yylsp[-3]));
2877                 (yyval.pval)->u2.arglist->next->next->next = nword((yyvsp[-1].str), &(yylsp[-1]));
2878                 prev_word=0;
2879         ;}
2880     break;
2881
2882   case 143:
2883 #line 651 "ael.y"
2884     { (yyval.pval) = linku1((yyvsp[-2].pval), nword((yyvsp[-1].str), &(yylsp[-1]))); ;}
2885     break;
2886
2887   case 144:
2888 #line 653 "ael.y"
2889     {
2890                 pval *z = nword((yyvsp[-13].str), &(yylsp[-13]));
2891                 (yyval.pval) = linku1((yyvsp[-14].pval), z);
2892                 z->u2.arglist = npval2(PV_WORD, &(yylsp[-11]), &(yylsp[-7]));
2893                 asprintf( &((yyval.pval)->u2.arglist->u1.str), "%s:%s:%s", (yyvsp[-11].str), (yyvsp[-9].str), (yyvsp[-7].str));
2894                 free((yyvsp[-11].str));
2895                 free((yyvsp[-9].str));
2896                 free((yyvsp[-7].str));
2897                 z->u2.arglist->next = nword((yyvsp[-5].str), &(yylsp[-5]));
2898                 z->u2.arglist->next->next = nword((yyvsp[-3].str), &(yylsp[-3]));
2899                 z->u2.arglist->next->next->next = nword((yyvsp[-1].str), &(yylsp[-1]));
2900                 prev_word=0;
2901         ;}
2902     break;
2903
2904   case 145:
2905 #line 666 "ael.y"
2906     {
2907                 pval *z = npval2(PV_WORD, &(yylsp[-9]), &(yylsp[-8]));
2908                 (yyval.pval) = linku1((yyvsp[-10].pval), z);
2909                 (yyval.pval)->u2.arglist->u1.str = (yyvsp[-7].str);                     /* XXX maybe too early ? */
2910                 z->u1.str = (yyvsp[-9].str);
2911                 z->u2.arglist = npval2(PV_WORD, &(yylsp[-7]), &(yylsp[-7]));    /* XXX is this correct ? */
2912                 z->u2.arglist->next = nword((yyvsp[-5].str), &(yylsp[-5]));
2913                 z->u2.arglist->next->next = nword((yyvsp[-3].str), &(yylsp[-3]));
2914                 z->u2.arglist->next->next->next = nword((yyvsp[-1].str), &(yylsp[-1]));
2915                 prev_word=0;
2916         ;}
2917     break;
2918
2919   case 146:
2920 #line 677 "ael.y"
2921     {(yyval.pval)=(yyvsp[-1].pval);;}
2922     break;
2923
2924   case 147:
2925 #line 680 "ael.y"
2926     { (yyval.str) = (yyvsp[0].str);;}
2927     break;
2928
2929   case 148:
2930 #line 681 "ael.y"
2931     {(yyval.str)=strdup("default");;}
2932     break;
2933
2934   case 149:
2935 #line 684 "ael.y"
2936     {
2937                 (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[-3]), &(yylsp[0]));
2938                 (yyval.pval)->u1.list = (yyvsp[-1].pval);;}
2939     break;
2940
2941   case 150:
2942 #line 687 "ael.y"
2943     {
2944                 (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[-2]), &(yylsp[0]));;}
2945     break;
2946
2947
2948       default: break;
2949     }
2950
2951 /* Line 1126 of yacc.c.  */
2952 #line 2953 "ael.tab.c"
2953 \f
2954   yyvsp -= yylen;
2955   yyssp -= yylen;
2956   yylsp -= yylen;
2957
2958   YY_STACK_PRINT (yyss, yyssp);
2959
2960   *++yyvsp = yyval;
2961   *++yylsp = yyloc;
2962
2963   /* Now `shift' the result of the reduction.  Determine what state
2964      that goes to, based on the state we popped back to and the rule
2965      number reduced by.  */
2966
2967   yyn = yyr1[yyn];
2968
2969   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2970   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2971     yystate = yytable[yystate];
2972   else
2973     yystate = yydefgoto[yyn - YYNTOKENS];
2974
2975   goto yynewstate;
2976
2977
2978 /*------------------------------------.
2979 | yyerrlab -- here on detecting error |
2980 `------------------------------------*/
2981 yyerrlab:
2982   /* If not already recovering from an error, report this error.  */
2983   if (!yyerrstatus)
2984     {
2985       ++yynerrs;
2986 #if YYERROR_VERBOSE
2987       yyn = yypact[yystate];
2988
2989       if (YYPACT_NINF < yyn && yyn < YYLAST)
2990         {
2991           int yytype = YYTRANSLATE (yychar);
2992           YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2993           YYSIZE_T yysize = yysize0;
2994           YYSIZE_T yysize1;
2995           int yysize_overflow = 0;
2996           char *yymsg = 0;
2997 #         define YYERROR_VERBOSE_ARGS_MAXIMUM 5
2998           char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2999           int yyx;
3000
3001 #if 0
3002           /* This is so xgettext sees the translatable formats that are
3003              constructed on the fly.  */
3004           YY_("syntax error, unexpected %s");
3005           YY_("syntax error, unexpected %s, expecting %s");
3006           YY_("syntax error, unexpected %s, expecting %s or %s");
3007           YY_("syntax error, unexpected %s, expecting %s or %s or %s");
3008           YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
3009 #endif
3010           char *yyfmt;
3011           char const *yyf;
3012           static char const yyunexpected[] = "syntax error, unexpected %s";
3013           static char const yyexpecting[] = ", expecting %s";
3014           static char const yyor[] = " or %s";
3015           char yyformat[sizeof yyunexpected
3016                         + sizeof yyexpecting - 1
3017                         + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
3018                            * (sizeof yyor - 1))];
3019           char const *yyprefix = yyexpecting;
3020
3021           /* Start YYX at -YYN if negative to avoid negative indexes in
3022              YYCHECK.  */
3023           int yyxbegin = yyn < 0 ? -yyn : 0;
3024
3025           /* Stay within bounds of both yycheck and yytname.  */
3026           int yychecklim = YYLAST - yyn;
3027           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3028           int yycount = 1;
3029
3030           yyarg[0] = yytname[yytype];
3031           yyfmt = yystpcpy (yyformat, yyunexpected);
3032
3033           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3034             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3035               {
3036                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3037                   {
3038                     yycount = 1;
3039                     yysize = yysize0;
3040                     yyformat[sizeof yyunexpected - 1] = '\0';
3041                     break;
3042                   }
3043                 yyarg[yycount++] = yytname[yyx];
3044                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
3045                 yysize_overflow |= yysize1 < yysize;
3046                 yysize = yysize1;
3047                 yyfmt = yystpcpy (yyfmt, yyprefix);
3048                 yyprefix = yyor;
3049               }
3050
3051           yyf = YY_(yyformat);
3052           yysize1 = yysize + yystrlen (yyf);
3053           yysize_overflow |= yysize1 < yysize;
3054           yysize = yysize1;
3055
3056           if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
3057             yymsg = (char *) YYSTACK_ALLOC (yysize);
3058           if (yymsg)
3059             {
3060               /* Avoid sprintf, as that infringes on the user's name space.
3061                  Don't have undefined behavior even if the translation
3062                  produced a string with the wrong number of "%s"s.  */
3063               char *yyp = yymsg;
3064               int yyi = 0;
3065               while ((*yyp = *yyf))
3066                 {
3067                   if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
3068                     {
3069                       yyp += yytnamerr (yyp, yyarg[yyi++]);
3070                       yyf += 2;
3071                     }
3072                   else
3073                     {
3074                       yyp++;
3075                       yyf++;
3076                     }
3077                 }
3078               yyerror (&yylloc, parseio, yymsg);
3079               YYSTACK_FREE (yymsg);
3080             }
3081           else
3082             {
3083               yyerror (&yylloc, parseio, YY_("syntax error"));
3084               goto yyexhaustedlab;
3085             }
3086         }
3087       else
3088 #endif /* YYERROR_VERBOSE */
3089         yyerror (&yylloc, parseio, YY_("syntax error"));
3090     }
3091
3092   yyerror_range[0] = yylloc;
3093
3094   if (yyerrstatus == 3)
3095     {
3096       /* If just tried and failed to reuse look-ahead token after an
3097          error, discard it.  */
3098
3099       if (yychar <= YYEOF)
3100         {
3101           /* Return failure if at end of input.  */
3102           if (yychar == YYEOF)
3103             YYABORT;
3104         }
3105       else
3106         {
3107           yydestruct ("Error: discarding", yytoken, &yylval, &yylloc);
3108           yychar = YYEMPTY;
3109         }
3110     }
3111
3112   /* Else will try to reuse look-ahead token after shifting the error
3113      token.  */
3114   goto yyerrlab1;
3115
3116
3117 /*---------------------------------------------------.
3118 | yyerrorlab -- error raised explicitly by YYERROR.  |
3119 `---------------------------------------------------*/
3120 yyerrorlab:
3121
3122   /* Pacify compilers like GCC when the user code never invokes
3123      YYERROR and the label yyerrorlab therefore never appears in user
3124      code.  */
3125   if (0)
3126      goto yyerrorlab;
3127
3128   yyerror_range[0] = yylsp[1-yylen];
3129   yylsp -= yylen;
3130   yyvsp -= yylen;
3131   yyssp -= yylen;
3132   yystate = *yyssp;
3133   goto yyerrlab1;
3134
3135
3136 /*-------------------------------------------------------------.
3137 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
3138 `-------------------------------------------------------------*/
3139 yyerrlab1:
3140   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
3141
3142   for (;;)
3143     {
3144       yyn = yypact[yystate];
3145       if (yyn != YYPACT_NINF)
3146         {
3147           yyn += YYTERROR;
3148           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3149             {
3150               yyn = yytable[yyn];
3151               if (0 < yyn)
3152                 break;
3153             }
3154         }
3155
3156       /* Pop the current state because it cannot handle the error token.  */
3157       if (yyssp == yyss)
3158         YYABORT;
3159
3160       yyerror_range[0] = *yylsp;
3161       yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp);
3162       YYPOPSTACK;
3163       yystate = *yyssp;
3164       YY_STACK_PRINT (yyss, yyssp);
3165     }
3166
3167   if (yyn == YYFINAL)
3168     YYACCEPT;
3169
3170   *++yyvsp = yylval;
3171
3172   yyerror_range[1] = yylloc;
3173   /* Using YYLLOC is tempting, but would change the location of
3174      the look-ahead.  YYLOC is available though. */
3175   YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
3176   *++yylsp = yyloc;
3177
3178   /* Shift the error token. */
3179   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3180
3181   yystate = yyn;
3182   goto yynewstate;
3183
3184
3185 /*-------------------------------------.
3186 | yyacceptlab -- YYACCEPT comes here.  |
3187 `-------------------------------------*/
3188 yyacceptlab:
3189   yyresult = 0;
3190   goto yyreturn;
3191
3192 /*-----------------------------------.
3193 | yyabortlab -- YYABORT comes here.  |
3194 `-----------------------------------*/
3195 yyabortlab:
3196   yyresult = 1;
3197   goto yyreturn;
3198
3199 #ifndef yyoverflow
3200 /*-------------------------------------------------.
3201 | yyexhaustedlab -- memory exhaustion comes here.  |
3202 `-------------------------------------------------*/
3203 yyexhaustedlab:
3204   yyerror (&yylloc, parseio, YY_("memory exhausted"));
3205   yyresult = 2;
3206   /* Fall through.  */
3207 #endif
3208
3209 yyreturn:
3210   if (yychar != YYEOF && yychar != YYEMPTY)
3211      yydestruct ("Cleanup: discarding lookahead",
3212                  yytoken, &yylval, &yylloc);
3213   while (yyssp != yyss)
3214     {
3215       yydestruct ("Cleanup: popping",
3216                   yystos[*yyssp], yyvsp, yylsp);
3217       YYPOPSTACK;
3218     }
3219 #ifndef yyoverflow
3220   if (yyss != yyssa)
3221     YYSTACK_FREE (yyss);
3222 #endif
3223   return yyresult;
3224 }
3225
3226
3227 #line 692 "ael.y"
3228
3229
3230 static char *token_equivs1[] =
3231 {
3232         "AMPER",
3233         "AT",
3234         "BAR",
3235         "COLON",
3236         "COMMA",
3237         "EQ",
3238         "EXTENMARK",
3239         "KW_BREAK",
3240         "KW_CASE",
3241         "KW_CATCH",
3242         "KW_CONTEXT",
3243         "KW_CONTINUE",
3244         "KW_DEFAULT",
3245         "KW_ELSE",
3246         "KW_ESWITCHES",
3247         "KW_FOR",
3248         "KW_GLOBALS",
3249         "KW_GOTO",
3250         "KW_HINT",
3251         "KW_IFTIME",
3252         "KW_IF",
3253         "KW_IGNOREPAT",
3254         "KW_INCLUDES"
3255         "KW_JUMP",
3256         "KW_MACRO",
3257         "KW_PATTERN",
3258         "KW_REGEXTEN",
3259         "KW_RETURN",
3260         "KW_SWITCHES",
3261         "KW_SWITCH",
3262         "KW_WHILE",
3263         "LC",
3264         "LP",
3265         "RC",
3266         "RP",
3267         "SEMI",
3268 };
3269
3270 static char *token_equivs2[] =
3271 {
3272         "&",
3273         "@",
3274         "|",
3275         ":",
3276         ",",
3277         "=",
3278         "=>",
3279         "break",
3280         "case",
3281         "catch",
3282         "context",
3283         "continue",
3284         "default",
3285         "else",
3286         "eswitches",
3287         "for",
3288         "globals",
3289         "goto",
3290         "hint",
3291         "ifTime",
3292         "if",
3293         "ignorepat",
3294         "includes"
3295         "jump",
3296         "macro",
3297         "pattern",
3298         "regexten",
3299         "return",
3300         "switches",
3301         "switch",
3302         "while",
3303         "{",
3304         "(",
3305         "}",
3306         ")",
3307         ";",
3308 };
3309
3310
3311 static char *ael_token_subst(char *mess)
3312 {
3313         /* calc a length, malloc, fill, and return; yyerror had better free it! */
3314         int len=0,i;
3315         char *p;
3316         char *res, *s,*t;
3317         int token_equivs_entries = sizeof(token_equivs1)/sizeof(char*);
3318
3319         for (p=mess; *p; p++) {
3320                 for (i=0; i<token_equivs_entries; i++) {
3321                         if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 )
3322                         {
3323                                 len+=strlen(token_equivs2[i])+2;
3324                                 p += strlen(token_equivs1[i])-1;
3325                                 break;
3326                         }
3327                 }
3328                 len++;
3329         }
3330         res = calloc(1, len+1);
3331         res[0] = 0;
3332         s = res;
3333         for (p=mess; *p;) {
3334                 int found = 0;
3335                 for (i=0; i<token_equivs_entries; i++) {
3336                         if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 ) {
3337                                 *s++ = '\'';
3338                                 for (t=token_equivs2[i]; *t;) {
3339                                         *s++ = *t++;
3340                                 }
3341                                 *s++ = '\'';
3342                                 p += strlen(token_equivs1[i]);
3343                                 found = 1;
3344                                 break;
3345                         }
3346                 }
3347                 if( !found )
3348                         *s++ = *p++;
3349         }
3350         *s++ = 0;
3351         return res;