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