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