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