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