Wed Aug 7 17:15:33 2019

Asterisk developer's documentation


ael.tab.c

Go to the documentation of this file.
00001 /* A Bison parser, made by GNU Bison 2.5.  */
00002 
00003 /* Bison implementation for Yacc-like parsers in C
00004    
00005       Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
00006    
00007    This program is free software: you can redistribute it and/or modify
00008    it under the terms of the GNU General Public License as published by
00009    the Free Software Foundation, either version 3 of the License, or
00010    (at your option) any later version.
00011    
00012    This program is distributed in the hope that it will be useful,
00013    but WITHOUT ANY WARRANTY; without even the implied warranty of
00014    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015    GNU General Public License for more details.
00016    
00017    You should have received a copy of the GNU General Public License
00018    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
00019 
00020 /* As a special exception, you may create a larger work that contains
00021    part or all of the Bison parser skeleton and distribute that work
00022    under terms of your choice, so long as that work isn't itself a
00023    parser generator using the skeleton or a modified version thereof
00024    as a parser skeleton.  Alternatively, if you modify or redistribute
00025    the parser skeleton itself, you may (at your option) remove this
00026    special exception, which will cause the skeleton and the resulting
00027    Bison output files to be licensed under the GNU General Public
00028    License without this special exception.
00029    
00030    This special exception was added by the Free Software Foundation in
00031    version 2.2 of Bison.  */
00032 
00033 /* C LALR(1) parser skeleton written by Richard Stallman, by
00034    simplifying the original so-called "semantic" parser.  */
00035 
00036 /* All symbols defined below should begin with yy or YY, to avoid
00037    infringing on user name space.  This should be done even for local
00038    variables, as they might otherwise be expanded by user macros.
00039    There are some unavoidable exceptions within include files to
00040    define necessary library symbols; they are noted "INFRINGES ON
00041    USER NAME SPACE" below.  */
00042 
00043 /* Identify Bison output.  */
00044 #define YYBISON 1
00045 
00046 /* Bison version.  */
00047 #define YYBISON_VERSION "2.5"
00048 
00049 /* Skeleton name.  */
00050 #define YYSKELETON_NAME "yacc.c"
00051 
00052 /* Pure parsers.  */
00053 #define YYPURE 1
00054 
00055 /* Push parsers.  */
00056 #define YYPUSH 0
00057 
00058 /* Pull parsers.  */
00059 #define YYPULL 1
00060 
00061 /* Using locations.  */
00062 #define YYLSP_NEEDED 1
00063 
00064 /* Substitute the variable and function names.  */
00065 #define yyparse         ael_yyparse
00066 #define yylex           ael_yylex
00067 #define yyerror         ael_yyerror
00068 #define yylval          ael_yylval
00069 #define yychar          ael_yychar
00070 #define yydebug         ael_yydebug
00071 #define yynerrs         ael_yynerrs
00072 #define yylloc          ael_yylloc
00073 
00074 /* Copy the first part of user declarations.  */
00075 
00076 /* Line 268 of yacc.c  */
00077 #line 1 "ael.y"
00078 
00079 /*
00080  * Asterisk -- An open source telephony toolkit.
00081  *
00082  * Copyright (C) 2006, Digium, Inc.
00083  *
00084  * Steve Murphy <murf@parsetree.com>
00085  *
00086  * See http://www.asterisk.org for more information about
00087  * the Asterisk project. Please do not directly contact
00088  * any of the maintainers of this project for assistance;
00089  * the project provides a web site, mailing lists and IRC
00090  * channels for your use.
00091  *
00092  * This program is free software, distributed under the terms of
00093  * the GNU General Public License Version 2. See the LICENSE file
00094  * at the top of the source tree.
00095  */
00096 /*! \file
00097  *
00098  * \brief Bison Grammar description of AEL2.
00099  *
00100  */
00101 
00102 #include "asterisk.h"
00103 
00104 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 360357 $")
00105 
00106 #include <stdio.h>
00107 #include <stdlib.h>
00108 #include <string.h>
00109 
00110 #include "asterisk/logger.h"
00111 #include "asterisk/lock.h"
00112 #include "asterisk/hashtab.h"
00113 #include "asterisk/ael_structs.h"
00114 #include "asterisk/utils.h"
00115 
00116 extern struct ast_flags ast_compat;
00117 
00118 pval * linku1(pval *head, pval *tail);
00119 static void set_dads(pval *dad, pval *child_list);
00120 void reset_parencount(yyscan_t yyscanner);
00121 void reset_semicount(yyscan_t yyscanner);
00122 void reset_argcount(yyscan_t yyscanner );
00123  
00124 #define YYLEX_PARAM ((struct parse_io *)parseio)->scanner
00125 #define YYERROR_VERBOSE 1
00126 
00127 extern char *my_file;
00128 #ifdef AAL_ARGCHECK
00129 int ael_is_funcname(char *name);
00130 #endif
00131 static char *ael_token_subst(const char *mess);
00132 
00133 
00134 
00135 /* Line 268 of yacc.c  */
00136 #line 137 "ael.tab.c"
00137 
00138 /* Enabling traces.  */
00139 #ifndef YYDEBUG
00140 # define YYDEBUG 0
00141 #endif
00142 
00143 /* Enabling verbose error messages.  */
00144 #ifdef YYERROR_VERBOSE
00145 # undef YYERROR_VERBOSE
00146 # define YYERROR_VERBOSE 1
00147 #else
00148 # define YYERROR_VERBOSE 1
00149 #endif
00150 
00151 /* Enabling the token table.  */
00152 #ifndef YYTOKEN_TABLE
00153 # define YYTOKEN_TABLE 0
00154 #endif
00155 
00156 
00157 /* Tokens.  */
00158 #ifndef YYTOKENTYPE
00159 # define YYTOKENTYPE
00160    /* Put the tokens into the symbol table, so that GDB and other debuggers
00161       know about them.  */
00162    enum yytokentype {
00163      KW_CONTEXT = 258,
00164      LC = 259,
00165      RC = 260,
00166      LP = 261,
00167      RP = 262,
00168      SEMI = 263,
00169      EQ = 264,
00170      COMMA = 265,
00171      COLON = 266,
00172      AMPER = 267,
00173      BAR = 268,
00174      AT = 269,
00175      KW_MACRO = 270,
00176      KW_GLOBALS = 271,
00177      KW_IGNOREPAT = 272,
00178      KW_SWITCH = 273,
00179      KW_IF = 274,
00180      KW_IFTIME = 275,
00181      KW_ELSE = 276,
00182      KW_RANDOM = 277,
00183      KW_ABSTRACT = 278,
00184      KW_EXTEND = 279,
00185      EXTENMARK = 280,
00186      KW_GOTO = 281,
00187      KW_JUMP = 282,
00188      KW_RETURN = 283,
00189      KW_BREAK = 284,
00190      KW_CONTINUE = 285,
00191      KW_REGEXTEN = 286,
00192      KW_HINT = 287,
00193      KW_FOR = 288,
00194      KW_WHILE = 289,
00195      KW_CASE = 290,
00196      KW_PATTERN = 291,
00197      KW_DEFAULT = 292,
00198      KW_CATCH = 293,
00199      KW_SWITCHES = 294,
00200      KW_ESWITCHES = 295,
00201      KW_INCLUDES = 296,
00202      KW_LOCAL = 297,
00203      word = 298
00204    };
00205 #endif
00206 
00207 
00208 
00209 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00210 typedef union YYSTYPE
00211 {
00212 
00213 /* Line 293 of yacc.c  */
00214 #line 59 "ael.y"
00215 
00216    int   intval;     /* integer value, typically flags */
00217    char  *str;    /* strings */
00218    struct pval *pval;   /* full objects */
00219 
00220 
00221 
00222 /* Line 293 of yacc.c  */
00223 #line 224 "ael.tab.c"
00224 } YYSTYPE;
00225 # define YYSTYPE_IS_TRIVIAL 1
00226 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00227 # define YYSTYPE_IS_DECLARED 1
00228 #endif
00229 
00230 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
00231 typedef struct YYLTYPE
00232 {
00233   int first_line;
00234   int first_column;
00235   int last_line;
00236   int last_column;
00237 } YYLTYPE;
00238 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
00239 # define YYLTYPE_IS_DECLARED 1
00240 # define YYLTYPE_IS_TRIVIAL 1
00241 #endif
00242 
00243 
00244 /* Copy the second part of user declarations.  */
00245 
00246 /* Line 343 of yacc.c  */
00247 #line 65 "ael.y"
00248 
00249    /* declaring these AFTER the union makes things a lot simpler! */
00250 void yyerror(YYLTYPE *locp, struct parse_io *parseio, char const *s);
00251 int ael_yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , void * yyscanner);
00252 
00253 /* create a new object with start-end marker */
00254 pval *npval(pvaltype type, int first_line, int last_line,
00255    int first_column, int last_column);
00256 
00257 /* create a new object with start-end marker, simplified interface.
00258  * Must be declared here because YYLTYPE is not known before
00259  */
00260 static pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last);
00261 
00262 /* another frontend for npval, this time for a string */
00263 static pval *nword(char *string, YYLTYPE *pos);
00264 
00265 /* update end position of an object, return the object */
00266 static pval *update_last(pval *, YYLTYPE *);
00267 
00268 
00269 /* Line 343 of yacc.c  */
00270 #line 271 "ael.tab.c"
00271 
00272 #ifdef short
00273 # undef short
00274 #endif
00275 
00276 #ifdef YYTYPE_UINT8
00277 typedef YYTYPE_UINT8 yytype_uint8;
00278 #else
00279 typedef unsigned char yytype_uint8;
00280 #endif
00281 
00282 #ifdef YYTYPE_INT8
00283 typedef YYTYPE_INT8 yytype_int8;
00284 #elif (defined __STDC__ || defined __C99__FUNC__ \
00285      || defined __cplusplus || defined _MSC_VER)
00286 typedef signed char yytype_int8;
00287 #else
00288 typedef short int yytype_int8;
00289 #endif
00290 
00291 #ifdef YYTYPE_UINT16
00292 typedef YYTYPE_UINT16 yytype_uint16;
00293 #else
00294 typedef unsigned short int yytype_uint16;
00295 #endif
00296 
00297 #ifdef YYTYPE_INT16
00298 typedef YYTYPE_INT16 yytype_int16;
00299 #else
00300 typedef short int yytype_int16;
00301 #endif
00302 
00303 #ifndef YYSIZE_T
00304 # ifdef __SIZE_TYPE__
00305 #  define YYSIZE_T __SIZE_TYPE__
00306 # elif defined size_t
00307 #  define YYSIZE_T size_t
00308 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00309      || defined __cplusplus || defined _MSC_VER)
00310 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00311 #  define YYSIZE_T size_t
00312 # else
00313 #  define YYSIZE_T unsigned int
00314 # endif
00315 #endif
00316 
00317 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00318 
00319 #ifndef YY_
00320 # if defined YYENABLE_NLS && YYENABLE_NLS
00321 #  if ENABLE_NLS
00322 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00323 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00324 #  endif
00325 # endif
00326 # ifndef YY_
00327 #  define YY_(msgid) msgid
00328 # endif
00329 #endif
00330 
00331 /* Suppress unused-variable warnings by "using" E.  */
00332 #if ! defined lint || defined __GNUC__
00333 # define YYUSE(e) ((void) (e))
00334 #else
00335 # define YYUSE(e) /* empty */
00336 #endif
00337 
00338 /* Identity function, used to suppress warnings about constant conditions.  */
00339 #ifndef lint
00340 # define YYID(n) (n)
00341 #else
00342 #if (defined __STDC__ || defined __C99__FUNC__ \
00343      || defined __cplusplus || defined _MSC_VER)
00344 static int
00345 YYID (int yyi)
00346 #else
00347 static int
00348 YYID (yyi)
00349     int yyi;
00350 #endif
00351 {
00352   return yyi;
00353 }
00354 #endif
00355 
00356 #if ! defined yyoverflow || YYERROR_VERBOSE
00357 
00358 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00359 
00360 # ifdef YYSTACK_USE_ALLOCA
00361 #  if YYSTACK_USE_ALLOCA
00362 #   ifdef __GNUC__
00363 #    define YYSTACK_ALLOC __builtin_alloca
00364 #   elif defined __BUILTIN_VA_ARG_INCR
00365 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00366 #   elif defined _AIX
00367 #    define YYSTACK_ALLOC __alloca
00368 #   elif defined _MSC_VER
00369 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00370 #    define alloca _alloca
00371 #   else
00372 #    define YYSTACK_ALLOC alloca
00373 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
00374      || defined __cplusplus || defined _MSC_VER)
00375 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00376 #     ifndef EXIT_SUCCESS
00377 #      define EXIT_SUCCESS 0
00378 #     endif
00379 #    endif
00380 #   endif
00381 #  endif
00382 # endif
00383 
00384 # ifdef YYSTACK_ALLOC
00385    /* Pacify GCC's `empty if-body' warning.  */
00386 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00387 #  ifndef YYSTACK_ALLOC_MAXIMUM
00388     /* The OS might guarantee only one guard page at the bottom of the stack,
00389        and a page size can be as small as 4096 bytes.  So we cannot safely
00390        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00391        to allow for a few compiler-allocated temporary stack slots.  */
00392 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
00393 #  endif
00394 # else
00395 #  define YYSTACK_ALLOC YYMALLOC
00396 #  define YYSTACK_FREE YYFREE
00397 #  ifndef YYSTACK_ALLOC_MAXIMUM
00398 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00399 #  endif
00400 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
00401        && ! ((defined YYMALLOC || defined malloc) \
00402         && (defined YYFREE || defined free)))
00403 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00404 #   ifndef EXIT_SUCCESS
00405 #    define EXIT_SUCCESS 0
00406 #   endif
00407 #  endif
00408 #  ifndef YYMALLOC
00409 #   define YYMALLOC malloc
00410 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
00411      || defined __cplusplus || defined _MSC_VER)
00412 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00413 #   endif
00414 #  endif
00415 #  ifndef YYFREE
00416 #   define YYFREE free
00417 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
00418      || defined __cplusplus || defined _MSC_VER)
00419 void free (void *); /* INFRINGES ON USER NAME SPACE */
00420 #   endif
00421 #  endif
00422 # endif
00423 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
00424 
00425 
00426 #if (! defined yyoverflow \
00427      && (! defined __cplusplus \
00428     || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
00429         && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00430 
00431 /* A type that is properly aligned for any stack member.  */
00432 union yyalloc
00433 {
00434   yytype_int16 yyss_alloc;
00435   YYSTYPE yyvs_alloc;
00436   YYLTYPE yyls_alloc;
00437 };
00438 
00439 /* The size of the maximum gap between one aligned stack and the next.  */
00440 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00441 
00442 /* The size of an array large to enough to hold all stacks, each with
00443    N elements.  */
00444 # define YYSTACK_BYTES(N) \
00445      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
00446       + 2 * YYSTACK_GAP_MAXIMUM)
00447 
00448 # define YYCOPY_NEEDED 1
00449 
00450 /* Relocate STACK from its old location to the new one.  The
00451    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00452    elements in the stack, and YYPTR gives the new location of the
00453    stack.  Advance YYPTR to a properly aligned location for the next
00454    stack.  */
00455 # define YYSTACK_RELOCATE(Stack_alloc, Stack)            \
00456     do                           \
00457       {                          \
00458    YYSIZE_T yynewbytes;                \
00459    YYCOPY (&yyptr->Stack_alloc, Stack, yysize);       \
00460    Stack = &yyptr->Stack_alloc;              \
00461    yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00462    yyptr += yynewbytes / sizeof (*yyptr);          \
00463       }                          \
00464     while (YYID (0))
00465 
00466 #endif
00467 
00468 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
00469 /* Copy COUNT objects from FROM to TO.  The source and destination do
00470    not overlap.  */
00471 # ifndef YYCOPY
00472 #  if defined __GNUC__ && 1 < __GNUC__
00473 #   define YYCOPY(To, From, Count) \
00474       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00475 #  else
00476 #   define YYCOPY(To, From, Count)     \
00477       do             \
00478    {              \
00479      YYSIZE_T yyi;            \
00480      for (yyi = 0; yyi < (Count); yyi++)  \
00481        (To)[yyi] = (From)[yyi];     \
00482    }              \
00483       while (YYID (0))
00484 #  endif
00485 # endif
00486 #endif /* !YYCOPY_NEEDED */
00487 
00488 /* YYFINAL -- State number of the termination state.  */
00489 #define YYFINAL  17
00490 /* YYLAST -- Last index in YYTABLE.  */
00491 #define YYLAST   371
00492 
00493 /* YYNTOKENS -- Number of terminals.  */
00494 #define YYNTOKENS  44
00495 /* YYNNTS -- Number of nonterminals.  */
00496 #define YYNNTS  56
00497 /* YYNRULES -- Number of rules.  */
00498 #define YYNRULES  143
00499 /* YYNRULES -- Number of states.  */
00500 #define YYNSTATES  283
00501 
00502 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00503 #define YYUNDEFTOK  2
00504 #define YYMAXUTOK   298
00505 
00506 #define YYTRANSLATE(YYX)                  \
00507   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00508 
00509 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00510 static const yytype_uint8 yytranslate[] =
00511 {
00512        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00513        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00514        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00515        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00516        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00517        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00518        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00519        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00520        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00521        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00522        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00523        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00524        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00525        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00526        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00527        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00528        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00529        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00530        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00531        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00532        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00533        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00534        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00535        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00536        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00537        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00538        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00539       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00540       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
00541       35,    36,    37,    38,    39,    40,    41,    42,    43
00542 };
00543 
00544 #if YYDEBUG
00545 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00546    YYRHS.  */
00547 static const yytype_uint16 yyprhs[] =
00548 {
00549        0,     0,     3,     5,     7,    10,    13,    15,    17,    19,
00550       21,    23,    25,    32,    34,    35,    37,    40,    43,    52,
00551       57,    58,    61,    64,    65,    71,    72,    79,    80,    82,
00552       86,    89,    90,    93,    96,    98,   100,   102,   104,   106,
00553      108,   110,   113,   115,   120,   124,   130,   135,   143,   152,
00554      153,   156,   159,   165,   167,   175,   176,   181,   184,   187,
00555      192,   194,   197,   199,   202,   206,   210,   214,   216,   219,
00556      223,   225,   228,   232,   238,   242,   244,   246,   250,   254,
00557      257,   258,   259,   260,   273,   277,   279,   283,   286,   289,
00558      290,   296,   299,   302,   305,   309,   311,   314,   315,   317,
00559      321,   325,   331,   337,   343,   349,   350,   353,   356,   361,
00560      362,   368,   372,   373,   377,   381,   384,   386,   387,   389,
00561      390,   394,   395,   398,   403,   407,   412,   413,   416,   418,
00562      420,   426,   431,   436,   437,   441,   447,   450,   452,   456,
00563      459,   463,   466,   471
00564 };
00565 
00566 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
00567 static const yytype_int8 yyrhs[] =
00568 {
00569       45,     0,    -1,    46,    -1,    47,    -1,    46,    47,    -1,
00570       46,     1,    -1,    49,    -1,    51,    -1,    52,    -1,     8,
00571       -1,    43,    -1,    37,    -1,    50,     3,    48,     4,    59,
00572        5,    -1,    23,    -1,    -1,    24,    -1,    24,    23,    -1,
00573       23,    24,    -1,    15,    43,     6,    58,     7,     4,    92,
00574        5,    -1,    16,     4,    53,     5,    -1,    -1,    53,    54,
00575       -1,     1,    53,    -1,    -1,    43,     9,    55,    43,     8,
00576       -1,    -1,    42,    43,     9,    57,    43,     8,    -1,    -1,
00577       43,    -1,    58,    10,    43,    -1,    58,     1,    -1,    -1,
00578       59,    60,    -1,     1,    59,    -1,    62,    -1,    99,    -1,
00579       94,    -1,    95,    -1,    61,    -1,    54,    -1,    56,    -1,
00580       43,     1,    -1,     8,    -1,    17,    25,    43,     8,    -1,
00581       43,    25,    74,    -1,    43,    14,    43,    25,    74,    -1,
00582       31,    43,    25,    74,    -1,    32,     6,    70,     7,    43,
00583       25,    74,    -1,    31,    32,     6,    70,     7,    43,    25,
00584       74,    -1,    -1,    63,    74,    -1,     1,    63,    -1,    71,
00585       11,    71,    11,    71,    -1,    43,    -1,    64,    13,    71,
00586       13,    71,    13,    71,    -1,    -1,     6,    67,    69,     7,
00587       -1,    19,    66,    -1,    22,    66,    -1,    20,     6,    65,
00588        7,    -1,    43,    -1,    43,    43,    -1,    43,    -1,    70,
00589       43,    -1,    70,    11,    43,    -1,    70,    12,    43,    -1,
00590       70,    14,    43,    -1,    43,    -1,    43,    43,    -1,    43,
00591       43,    43,    -1,    43,    -1,    43,    43,    -1,    72,    11,
00592       43,    -1,    18,    66,     4,    90,     5,    -1,     4,    63,
00593        5,    -1,    54,    -1,    56,    -1,    26,    80,     8,    -1,
00594       27,    82,     8,    -1,    43,    11,    -1,    -1,    -1,    -1,
00595       33,     6,    75,    43,     8,    76,    43,     8,    77,    43,
00596        7,    74,    -1,    34,    66,    74,    -1,    73,    -1,    12,
00597       83,     8,    -1,    87,     8,    -1,    43,     8,    -1,    -1,
00598       87,     9,    78,    43,     8,    -1,    29,     8,    -1,    28,
00599        8,    -1,    30,     8,    -1,    68,    74,    79,    -1,     8,
00600       -1,    21,    74,    -1,    -1,    72,    -1,    72,    13,    72,
00601       -1,    72,    10,    72,    -1,    72,    13,    72,    13,    72,
00602       -1,    72,    10,    72,    10,    72,    -1,    37,    13,    72,
00603       13,    72,    -1,    37,    10,    72,    10,    72,    -1,    -1,
00604       10,    43,    -1,    72,    81,    -1,    72,    81,    14,    48,
00605       -1,    -1,    43,     6,    84,    89,     7,    -1,    43,     6,
00606        7,    -1,    -1,    43,     6,    86,    -1,    85,    89,     7,
00607       -1,    85,     7,    -1,    43,    -1,    -1,    69,    -1,    -1,
00608       89,    10,    88,    -1,    -1,    90,    91,    -1,    35,    43,
00609       11,    63,    -1,    37,    11,    63,    -1,    36,    43,    11,
00610       63,    -1,    -1,    92,    93,    -1,    74,    -1,    99,    -1,
00611       38,    43,     4,    63,     5,    -1,    39,     4,    96,     5,
00612       -1,    40,     4,    96,     5,    -1,    -1,    96,    43,     8,
00613       -1,    96,    43,    14,    43,     8,    -1,     1,    96,    -1,
00614       48,    -1,    48,    13,    65,    -1,    97,     8,    -1,    98,
00615       97,     8,    -1,    98,     1,    -1,    41,     4,    98,     5,
00616       -1,    41,     4,     5,    -1
00617 };
00618 
00619 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00620 static const yytype_uint16 yyrline[] =
00621 {
00622        0,   191,   191,   194,   195,   196,   199,   200,   201,   202,
00623      205,   206,   209,   218,   219,   220,   221,   222,   225,   231,
00624      237,   238,   239,   242,   242,   248,   248,   255,   256,   257,
00625      258,   261,   262,   263,   266,   267,   268,   269,   270,   271,
00626      272,   273,   274,   277,   282,   286,   294,   299,   304,   313,
00627      314,   315,   321,   331,   335,   343,   343,   347,   350,   353,
00628      364,   365,   377,   378,   387,   396,   405,   416,   417,   427,
00629      440,   441,   450,   461,   470,   473,   474,   475,   478,   481,
00630      484,   485,   486,   484,   492,   496,   497,   498,   499,   502,
00631      502,   535,   536,   537,   538,   542,   545,   546,   549,   550,
00632      553,   556,   560,   564,   568,   574,   575,   579,   582,   588,
00633      588,   593,   601,   601,   612,   619,   622,   623,   626,   627,
00634      630,   633,   634,   637,   641,   645,   651,   652,   655,   656,
00635      657,   663,   668,   673,   674,   675,   686,   689,   690,   697,
00636      698,   699,   702,   705
00637 };
00638 #endif
00639 
00640 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00641 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00642    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
00643 static const char *const yytname[] =
00644 {
00645   "$end", "error", "$undefined", "KW_CONTEXT", "LC", "RC", "LP", "RP",
00646   "SEMI", "EQ", "COMMA", "COLON", "AMPER", "BAR", "AT", "KW_MACRO",
00647   "KW_GLOBALS", "KW_IGNOREPAT", "KW_SWITCH", "KW_IF", "KW_IFTIME",
00648   "KW_ELSE", "KW_RANDOM", "KW_ABSTRACT", "KW_EXTEND", "EXTENMARK",
00649   "KW_GOTO", "KW_JUMP", "KW_RETURN", "KW_BREAK", "KW_CONTINUE",
00650   "KW_REGEXTEN", "KW_HINT", "KW_FOR", "KW_WHILE", "KW_CASE", "KW_PATTERN",
00651   "KW_DEFAULT", "KW_CATCH", "KW_SWITCHES", "KW_ESWITCHES", "KW_INCLUDES",
00652   "KW_LOCAL", "word", "$accept", "file", "objects", "object",
00653   "context_name", "context", "opt_abstract", "macro", "globals",
00654   "global_statements", "assignment", "$@1", "local_assignment", "$@2",
00655   "arglist", "elements", "element", "ignorepat", "extension", "statements",
00656   "timerange", "timespec", "test_expr", "$@3", "if_like_head", "word_list",
00657   "hint_word", "word3_list", "goto_word", "switch_statement", "statement",
00658   "$@4", "$@5", "$@6", "$@7", "opt_else", "target", "opt_pri",
00659   "jumptarget", "macro_call", "$@8", "application_call_head", "$@9",
00660   "application_call", "opt_word", "eval_arglist", "case_statements",
00661   "case_statement", "macro_statements", "macro_statement", "switches",
00662   "eswitches", "switchlist", "included_entry", "includeslist", "includes", 0
00663 };
00664 #endif
00665 
00666 # ifdef YYPRINT
00667 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00668    token YYLEX-NUM.  */
00669 static const yytype_uint16 yytoknum[] =
00670 {
00671        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00672      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
00673      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
00674      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
00675      295,   296,   297,   298
00676 };
00677 # endif
00678 
00679 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00680 static const yytype_uint8 yyr1[] =
00681 {
00682        0,    44,    45,    46,    46,    46,    47,    47,    47,    47,
00683       48,    48,    49,    50,    50,    50,    50,    50,    51,    52,
00684       53,    53,    53,    55,    54,    57,    56,    58,    58,    58,
00685       58,    59,    59,    59,    60,    60,    60,    60,    60,    60,
00686       60,    60,    60,    61,    62,    62,    62,    62,    62,    63,
00687       63,    63,    64,    64,    65,    67,    66,    68,    68,    68,
00688       69,    69,    70,    70,    70,    70,    70,    71,    71,    71,
00689       72,    72,    72,    73,    74,    74,    74,    74,    74,    74,
00690       75,    76,    77,    74,    74,    74,    74,    74,    74,    78,
00691       74,    74,    74,    74,    74,    74,    79,    79,    80,    80,
00692       80,    80,    80,    80,    80,    81,    81,    82,    82,    84,
00693       83,    83,    86,    85,    87,    87,    88,    88,    89,    89,
00694       89,    90,    90,    91,    91,    91,    92,    92,    93,    93,
00695       93,    94,    95,    96,    96,    96,    96,    97,    97,    98,
00696       98,    98,    99,    99
00697 };
00698 
00699 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00700 static const yytype_uint8 yyr2[] =
00701 {
00702        0,     2,     1,     1,     2,     2,     1,     1,     1,     1,
00703        1,     1,     6,     1,     0,     1,     2,     2,     8,     4,
00704        0,     2,     2,     0,     5,     0,     6,     0,     1,     3,
00705        2,     0,     2,     2,     1,     1,     1,     1,     1,     1,
00706        1,     2,     1,     4,     3,     5,     4,     7,     8,     0,
00707        2,     2,     5,     1,     7,     0,     4,     2,     2,     4,
00708        1,     2,     1,     2,     3,     3,     3,     1,     2,     3,
00709        1,     2,     3,     5,     3,     1,     1,     3,     3,     2,
00710        0,     0,     0,    12,     3,     1,     3,     2,     2,     0,
00711        5,     2,     2,     2,     3,     1,     2,     0,     1,     3,
00712        3,     5,     5,     5,     5,     0,     2,     2,     4,     0,
00713        5,     3,     0,     3,     3,     2,     1,     0,     1,     0,
00714        3,     0,     2,     4,     3,     4,     0,     2,     1,     1,
00715        5,     4,     4,     0,     3,     5,     2,     1,     3,     2,
00716        3,     2,     4,     3
00717 };
00718 
00719 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
00720    Performed when YYTABLE doesn't specify something else to do.  Zero
00721    means the default is an error.  */
00722 static const yytype_uint8 yydefact[] =
00723 {
00724       14,     9,     0,     0,    13,    15,     0,     0,     3,     6,
00725        0,     7,     8,     0,     0,    17,    16,     1,     5,     4,
00726        0,    27,     0,     0,    11,    10,     0,    28,     0,    22,
00727       19,     0,    21,     0,    30,     0,     0,    23,     0,     0,
00728      126,    29,     0,    33,    12,    42,     0,     0,     0,     0,
00729        0,     0,     0,     0,    39,    40,    32,    38,    34,    36,
00730       37,    35,     0,     0,     0,     0,     0,     0,     0,     0,
00731        0,     0,    41,     0,     0,     0,    18,    95,     0,     0,
00732        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00733        0,     0,    75,    76,     0,    85,   128,   119,     0,   127,
00734      129,    24,     0,     0,     0,    62,     0,     0,     0,     0,
00735      143,   137,     0,     0,    25,     0,    44,     0,     0,     0,
00736        0,    55,     0,    57,     0,    58,     0,    70,    98,     0,
00737      105,     0,    92,    91,    93,    80,     0,     0,   112,    88,
00738       79,    97,   115,    60,   118,     0,    87,    89,    43,     0,
00739       46,     0,     0,     0,     0,    63,   136,   131,     0,   132,
00740        0,   139,   141,   142,     0,     0,     0,    51,    74,    50,
00741      109,    86,     0,   121,    53,     0,     0,     0,     0,     0,
00742       71,     0,     0,     0,    77,     0,   107,    78,     0,    84,
00743        0,   113,     0,    94,    61,   114,   117,     0,     0,     0,
00744       64,    65,    66,   134,     0,   138,   140,     0,    45,   111,
00745      119,     0,     0,    68,     0,    59,     0,     0,     0,   100,
00746       72,    99,   106,     0,     0,     0,    96,   116,   120,     0,
00747        0,     0,     0,    26,     0,    56,    73,     0,     0,     0,
00748      122,    69,    67,     0,     0,     0,     0,     0,     0,   108,
00749       81,   130,    90,     0,    47,   135,   110,     0,     0,     0,
00750        0,     0,   104,   103,   102,   101,     0,    48,     0,     0,
00751      124,     0,    52,     0,   123,   125,     0,    82,    54,     0,
00752        0,     0,    83
00753 };
00754 
00755 /* YYDEFGOTO[NTERM-NUM].  */
00756 static const yytype_int16 yydefgoto[] =
00757 {
00758       -1,     6,     7,     8,   111,     9,    10,    11,    12,    23,
00759       92,    42,    93,   165,    28,    39,    56,    57,    58,   118,
00760      175,   176,   122,   172,    94,   144,   106,   177,   128,    95,
00761      169,   188,   266,   279,   197,   193,   129,   186,   131,   120,
00762      210,    97,   191,    98,   228,   145,   212,   240,    62,    99,
00763       59,    60,   108,   112,   113,    61
00764 };
00765 
00766 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00767    STATE-NUM.  */
00768 #define YYPACT_NINF -211
00769 static const yytype_int16 yypact[] =
00770 {
00771      166,  -211,   -32,    15,    12,    36,    40,   316,  -211,  -211,
00772       75,  -211,  -211,    82,    17,  -211,  -211,  -211,  -211,  -211,
00773      -28,    57,    17,     0,  -211,  -211,   127,  -211,     6,   109,
00774     -211,   152,  -211,   136,  -211,   169,   143,  -211,   136,   117,
00775     -211,  -211,   144,   272,  -211,  -211,   170,   -15,   191,   197,
00776      199,   201,   168,   137,  -211,  -211,  -211,  -211,  -211,  -211,
00777     -211,  -211,   180,   204,   172,   219,   202,   185,    25,    25,
00778       28,   217,  -211,   186,   266,    90,  -211,  -211,   190,   229,
00779      229,   230,   229,    21,   194,   240,   241,   242,   246,   229,
00780      210,   312,  -211,  -211,   266,  -211,  -211,     1,    61,  -211,
00781     -211,  -211,   248,   185,   266,  -211,    68,    25,    24,    29,
00782     -211,   247,   254,    20,  -211,   238,  -211,    19,   212,   258,
00783      263,  -211,   271,  -211,   233,  -211,   126,   234,   183,   275,
00784       95,   279,  -211,  -211,  -211,  -211,   266,   286,  -211,  -211,
00785     -211,   270,  -211,   236,  -211,   140,  -211,  -211,  -211,    78,
00786     -211,   255,   259,   262,   264,  -211,   267,  -211,    69,  -211,
00787      233,  -211,  -211,  -211,   289,   282,   266,   266,  -211,  -211,
00788      294,  -211,   283,  -211,    70,   293,   315,   317,   194,   194,
00789     -211,   194,   284,   194,  -211,   287,   319,  -211,   291,  -211,
00790       90,  -211,   266,  -211,  -211,  -211,   292,   295,   298,   304,
00791     -211,  -211,  -211,  -211,   299,  -211,  -211,   328,  -211,  -211,
00792      283,   330,   135,   300,   301,  -211,   301,   104,    73,   132,
00793     -211,   116,  -211,   -28,   337,   239,  -211,  -211,  -211,   338,
00794      322,   266,   340,  -211,   173,  -211,  -211,   306,   307,   341,
00795     -211,  -211,   308,   342,   343,   194,   194,   194,   194,  -211,
00796     -211,  -211,  -211,   266,  -211,  -211,  -211,   345,   346,    19,
00797      301,   301,   347,   347,   347,   347,   310,  -211,    19,    19,
00798      266,   348,  -211,   351,   266,   266,   301,  -211,  -211,   320,
00799      353,   266,  -211
00800 };
00801 
00802 /* YYPGOTO[NTERM-NUM].  */
00803 static const yytype_int16 yypgoto[] =
00804 {
00805     -211,  -211,  -211,   355,   -19,  -211,  -211,  -211,  -211,   344,
00806       64,  -211,   -29,  -211,  -211,   326,  -211,  -211,  -211,  -114,
00807     -211,   205,    46,  -211,  -211,   195,   265,  -210,   -82,  -211,
00808      -62,  -211,  -211,  -211,  -211,  -211,  -211,  -211,  -211,  -211,
00809     -211,  -211,  -211,  -211,  -211,   159,  -211,  -211,  -211,  -211,
00810     -211,  -211,   -34,   257,  -211,   309
00811 };
00812 
00813 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00814    positive, shift that token.  If negative, reduce the rule which
00815    number is the opposite.  If YYTABLE_NINF, syntax error.  */
00816 #define YYTABLE_NINF -134
00817 static const yytype_int16 yytable[] =
00818 {
00819       96,    26,   130,   167,   243,    30,   244,    34,   142,    24,
00820       55,    13,   116,    35,    55,    25,    36,    65,    22,    14,
00821      117,   162,   -20,   -49,   -49,   163,   107,   -49,    66,   157,
00822     -133,   -49,   141,   110,   159,   109,    15,   -49,   -49,   -49,
00823       17,   -49,   150,    31,   143,   -49,   -49,   -49,   -49,   -49,
00824      271,   272,   -49,   -49,   -49,   -49,   -49,    24,   126,    16,
00825      -20,   -49,   -49,    25,   127,    24,   278,   158,  -133,   146,
00826      147,    25,   158,   156,   189,   151,   225,   203,    20,   152,
00827      153,   -67,   154,   204,   182,   198,   246,    32,    21,   152,
00828      153,   117,   154,    32,   -49,   -49,   217,   218,   -49,   219,
00829       27,   221,   -49,    54,   208,   185,   182,    54,   -49,   -49,
00830      -49,   155,   -49,   213,   245,   182,   -49,   -49,   -49,   -49,
00831      -49,   155,    44,   -49,   -49,    45,   123,   182,   125,   248,
00832      226,    33,   -49,   -49,    46,   136,   178,    38,    72,   179,
00833      236,   -31,   247,   182,   -31,   270,    37,   195,    47,    48,
00834      196,    73,    31,   -31,   274,   275,    49,    50,    51,    52,
00835       53,    37,    74,   262,   263,   264,   265,   -31,   -31,   254,
00836      237,   238,   239,    40,     1,   -31,   -31,   -31,   -31,   -31,
00837      256,     2,     3,   196,    75,    76,    41,    63,    77,     4,
00838        5,   267,    78,   181,   182,    64,   183,    67,    79,    80,
00839       81,    68,    82,    69,   249,    70,    83,    84,    85,    86,
00840       87,    71,   101,    88,    89,   102,    75,   168,    90,   282,
00841       77,    51,    52,    91,    78,   103,   114,   104,   105,   115,
00842       79,    80,    81,   119,    82,   121,   124,   127,    83,    84,
00843       85,    86,    87,    75,   251,    88,    89,    77,   132,   133,
00844      134,    78,   135,   137,    52,    91,   148,    79,    80,    81,
00845      160,    82,   161,   166,   170,    83,    84,    85,    86,    87,
00846       75,   171,    88,    89,    77,   173,   174,   180,    78,   194,
00847       45,    52,    91,   184,    79,    80,    81,   187,    82,    46,
00848      190,   192,    83,    84,    85,    86,    87,   206,   199,    88,
00849       89,   209,   200,    47,    48,   201,   214,   202,    52,    91,
00850      158,    49,    50,    51,    52,    53,    -2,    18,   138,   -14,
00851      139,    37,   215,   140,     1,   207,   143,   220,   216,   231,
00852      222,     2,     3,   223,   224,   227,   233,   235,   229,     4,
00853        5,   230,   232,   241,   242,   250,   252,   253,   255,   257,
00854      258,   213,   259,   273,   261,   260,   268,   269,   182,   277,
00855      281,   276,    19,   280,    43,   205,    29,   211,   149,   234,
00856      164,   100
00857 };
00858 
00859 #define yypact_value_is_default(yystate) \
00860   ((yystate) == (-211))
00861 
00862 #define yytable_value_is_error(yytable_value) \
00863   YYID (0)
00864 
00865 static const yytype_uint16 yycheck[] =
00866 {
00867       62,    20,    84,   117,   214,     5,   216,     1,     7,    37,
00868       39,    43,    74,     7,    43,    43,    10,    32,     1,     4,
00869        1,     1,     5,     4,     5,     5,     1,     8,    43,     5,
00870        5,    12,    94,     5,     5,    69,    24,    18,    19,    20,
00871        0,    22,   104,    43,    43,    26,    27,    28,    29,    30,
00872      260,   261,    33,    34,    35,    36,    37,    37,    37,    23,
00873       43,    42,    43,    43,    43,    37,   276,    43,    43,     8,
00874        9,    43,    43,   107,   136,     7,   190,     8,     3,    11,
00875       12,    11,    14,    14,    11,     7,    13,    23,     6,    11,
00876       12,     1,    14,    29,     4,     5,   178,   179,     8,   181,
00877       43,   183,    12,    39,   166,    10,    11,    43,    18,    19,
00878       20,    43,    22,    43,    10,    11,    26,    27,    28,    29,
00879       30,    43,     5,    33,    34,     8,    80,    11,    82,    13,
00880      192,     4,    42,    43,    17,    89,    10,     1,     1,    13,
00881        5,     5,    10,    11,     8,   259,     9,     7,    31,    32,
00882       10,    14,    43,    17,   268,   269,    39,    40,    41,    42,
00883       43,     9,    25,   245,   246,   247,   248,    31,    32,   231,
00884       35,    36,    37,     4,     8,    39,    40,    41,    42,    43,
00885        7,    15,    16,    10,     4,     5,    43,    43,     8,    23,
00886       24,   253,    12,    10,    11,    25,    13,     6,    18,    19,
00887       20,     4,    22,     4,   223,     4,    26,    27,    28,    29,
00888       30,    43,     8,    33,    34,    43,     4,     5,    38,   281,
00889        8,    41,    42,    43,    12,     6,     9,    25,    43,    43,
00890       18,    19,    20,    43,    22,     6,     6,    43,    26,    27,
00891       28,    29,    30,     4,     5,    33,    34,     8,     8,     8,
00892        8,    12,     6,    43,    42,    43,     8,    18,    19,    20,
00893       13,    22,     8,    25,     6,    26,    27,    28,    29,    30,
00894        4,     8,    33,    34,     8,     4,    43,    43,    12,    43,
00895        8,    42,    43,     8,    18,    19,    20,     8,    22,    17,
00896        4,    21,    26,    27,    28,    29,    30,     8,    43,    33,
00897       34,     7,    43,    31,    32,    43,    13,    43,    42,    43,
00898       43,    39,    40,    41,    42,    43,     0,     1,     6,     3,
00899        8,     9,     7,    11,     8,    43,    43,    43,    11,    25,
00900       43,    15,    16,    14,    43,    43,     8,     7,    43,    23,
00901       24,    43,    43,    43,    43,     8,     8,    25,     8,    43,
00902       43,    43,    11,    43,    11,    13,    11,    11,    11,     8,
00903        7,    13,     7,    43,    38,   160,    22,   172,   103,   210,
00904      113,    62
00905 };
00906 
00907 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00908    symbol of state STATE-NUM.  */
00909 static const yytype_uint8 yystos[] =
00910 {
00911        0,     8,    15,    16,    23,    24,    45,    46,    47,    49,
00912       50,    51,    52,    43,     4,    24,    23,     0,     1,    47,
00913        3,     6,     1,    53,    37,    43,    48,    43,    58,    53,
00914        5,    43,    54,     4,     1,     7,    10,     9,     1,    59,
00915        4,    43,    55,    59,     5,     8,    17,    31,    32,    39,
00916       40,    41,    42,    43,    54,    56,    60,    61,    62,    94,
00917       95,    99,    92,    43,    25,    32,    43,     6,     4,     4,
00918        4,    43,     1,    14,    25,     4,     5,     8,    12,    18,
00919       19,    20,    22,    26,    27,    28,    29,    30,    33,    34,
00920       38,    43,    54,    56,    68,    73,    74,    85,    87,    93,
00921       99,     8,    43,     6,    25,    43,    70,     1,    96,    96,
00922        5,    48,    97,    98,     9,    43,    74,     1,    63,    43,
00923       83,     6,    66,    66,     6,    66,    37,    43,    72,    80,
00924       72,    82,     8,     8,     8,     6,    66,    43,     6,     8,
00925       11,    74,     7,    43,    69,    89,     8,     9,     8,    70,
00926       74,     7,    11,    12,    14,    43,    96,     5,    43,     5,
00927       13,     8,     1,     5,    97,    57,    25,    63,     5,    74,
00928        6,     8,    67,     4,    43,    64,    65,    71,    10,    13,
00929       43,    10,    11,    13,     8,    10,    81,     8,    75,    74,
00930        4,    86,    21,    79,    43,     7,    10,    78,     7,    43,
00931       43,    43,    43,     8,    14,    65,     8,    43,    74,     7,
00932       84,    69,    90,    43,    13,     7,    11,    72,    72,    72,
00933       43,    72,    43,    14,    43,    63,    74,    43,    88,    43,
00934       43,    25,    43,     8,    89,     7,     5,    35,    36,    37,
00935       91,    43,    43,    71,    71,    10,    13,    10,    13,    48,
00936        8,     5,     8,    25,    74,     8,     7,    43,    43,    11,
00937       13,    11,    72,    72,    72,    72,    76,    74,    11,    11,
00938       63,    71,    71,    43,    63,    63,    13,     8,    71,    77,
00939       43,     7,    74
00940 };
00941 
00942 #define yyerrok      (yyerrstatus = 0)
00943 #define yyclearin (yychar = YYEMPTY)
00944 #define YYEMPTY      (-2)
00945 #define YYEOF     0
00946 
00947 #define YYACCEPT  goto yyacceptlab
00948 #define YYABORT      goto yyabortlab
00949 #define YYERROR      goto yyerrorlab
00950 
00951 
00952 /* Like YYERROR except do call yyerror.  This remains here temporarily
00953    to ease the transition to the new meaning of YYERROR, for GCC.
00954    Once GCC version 2 has supplanted version 1, this can go.  However,
00955    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
00956    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
00957    discussed.  */
00958 
00959 #define YYFAIL    goto yyerrlab
00960 #if defined YYFAIL
00961   /* This is here to suppress warnings from the GCC cpp's
00962      -Wunused-macros.  Normally we don't worry about that warning, but
00963      some users do, and we want to make it easy for users to remove
00964      YYFAIL uses, which will produce warnings from Bison 2.5.  */
00965 #endif
00966 
00967 #define YYRECOVERING()  (!!yyerrstatus)
00968 
00969 #define YYBACKUP(Token, Value)               \
00970 do                      \
00971   if (yychar == YYEMPTY && yylen == 1)          \
00972     {                      \
00973       yychar = (Token);                \
00974       yylval = (Value);                \
00975       YYPOPSTACK (1);                  \
00976       goto yybackup;                \
00977     }                      \
00978   else                        \
00979     {                      \
00980       yyerror (&yylloc, parseio, YY_("syntax error: cannot back up")); \
00981       YYERROR;                   \
00982     }                      \
00983 while (YYID (0))
00984 
00985 
00986 #define YYTERROR  1
00987 #define YYERRCODE 256
00988 
00989 
00990 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
00991    If N is 0, then set CURRENT to the empty location which ends
00992    the previous symbol: RHS[0] (always defined).  */
00993 
00994 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00995 #ifndef YYLLOC_DEFAULT
00996 # define YYLLOC_DEFAULT(Current, Rhs, N)           \
00997     do                           \
00998       if (YYID (N))                                                    \
00999    {                       \
01000      (Current).first_line   = YYRHSLOC (Rhs, 1).first_line; \
01001      (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
01002      (Current).last_line    = YYRHSLOC (Rhs, N).last_line;     \
01003      (Current).last_column  = YYRHSLOC (Rhs, N).last_column;   \
01004    }                       \
01005       else                       \
01006    {                       \
01007      (Current).first_line   = (Current).last_line   =    \
01008        YYRHSLOC (Rhs, 0).last_line;          \
01009      (Current).first_column = (Current).last_column =    \
01010        YYRHSLOC (Rhs, 0).last_column;           \
01011    }                       \
01012     while (YYID (0))
01013 #endif
01014 
01015 
01016 /* YY_LOCATION_PRINT -- Print the location on the stream.
01017    This macro was not mandated originally: define only if we know
01018    we won't break user code: when these are the locations we know.  */
01019 
01020 #ifndef YY_LOCATION_PRINT
01021 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
01022 #  define YY_LOCATION_PRINT(File, Loc)       \
01023      fprintf (File, "%d.%d-%d.%d",        \
01024          (Loc).first_line, (Loc).first_column,  \
01025          (Loc).last_line,  (Loc).last_column)
01026 # else
01027 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
01028 # endif
01029 #endif
01030 
01031 
01032 /* YYLEX -- calling `yylex' with the right arguments.  */
01033 
01034 #ifdef YYLEX_PARAM
01035 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
01036 #else
01037 # define YYLEX yylex (&yylval, &yylloc)
01038 #endif
01039 
01040 /* Enable debugging if requested.  */
01041 #if YYDEBUG
01042 
01043 # ifndef YYFPRINTF
01044 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
01045 #  define YYFPRINTF fprintf
01046 # endif
01047 
01048 # define YYDPRINTF(Args)         \
01049 do {                 \
01050   if (yydebug)             \
01051     YYFPRINTF Args;           \
01052 } while (YYID (0))
01053 
01054 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)           \
01055 do {                            \
01056   if (yydebug)                        \
01057     {                           \
01058       YYFPRINTF (stderr, "%s ", Title);                 \
01059       yy_symbol_print (stderr,                    \
01060         Type, Value, Location, parseio); \
01061       YYFPRINTF (stderr, "\n");                   \
01062     }                           \
01063 } while (YYID (0))
01064 
01065 
01066 /*--------------------------------.
01067 | Print this symbol on YYOUTPUT.  |
01068 `--------------------------------*/
01069 
01070 /*ARGSUSED*/
01071 #if (defined __STDC__ || defined __C99__FUNC__ \
01072      || defined __cplusplus || defined _MSC_VER)
01073 static void
01074 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parse_io *parseio)
01075 #else
01076 static void
01077 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parseio)
01078     FILE *yyoutput;
01079     int yytype;
01080     YYSTYPE const * const yyvaluep;
01081     YYLTYPE const * const yylocationp;
01082     struct parse_io *parseio;
01083 #endif
01084 {
01085   if (!yyvaluep)
01086     return;
01087   YYUSE (yylocationp);
01088   YYUSE (parseio);
01089 # ifdef YYPRINT
01090   if (yytype < YYNTOKENS)
01091     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
01092 # else
01093   YYUSE (yyoutput);
01094 # endif
01095   switch (yytype)
01096     {
01097       default:
01098    break;
01099     }
01100 }
01101 
01102 
01103 /*--------------------------------.
01104 | Print this symbol on YYOUTPUT.  |
01105 `--------------------------------*/
01106 
01107 #if (defined __STDC__ || defined __C99__FUNC__ \
01108      || defined __cplusplus || defined _MSC_VER)
01109 static void
01110 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parse_io *parseio)
01111 #else
01112 static void
01113 yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, parseio)
01114     FILE *yyoutput;
01115     int yytype;
01116     YYSTYPE const * const yyvaluep;
01117     YYLTYPE const * const yylocationp;
01118     struct parse_io *parseio;
01119 #endif
01120 {
01121   if (yytype < YYNTOKENS)
01122     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
01123   else
01124     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
01125 
01126   YY_LOCATION_PRINT (yyoutput, *yylocationp);
01127   YYFPRINTF (yyoutput, ": ");
01128   yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parseio);
01129   YYFPRINTF (yyoutput, ")");
01130 }
01131 
01132 /*------------------------------------------------------------------.
01133 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
01134 | TOP (included).                                                   |
01135 `------------------------------------------------------------------*/
01136 
01137 #if (defined __STDC__ || defined __C99__FUNC__ \
01138      || defined __cplusplus || defined _MSC_VER)
01139 static void
01140 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
01141 #else
01142 static void
01143 yy_stack_print (yybottom, yytop)
01144     yytype_int16 *yybottom;
01145     yytype_int16 *yytop;
01146 #endif
01147 {
01148   YYFPRINTF (stderr, "Stack now");
01149   for (; yybottom <= yytop; yybottom++)
01150     {
01151       int yybot = *yybottom;
01152       YYFPRINTF (stderr, " %d", yybot);
01153     }
01154   YYFPRINTF (stderr, "\n");
01155 }
01156 
01157 # define YY_STACK_PRINT(Bottom, Top)            \
01158 do {                       \
01159   if (yydebug)                   \
01160     yy_stack_print ((Bottom), (Top));           \
01161 } while (YYID (0))
01162 
01163 
01164 /*------------------------------------------------.
01165 | Report that the YYRULE is going to be reduced.  |
01166 `------------------------------------------------*/
01167 
01168 #if (defined __STDC__ || defined __C99__FUNC__ \
01169      || defined __cplusplus || defined _MSC_VER)
01170 static void
01171 yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct parse_io *parseio)
01172 #else
01173 static void
01174 yy_reduce_print (yyvsp, yylsp, yyrule, parseio)
01175     YYSTYPE *yyvsp;
01176     YYLTYPE *yylsp;
01177     int yyrule;
01178     struct parse_io *parseio;
01179 #endif
01180 {
01181   int yynrhs = yyr2[yyrule];
01182   int yyi;
01183   unsigned long int yylno = yyrline[yyrule];
01184   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
01185         yyrule - 1, yylno);
01186   /* The symbols being reduced.  */
01187   for (yyi = 0; yyi < yynrhs; yyi++)
01188     {
01189       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
01190       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
01191              &(yyvsp[(yyi + 1) - (yynrhs)])
01192              , &(yylsp[(yyi + 1) - (yynrhs)])             , parseio);
01193       YYFPRINTF (stderr, "\n");
01194     }
01195 }
01196 
01197 # define YY_REDUCE_PRINT(Rule)      \
01198 do {              \
01199   if (yydebug)          \
01200     yy_reduce_print (yyvsp, yylsp, Rule, parseio); \
01201 } while (YYID (0))
01202 
01203 /* Nonzero means print parse trace.  It is left uninitialized so that
01204    multiple parsers can coexist.  */
01205 int yydebug;
01206 #else /* !YYDEBUG */
01207 # define YYDPRINTF(Args)
01208 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
01209 # define YY_STACK_PRINT(Bottom, Top)
01210 # define YY_REDUCE_PRINT(Rule)
01211 #endif /* !YYDEBUG */
01212 
01213 
01214 /* YYINITDEPTH -- initial size of the parser's stacks.  */
01215 #ifndef  YYINITDEPTH
01216 # define YYINITDEPTH 200
01217 #endif
01218 
01219 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
01220    if the built-in stack extension method is used).
01221 
01222    Do not make this value too large; the results are undefined if
01223    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
01224    evaluated with infinite-precision integer arithmetic.  */
01225 
01226 #ifndef YYMAXDEPTH
01227 # define YYMAXDEPTH 10000
01228 #endif
01229 
01230 
01231 #if YYERROR_VERBOSE
01232 
01233 # ifndef yystrlen
01234 #  if defined __GLIBC__ && defined _STRING_H
01235 #   define yystrlen strlen
01236 #  else
01237 /* Return the length of YYSTR.  */
01238 #if (defined __STDC__ || defined __C99__FUNC__ \
01239      || defined __cplusplus || defined _MSC_VER)
01240 static YYSIZE_T
01241 yystrlen (const char *yystr)
01242 #else
01243 static YYSIZE_T
01244 yystrlen (yystr)
01245     const char *yystr;
01246 #endif
01247 {
01248   YYSIZE_T yylen;
01249   for (yylen = 0; yystr[yylen]; yylen++)
01250     continue;
01251   return yylen;
01252 }
01253 #  endif
01254 # endif
01255 
01256 # ifndef yystpcpy
01257 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
01258 #   define yystpcpy stpcpy
01259 #  else
01260 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
01261    YYDEST.  */
01262 #if (defined __STDC__ || defined __C99__FUNC__ \
01263      || defined __cplusplus || defined _MSC_VER)
01264 static char *
01265 yystpcpy (char *yydest, const char *yysrc)
01266 #else
01267 static char *
01268 yystpcpy (yydest, yysrc)
01269     char *yydest;
01270     const char *yysrc;
01271 #endif
01272 {
01273   char *yyd = yydest;
01274   const char *yys = yysrc;
01275 
01276   while ((*yyd++ = *yys++) != '\0')
01277     continue;
01278 
01279   return yyd - 1;
01280 }
01281 #  endif
01282 # endif
01283 
01284 # ifndef yytnamerr
01285 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
01286    quotes and backslashes, so that it's suitable for yyerror.  The
01287    heuristic is that double-quoting is unnecessary unless the string
01288    contains an apostrophe, a comma, or backslash (other than
01289    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
01290    null, do not copy; instead, return the length of what the result
01291    would have been.  */
01292 static YYSIZE_T
01293 yytnamerr (char *yyres, const char *yystr)
01294 {
01295   if (*yystr == '"')
01296     {
01297       YYSIZE_T yyn = 0;
01298       char const *yyp = yystr;
01299 
01300       for (;;)
01301    switch (*++yyp)
01302      {
01303      case '\'':
01304      case ',':
01305        goto do_not_strip_quotes;
01306 
01307      case '\\':
01308        if (*++yyp != '\\')
01309          goto do_not_strip_quotes;
01310        /* Fall through.  */
01311      default:
01312        if (yyres)
01313          yyres[yyn] = *yyp;
01314        yyn++;
01315        break;
01316 
01317      case '"':
01318        if (yyres)
01319          yyres[yyn] = '\0';
01320        return yyn;
01321      }
01322     do_not_strip_quotes: ;
01323     }
01324 
01325   if (! yyres)
01326     return yystrlen (yystr);
01327 
01328   return yystpcpy (yyres, yystr) - yyres;
01329 }
01330 # endif
01331 
01332 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
01333    about the unexpected token YYTOKEN for the state stack whose top is
01334    YYSSP.
01335 
01336    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
01337    not large enough to hold the message.  In that case, also set
01338    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
01339    required number of bytes is too large to store.  */
01340 static int
01341 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
01342                 yytype_int16 *yyssp, int yytoken)
01343 {
01344   YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
01345   YYSIZE_T yysize = yysize0;
01346   YYSIZE_T yysize1;
01347   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
01348   /* Internationalized format string. */
01349   const char *yyformat = 0;
01350   /* Arguments of yyformat. */
01351   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01352   /* Number of reported tokens (one for the "unexpected", one per
01353      "expected"). */
01354   int yycount = 0;
01355 
01356   /* There are many possibilities here to consider:
01357      - Assume YYFAIL is not used.  It's too flawed to consider.  See
01358        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
01359        for details.  YYERROR is fine as it does not invoke this
01360        function.
01361      - If this state is a consistent state with a default action, then
01362        the only way this function was invoked is if the default action
01363        is an error action.  In that case, don't check for expected
01364        tokens because there are none.
01365      - The only way there can be no lookahead present (in yychar) is if
01366        this state is a consistent state with a default action.  Thus,
01367        detecting the absence of a lookahead is sufficient to determine
01368        that there is no unexpected or expected token to report.  In that
01369        case, just report a simple "syntax error".
01370      - Don't assume there isn't a lookahead just because this state is a
01371        consistent state with a default action.  There might have been a
01372        previous inconsistent state, consistent state with a non-default
01373        action, or user semantic action that manipulated yychar.
01374      - Of course, the expected token list depends on states to have
01375        correct lookahead information, and it depends on the parser not
01376        to perform extra reductions after fetching a lookahead from the
01377        scanner and before detecting a syntax error.  Thus, state merging
01378        (from LALR or IELR) and default reductions corrupt the expected
01379        token list.  However, the list is correct for canonical LR with
01380        one exception: it will still contain any token that will not be
01381        accepted due to an error action in a later state.
01382   */
01383   if (yytoken != YYEMPTY)
01384     {
01385       int yyn = yypact[*yyssp];
01386       yyarg[yycount++] = yytname[yytoken];
01387       if (!yypact_value_is_default (yyn))
01388         {
01389           /* Start YYX at -YYN if negative to avoid negative indexes in
01390              YYCHECK.  In other words, skip the first -YYN actions for
01391              this state because they are default actions.  */
01392           int yyxbegin = yyn < 0 ? -yyn : 0;
01393           /* Stay within bounds of both yycheck and yytname.  */
01394           int yychecklim = YYLAST - yyn + 1;
01395           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01396           int yyx;
01397 
01398           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01399             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
01400                 && !yytable_value_is_error (yytable[yyx + yyn]))
01401               {
01402                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01403                   {
01404                     yycount = 1;
01405                     yysize = yysize0;
01406                     break;
01407                   }
01408                 yyarg[yycount++] = yytname[yyx];
01409                 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01410                 if (! (yysize <= yysize1
01411                        && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
01412                   return 2;
01413                 yysize = yysize1;
01414               }
01415         }
01416     }
01417 
01418   switch (yycount)
01419     {
01420 # define YYCASE_(N, S)                      \
01421       case N:                               \
01422         yyformat = S;                       \
01423       break
01424       YYCASE_(0, YY_("syntax error"));
01425       YYCASE_(1, YY_("syntax error, unexpected %s"));
01426       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
01427       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
01428       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
01429       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
01430 # undef YYCASE_
01431     }
01432 
01433   yysize1 = yysize + yystrlen (yyformat);
01434   if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
01435     return 2;
01436   yysize = yysize1;
01437 
01438   if (*yymsg_alloc < yysize)
01439     {
01440       *yymsg_alloc = 2 * yysize;
01441       if (! (yysize <= *yymsg_alloc
01442              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
01443         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
01444       return 1;
01445     }
01446 
01447   /* Avoid sprintf, as that infringes on the user's name space.
01448      Don't have undefined behavior even if the translation
01449      produced a string with the wrong number of "%s"s.  */
01450   {
01451     char *yyp = *yymsg;
01452     int yyi = 0;
01453     while ((*yyp = *yyformat) != '\0')
01454       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
01455         {
01456           yyp += yytnamerr (yyp, yyarg[yyi++]);
01457           yyformat += 2;
01458         }
01459       else
01460         {
01461           yyp++;
01462           yyformat++;
01463         }
01464   }
01465   return 0;
01466 }
01467 #endif /* YYERROR_VERBOSE */
01468 
01469 /*-----------------------------------------------.
01470 | Release the memory associated to this symbol.  |
01471 `-----------------------------------------------*/
01472 
01473 /*ARGSUSED*/
01474 #if (defined __STDC__ || defined __C99__FUNC__ \
01475      || defined __cplusplus || defined _MSC_VER)
01476 static void
01477 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct parse_io *parseio)
01478 #else
01479 static void
01480 yydestruct (yymsg, yytype, yyvaluep, yylocationp, parseio)
01481     const char *yymsg;
01482     int yytype;
01483     YYSTYPE *yyvaluep;
01484     YYLTYPE *yylocationp;
01485     struct parse_io *parseio;
01486 #endif
01487 {
01488   YYUSE (yyvaluep);
01489   YYUSE (yylocationp);
01490   YYUSE (parseio);
01491 
01492   if (!yymsg)
01493     yymsg = "Deleting";
01494   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01495 
01496   switch (yytype)
01497     {
01498       case 43: /* "word" */
01499 
01500 /* Line 1391 of yacc.c  */
01501 #line 183 "ael.y"
01502    { free((yyvaluep->str));};
01503 
01504 /* Line 1391 of yacc.c  */
01505 #line 1506 "ael.tab.c"
01506    break;
01507       case 46: /* "objects" */
01508 
01509 /* Line 1391 of yacc.c  */
01510 #line 170 "ael.y"
01511    {
01512       destroy_pval((yyvaluep->pval));
01513       prev_word=0;
01514    };
01515 
01516 /* Line 1391 of yacc.c  */
01517 #line 1518 "ael.tab.c"
01518    break;
01519       case 47: /* "object" */
01520 
01521 /* Line 1391 of yacc.c  */
01522 #line 170 "ael.y"
01523    {
01524       destroy_pval((yyvaluep->pval));
01525       prev_word=0;
01526    };
01527 
01528 /* Line 1391 of yacc.c  */
01529 #line 1530 "ael.tab.c"
01530    break;
01531       case 48: /* "context_name" */
01532 
01533 /* Line 1391 of yacc.c  */
01534 #line 183 "ael.y"
01535    { free((yyvaluep->str));};
01536 
01537 /* Line 1391 of yacc.c  */
01538 #line 1539 "ael.tab.c"
01539    break;
01540       case 49: /* "context" */
01541 
01542 /* Line 1391 of yacc.c  */
01543 #line 170 "ael.y"
01544    {
01545       destroy_pval((yyvaluep->pval));
01546       prev_word=0;
01547    };
01548 
01549 /* Line 1391 of yacc.c  */
01550 #line 1551 "ael.tab.c"
01551    break;
01552       case 51: /* "macro" */
01553 
01554 /* Line 1391 of yacc.c  */
01555 #line 170 "ael.y"
01556    {
01557       destroy_pval((yyvaluep->pval));
01558       prev_word=0;
01559    };
01560 
01561 /* Line 1391 of yacc.c  */
01562 #line 1563 "ael.tab.c"
01563    break;
01564       case 52: /* "globals" */
01565 
01566 /* Line 1391 of yacc.c  */
01567 #line 170 "ael.y"
01568    {
01569       destroy_pval((yyvaluep->pval));
01570       prev_word=0;
01571    };
01572 
01573 /* Line 1391 of yacc.c  */
01574 #line 1575 "ael.tab.c"
01575    break;
01576       case 53: /* "global_statements" */
01577 
01578 /* Line 1391 of yacc.c  */
01579 #line 170 "ael.y"
01580    {
01581       destroy_pval((yyvaluep->pval));
01582       prev_word=0;
01583    };
01584 
01585 /* Line 1391 of yacc.c  */
01586 #line 1587 "ael.tab.c"
01587    break;
01588       case 54: /* "assignment" */
01589 
01590 /* Line 1391 of yacc.c  */
01591 #line 170 "ael.y"
01592    {
01593       destroy_pval((yyvaluep->pval));
01594       prev_word=0;
01595    };
01596 
01597 /* Line 1391 of yacc.c  */
01598 #line 1599 "ael.tab.c"
01599    break;
01600       case 56: /* "local_assignment" */
01601 
01602 /* Line 1391 of yacc.c  */
01603 #line 170 "ael.y"
01604    {
01605       destroy_pval((yyvaluep->pval));
01606       prev_word=0;
01607    };
01608 
01609 /* Line 1391 of yacc.c  */
01610 #line 1611 "ael.tab.c"
01611    break;
01612       case 58: /* "arglist" */
01613 
01614 /* Line 1391 of yacc.c  */
01615 #line 170 "ael.y"
01616    {
01617       destroy_pval((yyvaluep->pval));
01618       prev_word=0;
01619    };
01620 
01621 /* Line 1391 of yacc.c  */
01622 #line 1623 "ael.tab.c"
01623    break;
01624       case 59: /* "elements" */
01625 
01626 /* Line 1391 of yacc.c  */
01627 #line 170 "ael.y"
01628    {
01629       destroy_pval((yyvaluep->pval));
01630       prev_word=0;
01631    };
01632 
01633 /* Line 1391 of yacc.c  */
01634 #line 1635 "ael.tab.c"
01635    break;
01636       case 60: /* "element" */
01637 
01638 /* Line 1391 of yacc.c  */
01639 #line 170 "ael.y"
01640    {
01641       destroy_pval((yyvaluep->pval));
01642       prev_word=0;
01643    };
01644 
01645 /* Line 1391 of yacc.c  */
01646 #line 1647 "ael.tab.c"
01647    break;
01648       case 61: /* "ignorepat" */
01649 
01650 /* Line 1391 of yacc.c  */
01651 #line 170 "ael.y"
01652    {
01653       destroy_pval((yyvaluep->pval));
01654       prev_word=0;
01655    };
01656 
01657 /* Line 1391 of yacc.c  */
01658 #line 1659 "ael.tab.c"
01659    break;
01660       case 62: /* "extension" */
01661 
01662 /* Line 1391 of yacc.c  */
01663 #line 170 "ael.y"
01664    {
01665       destroy_pval((yyvaluep->pval));
01666       prev_word=0;
01667    };
01668 
01669 /* Line 1391 of yacc.c  */
01670 #line 1671 "ael.tab.c"
01671    break;
01672       case 63: /* "statements" */
01673 
01674 /* Line 1391 of yacc.c  */
01675 #line 170 "ael.y"
01676    {
01677       destroy_pval((yyvaluep->pval));
01678       prev_word=0;
01679    };
01680 
01681 /* Line 1391 of yacc.c  */
01682 #line 1683 "ael.tab.c"
01683    break;
01684       case 64: /* "timerange" */
01685 
01686 /* Line 1391 of yacc.c  */
01687 #line 183 "ael.y"
01688    { free((yyvaluep->str));};
01689 
01690 /* Line 1391 of yacc.c  */
01691 #line 1692 "ael.tab.c"
01692    break;
01693       case 65: /* "timespec" */
01694 
01695 /* Line 1391 of yacc.c  */
01696 #line 170 "ael.y"
01697    {
01698       destroy_pval((yyvaluep->pval));
01699       prev_word=0;
01700    };
01701 
01702 /* Line 1391 of yacc.c  */
01703 #line 1704 "ael.tab.c"
01704    break;
01705       case 66: /* "test_expr" */
01706 
01707 /* Line 1391 of yacc.c  */
01708 #line 183 "ael.y"
01709    { free((yyvaluep->str));};
01710 
01711 /* Line 1391 of yacc.c  */
01712 #line 1713 "ael.tab.c"
01713    break;
01714       case 68: /* "if_like_head" */
01715 
01716 /* Line 1391 of yacc.c  */
01717 #line 170 "ael.y"
01718    {
01719       destroy_pval((yyvaluep->pval));
01720       prev_word=0;
01721    };
01722 
01723 /* Line 1391 of yacc.c  */
01724 #line 1725 "ael.tab.c"
01725    break;
01726       case 69: /* "word_list" */
01727 
01728 /* Line 1391 of yacc.c  */
01729 #line 183 "ael.y"
01730    { free((yyvaluep->str));};
01731 
01732 /* Line 1391 of yacc.c  */
01733 #line 1734 "ael.tab.c"
01734    break;
01735       case 71: /* "word3_list" */
01736 
01737 /* Line 1391 of yacc.c  */
01738 #line 183 "ael.y"
01739    { free((yyvaluep->str));};
01740 
01741 /* Line 1391 of yacc.c  */
01742 #line 1743 "ael.tab.c"
01743    break;
01744       case 72: /* "goto_word" */
01745 
01746 /* Line 1391 of yacc.c  */
01747 #line 183 "ael.y"
01748    { free((yyvaluep->str));};
01749 
01750 /* Line 1391 of yacc.c  */
01751 #line 1752 "ael.tab.c"
01752    break;
01753       case 73: /* "switch_statement" */
01754 
01755 /* Line 1391 of yacc.c  */
01756 #line 170 "ael.y"
01757    {
01758       destroy_pval((yyvaluep->pval));
01759       prev_word=0;
01760    };
01761 
01762 /* Line 1391 of yacc.c  */
01763 #line 1764 "ael.tab.c"
01764    break;
01765       case 74: /* "statement" */
01766 
01767 /* Line 1391 of yacc.c  */
01768 #line 170 "ael.y"
01769    {
01770       destroy_pval((yyvaluep->pval));
01771       prev_word=0;
01772    };
01773 
01774 /* Line 1391 of yacc.c  */
01775 #line 1776 "ael.tab.c"
01776    break;
01777       case 79: /* "opt_else" */
01778 
01779 /* Line 1391 of yacc.c  */
01780 #line 170 "ael.y"
01781    {
01782       destroy_pval((yyvaluep->pval));
01783       prev_word=0;
01784    };
01785 
01786 /* Line 1391 of yacc.c  */
01787 #line 1788 "ael.tab.c"
01788    break;
01789       case 80: /* "target" */
01790 
01791 /* Line 1391 of yacc.c  */
01792 #line 170 "ael.y"
01793    {
01794       destroy_pval((yyvaluep->pval));
01795       prev_word=0;
01796    };
01797 
01798 /* Line 1391 of yacc.c  */
01799 #line 1800 "ael.tab.c"
01800    break;
01801       case 81: /* "opt_pri" */
01802 
01803 /* Line 1391 of yacc.c  */
01804 #line 183 "ael.y"
01805    { free((yyvaluep->str));};
01806 
01807 /* Line 1391 of yacc.c  */
01808 #line 1809 "ael.tab.c"
01809    break;
01810       case 82: /* "jumptarget" */
01811 
01812 /* Line 1391 of yacc.c  */
01813 #line 170 "ael.y"
01814    {
01815       destroy_pval((yyvaluep->pval));
01816       prev_word=0;
01817    };
01818 
01819 /* Line 1391 of yacc.c  */
01820 #line 1821 "ael.tab.c"
01821    break;
01822       case 83: /* "macro_call" */
01823 
01824 /* Line 1391 of yacc.c  */
01825 #line 170 "ael.y"
01826    {
01827       destroy_pval((yyvaluep->pval));
01828       prev_word=0;
01829    };
01830 
01831 /* Line 1391 of yacc.c  */
01832 #line 1833 "ael.tab.c"
01833    break;
01834       case 85: /* "application_call_head" */
01835 
01836 /* Line 1391 of yacc.c  */
01837 #line 170 "ael.y"
01838    {
01839       destroy_pval((yyvaluep->pval));
01840       prev_word=0;
01841    };
01842 
01843 /* Line 1391 of yacc.c  */
01844 #line 1845 "ael.tab.c"
01845    break;
01846       case 87: /* "application_call" */
01847 
01848 /* Line 1391 of yacc.c  */
01849 #line 170 "ael.y"
01850    {
01851       destroy_pval((yyvaluep->pval));
01852       prev_word=0;
01853    };
01854 
01855 /* Line 1391 of yacc.c  */
01856 #line 1857 "ael.tab.c"
01857    break;
01858       case 88: /* "opt_word" */
01859 
01860 /* Line 1391 of yacc.c  */
01861 #line 183 "ael.y"
01862    { free((yyvaluep->str));};
01863 
01864 /* Line 1391 of yacc.c  */
01865 #line 1866 "ael.tab.c"
01866    break;
01867       case 89: /* "eval_arglist" */
01868 
01869 /* Line 1391 of yacc.c  */
01870 #line 170 "ael.y"
01871    {
01872       destroy_pval((yyvaluep->pval));
01873       prev_word=0;
01874    };
01875 
01876 /* Line 1391 of yacc.c  */
01877 #line 1878 "ael.tab.c"
01878    break;
01879       case 90: /* "case_statements" */
01880 
01881 /* Line 1391 of yacc.c  */
01882 #line 170 "ael.y"
01883    {
01884       destroy_pval((yyvaluep->pval));
01885       prev_word=0;
01886    };
01887 
01888 /* Line 1391 of yacc.c  */
01889 #line 1890 "ael.tab.c"
01890    break;
01891       case 91: /* "case_statement" */
01892 
01893 /* Line 1391 of yacc.c  */
01894 #line 170 "ael.y"
01895    {
01896       destroy_pval((yyvaluep->pval));
01897       prev_word=0;
01898    };
01899 
01900 /* Line 1391 of yacc.c  */
01901 #line 1902 "ael.tab.c"
01902    break;
01903       case 92: /* "macro_statements" */
01904 
01905 /* Line 1391 of yacc.c  */
01906 #line 170 "ael.y"
01907    {
01908       destroy_pval((yyvaluep->pval));
01909       prev_word=0;
01910    };
01911 
01912 /* Line 1391 of yacc.c  */
01913 #line 1914 "ael.tab.c"
01914    break;
01915       case 93: /* "macro_statement" */
01916 
01917 /* Line 1391 of yacc.c  */
01918 #line 170 "ael.y"
01919    {
01920       destroy_pval((yyvaluep->pval));
01921       prev_word=0;
01922    };
01923 
01924 /* Line 1391 of yacc.c  */
01925 #line 1926 "ael.tab.c"
01926    break;
01927       case 94: /* "switches" */
01928 
01929 /* Line 1391 of yacc.c  */
01930 #line 170 "ael.y"
01931    {
01932       destroy_pval((yyvaluep->pval));
01933       prev_word=0;
01934    };
01935 
01936 /* Line 1391 of yacc.c  */
01937 #line 1938 "ael.tab.c"
01938    break;
01939       case 95: /* "eswitches" */
01940 
01941 /* Line 1391 of yacc.c  */
01942 #line 170 "ael.y"
01943    {
01944       destroy_pval((yyvaluep->pval));
01945       prev_word=0;
01946    };
01947 
01948 /* Line 1391 of yacc.c  */
01949 #line 1950 "ael.tab.c"
01950    break;
01951       case 96: /* "switchlist" */
01952 
01953 /* Line 1391 of yacc.c  */
01954 #line 170 "ael.y"
01955    {
01956       destroy_pval((yyvaluep->pval));
01957       prev_word=0;
01958    };
01959 
01960 /* Line 1391 of yacc.c  */
01961 #line 1962 "ael.tab.c"
01962    break;
01963       case 97: /* "included_entry" */
01964 
01965 /* Line 1391 of yacc.c  */
01966 #line 170 "ael.y"
01967    {
01968       destroy_pval((yyvaluep->pval));
01969       prev_word=0;
01970    };
01971 
01972 /* Line 1391 of yacc.c  */
01973 #line 1974 "ael.tab.c"
01974    break;
01975       case 98: /* "includeslist" */
01976 
01977 /* Line 1391 of yacc.c  */
01978 #line 170 "ael.y"
01979    {
01980       destroy_pval((yyvaluep->pval));
01981       prev_word=0;
01982    };
01983 
01984 /* Line 1391 of yacc.c  */
01985 #line 1986 "ael.tab.c"
01986    break;
01987       case 99: /* "includes" */
01988 
01989 /* Line 1391 of yacc.c  */
01990 #line 170 "ael.y"
01991    {
01992       destroy_pval((yyvaluep->pval));
01993       prev_word=0;
01994    };
01995 
01996 /* Line 1391 of yacc.c  */
01997 #line 1998 "ael.tab.c"
01998    break;
01999 
02000       default:
02001    break;
02002     }
02003 }
02004 
02005 
02006 /* Prevent warnings from -Wmissing-prototypes.  */
02007 #ifdef YYPARSE_PARAM
02008 #if defined __STDC__ || defined __cplusplus
02009 int yyparse (void *YYPARSE_PARAM);
02010 #else
02011 int yyparse ();
02012 #endif
02013 #else /* ! YYPARSE_PARAM */
02014 #if defined __STDC__ || defined __cplusplus
02015 int yyparse (struct parse_io *parseio);
02016 #else
02017 int yyparse ();
02018 #endif
02019 #endif /* ! YYPARSE_PARAM */
02020 
02021 
02022 /*----------.
02023 | yyparse.  |
02024 `----------*/
02025 
02026 #ifdef YYPARSE_PARAM
02027 #if (defined __STDC__ || defined __C99__FUNC__ \
02028      || defined __cplusplus || defined _MSC_VER)
02029 int
02030 yyparse (void *YYPARSE_PARAM)
02031 #else
02032 int
02033 yyparse (YYPARSE_PARAM)
02034     void *YYPARSE_PARAM;
02035 #endif
02036 #else /* ! YYPARSE_PARAM */
02037 #if (defined __STDC__ || defined __C99__FUNC__ \
02038      || defined __cplusplus || defined _MSC_VER)
02039 int
02040 yyparse (struct parse_io *parseio)
02041 #else
02042 int
02043 yyparse (parseio)
02044     struct parse_io *parseio;
02045 #endif
02046 #endif
02047 {
02048 /* The lookahead symbol.  */
02049 int yychar;
02050 
02051 /* The semantic value of the lookahead symbol.  */
02052 YYSTYPE yylval;
02053 
02054 /* Location data for the lookahead symbol.  */
02055 YYLTYPE yylloc;
02056 
02057     /* Number of syntax errors so far.  */
02058     int yynerrs;
02059 
02060     int yystate;
02061     /* Number of tokens to shift before error messages enabled.  */
02062     int yyerrstatus;
02063 
02064     /* The stacks and their tools:
02065        `yyss': related to states.
02066        `yyvs': related to semantic values.
02067        `yyls': related to locations.
02068 
02069        Refer to the stacks thru separate pointers, to allow yyoverflow
02070        to reallocate them elsewhere.  */
02071 
02072     /* The state stack.  */
02073     yytype_int16 yyssa[YYINITDEPTH];
02074     yytype_int16 *yyss;
02075     yytype_int16 *yyssp;
02076 
02077     /* The semantic value stack.  */
02078     YYSTYPE yyvsa[YYINITDEPTH];
02079     YYSTYPE *yyvs;
02080     YYSTYPE *yyvsp;
02081 
02082     /* The location stack.  */
02083     YYLTYPE yylsa[YYINITDEPTH];
02084     YYLTYPE *yyls;
02085     YYLTYPE *yylsp;
02086 
02087     /* The locations where the error started and ended.  */
02088     YYLTYPE yyerror_range[3];
02089 
02090     YYSIZE_T yystacksize;
02091 
02092   int yyn;
02093   int yyresult;
02094   /* Lookahead token as an internal (translated) token number.  */
02095   int yytoken;
02096   /* The variables used to return semantic value and location from the
02097      action routines.  */
02098   YYSTYPE yyval;
02099   YYLTYPE yyloc;
02100 
02101 #if YYERROR_VERBOSE
02102   /* Buffer for error messages, and its allocated size.  */
02103   char yymsgbuf[128];
02104   char *yymsg = yymsgbuf;
02105   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
02106 #endif
02107 
02108 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
02109 
02110   /* The number of symbols on the RHS of the reduced rule.
02111      Keep to zero when no symbol should be popped.  */
02112   int yylen = 0;
02113 
02114   yytoken = 0;
02115   yyss = yyssa;
02116   yyvs = yyvsa;
02117   yyls = yylsa;
02118   yystacksize = YYINITDEPTH;
02119 
02120   YYDPRINTF ((stderr, "Starting parse\n"));
02121 
02122   yystate = 0;
02123   yyerrstatus = 0;
02124   yynerrs = 0;
02125   yychar = YYEMPTY; /* Cause a token to be read.  */
02126 
02127   /* Initialize stack pointers.
02128      Waste one element of value and location stack
02129      so that they stay on the same level as the state stack.
02130      The wasted elements are never initialized.  */
02131   yyssp = yyss;
02132   yyvsp = yyvs;
02133   yylsp = yyls;
02134 
02135 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
02136   /* Initialize the default location before parsing starts.  */
02137   yylloc.first_line   = yylloc.last_line   = 1;
02138   yylloc.first_column = yylloc.last_column = 1;
02139 #endif
02140 
02141   goto yysetstate;
02142 
02143 /*------------------------------------------------------------.
02144 | yynewstate -- Push a new state, which is found in yystate.  |
02145 `------------------------------------------------------------*/
02146  yynewstate:
02147   /* In all cases, when you get here, the value and location stacks
02148      have just been pushed.  So pushing a state here evens the stacks.  */
02149   yyssp++;
02150 
02151  yysetstate:
02152   *yyssp = yystate;
02153 
02154   if (yyss + yystacksize - 1 <= yyssp)
02155     {
02156       /* Get the current used size of the three stacks, in elements.  */
02157       YYSIZE_T yysize = yyssp - yyss + 1;
02158 
02159 #ifdef yyoverflow
02160       {
02161    /* Give user a chance to reallocate the stack.  Use copies of
02162       these so that the &'s don't force the real ones into
02163       memory.  */
02164    YYSTYPE *yyvs1 = yyvs;
02165    yytype_int16 *yyss1 = yyss;
02166    YYLTYPE *yyls1 = yyls;
02167 
02168    /* Each stack pointer address is followed by the size of the
02169       data in use in that stack, in bytes.  This used to be a
02170       conditional around just the two extra args, but that might
02171       be undefined if yyoverflow is a macro.  */
02172    yyoverflow (YY_("memory exhausted"),
02173           &yyss1, yysize * sizeof (*yyssp),
02174           &yyvs1, yysize * sizeof (*yyvsp),
02175           &yyls1, yysize * sizeof (*yylsp),
02176           &yystacksize);
02177 
02178    yyls = yyls1;
02179    yyss = yyss1;
02180    yyvs = yyvs1;
02181       }
02182 #else /* no yyoverflow */
02183 # ifndef YYSTACK_RELOCATE
02184       goto yyexhaustedlab;
02185 # else
02186       /* Extend the stack our own way.  */
02187       if (YYMAXDEPTH <= yystacksize)
02188    goto yyexhaustedlab;
02189       yystacksize *= 2;
02190       if (YYMAXDEPTH < yystacksize)
02191    yystacksize = YYMAXDEPTH;
02192 
02193       {
02194    yytype_int16 *yyss1 = yyss;
02195    union yyalloc *yyptr =
02196      (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
02197    if (! yyptr)
02198      goto yyexhaustedlab;
02199    YYSTACK_RELOCATE (yyss_alloc, yyss);
02200    YYSTACK_RELOCATE (yyvs_alloc, yyvs);
02201    YYSTACK_RELOCATE (yyls_alloc, yyls);
02202 #  undef YYSTACK_RELOCATE
02203    if (yyss1 != yyssa)
02204      YYSTACK_FREE (yyss1);
02205       }
02206 # endif
02207 #endif /* no yyoverflow */
02208 
02209       yyssp = yyss + yysize - 1;
02210       yyvsp = yyvs + yysize - 1;
02211       yylsp = yyls + yysize - 1;
02212 
02213       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
02214         (unsigned long int) yystacksize));
02215 
02216       if (yyss + yystacksize - 1 <= yyssp)
02217    YYABORT;
02218     }
02219 
02220   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
02221 
02222   if (yystate == YYFINAL)
02223     YYACCEPT;
02224 
02225   goto yybackup;
02226 
02227 /*-----------.
02228 | yybackup.  |
02229 `-----------*/
02230 yybackup:
02231 
02232   /* Do appropriate processing given the current state.  Read a
02233      lookahead token if we need one and don't already have one.  */
02234 
02235   /* First try to decide what to do without reference to lookahead token.  */
02236   yyn = yypact[yystate];
02237   if (yypact_value_is_default (yyn))
02238     goto yydefault;
02239 
02240   /* Not known => get a lookahead token if don't already have one.  */
02241 
02242   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
02243   if (yychar == YYEMPTY)
02244     {
02245       YYDPRINTF ((stderr, "Reading a token: "));
02246       yychar = YYLEX;
02247     }
02248 
02249   if (yychar <= YYEOF)
02250     {
02251       yychar = yytoken = YYEOF;
02252       YYDPRINTF ((stderr, "Now at end of input.\n"));
02253     }
02254   else
02255     {
02256       yytoken = YYTRANSLATE (yychar);
02257       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
02258     }
02259 
02260   /* If the proper action on seeing token YYTOKEN is to reduce or to
02261      detect an error, take that action.  */
02262   yyn += yytoken;
02263   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
02264     goto yydefault;
02265   yyn = yytable[yyn];
02266   if (yyn <= 0)
02267     {
02268       if (yytable_value_is_error (yyn))
02269         goto yyerrlab;
02270       yyn = -yyn;
02271       goto yyreduce;
02272     }
02273 
02274   /* Count tokens shifted since error; after three, turn off error
02275      status.  */
02276   if (yyerrstatus)
02277     yyerrstatus--;
02278 
02279   /* Shift the lookahead token.  */
02280   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
02281 
02282   /* Discard the shifted token.  */
02283   yychar = YYEMPTY;
02284 
02285   yystate = yyn;
02286   *++yyvsp = yylval;
02287   *++yylsp = yylloc;
02288   goto yynewstate;
02289 
02290 
02291 /*-----------------------------------------------------------.
02292 | yydefault -- do the default action for the current state.  |
02293 `-----------------------------------------------------------*/
02294 yydefault:
02295   yyn = yydefact[yystate];
02296   if (yyn == 0)
02297     goto yyerrlab;
02298   goto yyreduce;
02299 
02300 
02301 /*-----------------------------.
02302 | yyreduce -- Do a reduction.  |
02303 `-----------------------------*/
02304 yyreduce:
02305   /* yyn is the number of a rule to reduce with.  */
02306   yylen = yyr2[yyn];
02307 
02308   /* If YYLEN is nonzero, implement the default value of the action:
02309      `$$ = $1'.
02310 
02311      Otherwise, the following line sets YYVAL to garbage.
02312      This behavior is undocumented and Bison
02313      users should not rely upon it.  Assigning to YYVAL
02314      unconditionally makes the parser a bit smaller, and it avoids a
02315      GCC warning that YYVAL may be used uninitialized.  */
02316   yyval = yyvsp[1-yylen];
02317 
02318   /* Default location.  */
02319   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
02320   YY_REDUCE_PRINT (yyn);
02321   switch (yyn)
02322     {
02323         case 2:
02324 
02325 /* Line 1806 of yacc.c  */
02326 #line 191 "ael.y"
02327     { (yyval.pval) = parseio->pval = (yyvsp[(1) - (1)].pval); }
02328     break;
02329 
02330   case 3:
02331 
02332 /* Line 1806 of yacc.c  */
02333 #line 194 "ael.y"
02334     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02335     break;
02336 
02337   case 4:
02338 
02339 /* Line 1806 of yacc.c  */
02340 #line 195 "ael.y"
02341     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02342     break;
02343 
02344   case 5:
02345 
02346 /* Line 1806 of yacc.c  */
02347 #line 196 "ael.y"
02348     {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
02349     break;
02350 
02351   case 6:
02352 
02353 /* Line 1806 of yacc.c  */
02354 #line 199 "ael.y"
02355     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02356     break;
02357 
02358   case 7:
02359 
02360 /* Line 1806 of yacc.c  */
02361 #line 200 "ael.y"
02362     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02363     break;
02364 
02365   case 8:
02366 
02367 /* Line 1806 of yacc.c  */
02368 #line 201 "ael.y"
02369     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02370     break;
02371 
02372   case 9:
02373 
02374 /* Line 1806 of yacc.c  */
02375 #line 202 "ael.y"
02376     {(yyval.pval)=0;/* allow older docs to be read */}
02377     break;
02378 
02379   case 10:
02380 
02381 /* Line 1806 of yacc.c  */
02382 #line 205 "ael.y"
02383     { (yyval.str) = (yyvsp[(1) - (1)].str); }
02384     break;
02385 
02386   case 11:
02387 
02388 /* Line 1806 of yacc.c  */
02389 #line 206 "ael.y"
02390     { (yyval.str) = strdup("default"); }
02391     break;
02392 
02393   case 12:
02394 
02395 /* Line 1806 of yacc.c  */
02396 #line 209 "ael.y"
02397     {
02398       (yyval.pval) = npval2(PV_CONTEXT, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)]));
02399       (yyval.pval)->u1.str = (yyvsp[(3) - (6)].str);
02400       (yyval.pval)->u2.statements = (yyvsp[(5) - (6)].pval);
02401       set_dads((yyval.pval),(yyvsp[(5) - (6)].pval));
02402       (yyval.pval)->u3.abstract = (yyvsp[(1) - (6)].intval);}
02403     break;
02404 
02405   case 13:
02406 
02407 /* Line 1806 of yacc.c  */
02408 #line 218 "ael.y"
02409     { (yyval.intval) = 1; }
02410     break;
02411 
02412   case 14:
02413 
02414 /* Line 1806 of yacc.c  */
02415 #line 219 "ael.y"
02416     { (yyval.intval) = 0; }
02417     break;
02418 
02419   case 15:
02420 
02421 /* Line 1806 of yacc.c  */
02422 #line 220 "ael.y"
02423     { (yyval.intval) = 2; }
02424     break;
02425 
02426   case 16:
02427 
02428 /* Line 1806 of yacc.c  */
02429 #line 221 "ael.y"
02430     { (yyval.intval)=3; }
02431     break;
02432 
02433   case 17:
02434 
02435 /* Line 1806 of yacc.c  */
02436 #line 222 "ael.y"
02437     { (yyval.intval)=3; }
02438     break;
02439 
02440   case 18:
02441 
02442 /* Line 1806 of yacc.c  */
02443 #line 225 "ael.y"
02444     {
02445       (yyval.pval) = npval2(PV_MACRO, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)]));
02446       (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);
02447         set_dads((yyval.pval),(yyvsp[(7) - (8)].pval));}
02448     break;
02449 
02450   case 19:
02451 
02452 /* Line 1806 of yacc.c  */
02453 #line 231 "ael.y"
02454     {
02455       (yyval.pval) = npval2(PV_GLOBALS, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02456       (yyval.pval)->u1.statements = (yyvsp[(3) - (4)].pval);
02457         set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
02458     break;
02459 
02460   case 20:
02461 
02462 /* Line 1806 of yacc.c  */
02463 #line 237 "ael.y"
02464     { (yyval.pval) = NULL; }
02465     break;
02466 
02467   case 21:
02468 
02469 /* Line 1806 of yacc.c  */
02470 #line 238 "ael.y"
02471     {(yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02472     break;
02473 
02474   case 22:
02475 
02476 /* Line 1806 of yacc.c  */
02477 #line 239 "ael.y"
02478     {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
02479     break;
02480 
02481   case 23:
02482 
02483 /* Line 1806 of yacc.c  */
02484 #line 242 "ael.y"
02485     { reset_semicount(parseio->scanner); }
02486     break;
02487 
02488   case 24:
02489 
02490 /* Line 1806 of yacc.c  */
02491 #line 242 "ael.y"
02492     {
02493       (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
02494       (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str);
02495       (yyval.pval)->u2.val = (yyvsp[(4) - (5)].str); }
02496     break;
02497 
02498   case 25:
02499 
02500 /* Line 1806 of yacc.c  */
02501 #line 248 "ael.y"
02502     { reset_semicount(parseio->scanner); }
02503     break;
02504 
02505   case 26:
02506 
02507 /* Line 1806 of yacc.c  */
02508 #line 248 "ael.y"
02509     {
02510       (yyval.pval) = npval2(PV_LOCALVARDEC, &(yylsp[(1) - (6)]), &(yylsp[(6) - (6)]));
02511       (yyval.pval)->u1.str = (yyvsp[(2) - (6)].str);
02512       (yyval.pval)->u2.val = (yyvsp[(5) - (6)].str); }
02513     break;
02514 
02515   case 27:
02516 
02517 /* Line 1806 of yacc.c  */
02518 #line 255 "ael.y"
02519     { (yyval.pval) = NULL; }
02520     break;
02521 
02522   case 28:
02523 
02524 /* Line 1806 of yacc.c  */
02525 #line 256 "ael.y"
02526     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
02527     break;
02528 
02529   case 29:
02530 
02531 /* Line 1806 of yacc.c  */
02532 #line 257 "ael.y"
02533     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); }
02534     break;
02535 
02536   case 30:
02537 
02538 /* Line 1806 of yacc.c  */
02539 #line 258 "ael.y"
02540     {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
02541     break;
02542 
02543   case 31:
02544 
02545 /* Line 1806 of yacc.c  */
02546 #line 261 "ael.y"
02547     {(yyval.pval)=0;}
02548     break;
02549 
02550   case 32:
02551 
02552 /* Line 1806 of yacc.c  */
02553 #line 262 "ael.y"
02554     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02555     break;
02556 
02557   case 33:
02558 
02559 /* Line 1806 of yacc.c  */
02560 #line 263 "ael.y"
02561     { (yyval.pval)=(yyvsp[(2) - (2)].pval);}
02562     break;
02563 
02564   case 34:
02565 
02566 /* Line 1806 of yacc.c  */
02567 #line 266 "ael.y"
02568     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02569     break;
02570 
02571   case 35:
02572 
02573 /* Line 1806 of yacc.c  */
02574 #line 267 "ael.y"
02575     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02576     break;
02577 
02578   case 36:
02579 
02580 /* Line 1806 of yacc.c  */
02581 #line 268 "ael.y"
02582     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02583     break;
02584 
02585   case 37:
02586 
02587 /* Line 1806 of yacc.c  */
02588 #line 269 "ael.y"
02589     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02590     break;
02591 
02592   case 38:
02593 
02594 /* Line 1806 of yacc.c  */
02595 #line 270 "ael.y"
02596     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02597     break;
02598 
02599   case 39:
02600 
02601 /* Line 1806 of yacc.c  */
02602 #line 271 "ael.y"
02603     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02604     break;
02605 
02606   case 40:
02607 
02608 /* Line 1806 of yacc.c  */
02609 #line 272 "ael.y"
02610     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
02611     break;
02612 
02613   case 41:
02614 
02615 /* Line 1806 of yacc.c  */
02616 #line 273 "ael.y"
02617     {free((yyvsp[(1) - (2)].str)); (yyval.pval)=0;}
02618     break;
02619 
02620   case 42:
02621 
02622 /* Line 1806 of yacc.c  */
02623 #line 274 "ael.y"
02624     {(yyval.pval)=0;/* allow older docs to be read */}
02625     break;
02626 
02627   case 43:
02628 
02629 /* Line 1806 of yacc.c  */
02630 #line 277 "ael.y"
02631     {
02632       (yyval.pval) = npval2(PV_IGNOREPAT, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02633       (yyval.pval)->u1.str = (yyvsp[(3) - (4)].str);}
02634     break;
02635 
02636   case 44:
02637 
02638 /* Line 1806 of yacc.c  */
02639 #line 282 "ael.y"
02640     {
02641       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
02642       (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str);
02643       (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
02644     break;
02645 
02646   case 45:
02647 
02648 /* Line 1806 of yacc.c  */
02649 #line 286 "ael.y"
02650     {
02651       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (5)]), &(yylsp[(3) - (5)]));
02652       (yyval.pval)->u1.str = malloc(strlen((yyvsp[(1) - (5)].str))+strlen((yyvsp[(3) - (5)].str))+2);
02653       strcpy((yyval.pval)->u1.str,(yyvsp[(1) - (5)].str));
02654       strcat((yyval.pval)->u1.str,"@");
02655       strcat((yyval.pval)->u1.str,(yyvsp[(3) - (5)].str));
02656       free((yyvsp[(1) - (5)].str));
02657       (yyval.pval)->u2.statements = (yyvsp[(5) - (5)].pval); set_dads((yyval.pval),(yyvsp[(5) - (5)].pval));}
02658     break;
02659 
02660   case 46:
02661 
02662 /* Line 1806 of yacc.c  */
02663 #line 294 "ael.y"
02664     {
02665       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02666       (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
02667       (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));
02668       (yyval.pval)->u4.regexten=1;}
02669     break;
02670 
02671   case 47:
02672 
02673 /* Line 1806 of yacc.c  */
02674 #line 299 "ael.y"
02675     {
02676       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (7)]), &(yylsp[(7) - (7)]));
02677       (yyval.pval)->u1.str = (yyvsp[(5) - (7)].str);
02678       (yyval.pval)->u2.statements = (yyvsp[(7) - (7)].pval); set_dads((yyval.pval),(yyvsp[(7) - (7)].pval));
02679       (yyval.pval)->u3.hints = (yyvsp[(3) - (7)].str);}
02680     break;
02681 
02682   case 48:
02683 
02684 /* Line 1806 of yacc.c  */
02685 #line 304 "ael.y"
02686     {
02687       (yyval.pval) = npval2(PV_EXTENSION, &(yylsp[(1) - (8)]), &(yylsp[(8) - (8)]));
02688       (yyval.pval)->u1.str = (yyvsp[(6) - (8)].str);
02689       (yyval.pval)->u2.statements = (yyvsp[(8) - (8)].pval); set_dads((yyval.pval),(yyvsp[(8) - (8)].pval));
02690       (yyval.pval)->u4.regexten=1;
02691       (yyval.pval)->u3.hints = (yyvsp[(4) - (8)].str);}
02692     break;
02693 
02694   case 49:
02695 
02696 /* Line 1806 of yacc.c  */
02697 #line 313 "ael.y"
02698     { (yyval.pval) = NULL; }
02699     break;
02700 
02701   case 50:
02702 
02703 /* Line 1806 of yacc.c  */
02704 #line 314 "ael.y"
02705     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
02706     break;
02707 
02708   case 51:
02709 
02710 /* Line 1806 of yacc.c  */
02711 #line 315 "ael.y"
02712     {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
02713     break;
02714 
02715   case 52:
02716 
02717 /* Line 1806 of yacc.c  */
02718 #line 321 "ael.y"
02719     {
02720       if (asprintf(&(yyval.str), "%s:%s:%s", (yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (yyvsp[(5) - (5)].str)) < 0) {
02721          ast_log(LOG_WARNING, "asprintf() failed\n");
02722          (yyval.str) = NULL;
02723       } else {
02724          free((yyvsp[(1) - (5)].str));
02725          free((yyvsp[(3) - (5)].str));
02726          free((yyvsp[(5) - (5)].str));
02727       }
02728    }
02729     break;
02730 
02731   case 53:
02732 
02733 /* Line 1806 of yacc.c  */
02734 #line 331 "ael.y"
02735     { (yyval.str) = (yyvsp[(1) - (1)].str); }
02736     break;
02737 
02738   case 54:
02739 
02740 /* Line 1806 of yacc.c  */
02741 #line 335 "ael.y"
02742     {
02743       (yyval.pval) = nword((yyvsp[(1) - (7)].str), &(yylsp[(1) - (7)]));
02744       (yyval.pval)->next = nword((yyvsp[(3) - (7)].str), &(yylsp[(3) - (7)]));
02745       (yyval.pval)->next->next = nword((yyvsp[(5) - (7)].str), &(yylsp[(5) - (7)]));
02746       (yyval.pval)->next->next->next = nword((yyvsp[(7) - (7)].str), &(yylsp[(7) - (7)])); }
02747     break;
02748 
02749   case 55:
02750 
02751 /* Line 1806 of yacc.c  */
02752 #line 343 "ael.y"
02753     { reset_parencount(parseio->scanner); }
02754     break;
02755 
02756   case 56:
02757 
02758 /* Line 1806 of yacc.c  */
02759 #line 343 "ael.y"
02760     { (yyval.str) = (yyvsp[(3) - (4)].str); }
02761     break;
02762 
02763   case 57:
02764 
02765 /* Line 1806 of yacc.c  */
02766 #line 347 "ael.y"
02767     {
02768       (yyval.pval)= npval2(PV_IF, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
02769       (yyval.pval)->u1.str = (yyvsp[(2) - (2)].str); }
02770     break;
02771 
02772   case 58:
02773 
02774 /* Line 1806 of yacc.c  */
02775 #line 350 "ael.y"
02776     {
02777       (yyval.pval) = npval2(PV_RANDOM, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
02778       (yyval.pval)->u1.str=(yyvsp[(2) - (2)].str);}
02779     break;
02780 
02781   case 59:
02782 
02783 /* Line 1806 of yacc.c  */
02784 #line 353 "ael.y"
02785     {
02786       (yyval.pval) = npval2(PV_IFTIME, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
02787       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);
02788       prev_word = 0; }
02789     break;
02790 
02791   case 60:
02792 
02793 /* Line 1806 of yacc.c  */
02794 #line 364 "ael.y"
02795     { (yyval.str) = (yyvsp[(1) - (1)].str);}
02796     break;
02797 
02798   case 61:
02799 
02800 /* Line 1806 of yacc.c  */
02801 #line 365 "ael.y"
02802     {
02803       if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02804          ast_log(LOG_WARNING, "asprintf() failed\n");
02805          (yyval.str) = NULL;
02806       } else {
02807          free((yyvsp[(1) - (2)].str));
02808          free((yyvsp[(2) - (2)].str));
02809          prev_word = (yyval.str);
02810       }
02811    }
02812     break;
02813 
02814   case 62:
02815 
02816 /* Line 1806 of yacc.c  */
02817 #line 377 "ael.y"
02818     { (yyval.str) = (yyvsp[(1) - (1)].str); }
02819     break;
02820 
02821   case 63:
02822 
02823 /* Line 1806 of yacc.c  */
02824 #line 378 "ael.y"
02825     {
02826       if (asprintf(&((yyval.str)), "%s %s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02827          ast_log(LOG_WARNING, "asprintf() failed\n");
02828          (yyval.str) = NULL;
02829       } else {
02830          free((yyvsp[(1) - (2)].str));
02831          free((yyvsp[(2) - (2)].str));
02832       }
02833    }
02834     break;
02835 
02836   case 64:
02837 
02838 /* Line 1806 of yacc.c  */
02839 #line 387 "ael.y"
02840     {
02841       if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02842          ast_log(LOG_WARNING, "asprintf() failed\n");
02843          (yyval.str) = NULL;
02844       } else {
02845          free((yyvsp[(1) - (3)].str));
02846          free((yyvsp[(3) - (3)].str));
02847       }
02848    }
02849     break;
02850 
02851   case 65:
02852 
02853 /* Line 1806 of yacc.c  */
02854 #line 396 "ael.y"
02855     {  /* there are often '&' in hints */
02856       if (asprintf(&((yyval.str)), "%s&%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02857          ast_log(LOG_WARNING, "asprintf() failed\n");
02858          (yyval.str) = NULL;
02859       } else {
02860          free((yyvsp[(1) - (3)].str));
02861          free((yyvsp[(3) - (3)].str));
02862       }
02863    }
02864     break;
02865 
02866   case 66:
02867 
02868 /* Line 1806 of yacc.c  */
02869 #line 405 "ael.y"
02870     {
02871       if (asprintf(&((yyval.str)), "%s@%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02872          ast_log(LOG_WARNING, "asprintf() failed\n");
02873          (yyval.str) = NULL;
02874       } else {
02875          free((yyvsp[(1) - (3)].str));
02876          free((yyvsp[(3) - (3)].str));
02877       }
02878    }
02879     break;
02880 
02881   case 67:
02882 
02883 /* Line 1806 of yacc.c  */
02884 #line 416 "ael.y"
02885     { (yyval.str) = (yyvsp[(1) - (1)].str);}
02886     break;
02887 
02888   case 68:
02889 
02890 /* Line 1806 of yacc.c  */
02891 #line 417 "ael.y"
02892     {
02893       if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02894          ast_log(LOG_WARNING, "asprintf() failed\n");
02895          (yyval.str) = NULL;
02896       } else {
02897          free((yyvsp[(1) - (2)].str));
02898          free((yyvsp[(2) - (2)].str));
02899          prev_word = (yyval.str);
02900       }        
02901    }
02902     break;
02903 
02904   case 69:
02905 
02906 /* Line 1806 of yacc.c  */
02907 #line 427 "ael.y"
02908     {
02909       if (asprintf(&((yyval.str)), "%s%s%s", (yyvsp[(1) - (3)].str), (yyvsp[(2) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02910          ast_log(LOG_WARNING, "asprintf() failed\n");
02911          (yyval.str) = NULL;
02912       } else {
02913          free((yyvsp[(1) - (3)].str));
02914          free((yyvsp[(2) - (3)].str));
02915          free((yyvsp[(3) - (3)].str));
02916          prev_word=(yyval.str);
02917       }
02918    }
02919     break;
02920 
02921   case 70:
02922 
02923 /* Line 1806 of yacc.c  */
02924 #line 440 "ael.y"
02925     { (yyval.str) = (yyvsp[(1) - (1)].str);}
02926     break;
02927 
02928   case 71:
02929 
02930 /* Line 1806 of yacc.c  */
02931 #line 441 "ael.y"
02932     {
02933       if (asprintf(&((yyval.str)), "%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].str)) < 0) {
02934          ast_log(LOG_WARNING, "asprintf() failed\n");
02935          (yyval.str) = NULL;
02936       } else {
02937          free((yyvsp[(1) - (2)].str));
02938          free((yyvsp[(2) - (2)].str));
02939       }
02940    }
02941     break;
02942 
02943   case 72:
02944 
02945 /* Line 1806 of yacc.c  */
02946 #line 450 "ael.y"
02947     {
02948       if (asprintf(&((yyval.str)), "%s:%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)) < 0) {
02949          ast_log(LOG_WARNING, "asprintf() failed\n");
02950          (yyval.str) = NULL;
02951       } else {
02952          free((yyvsp[(1) - (3)].str));
02953          free((yyvsp[(3) - (3)].str));
02954       }
02955    }
02956     break;
02957 
02958   case 73:
02959 
02960 /* Line 1806 of yacc.c  */
02961 #line 461 "ael.y"
02962     {
02963       (yyval.pval) = npval2(PV_SWITCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
02964       (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
02965       (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));}
02966     break;
02967 
02968   case 74:
02969 
02970 /* Line 1806 of yacc.c  */
02971 #line 470 "ael.y"
02972     {
02973       (yyval.pval) = npval2(PV_STATEMENTBLOCK, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
02974       (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));}
02975     break;
02976 
02977   case 75:
02978 
02979 /* Line 1806 of yacc.c  */
02980 #line 473 "ael.y"
02981     { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
02982     break;
02983 
02984   case 76:
02985 
02986 /* Line 1806 of yacc.c  */
02987 #line 474 "ael.y"
02988     { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
02989     break;
02990 
02991   case 77:
02992 
02993 /* Line 1806 of yacc.c  */
02994 #line 475 "ael.y"
02995     {
02996       (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
02997       (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);}
02998     break;
02999 
03000   case 78:
03001 
03002 /* Line 1806 of yacc.c  */
03003 #line 478 "ael.y"
03004     {
03005       (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03006       (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);}
03007     break;
03008 
03009   case 79:
03010 
03011 /* Line 1806 of yacc.c  */
03012 #line 481 "ael.y"
03013     {
03014       (yyval.pval) = npval2(PV_LABEL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
03015       (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str); }
03016     break;
03017 
03018   case 80:
03019 
03020 /* Line 1806 of yacc.c  */
03021 #line 484 "ael.y"
03022     {reset_semicount(parseio->scanner);}
03023     break;
03024 
03025   case 81:
03026 
03027 /* Line 1806 of yacc.c  */
03028 #line 485 "ael.y"
03029     {reset_semicount(parseio->scanner);}
03030     break;
03031 
03032   case 82:
03033 
03034 /* Line 1806 of yacc.c  */
03035 #line 486 "ael.y"
03036     {reset_parencount(parseio->scanner);}
03037     break;
03038 
03039   case 83:
03040 
03041 /* Line 1806 of yacc.c  */
03042 #line 486 "ael.y"
03043     { /* XXX word_list maybe ? */
03044       (yyval.pval) = npval2(PV_FOR, &(yylsp[(1) - (12)]), &(yylsp[(12) - (12)]));
03045       (yyval.pval)->u1.for_init = (yyvsp[(4) - (12)].str);
03046       (yyval.pval)->u2.for_test=(yyvsp[(7) - (12)].str);
03047       (yyval.pval)->u3.for_inc = (yyvsp[(10) - (12)].str);
03048       (yyval.pval)->u4.for_statements = (yyvsp[(12) - (12)].pval); set_dads((yyval.pval),(yyvsp[(12) - (12)].pval));}
03049     break;
03050 
03051   case 84:
03052 
03053 /* Line 1806 of yacc.c  */
03054 #line 492 "ael.y"
03055     {
03056       (yyval.pval) = npval2(PV_WHILE, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03057       (yyval.pval)->u1.str = (yyvsp[(2) - (3)].str);
03058       (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval); set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
03059     break;
03060 
03061   case 85:
03062 
03063 /* Line 1806 of yacc.c  */
03064 #line 496 "ael.y"
03065     { (yyval.pval) = (yyvsp[(1) - (1)].pval); }
03066     break;
03067 
03068   case 86:
03069 
03070 /* Line 1806 of yacc.c  */
03071 #line 497 "ael.y"
03072     { (yyval.pval) = update_last((yyvsp[(2) - (3)].pval), &(yylsp[(2) - (3)])); }
03073     break;
03074 
03075   case 87:
03076 
03077 /* Line 1806 of yacc.c  */
03078 #line 498 "ael.y"
03079     { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); }
03080     break;
03081 
03082   case 88:
03083 
03084 /* Line 1806 of yacc.c  */
03085 #line 499 "ael.y"
03086     {
03087       (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)]));
03088       (yyval.pval)->u1.str = (yyvsp[(1) - (2)].str);}
03089     break;
03090 
03091   case 89:
03092 
03093 /* Line 1806 of yacc.c  */
03094 #line 502 "ael.y"
03095     {reset_semicount(parseio->scanner);}
03096     break;
03097 
03098   case 90:
03099 
03100 /* Line 1806 of yacc.c  */
03101 #line 502 "ael.y"
03102     {
03103       char *bufx;
03104       int tot=0;
03105       pval *pptr;
03106       (yyval.pval) = npval2(PV_VARDEC, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
03107       (yyval.pval)->u2.val=(yyvsp[(4) - (5)].str);
03108       /* rebuild the original string-- this is not an app call, it's an unwrapped vardec, with a func call on the LHS */
03109       /* string to big to fit in the buffer? */
03110       tot+=strlen((yyvsp[(1) - (5)].pval)->u1.str);
03111       for(pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
03112          tot+=strlen(pptr->u1.str);
03113          tot++; /* for a sep like a comma */
03114       }
03115       tot+=4; /* for safety */
03116       bufx = calloc(1, tot);
03117       strcpy(bufx,(yyvsp[(1) - (5)].pval)->u1.str);
03118       strcat(bufx,"(");
03119       /* XXX need to advance the pointer or the loop is very inefficient */
03120       for (pptr=(yyvsp[(1) - (5)].pval)->u2.arglist;pptr;pptr=pptr->next) {
03121          if ( pptr != (yyvsp[(1) - (5)].pval)->u2.arglist )
03122             strcat(bufx,",");
03123          strcat(bufx,pptr->u1.str);
03124       }
03125       strcat(bufx,")");
03126 #ifdef AAL_ARGCHECK
03127       if ( !ael_is_funcname((yyvsp[(1) - (5)].pval)->u1.str) )
03128          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",
03129             my_file, (yylsp[(1) - (5)]).first_line, (yylsp[(1) - (5)]).first_column, (yylsp[(1) - (5)]).last_column, (yyvsp[(1) - (5)].pval)->u1.str);
03130 #endif
03131       (yyval.pval)->u1.str = bufx;
03132       destroy_pval((yyvsp[(1) - (5)].pval)); /* the app call it is not, get rid of that chain */
03133       prev_word = 0;
03134    }
03135     break;
03136 
03137   case 91:
03138 
03139 /* Line 1806 of yacc.c  */
03140 #line 535 "ael.y"
03141     { (yyval.pval) = npval2(PV_BREAK, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
03142     break;
03143 
03144   case 92:
03145 
03146 /* Line 1806 of yacc.c  */
03147 #line 536 "ael.y"
03148     { (yyval.pval) = npval2(PV_RETURN, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
03149     break;
03150 
03151   case 93:
03152 
03153 /* Line 1806 of yacc.c  */
03154 #line 537 "ael.y"
03155     { (yyval.pval) = npval2(PV_CONTINUE, &(yylsp[(1) - (2)]), &(yylsp[(2) - (2)])); }
03156     break;
03157 
03158   case 94:
03159 
03160 /* Line 1806 of yacc.c  */
03161 #line 538 "ael.y"
03162     {
03163       (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(2) - (3)]));
03164       (yyval.pval)->u2.statements = (yyvsp[(2) - (3)].pval); set_dads((yyval.pval),(yyvsp[(2) - (3)].pval));
03165       (yyval.pval)->u3.else_statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
03166     break;
03167 
03168   case 95:
03169 
03170 /* Line 1806 of yacc.c  */
03171 #line 542 "ael.y"
03172     { (yyval.pval)=0; }
03173     break;
03174 
03175   case 96:
03176 
03177 /* Line 1806 of yacc.c  */
03178 #line 545 "ael.y"
03179     { (yyval.pval) = (yyvsp[(2) - (2)].pval); }
03180     break;
03181 
03182   case 97:
03183 
03184 /* Line 1806 of yacc.c  */
03185 #line 546 "ael.y"
03186     { (yyval.pval) = NULL ; }
03187     break;
03188 
03189   case 98:
03190 
03191 /* Line 1806 of yacc.c  */
03192 #line 549 "ael.y"
03193     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
03194     break;
03195 
03196   case 99:
03197 
03198 /* Line 1806 of yacc.c  */
03199 #line 550 "ael.y"
03200     {
03201       (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
03202       (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); }
03203     break;
03204 
03205   case 100:
03206 
03207 /* Line 1806 of yacc.c  */
03208 #line 553 "ael.y"
03209     {
03210       (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
03211       (yyval.pval)->next = nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)])); }
03212     break;
03213 
03214   case 101:
03215 
03216 /* Line 1806 of yacc.c  */
03217 #line 556 "ael.y"
03218     {
03219       (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
03220       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03221       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03222     break;
03223 
03224   case 102:
03225 
03226 /* Line 1806 of yacc.c  */
03227 #line 560 "ael.y"
03228     {
03229       (yyval.pval) = nword((yyvsp[(1) - (5)].str), &(yylsp[(1) - (5)]));
03230       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03231       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03232     break;
03233 
03234   case 103:
03235 
03236 /* Line 1806 of yacc.c  */
03237 #line 564 "ael.y"
03238     {
03239       (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
03240       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03241       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03242     break;
03243 
03244   case 104:
03245 
03246 /* Line 1806 of yacc.c  */
03247 #line 568 "ael.y"
03248     {
03249       (yyval.pval) = nword(strdup("default"), &(yylsp[(1) - (5)]));
03250       (yyval.pval)->next = nword((yyvsp[(3) - (5)].str), &(yylsp[(3) - (5)]));
03251       (yyval.pval)->next->next = nword((yyvsp[(5) - (5)].str), &(yylsp[(5) - (5)])); }
03252     break;
03253 
03254   case 105:
03255 
03256 /* Line 1806 of yacc.c  */
03257 #line 574 "ael.y"
03258     { (yyval.str) = strdup("1"); }
03259     break;
03260 
03261   case 106:
03262 
03263 /* Line 1806 of yacc.c  */
03264 #line 575 "ael.y"
03265     { (yyval.str) = (yyvsp[(2) - (2)].str); }
03266     break;
03267 
03268   case 107:
03269 
03270 /* Line 1806 of yacc.c  */
03271 #line 579 "ael.y"
03272     {       /* ext[, pri] default 1 */
03273       (yyval.pval) = nword((yyvsp[(1) - (2)].str), &(yylsp[(1) - (2)]));
03274       (yyval.pval)->next = nword((yyvsp[(2) - (2)].str), &(yylsp[(2) - (2)])); }
03275     break;
03276 
03277   case 108:
03278 
03279 /* Line 1806 of yacc.c  */
03280 #line 582 "ael.y"
03281     { /* context, ext, pri */
03282       (yyval.pval) = nword((yyvsp[(4) - (4)].str), &(yylsp[(4) - (4)]));
03283       (yyval.pval)->next = nword((yyvsp[(1) - (4)].str), &(yylsp[(1) - (4)]));
03284       (yyval.pval)->next->next = nword((yyvsp[(2) - (4)].str), &(yylsp[(2) - (4)])); }
03285     break;
03286 
03287   case 109:
03288 
03289 /* Line 1806 of yacc.c  */
03290 #line 588 "ael.y"
03291     {reset_argcount(parseio->scanner);}
03292     break;
03293 
03294   case 110:
03295 
03296 /* Line 1806 of yacc.c  */
03297 #line 588 "ael.y"
03298     {
03299       /* XXX original code had @2 but i think we need @5 */
03300       (yyval.pval) = npval2(PV_MACRO_CALL, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
03301       (yyval.pval)->u1.str = (yyvsp[(1) - (5)].str);
03302       (yyval.pval)->u2.arglist = (yyvsp[(4) - (5)].pval);}
03303     break;
03304 
03305   case 111:
03306 
03307 /* Line 1806 of yacc.c  */
03308 #line 593 "ael.y"
03309     {
03310       (yyval.pval)= npval2(PV_MACRO_CALL, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03311       (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str); }
03312     break;
03313 
03314   case 112:
03315 
03316 /* Line 1806 of yacc.c  */
03317 #line 601 "ael.y"
03318     {reset_argcount(parseio->scanner);}
03319     break;
03320 
03321   case 113:
03322 
03323 /* Line 1806 of yacc.c  */
03324 #line 601 "ael.y"
03325     {
03326       if (strcasecmp((yyvsp[(1) - (3)].str),"goto") == 0) {
03327          (yyval.pval) = npval2(PV_GOTO, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
03328          free((yyvsp[(1) - (3)].str)); /* won't be using this */
03329          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 );
03330       } else {
03331          (yyval.pval)= npval2(PV_APPLICATION_CALL, &(yylsp[(1) - (3)]), &(yylsp[(2) - (3)]));
03332          (yyval.pval)->u1.str = (yyvsp[(1) - (3)].str);
03333       } }
03334     break;
03335 
03336   case 114:
03337 
03338 /* Line 1806 of yacc.c  */
03339 #line 612 "ael.y"
03340     {
03341       (yyval.pval) = update_last((yyvsp[(1) - (3)].pval), &(yylsp[(3) - (3)]));
03342       if( (yyval.pval)->type == PV_GOTO )
03343          (yyval.pval)->u1.list = (yyvsp[(2) - (3)].pval);
03344       else
03345          (yyval.pval)->u2.arglist = (yyvsp[(2) - (3)].pval);
03346    }
03347     break;
03348 
03349   case 115:
03350 
03351 /* Line 1806 of yacc.c  */
03352 #line 619 "ael.y"
03353     { (yyval.pval) = update_last((yyvsp[(1) - (2)].pval), &(yylsp[(2) - (2)])); }
03354     break;
03355 
03356   case 116:
03357 
03358 /* Line 1806 of yacc.c  */
03359 #line 622 "ael.y"
03360     { (yyval.str) = (yyvsp[(1) - (1)].str) ;}
03361     break;
03362 
03363   case 117:
03364 
03365 /* Line 1806 of yacc.c  */
03366 #line 623 "ael.y"
03367     { (yyval.str) = strdup(""); }
03368     break;
03369 
03370   case 118:
03371 
03372 /* Line 1806 of yacc.c  */
03373 #line 626 "ael.y"
03374     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
03375     break;
03376 
03377   case 119:
03378 
03379 /* Line 1806 of yacc.c  */
03380 #line 627 "ael.y"
03381     {
03382       (yyval.pval)= npval(PV_WORD,0/*@1.first_line*/,0/*@1.last_line*/,0/* @1.first_column*/, 0/*@1.last_column*/);
03383       (yyval.pval)->u1.str = strdup(""); }
03384     break;
03385 
03386   case 120:
03387 
03388 /* Line 1806 of yacc.c  */
03389 #line 630 "ael.y"
03390     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), nword((yyvsp[(3) - (3)].str), &(yylsp[(3) - (3)]))); }
03391     break;
03392 
03393   case 121:
03394 
03395 /* Line 1806 of yacc.c  */
03396 #line 633 "ael.y"
03397     { (yyval.pval) = NULL; }
03398     break;
03399 
03400   case 122:
03401 
03402 /* Line 1806 of yacc.c  */
03403 #line 634 "ael.y"
03404     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
03405     break;
03406 
03407   case 123:
03408 
03409 /* Line 1806 of yacc.c  */
03410 #line 637 "ael.y"
03411     {
03412       (yyval.pval) = npval2(PV_CASE, &(yylsp[(1) - (4)]), &(yylsp[(3) - (4)])); /* XXX 3 or 4 ? */
03413       (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
03414       (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval); set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));}
03415     break;
03416 
03417   case 124:
03418 
03419 /* Line 1806 of yacc.c  */
03420 #line 641 "ael.y"
03421     {
03422       (yyval.pval) = npval2(PV_DEFAULT, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));
03423       (yyval.pval)->u1.str = NULL;
03424       (yyval.pval)->u2.statements = (yyvsp[(3) - (3)].pval);set_dads((yyval.pval),(yyvsp[(3) - (3)].pval));}
03425     break;
03426 
03427   case 125:
03428 
03429 /* Line 1806 of yacc.c  */
03430 #line 645 "ael.y"
03431     {
03432       (yyval.pval) = npval2(PV_PATTERN, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)])); /* XXX@3 or @4 ? */
03433       (yyval.pval)->u1.str = (yyvsp[(2) - (4)].str);
03434       (yyval.pval)->u2.statements = (yyvsp[(4) - (4)].pval);set_dads((yyval.pval),(yyvsp[(4) - (4)].pval));}
03435     break;
03436 
03437   case 126:
03438 
03439 /* Line 1806 of yacc.c  */
03440 #line 651 "ael.y"
03441     { (yyval.pval) = NULL; }
03442     break;
03443 
03444   case 127:
03445 
03446 /* Line 1806 of yacc.c  */
03447 #line 652 "ael.y"
03448     { (yyval.pval) = linku1((yyvsp[(1) - (2)].pval), (yyvsp[(2) - (2)].pval)); }
03449     break;
03450 
03451   case 128:
03452 
03453 /* Line 1806 of yacc.c  */
03454 #line 655 "ael.y"
03455     {(yyval.pval)=(yyvsp[(1) - (1)].pval);}
03456     break;
03457 
03458   case 129:
03459 
03460 /* Line 1806 of yacc.c  */
03461 #line 656 "ael.y"
03462     { (yyval.pval)=(yyvsp[(1) - (1)].pval);}
03463     break;
03464 
03465   case 130:
03466 
03467 /* Line 1806 of yacc.c  */
03468 #line 657 "ael.y"
03469     {
03470       (yyval.pval) = npval2(PV_CATCH, &(yylsp[(1) - (5)]), &(yylsp[(5) - (5)]));
03471       (yyval.pval)->u1.str = (yyvsp[(2) - (5)].str);
03472       (yyval.pval)->u2.statements = (yyvsp[(4) - (5)].pval); set_dads((yyval.pval),(yyvsp[(4) - (5)].pval));}
03473     break;
03474 
03475   case 131:
03476 
03477 /* Line 1806 of yacc.c  */
03478 #line 663 "ael.y"
03479     {
03480       (yyval.pval) = npval2(PV_SWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
03481       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
03482     break;
03483 
03484   case 132:
03485 
03486 /* Line 1806 of yacc.c  */
03487 #line 668 "ael.y"
03488     {
03489       (yyval.pval) = npval2(PV_ESWITCHES, &(yylsp[(1) - (4)]), &(yylsp[(2) - (4)]));
03490       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval); set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
03491     break;
03492 
03493   case 133:
03494 
03495 /* Line 1806 of yacc.c  */
03496 #line 673 "ael.y"
03497     { (yyval.pval) = NULL; }
03498     break;
03499 
03500   case 134:
03501 
03502 /* Line 1806 of yacc.c  */
03503 #line 674 "ael.y"
03504     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval),nword((yyvsp[(2) - (3)].str), &(yylsp[(2) - (3)]))); }
03505     break;
03506 
03507   case 135:
03508 
03509 /* Line 1806 of yacc.c  */
03510 #line 675 "ael.y"
03511     {
03512      char *x;
03513      if (asprintf(&x,"%s@%s", (yyvsp[(2) - (5)].str), (yyvsp[(4) - (5)].str)) < 0) {
03514       ast_log(LOG_WARNING, "asprintf() failed\n");
03515       (yyval.pval) = NULL;
03516      } else {
03517       free((yyvsp[(2) - (5)].str));
03518       free((yyvsp[(4) - (5)].str));
03519       (yyval.pval) = linku1((yyvsp[(1) - (5)].pval),nword(x, &(yylsp[(2) - (5)])));
03520      }
03521    }
03522     break;
03523 
03524   case 136:
03525 
03526 /* Line 1806 of yacc.c  */
03527 #line 686 "ael.y"
03528     {(yyval.pval)=(yyvsp[(2) - (2)].pval);}
03529     break;
03530 
03531   case 137:
03532 
03533 /* Line 1806 of yacc.c  */
03534 #line 689 "ael.y"
03535     { (yyval.pval) = nword((yyvsp[(1) - (1)].str), &(yylsp[(1) - (1)])); }
03536     break;
03537 
03538   case 138:
03539 
03540 /* Line 1806 of yacc.c  */
03541 #line 690 "ael.y"
03542     {
03543       (yyval.pval) = nword((yyvsp[(1) - (3)].str), &(yylsp[(1) - (3)]));
03544       (yyval.pval)->u2.arglist = (yyvsp[(3) - (3)].pval);
03545       prev_word=0; /* XXX sure ? */ }
03546     break;
03547 
03548   case 139:
03549 
03550 /* Line 1806 of yacc.c  */
03551 #line 697 "ael.y"
03552     { (yyval.pval) = (yyvsp[(1) - (2)].pval); }
03553     break;
03554 
03555   case 140:
03556 
03557 /* Line 1806 of yacc.c  */
03558 #line 698 "ael.y"
03559     { (yyval.pval) = linku1((yyvsp[(1) - (3)].pval), (yyvsp[(2) - (3)].pval)); }
03560     break;
03561 
03562   case 141:
03563 
03564 /* Line 1806 of yacc.c  */
03565 #line 699 "ael.y"
03566     {(yyval.pval)=(yyvsp[(1) - (2)].pval);}
03567     break;
03568 
03569   case 142:
03570 
03571 /* Line 1806 of yacc.c  */
03572 #line 702 "ael.y"
03573     {
03574       (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (4)]), &(yylsp[(4) - (4)]));
03575       (yyval.pval)->u1.list = (yyvsp[(3) - (4)].pval);set_dads((yyval.pval),(yyvsp[(3) - (4)].pval));}
03576     break;
03577 
03578   case 143:
03579 
03580 /* Line 1806 of yacc.c  */
03581 #line 705 "ael.y"
03582     {
03583       (yyval.pval) = npval2(PV_INCLUDES, &(yylsp[(1) - (3)]), &(yylsp[(3) - (3)]));}
03584     break;
03585 
03586 
03587 
03588 /* Line 1806 of yacc.c  */
03589 #line 3590 "ael.tab.c"
03590       default: break;
03591     }
03592   /* User semantic actions sometimes alter yychar, and that requires
03593      that yytoken be updated with the new translation.  We take the
03594      approach of translating immediately before every use of yytoken.
03595      One alternative is translating here after every semantic action,
03596      but that translation would be missed if the semantic action invokes
03597      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
03598      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
03599      incorrect destructor might then be invoked immediately.  In the
03600      case of YYERROR or YYBACKUP, subsequent parser actions might lead
03601      to an incorrect destructor call or verbose syntax error message
03602      before the lookahead is translated.  */
03603   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
03604 
03605   YYPOPSTACK (yylen);
03606   yylen = 0;
03607   YY_STACK_PRINT (yyss, yyssp);
03608 
03609   *++yyvsp = yyval;
03610   *++yylsp = yyloc;
03611 
03612   /* Now `shift' the result of the reduction.  Determine what state
03613      that goes to, based on the state we popped back to and the rule
03614      number reduced by.  */
03615 
03616   yyn = yyr1[yyn];
03617 
03618   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
03619   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
03620     yystate = yytable[yystate];
03621   else
03622     yystate = yydefgoto[yyn - YYNTOKENS];
03623 
03624   goto yynewstate;
03625 
03626 
03627 /*------------------------------------.
03628 | yyerrlab -- here on detecting error |
03629 `------------------------------------*/
03630 yyerrlab:
03631   /* Make sure we have latest lookahead translation.  See comments at
03632      user semantic actions for why this is necessary.  */
03633   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
03634 
03635   /* If not already recovering from an error, report this error.  */
03636   if (!yyerrstatus)
03637     {
03638       ++yynerrs;
03639 #if ! YYERROR_VERBOSE
03640       yyerror (&yylloc, parseio, YY_("syntax error"));
03641 #else
03642 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
03643                                         yyssp, yytoken)
03644       {
03645         char const *yymsgp = YY_("syntax error");
03646         int yysyntax_error_status;
03647         yysyntax_error_status = YYSYNTAX_ERROR;
03648         if (yysyntax_error_status == 0)
03649           yymsgp = yymsg;
03650         else if (yysyntax_error_status == 1)
03651           {
03652             if (yymsg != yymsgbuf)
03653               YYSTACK_FREE (yymsg);
03654             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
03655             if (!yymsg)
03656               {
03657                 yymsg = yymsgbuf;
03658                 yymsg_alloc = sizeof yymsgbuf;
03659                 yysyntax_error_status = 2;
03660               }
03661             else
03662               {
03663                 yysyntax_error_status = YYSYNTAX_ERROR;
03664                 yymsgp = yymsg;
03665               }
03666           }
03667         yyerror (&yylloc, parseio, yymsgp);
03668         if (yysyntax_error_status == 2)
03669           goto yyexhaustedlab;
03670       }
03671 # undef YYSYNTAX_ERROR
03672 #endif
03673     }
03674 
03675   yyerror_range[1] = yylloc;
03676 
03677   if (yyerrstatus == 3)
03678     {
03679       /* If just tried and failed to reuse lookahead token after an
03680     error, discard it.  */
03681 
03682       if (yychar <= YYEOF)
03683    {
03684      /* Return failure if at end of input.  */
03685      if (yychar == YYEOF)
03686        YYABORT;
03687    }
03688       else
03689    {
03690      yydestruct ("Error: discarding",
03691             yytoken, &yylval, &yylloc, parseio);
03692      yychar = YYEMPTY;
03693    }
03694     }
03695 
03696   /* Else will try to reuse lookahead token after shifting the error
03697      token.  */
03698   goto yyerrlab1;
03699 
03700 
03701 /*---------------------------------------------------.
03702 | yyerrorlab -- error raised explicitly by YYERROR.  |
03703 `---------------------------------------------------*/
03704 yyerrorlab:
03705 
03706   /* Pacify compilers like GCC when the user code never invokes
03707      YYERROR and the label yyerrorlab therefore never appears in user
03708      code.  */
03709   if (/*CONSTCOND*/ 0)
03710      goto yyerrorlab;
03711 
03712   yyerror_range[1] = yylsp[1-yylen];
03713   /* Do not reclaim the symbols of the rule which action triggered
03714      this YYERROR.  */
03715   YYPOPSTACK (yylen);
03716   yylen = 0;
03717   YY_STACK_PRINT (yyss, yyssp);
03718   yystate = *yyssp;
03719   goto yyerrlab1;
03720 
03721 
03722 /*-------------------------------------------------------------.
03723 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
03724 `-------------------------------------------------------------*/
03725 yyerrlab1:
03726   yyerrstatus = 3;   /* Each real token shifted decrements this.  */
03727 
03728   for (;;)
03729     {
03730       yyn = yypact[yystate];
03731       if (!yypact_value_is_default (yyn))
03732    {
03733      yyn += YYTERROR;
03734      if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
03735        {
03736          yyn = yytable[yyn];
03737          if (0 < yyn)
03738       break;
03739        }
03740    }
03741 
03742       /* Pop the current state because it cannot handle the error token.  */
03743       if (yyssp == yyss)
03744    YYABORT;
03745 
03746       yyerror_range[1] = *yylsp;
03747       yydestruct ("Error: popping",
03748         yystos[yystate], yyvsp, yylsp, parseio);
03749       YYPOPSTACK (1);
03750       yystate = *yyssp;
03751       YY_STACK_PRINT (yyss, yyssp);
03752     }
03753 
03754   *++yyvsp = yylval;
03755 
03756   yyerror_range[2] = yylloc;
03757   /* Using YYLLOC is tempting, but would change the location of
03758      the lookahead.  YYLOC is available though.  */
03759   YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
03760   *++yylsp = yyloc;
03761 
03762   /* Shift the error token.  */
03763   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
03764 
03765   yystate = yyn;
03766   goto yynewstate;
03767 
03768 
03769 /*-------------------------------------.
03770 | yyacceptlab -- YYACCEPT comes here.  |
03771 `-------------------------------------*/
03772 yyacceptlab:
03773   yyresult = 0;
03774   goto yyreturn;
03775 
03776 /*-----------------------------------.
03777 | yyabortlab -- YYABORT comes here.  |
03778 `-----------------------------------*/
03779 yyabortlab:
03780   yyresult = 1;
03781   goto yyreturn;
03782 
03783 #if !defined(yyoverflow) || YYERROR_VERBOSE
03784 /*-------------------------------------------------.
03785 | yyexhaustedlab -- memory exhaustion comes here.  |
03786 `-------------------------------------------------*/
03787 yyexhaustedlab:
03788   yyerror (&yylloc, parseio, YY_("memory exhausted"));
03789   yyresult = 2;
03790   /* Fall through.  */
03791 #endif
03792 
03793 yyreturn:
03794   if (yychar != YYEMPTY)
03795     {
03796       /* Make sure we have latest lookahead translation.  See comments at
03797          user semantic actions for why this is necessary.  */
03798       yytoken = YYTRANSLATE (yychar);
03799       yydestruct ("Cleanup: discarding lookahead",
03800                   yytoken, &yylval, &yylloc, parseio);
03801     }
03802   /* Do not reclaim the symbols of the rule which action triggered
03803      this YYABORT or YYACCEPT.  */
03804   YYPOPSTACK (yylen);
03805   YY_STACK_PRINT (yyss, yyssp);
03806   while (yyssp != yyss)
03807     {
03808       yydestruct ("Cleanup: popping",
03809         yystos[*yyssp], yyvsp, yylsp, parseio);
03810       YYPOPSTACK (1);
03811     }
03812 #ifndef yyoverflow
03813   if (yyss != yyssa)
03814     YYSTACK_FREE (yyss);
03815 #endif
03816 #if YYERROR_VERBOSE
03817   if (yymsg != yymsgbuf)
03818     YYSTACK_FREE (yymsg);
03819 #endif
03820   /* Make sure YYID is used.  */
03821   return YYID (yyresult);
03822 }
03823 
03824 
03825 
03826 /* Line 2067 of yacc.c  */
03827 #line 710 "ael.y"
03828 
03829 
03830 static char *token_equivs1[] =
03831 {
03832    "AMPER",
03833    "AT",
03834    "BAR",
03835    "COLON",
03836    "COMMA",
03837    "EQ",
03838    "EXTENMARK",
03839    "KW_BREAK",
03840    "KW_CASE",
03841    "KW_CATCH",
03842    "KW_CONTEXT",
03843    "KW_CONTINUE",
03844    "KW_DEFAULT",
03845    "KW_ELSE",
03846    "KW_ESWITCHES",
03847    "KW_FOR",
03848    "KW_GLOBALS",
03849    "KW_GOTO",
03850    "KW_HINT",
03851    "KW_IFTIME",
03852    "KW_IF",
03853    "KW_IGNOREPAT",
03854    "KW_INCLUDES"
03855    "KW_JUMP",
03856    "KW_MACRO",
03857    "KW_PATTERN",
03858    "KW_REGEXTEN",
03859    "KW_RETURN",
03860    "KW_SWITCHES",
03861    "KW_SWITCH",
03862    "KW_WHILE",
03863    "LC",
03864    "LP",
03865    "RC",
03866    "RP",
03867    "SEMI",
03868 };
03869 
03870 static char *token_equivs2[] =
03871 {
03872    "&",
03873    "@",
03874    "|",
03875    ":",
03876    ",",
03877    "=",
03878    "=>",
03879    "break",
03880    "case",
03881    "catch",
03882    "context",
03883    "continue",
03884    "default",
03885    "else",
03886    "eswitches",
03887    "for",
03888    "globals",
03889    "goto",
03890    "hint",
03891    "ifTime",
03892    "if",
03893    "ignorepat",
03894    "includes"
03895    "jump",
03896    "macro",
03897    "pattern",
03898    "regexten",
03899    "return",
03900    "switches",
03901    "switch",
03902    "while",
03903    "{",
03904    "(",
03905    "}",
03906    ")",
03907    ";",
03908 };
03909 
03910 
03911 static char *ael_token_subst(const char *mess)
03912 {
03913    /* calc a length, malloc, fill, and return; yyerror had better free it! */
03914    int len=0,i;
03915    const char *p;
03916    char *res, *s,*t;
03917    int token_equivs_entries = sizeof(token_equivs1)/sizeof(char*);
03918 
03919    for (p=mess; *p; p++) {
03920       for (i=0; i<token_equivs_entries; i++) {
03921          if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 )
03922          {
03923             len+=strlen(token_equivs2[i])+2;
03924             p += strlen(token_equivs1[i])-1;
03925             break;
03926          }
03927       }
03928       len++;
03929    }
03930    res = calloc(1, len+1);
03931    res[0] = 0;
03932    s = res;
03933    for (p=mess; *p;) {
03934       int found = 0;
03935       for (i=0; i<token_equivs_entries; i++) {
03936          if ( strncmp(p,token_equivs1[i],strlen(token_equivs1[i])) == 0 ) {
03937             *s++ = '\'';
03938             for (t=token_equivs2[i]; *t;) {
03939                *s++ = *t++;
03940             }
03941             *s++ = '\'';
03942             p += strlen(token_equivs1[i]);
03943             found = 1;
03944             break;
03945          }
03946       }
03947       if( !found )
03948          *s++ = *p++;
03949    }
03950    *s++ = 0;
03951    return res;
03952 }
03953 
03954 void yyerror(YYLTYPE *locp, struct parse_io *parseio,  char const *s)
03955 {
03956    char *s2 = ael_token_subst((char *)s);
03957    if (locp->first_line == locp->last_line) {
03958       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);
03959    } else {
03960       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);
03961    }
03962    free(s2);
03963    parseio->syntax_error_count++;
03964 }
03965 
03966 struct pval *npval(pvaltype type, int first_line, int last_line,
03967    int first_column, int last_column)
03968 {
03969    pval *z = calloc(1, sizeof(struct pval));
03970    z->type = type;
03971    z->startline = first_line;
03972    z->endline = last_line;
03973    z->startcol = first_column;
03974    z->endcol = last_column;
03975    z->filename = strdup(S_OR(my_file, "<none>"));
03976    return z;
03977 }
03978 
03979 static struct pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last)
03980 {
03981    return npval(type, first->first_line, last->last_line,
03982          first->first_column, last->last_column);
03983 }
03984 
03985 static struct pval *update_last(pval *obj, YYLTYPE *last)
03986 {
03987    obj->endline = last->last_line;
03988    obj->endcol = last->last_column;
03989    return obj;
03990 }
03991 
03992 /* frontend for npval to create a PV_WORD string from the given token */
03993 static pval *nword(char *string, YYLTYPE *pos)
03994 {
03995    pval *p = npval2(PV_WORD, pos, pos);
03996    if (p)
03997       p->u1.str = string;
03998    return p;
03999 }
04000 
04001 /* this routine adds a dad ptr to each element in the list */
04002 static void set_dads(struct pval *dad, struct pval *child_list)
04003 {
04004    struct pval *t;
04005    
04006    for(t=child_list;t;t=t->next)  /* simple stuff */
04007       t->dad = dad;
04008 }
04009 
04010 

Generated on 7 Aug 2019 for Asterisk - The Open Source Telephony Project by  doxygen 1.6.1