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