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