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