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