[asterisk-commits] murf: branch murf/AEL2-1.2 r48454 - /team/murf/AEL2-1.2/

asterisk-commits at lists.digium.com asterisk-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 asterisk-commits mailing list