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