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