-/* 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.
+/* A Bison parser, made by GNU Bison 2.4.1. */
- This program is free software; you can redistribute it and/or modify
+/* Skeleton implementation for Bison's Yacc-like parsers in C
+
+ 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.
+ the Free Software Foundation, either version 3 of the License, 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
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. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
-/* 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. */
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
/* C LALR(1) parser skeleton written by Richard Stallman, by
simplifying the original so-called "semantic" parser. */
#define YYBISON 1
/* Bison version. */
-#define YYBISON_VERSION "2.1a"
+#define YYBISON_VERSION "2.4.1"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
/* Pure parsers. */
#define YYPURE 1
+/* Push parsers. */
+#define YYPUSH 0
+
+/* Pull parsers. */
+#define YYPULL 1
+
/* Using locations. */
#define YYLSP_NEEDED 1
/* Substitute the variable and function names. */
-#define yyparse ast_yyparse
-#define yylex ast_yylex
-#define yyerror ast_yyerror
-#define yylval ast_yylval
-#define yychar ast_yychar
-#define yydebug ast_yydebug
-#define yynerrs ast_yynerrs
-#define yylloc ast_yylloc
-
-/* Tokens. */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
- /* Put the tokens into the symbol table, so that GDB and other debuggers
- know about them. */
- enum yytokentype {
- TOK_COMMA = 258,
- TOK_COLONCOLON = 259,
- TOK_COND = 260,
- TOK_OR = 261,
- TOK_AND = 262,
- TOK_NE = 263,
- TOK_LE = 264,
- TOK_GE = 265,
- TOK_LT = 266,
- TOK_GT = 267,
- TOK_EQ = 268,
- TOK_MINUS = 269,
- TOK_PLUS = 270,
- TOK_MOD = 271,
- TOK_DIV = 272,
- TOK_MULT = 273,
- TOK_COMPL = 274,
- TOK_EQTILDE = 275,
- TOK_COLON = 276,
- TOK_LP = 277,
- TOK_RP = 278,
- TOKEN = 279
- };
-#endif
-/* Tokens. */
-#define TOK_COMMA 258
-#define TOK_COLONCOLON 259
-#define TOK_COND 260
-#define TOK_OR 261
-#define TOK_AND 262
-#define TOK_NE 263
-#define TOK_LE 264
-#define TOK_GE 265
-#define TOK_LT 266
-#define TOK_GT 267
-#define TOK_EQ 268
-#define TOK_MINUS 269
-#define TOK_PLUS 270
-#define TOK_MOD 271
-#define TOK_DIV 272
-#define TOK_MULT 273
-#define TOK_COMPL 274
-#define TOK_EQTILDE 275
-#define TOK_COLON 276
-#define TOK_LP 277
-#define TOK_RP 278
-#define TOKEN 279
-
-
-
+#define yyparse ast_yyparse
+#define yylex ast_yylex
+#define yyerror ast_yyerror
+#define yylval ast_yylval
+#define yychar ast_yychar
+#define yydebug ast_yydebug
+#define yynerrs ast_yynerrs
+#define yylloc ast_yylloc
/* Copy the first part of user declarations. */
+
+/* Line 189 of yacc.c */
#line 1 "ast_expr2.y"
-/* Written by Pace Willisson (pace@blitz.com)
+/* Written by Pace Willisson (pace@blitz.com)
* and placed in the public domain.
*
* Largely rewritten by J.T. Conklin (jtc@wimsey.com)
*
* And then overhauled twice by Steve Murphy (murf@digium.com)
* to add double-quoted strings, allow mult. spaces, improve
- * error messages, and then to fold in a flex scanner for the
+ * error messages, and then to fold in a flex scanner for the
* yylex operation.
*
* $FreeBSD: src/bin/expr/expr.y,v 1.16 2000/07/22 10:59:36 se Exp $
*/
+#define ASTMM_LIBC ASTMM_REDIRECT
+#include "asterisk.h"
+
+#include <sys/cdefs.h>
#include <sys/types.h>
#include <stdio.h>
-#ifdef STANDALONE /* I guess somewhere, the feature is set in the asterisk includes */
+#if defined(STANDALONE) || defined(STANDALONE2)
#ifndef __USE_ISOC99
#define __USE_ISOC99 1
#endif
#ifdef __USE_ISOC99
#define FP___PRINTF "%.18Lg"
-#define FP___FMOD fmodl
-#define FP___STRTOD strtold
#define FP___TYPE long double
-#define FUNC_COS cosl
-#define FUNC_SIN sinl
-#define FUNC_TAN tanl
-#define FUNC_ACOS acosl
-#define FUNC_ASIN asinl
-#define FUNC_ATAN atanl
-#define FUNC_ATAN2 atan2l
-#define FUNC_POW powl
-#define FUNC_SQRT sqrtl
+#else
+#define FP___PRINTF "%.16g"
+#define FP___TYPE double
+#endif
+
+#ifdef HAVE_COSL
+#define FUNC_COS cosl
+#elif defined(HAVE_COS)
+#define FUNC_COS (long double)cos
+#endif
+
+#ifdef HAVE_SINL
+#define FUNC_SIN sinl
+#elif defined(HAVE_SIN)
+#define FUNC_SIN (long double)sin
+#endif
+
+#ifdef HAVE_TANL
+#define FUNC_TAN tanl
+#elif defined(HAVE_TAN)
+#define FUNC_TAN (long double)tan
+#endif
+
+#ifdef HAVE_ACOSL
+#define FUNC_ACOS acosl
+#elif defined(HAVE_ACOS)
+#define FUNC_ACOS (long double)acos
+#endif
+
+#ifdef HAVE_ASINL
+#define FUNC_ASIN asinl
+#elif defined(HAVE_ASIN)
+#define FUNC_ASIN (long double)asin
+#endif
+
+#ifdef HAVE_ATANL
+#define FUNC_ATAN atanl
+#elif defined(HAVE_ATAN)
+#define FUNC_ATAN (long double)atan
+#endif
+
+#ifdef HAVE_ATAN2L
+#define FUNC_ATAN2 atan2l
+#elif defined(HAVE_ATAN2)
+#define FUNC_ATAN2 (long double)atan2
+#endif
+
+#ifdef HAVE_POWL
+#define FUNC_POW powl
+#elif defined(HAVE_POW)
+#define FUNC_POW (long double)pow
+#endif
+
+#ifdef HAVE_SQRTL
+#define FUNC_SQRT sqrtl
+#elif defined(HAVE_SQRT)
+#define FUNC_SQRT (long double)sqrt
+#endif
+
+#ifdef HAVE_RINTL
+#define FUNC_RINT rintl
+#elif defined(HAVE_RINT)
+#define FUNC_RINT (long double)rint
+#endif
+
+#ifdef HAVE_EXPL
+#define FUNC_EXP expl
+#elif defined(HAVE_EXP)
+#define FUNC_EXP (long double)exp
+#endif
+
+#ifdef HAVE_LOGL
+#define FUNC_LOG logl
+#elif defined(HAVE_LOG)
+#define FUNC_LOG (long double)log
+#endif
+
+#ifdef HAVE_REMAINDERL
+#define FUNC_REMAINDER remainderl
+#elif defined(HAVE_REMAINDER)
+#define FUNC_REMAINDER (long double)remainder
+#endif
+
+#ifdef HAVE_FMODL
+#define FUNC_FMOD fmodl
+#elif defined(HAVE_FMOD)
+#define FUNC_FMOD (long double)fmod
+#endif
+
+#ifdef HAVE_STRTOLD
+#define FUNC_STRTOD strtold
+#elif defined(HAVE_STRTOD)
+#define FUNC_STRTOD (long double)strtod
+#endif
+
+#ifdef HAVE_FLOORL
#define FUNC_FLOOR floorl
+#elif defined(HAVE_FLOOR)
+#define FUNC_FLOOR (long double)floor
+#endif
+
+#ifdef HAVE_CEILL
#define FUNC_CEIL ceill
+#elif defined(HAVE_CEIL)
+#define FUNC_CEIL (long double)ceil
+#endif
+
+#ifdef HAVE_ROUNDL
#define FUNC_ROUND roundl
-#define FUNC_RINT rintl
+#elif defined(HAVE_ROUND)
+#define FUNC_ROUND (long double)round
+#endif
+
+#ifdef HAVE_TRUNCL
#define FUNC_TRUNC truncl
-#define FUNC_EXP expl
+#elif defined(HAVE_TRUNC)
+#define FUNC_TRUNC (long double)trunc
+#endif
+
+/*! \note
+ * Oddly enough, some platforms have some ISO C99 functions, but not others, so
+ * we define the missing functions in terms of their mathematical identities.
+ */
+#ifdef HAVE_EXP2L
#define FUNC_EXP2 exp2l
-#define FUNC_LOG logl
+#elif (defined(HAVE_EXPL) && defined(HAVE_LOGL))
+#define FUNC_EXP2(x) expl((x) * logl(2.0))
+#elif (defined(HAVE_EXP) && defined(HAVE_LOG))
+#define FUNC_EXP2(x) (long double)exp((x) * log(2.0))
+#endif
+
+#ifdef HAVE_EXP10L
+#define FUNC_EXP10 exp10l
+#elif (defined(HAVE_EXPL) && defined(HAVE_LOGL))
+#define FUNC_EXP10(x) expl((x) * logl(10.0))
+#elif (defined(HAVE_EXP) && defined(HAVE_LOG))
+#define FUNC_EXP10(x) (long double)exp((x) * log(10.0))
+#endif
+
+#ifdef HAVE_LOG2L
#define FUNC_LOG2 log2l
+#elif defined(HAVE_LOGL)
+#define FUNC_LOG2(x) (logl(x) / logl(2.0))
+#elif defined(HAVE_LOG10L)
+#define FUNC_LOG2(x) (log10l(x) / log10l(2.0))
+#elif defined(HAVE_LOG2)
+#define FUNC_LOG2 (long double)log2
+#elif defined(HAVE_LOG)
+#define FUNC_LOG2(x) ((long double)log(x) / log(2.0))
+#endif
+
+#ifdef HAVE_LOG10L
#define FUNC_LOG10 log10l
-#define FUNC_REMAINDER remainderl
-#else
-#define FP___PRINTF "%.16g"
-#define FP___FMOD fmod
-#define FP___STRTOD strtod
-#define FP___TYPE double
-#define FUNC_COS cos
-#define FUNC_SIN sin
-#define FUNC_TAN tan
-#define FUNC_ACOS acos
-#define FUNC_ASIN asin
-#define FUNC_ATAN atan
-#define FUNC_ATAN2 atan2
-#define FUNC_POW pow
-#define FUNC_SQRT sqrt
-#define FUNC_FLOOR floor
-#define FUNC_CEIL ceil
-#define FUNC_ROUND round
-#define FUNC_RINT rint
-#define FUNC_TRUNC trunc
-#define FUNC_EXP exp
-#define FUNC_EXP2 exp2
-#define FUNC_LOG log
-#define FUNC_LOG2 log2
-#define FUNC_LOG10 log10
-#define FUNC_REMAINDER remainder
+#elif defined(HAVE_LOGL)
+#define FUNC_LOG10(x) (logl(x) / logl(10.0))
+#elif defined(HAVE_LOG2L)
+#define FUNC_LOG10(x) (log2l(x) / log2l(10.0))
+#elif defined(HAVE_LOG10)
+#define FUNC_LOG10(x) (long double)log10(x)
+#elif defined(HAVE_LOG)
+#define FUNC_LOG10(x) ((long double)log(x) / log(10.0))
#endif
+
#include <stdlib.h>
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#include <regex.h>
#include <limits.h>
-#include "asterisk.h"
#include "asterisk/ast_expr.h"
#include "asterisk/logger.h"
-#ifndef STANDALONE
+#if !defined(STANDALONE) && !defined(STANDALONE2)
#include "asterisk/pbx.h"
#endif
AST_EXPR_number, AST_EXPR_numeric_string, AST_EXPR_string
} ;
-#ifdef STANDALONE
+#if defined(STANDALONE) || defined(STANDALONE2)
void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...) __attribute__ ((format (printf,5,6)));
#endif
AST_EXPR_NODE_COMMA, AST_EXPR_NODE_STRING, AST_EXPR_NODE_VAL
} ;
-struct expr_node
+struct expr_node
{
enum node_type type;
struct val *val;
yyscan_t scanner;
struct ast_channel *chan;
};
-
+
static int chk_div __P((FP___TYPE, FP___TYPE));
static int chk_minus __P((FP___TYPE, FP___TYPE, FP___TYPE));
static int chk_plus __P((FP___TYPE, FP___TYPE, FP___TYPE));
static struct val *op_and __P((struct val *, struct val *));
static struct val *op_colon __P((struct val *, struct val *));
static struct val *op_eqtilde __P((struct val *, struct val *));
+static struct val *op_tildetilde __P((struct val *, struct val *));
static struct val *op_div __P((struct val *, struct val *));
static struct val *op_eq __P((struct val *, struct val *));
static struct val *op_ge __P((struct val *, struct val *));
static void to_string __P((struct val *));
static struct expr_node *alloc_expr_node(enum node_type);
static void destroy_arglist(struct expr_node *arglist);
-static int is_really_num(char *str);
/* uh, if I want to predeclare yylex with a YYLTYPE, I have to predeclare the yyltype... sigh */
typedef struct yyltype
define it here, we have no definition yet for YYSTYPE. */
int ast_yyerror(const char *,YYLTYPE *, struct parse_io *);
-
+
/* I wanted to add args to the yyerror routine, so I could print out
some useful info about the error. Not as easy as it looks, but it
is possible. */
#define DESTROY(x) {if((x)->type == AST_EXPR_numeric_string || (x)->type == AST_EXPR_string) free((x)->u.s); (x)->u.s = 0; free(x);}
+/* Line 189 of yacc.c */
+#line 419 "ast_expr2.c"
+
/* Enabling traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
# define YYTOKEN_TABLE 0
#endif
+
+/* Tokens. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ /* Put the tokens into the symbol table, so that GDB and other debuggers
+ know about them. */
+ enum yytokentype {
+ TOK_COMMA = 258,
+ TOK_COLONCOLON = 259,
+ TOK_COND = 260,
+ TOK_OR = 261,
+ TOK_AND = 262,
+ TOK_NE = 263,
+ TOK_LE = 264,
+ TOK_GE = 265,
+ TOK_LT = 266,
+ TOK_GT = 267,
+ TOK_EQ = 268,
+ TOK_MINUS = 269,
+ TOK_PLUS = 270,
+ TOK_MOD = 271,
+ TOK_DIV = 272,
+ TOK_MULT = 273,
+ TOK_COMPL = 274,
+ TOK_TILDETILDE = 275,
+ TOK_EQTILDE = 276,
+ TOK_COLON = 277,
+ TOK_LP = 278,
+ TOK_RP = 279,
+ TOKEN = 280
+ };
+#endif
+
+
+
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
-#line 226 "ast_expr2.y"
{
+
+/* Line 214 of yacc.c */
+#line 345 "ast_expr2.y"
+
struct val *val;
struct expr_node *arglist;
-}
-/* Line 198 of yacc.c. */
-#line 365 "ast_expr2.c"
- YYSTYPE;
+
+
+
+/* Line 214 of yacc.c */
+#line 487 "ast_expr2.c"
+} YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
# 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
/* Copy the second part of user declarations. */
-#line 231 "ast_expr2.y"
+
+/* Line 264 of yacc.c */
+#line 350 "ast_expr2.y"
extern int ast_yylex __P((YYSTYPE *, YYLTYPE *, yyscan_t));
-/* Line 221 of yacc.c. */
-#line 393 "ast_expr2.c"
+/* Line 264 of yacc.c */
+#line 517 "ast_expr2.c"
#ifdef short
# undef short
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static int
-YYID (int i)
+YYID (int yyi)
#else
static int
-YYID (i)
- int i;
+YYID (yyi)
+ int yyi;
#endif
{
- return i;
+ return yyi;
}
#endif
# ifndef YYSTACK_ALLOC_MAXIMUM
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
# endif
-# ifdef __cplusplus
-extern "C" {
+# if (defined __cplusplus && ! defined _STDLIB_H \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef _STDLIB_H
+# define _STDLIB_H 1
+# endif
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
void free (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
-# ifdef __cplusplus
-}
-# endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
/* A type that is properly aligned for any stack member. */
union yyalloc
{
- yytype_int16 yyss;
- YYSTYPE yyvs;
- YYLTYPE yyls;
+ yytype_int16 yyss_alloc;
+ YYSTYPE yyvs_alloc;
+ YYLTYPE yyls_alloc;
};
/* The size of the maximum gap between one aligned stack and the next. */
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) \
+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
- YYCOPY (&yyptr->Stack, Stack, yysize); \
- Stack = &yyptr->Stack; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 11
/* YYLAST -- Last index in YYTABLE. */
-#define YYLAST 150
+#define YYLAST 159
/* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS 25
+#define YYNTOKENS 26
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 4
/* YYNRULES -- Number of rules. */
-#define YYNRULES 26
+#define YYNRULES 28
/* YYNRULES -- Number of states. */
-#define YYNSTATES 52
+#define YYNSTATES 54
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
#define YYUNDEFTOK 2
-#define YYMAXUTOK 279
+#define YYMAXUTOK 280
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
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
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+ 25
};
#if YYDEBUG
YYRHS. */
static const yytype_uint8 yyprhs[] =
{
- 0, 0, 3, 5, 6, 8, 12, 17, 19, 23,
- 27, 31, 35, 39, 43, 47, 51, 55, 59, 63,
- 66, 69, 73, 77, 81, 85, 89
+ 0, 0, 3, 5, 6, 8, 12, 15, 20, 22,
+ 26, 30, 34, 38, 42, 46, 50, 54, 58, 62,
+ 66, 69, 72, 76, 80, 84, 88, 92, 98
};
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yytype_int8 yyrhs[] =
{
- 26, 0, -1, 28, -1, -1, 28, -1, 27, 3,
- 28, -1, 24, 22, 27, 23, -1, 24, -1, 22,
- 28, 23, -1, 28, 6, 28, -1, 28, 7, 28,
- -1, 28, 13, 28, -1, 28, 12, 28, -1, 28,
- 11, 28, -1, 28, 10, 28, -1, 28, 9, 28,
- -1, 28, 8, 28, -1, 28, 15, 28, -1, 28,
- 14, 28, -1, 14, 28, -1, 19, 28, -1, 28,
- 18, 28, -1, 28, 17, 28, -1, 28, 16, 28,
- -1, 28, 21, 28, -1, 28, 20, 28, -1, 28,
- 5, 28, 4, 28, -1
+ 27, 0, -1, 29, -1, -1, 29, -1, 28, 3,
+ 29, -1, 28, 3, -1, 25, 23, 28, 24, -1,
+ 25, -1, 23, 29, 24, -1, 29, 6, 29, -1,
+ 29, 7, 29, -1, 29, 13, 29, -1, 29, 12,
+ 29, -1, 29, 11, 29, -1, 29, 10, 29, -1,
+ 29, 9, 29, -1, 29, 8, 29, -1, 29, 15,
+ 29, -1, 29, 14, 29, -1, 14, 29, -1, 19,
+ 29, -1, 29, 18, 29, -1, 29, 17, 29, -1,
+ 29, 16, 29, -1, 29, 22, 29, -1, 29, 21,
+ 29, -1, 29, 5, 29, 4, 29, -1, 29, 20,
+ 29, -1
};
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
- 0, 257, 257, 265, 272, 273, 282, 288, 289, 293,
- 297, 301, 305, 309, 313, 317, 321, 325, 329, 333,
- 337, 341, 345, 349, 353, 357, 361
+ 0, 374, 374, 382, 389, 390, 396, 405, 411, 412,
+ 416, 420, 424, 428, 432, 436, 440, 444, 448, 452,
+ 456, 460, 464, 468, 472, 476, 480, 484, 489
};
#endif
"$end", "error", "$undefined", "TOK_COMMA", "TOK_COLONCOLON",
"TOK_COND", "TOK_OR", "TOK_AND", "TOK_NE", "TOK_LE", "TOK_GE", "TOK_LT",
"TOK_GT", "TOK_EQ", "TOK_MINUS", "TOK_PLUS", "TOK_MOD", "TOK_DIV",
- "TOK_MULT", "TOK_COMPL", "TOK_EQTILDE", "TOK_COLON", "TOK_LP", "TOK_RP",
- "TOKEN", "$accept", "start", "arglist", "expr", 0
+ "TOK_MULT", "TOK_COMPL", "TOK_TILDETILDE", "TOK_EQTILDE", "TOK_COLON",
+ "TOK_LP", "TOK_RP", "TOKEN", "$accept", "start", "arglist", "expr", 0
};
#endif
{
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
+ 275, 276, 277, 278, 279, 280
};
# endif
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const yytype_uint8 yyr1[] =
{
- 0, 25, 26, 26, 27, 27, 28, 28, 28, 28,
- 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
- 28, 28, 28, 28, 28, 28, 28
+ 0, 26, 27, 27, 28, 28, 28, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29
};
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
static const yytype_uint8 yyr2[] =
{
- 0, 2, 1, 0, 1, 3, 4, 1, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 2,
- 2, 3, 3, 3, 3, 3, 5
+ 0, 2, 1, 0, 1, 3, 2, 4, 1, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 2, 2, 3, 3, 3, 3, 3, 5, 3
};
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
means the default is an error. */
static const yytype_uint8 yydefact[] =
{
- 3, 0, 0, 0, 7, 0, 2, 19, 20, 0,
+ 3, 0, 0, 0, 8, 0, 2, 20, 21, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 8, 0,
- 4, 0, 9, 10, 16, 15, 14, 13, 12, 11,
- 18, 17, 23, 22, 21, 25, 24, 0, 6, 0,
- 5, 26
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+ 0, 4, 0, 10, 11, 17, 16, 15, 14, 13,
+ 12, 19, 18, 24, 23, 22, 28, 26, 25, 6,
+ 7, 0, 5, 27
};
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int8 yydefgoto[] =
{
- -1, 5, 29, 6
+ -1, 5, 30, 6
};
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
#define YYPACT_NINF -18
static const yytype_int16 yypact[] =
{
- 112, 112, 112, 112, -16, 5, 62, -17, -17, 24,
- 112, -18, 112, 112, 112, 112, 112, 112, 112, 112,
- 112, 112, 112, 112, 112, 112, 112, 112, -18, 4,
- 62, 45, 93, 107, 123, 123, 123, 123, 123, 123,
- 129, 129, -17, -17, -17, -18, -18, 112, -18, 112,
- 62, 78
+ 118, 118, 118, 118, -15, 6, 65, -17, -17, 25,
+ 118, -18, 118, 118, 118, 118, 118, 118, 118, 118,
+ 118, 118, 118, 118, 118, 118, 118, 118, 118, -18,
+ 4, 65, 47, 98, 113, 130, 130, 130, 130, 130,
+ 130, 137, 137, -17, -17, -17, -18, -18, -18, 118,
+ -18, 118, 65, 82
};
/* YYPGOTO[NTERM-NUM]. */
#define YYTABLE_NINF -1
static const yytype_uint8 yytable[] =
{
- 7, 8, 9, 26, 27, 11, 10, 47, 0, 30,
- 0, 31, 32, 33, 34, 35, 36, 37, 38, 39,
- 40, 41, 42, 43, 44, 45, 46, 48, 0, 12,
- 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
- 23, 24, 25, 0, 26, 27, 50, 28, 51, 49,
+ 7, 8, 9, 26, 27, 28, 11, 49, 10, 31,
+ 0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 50, 0,
+ 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+ 22, 23, 24, 25, 0, 26, 27, 28, 52, 29,
+ 53, 51, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 0, 26, 27, 28,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
- 22, 23, 24, 25, 0, 26, 27, 12, 13, 14,
+ 22, 23, 24, 25, 0, 26, 27, 28, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, 0, 26, 27, 13, 14, 15, 16, 17, 18,
+ 25, 0, 26, 27, 28, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 0, 26, 27,
- 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
- 24, 25, 0, 26, 27, 15, 16, 17, 18, 19,
- 20, 21, 22, 23, 24, 25, 1, 26, 27, 0,
- 0, 2, 0, 0, 3, 0, 4, 21, 22, 23,
- 24, 25, 0, 26, 27, 23, 24, 25, 0, 26,
- 27
+ 28, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 1, 26, 27, 28, 0, 2, 0, 0,
+ 0, 3, 0, 4, 21, 22, 23, 24, 25, 0,
+ 26, 27, 28, 23, 24, 25, 0, 26, 27, 28
};
static const yytype_int8 yycheck[] =
{
- 1, 2, 3, 20, 21, 0, 22, 3, -1, 10,
+ 1, 2, 3, 20, 21, 22, 0, 3, 23, 10,
-1, 12, 13, 14, 15, 16, 17, 18, 19, 20,
- 21, 22, 23, 24, 25, 26, 27, 23, -1, 5,
- 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
- 16, 17, 18, -1, 20, 21, 47, 23, 49, 4,
+ 21, 22, 23, 24, 25, 26, 27, 28, 24, -1,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, -1, 20, 21, 22, 49, 24,
+ 51, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, -1, 20, 21, 22,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, -1, 20, 21, 5, 6, 7,
+ 15, 16, 17, 18, -1, 20, 21, 22, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
- 18, -1, 20, 21, 6, 7, 8, 9, 10, 11,
+ 18, -1, 20, 21, 22, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, -1, 20, 21,
- 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
- 17, 18, -1, 20, 21, 8, 9, 10, 11, 12,
- 13, 14, 15, 16, 17, 18, 14, 20, 21, -1,
- -1, 19, -1, -1, 22, -1, 24, 14, 15, 16,
- 17, 18, -1, 20, 21, 16, 17, 18, -1, 20,
- 21
+ 22, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+ 17, 18, 14, 20, 21, 22, -1, 19, -1, -1,
+ -1, 23, -1, 25, 14, 15, 16, 17, 18, -1,
+ 20, 21, 22, 16, 17, 18, -1, 20, 21, 22
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const yytype_uint8 yystos[] =
{
- 0, 14, 19, 22, 24, 26, 28, 28, 28, 28,
- 22, 0, 5, 6, 7, 8, 9, 10, 11, 12,
- 13, 14, 15, 16, 17, 18, 20, 21, 23, 27,
- 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
- 28, 28, 28, 28, 28, 28, 28, 3, 23, 4,
- 28, 28
+ 0, 14, 19, 23, 25, 27, 29, 29, 29, 29,
+ 23, 0, 5, 6, 7, 8, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, 18, 20, 21, 22, 24,
+ 28, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 3,
+ 24, 4, 29, 29
};
#define yyerrok (yyerrstatus = 0)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, const YYSTYPE * const yyvaluep, const YYLTYPE * const yylocationp)
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
#else
static void
yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp)
FILE *yyoutput;
int yytype;
- const YYSTYPE * const yyvaluep;
- const YYLTYPE * const yylocationp;
+ YYSTYPE const * const yyvaluep;
+ YYLTYPE const * const yylocationp;
#endif
{
if (!yyvaluep)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
-yy_symbol_print (FILE *yyoutput, int yytype, const YYSTYPE * const yyvaluep, const YYLTYPE * const yylocationp)
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
#else
static void
yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp)
FILE *yyoutput;
int yytype;
- const YYSTYPE * const yyvaluep;
- const YYLTYPE * const yylocationp;
+ YYSTYPE const * const yyvaluep;
+ YYLTYPE const * const yylocationp;
#endif
{
if (yytype < YYNTOKENS)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
-yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
#else
static void
-yy_stack_print (bottom, top)
- yytype_int16 *bottom;
- yytype_int16 *top;
+yy_stack_print (yybottom, yytop)
+ yytype_int16 *yybottom;
+ yytype_int16 *yytop;
#endif
{
YYFPRINTF (stderr, "Stack now");
- for (; bottom <= top; ++bottom)
- YYFPRINTF (stderr, " %d", *bottom);
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
YYFPRINTF (stderr, "\n");
}
yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule)
#else
static void
-yy_reduce_print (yyvsp, yylsp, yyrule
- )
+yy_reduce_print (yyvsp, yylsp, yyrule)
YYSTYPE *yyvsp;
YYLTYPE *yylsp;
int yyrule;
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
- fprintf (stderr, " $%d = ", yyi + 1);
+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&(yyvsp[(yyi + 1) - (yynrhs)])
, &(yylsp[(yyi + 1) - (yynrhs)]) );
- fprintf (stderr, "\n");
+ YYFPRINTF (stderr, "\n");
}
}
# define YYMAXDEPTH 10000
#endif
-\f
+
#if YYERROR_VERBOSE
{
if (*yystr == '"')
{
- size_t yyn = 0;
+ YYSIZE_T yyn = 0;
char const *yyp = yystr;
for (;;)
{
int yyn = yypact[yystate];
- if (! (YYPACT_NINF < yyn && yyn < YYLAST))
+ if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
return 0;
else
{
int yyxbegin = yyn < 0 ? -yyn : 0;
/* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn;
+ int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yycount = 1;
}
}
#endif /* YYERROR_VERBOSE */
-\f
+
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
switch (yytype)
{
case 4: /* "TOK_COLONCOLON" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1345 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1479 "ast_expr2.c"
break;
case 5: /* "TOK_COND" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1350 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1488 "ast_expr2.c"
break;
case 6: /* "TOK_OR" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1355 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1497 "ast_expr2.c"
break;
case 7: /* "TOK_AND" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1360 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1506 "ast_expr2.c"
break;
case 8: /* "TOK_NE" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1365 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1515 "ast_expr2.c"
break;
case 9: /* "TOK_LE" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1370 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1524 "ast_expr2.c"
break;
case 10: /* "TOK_GE" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1375 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1533 "ast_expr2.c"
break;
case 11: /* "TOK_LT" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1380 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1542 "ast_expr2.c"
break;
case 12: /* "TOK_GT" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1385 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1551 "ast_expr2.c"
break;
case 13: /* "TOK_EQ" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1390 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1560 "ast_expr2.c"
break;
case 14: /* "TOK_MINUS" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1395 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1569 "ast_expr2.c"
break;
case 15: /* "TOK_PLUS" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1400 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1578 "ast_expr2.c"
break;
case 16: /* "TOK_MOD" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1405 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1587 "ast_expr2.c"
break;
case 17: /* "TOK_DIV" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1410 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1596 "ast_expr2.c"
break;
case 18: /* "TOK_MULT" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1415 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1605 "ast_expr2.c"
break;
case 19: /* "TOK_COMPL" */
-#line 251 "ast_expr2.y"
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1420 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1614 "ast_expr2.c"
+ break;
+ case 20: /* "TOK_TILDETILDE" */
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
+ { free_value((yyvaluep->val)); };
+
+/* Line 1000 of yacc.c */
+#line 1623 "ast_expr2.c"
break;
- case 20: /* "TOK_EQTILDE" */
-#line 251 "ast_expr2.y"
+ case 21: /* "TOK_EQTILDE" */
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1425 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1632 "ast_expr2.c"
break;
- case 21: /* "TOK_COLON" */
-#line 251 "ast_expr2.y"
+ case 22: /* "TOK_COLON" */
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1430 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1641 "ast_expr2.c"
break;
- case 22: /* "TOK_LP" */
-#line 251 "ast_expr2.y"
+ case 23: /* "TOK_LP" */
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1435 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1650 "ast_expr2.c"
break;
- case 23: /* "TOK_RP" */
-#line 251 "ast_expr2.y"
+ case 24: /* "TOK_RP" */
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1440 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1659 "ast_expr2.c"
break;
- case 24: /* "TOKEN" */
-#line 251 "ast_expr2.y"
+ case 25: /* "TOKEN" */
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1445 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1668 "ast_expr2.c"
break;
- case 28: /* "expr" */
-#line 251 "ast_expr2.y"
+ case 29: /* "expr" */
+
+/* Line 1000 of yacc.c */
+#line 368 "ast_expr2.y"
{ free_value((yyvaluep->val)); };
-#line 1450 "ast_expr2.c"
+
+/* Line 1000 of yacc.c */
+#line 1677 "ast_expr2.c"
break;
default:
break;
}
}
-\f
/* Prevent warnings from -Wmissing-prototypes. */
-
#ifdef YYPARSE_PARAM
#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
-
-/*----------.
-| yyparse. |
-`----------*/
+/*-------------------------.
+| yyparse or yypush_parse. |
+`-------------------------*/
#ifdef YYPARSE_PARAM
#if (defined __STDC__ || defined __C99__FUNC__ \
#endif
#endif
{
- /* The look-ahead symbol. */
+/* The lookahead symbol. */
int yychar;
-/* The semantic value of the look-ahead symbol. */
+/* The semantic value of the lookahead symbol. */
YYSTYPE yylval;
-/* Number of syntax errors so far. */
-int yynerrs;
-/* Location data for the look-ahead symbol. */
+/* Location data for the lookahead symbol. */
YYLTYPE yylloc;
- int yystate;
- int yyn;
- int yyresult;
- /* Number of tokens to shift before error messages enabled. */
- int yyerrstatus;
- /* Look-ahead token as an internal (translated) token number. */
- int yytoken = 0;
-#if YYERROR_VERBOSE
- /* Buffer for error messages, and its allocated size. */
- char yymsgbuf[128];
- char *yymsg = yymsgbuf;
- YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
-#endif
+ /* Number of syntax errors so far. */
+ int yynerrs;
+
+ int yystate;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
- /* Three stacks and their tools:
- `yyss': related to states,
- `yyvs': related to semantic values,
- `yyls': related to locations.
+ /* The stacks and their tools:
+ `yyss': related to states.
+ `yyvs': related to semantic values.
+ `yyls': related to locations.
- Refer to the stacks thru separate pointers, to allow yyoverflow
- to reallocate them elsewhere. */
+ Refer to the stacks thru separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
- /* The state stack. */
- yytype_int16 yyssa[YYINITDEPTH];
- yytype_int16 *yyss = yyssa;
- yytype_int16 *yyssp;
+ /* The state stack. */
+ yytype_int16 yyssa[YYINITDEPTH];
+ yytype_int16 *yyss;
+ yytype_int16 *yyssp;
- /* The semantic value stack. */
- YYSTYPE yyvsa[YYINITDEPTH];
- YYSTYPE *yyvs = yyvsa;
- YYSTYPE *yyvsp;
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs;
+ YYSTYPE *yyvsp;
- /* The location stack. */
- YYLTYPE yylsa[YYINITDEPTH];
- YYLTYPE *yyls = yylsa;
- YYLTYPE *yylsp;
- /* The locations where the error started and ended. */
- YYLTYPE yyerror_range[2];
+ /* The location stack. */
+ YYLTYPE yylsa[YYINITDEPTH];
+ YYLTYPE *yyls;
+ YYLTYPE *yylsp;
-#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+ /* The locations where the error started and ended. */
+ YYLTYPE yyerror_range[2];
- YYSIZE_T yystacksize = YYINITDEPTH;
+ YYSIZE_T yystacksize;
+ int yyn;
+ int yyresult;
+ /* Lookahead token as an internal (translated) token number. */
+ int yytoken;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
YYLTYPE yyloc;
+#if YYERROR_VERBOSE
+ /* Buffer for error messages, and its allocated size. */
+ char yymsgbuf[128];
+ char *yymsg = yymsgbuf;
+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
+ yytoken = 0;
+ yyss = yyssa;
+ yyvs = yyvsa;
+ yyls = yylsa;
+ yystacksize = YYINITDEPTH;
+
YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
- yychar = YYEMPTY; /* Cause a token to be read. */
+ yychar = YYEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
-
yyssp = yyss;
yyvsp = yyvs;
yylsp = yyls;
+
#if YYLTYPE_IS_TRIVIAL
/* Initialize the default location before parsing starts. */
yylloc.first_line = yylloc.last_line = 1;
- yylloc.first_column = yylloc.last_column = 0;
+ yylloc.first_column = yylloc.last_column = 1;
#endif
goto yysetstate;
&yyvs1, yysize * sizeof (*yyvsp),
&yyls1, yysize * sizeof (*yylsp),
&yystacksize);
+
yyls = yyls1;
yyss = yyss1;
yyvs = yyvs1;
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyexhaustedlab;
- YYSTACK_RELOCATE (yyss);
- YYSTACK_RELOCATE (yyvs);
- YYSTACK_RELOCATE (yyls);
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+ YYSTACK_RELOCATE (yyls_alloc, yyls);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
goto yybackup;
/*-----------.
yybackup:
/* Do appropriate processing given the current state. Read a
- look-ahead token if we need one and don't already have one. */
+ lookahead token if we need one and don't already have one. */
- /* First try to decide what to do without reference to look-ahead token. */
+ /* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;
- /* Not known => get a look-ahead token if don't already have one. */
+ /* Not known => get a lookahead token if don't already have one. */
- /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
+ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
goto yyreduce;
}
- if (yyn == YYFINAL)
- YYACCEPT;
-
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
- /* Shift the look-ahead token. */
+ /* Shift the lookahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- /* Discard the shifted token unless it is eof. */
- if (yychar != YYEOF)
- yychar = YYEMPTY;
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
yystate = yyn;
*++yyvsp = yylval;
switch (yyn)
{
case 2:
-#line 257 "ast_expr2.y"
+
+/* Line 1455 of yacc.c */
+#line 374 "ast_expr2.y"
{ ((struct parse_io *)parseio)->val = (struct val *)calloc(sizeof(struct val),1);
((struct parse_io *)parseio)->val->type = (yyvsp[(1) - (1)].val)->type;
if( (yyvsp[(1) - (1)].val)->type == AST_EXPR_number )
((struct parse_io *)parseio)->val->u.i = (yyvsp[(1) - (1)].val)->u.i;
else
- ((struct parse_io *)parseio)->val->u.s = (yyvsp[(1) - (1)].val)->u.s;
+ ((struct parse_io *)parseio)->val->u.s = (yyvsp[(1) - (1)].val)->u.s;
free((yyvsp[(1) - (1)].val));
;}
break;
case 3:
-#line 265 "ast_expr2.y"
+
+/* Line 1455 of yacc.c */
+#line 382 "ast_expr2.y"
{/* nothing */ ((struct parse_io *)parseio)->val = (struct val *)calloc(sizeof(struct val),1);
((struct parse_io *)parseio)->val->type = AST_EXPR_string;
- ((struct parse_io *)parseio)->val->u.s = strdup("");
+ ((struct parse_io *)parseio)->val->u.s = strdup("");
;}
break;
case 4:
-#line 272 "ast_expr2.y"
+
+/* Line 1455 of yacc.c */
+#line 389 "ast_expr2.y"
{ (yyval.arglist) = alloc_expr_node(AST_EXPR_NODE_VAL); (yyval.arglist)->val = (yyvsp[(1) - (1)].val);;}
break;
case 5:
-#line 273 "ast_expr2.y"
+
+/* Line 1455 of yacc.c */
+#line 390 "ast_expr2.y"
{struct expr_node *x = alloc_expr_node(AST_EXPR_NODE_VAL);
struct expr_node *t;
DESTROY((yyvsp[(2) - (3)].val));
break;
case 6:
-#line 282 "ast_expr2.y"
+
+/* Line 1455 of yacc.c */
+#line 396 "ast_expr2.y"
+ {struct expr_node *x = alloc_expr_node(AST_EXPR_NODE_VAL);
+ struct expr_node *t; /* NULL args should OK */
+ DESTROY((yyvsp[(2) - (2)].val));
+ for (t=(yyvsp[(1) - (2)].arglist);t->right;t=t->right)
+ ;
+ (yyval.arglist) = (yyvsp[(1) - (2)].arglist); t->right = x; x->val = make_str("");;}
+ break;
+
+ case 7:
+
+/* Line 1455 of yacc.c */
+#line 405 "ast_expr2.y"
{ (yyval.val) = op_func((yyvsp[(1) - (4)].val),(yyvsp[(3) - (4)].arglist), ((struct parse_io *)parseio)->chan);
DESTROY((yyvsp[(2) - (4)].val));
DESTROY((yyvsp[(4) - (4)].val));
;}
break;
- case 7:
-#line 288 "ast_expr2.y"
+ case 8:
+
+/* Line 1455 of yacc.c */
+#line 411 "ast_expr2.y"
{(yyval.val) = (yyvsp[(1) - (1)].val);;}
break;
- case 8:
-#line 289 "ast_expr2.y"
+ case 9:
+
+/* Line 1455 of yacc.c */
+#line 412 "ast_expr2.y"
{ (yyval.val) = (yyvsp[(2) - (3)].val);
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;
DESTROY((yyvsp[(1) - (3)].val)); DESTROY((yyvsp[(3) - (3)].val)); ;}
break;
- case 9:
-#line 293 "ast_expr2.y"
+ case 10:
+
+/* Line 1455 of yacc.c */
+#line 416 "ast_expr2.y"
{ (yyval.val) = op_or ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
- case 10:
-#line 297 "ast_expr2.y"
- { (yyval.val) = op_and ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+ case 11:
+
+/* Line 1455 of yacc.c */
+#line 420 "ast_expr2.y"
+ { (yyval.val) = op_and ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
- case 11:
-#line 301 "ast_expr2.y"
+ case 12:
+
+/* Line 1455 of yacc.c */
+#line 424 "ast_expr2.y"
{ (yyval.val) = op_eq ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
(yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
- case 12:
-#line 305 "ast_expr2.y"
+ case 13:
+
+/* Line 1455 of yacc.c */
+#line 428 "ast_expr2.y"
{ (yyval.val) = op_gt ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
(yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
- case 13:
-#line 309 "ast_expr2.y"
- { (yyval.val) = op_lt ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
- (yyloc).first_line=0; (yyloc).last_line=0;;}
- break;
-
case 14:
-#line 313 "ast_expr2.y"
- { (yyval.val) = op_ge ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
- (yyloc).first_line=0; (yyloc).last_line=0;;}
+
+/* Line 1455 of yacc.c */
+#line 432 "ast_expr2.y"
+ { (yyval.val) = op_lt ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+ (yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 15:
-#line 317 "ast_expr2.y"
- { (yyval.val) = op_le ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+
+/* Line 1455 of yacc.c */
+#line 436 "ast_expr2.y"
+ { (yyval.val) = op_ge ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 16:
-#line 321 "ast_expr2.y"
- { (yyval.val) = op_ne ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+
+/* Line 1455 of yacc.c */
+#line 440 "ast_expr2.y"
+ { (yyval.val) = op_le ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 17:
-#line 325 "ast_expr2.y"
- { (yyval.val) = op_plus ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
- (yyloc).first_line=0; (yyloc).last_line=0;;}
+
+/* Line 1455 of yacc.c */
+#line 444 "ast_expr2.y"
+ { (yyval.val) = op_ne ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+ (yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 18:
-#line 329 "ast_expr2.y"
- { (yyval.val) = op_minus ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
- (yyloc).first_line=0; (yyloc).last_line=0;;}
+
+/* Line 1455 of yacc.c */
+#line 448 "ast_expr2.y"
+ { (yyval.val) = op_plus ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+ (yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 19:
-#line 333 "ast_expr2.y"
- { (yyval.val) = op_negate ((yyvsp[(2) - (2)].val));
- DESTROY((yyvsp[(1) - (2)].val));
- (yyloc).first_column = (yylsp[(1) - (2)]).first_column; (yyloc).last_column = (yylsp[(2) - (2)]).last_column;
+
+/* Line 1455 of yacc.c */
+#line 452 "ast_expr2.y"
+ { (yyval.val) = op_minus ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 20:
-#line 337 "ast_expr2.y"
- { (yyval.val) = op_compl ((yyvsp[(2) - (2)].val));
- DESTROY((yyvsp[(1) - (2)].val));
- (yyloc).first_column = (yylsp[(1) - (2)]).first_column; (yyloc).last_column = (yylsp[(2) - (2)]).last_column;
+
+/* Line 1455 of yacc.c */
+#line 456 "ast_expr2.y"
+ { (yyval.val) = op_negate ((yyvsp[(2) - (2)].val));
+ DESTROY((yyvsp[(1) - (2)].val));
+ (yyloc).first_column = (yylsp[(1) - (2)]).first_column; (yyloc).last_column = (yylsp[(2) - (2)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 21:
-#line 341 "ast_expr2.y"
- { (yyval.val) = op_times ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
- (yyloc).first_line=0; (yyloc).last_line=0;;}
+
+/* Line 1455 of yacc.c */
+#line 460 "ast_expr2.y"
+ { (yyval.val) = op_compl ((yyvsp[(2) - (2)].val));
+ DESTROY((yyvsp[(1) - (2)].val));
+ (yyloc).first_column = (yylsp[(1) - (2)]).first_column; (yyloc).last_column = (yylsp[(2) - (2)]).last_column;
+ (yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 22:
-#line 345 "ast_expr2.y"
- { (yyval.val) = op_div ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
- (yyloc).first_line=0; (yyloc).last_line=0;;}
+
+/* Line 1455 of yacc.c */
+#line 464 "ast_expr2.y"
+ { (yyval.val) = op_times ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+ (yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 23:
-#line 349 "ast_expr2.y"
- { (yyval.val) = op_rem ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+
+/* Line 1455 of yacc.c */
+#line 468 "ast_expr2.y"
+ { (yyval.val) = op_div ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 24:
-#line 353 "ast_expr2.y"
- { (yyval.val) = op_colon ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
- (yyloc).first_line=0; (yyloc).last_line=0;;}
+
+/* Line 1455 of yacc.c */
+#line 472 "ast_expr2.y"
+ { (yyval.val) = op_rem ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+ (yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 25:
-#line 357 "ast_expr2.y"
- { (yyval.val) = op_eqtilde ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
- DESTROY((yyvsp[(2) - (3)].val));
- (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+
+/* Line 1455 of yacc.c */
+#line 476 "ast_expr2.y"
+ { (yyval.val) = op_colon ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
case 26:
-#line 361 "ast_expr2.y"
- { (yyval.val) = op_cond ((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
- DESTROY((yyvsp[(2) - (5)].val));
- DESTROY((yyvsp[(4) - (5)].val));
- (yyloc).first_column = (yylsp[(1) - (5)]).first_column; (yyloc).last_column = (yylsp[(3) - (5)]).last_column;
+
+/* Line 1455 of yacc.c */
+#line 480 "ast_expr2.y"
+ { (yyval.val) = op_eqtilde ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
(yyloc).first_line=0; (yyloc).last_line=0;;}
break;
+ case 27:
+
+/* Line 1455 of yacc.c */
+#line 484 "ast_expr2.y"
+ { (yyval.val) = op_cond ((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
+ DESTROY((yyvsp[(2) - (5)].val));
+ DESTROY((yyvsp[(4) - (5)].val));
+ (yyloc).first_column = (yylsp[(1) - (5)]).first_column; (yyloc).last_column = (yylsp[(3) - (5)]).last_column;
+ (yyloc).first_line=0; (yyloc).last_line=0;;}
+ break;
+
+ case 28:
+
+/* Line 1455 of yacc.c */
+#line 489 "ast_expr2.y"
+ { (yyval.val) = op_tildetilde ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
+ DESTROY((yyvsp[(2) - (3)].val));
+ (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
+ (yyloc).first_line=0; (yyloc).last_line=0;;}
+ break;
+
+
-/* Line 1270 of yacc.c. */
-#line 1977 "ast_expr2.c"
+/* Line 1455 of yacc.c */
+#line 2283 "ast_expr2.c"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
if (yyerrstatus == 3)
{
- /* If just tried and failed to reuse look-ahead token after an
+ /* If just tried and failed to reuse lookahead token after an
error, discard it. */
if (yychar <= YYEOF)
}
}
- /* Else will try to reuse look-ahead token after shifting the error
+ /* Else will try to reuse lookahead token after shifting the error
token. */
goto yyerrlab1;
YY_STACK_PRINT (yyss, yyssp);
}
- if (yyn == YYFINAL)
- YYACCEPT;
-
*++yyvsp = yylval;
yyerror_range[1] = yylloc;
/* Using YYLLOC is tempting, but would change the location of
- the look-ahead. YYLOC is available though. */
+ the lookahead. YYLOC is available though. */
YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
*++yylsp = yyloc;
yyresult = 1;
goto yyreturn;
-#ifndef yyoverflow
+#if !defined(yyoverflow) || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
#endif
yyreturn:
- if (yychar != YYEOF && yychar != YYEMPTY)
+ if (yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval, &yylloc);
/* Do not reclaim the symbols of the rule which action triggered
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
- return yyresult;
+ /* Make sure YYID is used. */
+ return YYID (yyresult);
}
-#line 368 "ast_expr2.y"
+
+/* Line 1675 of yacc.c */
+#line 495 "ast_expr2.y"
static struct expr_node *alloc_expr_node(enum node_type nt)
vp->type = AST_EXPR_number;
vp->u.i = i;
- return vp;
+ return vp;
}
static struct val *
vp = (struct val *) malloc (sizeof (*vp));
if (vp == NULL || ((vp->u.s = strdup (s)) == NULL)) {
+ if (vp) {
+ free(vp);
+ }
ast_log(LOG_WARNING,"malloc() failed\n");
return(NULL);
}
}
if (isint)
vp->type = AST_EXPR_numeric_string;
- else
+ else
vp->type = AST_EXPR_string;
return vp;
static void
free_value (struct val *vp)
-{
+{
if (vp==NULL) {
return;
}
if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
- free (vp->u.s);
+ free (vp->u.s);
free(vp);
}
to_number (struct val *vp)
{
FP___TYPE i;
-
+
if (vp == NULL) {
ast_log(LOG_WARNING,"vp==NULL in to_number()\n");
return(0);
/* vp->type == AST_EXPR_numeric_string, make it numeric */
errno = 0;
- i = FP___STRTOD(vp->u.s, (char**)0); /* either strtod, or strtold on a good day */
+ i = FUNC_STRTOD(vp->u.s, (char**)0); /* either strtod, or strtold on a good day */
if (errno != 0) {
ast_log(LOG_WARNING,"Conversion of %s to number under/overflowed!\n", vp->u.s);
free(vp->u.s);
{
if (vp->type != AST_EXPR_string && vp->type != AST_EXPR_numeric_string)
return;
-
+
if( vp->u.s[0] == '"' && vp->u.s[strlen(vp->u.s)-1] == '"' )
{
char *f, *t;
f = vp->u.s;
t = vp->u.s;
-
+
while( *f )
{
if( *f && *f != '"' )
if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
return;
- tmp = malloc ((size_t)25);
- if (tmp == NULL) {
- ast_log(LOG_WARNING,"malloc() failed\n");
+ if (asprintf(&tmp, FP___PRINTF, vp->u.i) == -1) {
+ ast_log(LOG_WARNING, "asprintf() failed\n");
return;
}
- sprintf(tmp, FP___PRINTF, vp->u.i);
vp->type = AST_EXPR_string;
vp->u.s = tmp;
}
/* NOTREACHED */
}
-#ifdef STANDALONE
+#ifdef STANDALONE2
void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
{
va_list vars;
va_start(vars,fmt);
-
+
printf("LOG: lev:%d file:%s line:%d func: %s ",
level, file, line, function);
vprintf(fmt, vars);
char s[4096];
char out[4096];
FILE *infile;
-
+
if( !argv[1] )
exit(20);
-
+
if( access(argv[1],F_OK)== 0 )
{
int ret;
-
+
infile = fopen(argv[1],"r");
if( !infile )
{
{
if( s[strlen(s)-1] == '\n' )
s[strlen(s)-1] = 0;
-
- ret = ast_expr(s, out, sizeof(out),NULL);
+
+ ret = ast_expr(s, out, sizeof(out), NULL);
printf("Expression: %s Result: [%d] '%s'\n",
s, ret, out);
}
else
printf("No result\n");
}
+ return 0;
}
#endif
static void destroy_arglist(struct expr_node *arglist)
{
struct expr_node *arglist_next;
-
+
while (arglist)
{
arglist_next = arglist->right;
}
}
+#if !defined(STANDALONE) && !defined(STANDALONE2)
static char *compose_func_args(struct expr_node *arglist)
{
struct expr_node *t = arglist;
char *argbuf;
int total_len = 0;
-
+
while (t) {
if (t != arglist)
total_len += 1; /* for the sep */
else
total_len += strlen(t->val->u.s);
}
-
+
t = t->right;
}
total_len++; /* for the null */
t = arglist;
while (t) {
char numbuf[30];
-
+
if (t != arglist)
- strcat(argbuf,"|");
-
+ strcat(argbuf,",");
+
if (t->val) {
if (t->val->type == AST_EXPR_number) {
sprintf(numbuf,FP___PRINTF,t->val->u.i);
}
t = t->right;
}
- ast_log(LOG_NOTICE,"argbuf uses %d bytes;\n", strlen(argbuf));
+ ast_log(LOG_NOTICE,"argbuf uses %d bytes;\n", (int) strlen(argbuf));
return argbuf;
}
else
return 0;
}
-
+#endif
static struct val *op_func(struct val *funcname, struct expr_node *arglist, struct ast_channel *chan)
{
if (strspn(funcname->u.s,"ABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789") == strlen(funcname->u.s))
{
struct val *result;
-
- if (strcmp(funcname->u.s,"COS") == 0) {
+ if (0) {
+#ifdef FUNC_COS
+ } else if (strcmp(funcname->u.s,"COS") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
result = make_number(FUNC_COS(arglist->val->u.i));
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_SIN
} else if (strcmp(funcname->u.s,"SIN") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_TAN
} else if (strcmp(funcname->u.s,"TAN") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_ACOS
} else if (strcmp(funcname->u.s,"ACOS") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_ASIN
} else if (strcmp(funcname->u.s,"ASIN") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_ATAN
} else if (strcmp(funcname->u.s,"ATAN") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_ATAN2
} else if (strcmp(funcname->u.s,"ATAN2") == 0) {
if (arglist && arglist->right && !arglist->right->right && arglist->val && arglist->right->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_POW
} else if (strcmp(funcname->u.s,"POW") == 0) {
if (arglist && arglist->right && !arglist->right->right && arglist->val && arglist->right->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_SQRT
} else if (strcmp(funcname->u.s,"SQRT") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_FLOOR
} else if (strcmp(funcname->u.s,"FLOOR") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_CEIL
} else if (strcmp(funcname->u.s,"CEIL") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_ROUND
} else if (strcmp(funcname->u.s,"ROUND") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif /* defined(FUNC_ROUND) */
+#ifdef FUNC_RINT
} else if (strcmp(funcname->u.s,"RINT") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_TRUNC
} else if (strcmp(funcname->u.s,"TRUNC") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif /* defined(FUNC_TRUNC) */
+#ifdef FUNC_EXP
} else if (strcmp(funcname->u.s,"EXP") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_EXP2
} else if (strcmp(funcname->u.s,"EXP2") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_EXP10
+ } else if (strcmp(funcname->u.s,"EXP10") == 0) {
+ if (arglist && !arglist->right && arglist->val){
+ to_number(arglist->val);
+ result = make_number(FUNC_EXP10(arglist->val->u.i));
+ return result;
+ } else {
+ ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
+ return make_number(0.0);
+ }
+#endif
+#ifdef FUNC_LOG
} else if (strcmp(funcname->u.s,"LOG") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_LOG2
} else if (strcmp(funcname->u.s,"LOG2") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_LOG10
} else if (strcmp(funcname->u.s,"LOG10") == 0) {
if (arglist && !arglist->right && arglist->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+#ifdef FUNC_REMAINDER
} else if (strcmp(funcname->u.s,"REMAINDER") == 0) {
if (arglist && arglist->right && !arglist->right->right && arglist->val && arglist->right->val){
to_number(arglist->val);
ast_log(LOG_WARNING,"Wrong args to %s() function\n",funcname->u.s);
return make_number(0.0);
}
+#endif
+ } else if (strcmp(funcname->u.s, "ABS") == 0) {
+ if (arglist && !arglist->right && arglist->val) {
+ to_number(arglist->val);
+ result = make_number(arglist->val->u.i < 0 ? arglist->val->u.i * -1 : arglist->val->u.i);
+ return result;
+ } else {
+ ast_log(LOG_WARNING, "Wrong args to %s() function\n", funcname->u.s);
+ return make_number(0.0);
+ }
} else {
/* is this a custom function we should execute and collect the results of? */
-#ifndef STANDALONE
+#if !defined(STANDALONE) && !defined(STANDALONE2)
struct ast_custom_function *f = ast_custom_function_find(funcname->u.s);
if (!chan)
ast_log(LOG_WARNING,"Hey! chan is NULL.\n");
if (!f)
ast_log(LOG_WARNING,"Hey! could not find func %s.\n", funcname->u.s);
-
+
if (f && chan) {
if (f->read) {
char workspace[512];
f->read(chan, funcname->u.s, argbuf, workspace, sizeof(workspace));
free(argbuf);
if (is_really_num(workspace))
- return make_number(FP___STRTOD(workspace,(char **)NULL));
+ return make_number(FUNC_STRTOD(workspace,(char **)NULL));
else
return make_str(workspace);
} else {
ast_log(LOG_ERROR,"Error! Function '%s' cannot be read!\n", funcname->u.s);
return (make_number ((FP___TYPE)0.0));
}
-
+
} else {
- ast_log(LOG_ERROR,"Error! '%s' doesn't appear to be an available function!", funcname->u.s);
+ ast_log(LOG_ERROR, "Error! '%s' doesn't appear to be an available function!\n", funcname->u.s);
return (make_number ((FP___TYPE)0.0));
}
#else
- ast_log(LOG_ERROR,"Error! '%s' is not available in the standalone version!", funcname->u.s);
+ ast_log(LOG_ERROR, "Error! '%s' is not available in the standalone version!\n", funcname->u.s);
return (make_number ((FP___TYPE)0.0));
#endif
}
}
else
{
- ast_log(LOG_ERROR,"Error! '%s' is not possibly a function name!", funcname->u.s);
+ ast_log(LOG_ERROR, "Error! '%s' is not possibly a function name!\n", funcname->u.s);
return (make_number ((FP___TYPE)0.0));
}
return (make_number ((FP___TYPE)0.0));
return (a);
}
}
-
+
static struct val *
op_and (struct val *a, struct val *b)
{
static struct val *
op_eq (struct val *a, struct val *b)
{
- struct val *r;
+ struct val *r;
if (isstring (a) || isstring (b)) {
to_string (a);
- to_string (b);
+ to_string (b);
r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) == 0));
} else {
#ifdef DEBUG_FOR_CONVERSIONS
{
int v1 = 1;
struct val *r;
-
+
if( !a )
{
v1 = 0;
if( a->u.i == 0 )
v1 = 0;
break;
-
+
case AST_EXPR_string:
if( a->u.s == 0 )
v1 = 0;
v1 = 0;
else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
v1 = 0;
+ else
+ v1 = atoi(a->u.s);
}
break;
-
+
case AST_EXPR_numeric_string:
if( a->u.s == 0 )
v1 = 0;
v1 = 0;
else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
v1 = 0;
+ else
+ v1 = atoi(a->u.s);
}
break;
}
}
-
+
r = make_number (!v1);
free_value (a);
return r;
}
if (b->u.i == 0) {
- ast_log(LOG_WARNING, "division by zero\n");
+ ast_log(LOG_WARNING, "division by zero\n");
free_value(a);
free_value(b);
return make_number(INT_MAX);
free_value (b);
return r;
}
-
+
static struct val *
op_rem (struct val *a, struct val *b)
{
return(b);
}
- r = make_number (FP___FMOD(a->u.i, b->u.i)); /* either fmod or fmodl if FP___TYPE is available */
+ r = make_number (FUNC_FMOD(a->u.i, b->u.i)); /* either fmod or fmodl if FP___TYPE is available */
/* chk_rem necessary ??? */
free_value (a);
free_value (b);
return r;
}
-
+
static struct val *
op_colon (struct val *a, struct val *b)
/* compile regular expression */
if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
regerror (eval, &rp, errbuf, sizeof(errbuf));
- ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
+ ast_log(LOG_WARNING, "regcomp() error : %s\n", errbuf);
free_value(a);
free_value(b);
- return make_str("");
+ return make_str("");
}
/* compare string against pattern */
return v;
}
-
+
static struct val *
op_eqtilde (struct val *a, struct val *b)
/* compile regular expression */
if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
regerror (eval, &rp, errbuf, sizeof(errbuf));
- ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
+ ast_log(LOG_WARNING, "regcomp() error : %s\n", errbuf);
free_value(a);
free_value(b);
- return make_str("");
+ return make_str("");
}
/* compare string against pattern */
return v;
}
+static struct val * /* this is a string concat operator */
+op_tildetilde (struct val *a, struct val *b)
+{
+ struct val *v;
+ char *vs;
+
+ /* coerce to both arguments to strings */
+ to_string(a);
+ to_string(b);
+ /* strip double quotes from both -- */
+ strip_quotes(a);
+ strip_quotes(b);
+
+ vs = malloc(strlen(a->u.s)+strlen(b->u.s)+1);
+ if (vs == NULL) {
+ ast_log(LOG_WARNING, "malloc() failed\n");
+ free_value(a);
+ free_value(b);
+ return NULL;
+ }
+
+ strcpy(vs,a->u.s);
+ strcat(vs,b->u.s);
+
+ v = make_str(vs);
+
+ free(vs);
+
+ /* free arguments */
+ free_value(a);
+ free_value(b);
+
+ return v;
+}
projects / asterisk/asterisk.git / blobdiff