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