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