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