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