pbx/ael/ael.tab.c

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