fix signed/unsigned result issue on 32-bit platforms (issue #5050)
[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,   165,   166,   169,   172,   175,   178,   181,
477      184,   187,   190,   193,   196,   199,   202,   205,   208,   211,
478      214,   217,   220
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               ((struct parse_io *)parseio)->val->u.s = yyval.val->u.s; ;}
1236     break;
1237
1238   case 3:
1239 #line 165 "ast_expr2.y"
1240     { yyval.val= yyvsp[0].val;;}
1241     break;
1242
1243   case 4:
1244 #line 166 "ast_expr2.y"
1245     { yyval.val = yyvsp[-1].val; 
1246                                yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1247                                                    yyloc.first_line=0; yyloc.last_line=0;;}
1248     break;
1249
1250   case 5:
1251 #line 169 "ast_expr2.y"
1252     { yyval.val = op_or (yyvsp[-2].val, yyvsp[0].val);
1253                          yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1254                                                  yyloc.first_line=0; yyloc.last_line=0;;}
1255     break;
1256
1257   case 6:
1258 #line 172 "ast_expr2.y"
1259     { yyval.val = op_and (yyvsp[-2].val, yyvsp[0].val); 
1260                               yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1261                           yyloc.first_line=0; yyloc.last_line=0;;}
1262     break;
1263
1264   case 7:
1265 #line 175 "ast_expr2.y"
1266     { yyval.val = op_eq (yyvsp[-2].val, yyvsp[0].val);
1267                              yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column;
1268                                                  yyloc.first_line=0; yyloc.last_line=0;;}
1269     break;
1270
1271   case 8:
1272 #line 178 "ast_expr2.y"
1273     { yyval.val = op_gt (yyvsp[-2].val, yyvsp[0].val);
1274                          yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column;
1275                                                  yyloc.first_line=0; yyloc.last_line=0;;}
1276     break;
1277
1278   case 9:
1279 #line 181 "ast_expr2.y"
1280     { yyval.val = op_lt (yyvsp[-2].val, yyvsp[0].val); 
1281                              yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1282                                                  yyloc.first_line=0; yyloc.last_line=0;;}
1283     break;
1284
1285   case 10:
1286 #line 184 "ast_expr2.y"
1287     { yyval.val = op_ge (yyvsp[-2].val, yyvsp[0].val); 
1288                               yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1289                                                   yyloc.first_line=0; yyloc.last_line=0;;}
1290     break;
1291
1292   case 11:
1293 #line 187 "ast_expr2.y"
1294     { yyval.val = op_le (yyvsp[-2].val, yyvsp[0].val); 
1295                               yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1296                                                   yyloc.first_line=0; yyloc.last_line=0;;}
1297     break;
1298
1299   case 12:
1300 #line 190 "ast_expr2.y"
1301     { yyval.val = op_ne (yyvsp[-2].val, yyvsp[0].val); 
1302                               yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1303                                                   yyloc.first_line=0; yyloc.last_line=0;;}
1304     break;
1305
1306   case 13:
1307 #line 193 "ast_expr2.y"
1308     { yyval.val = op_plus (yyvsp[-2].val, yyvsp[0].val); 
1309                                yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1310                                                    yyloc.first_line=0; yyloc.last_line=0;;}
1311     break;
1312
1313   case 14:
1314 #line 196 "ast_expr2.y"
1315     { yyval.val = op_minus (yyvsp[-2].val, yyvsp[0].val); 
1316                                 yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1317                                                         yyloc.first_line=0; yyloc.last_line=0;;}
1318     break;
1319
1320   case 15:
1321 #line 199 "ast_expr2.y"
1322     { yyval.val = op_negate (yyvsp[0].val); 
1323                                 yyloc.first_column = yylsp[-1].first_column; yyloc.last_column = yylsp[0].last_column; 
1324                                                         yyloc.first_line=0; yyloc.last_line=0;;}
1325     break;
1326
1327   case 16:
1328 #line 202 "ast_expr2.y"
1329     { yyval.val = op_compl (yyvsp[0].val); 
1330                                 yyloc.first_column = yylsp[-1].first_column; yyloc.last_column = yylsp[0].last_column; 
1331                                                         yyloc.first_line=0; yyloc.last_line=0;;}
1332     break;
1333
1334   case 17:
1335 #line 205 "ast_expr2.y"
1336     { yyval.val = op_times (yyvsp[-2].val, yyvsp[0].val); 
1337                                yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1338                                                    yyloc.first_line=0; yyloc.last_line=0;;}
1339     break;
1340
1341   case 18:
1342 #line 208 "ast_expr2.y"
1343     { yyval.val = op_div (yyvsp[-2].val, yyvsp[0].val); 
1344                               yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1345                                                   yyloc.first_line=0; yyloc.last_line=0;;}
1346     break;
1347
1348   case 19:
1349 #line 211 "ast_expr2.y"
1350     { yyval.val = op_rem (yyvsp[-2].val, yyvsp[0].val); 
1351                               yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1352                                                   yyloc.first_line=0; yyloc.last_line=0;;}
1353     break;
1354
1355   case 20:
1356 #line 214 "ast_expr2.y"
1357     { yyval.val = op_colon (yyvsp[-2].val, yyvsp[0].val); 
1358                                 yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1359                                                         yyloc.first_line=0; yyloc.last_line=0;;}
1360     break;
1361
1362   case 21:
1363 #line 217 "ast_expr2.y"
1364     { yyval.val = op_eqtilde (yyvsp[-2].val, yyvsp[0].val); 
1365                                 yyloc.first_column = yylsp[-2].first_column; yyloc.last_column = yylsp[0].last_column; 
1366                                                         yyloc.first_line=0; yyloc.last_line=0;;}
1367     break;
1368
1369   case 22:
1370 #line 220 "ast_expr2.y"
1371     { yyval.val = op_cond (yyvsp[-4].val, yyvsp[-2].val, yyvsp[0].val); 
1372                                 yyloc.first_column = yylsp[-4].first_column; yyloc.last_column = yylsp[-2].last_column; 
1373                                                         yyloc.first_line=0; yyloc.last_line=0;;}
1374     break;
1375
1376
1377     }
1378
1379 /* Line 1010 of yacc.c.  */
1380 #line 1381 "ast_expr2.c"
1381 \f
1382   yyvsp -= yylen;
1383   yyssp -= yylen;
1384   yylsp -= yylen;
1385
1386   YY_STACK_PRINT (yyss, yyssp);
1387
1388   *++yyvsp = yyval;
1389   *++yylsp = yyloc;
1390
1391   /* Now `shift' the result of the reduction.  Determine what state
1392      that goes to, based on the state we popped back to and the rule
1393      number reduced by.  */
1394
1395   yyn = yyr1[yyn];
1396
1397   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1398   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1399     yystate = yytable[yystate];
1400   else
1401     yystate = yydefgoto[yyn - YYNTOKENS];
1402
1403   goto yynewstate;
1404
1405
1406 /*------------------------------------.
1407 | yyerrlab -- here on detecting error |
1408 `------------------------------------*/
1409 yyerrlab:
1410   /* If not already recovering from an error, report this error.  */
1411   if (!yyerrstatus)
1412     {
1413       ++yynerrs;
1414 #if YYERROR_VERBOSE
1415       yyn = yypact[yystate];
1416
1417       if (YYPACT_NINF < yyn && yyn < YYLAST)
1418         {
1419           YYSIZE_T yysize = 0;
1420           int yytype = YYTRANSLATE (yychar);
1421           const char* yyprefix;
1422           char *yymsg;
1423           int yyx;
1424
1425           /* Start YYX at -YYN if negative to avoid negative indexes in
1426              YYCHECK.  */
1427           int yyxbegin = yyn < 0 ? -yyn : 0;
1428
1429           /* Stay within bounds of both yycheck and yytname.  */
1430           int yychecklim = YYLAST - yyn;
1431           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1432           int yycount = 0;
1433
1434           yyprefix = ", expecting ";
1435           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1436             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1437               {
1438                 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
1439                 yycount += 1;
1440                 if (yycount == 5)
1441                   {
1442                     yysize = 0;
1443                     break;
1444                   }
1445               }
1446           yysize += (sizeof ("syntax error, unexpected ")
1447                      + yystrlen (yytname[yytype]));
1448           yymsg = (char *) YYSTACK_ALLOC (yysize);
1449           if (yymsg != 0)
1450             {
1451               char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1452               yyp = yystpcpy (yyp, yytname[yytype]);
1453
1454               if (yycount < 5)
1455                 {
1456                   yyprefix = ", expecting ";
1457                   for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1458                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1459                       {
1460                         yyp = yystpcpy (yyp, yyprefix);
1461                         yyp = yystpcpy (yyp, yytname[yyx]);
1462                         yyprefix = " or ";
1463                       }
1464                 }
1465               yyerror (yymsg);
1466               YYSTACK_FREE (yymsg);
1467             }
1468           else
1469             yyerror ("syntax error; also virtual memory exhausted");
1470         }
1471       else
1472 #endif /* YYERROR_VERBOSE */
1473         yyerror ("syntax error");
1474     }
1475
1476   yylerrsp = yylsp;
1477
1478   if (yyerrstatus == 3)
1479     {
1480       /* If just tried and failed to reuse lookahead token after an
1481          error, discard it.  */
1482
1483       if (yychar <= YYEOF)
1484         {
1485           /* If at end of input, pop the error token,
1486              then the rest of the stack, then return failure.  */
1487           if (yychar == YYEOF)
1488              for (;;)
1489                {
1490                  YYPOPSTACK;
1491                  if (yyssp == yyss)
1492                    YYABORT;
1493                  YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1494                  yydestruct (yystos[*yyssp], yyvsp, yylsp);
1495                }
1496         }
1497       else
1498         {
1499           YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
1500           yydestruct (yytoken, &yylval, &yylloc);
1501           yychar = YYEMPTY;
1502           *++yylerrsp = yylloc;
1503         }
1504     }
1505
1506   /* Else will try to reuse lookahead token after shifting the error
1507      token.  */
1508   goto yyerrlab1;
1509
1510
1511 /*---------------------------------------------------.
1512 | yyerrorlab -- error raised explicitly by YYERROR.  |
1513 `---------------------------------------------------*/
1514 yyerrorlab:
1515
1516 #ifdef __GNUC__
1517   /* Pacify GCC when the user code never invokes YYERROR and the label
1518      yyerrorlab therefore never appears in user code.  */
1519   if (0)
1520      goto yyerrorlab;
1521 #endif
1522
1523   yyvsp -= yylen;
1524   yyssp -= yylen;
1525   yystate = *yyssp;
1526   yylerrsp = yylsp;
1527   *++yylerrsp = yyloc;
1528   yylsp -= yylen;
1529   goto yyerrlab1;
1530
1531
1532 /*-------------------------------------------------------------.
1533 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1534 `-------------------------------------------------------------*/
1535 yyerrlab1:
1536   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1537
1538   for (;;)
1539     {
1540       yyn = yypact[yystate];
1541       if (yyn != YYPACT_NINF)
1542         {
1543           yyn += YYTERROR;
1544           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1545             {
1546               yyn = yytable[yyn];
1547               if (0 < yyn)
1548                 break;
1549             }
1550         }
1551
1552       /* Pop the current state because it cannot handle the error token.  */
1553       if (yyssp == yyss)
1554         YYABORT;
1555
1556       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1557       yydestruct (yystos[yystate], yyvsp, yylsp);
1558       YYPOPSTACK;
1559       yystate = *yyssp;
1560       YY_STACK_PRINT (yyss, yyssp);
1561     }
1562
1563   if (yyn == YYFINAL)
1564     YYACCEPT;
1565
1566   YYDPRINTF ((stderr, "Shifting error token, "));
1567
1568   *++yyvsp = yylval;
1569   YYLLOC_DEFAULT (yyloc, yylsp, yylerrsp - yylsp);
1570   *++yylsp = yyloc;
1571
1572   yystate = yyn;
1573   goto yynewstate;
1574
1575
1576 /*-------------------------------------.
1577 | yyacceptlab -- YYACCEPT comes here.  |
1578 `-------------------------------------*/
1579 yyacceptlab:
1580   yyresult = 0;
1581   goto yyreturn;
1582
1583 /*-----------------------------------.
1584 | yyabortlab -- YYABORT comes here.  |
1585 `-----------------------------------*/
1586 yyabortlab:
1587   yyresult = 1;
1588   goto yyreturn;
1589
1590 #ifndef yyoverflow
1591 /*----------------------------------------------.
1592 | yyoverflowlab -- parser overflow comes here.  |
1593 `----------------------------------------------*/
1594 yyoverflowlab:
1595   yyerror ("parser stack overflow");
1596   yyresult = 2;
1597   /* Fall through.  */
1598 #endif
1599
1600 yyreturn:
1601 #ifndef yyoverflow
1602   if (yyss != yyssa)
1603     YYSTACK_FREE (yyss);
1604 #endif
1605   return yyresult;
1606 }
1607
1608
1609 #line 225 "ast_expr2.y"
1610
1611
1612 static struct val *
1613 make_integer (quad_t i)
1614 {
1615         struct val *vp;
1616
1617         vp = (struct val *) malloc (sizeof (*vp));
1618         if (vp == NULL) {
1619                 ast_log(LOG_WARNING, "malloc() failed\n");
1620                 return(NULL);
1621         }
1622
1623         vp->type = AST_EXPR_integer;
1624         vp->u.i  = i;
1625         return vp; 
1626 }
1627
1628 static struct val *
1629 make_str (const char *s)
1630 {
1631         struct val *vp;
1632         size_t i;
1633         int isint;
1634
1635         vp = (struct val *) malloc (sizeof (*vp));
1636         if (vp == NULL || ((vp->u.s = strdup (s)) == NULL)) {
1637                 ast_log(LOG_WARNING,"malloc() failed\n");
1638                 return(NULL);
1639         }
1640
1641         for(i = 1, isint = isdigit(s[0]) || s[0] == '-';
1642             isint && i < strlen(s);
1643             i++)
1644         {
1645                 if(!isdigit(s[i]))
1646                          isint = 0;
1647         }
1648
1649         if (isint)
1650                 vp->type = AST_EXPR_numeric_string;
1651         else    
1652                 vp->type = AST_EXPR_string;
1653
1654         return vp;
1655 }
1656
1657
1658 static void
1659 free_value (struct val *vp)
1660 {       
1661         if (vp==NULL) {
1662                 return;
1663         }
1664         if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
1665                 free (vp->u.s); 
1666 }
1667
1668
1669 static quad_t
1670 to_integer (struct val *vp)
1671 {
1672         quad_t i;
1673         
1674         if (vp == NULL) {
1675                 ast_log(LOG_WARNING,"vp==NULL in to_integer()\n");
1676                 return(0);
1677         }
1678
1679         if (vp->type == AST_EXPR_integer)
1680                 return 1;
1681
1682         if (vp->type == AST_EXPR_string)
1683                 return 0;
1684
1685         /* vp->type == AST_EXPR_numeric_string, make it numeric */
1686         errno = 0;
1687         i  = strtoll(vp->u.s, (char**)NULL, 10);
1688         if (errno != 0) {
1689                 ast_log(LOG_WARNING,"Conversion of %s to integer under/overflowed!\n", vp->u.s);
1690                 free(vp->u.s);
1691                 vp->u.s = 0;
1692                 return(0);
1693         }
1694         free (vp->u.s);
1695         vp->u.i = i;
1696         vp->type = AST_EXPR_integer;
1697         return 1;
1698 }
1699
1700 static void
1701 strip_quotes(struct val *vp)
1702 {
1703         if (vp->type != AST_EXPR_string && vp->type != AST_EXPR_numeric_string)
1704                 return;
1705         
1706         if( vp->u.s[0] == '"' && vp->u.s[strlen(vp->u.s)-1] == '"' )
1707         {
1708                 char *f, *t;
1709                 f = vp->u.s;
1710                 t = vp->u.s;
1711                 
1712                 while( *f )
1713                 {
1714                         if( *f  && *f != '"' )
1715                                 *t++ = *f++;
1716                         else
1717                                 f++;
1718                 }
1719                 *t = *f;
1720         }
1721 }
1722
1723 static void
1724 to_string (struct val *vp)
1725 {
1726         char *tmp;
1727
1728         if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
1729                 return;
1730
1731         tmp = malloc ((size_t)25);
1732         if (tmp == NULL) {
1733                 ast_log(LOG_WARNING,"malloc() failed\n");
1734                 return;
1735         }
1736
1737         sprintf (tmp, "%ld", vp->u.i);
1738         vp->type = AST_EXPR_string;
1739         vp->u.s  = tmp;
1740 }
1741
1742
1743 static int
1744 isstring (struct val *vp)
1745 {
1746         /* only TRUE if this string is not a valid integer */
1747         return (vp->type == AST_EXPR_string);
1748 }
1749
1750
1751 static int
1752 is_zero_or_null (struct val *vp)
1753 {
1754         if (vp->type == AST_EXPR_integer) {
1755                 return (vp->u.i == 0);
1756         } else {
1757                 return (*vp->u.s == 0 || (to_integer (vp) && vp->u.i == 0));
1758         }
1759         /* NOTREACHED */
1760 }
1761
1762 #ifdef STANDALONE
1763
1764 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
1765 {
1766         va_list vars;
1767         va_start(vars,fmt);
1768         
1769         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
1770                    level, file, line, function);
1771         vprintf(fmt, vars);
1772         fflush(stdout);
1773         va_end(vars);
1774 }
1775
1776
1777 int main(int argc,char **argv) {
1778         char *s;
1779
1780         s=ast_expr(argv[1]);
1781
1782         printf("=====%s======\n",s);
1783 }
1784
1785 #endif
1786
1787 #undef ast_yyerror
1788 #define ast_yyerror(x) ast_yyerror(x, YYLTYPE *yylloc, struct parse_io *parseio)
1789
1790 /* I put the ast_yyerror func in the flex input file,
1791    because it refers to the buffer state. Best to
1792    let it access the BUFFER stuff there and not trying
1793    define all the structs, macros etc. in this file! */
1794
1795
1796 static struct val *
1797 op_or (struct val *a, struct val *b)
1798 {
1799         if (is_zero_or_null (a)) {
1800                 free_value (a);
1801                 return (b);
1802         } else {
1803                 free_value (b);
1804                 return (a);
1805         }
1806 }
1807                 
1808 static struct val *
1809 op_and (struct val *a, struct val *b)
1810 {
1811         if (is_zero_or_null (a) || is_zero_or_null (b)) {
1812                 free_value (a);
1813                 free_value (b);
1814                 return (make_integer ((quad_t)0));
1815         } else {
1816                 free_value (b);
1817                 return (a);
1818         }
1819 }
1820
1821 static struct val *
1822 op_eq (struct val *a, struct val *b)
1823 {
1824         struct val *r; 
1825
1826         if (isstring (a) || isstring (b)) {
1827                 to_string (a);
1828                 to_string (b);  
1829                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) == 0));
1830         } else {
1831 #ifdef DEBUG_FOR_CONVERSIONS
1832                 char buffer[2000];
1833                 sprintf(buffer,"Converting '%s' and '%s' ", a->u.s, b->u.s);
1834 #endif
1835                 (void)to_integer(a);
1836                 (void)to_integer(b);
1837 #ifdef DEBUG_FOR_CONVERSIONS
1838                 ast_log(LOG_WARNING,"%s to '%lld' and '%lld'\n", buffer, a->u.i, b->u.i);
1839 #endif
1840                 r = make_integer ((quad_t)(a->u.i == b->u.i));
1841         }
1842
1843         free_value (a);
1844         free_value (b);
1845         return r;
1846 }
1847
1848 static struct val *
1849 op_gt (struct val *a, struct val *b)
1850 {
1851         struct val *r;
1852
1853         if (isstring (a) || isstring (b)) {
1854                 to_string (a);
1855                 to_string (b);
1856                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) > 0));
1857         } else {
1858                 (void)to_integer(a);
1859                 (void)to_integer(b);
1860                 r = make_integer ((quad_t)(a->u.i > b->u.i));
1861         }
1862
1863         free_value (a);
1864         free_value (b);
1865         return r;
1866 }
1867
1868 static struct val *
1869 op_lt (struct val *a, struct val *b)
1870 {
1871         struct val *r;
1872
1873         if (isstring (a) || isstring (b)) {
1874                 to_string (a);
1875                 to_string (b);
1876                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) < 0));
1877         } else {
1878                 (void)to_integer(a);
1879                 (void)to_integer(b);
1880                 r = make_integer ((quad_t)(a->u.i < b->u.i));
1881         }
1882
1883         free_value (a);
1884         free_value (b);
1885         return r;
1886 }
1887
1888 static struct val *
1889 op_ge (struct val *a, struct val *b)
1890 {
1891         struct val *r;
1892
1893         if (isstring (a) || isstring (b)) {
1894                 to_string (a);
1895                 to_string (b);
1896                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) >= 0));
1897         } else {
1898                 (void)to_integer(a);
1899                 (void)to_integer(b);
1900                 r = make_integer ((quad_t)(a->u.i >= b->u.i));
1901         }
1902
1903         free_value (a);
1904         free_value (b);
1905         return r;
1906 }
1907
1908 static struct val *
1909 op_le (struct val *a, struct val *b)
1910 {
1911         struct val *r;
1912
1913         if (isstring (a) || isstring (b)) {
1914                 to_string (a);
1915                 to_string (b);
1916                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) <= 0));
1917         } else {
1918                 (void)to_integer(a);
1919                 (void)to_integer(b);
1920                 r = make_integer ((quad_t)(a->u.i <= b->u.i));
1921         }
1922
1923         free_value (a);
1924         free_value (b);
1925         return r;
1926 }
1927
1928 static struct val *
1929 op_cond (struct val *a, struct val *b, struct val *c)
1930 {
1931         struct val *r;
1932
1933         if( isstring(a) )
1934         {
1935                 if( strlen(a->u.s) && strcmp(a->u.s, "\"\"") != 0 && strcmp(a->u.s,"0") != 0 )
1936                 {
1937                         free_value(a);
1938                         free_value(c);
1939                         r = b;
1940                 }
1941                 else
1942                 {
1943                         free_value(a);
1944                         free_value(b);
1945                         r = c;
1946                 }
1947         }
1948         else
1949         {
1950                 (void)to_integer(a);
1951                 if( a->u.i )
1952                 {
1953                         free_value(a);
1954                         free_value(c);
1955                         r = b;
1956                 }
1957                 else
1958                 {
1959                         free_value(a);
1960                         free_value(b);
1961                         r = c;
1962                 }
1963         }
1964         return r;
1965 }
1966
1967 static struct val *
1968 op_ne (struct val *a, struct val *b)
1969 {
1970         struct val *r;
1971
1972         if (isstring (a) || isstring (b)) {
1973                 to_string (a);
1974                 to_string (b);
1975                 r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) != 0));
1976         } else {
1977                 (void)to_integer(a);
1978                 (void)to_integer(b);
1979                 r = make_integer ((quad_t)(a->u.i != b->u.i));
1980         }
1981
1982         free_value (a);
1983         free_value (b);
1984         return r;
1985 }
1986
1987 static int
1988 chk_plus (quad_t a, quad_t b, quad_t r)
1989 {
1990         /* sum of two positive numbers must be positive */
1991         if (a > 0 && b > 0 && r <= 0)
1992                 return 1;
1993         /* sum of two negative numbers must be negative */
1994         if (a < 0 && b < 0 && r >= 0)
1995                 return 1;
1996         /* all other cases are OK */
1997         return 0;
1998 }
1999
2000 static struct val *
2001 op_plus (struct val *a, struct val *b)
2002 {
2003         struct val *r;
2004
2005         if (!to_integer (a)) {
2006                 ast_log(LOG_WARNING,"non-numeric argument\n");
2007                 if (!to_integer (b)) {
2008                         free_value(a);
2009                         free_value(b);
2010                         return make_integer(0);
2011                 } else {
2012                         free_value(a);
2013                         return (b);
2014                 }
2015         } else if (!to_integer(b)) {
2016                 free_value(b);
2017                 return (a);
2018         }
2019
2020         r = make_integer (/*(quad_t)*/(a->u.i + b->u.i));
2021         if (chk_plus (a->u.i, b->u.i, r->u.i)) {
2022                 ast_log(LOG_WARNING,"overflow\n");
2023         }
2024         free_value (a);
2025         free_value (b);
2026         return r;
2027 }
2028
2029 static int
2030 chk_minus (quad_t a, quad_t b, quad_t r)
2031 {
2032         /* special case subtraction of QUAD_MIN */
2033         if (b == QUAD_MIN) {
2034                 if (a >= 0)
2035                         return 1;
2036                 else
2037                         return 0;
2038         }
2039         /* this is allowed for b != QUAD_MIN */
2040         return chk_plus (a, -b, r);
2041 }
2042
2043 static struct val *
2044 op_minus (struct val *a, struct val *b)
2045 {
2046         struct val *r;
2047
2048         if (!to_integer (a)) {
2049                 ast_log(LOG_WARNING, "non-numeric argument\n");
2050                 if (!to_integer (b)) {
2051                         free_value(a);
2052                         free_value(b);
2053                         return make_integer(0);
2054                 } else {
2055                         r = make_integer(0 - b->u.i);
2056                         free_value(a);
2057                         free_value(b);
2058                         return (r);
2059                 }
2060         } else if (!to_integer(b)) {
2061                 ast_log(LOG_WARNING, "non-numeric argument\n");
2062                 free_value(b);
2063                 return (a);
2064         }
2065
2066         r = make_integer (/*(quad_t)*/(a->u.i - b->u.i));
2067         if (chk_minus (a->u.i, b->u.i, r->u.i)) {
2068                 ast_log(LOG_WARNING, "overflow\n");
2069         }
2070         free_value (a);
2071         free_value (b);
2072         return r;
2073 }
2074
2075 static struct val *
2076 op_negate (struct val *a)
2077 {
2078         struct val *r;
2079
2080         if (!to_integer (a) ) {
2081                 free_value(a);
2082                 ast_log(LOG_WARNING, "non-numeric argument\n");
2083                 return make_integer(0);
2084         }
2085
2086         r = make_integer (/*(quad_t)*/(- a->u.i));
2087         if (chk_minus (0, a->u.i, r->u.i)) {
2088                 ast_log(LOG_WARNING, "overflow\n");
2089         }
2090         free_value (a);
2091         return r;
2092 }
2093
2094 static struct val *
2095 op_compl (struct val *a)
2096 {
2097         int v1 = 1;
2098         struct val *r;
2099         
2100         if( !a )
2101         {
2102                 v1 = 0;
2103         }
2104         else
2105         {
2106                 switch( a->type )
2107                 {
2108                 case AST_EXPR_integer:
2109                         if( a->u.i == 0 )
2110                                 v1 = 0;
2111                         break;
2112                         
2113                 case AST_EXPR_string:
2114                         if( a->u.s == 0 )
2115                                 v1 = 0;
2116                         else
2117                         {
2118                                 if( a->u.s[0] == 0 )
2119                                         v1 = 0;
2120                                 else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
2121                                         v1 = 0;
2122                         }
2123                         break;
2124                         
2125                 case AST_EXPR_numeric_string:
2126                         if( a->u.s == 0 )
2127                                 v1 = 0;
2128                         else
2129                         {
2130                                 if( a->u.s[0] == 0 )
2131                                         v1 = 0;
2132                                 else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
2133                                         v1 = 0;
2134                         }
2135                         break;
2136                 }
2137         }
2138         
2139         r = make_integer (!v1);
2140         free_value (a);
2141         return r;
2142 }
2143
2144 static int
2145 chk_times (quad_t a, quad_t b, quad_t r)
2146 {
2147         /* special case: first operand is 0, no overflow possible */
2148         if (a == 0)
2149                 return 0;
2150         /* cerify that result of division matches second operand */
2151         if (r / a != b)
2152                 return 1;
2153         return 0;
2154 }
2155
2156 static struct val *
2157 op_times (struct val *a, struct val *b)
2158 {
2159         struct val *r;
2160
2161         if (!to_integer (a) || !to_integer (b)) {
2162                 free_value(a);
2163                 free_value(b);
2164                 ast_log(LOG_WARNING, "non-numeric argument\n");
2165                 return(make_integer(0));
2166         }
2167
2168         r = make_integer (/*(quad_t)*/(a->u.i * b->u.i));
2169         if (chk_times (a->u.i, b->u.i, r->u.i)) {
2170                 ast_log(LOG_WARNING, "overflow\n");
2171         }
2172         free_value (a);
2173         free_value (b);
2174         return (r);
2175 }
2176
2177 static int
2178 chk_div (quad_t a, quad_t b)
2179 {
2180         /* div by zero has been taken care of before */
2181         /* only QUAD_MIN / -1 causes overflow */
2182         if (a == QUAD_MIN && b == -1)
2183                 return 1;
2184         /* everything else is OK */
2185         return 0;
2186 }
2187
2188 static struct val *
2189 op_div (struct val *a, struct val *b)
2190 {
2191         struct val *r;
2192
2193         if (!to_integer (a)) {
2194                 free_value(a);
2195                 free_value(b);
2196                 ast_log(LOG_WARNING, "non-numeric argument\n");
2197                 return make_integer(0);
2198         } else if (!to_integer (b)) {
2199                 free_value(a);
2200                 free_value(b);
2201                 ast_log(LOG_WARNING, "non-numeric argument\n");
2202                 return make_integer(INT_MAX);
2203         }
2204
2205         if (b->u.i == 0) {
2206                 ast_log(LOG_WARNING, "division by zero\n");             
2207                 free_value(a);
2208                 free_value(b);
2209                 return make_integer(INT_MAX);
2210         }
2211
2212         r = make_integer (/*(quad_t)*/(a->u.i / b->u.i));
2213         if (chk_div (a->u.i, b->u.i)) {
2214                 ast_log(LOG_WARNING, "overflow\n");
2215         }
2216         free_value (a);
2217         free_value (b);
2218         return r;
2219 }
2220         
2221 static struct val *
2222 op_rem (struct val *a, struct val *b)
2223 {
2224         struct val *r;
2225
2226         if (!to_integer (a) || !to_integer (b)) {
2227                 ast_log(LOG_WARNING, "non-numeric argument\n");
2228                 free_value(a);
2229                 free_value(b);
2230                 return make_integer(0);
2231         }
2232
2233         if (b->u.i == 0) {
2234                 ast_log(LOG_WARNING, "div by zero\n");
2235                 free_value(a);
2236                 return(b);
2237         }
2238
2239         r = make_integer (/*(quad_t)*/(a->u.i % b->u.i));
2240         /* chk_rem necessary ??? */
2241         free_value (a);
2242         free_value (b);
2243         return r;
2244 }
2245         
2246
2247 static struct val *
2248 op_colon (struct val *a, struct val *b)
2249 {
2250         regex_t rp;
2251         regmatch_t rm[2];
2252         char errbuf[256];
2253         int eval;
2254         struct val *v;
2255
2256         /* coerce to both arguments to strings */
2257         to_string(a);
2258         to_string(b);
2259         /* strip double quotes from both -- they'll screw up the pattern, and the search string starting at ^ */
2260         strip_quotes(a);
2261         strip_quotes(b);
2262         /* compile regular expression */
2263         if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
2264                 regerror (eval, &rp, errbuf, sizeof(errbuf));
2265                 ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
2266                 free_value(a);
2267                 free_value(b);
2268                 return make_str("");            
2269         }
2270
2271         /* compare string against pattern */
2272         /* remember that patterns are anchored to the beginning of the line */
2273         if (regexec(&rp, a->u.s, (size_t)2, rm, 0) == 0 && rm[0].rm_so == 0) {
2274                 if (rm[1].rm_so >= 0) {
2275                         *(a->u.s + rm[1].rm_eo) = '\0';
2276                         v = make_str (a->u.s + rm[1].rm_so);
2277
2278                 } else {
2279                         v = make_integer ((quad_t)(rm[0].rm_eo - rm[0].rm_so));
2280                 }
2281         } else {
2282                 if (rp.re_nsub == 0) {
2283                         v = make_integer ((quad_t)0);
2284                 } else {
2285                         v = make_str ("");
2286                 }
2287         }
2288
2289         /* free arguments and pattern buffer */
2290         free_value (a);
2291         free_value (b);
2292         regfree (&rp);
2293
2294         return v;
2295 }
2296         
2297
2298 static struct val *
2299 op_eqtilde (struct val *a, struct val *b)
2300 {
2301         regex_t rp;
2302         regmatch_t rm[2];
2303         char errbuf[256];
2304         int eval;
2305         struct val *v;
2306
2307         /* coerce to both arguments to strings */
2308         to_string(a);
2309         to_string(b);
2310         /* strip double quotes from both -- they'll screw up the pattern, and the search string starting at ^ */
2311         strip_quotes(a);
2312         strip_quotes(b);
2313         /* compile regular expression */
2314         if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
2315                 regerror (eval, &rp, errbuf, sizeof(errbuf));
2316                 ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
2317                 free_value(a);
2318                 free_value(b);
2319                 return make_str("");            
2320         }
2321
2322         /* compare string against pattern */
2323         /* remember that patterns are anchored to the beginning of the line */
2324         if (regexec(&rp, a->u.s, (size_t)2, rm, 0) == 0 ) {
2325                 if (rm[1].rm_so >= 0) {
2326                         *(a->u.s + rm[1].rm_eo) = '\0';
2327                         v = make_str (a->u.s + rm[1].rm_so);
2328
2329                 } else {
2330                         v = make_integer ((quad_t)(rm[0].rm_eo - rm[0].rm_so));
2331                 }
2332         } else {
2333                 if (rp.re_nsub == 0) {
2334                         v = make_integer ((quad_t)0);
2335                 } else {
2336                         v = make_str ("");
2337                 }
2338         }
2339
2340         /* free arguments and pattern buffer */
2341         free_value (a);
2342         free_value (b);
2343         regfree (&rp);
2344
2345         return v;
2346 }
2347