[svn-commits] murf: branch murf/AEL2-1.2 r48454 -
/team/murf/AEL2-1.2/
svn-commits at lists.digium.com
svn-commits at lists.digium.com
Wed Dec 13 11:08:37 MST 2006
Author: murf
Date: Wed Dec 13 12:08:36 2006
New Revision: 48454
URL: http://svn.digium.com/view/asterisk?view=rev&rev=48454
Log:
Let's make a patch available for poor users, instead of downloading the entire source, and **maybe** getting a useful diff from 1.2.
Added:
team/murf/AEL2-1.2/diffs.AEL2.patch (with props)
team/murf/AEL2-1.2/update-patch (with props)
Added: team/murf/AEL2-1.2/diffs.AEL2.patch
URL: http://svn.digium.com/view/asterisk/team/murf/AEL2-1.2/diffs.AEL2.patch?view=auto&rev=48454
==============================================================================
--- team/murf/AEL2-1.2/diffs.AEL2.patch (added)
+++ team/murf/AEL2-1.2/diffs.AEL2.patch Wed Dec 13 12:08:36 2006
@@ -1,0 +1,38413 @@
+Index: pbx/argdesc.y
+===================================================================
+--- pbx/argdesc.y (.../branches/1.2) (revision 0)
++++ pbx/argdesc.y (.../team/murf/AEL2-1.2) (revision 48453)
+@@ -0,0 +1,268 @@
++%{
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include "asterisk/argdesc.h"
++#include "asterisk/logger.h"
++
++#define YYPARSE_PARAM parseio
++#define YYLEX_PARAM ((struct parse_arginfo *)parseio)->scanner
++#define YYERROR_VERBOSE 1
++/* this stuff is included so I can declare the proto for yyerror */
++#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
++
++typedef struct YYLTYPE
++{
++ int first_line;
++ int first_column;
++ int last_line;
++ int last_column;
++} YYLTYPE;
++
++# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
++# define YYLTYPE_IS_DECLARED 1
++# define YYLTYPE_IS_TRIVIAL 1
++#endif
++#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
++typedef union YYSTYPE {
++ char *str;
++ struct argapp *argapp;
++ struct argdesc *argdesc;
++ struct appsetvar *appsetvar;
++ struct argchoice *argchoice;
++} YYSTYPE;
++# define yystype YYSTYPE /* obsolescent; will be withdrawn */
++# define YYSTYPE_IS_DECLARED 1
++# define YYSTYPE_IS_TRIVIAL 1
++#endif
++
++ static int errcnt = 0;
++
++void yyerror(YYLTYPE *locp,void *nothing, char const *s);
++int argdesc_yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , void * yyscanner);
++void linkarg(struct argdesc *head, struct argdesc *tail);
++static void argdesc_destroy_argdesc(struct argdesc *desc);
++static void argdesc_destroy_appsetvar(struct appsetvar *var);
++static void argdesc_destroy_argchoice(struct argchoice *choice);
++static void argdesc_destroy_argapp(struct argapp *app);
++
++%}
++
++
++%union {
++ char *str;
++ struct argapp *argapp;
++ struct argdesc *argdesc;
++ struct appsetvar *appsetvar;
++ struct argchoice *argchoice;
++}
++
++
++%token SEMI COMMA BAR EQ LP RP LB RB LAB RAB COLON LC RC ELLIPSES
++%token KW_ARGS KW_OPTIONS KW_CHANVARS intspec fltspec strspec
++
++%token <str> word str1
++
++%type <argapp> file appentries appentry
++%type <argdesc> arglist argdeclist argdec argspec
++%type <appsetvar> varlist varspec varspeclist
++%type <argchoice> choicelist vallist optionslist optionspeclist optionspec
++
++/* OPTIONS */
++%locations
++%pure-parser
++%name-prefix="argdesc_yy"
++/* the following option does two things:
++ it adds the locp arg to the yyerror
++ and it adds the NULL to the yyerrr arg list, and calls yyerror with NULL for that arg.
++ You can't get the locp arg without the NULL arg, don't ask me why. */
++%parse-param {void *NULL}
++
++%error-verbose
++
++%%
++
++file : appentries {((struct parse_arginfo *)parseio)->apps = $$; ((struct parse_arginfo *)parseio)->syntax_error_count = errcnt;}
++ ;
++
++appentries: appentry {$$=$1;}
++ | appentries appentry {$2->next = $1; $$ = $2; }
++ ;
++
++appentry: word COLON str1 SEMI arglist optionslist varlist {
++ $$=(struct argapp *)calloc(sizeof(struct argapp),1);
++ $$->name = $1;
++ $$->desc = $3;
++ $$->args = $5;
++ $$->opts = $6;
++ $$->setvars = $7;
++ }
++ ;
++
++arglist : /* nothing */ {$$=0;}
++ | KW_ARGS EQ argdeclist SEMI {$$=$3;}
++ ;
++
++argdeclist : argdec {$$=$1;}
++ | argdeclist BAR argdec {$$=$1; linkarg($$,$3);}
++ ;
++
++argdec : argspec {$$=$1; $$->type=ARGD_REQUIRED;}
++ | LB argspec RB {$$=$2; $$->type=ARGD_OPTIONAL;}
++ | LB COLON argspec RB {$$=$3; $$->type=ARGD_OPTIONAL_PREV;}
++ | LC argspec RC {$$=$2; $$->type=ARGD_OPTIONAL_PLACEHOLD;}
++ ;
++argspec : word {$$=(struct argdesc*)calloc(sizeof(struct argdesc),1); $$->name=$1;$$->dtype=ARGD_STRING;}
++ | word intspec {$$=(struct argdesc*)calloc(sizeof(struct argdesc),1); $$->name=$1; $$->dtype=ARGD_INT;}
++ | word strspec {$$=(struct argdesc*)calloc(sizeof(struct argdesc),1); $$->name=$1;$$->dtype=ARGD_STRING;}
++ | word fltspec {$$=(struct argdesc*)calloc(sizeof(struct argdesc),1); $$->name=$1;$$->dtype=ARGD_FLOAT;}
++ | ELLIPSES {$$=(struct argdesc*)calloc(sizeof(struct argdesc),1); $$->name=0;$$->dtype=ARGD_VARARG;}
++ | KW_OPTIONS {$$=(struct argdesc*)calloc(sizeof(struct argdesc),1); $$->name=0;$$->dtype=ARGD_OPTIONSET;}
++ | LAB word COLON choicelist RAB {$$=(struct argdesc*)calloc(sizeof(struct argdesc),1); $$->name=$2;$$->dtype=ARGD_ENUM;$$->choices = $4;}
++ ;
++
++choicelist : word {$$=(struct argchoice*)calloc(sizeof(struct argchoice),1); $$->name=$1;}
++ | choicelist COMMA word {$$=(struct argchoice*)calloc(sizeof(struct argchoice),1); $$->name=$3; $$->next = $1;}
++ ;
++
++optionslist : KW_OPTIONS EQ optionspeclist SEMI {$$=$3;}
++ | /* nothing */ {$$=0;}
++ ;
++
++optionspeclist : optionspec {$$=$1;}
++ | optionspeclist COMMA optionspec {$$=$3; $3->next = $1; }
++ ;
++
++optionspec : word {$$ = (struct argchoice *)calloc(sizeof(struct argchoice),1); $$->name=$1; $$->opttype=ARGD_OPT_NOARG;}
++ | word LP RP {$$ = (struct argchoice *)calloc(sizeof(struct argchoice),1); $$->name=$1; $$->opttype=ARGD_OPT_WITHARG;}
++ | word LB LP RP RB {$$ = (struct argchoice *)calloc(sizeof(struct argchoice),1); $$->name=$1; $$->opttype=ARGD_OPT_WITHOPTARG;}
++ ;
++
++
++varlist : /* nothing */ {$$=0;}
++ | KW_CHANVARS EQ varspeclist SEMI {$$=$3;}
++ ;
++
++varspeclist : varspec {$$=$1;}
++ | varspeclist COMMA varspec {$$ = $3; $$->next = $1;}
++ ;
++
++varspec : word {$$=(struct appsetvar*)calloc(sizeof(struct appsetvar),1); $$->name=$1;}
++ | word COLON vallist {$$=(struct appsetvar*)calloc(sizeof(struct appsetvar),1); $$->name=$1; $$->vals=$3;}
++ ;
++
++vallist : word {$$=(struct argchoice*)calloc(sizeof(struct argchoice),1); $$->name=$1; }
++ | vallist BAR word {$$=(struct argchoice*)calloc(sizeof(struct argchoice),1); $$->name=$3; $$->next = $1; }
++ ;
++
++
++%%
++
++void yyerror(YYLTYPE *locp, void *nothing, char const *s)
++{
++
++ if (locp->first_line == locp->last_line) {
++ ast_log(LOG_ERROR, "==== Line %d, Cols: %d-%d: Error: %s\n", locp->first_line, locp->first_column, locp->last_column, s);
++ } else {
++ ast_log(LOG_ERROR, "==== Line %d Col %d to Line %d Col %d: Error: %s\n", locp->first_line, locp->first_column, locp->last_line, locp->last_column, s);
++ }
++ errcnt++;
++}
++
++void linkarg(struct argdesc *head, struct argdesc *tail)
++{
++ if (!head->next) {
++ head->next = tail;
++ head->last_args = tail;
++ } else {
++ head->last_args->next = tail;
++ head->last_args = tail;
++ }
++}
++
++static void argdesc_destroy_argdesc(struct argdesc *desc)
++{
++ struct argchoice *c, *cn;
++ if (desc->name)
++ free(desc->name);
++ for(c=desc->choices; c;) {
++ cn = c->next;
++ argdesc_destroy_argchoice(c);
++ c = cn;
++ }
++ desc->name = 0;
++ desc->choices = 0;
++ desc->next = 0;
++ free(desc);
++}
++
++static void argdesc_destroy_appsetvar(struct appsetvar *var)
++{
++ struct argchoice *c, *cn;
++ if (var->name)
++ free(var->name);
++ for (c=var->vals; c;) {
++ cn = c->next;
++ argdesc_destroy_argchoice(c);
++ c = cn;
++ }
++ var->name = 0;
++ var->vals = 0;
++ var->next = 0;
++ free(var);
++}
++
++static void argdesc_destroy_argchoice(struct argchoice *choice)
++{
++ if( choice->name )
++ free( choice->name);
++ choice->name = 0;
++ choice->next = 0;
++ free(choice);
++}
++
++
++static void argdesc_destroy_argapp(struct argapp *app)
++{
++ struct argdesc *d,*dn;
++ struct appsetvar *v, *vn;
++ struct argchoice *c, *cn;
++
++ for (d=app->args; d; ) {
++ dn = d->next;
++ argdesc_destroy_argdesc(d);
++ d = dn;
++ }
++ for (v=app->setvars; v;) {
++ vn = v->next;
++ argdesc_destroy_appsetvar(v);
++ v = vn;
++ }
++ for(c=app->opts; c;) {
++ cn = c->next;
++ argdesc_destroy_argchoice(c);
++ c = cn;
++ }
++ if (app->name)
++ free(app->name);
++ if (app->desc)
++ free(app->desc);
++ app->name = 0;
++ app->desc = 0;
++ app->next = 0;
++ app->args = 0;
++ app->setvars = 0;
++ app->opts = 0;
++ free(app);
++}
++
++void argdesc_destroy(struct argapp *apps)
++{
++ struct argapp *p,*pn;
++
++ for (p=apps; p; ) {
++ pn = p->next;
++ argdesc_destroy_argapp(p);
++ p = pn;
++ }
++}
+
+Property changes on: pbx/argdesc.y
+___________________________________________________________________
+Name: svn:eol-style
+ + native
+Name: svn:mime-type
+ + text/plain
+Name: svn:keywords
+ + Author Date Id Revision
+
+Index: pbx/ael.tab.c
+===================================================================
+--- pbx/ael.tab.c (.../branches/1.2) (revision 0)
++++ pbx/ael.tab.c (.../team/murf/AEL2-1.2) (revision 48453)
+@@ -0,0 +1,3334 @@
++/* A Bison parser, made by GNU Bison 2.1a. */
++
++/* Skeleton parser for Yacc-like parsing with Bison,
++ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
++
++ This program is free software; you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation; either version 2, or (at your option)
++ any later version.
++
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++
++ You should have received a copy of the GNU General Public License
++ along with this program; if not, write to the Free Software
++ Foundation, Inc., 51 Franklin Street, Fifth Floor,
++ Boston, MA 02110-1301, USA. */
++
++/* As a special exception, when this file is copied by Bison into a
++ Bison output file, you may use that output file without restriction.
++ This special exception was added by the Free Software Foundation
++ in version 1.24 of Bison. */
++
++/* C LALR(1) parser skeleton written by Richard Stallman, by
++ simplifying the original so-called "semantic" parser. */
++
++/* All symbols defined below should begin with yy or YY, to avoid
++ infringing on user name space. This should be done even for local
++ variables, as they might otherwise be expanded by user macros.
++ There are some unavoidable exceptions within include files to
++ define necessary library symbols; they are noted "INFRINGES ON
++ USER NAME SPACE" below. */
++
++/* Identify Bison output. */
++#define YYBISON 1
++
++/* Bison version. */
++#define YYBISON_VERSION "2.1a"
++
++/* Skeleton name. */
++#define YYSKELETON_NAME "yacc.c"
++
++/* Pure parsers. */
++#define YYPURE 1
++
++/* Using locations. */
++#define YYLSP_NEEDED 1
++
++/* Substitute the variable and function names. */
++#define yyparse ael_yyparse
++#define yylex ael_yylex
++#define yyerror ael_yyerror
++#define yylval ael_yylval
++#define yychar ael_yychar
++#define yydebug ael_yydebug
++#define yynerrs ael_yynerrs
++#define yylloc ael_yylloc
++
++/* Tokens. */
++#ifndef YYTOKENTYPE
++# define YYTOKENTYPE
++ /* Put the tokens into the symbol table, so that GDB and other debuggers
++ know about them. */
++ enum yytokentype {
++ KW_CONTEXT = 258,
++ LC = 259,
++ RC = 260,
++ LP = 261,
++ RP = 262,
++ SEMI = 263,
++ EQ = 264,
++ COMMA = 265,
++ COLON = 266,
++ AMPER = 267,
++ BAR = 268,
++ AT = 269,
++ KW_MACRO = 270,
++ KW_GLOBALS = 271,
++ KW_IGNOREPAT = 272,
++ KW_SWITCH = 273,
++ KW_IF = 274,
++ KW_IFTIME = 275,
++ KW_ELSE = 276,
++ KW_RANDOM = 277,
++ KW_ABSTRACT = 278,
++ EXTENMARK = 279,
++ KW_GOTO = 280,
++ KW_JUMP = 281,
++ KW_RETURN = 282,
++ KW_BREAK = 283,
++ KW_CONTINUE = 284,
++ KW_REGEXTEN = 285,
++ KW_HINT = 286,
++ KW_FOR = 287,
++ KW_WHILE = 288,
++ KW_CASE = 289,
++ KW_PATTERN = 290,
++ KW_DEFAULT = 291,
++ KW_CATCH = 292,
++ KW_SWITCHES = 293,
++ KW_ESWITCHES = 294,
++ KW_INCLUDES = 295,
++ word = 296
++ };
++#endif
++/* Tokens. */
++#define KW_CONTEXT 258
++#define LC 259
++#define RC 260
++#define LP 261
++#define RP 262
++#define SEMI 263
++#define EQ 264
++#define COMMA 265
++#define COLON 266
++#define AMPER 267
++#define BAR 268
++#define AT 269
++#define KW_MACRO 270
++#define KW_GLOBALS 271
++#define KW_IGNOREPAT 272
++#define KW_SWITCH 273
++#define KW_IF 274
++#define KW_IFTIME 275
++#define KW_ELSE 276
++#define KW_RANDOM 277
++#define KW_ABSTRACT 278
++#define EXTENMARK 279
++#define KW_GOTO 280
++#define KW_JUMP 281
++#define KW_RETURN 282
++#define KW_BREAK 283
++#define KW_CONTINUE 284
++#define KW_REGEXTEN 285
++#define KW_HINT 286
++#define KW_FOR 287
++#define KW_WHILE 288
++#define KW_CASE 289
++#define KW_PATTERN 290
++#define KW_DEFAULT 291
++#define KW_CATCH 292
++#define KW_SWITCHES 293
++#define KW_ESWITCHES 294
++#define KW_INCLUDES 295
++#define word 296
++
++
++
++
++/* Copy the first part of user declarations. */
++#line 1 "ael.y"
++
++/*
++ * Asterisk -- An open source telephony toolkit.
++ *
++ * Copyright (C) 2006, Digium, Inc.
++ *
++ * Steve Murphy <murf at parsetree.com>
++ *
++ * See http://www.asterisk.org for more information about
++ * the Asterisk project. Please do not directly contact
++ * any of the maintainers of this project for assistance;
++ * the project provides a web site, mailing lists and IRC
++ * channels for your use.
++ *
++ * This program is free software, distributed under the terms of
++ * the GNU General Public License Version 2. See the LICENSE file
++ * at the top of the source tree.
++ */
++/*! \file
++ *
++ * \brief Bison Grammar description of AEL2.
++ *
++ */
++
++#include "asterisk.h"
++
++ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++
++#include "asterisk/logger.h"
++#include "asterisk/ael_structs.h"
++
++static pval * linku1(pval *head, pval *tail);
++static void set_dads(pval *dad, pval *child_list);
++void reset_parencount(yyscan_t yyscanner);
++void reset_semicount(yyscan_t yyscanner);
++void reset_argcount(yyscan_t yyscanner );
++
++#define YYLEX_PARAM ((struct parse_io *)parseio)->scanner
++#define YYERROR_VERBOSE 1
++
++extern char *my_file;
++#ifdef AAL_ARGCHECK
++int ael_is_funcname(char *name);
++#endif
++static char *ael_token_subst(char *mess);
++
++
++
++/* Enabling traces. */
++#ifndef YYDEBUG
++# define YYDEBUG 0
++#endif
++
++/* Enabling verbose error messages. */
++#ifdef YYERROR_VERBOSE
++# undef YYERROR_VERBOSE
++# define YYERROR_VERBOSE 1
++#else
++# define YYERROR_VERBOSE 1
++#endif
++
++/* Enabling the token table. */
++#ifndef YYTOKEN_TABLE
++# define YYTOKEN_TABLE 0
++#endif
++
++#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
++typedef union YYSTYPE
++#line 54 "ael.y"
++{
++ int intval; /* integer value, typically flags */
++ char *str; /* strings */
++ struct pval *pval; /* full objects */
++}
++/* Line 198 of yacc.c. */
++#line 234 "ael.tab.c"
++ YYSTYPE;
++# define yystype YYSTYPE /* obsolescent; will be withdrawn */
++# define YYSTYPE_IS_DECLARED 1
++# define YYSTYPE_IS_TRIVIAL 1
++#endif
++
++#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
++typedef struct YYLTYPE
++{
++ int first_line;
++ int first_column;
++ int last_line;
++ int last_column;
++} YYLTYPE;
++# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
++# define YYLTYPE_IS_DECLARED 1
++# define YYLTYPE_IS_TRIVIAL 1
++#endif
++
++
++/* Copy the second part of user declarations. */
++#line 60 "ael.y"
++
++ /* declaring these AFTER the union makes things a lot simpler! */
++void yyerror(YYLTYPE *locp, struct parse_io *parseio, char const *s);
++int ael_yylex (YYSTYPE * yylval_param, YYLTYPE * yylloc_param , void * yyscanner);
++
++/* create a new object with start-end marker */
++static pval *npval(pvaltype type, int first_line, int last_line,
++ int first_column, int last_column);
++
++/* create a new object with start-end marker, simplified interface.
++ * Must be declared here because YYLTYPE is not known before
++ */
++static pval *npval2(pvaltype type, YYLTYPE *first, YYLTYPE *last);
++
++/* another frontend for npval, this time for a string */
++static pval *nword(char *string, YYLTYPE *pos);
++
++/* update end position of an object, return the object */
++static pval *update_last(pval *, YYLTYPE *);
++
++
++/* Line 221 of yacc.c. */
++#line 279 "ael.tab.c"
++
++#ifdef short
++# undef short
++#endif
++
++#ifdef YYTYPE_UINT8
++typedef YYTYPE_UINT8 yytype_uint8;
++#else
++typedef unsigned char yytype_uint8;
++#endif
++
++#ifdef YYTYPE_INT8
++typedef YYTYPE_INT8 yytype_int8;
++#elif (defined __STDC__ || defined __C99__FUNC__ \
++ || defined __cplusplus || defined _MSC_VER)
++typedef signed char yytype_int8;
++#else
++typedef short int yytype_int8;
++#endif
++
++#ifdef YYTYPE_UINT16
++typedef YYTYPE_UINT16 yytype_uint16;
++#else
++typedef unsigned short int yytype_uint16;
++#endif
++
++#ifdef YYTYPE_INT16
++typedef YYTYPE_INT16 yytype_int16;
++#else
++typedef short int yytype_int16;
++#endif
++
++#ifndef YYSIZE_T
++# ifdef __SIZE_TYPE__
++# define YYSIZE_T __SIZE_TYPE__
++# elif defined size_t
++# define YYSIZE_T size_t
++# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
++ || defined __cplusplus || defined _MSC_VER)
++# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
++# define YYSIZE_T size_t
++# else
++# define YYSIZE_T unsigned int
++# endif
++#endif
++
++#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
++
++#ifndef YY_
++# if YYENABLE_NLS
++# if ENABLE_NLS
++# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
++# define YY_(msgid) dgettext ("bison-runtime", msgid)
++# endif
++# endif
++# ifndef YY_
++# define YY_(msgid) msgid
++# endif
++#endif
++
++/* Suppress unused-variable warnings by "using" E. */
++#if ! defined lint || defined __GNUC__
++# define YYUSE(e) ((void) (e))
++#else
++# define YYUSE(e) /* empty */
++#endif
++
++/* Identity function, used to suppress warnings about constant conditions. */
++#ifndef lint
++# define YYID(n) (n)
++#else
++#if (defined __STDC__ || defined __C99__FUNC__ \
++ || defined __cplusplus || defined _MSC_VER)
++static int
++YYID (int i)
++#else
++static int
++YYID (i)
++ int i;
++#endif
++{
++ return i;
++}
++#endif
++
++#if ! defined yyoverflow || YYERROR_VERBOSE
++
++/* The parser invokes alloca or malloc; define the necessary symbols. */
++
++# ifdef YYSTACK_USE_ALLOCA
++# if YYSTACK_USE_ALLOCA
++# ifdef __GNUC__
++# define YYSTACK_ALLOC __builtin_alloca
++# elif defined __BUILTIN_VA_ARG_INCR
++# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
++# elif defined _AIX
++# define YYSTACK_ALLOC __alloca
++# elif defined _MSC_VER
++# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
++# define alloca _alloca
++# else
++# define YYSTACK_ALLOC alloca
++# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
++ || defined __cplusplus || defined _MSC_VER)
++# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
++# ifndef _STDLIB_H
++# define _STDLIB_H 1
++# endif
++# endif
++# endif
++# endif
++# endif
++
++# ifdef YYSTACK_ALLOC
++ /* Pacify GCC's `empty if-body' warning. */
++# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
++# ifndef YYSTACK_ALLOC_MAXIMUM
++ /* The OS might guarantee only one guard page at the bottom of the stack,
++ and a page size can be as small as 4096 bytes. So we cannot safely
++ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
++ to allow for a few compiler-allocated temporary stack slots. */
++# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
++# endif
++# else
++# define YYSTACK_ALLOC YYMALLOC
++# define YYSTACK_FREE YYFREE
++# ifndef YYSTACK_ALLOC_MAXIMUM
++# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
++# endif
++# ifdef __cplusplus
++extern "C" {
++# endif
++# ifndef YYMALLOC
++# define YYMALLOC malloc
++# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
++ || defined __cplusplus || defined _MSC_VER)
++void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
++# endif
++# endif
++# ifndef YYFREE
++# define YYFREE free
++# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
++ || defined __cplusplus || defined _MSC_VER)
++void free (void *); /* INFRINGES ON USER NAME SPACE */
++# endif
++# endif
++# ifdef __cplusplus
++}
++# endif
++# endif
++#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
++
++
++#if (! defined yyoverflow \
++ && (! defined __cplusplus \
++ || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
++ && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
++
++/* A type that is properly aligned for any stack member. */
++union yyalloc
++{
++ yytype_int16 yyss;
++ YYSTYPE yyvs;
++ YYLTYPE yyls;
++};
++
++/* The size of the maximum gap between one aligned stack and the next. */
++# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
++
++/* The size of an array large to enough to hold all stacks, each with
++ N elements. */
++# define YYSTACK_BYTES(N) \
++ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
++ + 2 * YYSTACK_GAP_MAXIMUM)
++
++/* Copy COUNT objects from FROM to TO. The source and destination do
++ not overlap. */
++# ifndef YYCOPY
++# if defined __GNUC__ && 1 < __GNUC__
++# define YYCOPY(To, From, Count) \
++ __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
++# else
++# define YYCOPY(To, From, Count) \
++ do \
++ { \
++ YYSIZE_T yyi; \
++ for (yyi = 0; yyi < (Count); yyi++) \
++ (To)[yyi] = (From)[yyi]; \
++ } \
++ while (YYID (0))
++# endif
++# endif
++
++/* Relocate STACK from its old location to the new one. The
++ local variables YYSIZE and YYSTACKSIZE give the old and new number of
++ elements in the stack, and YYPTR gives the new location of the
++ stack. Advance YYPTR to a properly aligned location for the next
++ stack. */
++# define YYSTACK_RELOCATE(Stack) \
++ do \
++ { \
++ YYSIZE_T yynewbytes; \
++ YYCOPY (&yyptr->Stack, Stack, yysize); \
++ Stack = &yyptr->Stack; \
++ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
++ yyptr += yynewbytes / sizeof (*yyptr); \
++ } \
++ while (YYID (0))
++
++#endif
++
++/* YYFINAL -- State number of the termination state. */
++#define YYFINAL 14
++/* YYLAST -- Last index in YYTABLE. */
++#define YYLAST 298
++
++/* YYNTOKENS -- Number of terminals. */
++#define YYNTOKENS 42
++/* YYNNTS -- Number of nonterminals. */
++#define YYNNTS 54
++/* YYNRULES -- Number of rules. */
++#define YYNRULES 131
++/* YYNRULES -- Number of states. */
++#define YYNSTATES 262
++
++/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
++#define YYUNDEFTOK 2
++#define YYMAXUTOK 296
++
++#define YYTRANSLATE(YYX) \
++ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
++
++/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
++static const yytype_uint8 yytranslate[] =
++{
++ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
++ 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
++ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
++ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
++ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
++ 35, 36, 37, 38, 39, 40, 41
++};
++
++#if YYDEBUG
++/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
++ YYRHS. */
++static const yytype_uint16 yyprhs[] =
++{
++ 0, 0, 3, 5, 7, 10, 13, 15, 17, 19,
++ 21, 23, 25, 32, 34, 35, 44, 49, 50, 53,
++ 56, 57, 63, 64, 66, 70, 73, 74, 77, 80,
++ 82, 84, 86, 88, 90, 92, 95, 97, 102, 106,
++ 111, 119, 128, 129, 132, 135, 141, 143, 151, 152,
++ 157, 160, 163, 168, 170, 173, 175, 178, 182, 184,
++ 187, 191, 193, 196, 200, 206, 210, 212, 216, 220,
++ 223, 224, 225, 226, 239, 243, 245, 249, 252, 255,
++ 256, 262, 265, 268, 271, 275, 277, 280, 281, 283,
++ 287, 291, 297, 303, 309, 315, 316, 319, 322, 327,
++ 328, 334, 338, 339, 343, 347, 350, 352, 353, 355,
++ 356, 360, 361, 364, 369, 373, 378, 379, 382, 384,
++ 390, 395, 400, 401, 405, 408, 410, 414, 417, 421,
++ 424, 429
++};
++
++/* YYRHS -- A `-1'-separated list of the rules' RHS. */
++static const yytype_int8 yyrhs[] =
++{
++ 43, 0, -1, 44, -1, 45, -1, 44, 45, -1,
++ 44, 1, -1, 47, -1, 49, -1, 50, -1, 8,
++ -1, 41, -1, 36, -1, 48, 3, 46, 4, 55,
++ 5, -1, 23, -1, -1, 15, 41, 6, 54, 7,
++ 4, 88, 5, -1, 16, 4, 51, 5, -1, -1,
++ 52, 51, -1, 51, 1, -1, -1, 41, 9, 53,
++ 41, 8, -1, -1, 41, -1, 54, 10, 41, -1,
++ 54, 1, -1, -1, 56, 55, -1, 55, 1, -1,
++ 58, -1, 95, -1, 90, -1, 91, -1, 57, -1,
++ 52, -1, 41, 1, -1, 8, -1, 17, 24, 41,
++ 8, -1, 41, 24, 70, -1, 30, 41, 24, 70,
++ -1, 31, 6, 66, 7, 41, 24, 70, -1, 30,
++ 31, 6, 66, 7, 41, 24, 70, -1, -1, 70,
++ 59, -1, 59, 1, -1, 67, 11, 67, 11, 67,
++ -1, 41, -1, 60, 13, 67, 13, 67, 13, 67,
++ -1, -1, 6, 63, 65, 7, -1, 19, 62, -1,
++ 22, 62, -1, 20, 6, 61, 7, -1, 41, -1,
++ 41, 41, -1, 41, -1, 66, 41, -1, 66, 12,
++ 41, -1, 41, -1, 41, 41, -1, 41, 41, 41,
++ -1, 41, -1, 41, 41, -1, 68, 11, 41, -1,
++ 18, 62, 4, 86, 5, -1, 4, 59, 5, -1,
++ 52, -1, 25, 76, 8, -1, 26, 78, 8, -1,
++ 41, 11, -1, -1, -1, -1, 32, 6, 71, 41,
++ 8, 72, 41, 8, 73, 41, 7, 70, -1, 33,
++ 62, 70, -1, 69, -1, 12, 79, 8, -1, 83,
++ 8, -1, 41, 8, -1, -1, 83, 9, 74, 41,
++ 8, -1, 28, 8, -1, 27, 8, -1, 29, 8,
++ -1, 64, 70, 75, -1, 8, -1, 21, 70, -1,
++ -1, 68, -1, 68, 13, 68, -1, 68, 10, 68,
++ -1, 68, 13, 68, 13, 68, -1, 68, 10, 68,
++ 10, 68, -1, 36, 13, 68, 13, 68, -1, 36,
++ 10, 68, 10, 68, -1, -1, 10, 41, -1, 68,
++ 77, -1, 68, 77, 14, 46, -1, -1, 41, 6,
++ 80, 85, 7, -1, 41, 6, 7, -1, -1, 41,
++ 6, 82, -1, 81, 85, 7, -1, 81, 7, -1,
++ 41, -1, -1, 65, -1, -1, 85, 10, 84, -1,
++ -1, 87, 86, -1, 34, 41, 11, 59, -1, 36,
++ 11, 59, -1, 35, 41, 11, 59, -1, -1, 89,
++ 88, -1, 70, -1, 37, 41, 4, 59, 5, -1,
++ 38, 4, 92, 5, -1, 39, 4, 92, 5, -1,
++ -1, 41, 8, 92, -1, 92, 1, -1, 46, -1,
++ 46, 13, 61, -1, 93, 8, -1, 94, 93, 8,
++ -1, 94, 1, -1, 40, 4, 94, 5, -1, 40,
++ 4, 5, -1
++};
++
++/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
++static const yytype_uint16 yyrline[] =
++{
++ 0, 185, 185, 188, 189, 190, 193, 194, 195, 196,
++ 199, 200, 203, 218, 219, 222, 228, 234, 235, 236,
++ 239, 239, 246, 247, 248, 249, 252, 253, 254, 257,
++ 258, 259, 260, 261, 262, 263, 264, 267, 272, 276,
++ 281, 286, 296, 297, 298, 304, 309, 313, 321, 321,
++ 325, 328, 331, 342, 343, 350, 351, 355, 361, 362,
++ 367, 375, 376, 380, 386, 395, 398, 399, 402, 405,
++ 408, 409, 410, 408, 416, 420, 421, 422, 423, 426,
++ 426, 459, 460, 461, 462, 466, 469, 470, 473, 474,
++ 477, 480, 484, 488, 492, 498, 499, 503, 506, 512,
++ 512, 517, 525, 525, 536, 543, 546, 547, 550, 551,
++ 554, 557, 558, 561, 565, 569, 575, 576, 579, 580,
++ 586, 591, 596, 597, 598, 601, 602, 609, 610, 611,
++ 614, 617
++};
++#endif
++
++#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
++/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
++ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
++static const char *const yytname[] =
++{
++ "$end", "error", "$undefined", "KW_CONTEXT", "LC", "RC", "LP", "RP",
++ "SEMI", "EQ", "COMMA", "COLON", "AMPER", "BAR", "AT", "KW_MACRO",
++ "KW_GLOBALS", "KW_IGNOREPAT", "KW_SWITCH", "KW_IF", "KW_IFTIME",
++ "KW_ELSE", "KW_RANDOM", "KW_ABSTRACT", "EXTENMARK", "KW_GOTO", "KW_JUMP",
++ "KW_RETURN", "KW_BREAK", "KW_CONTINUE", "KW_REGEXTEN", "KW_HINT",
++ "KW_FOR", "KW_WHILE", "KW_CASE", "KW_PATTERN", "KW_DEFAULT", "KW_CATCH",
++ "KW_SWITCHES", "KW_ESWITCHES", "KW_INCLUDES", "word", "$accept", "file",
++ "objects", "object", "context_name", "context", "opt_abstract", "macro",
++ "globals", "global_statements", "assignment", "@1", "arglist",
++ "elements", "element", "ignorepat", "extension", "statements",
++ "timerange", "timespec", "test_expr", "@2", "if_like_head", "word_list",
++ "hint_word", "word3_list", "goto_word", "switch_statement", "statement",
++ "@3", "@4", "@5", "@6", "opt_else", "target", "opt_pri", "jumptarget",
++ "macro_call", "@7", "application_call_head", "@8", "application_call",
++ "opt_word", "eval_arglist", "case_statements", "case_statement",
++ "macro_statements", "macro_statement", "switches", "eswitches",
++ "switchlist", "included_entry", "includeslist", "includes", 0
++};
++#endif
++
++# ifdef YYPRINT
++/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
++ token YYLEX-NUM. */
++static const yytype_uint16 yytoknum[] =
++{
++ 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
++ 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
++ 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
++ 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
++ 295, 296
++};
++# endif
++
++/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
++static const yytype_uint8 yyr1[] =
++{
++ 0, 42, 43, 44, 44, 44, 45, 45, 45, 45,
++ 46, 46, 47, 48, 48, 49, 50, 51, 51, 51,
++ 53, 52, 54, 54, 54, 54, 55, 55, 55, 56,
++ 56, 56, 56, 56, 56, 56, 56, 57, 58, 58,
++ 58, 58, 59, 59, 59, 60, 60, 61, 63, 62,
++ 64, 64, 64, 65, 65, 66, 66, 66, 67, 67,
++ 67, 68, 68, 68, 69, 70, 70, 70, 70, 70,
++ 71, 72, 73, 70, 70, 70, 70, 70, 70, 74,
++ 70, 70, 70, 70, 70, 70, 75, 75, 76, 76,
++ 76, 76, 76, 76, 76, 77, 77, 78, 78, 80,
++ 79, 79, 82, 81, 83, 83, 84, 84, 85, 85,
++ 85, 86, 86, 87, 87, 87, 88, 88, 89, 89,
++ 90, 91, 92, 92, 92, 93, 93, 94, 94, 94,
++ 95, 95
++};
++
++/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
++static const yytype_uint8 yyr2[] =
++{
++ 0, 2, 1, 1, 2, 2, 1, 1, 1, 1,
++ 1, 1, 6, 1, 0, 8, 4, 0, 2, 2,
++ 0, 5, 0, 1, 3, 2, 0, 2, 2, 1,
++ 1, 1, 1, 1, 1, 2, 1, 4, 3, 4,
++ 7, 8, 0, 2, 2, 5, 1, 7, 0, 4,
++ 2, 2, 4, 1, 2, 1, 2, 3, 1, 2,
++ 3, 1, 2, 3, 5, 3, 1, 3, 3, 2,
++ 0, 0, 0, 12, 3, 1, 3, 2, 2, 0,
++ 5, 2, 2, 2, 3, 1, 2, 0, 1, 3,
++ 3, 5, 5, 5, 5, 0, 2, 2, 4, 0,
++ 5, 3, 0, 3, 3, 2, 1, 0, 1, 0,
++ 3, 0, 2, 4, 3, 4, 0, 2, 1, 5,
++ 4, 4, 0, 3, 2, 1, 3, 2, 3, 2,
++ 4, 3
++};
++
++/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
++ STATE-NUM when YYTABLE doesn't specify something else to do. Zero
++ means the default is an error. */
++static const yytype_uint8 yydefact[] =
++{
++ 14, 9, 0, 0, 13, 0, 0, 3, 6, 0,
++ 7, 8, 0, 17, 1, 5, 4, 0, 22, 0,
++ 0, 17, 11, 10, 0, 23, 0, 20, 19, 16,
++ 0, 26, 25, 0, 0, 0, 36, 0, 0, 0,
++ 0, 0, 0, 0, 34, 0, 26, 33, 29, 31,
++ 32, 30, 116, 24, 0, 0, 0, 0, 0, 122,
++ 122, 0, 35, 0, 28, 12, 0, 42, 85, 0,
++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
++ 0, 0, 0, 66, 0, 75, 118, 109, 0, 0,
++ 116, 21, 0, 0, 0, 55, 0, 0, 0, 0,
++ 131, 125, 0, 0, 38, 0, 42, 0, 0, 48,
++ 0, 50, 0, 51, 0, 61, 88, 0, 95, 0,
++ 82, 81, 83, 70, 0, 0, 102, 78, 69, 87,
++ 105, 53, 108, 0, 77, 79, 15, 117, 37, 0,
++ 39, 0, 0, 56, 122, 124, 120, 121, 0, 127,
++ 129, 130, 0, 44, 65, 0, 99, 76, 0, 111,
++ 46, 0, 0, 0, 0, 0, 62, 0, 0, 0,
++ 67, 0, 97, 68, 0, 74, 42, 103, 0, 84,
++ 54, 104, 107, 0, 0, 0, 57, 0, 126, 128,
++ 101, 109, 0, 0, 0, 0, 0, 111, 59, 0,
++ 52, 0, 0, 0, 90, 63, 89, 96, 0, 0,
++ 0, 86, 106, 110, 0, 0, 0, 0, 49, 0,
++ 0, 42, 64, 112, 60, 58, 0, 0, 0, 0,
++ 0, 0, 98, 71, 119, 80, 0, 40, 100, 42,
++ 42, 0, 0, 0, 94, 93, 92, 91, 0, 41,
++ 0, 0, 0, 45, 0, 0, 72, 47, 0, 0,
++ 0, 73
++};
++
++/* YYDEFGOTO[NTERM-NUM]. */
++static const yytype_int16 yydefgoto[] =
++{
++ -1, 5, 6, 7, 101, 8, 9, 10, 11, 20,
++ 83, 35, 26, 45, 46, 47, 48, 105, 161, 162,
++ 110, 158, 84, 132, 96, 163, 116, 85, 106, 174,
++ 248, 258, 183, 179, 117, 172, 119, 108, 191, 87,
++ 177, 88, 213, 133, 196, 197, 89, 90, 49, 50,
++ 98, 102, 103, 51
++};
++
++/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
++ STATE-NUM. */
++#define YYPACT_NINF -195
++static const yytype_int16 yypact[] =
++{
++ 136, -195, -27, 22, -195, 67, 127, -195, -195, 79,
++ -195, -195, 89, 76, -195, -195, -195, -21, 88, 125,
++ 12, 76, -195, -195, 156, -195, 11, -195, -195, -195,
++ 35, 108, -195, 193, 99, 129, -195, 147, -22, 176,
++ 194, 195, 196, 7, -195, 110, 108, -195, -195, -195,
++ -195, -195, 25, -195, 197, 163, 200, 179, 169, 170,
++ 170, 19, -195, 81, -195, -195, 140, 81, -195, 172,
++ 201, 201, 203, 201, -13, 174, 204, 206, 208, 211,
++ 201, 180, 72, -195, 81, -195, -195, 18, 115, 213,
++ 25, -195, 212, 169, 81, -195, 15, 214, 160, 161,
++ -195, 188, 215, 5, -195, 162, 81, 218, 217, -195,
++ 198, -195, 186, -195, 166, 187, 164, 221, 143, 222,
++ -195, -195, -195, -195, 81, 227, -195, -195, -195, 205,
++ -195, 191, -195, 171, -195, -195, -195, -195, -195, 64,
[... 37392 lines stripped ...]
More information about the svn-commits
mailing list