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