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