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