main/ast_expr2.c

   1 /* A Bison parser, made by GNU Bison 2.1a.  */
   2
   3 /* Skeleton parser for Yacc-like parsing with Bison,
   4    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19    Boston, MA 02110-1301, USA.  */
  20
  21 /* As a special exception, when this file is copied by Bison into a
  22    Bison output file, you may use that output file without restriction.
  23    This special exception was added by the Free Software Foundation
  24    in version 1.24 of Bison.  */
  25
  26 /* C LALR(1) parser skeleton written by Richard Stallman, by
  27    simplifying the original so-called "semantic" parser.  */
  28
  29 /* All symbols defined below should begin with yy or YY, to avoid
  30    infringing on user name space.  This should be done even for local
  31    variables, as they might otherwise be expanded by user macros.
  32    There are some unavoidable exceptions within include files to
  33    define necessary library symbols; they are noted "INFRINGES ON
  34    USER NAME SPACE" below.  */
  35
  36 /* Identify Bison output.  */
  37 #define YYBISON 1
  38
  39 /* Bison version.  */
  40 #define YYBISON_VERSION "2.1a"
  41
  42 /* Skeleton name.  */
  43 #define YYSKELETON_NAME "yacc.c"
  44
  45 /* Pure parsers.  */
  46 #define YYPURE 1
  47
  48 /* Using locations.  */
  49 #define YYLSP_NEEDED 1
  50
  51 /* Substitute the variable and function names.  */
  52 #define yyparse ast_yyparse
  53 #define yylex   ast_yylex
  54 #define yyerror ast_yyerror
  55 #define yylval  ast_yylval
  56 #define yychar  ast_yychar
  57 #define yydebug ast_yydebug
  58 #define yynerrs ast_yynerrs
  59 #define yylloc ast_yylloc
  60
  61 /* Tokens.  */
  62 #ifndef YYTOKENTYPE
  63 # define YYTOKENTYPE
  64    /* Put the tokens into the symbol table, so that GDB and other debuggers
  65       know about them.  */
  66    enum yytokentype {
  67      TOK_COLONCOLON = 258,
  68      TOK_COND = 259,
  69      TOK_OR = 260,
  70      TOK_AND = 261,
  71      TOK_NE = 262,
  72      TOK_LE = 263,
  73      TOK_GE = 264,
  74      TOK_LT = 265,
  75      TOK_GT = 266,
  76      TOK_EQ = 267,
  77      TOK_MINUS = 268,
  78      TOK_PLUS = 269,
  79      TOK_MOD = 270,
  80      TOK_DIV = 271,
  81      TOK_MULT = 272,
  82      TOK_COMPL = 273,
  83      TOK_EQTILDE = 274,
  84      TOK_COLON = 275,
  85      TOK_LP = 276,
  86      TOK_RP = 277,
  87      TOKEN = 278
  88    };
  89 #endif
  90 /* Tokens.  */
  91 #define TOK_COLONCOLON 258
  92 #define TOK_COND 259
  93 #define TOK_OR 260
  94 #define TOK_AND 261
  95 #define TOK_NE 262
  96 #define TOK_LE 263
  97 #define TOK_GE 264
  98 #define TOK_LT 265
  99 #define TOK_GT 266
 100 #define TOK_EQ 267
 101 #define TOK_MINUS 268
 102 #define TOK_PLUS 269
 103 #define TOK_MOD 270
 104 #define TOK_DIV 271
 105 #define TOK_MULT 272
 106 #define TOK_COMPL 273
 107 #define TOK_EQTILDE 274
 108 #define TOK_COLON 275
 109 #define TOK_LP 276
 110 #define TOK_RP 277
 111 #define TOKEN 278
 112
 113
 114
 115
 116 /* Copy the first part of user declarations.  */
 117 #line 1 "ast_expr2.y"
 118
 119 /* Written by Pace Willisson (pace@blitz.com)
 120  * and placed in the public domain.
 121  *
 122  * Largely rewritten by J.T. Conklin (jtc@wimsey.com)
 123  *
 124  * And then overhauled twice by Steve Murphy (murf@digium.com)
 125  * to add double-quoted strings, allow mult. spaces, improve
 126  * error messages, and then to fold in a flex scanner for the
 127  * yylex operation.
 128  *
 129  * $FreeBSD: src/bin/expr/expr.y,v 1.16 2000/07/22 10:59:36 se Exp $
 130  */
 131
 132 #include <sys/types.h>
 133 #include <stdio.h>
 134
 135 #ifdef STANDALONE /* I guess somewhere, the feature is set in the asterisk includes */
 136 #ifndef __USE_ISOC99
 137 #define __USE_ISOC99 1
 138 #endif
 139 #endif
 140
 141 #ifdef __USE_ISOC99
 142 #define FP___PRINTF "%.16Lg"
 143 #define FP___FMOD   fmodl
 144 #define FP___STRTOD  strtold
 145 #define FP___TYPE    long double
 146 #else
 147 #define FP___PRINTF "%.8g"
 148 #define FP___FMOD   fmod
 149 #define FP___STRTOD  strtod
 150 #define FP___TYPE    double
 151 #endif
 152
 153 #include <stdlib.h>
 154 #ifndef _GNU_SOURCE
 155 #define _GNU_SOURCE
 156 #endif
 157 #include <string.h>
 158 #include <math.h>
 159 #include <locale.h>
 160 #include <unistd.h>
 161 #include <ctype.h>
 162 #if !defined(SOLARIS) && !defined(__CYGWIN__)
 163         /* #include <err.h> */
 164 #else
 165 #define quad_t int64_t
 166 #endif
 167 #include <errno.h>
 168 #include <regex.h>
 169 #include <limits.h>
 170
 171 #include "asterisk.h"
 172 #include "asterisk/ast_expr.h"
 173 #include "asterisk/logger.h"
 174
 175 #if defined(LONG_LONG_MIN) && !defined(QUAD_MIN)
 176 #define QUAD_MIN LONG_LONG_MIN
 177 #endif
 178 #if defined(LONG_LONG_MAX) && !defined(QUAD_MAX)
 179 #define QUAD_MAX LONG_LONG_MAX
 180 #endif
 181
 182 #  if ! defined(QUAD_MIN)
 183 #   define QUAD_MIN     (-0x7fffffffffffffffLL-1)
 184 #  endif
 185 #  if ! defined(QUAD_MAX)
 186 #   define QUAD_MAX     (0x7fffffffffffffffLL)
 187 #  endif
 188 #define YYENABLE_NLS 0
 189 #define YYPARSE_PARAM parseio
 190 #define YYLEX_PARAM ((struct parse_io *)parseio)->scanner
 191 #define YYERROR_VERBOSE 1
 192 extern char extra_error_message[4095];
 193 extern int extra_error_message_supplied;
 194
 195 enum valtype {
 196         AST_EXPR_number, AST_EXPR_numeric_string, AST_EXPR_string
 197 } ;
 198
 199 #ifdef STANDALONE
 200 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...) __attribute__ ((format (printf,5,6)));
 201 #endif
 202
 203 struct val {
 204         enum valtype type;
 205         union {
 206                 char *s;
 207                 FP___TYPE i; /* either long double, or just double, on a bad day */
 208         } u;
 209 } ;
 210
 211 typedef void *yyscan_t;
 212
 213 struct parse_io
 214 {
 215         char *string;
 216         struct val *val;
 217         yyscan_t scanner;
 218 };
 219
 220 static int              chk_div __P((FP___TYPE, FP___TYPE));
 221 static int              chk_minus __P((FP___TYPE, FP___TYPE, FP___TYPE));
 222 static int              chk_plus __P((FP___TYPE, FP___TYPE, FP___TYPE));
 223 static int              chk_times __P((FP___TYPE, FP___TYPE, FP___TYPE));
 224 static void             free_value __P((struct val *));
 225 static int              is_zero_or_null __P((struct val *));
 226 static int              isstring __P((struct val *));
 227 static struct val       *make_number __P((FP___TYPE));
 228 static struct val       *make_str __P((const char *));
 229 static struct val       *op_and __P((struct val *, struct val *));
 230 static struct val       *op_colon __P((struct val *, struct val *));
 231 static struct val       *op_eqtilde __P((struct val *, struct val *));
 232 static struct val       *op_div __P((struct val *, struct val *));
 233 static struct val       *op_eq __P((struct val *, struct val *));
 234 static struct val       *op_ge __P((struct val *, struct val *));
 235 static struct val       *op_gt __P((struct val *, struct val *));
 236 static struct val       *op_le __P((struct val *, struct val *));
 237 static struct val       *op_lt __P((struct val *, struct val *));
 238 static struct val       *op_cond __P((struct val *, struct val *, struct val *));
 239 static struct val       *op_minus __P((struct val *, struct val *));
 240 static struct val       *op_negate __P((struct val *));
 241 static struct val       *op_compl __P((struct val *));
 242 static struct val       *op_ne __P((struct val *, struct val *));
 243 static struct val       *op_or __P((struct val *, struct val *));
 244 static struct val       *op_plus __P((struct val *, struct val *));
 245 static struct val       *op_rem __P((struct val *, struct val *));
 246 static struct val       *op_times __P((struct val *, struct val *));
 247 static int              to_number __P((struct val *));
 248 static void             to_string __P((struct val *));
 249
 250 /* uh, if I want to predeclare yylex with a YYLTYPE, I have to predeclare the yyltype... sigh */
 251 typedef struct yyltype
 252 {
 253   int first_line;
 254   int first_column;
 255
 256   int last_line;
 257   int last_column;
 258 } yyltype;
 259
 260 # define YYLTYPE yyltype
 261 # define YYLTYPE_IS_TRIVIAL 1
 262
 263 /* we will get warning about no prototype for yylex! But we can't
 264    define it here, we have no definition yet for YYSTYPE. */
 265
 266 int             ast_yyerror(const char *,YYLTYPE *, struct parse_io *);
 267
 268 /* I wanted to add args to the yyerror routine, so I could print out
 269    some useful info about the error. Not as easy as it looks, but it
 270    is possible. */
 271 #define ast_yyerror(x) ast_yyerror(x,&yyloc,parseio)
 272 #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);}
 273
 274
 275 /* Enabling traces.  */
 276 #ifndef YYDEBUG
 277 # define YYDEBUG 0
 278 #endif
 279
 280 /* Enabling verbose error messages.  */
 281 #ifdef YYERROR_VERBOSE
 282 # undef YYERROR_VERBOSE
 283 # define YYERROR_VERBOSE 1
 284 #else
 285 # define YYERROR_VERBOSE 0
 286 #endif
 287
 288 /* Enabling the token table.  */
 289 #ifndef YYTOKEN_TABLE
 290 # define YYTOKEN_TABLE 0
 291 #endif
 292
 293 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 294 typedef union YYSTYPE
 295 #line 165 "ast_expr2.y"
 296 {
 297         struct val *val;
 298 }
 299 /* Line 198 of yacc.c.  */
 300 #line 301 "ast_expr2.c"
 301         YYSTYPE;
 302 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 303 # define YYSTYPE_IS_DECLARED 1
 304 # define YYSTYPE_IS_TRIVIAL 1
 305 #endif
 306
 307 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
 308 typedef struct YYLTYPE
 309 {
 310   int first_line;
 311   int first_column;
 312   int last_line;
 313   int last_column;
 314 } YYLTYPE;
 315 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
 316 # define YYLTYPE_IS_DECLARED 1
 317 # define YYLTYPE_IS_TRIVIAL 1
 318 #endif
 319
 320
 321 /* Copy the second part of user declarations.  */
 322 #line 169 "ast_expr2.y"
 323
 324 extern int              ast_yylex __P((YYSTYPE *, YYLTYPE *, yyscan_t));
 325
 326
 327 /* Line 221 of yacc.c.  */
 328 #line 329 "ast_expr2.c"
 329
 330 #ifdef short
 331 # undef short
 332 #endif
 333
 334 #ifdef YYTYPE_UINT8
 335 typedef YYTYPE_UINT8 yytype_uint8;
 336 #else
 337 typedef unsigned char yytype_uint8;
 338 #endif
 339
 340 #ifdef YYTYPE_INT8
 341 typedef YYTYPE_INT8 yytype_int8;
 342 #elif (defined __STDC__ || defined __C99__FUNC__ \
 343      || defined __cplusplus || defined _MSC_VER)
 344 typedef signed char yytype_int8;
 345 #else
 346 typedef short int yytype_int8;
 347 #endif
 348
 349 #ifdef YYTYPE_UINT16
 350 typedef YYTYPE_UINT16 yytype_uint16;
 351 #else
 352 typedef unsigned short int yytype_uint16;
 353 #endif
 354
 355 #ifdef YYTYPE_INT16
 356 typedef YYTYPE_INT16 yytype_int16;
 357 #else
 358 typedef short int yytype_int16;
 359 #endif
 360
 361 #ifndef YYSIZE_T
 362 # ifdef __SIZE_TYPE__
 363 #  define YYSIZE_T __SIZE_TYPE__
 364 # elif defined size_t
 365 #  define YYSIZE_T size_t
 366 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 367      || defined __cplusplus || defined _MSC_VER)
 368 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 369 #  define YYSIZE_T size_t
 370 # else
 371 #  define YYSIZE_T unsigned int
 372 # endif
 373 #endif
 374
 375 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 376
 377 #ifndef YY_
 378 # if YYENABLE_NLS
 379 #  if ENABLE_NLS
 380 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 381 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 382 #  endif
 383 # endif
 384 # ifndef YY_
 385 #  define YY_(msgid) msgid
 386 # endif
 387 #endif
 388
 389 /* Suppress unused-variable warnings by "using" E.  */
 390 #if ! defined lint || defined __GNUC__
 391 # define YYUSE(e) ((void) (e))
 392 #else
 393 # define YYUSE(e) /* empty */
 394 #endif
 395
 396 /* Identity function, used to suppress warnings about constant conditions.  */
 397 #ifndef lint
 398 # define YYID(n) (n)
 399 #else
 400 #if (defined __STDC__ || defined __C99__FUNC__ \
 401      || defined __cplusplus || defined _MSC_VER)
 402 static int
 403 YYID (int i)
 404 #else
 405 static int
 406 YYID (i)
 407     int i;
 408 #endif
 409 {
 410   return i;
 411 }
 412 #endif
 413
 414 #if ! defined yyoverflow || YYERROR_VERBOSE
 415
 416 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 417
 418 # ifdef YYSTACK_USE_ALLOCA
 419 #  if YYSTACK_USE_ALLOCA
 420 #   ifdef __GNUC__
 421 #    define YYSTACK_ALLOC __builtin_alloca
 422 #   elif defined __BUILTIN_VA_ARG_INCR
 423 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 424 #   elif defined _AIX
 425 #    define YYSTACK_ALLOC __alloca
 426 #   elif defined _MSC_VER
 427 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 428 #    define alloca _alloca
 429 #   else
 430 #    define YYSTACK_ALLOC alloca
 431 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 432      || defined __cplusplus || defined _MSC_VER)
 433 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 434 #     ifndef _STDLIB_H
 435 #      define _STDLIB_H 1
 436 #     endif
 437 #    endif
 438 #   endif
 439 #  endif
 440 # endif
 441
 442 # ifdef YYSTACK_ALLOC
 443    /* Pacify GCC's `empty if-body' warning.  */
 444 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 445 #  ifndef YYSTACK_ALLOC_MAXIMUM
 446     /* The OS might guarantee only one guard page at the bottom of the stack,
 447        and a page size can be as small as 4096 bytes.  So we cannot safely
 448        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 449        to allow for a few compiler-allocated temporary stack slots.  */
 450 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 451 #  endif
 452 # else
 453 #  define YYSTACK_ALLOC YYMALLOC
 454 #  define YYSTACK_FREE YYFREE
 455 #  ifndef YYSTACK_ALLOC_MAXIMUM
 456 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 457 #  endif
 458 #  ifdef __cplusplus
 459 extern "C" {
 460 #  endif
 461 #  ifndef YYMALLOC
 462 #   define YYMALLOC malloc
 463 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 464      || defined __cplusplus || defined _MSC_VER)
 465 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 466 #   endif
 467 #  endif
 468 #  ifndef YYFREE
 469 #   define YYFREE free
 470 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 471      || defined __cplusplus || defined _MSC_VER)
 472 void free (void *); /* INFRINGES ON USER NAME SPACE */
 473 #   endif
 474 #  endif
 475 #  ifdef __cplusplus
 476 }
 477 #  endif
 478 # endif
 479 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 480
 481
 482 #if (! defined yyoverflow \
 483      && (! defined __cplusplus \
 484          || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
 485              && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 486
 487 /* A type that is properly aligned for any stack member.  */
 488 union yyalloc
 489 {
 490   yytype_int16 yyss;
 491   YYSTYPE yyvs;
 492     YYLTYPE yyls;
 493 };
 494
 495 /* The size of the maximum gap between one aligned stack and the next.  */
 496 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 497
 498 /* The size of an array large to enough to hold all stacks, each with
 499    N elements.  */
 500 # define YYSTACK_BYTES(N) \
 501      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
 502       + 2 * YYSTACK_GAP_MAXIMUM)
 503
 504 /* Copy COUNT objects from FROM to TO.  The source and destination do
 505    not overlap.  */
 506 # ifndef YYCOPY
 507 #  if defined __GNUC__ && 1 < __GNUC__
 508 #   define YYCOPY(To, From, Count) \
 509       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 510 #  else
 511 #   define YYCOPY(To, From, Count)              \
 512       do                                        \
 513         {                                       \
 514           YYSIZE_T yyi;                         \
 515           for (yyi = 0; yyi < (Count); yyi++)   \
 516             (To)[yyi] = (From)[yyi];            \
 517         }                                       \
 518       while (YYID (0))
 519 #  endif
 520 # endif
 521
 522 /* Relocate STACK from its old location to the new one.  The
 523    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 524    elements in the stack, and YYPTR gives the new location of the
 525    stack.  Advance YYPTR to a properly aligned location for the next
 526    stack.  */
 527 # define YYSTACK_RELOCATE(Stack)                                        \
 528     do                                                                  \
 529       {                                                                 \
 530         YYSIZE_T yynewbytes;                                            \
 531         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 532         Stack = &yyptr->Stack;                                          \
 533         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 534         yyptr += yynewbytes / sizeof (*yyptr);                          \
 535       }                                                                 \
 536     while (YYID (0))
 537
 538 #endif
 539
 540 /* YYFINAL -- State number of the termination state.  */
 541 #define YYFINAL  10
 542 /* YYLAST -- Last index in YYTABLE.  */
 543 #define YYLAST   140
 544
 545 /* YYNTOKENS -- Number of terminals.  */
 546 #define YYNTOKENS  24
 547 /* YYNNTS -- Number of nonterminals.  */
 548 #define YYNNTS  3
 549 /* YYNRULES -- Number of rules.  */
 550 #define YYNRULES  23
 551 /* YYNRULES -- Number of states.  */
 552 #define YYNSTATES  46
 553
 554 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 555 #define YYUNDEFTOK  2
 556 #define YYMAXUTOK   278
 557
 558 #define YYTRANSLATE(YYX)                                                \
 559   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 560
 561 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 562 static const yytype_uint8 yytranslate[] =
 563 {
 564        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 565        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 566        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 567        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 568        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 569        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 570        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 571        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 572        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 573        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 574        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 575        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 576        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 577        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 578        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 579        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 580        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 581        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 582        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 583        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 584        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 585        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 586        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 587        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 588        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 589        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 590        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 591       15,    16,    17,    18,    19,    20,    21,    22,    23
 592 };
 593
 594 #if YYDEBUG
 595 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 596    YYRHS.  */
 597 static const yytype_uint8 yyprhs[] =
 598 {
 599        0,     0,     3,     5,     6,     8,    12,    16,    20,    24,
 600       28,    32,    36,    40,    44,    48,    52,    55,    58,    62,
 601       66,    70,    74,    78
 602 };
 603
 604 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 605 static const yytype_int8 yyrhs[] =
 606 {
 607       25,     0,    -1,    26,    -1,    -1,    23,    -1,    21,    26,
 608       22,    -1,    26,     5,    26,    -1,    26,     6,    26,    -1,
 609       26,    12,    26,    -1,    26,    11,    26,    -1,    26,    10,
 610       26,    -1,    26,     9,    26,    -1,    26,     8,    26,    -1,
 611       26,     7,    26,    -1,    26,    14,    26,    -1,    26,    13,
 612       26,    -1,    13,    26,    -1,    18,    26,    -1,    26,    17,
 613       26,    -1,    26,    16,    26,    -1,    26,    15,    26,    -1,
 614       26,    20,    26,    -1,    26,    19,    26,    -1,    26,     4,
 615       26,     3,    26,    -1
 616 };
 617
 618 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 619 static const yytype_uint16 yyrline[] =
 620 {
 621        0,   193,   193,   201,   208,   209,   213,   217,   221,   225,
 622      229,   233,   237,   241,   245,   249,   253,   257,   261,   265,
 623      269,   273,   277,   281
 624 };
 625 #endif
 626
 627 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 628 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 629    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 630 static const char *const yytname[] =
 631 {
 632   "$end", "error", "$undefined", "TOK_COLONCOLON", "TOK_COND", "TOK_OR",
 633   "TOK_AND", "TOK_NE", "TOK_LE", "TOK_GE", "TOK_LT", "TOK_GT", "TOK_EQ",
 634   "TOK_MINUS", "TOK_PLUS", "TOK_MOD", "TOK_DIV", "TOK_MULT", "TOK_COMPL",
 635   "TOK_EQTILDE", "TOK_COLON", "TOK_LP", "TOK_RP", "TOKEN", "$accept",
 636   "start", "expr", 0
 637 };
 638 #endif
 639
 640 # ifdef YYPRINT
 641 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 642    token YYLEX-NUM.  */
 643 static const yytype_uint16 yytoknum[] =
 644 {
 645        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 646      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 647      275,   276,   277,   278
 648 };
 649 # endif
 650
 651 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 652 static const yytype_uint8 yyr1[] =
 653 {
 654        0,    24,    25,    25,    26,    26,    26,    26,    26,    26,
 655       26,    26,    26,    26,    26,    26,    26,    26,    26,    26,
 656       26,    26,    26,    26
 657 };
 658
 659 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 660 static const yytype_uint8 yyr2[] =
 661 {
 662        0,     2,     1,     0,     1,     3,     3,     3,     3,     3,
 663        3,     3,     3,     3,     3,     3,     2,     2,     3,     3,
 664        3,     3,     3,     5
 665 };
 666
 667 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 668    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 669    means the default is an error.  */
 670 static const yytype_uint8 yydefact[] =
 671 {
 672        3,     0,     0,     0,     4,     0,     2,    16,    17,     0,
 673        1,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 674        0,     0,     0,     0,     0,     0,     0,     5,     0,     6,
 675        7,    13,    12,    11,    10,     9,     8,    15,    14,    20,
 676       19,    18,    22,    21,     0,    23
 677 };
 678
 679 /* YYDEFGOTO[NTERM-NUM].  */
 680 static const yytype_int8 yydefgoto[] =
 681 {
 682       -1,     5,     6
 683 };
 684
 685 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 686    STATE-NUM.  */
 687 #define YYPACT_NINF -13
 688 static const yytype_int8 yypact[] =
 689 {
 690      109,   109,   109,   109,   -13,     6,    59,   106,   106,    22,
 691      -13,   109,   109,   109,   109,   109,   109,   109,   109,   109,
 692      109,   109,   109,   109,   109,   109,   109,   -13,    42,    90,
 693      104,   120,   120,   120,   120,   120,   120,   -12,   -12,   106,
 694      106,   106,   -13,   -13,   109,    75
 695 };
 696
 697 /* YYPGOTO[NTERM-NUM].  */
 698 static const yytype_int8 yypgoto[] =
 699 {
 700      -13,   -13,    -1
 701 };
 702
 703 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 704    positive, shift that token.  If negative, reduce the rule which
 705    number is the opposite.  If zero, do what YYDEFACT says.
 706    If YYTABLE_NINF, syntax error.  */
 707 #define YYTABLE_NINF -1
 708 static const yytype_uint8 yytable[] =
 709 {
 710        7,     8,     9,    22,    23,    24,    10,    25,    26,     0,
 711       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
 712       38,    39,    40,    41,    42,    43,    11,    12,    13,    14,
 713       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 714        0,    25,    26,    45,    27,    44,    11,    12,    13,    14,
 715       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 716        0,    25,    26,    11,    12,    13,    14,    15,    16,    17,
 717       18,    19,    20,    21,    22,    23,    24,     0,    25,    26,
 718       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
 719       22,    23,    24,     0,    25,    26,    13,    14,    15,    16,
 720       17,    18,    19,    20,    21,    22,    23,    24,     0,    25,
 721       26,    14,    15,    16,    17,    18,    19,    20,    21,    22,
 722       23,    24,     1,    25,    26,    25,    26,     2,     0,     0,
 723        3,     0,     4,    20,    21,    22,    23,    24,     0,    25,
 724       26
 725 };
 726
 727 static const yytype_int8 yycheck[] =
 728 {
 729        1,     2,     3,    15,    16,    17,     0,    19,    20,    -1,
 730       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
 731       21,    22,    23,    24,    25,    26,     4,     5,     6,     7,
 732        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
 733       -1,    19,    20,    44,    22,     3,     4,     5,     6,     7,
 734        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
 735       -1,    19,    20,     4,     5,     6,     7,     8,     9,    10,
 736       11,    12,    13,    14,    15,    16,    17,    -1,    19,    20,
 737        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 738       15,    16,    17,    -1,    19,    20,     6,     7,     8,     9,
 739       10,    11,    12,    13,    14,    15,    16,    17,    -1,    19,
 740       20,     7,     8,     9,    10,    11,    12,    13,    14,    15,
 741       16,    17,    13,    19,    20,    19,    20,    18,    -1,    -1,
 742       21,    -1,    23,    13,    14,    15,    16,    17,    -1,    19,
 743       20
 744 };
 745
 746 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 747    symbol of state STATE-NUM.  */
 748 static const yytype_uint8 yystos[] =
 749 {
 750        0,    13,    18,    21,    23,    25,    26,    26,    26,    26,
 751        0,     4,     5,     6,     7,     8,     9,    10,    11,    12,
 752       13,    14,    15,    16,    17,    19,    20,    22,    26,    26,
 753       26,    26,    26,    26,    26,    26,    26,    26,    26,    26,
 754       26,    26,    26,    26,     3,    26
 755 };
 756
 757 #define yyerrok         (yyerrstatus = 0)
 758 #define yyclearin       (yychar = YYEMPTY)
 759 #define YYEMPTY         (-2)
 760 #define YYEOF           0
 761
 762 #define YYACCEPT        goto yyacceptlab
 763 #define YYABORT         goto yyabortlab
 764 #define YYERROR         goto yyerrorlab
 765
 766
 767 /* Like YYERROR except do call yyerror.  This remains here temporarily
 768    to ease the transition to the new meaning of YYERROR, for GCC.
 769    Once GCC version 2 has supplanted version 1, this can go.  */
 770
 771 #define YYFAIL          goto yyerrlab
 772
 773 #define YYRECOVERING()  (!!yyerrstatus)
 774
 775 #define YYBACKUP(Token, Value)                                  \
 776 do                                                              \
 777   if (yychar == YYEMPTY && yylen == 1)                          \
 778     {                                                           \
 779       yychar = (Token);                                         \
 780       yylval = (Value);                                         \
 781       yytoken = YYTRANSLATE (yychar);                           \
 782       YYPOPSTACK (1);                                           \
 783       goto yybackup;                                            \
 784     }                                                           \
 785   else                                                          \
 786     {                                                           \
 787       yyerror (YY_("syntax error: cannot back up")); \
 788       YYERROR;                                                  \
 789     }                                                           \
 790 while (YYID (0))
 791
 792
 793 #define YYTERROR        1
 794 #define YYERRCODE       256
 795
 796
 797 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 798    If N is 0, then set CURRENT to the empty location which ends
 799    the previous symbol: RHS[0] (always defined).  */
 800
 801 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
 802 #ifndef YYLLOC_DEFAULT
 803 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 804     do                                                                  \
 805       if (YYID (N))                                                    \
 806         {                                                               \
 807           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 808           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 809           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 810           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 811         }                                                               \
 812       else                                                              \
 813         {                                                               \
 814           (Current).first_line   = (Current).last_line   =              \
 815             YYRHSLOC (Rhs, 0).last_line;                                \
 816           (Current).first_column = (Current).last_column =              \
 817             YYRHSLOC (Rhs, 0).last_column;                              \
 818         }                                                               \
 819     while (YYID (0))
 820 #endif
 821
 822
 823 /* YY_LOCATION_PRINT -- Print the location on the stream.
 824    This macro was not mandated originally: define only if we know
 825    we won't break user code: when these are the locations we know.  */
 826
 827 #ifndef YY_LOCATION_PRINT
 828 # if YYLTYPE_IS_TRIVIAL
 829 #  define YY_LOCATION_PRINT(File, Loc)                  \
 830      fprintf (File, "%d.%d-%d.%d",                      \
 831               (Loc).first_line, (Loc).first_column,     \
 832               (Loc).last_line,  (Loc).last_column)
 833 # else
 834 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 835 # endif
 836 #endif
 837
 838
 839 /* YYLEX -- calling `yylex' with the right arguments.  */
 840
 841 #ifdef YYLEX_PARAM
 842 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
 843 #else
 844 # define YYLEX yylex (&yylval, &yylloc)
 845 #endif
 846
 847 /* Enable debugging if requested.  */
 848 #if YYDEBUG
 849
 850 # ifndef YYFPRINTF
 851 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 852 #  define YYFPRINTF fprintf
 853 # endif
 854
 855 # define YYDPRINTF(Args)                        \
 856 do {                                            \
 857   if (yydebug)                                  \
 858     YYFPRINTF Args;                             \
 859 } while (YYID (0))
 860
 861 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 862 do {                                                                      \
 863   if (yydebug)                                                            \
 864     {                                                                     \
 865       YYFPRINTF (stderr, "%s ", Title);                                   \
 866       yy_symbol_print (stderr,                                            \
 867                   Type, Value, Location); \
 868       YYFPRINTF (stderr, "\n");                                           \
 869     }                                                                     \
 870 } while (YYID (0))
 871
 872
 873 /*--------------------------------.
 874 | Print this symbol on YYOUTPUT.  |
 875 `--------------------------------*/
 876
 877 /*ARGSUSED*/
 878 #if (defined __STDC__ || defined __C99__FUNC__ \
 879      || defined __cplusplus || defined _MSC_VER)
 880 static void
 881 yy_symbol_value_print (FILE *yyoutput, int yytype, const YYSTYPE * const yyvaluep, const YYLTYPE * const yylocationp)
 882 #else
 883 static void
 884 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp)
 885     FILE *yyoutput;
 886     int yytype;
 887     const YYSTYPE * const yyvaluep;
 888     const YYLTYPE * const yylocationp;
 889 #endif
 890 {
 891   if (!yyvaluep)
 892     return;
 893   YYUSE (yylocationp);
 894 # ifdef YYPRINT
 895   if (yytype < YYNTOKENS)
 896     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 897 # else
 898   YYUSE (yyoutput);
 899 # endif
 900   switch (yytype)
 901     {
 902       default:
 903         break;
 904     }
 905 }
 906
 907
 908 /*--------------------------------.
 909 | Print this symbol on YYOUTPUT.  |
 910 `--------------------------------*/
 911
 912 #if (defined __STDC__ || defined __C99__FUNC__ \
 913      || defined __cplusplus || defined _MSC_VER)
 914 static void
 915 yy_symbol_print (FILE *yyoutput, int yytype, const YYSTYPE * const yyvaluep, const YYLTYPE * const yylocationp)
 916 #else
 917 static void
 918 yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp)
 919     FILE *yyoutput;
 920     int yytype;
 921     const YYSTYPE * const yyvaluep;
 922     const YYLTYPE * const yylocationp;
 923 #endif
 924 {
 925   if (yytype < YYNTOKENS)
 926     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 927   else
 928     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 929
 930   YY_LOCATION_PRINT (yyoutput, *yylocationp);
 931   YYFPRINTF (yyoutput, ": ");
 932   yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp);
 933   YYFPRINTF (yyoutput, ")");
 934 }
 935
 936 /*------------------------------------------------------------------.
 937 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 938 | TOP (included).                                                   |
 939 `------------------------------------------------------------------*/
 940
 941 #if (defined __STDC__ || defined __C99__FUNC__ \
 942      || defined __cplusplus || defined _MSC_VER)
 943 static void
 944 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
 945 #else
 946 static void
 947 yy_stack_print (bottom, top)
 948     yytype_int16 *bottom;
 949     yytype_int16 *top;
 950 #endif
 951 {
 952   YYFPRINTF (stderr, "Stack now");
 953   for (; bottom <= top; ++bottom)
 954     YYFPRINTF (stderr, " %d", *bottom);
 955   YYFPRINTF (stderr, "\n");
 956 }
 957
 958 # define YY_STACK_PRINT(Bottom, Top)                            \
 959 do {                                                            \
 960   if (yydebug)                                                  \
 961     yy_stack_print ((Bottom), (Top));                           \
 962 } while (YYID (0))
 963
 964
 965 /*------------------------------------------------.
 966 | Report that the YYRULE is going to be reduced.  |
 967 `------------------------------------------------*/
 968
 969 #if (defined __STDC__ || defined __C99__FUNC__ \
 970      || defined __cplusplus || defined _MSC_VER)
 971 static void
 972 yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule)
 973 #else
 974 static void
 975 yy_reduce_print (yyvsp, yylsp, yyrule
 976                    )
 977     YYSTYPE *yyvsp;
 978     YYLTYPE *yylsp;
 979     int yyrule;
 980 #endif
 981 {
 982   int yynrhs = yyr2[yyrule];
 983   int yyi;
 984   unsigned long int yylno = yyrline[yyrule];
 985   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 986              yyrule - 1, yylno);
 987   /* The symbols being reduced.  */
 988   for (yyi = 0; yyi < yynrhs; yyi++)
 989     {
 990       fprintf (stderr, "   $%d = ", yyi + 1);
 991       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 992                        &(yyvsp[(yyi + 1) - (yynrhs)])
 993                        , &(yylsp[(yyi + 1) - (yynrhs)])                );
 994       fprintf (stderr, "\n");
 995     }
 996 }
 997
 998 # define YY_REDUCE_PRINT(Rule)          \
 999 do {                                    \
1000   if (yydebug)                          \
1001     yy_reduce_print (yyvsp, yylsp, Rule); \
1002 } while (YYID (0))
1003
1004 /* Nonzero means print parse trace.  It is left uninitialized so that
1005    multiple parsers can coexist.  */
1006 int yydebug;
1007 #else /* !YYDEBUG */
1008 # define YYDPRINTF(Args)
1009 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1010 # define YY_STACK_PRINT(Bottom, Top)
1011 # define YY_REDUCE_PRINT(Rule)
1012 #endif /* !YYDEBUG */
1013
1014
1015 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1016 #ifndef YYINITDEPTH
1017 # define YYINITDEPTH 200
1018 #endif
1019
1020 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1021    if the built-in stack extension method is used).
1022
1023    Do not make this value too large; the results are undefined if
1024    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1025    evaluated with infinite-precision integer arithmetic.  */
1026
1027 #ifndef YYMAXDEPTH
1028 # define YYMAXDEPTH 10000
1029 #endif
1030
1031 \f
1032
1033 #if YYERROR_VERBOSE
1034
1035 # ifndef yystrlen
1036 #  if defined __GLIBC__ && defined _STRING_H
1037 #   define yystrlen strlen
1038 #  else
1039 /* Return the length of YYSTR.  */
1040 #if (defined __STDC__ || defined __C99__FUNC__ \
1041      || defined __cplusplus || defined _MSC_VER)
1042 static YYSIZE_T
1043 yystrlen (const char *yystr)
1044 #else
1045 static YYSIZE_T
1046 yystrlen (yystr)
1047     const char *yystr;
1048 #endif
1049 {
1050   YYSIZE_T yylen;
1051   for (yylen = 0; yystr[yylen]; yylen++)
1052     continue;
1053   return yylen;
1054 }
1055 #  endif
1056 # endif
1057
1058 # ifndef yystpcpy
1059 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1060 #   define yystpcpy stpcpy
1061 #  else
1062 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1063    YYDEST.  */
1064 #if (defined __STDC__ || defined __C99__FUNC__ \
1065      || defined __cplusplus || defined _MSC_VER)
1066 static char *
1067 yystpcpy (char *yydest, const char *yysrc)
1068 #else
1069 static char *
1070 yystpcpy (yydest, yysrc)
1071     char *yydest;
1072     const char *yysrc;
1073 #endif
1074 {
1075   char *yyd = yydest;
1076   const char *yys = yysrc;
1077
1078   while ((*yyd++ = *yys++) != '\0')
1079     continue;
1080
1081   return yyd - 1;
1082 }
1083 #  endif
1084 # endif
1085
1086 # ifndef yytnamerr
1087 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1088    quotes and backslashes, so that it's suitable for yyerror.  The
1089    heuristic is that double-quoting is unnecessary unless the string
1090    contains an apostrophe, a comma, or backslash (other than
1091    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1092    null, do not copy; instead, return the length of what the result
1093    would have been.  */
1094 static YYSIZE_T
1095 yytnamerr (char *yyres, const char *yystr)
1096 {
1097   if (*yystr == '"')
1098     {
1099       size_t yyn = 0;
1100       char const *yyp = yystr;
1101
1102       for (;;)
1103         switch (*++yyp)
1104           {
1105           case '\'':
1106           case ',':
1107             goto do_not_strip_quotes;
1108
1109           case '\\':
1110             if (*++yyp != '\\')
1111               goto do_not_strip_quotes;
1112             /* Fall through.  */
1113           default:
1114             if (yyres)
1115               yyres[yyn] = *yyp;
1116             yyn++;
1117             break;
1118
1119           case '"':
1120             if (yyres)
1121               yyres[yyn] = '\0';
1122             return yyn;
1123           }
1124     do_not_strip_quotes: ;
1125     }
1126
1127   if (! yyres)
1128     return yystrlen (yystr);
1129
1130   return yystpcpy (yyres, yystr) - yyres;
1131 }
1132 # endif
1133
1134 /* Copy into YYRESULT an error message about the unexpected token
1135    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1136    including the terminating null byte.  If YYRESULT is null, do not
1137    copy anything; just return the number of bytes that would be
1138    copied.  As a special case, return 0 if an ordinary "syntax error"
1139    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1140    size calculation.  */
1141 static YYSIZE_T
1142 yysyntax_error (char *yyresult, int yystate, int yychar)
1143 {
1144   int yyn = yypact[yystate];
1145
1146   if (! (YYPACT_NINF < yyn && yyn < YYLAST))
1147     return 0;
1148   else
1149     {
1150       int yytype = YYTRANSLATE (yychar);
1151       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1152       YYSIZE_T yysize = yysize0;
1153       YYSIZE_T yysize1;
1154       int yysize_overflow = 0;
1155       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1156       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1157       int yyx;
1158
1159 # if 0
1160       /* This is so xgettext sees the translatable formats that are
1161          constructed on the fly.  */
1162       YY_("syntax error, unexpected %s");
1163       YY_("syntax error, unexpected %s, expecting %s");
1164       YY_("syntax error, unexpected %s, expecting %s or %s");
1165       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1166       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1167 # endif
1168       char *yyfmt;
1169       char const *yyf;
1170       static char const yyunexpected[] = "syntax error, unexpected %s";
1171       static char const yyexpecting[] = ", expecting %s";
1172       static char const yyor[] = " or %s";
1173       char yyformat[sizeof yyunexpected
1174                     + sizeof yyexpecting - 1
1175                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1176                        * (sizeof yyor - 1))];
1177       char const *yyprefix = yyexpecting;
1178
1179       /* Start YYX at -YYN if negative to avoid negative indexes in
1180          YYCHECK.  */
1181       int yyxbegin = yyn < 0 ? -yyn : 0;
1182
1183       /* Stay within bounds of both yycheck and yytname.  */
1184       int yychecklim = YYLAST - yyn;
1185       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1186       int yycount = 1;
1187
1188       yyarg[0] = yytname[yytype];
1189       yyfmt = yystpcpy (yyformat, yyunexpected);
1190
1191       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1192         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1193           {
1194             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1195               {
1196                 yycount = 1;
1197                 yysize = yysize0;
1198                 yyformat[sizeof yyunexpected - 1] = '\0';
1199                 break;
1200               }
1201             yyarg[yycount++] = yytname[yyx];
1202             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1203             yysize_overflow |= (yysize1 < yysize);
1204             yysize = yysize1;
1205             yyfmt = yystpcpy (yyfmt, yyprefix);
1206             yyprefix = yyor;
1207           }
1208
1209       yyf = YY_(yyformat);
1210       yysize1 = yysize + yystrlen (yyf);
1211       yysize_overflow |= (yysize1 < yysize);
1212       yysize = yysize1;
1213
1214       if (yysize_overflow)
1215         return YYSIZE_MAXIMUM;
1216
1217       if (yyresult)
1218         {
1219           /* Avoid sprintf, as that infringes on the user's name space.
1220              Don't have undefined behavior even if the translation
1221              produced a string with the wrong number of "%s"s.  */
1222           char *yyp = yyresult;
1223           int yyi = 0;
1224           while ((*yyp = *yyf) != '\0')
1225             {
1226               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1227                 {
1228                   yyp += yytnamerr (yyp, yyarg[yyi++]);
1229                   yyf += 2;
1230                 }
1231               else
1232                 {
1233                   yyp++;
1234                   yyf++;
1235                 }
1236             }
1237         }
1238       return yysize;
1239     }
1240 }
1241 #endif /* YYERROR_VERBOSE */
1242 \f
1243
1244 /*-----------------------------------------------.
1245 | Release the memory associated to this symbol.  |
1246 `-----------------------------------------------*/
1247
1248 /*ARGSUSED*/
1249 #if (defined __STDC__ || defined __C99__FUNC__ \
1250      || defined __cplusplus || defined _MSC_VER)
1251 static void
1252 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1253 #else
1254 static void
1255 yydestruct (yymsg, yytype, yyvaluep, yylocationp)
1256     const char *yymsg;
1257     int yytype;
1258     YYSTYPE *yyvaluep;
1259     YYLTYPE *yylocationp;
1260 #endif
1261 {
1262   YYUSE (yyvaluep);
1263   YYUSE (yylocationp);
1264
1265   if (!yymsg)
1266     yymsg = "Deleting";
1267   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1268
1269   switch (yytype)
1270     {
1271       case 3: /* "TOK_COLONCOLON" */
1272 #line 187 "ast_expr2.y"
1273         {  free_value((yyvaluep->val)); };
1274 #line 1275 "ast_expr2.c"
1275         break;
1276       case 4: /* "TOK_COND" */
1277 #line 187 "ast_expr2.y"
1278         {  free_value((yyvaluep->val)); };
1279 #line 1280 "ast_expr2.c"
1280         break;
1281       case 5: /* "TOK_OR" */
1282 #line 187 "ast_expr2.y"
1283         {  free_value((yyvaluep->val)); };
1284 #line 1285 "ast_expr2.c"
1285         break;
1286       case 6: /* "TOK_AND" */
1287 #line 187 "ast_expr2.y"
1288         {  free_value((yyvaluep->val)); };
1289 #line 1290 "ast_expr2.c"
1290         break;
1291       case 7: /* "TOK_NE" */
1292 #line 187 "ast_expr2.y"
1293         {  free_value((yyvaluep->val)); };
1294 #line 1295 "ast_expr2.c"
1295         break;
1296       case 8: /* "TOK_LE" */
1297 #line 187 "ast_expr2.y"
1298         {  free_value((yyvaluep->val)); };
1299 #line 1300 "ast_expr2.c"
1300         break;
1301       case 9: /* "TOK_GE" */
1302 #line 187 "ast_expr2.y"
1303         {  free_value((yyvaluep->val)); };
1304 #line 1305 "ast_expr2.c"
1305         break;
1306       case 10: /* "TOK_LT" */
1307 #line 187 "ast_expr2.y"
1308         {  free_value((yyvaluep->val)); };
1309 #line 1310 "ast_expr2.c"
1310         break;
1311       case 11: /* "TOK_GT" */
1312 #line 187 "ast_expr2.y"
1313         {  free_value((yyvaluep->val)); };
1314 #line 1315 "ast_expr2.c"
1315         break;
1316       case 12: /* "TOK_EQ" */
1317 #line 187 "ast_expr2.y"
1318         {  free_value((yyvaluep->val)); };
1319 #line 1320 "ast_expr2.c"
1320         break;
1321       case 13: /* "TOK_MINUS" */
1322 #line 187 "ast_expr2.y"
1323         {  free_value((yyvaluep->val)); };
1324 #line 1325 "ast_expr2.c"
1325         break;
1326       case 14: /* "TOK_PLUS" */
1327 #line 187 "ast_expr2.y"
1328         {  free_value((yyvaluep->val)); };
1329 #line 1330 "ast_expr2.c"
1330         break;
1331       case 15: /* "TOK_MOD" */
1332 #line 187 "ast_expr2.y"
1333         {  free_value((yyvaluep->val)); };
1334 #line 1335 "ast_expr2.c"
1335         break;
1336       case 16: /* "TOK_DIV" */
1337 #line 187 "ast_expr2.y"
1338         {  free_value((yyvaluep->val)); };
1339 #line 1340 "ast_expr2.c"
1340         break;
1341       case 17: /* "TOK_MULT" */
1342 #line 187 "ast_expr2.y"
1343         {  free_value((yyvaluep->val)); };
1344 #line 1345 "ast_expr2.c"
1345         break;
1346       case 18: /* "TOK_COMPL" */
1347 #line 187 "ast_expr2.y"
1348         {  free_value((yyvaluep->val)); };
1349 #line 1350 "ast_expr2.c"
1350         break;
1351       case 19: /* "TOK_EQTILDE" */
1352 #line 187 "ast_expr2.y"
1353         {  free_value((yyvaluep->val)); };
1354 #line 1355 "ast_expr2.c"
1355         break;
1356       case 20: /* "TOK_COLON" */
1357 #line 187 "ast_expr2.y"
1358         {  free_value((yyvaluep->val)); };
1359 #line 1360 "ast_expr2.c"
1360         break;
1361       case 21: /* "TOK_LP" */
1362 #line 187 "ast_expr2.y"
1363         {  free_value((yyvaluep->val)); };
1364 #line 1365 "ast_expr2.c"
1365         break;
1366       case 22: /* "TOK_RP" */
1367 #line 187 "ast_expr2.y"
1368         {  free_value((yyvaluep->val)); };
1369 #line 1370 "ast_expr2.c"
1370         break;
1371       case 23: /* "TOKEN" */
1372 #line 187 "ast_expr2.y"
1373         {  free_value((yyvaluep->val)); };
1374 #line 1375 "ast_expr2.c"
1375         break;
1376       case 26: /* "expr" */
1377 #line 187 "ast_expr2.y"
1378         {  free_value((yyvaluep->val)); };
1379 #line 1380 "ast_expr2.c"
1380         break;
1381
1382       default:
1383         break;
1384     }
1385 }
1386 \f
1387
1388 /* Prevent warnings from -Wmissing-prototypes.  */
1389
1390 #ifdef YYPARSE_PARAM
1391 #if defined __STDC__ || defined __cplusplus
1392 int yyparse (void *YYPARSE_PARAM);
1393 #else
1394 int yyparse ();
1395 #endif
1396 #else /* ! YYPARSE_PARAM */
1397 #if defined __STDC__ || defined __cplusplus
1398 int yyparse (void);
1399 #else
1400 int yyparse ();
1401 #endif
1402 #endif /* ! YYPARSE_PARAM */
1403
1404
1405
1406
1407
1408
1409 /*----------.
1410 | yyparse.  |
1411 `----------*/
1412
1413 #ifdef YYPARSE_PARAM
1414 #if (defined __STDC__ || defined __C99__FUNC__ \
1415      || defined __cplusplus || defined _MSC_VER)
1416 int
1417 yyparse (void *YYPARSE_PARAM)
1418 #else
1419 int
1420 yyparse (YYPARSE_PARAM)
1421     void *YYPARSE_PARAM;
1422 #endif
1423 #else /* ! YYPARSE_PARAM */
1424 #if (defined __STDC__ || defined __C99__FUNC__ \
1425      || defined __cplusplus || defined _MSC_VER)
1426 int
1427 yyparse (void)
1428 #else
1429 int
1430 yyparse ()
1431
1432 #endif
1433 #endif
1434 {
1435   /* The look-ahead symbol.  */
1436 int yychar;
1437
1438 /* The semantic value of the look-ahead symbol.  */
1439 YYSTYPE yylval;
1440
1441 /* Number of syntax errors so far.  */
1442 int yynerrs;
1443 /* Location data for the look-ahead symbol.  */
1444 YYLTYPE yylloc;
1445
1446   int yystate;
1447   int yyn;
1448   int yyresult;
1449   /* Number of tokens to shift before error messages enabled.  */
1450   int yyerrstatus;
1451   /* Look-ahead token as an internal (translated) token number.  */
1452   int yytoken = 0;
1453 #if YYERROR_VERBOSE
1454   /* Buffer for error messages, and its allocated size.  */
1455   char yymsgbuf[128];
1456   char *yymsg = yymsgbuf;
1457   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1458 #endif
1459
1460   /* Three stacks and their tools:
1461      `yyss': related to states,
1462      `yyvs': related to semantic values,
1463      `yyls': related to locations.
1464
1465      Refer to the stacks thru separate pointers, to allow yyoverflow
1466      to reallocate them elsewhere.  */
1467
1468   /* The state stack.  */
1469   yytype_int16 yyssa[YYINITDEPTH];
1470   yytype_int16 *yyss = yyssa;
1471   yytype_int16 *yyssp;
1472
1473   /* The semantic value stack.  */
1474   YYSTYPE yyvsa[YYINITDEPTH];
1475   YYSTYPE *yyvs = yyvsa;
1476   YYSTYPE *yyvsp;
1477
1478   /* The location stack.  */
1479   YYLTYPE yylsa[YYINITDEPTH];
1480   YYLTYPE *yyls = yylsa;
1481   YYLTYPE *yylsp;
1482   /* The locations where the error started and ended.  */
1483   YYLTYPE yyerror_range[2];
1484
1485 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1486
1487   YYSIZE_T yystacksize = YYINITDEPTH;
1488
1489   /* The variables used to return semantic value and location from the
1490      action routines.  */
1491   YYSTYPE yyval;
1492   YYLTYPE yyloc;
1493
1494   /* The number of symbols on the RHS of the reduced rule.
1495      Keep to zero when no symbol should be popped.  */
1496   int yylen = 0;
1497
1498   YYDPRINTF ((stderr, "Starting parse\n"));
1499
1500   yystate = 0;
1501   yyerrstatus = 0;
1502   yynerrs = 0;
1503   yychar = YYEMPTY;             /* Cause a token to be read.  */
1504
1505   /* Initialize stack pointers.
1506      Waste one element of value and location stack
1507      so that they stay on the same level as the state stack.
1508      The wasted elements are never initialized.  */
1509
1510   yyssp = yyss;
1511   yyvsp = yyvs;
1512   yylsp = yyls;
1513 #if YYLTYPE_IS_TRIVIAL
1514   /* Initialize the default location before parsing starts.  */
1515   yylloc.first_line   = yylloc.last_line   = 1;
1516   yylloc.first_column = yylloc.last_column = 0;
1517 #endif
1518
1519   goto yysetstate;
1520
1521 /*------------------------------------------------------------.
1522 | yynewstate -- Push a new state, which is found in yystate.  |
1523 `------------------------------------------------------------*/
1524  yynewstate:
1525   /* In all cases, when you get here, the value and location stacks
1526      have just been pushed.  So pushing a state here evens the stacks.  */
1527   yyssp++;
1528
1529  yysetstate:
1530   *yyssp = yystate;
1531
1532   if (yyss + yystacksize - 1 <= yyssp)
1533     {
1534       /* Get the current used size of the three stacks, in elements.  */
1535       YYSIZE_T yysize = yyssp - yyss + 1;
1536
1537 #ifdef yyoverflow
1538       {
1539         /* Give user a chance to reallocate the stack.  Use copies of
1540            these so that the &'s don't force the real ones into
1541            memory.  */
1542         YYSTYPE *yyvs1 = yyvs;
1543         yytype_int16 *yyss1 = yyss;
1544         YYLTYPE *yyls1 = yyls;
1545
1546         /* Each stack pointer address is followed by the size of the
1547            data in use in that stack, in bytes.  This used to be a
1548            conditional around just the two extra args, but that might
1549            be undefined if yyoverflow is a macro.  */
1550         yyoverflow (YY_("memory exhausted"),
1551                     &yyss1, yysize * sizeof (*yyssp),
1552                     &yyvs1, yysize * sizeof (*yyvsp),
1553                     &yyls1, yysize * sizeof (*yylsp),
1554                     &yystacksize);
1555         yyls = yyls1;
1556         yyss = yyss1;
1557         yyvs = yyvs1;
1558       }
1559 #else /* no yyoverflow */
1560 # ifndef YYSTACK_RELOCATE
1561       goto yyexhaustedlab;
1562 # else
1563       /* Extend the stack our own way.  */
1564       if (YYMAXDEPTH <= yystacksize)
1565         goto yyexhaustedlab;
1566       yystacksize *= 2;
1567       if (YYMAXDEPTH < yystacksize)
1568         yystacksize = YYMAXDEPTH;
1569
1570       {
1571         yytype_int16 *yyss1 = yyss;
1572         union yyalloc *yyptr =
1573           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1574         if (! yyptr)
1575           goto yyexhaustedlab;
1576         YYSTACK_RELOCATE (yyss);
1577         YYSTACK_RELOCATE (yyvs);
1578         YYSTACK_RELOCATE (yyls);
1579 #  undef YYSTACK_RELOCATE
1580         if (yyss1 != yyssa)
1581           YYSTACK_FREE (yyss1);
1582       }
1583 # endif
1584 #endif /* no yyoverflow */
1585
1586       yyssp = yyss + yysize - 1;
1587       yyvsp = yyvs + yysize - 1;
1588       yylsp = yyls + yysize - 1;
1589
1590       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1591                   (unsigned long int) yystacksize));
1592
1593       if (yyss + yystacksize - 1 <= yyssp)
1594         YYABORT;
1595     }
1596
1597   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1598
1599   goto yybackup;
1600
1601 /*-----------.
1602 | yybackup.  |
1603 `-----------*/
1604 yybackup:
1605
1606   /* Do appropriate processing given the current state.  Read a
1607      look-ahead token if we need one and don't already have one.  */
1608
1609   /* First try to decide what to do without reference to look-ahead token.  */
1610   yyn = yypact[yystate];
1611   if (yyn == YYPACT_NINF)
1612     goto yydefault;
1613
1614   /* Not known => get a look-ahead token if don't already have one.  */
1615
1616   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1617   if (yychar == YYEMPTY)
1618     {
1619       YYDPRINTF ((stderr, "Reading a token: "));
1620       yychar = YYLEX;
1621     }
1622
1623   if (yychar <= YYEOF)
1624     {
1625       yychar = yytoken = YYEOF;
1626       YYDPRINTF ((stderr, "Now at end of input.\n"));
1627     }
1628   else
1629     {
1630       yytoken = YYTRANSLATE (yychar);
1631       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1632     }
1633
1634   /* If the proper action on seeing token YYTOKEN is to reduce or to
1635      detect an error, take that action.  */
1636   yyn += yytoken;
1637   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1638     goto yydefault;
1639   yyn = yytable[yyn];
1640   if (yyn <= 0)
1641     {
1642       if (yyn == 0 || yyn == YYTABLE_NINF)
1643         goto yyerrlab;
1644       yyn = -yyn;
1645       goto yyreduce;
1646     }
1647
1648   if (yyn == YYFINAL)
1649     YYACCEPT;
1650
1651   /* Count tokens shifted since error; after three, turn off error
1652      status.  */
1653   if (yyerrstatus)
1654     yyerrstatus--;
1655
1656   /* Shift the look-ahead token.  */
1657   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1658
1659   /* Discard the shifted token unless it is eof.  */
1660   if (yychar != YYEOF)
1661     yychar = YYEMPTY;
1662
1663   yystate = yyn;
1664   *++yyvsp = yylval;
1665   *++yylsp = yylloc;
1666   goto yynewstate;
1667
1668
1669 /*-----------------------------------------------------------.
1670 | yydefault -- do the default action for the current state.  |
1671 `-----------------------------------------------------------*/
1672 yydefault:
1673   yyn = yydefact[yystate];
1674   if (yyn == 0)
1675     goto yyerrlab;
1676   goto yyreduce;
1677
1678
1679 /*-----------------------------.
1680 | yyreduce -- Do a reduction.  |
1681 `-----------------------------*/
1682 yyreduce:
1683   /* yyn is the number of a rule to reduce with.  */
1684   yylen = yyr2[yyn];
1685
1686   /* If YYLEN is nonzero, implement the default value of the action:
1687      `$$ = $1'.
1688
1689      Otherwise, the following line sets YYVAL to garbage.
1690      This behavior is undocumented and Bison
1691      users should not rely upon it.  Assigning to YYVAL
1692      unconditionally makes the parser a bit smaller, and it avoids a
1693      GCC warning that YYVAL may be used uninitialized.  */
1694   yyval = yyvsp[1-yylen];
1695
1696   /* Default location.  */
1697   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
1698   YY_REDUCE_PRINT (yyn);
1699   switch (yyn)
1700     {
1701         case 2:
1702 #line 193 "ast_expr2.y"
1703     { ((struct parse_io *)parseio)->val = (struct val *)calloc(sizeof(struct val),1);
1704               ((struct parse_io *)parseio)->val->type = (yyvsp[(1) - (1)].val)->type;
1705               if( (yyvsp[(1) - (1)].val)->type == AST_EXPR_number )
1706                                   ((struct parse_io *)parseio)->val->u.i = (yyvsp[(1) - (1)].val)->u.i;
1707               else
1708                                   ((struct parse_io *)parseio)->val->u.s = (yyvsp[(1) - (1)].val)->u.s;
1709                           free((yyvsp[(1) - (1)].val));
1710                         ;}
1711     break;
1712
1713   case 3:
1714 #line 201 "ast_expr2.y"
1715     {/* nothing */ ((struct parse_io *)parseio)->val = (struct val *)calloc(sizeof(struct val),1);
1716               ((struct parse_io *)parseio)->val->type = AST_EXPR_string;
1717                           ((struct parse_io *)parseio)->val->u.s = strdup("");
1718                         ;}
1719     break;
1720
1721   case 4:
1722 #line 208 "ast_expr2.y"
1723     { (yyval.val)= (yyvsp[(1) - (1)].val);;}
1724     break;
1725
1726   case 5:
1727 #line 209 "ast_expr2.y"
1728     { (yyval.val) = (yyvsp[(2) - (3)].val);
1729                                (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1730                                                    (yyloc).first_line=0; (yyloc).last_line=0;
1731                                                         DESTROY((yyvsp[(1) - (3)].val)); DESTROY((yyvsp[(3) - (3)].val)); ;}
1732     break;
1733
1734   case 6:
1735 #line 213 "ast_expr2.y"
1736     { (yyval.val) = op_or ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1737                                                 DESTROY((yyvsp[(2) - (3)].val));
1738                          (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1739                                                  (yyloc).first_line=0; (yyloc).last_line=0;;}
1740     break;
1741
1742   case 7:
1743 #line 217 "ast_expr2.y"
1744     { (yyval.val) = op_and ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1745                                                 DESTROY((yyvsp[(2) - (3)].val));
1746                               (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1747                           (yyloc).first_line=0; (yyloc).last_line=0;;}
1748     break;
1749
1750   case 8:
1751 #line 221 "ast_expr2.y"
1752     { (yyval.val) = op_eq ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1753                                                 DESTROY((yyvsp[(2) - (3)].val));
1754                              (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1755                                                  (yyloc).first_line=0; (yyloc).last_line=0;;}
1756     break;
1757
1758   case 9:
1759 #line 225 "ast_expr2.y"
1760     { (yyval.val) = op_gt ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1761                                                 DESTROY((yyvsp[(2) - (3)].val));
1762                          (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1763                                                  (yyloc).first_line=0; (yyloc).last_line=0;;}
1764     break;
1765
1766   case 10:
1767 #line 229 "ast_expr2.y"
1768     { (yyval.val) = op_lt ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1769                                                 DESTROY((yyvsp[(2) - (3)].val));
1770                              (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1771                                                  (yyloc).first_line=0; (yyloc).last_line=0;;}
1772     break;
1773
1774   case 11:
1775 #line 233 "ast_expr2.y"
1776     { (yyval.val) = op_ge ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1777                                                 DESTROY((yyvsp[(2) - (3)].val));
1778                               (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1779                                                   (yyloc).first_line=0; (yyloc).last_line=0;;}
1780     break;
1781
1782   case 12:
1783 #line 237 "ast_expr2.y"
1784     { (yyval.val) = op_le ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1785                                                 DESTROY((yyvsp[(2) - (3)].val));
1786                               (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1787                                                   (yyloc).first_line=0; (yyloc).last_line=0;;}
1788     break;
1789
1790   case 13:
1791 #line 241 "ast_expr2.y"
1792     { (yyval.val) = op_ne ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1793                                                 DESTROY((yyvsp[(2) - (3)].val));
1794                               (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1795                                                   (yyloc).first_line=0; (yyloc).last_line=0;;}
1796     break;
1797
1798   case 14:
1799 #line 245 "ast_expr2.y"
1800     { (yyval.val) = op_plus ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1801                                                 DESTROY((yyvsp[(2) - (3)].val));
1802                                (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1803                                                    (yyloc).first_line=0; (yyloc).last_line=0;;}
1804     break;
1805
1806   case 15:
1807 #line 249 "ast_expr2.y"
1808     { (yyval.val) = op_minus ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1809                                                 DESTROY((yyvsp[(2) - (3)].val));
1810                                 (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1811                                                         (yyloc).first_line=0; (yyloc).last_line=0;;}
1812     break;
1813
1814   case 16:
1815 #line 253 "ast_expr2.y"
1816     { (yyval.val) = op_negate ((yyvsp[(2) - (2)].val));
1817                                                 DESTROY((yyvsp[(1) - (2)].val));
1818                                 (yyloc).first_column = (yylsp[(1) - (2)]).first_column; (yyloc).last_column = (yylsp[(2) - (2)]).last_column;
1819                                                         (yyloc).first_line=0; (yyloc).last_line=0;;}
1820     break;
1821
1822   case 17:
1823 #line 257 "ast_expr2.y"
1824     { (yyval.val) = op_compl ((yyvsp[(2) - (2)].val));
1825                                                 DESTROY((yyvsp[(1) - (2)].val));
1826                                 (yyloc).first_column = (yylsp[(1) - (2)]).first_column; (yyloc).last_column = (yylsp[(2) - (2)]).last_column;
1827                                                         (yyloc).first_line=0; (yyloc).last_line=0;;}
1828     break;
1829
1830   case 18:
1831 #line 261 "ast_expr2.y"
1832     { (yyval.val) = op_times ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1833                                                 DESTROY((yyvsp[(2) - (3)].val));
1834                                (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1835                                                    (yyloc).first_line=0; (yyloc).last_line=0;;}
1836     break;
1837
1838   case 19:
1839 #line 265 "ast_expr2.y"
1840     { (yyval.val) = op_div ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1841                                                 DESTROY((yyvsp[(2) - (3)].val));
1842                               (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1843                                                   (yyloc).first_line=0; (yyloc).last_line=0;;}
1844     break;
1845
1846   case 20:
1847 #line 269 "ast_expr2.y"
1848     { (yyval.val) = op_rem ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1849                                                 DESTROY((yyvsp[(2) - (3)].val));
1850                               (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1851                                                   (yyloc).first_line=0; (yyloc).last_line=0;;}
1852     break;
1853
1854   case 21:
1855 #line 273 "ast_expr2.y"
1856     { (yyval.val) = op_colon ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1857                                                 DESTROY((yyvsp[(2) - (3)].val));
1858                                 (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1859                                                         (yyloc).first_line=0; (yyloc).last_line=0;;}
1860     break;
1861
1862   case 22:
1863 #line 277 "ast_expr2.y"
1864     { (yyval.val) = op_eqtilde ((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
1865                                                 DESTROY((yyvsp[(2) - (3)].val));
1866                                 (yyloc).first_column = (yylsp[(1) - (3)]).first_column; (yyloc).last_column = (yylsp[(3) - (3)]).last_column;
1867                                                         (yyloc).first_line=0; (yyloc).last_line=0;;}
1868     break;
1869
1870   case 23:
1871 #line 281 "ast_expr2.y"
1872     { (yyval.val) = op_cond ((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
1873                                                 DESTROY((yyvsp[(2) - (5)].val));
1874                                                 DESTROY((yyvsp[(4) - (5)].val));
1875                                 (yyloc).first_column = (yylsp[(1) - (5)]).first_column; (yyloc).last_column = (yylsp[(3) - (5)]).last_column;
1876                                                         (yyloc).first_line=0; (yyloc).last_line=0;;}
1877     break;
1878
1879
1880 /* Line 1270 of yacc.c.  */
1881 #line 1882 "ast_expr2.c"
1882       default: break;
1883     }
1884   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1885
1886   YYPOPSTACK (yylen);
1887   yylen = 0;
1888   YY_STACK_PRINT (yyss, yyssp);
1889
1890   *++yyvsp = yyval;
1891   *++yylsp = yyloc;
1892
1893   /* Now `shift' the result of the reduction.  Determine what state
1894      that goes to, based on the state we popped back to and the rule
1895      number reduced by.  */
1896
1897   yyn = yyr1[yyn];
1898
1899   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1900   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1901     yystate = yytable[yystate];
1902   else
1903     yystate = yydefgoto[yyn - YYNTOKENS];
1904
1905   goto yynewstate;
1906
1907
1908 /*------------------------------------.
1909 | yyerrlab -- here on detecting error |
1910 `------------------------------------*/
1911 yyerrlab:
1912   /* If not already recovering from an error, report this error.  */
1913   if (!yyerrstatus)
1914     {
1915       ++yynerrs;
1916 #if ! YYERROR_VERBOSE
1917       yyerror (YY_("syntax error"));
1918 #else
1919       {
1920         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1921         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1922           {
1923             YYSIZE_T yyalloc = 2 * yysize;
1924             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1925               yyalloc = YYSTACK_ALLOC_MAXIMUM;
1926             if (yymsg != yymsgbuf)
1927               YYSTACK_FREE (yymsg);
1928             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1929             if (yymsg)
1930               yymsg_alloc = yyalloc;
1931             else
1932               {
1933                 yymsg = yymsgbuf;
1934                 yymsg_alloc = sizeof yymsgbuf;
1935               }
1936           }
1937
1938         if (0 < yysize && yysize <= yymsg_alloc)
1939           {
1940             (void) yysyntax_error (yymsg, yystate, yychar);
1941             yyerror (yymsg);
1942           }
1943         else
1944           {
1945             yyerror (YY_("syntax error"));
1946             if (yysize != 0)
1947               goto yyexhaustedlab;
1948           }
1949       }
1950 #endif
1951     }
1952
1953   yyerror_range[0] = yylloc;
1954
1955   if (yyerrstatus == 3)
1956     {
1957       /* If just tried and failed to reuse look-ahead token after an
1958          error, discard it.  */
1959
1960       if (yychar <= YYEOF)
1961         {
1962           /* Return failure if at end of input.  */
1963           if (yychar == YYEOF)
1964             YYABORT;
1965         }
1966       else
1967         {
1968           yydestruct ("Error: discarding",
1969                       yytoken, &yylval, &yylloc);
1970           yychar = YYEMPTY;
1971         }
1972     }
1973
1974   /* Else will try to reuse look-ahead token after shifting the error
1975      token.  */
1976   goto yyerrlab1;
1977
1978
1979 /*---------------------------------------------------.
1980 | yyerrorlab -- error raised explicitly by YYERROR.  |
1981 `---------------------------------------------------*/
1982 yyerrorlab:
1983
1984   /* Pacify compilers like GCC when the user code never invokes
1985      YYERROR and the label yyerrorlab therefore never appears in user
1986      code.  */
1987   if (/*CONSTCOND*/ 0)
1988      goto yyerrorlab;
1989
1990   yyerror_range[0] = yylsp[1-yylen];
1991   /* Do not reclaim the symbols of the rule which action triggered
1992      this YYERROR.  */
1993   YYPOPSTACK (yylen);
1994   yylen = 0;
1995   YY_STACK_PRINT (yyss, yyssp);
1996   yystate = *yyssp;
1997   goto yyerrlab1;
1998
1999
2000 /*-------------------------------------------------------------.
2001 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
2002 `-------------------------------------------------------------*/
2003 yyerrlab1:
2004   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
2005
2006   for (;;)
2007     {
2008       yyn = yypact[yystate];
2009       if (yyn != YYPACT_NINF)
2010         {
2011           yyn += YYTERROR;
2012           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2013             {
2014               yyn = yytable[yyn];
2015               if (0 < yyn)
2016                 break;
2017             }
2018         }
2019
2020       /* Pop the current state because it cannot handle the error token.  */
2021       if (yyssp == yyss)
2022         YYABORT;
2023
2024       yyerror_range[0] = *yylsp;
2025       yydestruct ("Error: popping",
2026                   yystos[yystate], yyvsp, yylsp);
2027       YYPOPSTACK (1);
2028       yystate = *yyssp;
2029       YY_STACK_PRINT (yyss, yyssp);
2030     }
2031
2032   if (yyn == YYFINAL)
2033     YYACCEPT;
2034
2035   *++yyvsp = yylval;
2036
2037   yyerror_range[1] = yylloc;
2038   /* Using YYLLOC is tempting, but would change the location of
2039      the look-ahead.  YYLOC is available though.  */
2040   YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
2041   *++yylsp = yyloc;
2042
2043   /* Shift the error token.  */
2044   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2045
2046   yystate = yyn;
2047   goto yynewstate;
2048
2049
2050 /*-------------------------------------.
2051 | yyacceptlab -- YYACCEPT comes here.  |
2052 `-------------------------------------*/
2053 yyacceptlab:
2054   yyresult = 0;
2055   goto yyreturn;
2056
2057 /*-----------------------------------.
2058 | yyabortlab -- YYABORT comes here.  |
2059 `-----------------------------------*/
2060 yyabortlab:
2061   yyresult = 1;
2062   goto yyreturn;
2063
2064 #ifndef yyoverflow
2065 /*-------------------------------------------------.
2066 | yyexhaustedlab -- memory exhaustion comes here.  |
2067 `-------------------------------------------------*/
2068 yyexhaustedlab:
2069   yyerror (YY_("memory exhausted"));
2070   yyresult = 2;
2071   /* Fall through.  */
2072 #endif
2073
2074 yyreturn:
2075   if (yychar != YYEOF && yychar != YYEMPTY)
2076      yydestruct ("Cleanup: discarding lookahead",
2077                  yytoken, &yylval, &yylloc);
2078   /* Do not reclaim the symbols of the rule which action triggered
2079      this YYABORT or YYACCEPT.  */
2080   YYPOPSTACK (yylen);
2081   YY_STACK_PRINT (yyss, yyssp);
2082   while (yyssp != yyss)
2083     {
2084       yydestruct ("Cleanup: popping",
2085                   yystos[*yyssp], yyvsp, yylsp);
2086       YYPOPSTACK (1);
2087     }
2088 #ifndef yyoverflow
2089   if (yyss != yyssa)
2090     YYSTACK_FREE (yyss);
2091 #endif
2092 #if YYERROR_VERBOSE
2093   if (yymsg != yymsgbuf)
2094     YYSTACK_FREE (yymsg);
2095 #endif
2096   return yyresult;
2097 }
2098
2099
2100 #line 288 "ast_expr2.y"
2101
2102
2103 static struct val *
2104 make_number (FP___TYPE i)
2105 {
2106         struct val *vp;
2107
2108         vp = (struct val *) malloc (sizeof (*vp));
2109         if (vp == NULL) {
2110                 ast_log(LOG_WARNING, "malloc() failed\n");
2111                 return(NULL);
2112         }
2113
2114         vp->type = AST_EXPR_number;
2115         vp->u.i  = i;
2116         return vp;
2117 }
2118
2119 static struct val *
2120 make_str (const char *s)
2121 {
2122         struct val *vp;
2123         size_t i;
2124         int isint; /* this started out being a test for an integer, but then ended up being a test for a float */
2125
2126         vp = (struct val *) malloc (sizeof (*vp));
2127         if (vp == NULL || ((vp->u.s = strdup (s)) == NULL)) {
2128                 ast_log(LOG_WARNING,"malloc() failed\n");
2129                 return(NULL);
2130         }
2131
2132         for (i = 0, isint = (isdigit(s[0]) || s[0] == '-' || s[0]=='.'); isint && i < strlen(s); i++)
2133         {
2134                 if (!isdigit(s[i]) && s[i] != '.') {
2135                         isint = 0;
2136                         break;
2137                 }
2138         }
2139         if (isint)
2140                 vp->type = AST_EXPR_numeric_string;
2141         else
2142                 vp->type = AST_EXPR_string;
2143
2144         return vp;
2145 }
2146
2147
2148 static void
2149 free_value (struct val *vp)
2150 {
2151         if (vp==NULL) {
2152                 return;
2153         }
2154         if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
2155                 free (vp->u.s);
2156         free(vp);
2157 }
2158
2159
2160 static int
2161 to_number (struct val *vp)
2162 {
2163         FP___TYPE i;
2164
2165         if (vp == NULL) {
2166                 ast_log(LOG_WARNING,"vp==NULL in to_number()\n");
2167                 return(0);
2168         }
2169
2170         if (vp->type == AST_EXPR_number)
2171                 return 1;
2172
2173         if (vp->type == AST_EXPR_string)
2174                 return 0;
2175
2176         /* vp->type == AST_EXPR_numeric_string, make it numeric */
2177         errno = 0;
2178         i  = FP___STRTOD(vp->u.s, (char**)0); /* either strtod, or strtold on a good day */
2179         if (errno != 0) {
2180                 ast_log(LOG_WARNING,"Conversion of %s to number under/overflowed!\n", vp->u.s);
2181                 free(vp->u.s);
2182                 vp->u.s = 0;
2183                 return(0);
2184         }
2185         free (vp->u.s);
2186         vp->u.i = i;
2187         vp->type = AST_EXPR_number;
2188         return 1;
2189 }
2190
2191 static void
2192 strip_quotes(struct val *vp)
2193 {
2194         if (vp->type != AST_EXPR_string && vp->type != AST_EXPR_numeric_string)
2195                 return;
2196
2197         if( vp->u.s[0] == '"' && vp->u.s[strlen(vp->u.s)-1] == '"' )
2198         {
2199                 char *f, *t;
2200                 f = vp->u.s;
2201                 t = vp->u.s;
2202
2203                 while( *f )
2204                 {
2205                         if( *f  && *f != '"' )
2206                                 *t++ = *f++;
2207                         else
2208                                 f++;
2209                 }
2210                 *t = *f;
2211         }
2212 }
2213
2214 static void
2215 to_string (struct val *vp)
2216 {
2217         char *tmp;
2218
2219         if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
2220                 return;
2221
2222         tmp = malloc ((size_t)25);
2223         if (tmp == NULL) {
2224                 ast_log(LOG_WARNING,"malloc() failed\n");
2225                 return;
2226         }
2227
2228         sprintf(tmp, FP___PRINTF, vp->u.i);
2229         vp->type = AST_EXPR_string;
2230         vp->u.s  = tmp;
2231 }
2232
2233
2234 static int
2235 isstring (struct val *vp)
2236 {
2237         /* only TRUE if this string is not a valid number */
2238         return (vp->type == AST_EXPR_string);
2239 }
2240
2241
2242 static int
2243 is_zero_or_null (struct val *vp)
2244 {
2245         if (vp->type == AST_EXPR_number) {
2246                 return (vp->u.i == 0);
2247         } else {
2248                 return (*vp->u.s == 0 || (to_number(vp) && vp->u.i == 0));
2249         }
2250         /* NOTREACHED */
2251 }
2252
2253 #ifdef STANDALONE
2254
2255 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
2256 {
2257         va_list vars;
2258         va_start(vars,fmt);
2259
2260         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
2261                    level, file, line, function);
2262         vprintf(fmt, vars);
2263         fflush(stdout);
2264         va_end(vars);
2265 }
2266
2267
2268 int main(int argc,char **argv) {
2269         char s[4096];
2270         char out[4096];
2271         FILE *infile;
2272
2273         if( !argv[1] )
2274                 exit(20);
2275
2276         if( access(argv[1],F_OK)== 0 )
2277         {
2278                 int ret;
2279
2280                 infile = fopen(argv[1],"r");
2281                 if( !infile )
2282                 {
2283                         printf("Sorry, couldn't open %s for reading!\n", argv[1]);
2284                         exit(10);
2285                 }
2286                 while( fgets(s,sizeof(s),infile) )
2287                 {
2288                         if( s[strlen(s)-1] == '\n' )
2289                                 s[strlen(s)-1] = 0;
2290
2291                         ret = ast_expr(s, out, sizeof(out));
2292                         printf("Expression: %s    Result: [%d] '%s'\n",
2293                                    s, ret, out);
2294                 }
2295                 fclose(infile);
2296         }
2297         else
2298         {
2299                 if (ast_expr(argv[1], s, sizeof(s)))
2300                         printf("=====%s======\n",s);
2301                 else
2302                         printf("No result\n");
2303         }
2304 }
2305
2306 #endif
2307
2308 #undef ast_yyerror
2309 #define ast_yyerror(x) ast_yyerror(x, YYLTYPE *yylloc, struct parse_io *parseio)
2310
2311 /* I put the ast_yyerror func in the flex input file,
2312    because it refers to the buffer state. Best to
2313    let it access the BUFFER stuff there and not trying
2314    define all the structs, macros etc. in this file! */
2315
2316
2317 static struct val *
2318 op_or (struct val *a, struct val *b)
2319 {
2320         if (is_zero_or_null (a)) {
2321                 free_value (a);
2322                 return (b);
2323         } else {
2324                 free_value (b);
2325                 return (a);
2326         }
2327 }
2328
2329 static struct val *
2330 op_and (struct val *a, struct val *b)
2331 {
2332         if (is_zero_or_null (a) || is_zero_or_null (b)) {
2333                 free_value (a);
2334                 free_value (b);
2335                 return (make_number ((double)0.0));
2336         } else {
2337                 free_value (b);
2338                 return (a);
2339         }
2340 }
2341
2342 static struct val *
2343 op_eq (struct val *a, struct val *b)
2344 {
2345         struct val *r;
2346
2347         if (isstring (a) || isstring (b)) {
2348                 to_string (a);
2349                 to_string (b);
2350                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) == 0));
2351         } else {
2352 #ifdef DEBUG_FOR_CONVERSIONS
2353                 char buffer[2000];
2354                 sprintf(buffer,"Converting '%s' and '%s' ", a->u.s, b->u.s);
2355 #endif
2356                 (void)to_number(a);
2357                 (void)to_number(b);
2358 #ifdef DEBUG_FOR_CONVERSIONS
2359                 ast_log(LOG_WARNING,"%s to '%lld' and '%lld'\n", buffer, a->u.i, b->u.i);
2360 #endif
2361                 r = make_number ((FP___TYPE)(a->u.i == b->u.i));
2362         }
2363
2364         free_value (a);
2365         free_value (b);
2366         return r;
2367 }
2368
2369 static struct val *
2370 op_gt (struct val *a, struct val *b)
2371 {
2372         struct val *r;
2373
2374         if (isstring (a) || isstring (b)) {
2375                 to_string (a);
2376                 to_string (b);
2377                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) > 0));
2378         } else {
2379                 (void)to_number(a);
2380                 (void)to_number(b);
2381                 r = make_number ((FP___TYPE)(a->u.i > b->u.i));
2382         }
2383
2384         free_value (a);
2385         free_value (b);
2386         return r;
2387 }
2388
2389 static struct val *
2390 op_lt (struct val *a, struct val *b)
2391 {
2392         struct val *r;
2393
2394         if (isstring (a) || isstring (b)) {
2395                 to_string (a);
2396                 to_string (b);
2397                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) < 0));
2398         } else {
2399                 (void)to_number(a);
2400                 (void)to_number(b);
2401                 r = make_number ((FP___TYPE)(a->u.i < b->u.i));
2402         }
2403
2404         free_value (a);
2405         free_value (b);
2406         return r;
2407 }
2408
2409 static struct val *
2410 op_ge (struct val *a, struct val *b)
2411 {
2412         struct val *r;
2413
2414         if (isstring (a) || isstring (b)) {
2415                 to_string (a);
2416                 to_string (b);
2417                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) >= 0));
2418         } else {
2419                 (void)to_number(a);
2420                 (void)to_number(b);
2421                 r = make_number ((FP___TYPE)(a->u.i >= b->u.i));
2422         }
2423
2424         free_value (a);
2425         free_value (b);
2426         return r;
2427 }
2428
2429 static struct val *
2430 op_le (struct val *a, struct val *b)
2431 {
2432         struct val *r;
2433
2434         if (isstring (a) || isstring (b)) {
2435                 to_string (a);
2436                 to_string (b);
2437                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) <= 0));
2438         } else {
2439                 (void)to_number(a);
2440                 (void)to_number(b);
2441                 r = make_number ((FP___TYPE)(a->u.i <= b->u.i));
2442         }
2443
2444         free_value (a);
2445         free_value (b);
2446         return r;
2447 }
2448
2449 static struct val *
2450 op_cond (struct val *a, struct val *b, struct val *c)
2451 {
2452         struct val *r;
2453
2454         if( isstring(a) )
2455         {
2456                 if( strlen(a->u.s) && strcmp(a->u.s, "\"\"") != 0 && strcmp(a->u.s,"0") != 0 )
2457                 {
2458                         free_value(a);
2459                         free_value(c);
2460                         r = b;
2461                 }
2462                 else
2463                 {
2464                         free_value(a);
2465                         free_value(b);
2466                         r = c;
2467                 }
2468         }
2469         else
2470         {
2471                 (void)to_number(a);
2472                 if( a->u.i )
2473                 {
2474                         free_value(a);
2475                         free_value(c);
2476                         r = b;
2477                 }
2478                 else
2479                 {
2480                         free_value(a);
2481                         free_value(b);
2482                         r = c;
2483                 }
2484         }
2485         return r;
2486 }
2487
2488 static struct val *
2489 op_ne (struct val *a, struct val *b)
2490 {
2491         struct val *r;
2492
2493         if (isstring (a) || isstring (b)) {
2494                 to_string (a);
2495                 to_string (b);
2496                 r = make_number ((FP___TYPE)(strcoll (a->u.s, b->u.s) != 0));
2497         } else {
2498                 (void)to_number(a);
2499                 (void)to_number(b);
2500                 r = make_number ((FP___TYPE)(a->u.i != b->u.i));
2501         }
2502
2503         free_value (a);
2504         free_value (b);
2505         return r;
2506 }
2507
2508 static int
2509 chk_plus (FP___TYPE a, FP___TYPE b, FP___TYPE r)
2510 {
2511         /* sum of two positive numbers must be positive */
2512         if (a > 0 && b > 0 && r <= 0)
2513                 return 1;
2514         /* sum of two negative numbers must be negative */
2515         if (a < 0 && b < 0 && r >= 0)
2516                 return 1;
2517         /* all other cases are OK */
2518         return 0;
2519 }
2520
2521 static struct val *
2522 op_plus (struct val *a, struct val *b)
2523 {
2524         struct val *r;
2525
2526         if (!to_number (a)) {
2527                 if( !extra_error_message_supplied )
2528                         ast_log(LOG_WARNING,"non-numeric argument\n");
2529                 if (!to_number (b)) {
2530                         free_value(a);
2531                         free_value(b);
2532                         return make_number(0);
2533                 } else {
2534                         free_value(a);
2535                         return (b);
2536                 }
2537         } else if (!to_number(b)) {
2538                 free_value(b);
2539                 return (a);
2540         }
2541
2542         r = make_number (a->u.i + b->u.i);
2543         if (chk_plus (a->u.i, b->u.i, r->u.i)) {
2544                 ast_log(LOG_WARNING,"overflow\n");
2545         }
2546         free_value (a);
2547         free_value (b);
2548         return r;
2549 }
2550
2551 static int
2552 chk_minus (FP___TYPE a, FP___TYPE b, FP___TYPE r)
2553 {
2554         /* special case subtraction of QUAD_MIN */
2555         if (b == QUAD_MIN) {
2556                 if (a >= 0)
2557                         return 1;
2558                 else
2559                         return 0;
2560         }
2561         /* this is allowed for b != QUAD_MIN */
2562         return chk_plus (a, -b, r);
2563 }
2564
2565 static struct val *
2566 op_minus (struct val *a, struct val *b)
2567 {
2568         struct val *r;
2569
2570         if (!to_number (a)) {
2571                 if( !extra_error_message_supplied )
2572                         ast_log(LOG_WARNING, "non-numeric argument\n");
2573                 if (!to_number (b)) {
2574                         free_value(a);
2575                         free_value(b);
2576                         return make_number(0);
2577                 } else {
2578                         r = make_number(0 - b->u.i);
2579                         free_value(a);
2580                         free_value(b);
2581                         return (r);
2582                 }
2583         } else if (!to_number(b)) {
2584                 if( !extra_error_message_supplied )
2585                         ast_log(LOG_WARNING, "non-numeric argument\n");
2586                 free_value(b);
2587                 return (a);
2588         }
2589
2590         r = make_number (a->u.i - b->u.i);
2591         if (chk_minus (a->u.i, b->u.i, r->u.i)) {
2592                 ast_log(LOG_WARNING, "overflow\n");
2593         }
2594         free_value (a);
2595         free_value (b);
2596         return r;
2597 }
2598
2599 static struct val *
2600 op_negate (struct val *a)
2601 {
2602         struct val *r;
2603
2604         if (!to_number (a) ) {
2605                 free_value(a);
2606                 if( !extra_error_message_supplied )
2607                         ast_log(LOG_WARNING, "non-numeric argument\n");
2608                 return make_number(0);
2609         }
2610
2611         r = make_number (- a->u.i);
2612         if (chk_minus (0, a->u.i, r->u.i)) {
2613                 ast_log(LOG_WARNING, "overflow\n");
2614         }
2615         free_value (a);
2616         return r;
2617 }
2618
2619 static struct val *
2620 op_compl (struct val *a)
2621 {
2622         int v1 = 1;
2623         struct val *r;
2624
2625         if( !a )
2626         {
2627                 v1 = 0;
2628         }
2629         else
2630         {
2631                 switch( a->type )
2632                 {
2633                 case AST_EXPR_number:
2634                         if( a->u.i == 0 )
2635                                 v1 = 0;
2636                         break;
2637
2638                 case AST_EXPR_string:
2639                         if( a->u.s == 0 )
2640                                 v1 = 0;
2641                         else
2642                         {
2643                                 if( a->u.s[0] == 0 )
2644                                         v1 = 0;
2645                                 else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
2646                                         v1 = 0;
2647                         }
2648                         break;
2649
2650                 case AST_EXPR_numeric_string:
2651                         if( a->u.s == 0 )
2652                                 v1 = 0;
2653                         else
2654                         {
2655                                 if( a->u.s[0] == 0 )
2656                                         v1 = 0;
2657                                 else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
2658                                         v1 = 0;
2659                         }
2660                         break;
2661                 }
2662         }
2663
2664         r = make_number (!v1);
2665         free_value (a);
2666         return r;
2667 }
2668
2669 static int
2670 chk_times (FP___TYPE a, FP___TYPE b, FP___TYPE r)
2671 {
2672         /* special case: first operand is 0, no overflow possible */
2673         if (a == 0)
2674                 return 0;
2675         /* cerify that result of division matches second operand */
2676         if (r / a != b)
2677                 return 1;
2678         return 0;
2679 }
2680
2681 static struct val *
2682 op_times (struct val *a, struct val *b)
2683 {
2684         struct val *r;
2685
2686         if (!to_number (a) || !to_number (b)) {
2687                 free_value(a);
2688                 free_value(b);
2689                 if( !extra_error_message_supplied )
2690                         ast_log(LOG_WARNING, "non-numeric argument\n");
2691                 return(make_number(0));
2692         }
2693
2694         r = make_number (a->u.i * b->u.i);
2695         if (chk_times (a->u.i, b->u.i, r->u.i)) {
2696                 ast_log(LOG_WARNING, "overflow\n");
2697         }
2698         free_value (a);
2699         free_value (b);
2700         return (r);
2701 }
2702
2703 static int
2704 chk_div (FP___TYPE a, FP___TYPE b)
2705 {
2706         /* div by zero has been taken care of before */
2707         /* only QUAD_MIN / -1 causes overflow */
2708         if (a == QUAD_MIN && b == -1)
2709                 return 1;
2710         /* everything else is OK */
2711         return 0;
2712 }
2713
2714 static struct val *
2715 op_div (struct val *a, struct val *b)
2716 {
2717         struct val *r;
2718
2719         if (!to_number (a)) {
2720                 free_value(a);
2721                 free_value(b);
2722                 if( !extra_error_message_supplied )
2723                         ast_log(LOG_WARNING, "non-numeric argument\n");
2724                 return make_number(0);
2725         } else if (!to_number (b)) {
2726                 free_value(a);
2727                 free_value(b);
2728                 if( !extra_error_message_supplied )
2729                         ast_log(LOG_WARNING, "non-numeric argument\n");
2730                 return make_number(INT_MAX);
2731         }
2732
2733         if (b->u.i == 0) {
2734                 ast_log(LOG_WARNING, "division by zero\n");
2735                 free_value(a);
2736                 free_value(b);
2737                 return make_number(INT_MAX);
2738         }
2739
2740         r = make_number (a->u.i / b->u.i);
2741         if (chk_div (a->u.i, b->u.i)) {
2742                 ast_log(LOG_WARNING, "overflow\n");
2743         }
2744         free_value (a);
2745         free_value (b);
2746         return r;
2747 }
2748
2749 static struct val *
2750 op_rem (struct val *a, struct val *b)
2751 {
2752         struct val *r;
2753
2754         if (!to_number (a) || !to_number (b)) {
2755                 if( !extra_error_message_supplied )
2756                         ast_log(LOG_WARNING, "non-numeric argument\n");
2757                 free_value(a);
2758                 free_value(b);
2759                 return make_number(0);
2760         }
2761
2762         if (b->u.i == 0) {
2763                 ast_log(LOG_WARNING, "div by zero\n");
2764                 free_value(a);
2765                 return(b);
2766         }
2767
2768         r = make_number (FP___FMOD(a->u.i, b->u.i)); /* either fmod or fmodl if FP___TYPE is available */
2769         /* chk_rem necessary ??? */
2770         free_value (a);
2771         free_value (b);
2772         return r;
2773 }
2774
2775
2776 static struct val *
2777 op_colon (struct val *a, struct val *b)
2778 {
2779         regex_t rp;
2780         regmatch_t rm[2];
2781         char errbuf[256];
2782         int eval;
2783         struct val *v;
2784
2785         /* coerce to both arguments to strings */
2786         to_string(a);
2787         to_string(b);
2788         /* strip double quotes from both -- they'll screw up the pattern, and the search string starting at ^ */
2789         strip_quotes(a);
2790         strip_quotes(b);
2791         /* compile regular expression */
2792         if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
2793                 regerror (eval, &rp, errbuf, sizeof(errbuf));
2794                 ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
2795                 free_value(a);
2796                 free_value(b);
2797                 return make_str("");
2798         }
2799
2800         /* compare string against pattern */
2801         /* remember that patterns are anchored to the beginning of the line */
2802         if (regexec(&rp, a->u.s, (size_t)2, rm, 0) == 0 && rm[0].rm_so == 0) {
2803                 if (rm[1].rm_so >= 0) {
2804                         *(a->u.s + rm[1].rm_eo) = '\0';
2805                         v = make_str (a->u.s + rm[1].rm_so);
2806
2807                 } else {
2808                         v = make_number ((FP___TYPE)(rm[0].rm_eo - rm[0].rm_so));
2809                 }
2810         } else {
2811                 if (rp.re_nsub == 0) {
2812                         v = make_number ((FP___TYPE)0);
2813                 } else {
2814                         v = make_str ("");
2815                 }
2816         }
2817
2818         /* free arguments and pattern buffer */
2819         free_value (a);
2820         free_value (b);
2821         regfree (&rp);
2822
2823         return v;
2824 }
2825
2826
2827 static struct val *
2828 op_eqtilde (struct val *a, struct val *b)
2829 {
2830         regex_t rp;
2831         regmatch_t rm[2];
2832         char errbuf[256];
2833         int eval;
2834         struct val *v;
2835
2836         /* coerce to both arguments to strings */
2837         to_string(a);
2838         to_string(b);
2839         /* strip double quotes from both -- they'll screw up the pattern, and the search string starting at ^ */
2840         strip_quotes(a);
2841         strip_quotes(b);
2842         /* compile regular expression */
2843         if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
2844                 regerror (eval, &rp, errbuf, sizeof(errbuf));
2845                 ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
2846                 free_value(a);
2847                 free_value(b);
2848                 return make_str("");
2849         }
2850
2851         /* compare string against pattern */
2852         /* remember that patterns are anchored to the beginning of the line */
2853         if (regexec(&rp, a->u.s, (size_t)2, rm, 0) == 0 ) {
2854                 if (rm[1].rm_so >= 0) {
2855                         *(a->u.s + rm[1].rm_eo) = '\0';
2856                         v = make_str (a->u.s + rm[1].rm_so);
2857
2858                 } else {
2859                         v = make_number ((FP___TYPE)(rm[0].rm_eo - rm[0].rm_so));
2860                 }
2861         } else {
2862                 if (rp.re_nsub == 0) {
2863                         v = make_number ((FP___TYPE)0.0);
2864                 } else {
2865                         v = make_str ("");
2866                 }
2867         }
2868
2869         /* free arguments and pattern buffer */
2870         free_value (a);
2871         free_value (b);
2872         regfree (&rp);
2873
2874         return v;
2875 }
2876