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