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