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