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