Sat Mar 24 23:26:00 2007

Asterisk developer's documentation


ast_expr2.c

Go to the documentation of this file.
00001 /* A Bison parser, made by GNU Bison 2.0.  */
00002 
00003 /* Skeleton parser for Yacc-like parsing with Bison,
00004    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
00005 
00006    This program is free software; you can redistribute it and/or modify
00007    it under the terms of the GNU General Public License as published by
00008    the Free Software Foundation; either version 2, or (at your option)
00009    any later version.
00010 
00011    This program is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014    GNU General Public License for more details.
00015 
00016    You should have received a copy of the GNU General Public License
00017    along with this program; if not, write to the Free Software
00018    Foundation, Inc., 59 Temple Place - Suite 330,
00019    Boston, MA 02111-1307, USA.  */
00020 
00021 /* As a special exception, when this file is copied by Bison into a
00022    Bison output file, you may use that output file without restriction.
00023    This special exception was added by the Free Software Foundation
00024    in version 1.24 of Bison.  */
00025 
00026 /* Written by Richard Stallman by simplifying the original so called
00027    ``semantic'' parser.  */
00028 
00029 /* All symbols defined below should begin with yy or YY, to avoid
00030    infringing on user name space.  This should be done even for local
00031    variables, as they might otherwise be expanded by user macros.
00032    There are some unavoidable exceptions within include files to
00033    define necessary library symbols; they are noted "INFRINGES ON
00034    USER NAME SPACE" below.  */
00035 
00036 /* Identify Bison output.  */
00037 #define YYBISON 1
00038 
00039 /* Skeleton name.  */
00040 #define YYSKELETON_NAME "yacc.c"
00041 
00042 /* Pure parsers.  */
00043 #define YYPURE 1
00044 
00045 /* Using locations.  */
00046 #define YYLSP_NEEDED 1
00047 
00048 /* Substitute the variable and function names.  */
00049 #define yyparse ast_yyparse
00050 #define yylex   ast_yylex
00051 #define yyerror ast_yyerror
00052 #define yylval  ast_yylval
00053 #define yychar  ast_yychar
00054 #define yydebug ast_yydebug
00055 #define yynerrs ast_yynerrs
00056 #define yylloc ast_yylloc
00057 
00058 /* Tokens.  */
00059 #ifndef YYTOKENTYPE
00060 # define YYTOKENTYPE
00061    /* Put the tokens into the symbol table, so that GDB and other debuggers
00062       know about them.  */
00063    enum yytokentype {
00064      TOK_COLONCOLON = 258,
00065      TOK_COND = 259,
00066      TOK_OR = 260,
00067      TOK_AND = 261,
00068      TOK_NE = 262,
00069      TOK_LE = 263,
00070      TOK_GE = 264,
00071      TOK_LT = 265,
00072      TOK_GT = 266,
00073      TOK_EQ = 267,
00074      TOK_MINUS = 268,
00075      TOK_PLUS = 269,
00076      TOK_MOD = 270,
00077      TOK_DIV = 271,
00078      TOK_MULT = 272,
00079      TOK_COMPL = 273,
00080      TOK_EQTILDE = 274,
00081      TOK_COLON = 275,
00082      TOK_LP = 276,
00083      TOK_RP = 277,
00084      TOKEN = 278
00085    };
00086 #endif
00087 #define TOK_COLONCOLON 258
00088 #define TOK_COND 259
00089 #define TOK_OR 260
00090 #define TOK_AND 261
00091 #define TOK_NE 262
00092 #define TOK_LE 263
00093 #define TOK_GE 264
00094 #define TOK_LT 265
00095 #define TOK_GT 266
00096 #define TOK_EQ 267
00097 #define TOK_MINUS 268
00098 #define TOK_PLUS 269
00099 #define TOK_MOD 270
00100 #define TOK_DIV 271
00101 #define TOK_MULT 272
00102 #define TOK_COMPL 273
00103 #define TOK_EQTILDE 274
00104 #define TOK_COLON 275
00105 #define TOK_LP 276
00106 #define TOK_RP 277
00107 #define TOKEN 278
00108 
00109 
00110 
00111 
00112 /* Copy the first part of user declarations.  */
00113 #line 1 "ast_expr2.y"
00114 
00115 /* Written by Pace Willisson (pace@blitz.com) 
00116  * and placed in the public domain.
00117  *
00118  * Largely rewritten by J.T. Conklin (jtc@wimsey.com)
00119  *
00120  * And then overhauled twice by Steve Murphy (murf@e-tools.com)
00121  * to add double-quoted strings, allow mult. spaces, improve
00122  * error messages, and then to fold in a flex scanner for the 
00123  * yylex operation.
00124  *
00125  * $FreeBSD: src/bin/expr/expr.y,v 1.16 2000/07/22 10:59:36 se Exp $
00126  */
00127 
00128 #include <sys/types.h>
00129 #include <stdio.h>
00130 #include <stdlib.h>
00131 #include <string.h>
00132 #include <locale.h>
00133 #include <ctype.h>
00134 #if !defined(SOLARIS) && !defined(__CYGWIN__)
00135 #include <err.h>
00136 #else
00137 #define quad_t int64_t
00138 #endif
00139 #include <errno.h>
00140 #include <regex.h>
00141 #include <limits.h>
00142 #include <asterisk/ast_expr.h>
00143 #include <asterisk/logger.h>
00144 
00145 #if defined(LONG_LONG_MIN) && !defined(QUAD_MIN)
00146 #define QUAD_MIN LONG_LONG_MIN
00147 #endif
00148 #if defined(LONG_LONG_MAX) && !defined(QUAD_MAX)
00149 #define QUAD_MAX LONG_LONG_MAX
00150 #endif
00151 
00152 #  if ! defined(QUAD_MIN)
00153 #   define QUAD_MIN     (-0x7fffffffffffffffLL-1)
00154 #  endif
00155 #  if ! defined(QUAD_MAX)
00156 #   define QUAD_MAX     (0x7fffffffffffffffLL)
00157 #  endif
00158 
00159 #define YYPARSE_PARAM parseio
00160 #define YYLEX_PARAM ((struct parse_io *)parseio)->scanner
00161 #define YYERROR_VERBOSE 1
00162 
00163 enum valtype {
00164    AST_EXPR_integer, AST_EXPR_numeric_string, AST_EXPR_string
00165 } ;
00166 
00167 #ifdef STANDALONE
00168 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...) __attribute__ ((format (printf,5,6)));
00169 #endif
00170 
00171 struct val {
00172    enum valtype type;
00173    union {
00174       char *s;
00175       quad_t i;
00176    } u;
00177 } ;
00178 
00179 typedef void *yyscan_t;
00180 
00181 struct parse_io
00182 {
00183    char *string;
00184    struct val *val;
00185    yyscan_t scanner;
00186 };
00187  
00188 static int     chk_div __P((quad_t, quad_t));
00189 static int     chk_minus __P((quad_t, quad_t, quad_t));
00190 static int     chk_plus __P((quad_t, quad_t, quad_t));
00191 static int     chk_times __P((quad_t, quad_t, quad_t));
00192 static void    free_value __P((struct val *));
00193 static int     is_zero_or_null __P((struct val *));
00194 static int     isstring __P((struct val *));
00195 static struct val *make_integer __P((quad_t));
00196 static struct val *make_str __P((const char *));
00197 static struct val *op_and __P((struct val *, struct val *));
00198 static struct val *op_colon __P((struct val *, struct val *));
00199 static struct val *op_eqtilde __P((struct val *, struct val *));
00200 static struct val *op_div __P((struct val *, struct val *));
00201 static struct val *op_eq __P((struct val *, struct val *));
00202 static struct val *op_ge __P((struct val *, struct val *));
00203 static struct val *op_gt __P((struct val *, struct val *));
00204 static struct val *op_le __P((struct val *, struct val *));
00205 static struct val *op_lt __P((struct val *, struct val *));
00206 static struct val *op_cond __P((struct val *, struct val *, struct val *));
00207 static struct val *op_minus __P((struct val *, struct val *));
00208 static struct val *op_negate __P((struct val *));
00209 static struct val *op_compl __P((struct val *));
00210 static struct val *op_ne __P((struct val *, struct val *));
00211 static struct val *op_or __P((struct val *, struct val *));
00212 static struct val *op_plus __P((struct val *, struct val *));
00213 static struct val *op_rem __P((struct val *, struct val *));
00214 static struct val *op_times __P((struct val *, struct val *));
00215 static quad_t     to_integer __P((struct val *));
00216 static void    to_string __P((struct val *));
00217 
00218 /* uh, if I want to predeclare yylex with a YYLTYPE, I have to predeclare the yyltype... sigh */
00219 typedef struct yyltype
00220 {
00221   int first_line;
00222   int first_column;
00223 
00224   int last_line;
00225   int last_column;
00226 } yyltype;
00227 
00228 # define YYLTYPE yyltype
00229 # define YYLTYPE_IS_TRIVIAL 1
00230 
00231 /* we will get warning about no prototype for yylex! But we can't
00232    define it here, we have no definition yet for YYSTYPE. */
00233 
00234 int      ast_yyerror(const char *,YYLTYPE *, struct parse_io *);
00235  
00236 /* I wanted to add args to the yyerror routine, so I could print out
00237    some useful info about the error. Not as easy as it looks, but it
00238    is possible. */
00239 #define ast_yyerror(x) ast_yyerror(x,&yyloc,parseio)
00240 #define DESTROY(x) { \
00241 if ((x)->type == AST_EXPR_numeric_string || (x)->type == AST_EXPR_string) \
00242    free((x)->u.s); \
00243    (x)->u.s = 0; \
00244    free(x); \
00245 }
00246 
00247 
00248 /* Enabling traces.  */
00249 #ifndef YYDEBUG
00250 # define YYDEBUG 0
00251 #endif
00252 
00253 /* Enabling verbose error messages.  */
00254 #ifdef YYERROR_VERBOSE
00255 # undef YYERROR_VERBOSE
00256 # define YYERROR_VERBOSE 1
00257 #else
00258 # define YYERROR_VERBOSE 0
00259 #endif
00260 
00261 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
00262 #line 142 "ast_expr2.y"
00263 typedef union YYSTYPE {
00264    struct val *val;
00265 } YYSTYPE;
00266 /* Line 190 of yacc.c.  */
00267 #line 268 "ast_expr2.c"
00268 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00269 # define YYSTYPE_IS_DECLARED 1
00270 # define YYSTYPE_IS_TRIVIAL 1
00271 #endif
00272 
00273 #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
00274 typedef struct YYLTYPE
00275 {
00276   int first_line;
00277   int first_column;
00278   int last_line;
00279   int last_column;
00280 } YYLTYPE;
00281 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
00282 # define YYLTYPE_IS_DECLARED 1
00283 # define YYLTYPE_IS_TRIVIAL 1
00284 #endif
00285 
00286 
00287 /* Copy the second part of user declarations.  */
00288 #line 146 "ast_expr2.y"
00289 
00290 extern int     ast_yylex __P((YYSTYPE *, YYLTYPE *, yyscan_t));
00291 
00292 
00293 /* Line 213 of yacc.c.  */
00294 #line 295 "ast_expr2.c"
00295 
00296 #if ! defined (yyoverflow) || YYERROR_VERBOSE
00297 
00298 # ifndef YYFREE
00299 #  define YYFREE free
00300 # endif
00301 # ifndef YYMALLOC
00302 #  define YYMALLOC malloc
00303 # endif
00304 
00305 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00306 
00307 # ifdef YYSTACK_USE_ALLOCA
00308 #  if YYSTACK_USE_ALLOCA
00309 #   ifdef __GNUC__
00310 #    define YYSTACK_ALLOC __builtin_alloca
00311 #   else
00312 #    define YYSTACK_ALLOC alloca
00313 #   endif
00314 #  endif
00315 # endif
00316 
00317 # ifdef YYSTACK_ALLOC
00318    /* Pacify GCC's `empty if-body' warning. */
00319 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
00320 # else
00321 #  if defined (__STDC__) || defined (__cplusplus)
00322 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00323 #   define YYSIZE_T size_t
00324 #  endif
00325 #  define YYSTACK_ALLOC YYMALLOC
00326 #  define YYSTACK_FREE YYFREE
00327 # endif
00328 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
00329 
00330 
00331 #if (! defined (yyoverflow) \
00332      && (! defined (__cplusplus) \
00333     || (defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
00334              && defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
00335 
00336 /* A type that is properly aligned for any stack member.  */
00337 union yyalloc
00338 {
00339   short int yyss;
00340   YYSTYPE yyvs;
00341     YYLTYPE yyls;
00342 };
00343 
00344 /* The size of the maximum gap between one aligned stack and the next.  */
00345 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00346 
00347 /* The size of an array large to enough to hold all stacks, each with
00348    N elements.  */
00349 # define YYSTACK_BYTES(N) \
00350      ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE))  \
00351       + 2 * YYSTACK_GAP_MAXIMUM)
00352 
00353 /* Copy COUNT objects from FROM to TO.  The source and destination do
00354    not overlap.  */
00355 # ifndef YYCOPY
00356 #  if defined (__GNUC__) && 1 < __GNUC__
00357 #   define YYCOPY(To, From, Count) \
00358       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00359 #  else
00360 #   define YYCOPY(To, From, Count)     \
00361       do             \
00362    {              \
00363      register YYSIZE_T yyi;      \
00364      for (yyi = 0; yyi < (Count); yyi++)  \
00365        (To)[yyi] = (From)[yyi];     \
00366    }              \
00367       while (0)
00368 #  endif
00369 # endif
00370 
00371 /* Relocate STACK from its old location to the new one.  The
00372    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00373    elements in the stack, and YYPTR gives the new location of the
00374    stack.  Advance YYPTR to a properly aligned location for the next
00375    stack.  */
00376 # define YYSTACK_RELOCATE(Stack)             \
00377     do                           \
00378       {                          \
00379    YYSIZE_T yynewbytes;                \
00380    YYCOPY (&yyptr->Stack, Stack, yysize);          \
00381    Stack = &yyptr->Stack;                 \
00382    yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00383    yyptr += yynewbytes / sizeof (*yyptr);          \
00384       }                          \
00385     while (0)
00386 
00387 #endif
00388 
00389 #if defined (__STDC__) || defined (__cplusplus)
00390    typedef signed char yysigned_char;
00391 #else
00392    typedef short int yysigned_char;
00393 #endif
00394 
00395 /* YYFINAL -- State number of the termination state. */
00396 #define YYFINAL  10
00397 /* YYLAST -- Last index in YYTABLE.  */
00398 #define YYLAST   140
00399 
00400 /* YYNTOKENS -- Number of terminals. */
00401 #define YYNTOKENS  24
00402 /* YYNNTS -- Number of nonterminals. */
00403 #define YYNNTS  3
00404 /* YYNRULES -- Number of rules. */
00405 #define YYNRULES  22
00406 /* YYNRULES -- Number of states. */
00407 #define YYNSTATES  46
00408 
00409 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00410 #define YYUNDEFTOK  2
00411 #define YYMAXUTOK   278
00412 
00413 #define YYTRANSLATE(YYX)                  \
00414   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00415 
00416 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00417 static const unsigned char yytranslate[] =
00418 {
00419        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00420        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00421        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00422        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00423        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00424        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00425        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00426        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00427        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00428        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00429        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00430        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00431        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00432        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00433        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00434        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00435        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00436        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00437        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00438        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00439        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00440        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00441        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00442        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00443        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00444        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00445        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00446       15,    16,    17,    18,    19,    20,    21,    22,    23
00447 };
00448 
00449 #if YYDEBUG
00450 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00451    YYRHS.  */
00452 static const unsigned char yyprhs[] =
00453 {
00454        0,     0,     3,     5,     7,    11,    15,    19,    23,    27,
00455       31,    35,    39,    43,    47,    51,    54,    57,    61,    65,
00456       69,    73,    77
00457 };
00458 
00459 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
00460 static const yysigned_char yyrhs[] =
00461 {
00462       25,     0,    -1,    26,    -1,    23,    -1,    21,    26,    22,
00463       -1,    26,     5,    26,    -1,    26,     6,    26,    -1,    26,
00464       12,    26,    -1,    26,    11,    26,    -1,    26,    10,    26,
00465       -1,    26,     9,    26,    -1,    26,     8,    26,    -1,    26,
00466        7,    26,    -1,    26,    14,    26,    -1,    26,    13,    26,
00467       -1,    13,    26,    -1,    18,    26,    -1,    26,    17,    26,
00468       -1,    26,    16,    26,    -1,    26,    15,    26,    -1,    26,
00469       20,    26,    -1,    26,    19,    26,    -1,    26,     4,    26,
00470        3,    26,    -1
00471 };
00472 
00473 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00474 static const unsigned char yyrline[] =
00475 {
00476        0,   165,   165,   175,   176,   180,   184,   188,   192,   196,
00477      200,   204,   208,   212,   216,   220,   224,   228,   232,   236,
00478      240,   244,   248
00479 };
00480 #endif
00481 
00482 #if YYDEBUG || YYERROR_VERBOSE
00483 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00484    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
00485 static const char *const yytname[] =
00486 {
00487   "$end", "error", "$undefined", "TOK_COLONCOLON", "TOK_COND", "TOK_OR",
00488   "TOK_AND", "TOK_NE", "TOK_LE", "TOK_GE", "TOK_LT", "TOK_GT", "TOK_EQ",
00489   "TOK_MINUS", "TOK_PLUS", "TOK_MOD", "TOK_DIV", "TOK_MULT", "TOK_COMPL",
00490   "TOK_EQTILDE", "TOK_COLON", "TOK_LP", "TOK_RP", "TOKEN", "$accept",
00491   "start", "expr", 0
00492 };
00493 #endif
00494 
00495 # ifdef YYPRINT
00496 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00497    token YYLEX-NUM.  */
00498 static const unsigned short int yytoknum[] =
00499 {
00500        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00501      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
00502      275,   276,   277,   278
00503 };
00504 # endif
00505 
00506 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00507 static const unsigned char yyr1[] =
00508 {
00509        0,    24,    25,    26,    26,    26,    26,    26,    26,    26,
00510       26,    26,    26,    26,    26,    26,    26,    26,    26,    26,
00511       26,    26,    26
00512 };
00513 
00514 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00515 static const unsigned char yyr2[] =
00516 {
00517        0,     2,     1,     1,     3,     3,     3,     3,     3,     3,
00518        3,     3,     3,     3,     3,     2,     2,     3,     3,     3,
00519        3,     3,     5
00520 };
00521 
00522 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00523    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00524    means the default is an error.  */
00525 static const unsigned char yydefact[] =
00526 {
00527        0,     0,     0,     0,     3,     0,     2,    15,    16,     0,
00528        1,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00529        0,     0,     0,     0,     0,     0,     0,     4,     0,     5,
00530        6,    12,    11,    10,     9,     8,     7,    14,    13,    19,
00531       18,    17,    21,    20,     0,    22
00532 };
00533 
00534 /* YYDEFGOTO[NTERM-NUM]. */
00535 static const yysigned_char yydefgoto[] =
00536 {
00537       -1,     5,     6
00538 };
00539 
00540 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00541    STATE-NUM.  */
00542 #define YYPACT_NINF -13
00543 static const yysigned_char yypact[] =
00544 {
00545      109,   109,   109,   109,   -13,     6,    59,   106,   106,    22,
00546      -13,   109,   109,   109,   109,   109,   109,   109,   109,   109,
00547      109,   109,   109,   109,   109,   109,   109,   -13,    42,    90,
00548      104,   120,   120,   120,   120,   120,   120,   -12,   -12,   106,
00549      106,   106,   -13,   -13,   109,    75
00550 };
00551 
00552 /* YYPGOTO[NTERM-NUM].  */
00553 static const yysigned_char yypgoto[] =
00554 {
00555      -13,   -13,    -1
00556 };
00557 
00558 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00559    positive, shift that token.  If negative, reduce the rule which
00560    number is the opposite.  If zero, do what YYDEFACT says.
00561    If YYTABLE_NINF, syntax error.  */
00562 #define YYTABLE_NINF -1
00563 static const unsigned char yytable[] =
00564 {
00565        7,     8,     9,    22,    23,    24,    10,    25,    26,     0,
00566       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
00567       38,    39,    40,    41,    42,    43,    11,    12,    13,    14,
00568       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00569        0,    25,    26,    45,    27,    44,    11,    12,    13,    14,
00570       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00571        0,    25,    26,    11,    12,    13,    14,    15,    16,    17,
00572       18,    19,    20,    21,    22,    23,    24,     0,    25,    26,
00573       12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
00574       22,    23,    24,     0,    25,    26,    13,    14,    15,    16,
00575       17,    18,    19,    20,    21,    22,    23,    24,     0,    25,
00576       26,    14,    15,    16,    17,    18,    19,    20,    21,    22,
00577       23,    24,     1,    25,    26,    25,    26,     2,     0,     0,
00578        3,     0,     4,    20,    21,    22,    23,    24,     0,    25,
00579       26
00580 };
00581 
00582 static const yysigned_char yycheck[] =
00583 {
00584        1,     2,     3,    15,    16,    17,     0,    19,    20,    -1,
00585       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
00586       21,    22,    23,    24,    25,    26,     4,     5,     6,     7,
00587        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
00588       -1,    19,    20,    44,    22,     3,     4,     5,     6,     7,
00589        8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
00590       -1,    19,    20,     4,     5,     6,     7,     8,     9,    10,
00591       11,    12,    13,    14,    15,    16,    17,    -1,    19,    20,
00592        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00593       15,    16,    17,    -1,    19,    20,     6,     7,     8,     9,
00594       10,    11,    12,    13,    14,    15,    16,    17,    -1,    19,
00595       20,     7,     8,     9,    10,    11,    12,    13,    14,    15,
00596       16,    17,    13,    19,    20,    19,    20,    18,    -1,    -1,
00597       21,    -1,    23,    13,    14,    15,    16,    17,    -1,    19,
00598       20
00599 };
00600 
00601 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00602    symbol of state STATE-NUM.  */
00603 static const unsigned char yystos[] =
00604 {
00605        0,    13,    18,    21,    23,    25,    26,    26,    26,    26,
00606        0,     4,     5,     6,     7,     8,     9,    10,    11,    12,
00607       13,    14,    15,    16,    17,    19,    20,    22,    26,    26,
00608       26,    26,    26,    26,    26,    26,    26,    26,    26,    26,
00609       26,    26,    26,    26,     3,    26
00610 };
00611 
00612 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
00613 # define YYSIZE_T __SIZE_TYPE__
00614 #endif
00615 #if ! defined (YYSIZE_T) && defined (size_t)
00616 # define YYSIZE_T size_t
00617 #endif
00618 #if ! defined (YYSIZE_T)
00619 # if defined (__STDC__) || defined (__cplusplus)
00620 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00621 #  define YYSIZE_T size_t
00622 # endif
00623 #endif
00624 #if ! defined (YYSIZE_T)
00625 # define YYSIZE_T unsigned int
00626 #endif
00627 
00628 #define yyerrok      (yyerrstatus = 0)
00629 #define yyclearin (yychar = YYEMPTY)
00630 #define YYEMPTY      (-2)
00631 #define YYEOF     0
00632 
00633 #define YYACCEPT  goto yyacceptlab
00634 #define YYABORT      goto yyabortlab
00635 #define YYERROR      goto yyerrorlab
00636 
00637 
00638 /* Like YYERROR except do call yyerror.  This remains here temporarily
00639    to ease the transition to the new meaning of YYERROR, for GCC.
00640    Once GCC version 2 has supplanted version 1, this can go.  */
00641 
00642 #define YYFAIL    goto yyerrlab
00643 
00644 #define YYRECOVERING()  (!!yyerrstatus)
00645 
00646 #define YYBACKUP(Token, Value)               \
00647 do                      \
00648   if (yychar == YYEMPTY && yylen == 1)          \
00649     {                      \
00650       yychar = (Token);                \
00651       yylval = (Value);                \
00652       yytoken = YYTRANSLATE (yychar);           \
00653       YYPOPSTACK;                \
00654       goto yybackup;                \
00655     }                      \
00656   else                        \
00657     {                         \
00658       yyerror ("syntax error: cannot back up");\
00659       YYERROR;                   \
00660     }                      \
00661 while (0)
00662 
00663 
00664 #define YYTERROR  1
00665 #define YYERRCODE 256
00666 
00667 
00668 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
00669    If N is 0, then set CURRENT to the empty location which ends
00670    the previous symbol: RHS[0] (always defined).  */
00671 
00672 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00673 #ifndef YYLLOC_DEFAULT
00674 # define YYLLOC_DEFAULT(Current, Rhs, N)           \
00675     do                           \
00676       if (N)                        \
00677    {                       \
00678      (Current).first_line   = YYRHSLOC (Rhs, 1).first_line; \
00679      (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
00680      (Current).last_line    = YYRHSLOC (Rhs, N).last_line;     \
00681      (Current).last_column  = YYRHSLOC (Rhs, N).last_column;   \
00682    }                       \
00683       else                       \
00684    {                       \
00685      (Current).first_line   = (Current).last_line   =    \
00686        YYRHSLOC (Rhs, 0).last_line;          \
00687      (Current).first_column = (Current).last_column =    \
00688        YYRHSLOC (Rhs, 0).last_column;           \
00689    }                       \
00690     while (0)
00691 #endif
00692 
00693 
00694 /* YY_LOCATION_PRINT -- Print the location on the stream.
00695    This macro was not mandated originally: define only if we know
00696    we won't break user code: when these are the locations we know.  */
00697 
00698 #ifndef YY_LOCATION_PRINT
00699 # if YYLTYPE_IS_TRIVIAL
00700 #  define YY_LOCATION_PRINT(File, Loc)       \
00701      fprintf (File, "%d.%d-%d.%d",        \
00702               (Loc).first_line, (Loc).first_column,   \
00703               (Loc).last_line,  (Loc).last_column)
00704 # else
00705 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00706 # endif
00707 #endif
00708 
00709 
00710 /* YYLEX -- calling `yylex' with the right arguments.  */
00711 
00712 #ifdef YYLEX_PARAM
00713 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
00714 #else
00715 # define YYLEX yylex (&yylval, &yylloc)
00716 #endif
00717 
00718 /* Enable debugging if requested.  */
00719 #if YYDEBUG
00720 
00721 # ifndef YYFPRINTF
00722 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
00723 #  define YYFPRINTF fprintf
00724 # endif
00725 
00726 # define YYDPRINTF(Args)         \
00727 do {                 \
00728   if (yydebug)             \
00729     YYFPRINTF Args;           \
00730 } while (0)
00731 
00732 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)      \
00733 do {                       \
00734   if (yydebug)                   \
00735     {                      \
00736       YYFPRINTF (stderr, "%s ", Title);            \
00737       yysymprint (stderr,              \
00738                   Type, Value, Location); \
00739       YYFPRINTF (stderr, "\n");              \
00740     }                      \
00741 } while (0)
00742 
00743 /*------------------------------------------------------------------.
00744 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
00745 | TOP (included).                                                   |
00746 `------------------------------------------------------------------*/
00747 
00748 #if defined (__STDC__) || defined (__cplusplus)
00749 static void
00750 yy_stack_print (short int *bottom, short int *top)
00751 #else
00752 static void
00753 yy_stack_print (bottom, top)
00754     short int *bottom;
00755     short int *top;
00756 #endif
00757 {
00758   YYFPRINTF (stderr, "Stack now");
00759   for (/* Nothing. */; bottom <= top; ++bottom)
00760     YYFPRINTF (stderr, " %d", *bottom);
00761   YYFPRINTF (stderr, "\n");
00762 }
00763 
00764 # define YY_STACK_PRINT(Bottom, Top)            \
00765 do {                       \
00766   if (yydebug)                   \
00767     yy_stack_print ((Bottom), (Top));           \
00768 } while (0)
00769 
00770 
00771 /*------------------------------------------------.
00772 | Report that the YYRULE is going to be reduced.  |
00773 `------------------------------------------------*/
00774 
00775 #if defined (__STDC__) || defined (__cplusplus)
00776 static void
00777 yy_reduce_print (int yyrule)
00778 #else
00779 static void
00780 yy_reduce_print (yyrule)
00781     int yyrule;
00782 #endif
00783 {
00784   int yyi;
00785   unsigned int yylno = yyrline[yyrule];
00786   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
00787              yyrule - 1, yylno);
00788   /* Print the symbols being reduced, and their result.  */
00789   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
00790     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
00791   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
00792 }
00793 
00794 # define YY_REDUCE_PRINT(Rule)      \
00795 do {              \
00796   if (yydebug)          \
00797     yy_reduce_print (Rule);      \
00798 } while (0)
00799 
00800 /* Nonzero means print parse trace.  It is left uninitialized so that
00801    multiple parsers can coexist.  */
00802 int yydebug;
00803 #else /* !YYDEBUG */
00804 # define YYDPRINTF(Args)
00805 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
00806 # define YY_STACK_PRINT(Bottom, Top)
00807 # define YY_REDUCE_PRINT(Rule)
00808 #endif /* !YYDEBUG */
00809 
00810 
00811 /* YYINITDEPTH -- initial size of the parser's stacks.  */
00812 #ifndef  YYINITDEPTH
00813 # define YYINITDEPTH 200
00814 #endif
00815 
00816 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
00817    if the built-in stack extension method is used).
00818 
00819    Do not make this value too large; the results are undefined if
00820    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
00821    evaluated with infinite-precision integer arithmetic.  */
00822 
00823 #ifndef YYMAXDEPTH
00824 # define YYMAXDEPTH 10000
00825 #endif
00826 
00827 
00828 
00829 #if YYERROR_VERBOSE
00830 
00831 # ifndef yystrlen
00832 #  if defined (__GLIBC__) && defined (_STRING_H)
00833 #   define yystrlen strlen
00834 #  else
00835 /* Return the length of YYSTR.  */
00836 static YYSIZE_T
00837 #   if defined (__STDC__) || defined (__cplusplus)
00838 yystrlen (const char *yystr)
00839 #   else
00840 yystrlen (yystr)
00841      const char *yystr;
00842 #   endif
00843 {
00844   register const char *yys = yystr;
00845 
00846   while (*yys++ != '\0')
00847     continue;
00848 
00849   return yys - yystr - 1;
00850 }
00851 #  endif
00852 # endif
00853 
00854 # ifndef yystpcpy
00855 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
00856 #   define yystpcpy stpcpy
00857 #  else
00858 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
00859    YYDEST.  */
00860 static char *
00861 #   if defined (__STDC__) || defined (__cplusplus)
00862 yystpcpy (char *yydest, const char *yysrc)
00863 #   else
00864 yystpcpy (yydest, yysrc)
00865      char *yydest;
00866      const char *yysrc;
00867 #   endif
00868 {
00869   register char *yyd = yydest;
00870   register const char *yys = yysrc;
00871 
00872   while ((*yyd++ = *yys++) != '\0')
00873     continue;
00874 
00875   return yyd - 1;
00876 }
00877 #  endif
00878 # endif
00879 
00880 #endif /* !YYERROR_VERBOSE */
00881 
00882 
00883 
00884 #if YYDEBUG
00885 /*--------------------------------.
00886 | Print this symbol on YYOUTPUT.  |
00887 `--------------------------------*/
00888 
00889 #if defined (__STDC__) || defined (__cplusplus)
00890 static void
00891 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
00892 #else
00893 static void
00894 yysymprint (yyoutput, yytype, yyvaluep, yylocationp)
00895     FILE *yyoutput;
00896     int yytype;
00897     YYSTYPE *yyvaluep;
00898     YYLTYPE *yylocationp;
00899 #endif
00900 {
00901   /* Pacify ``unused variable'' warnings.  */
00902   (void) yyvaluep;
00903   (void) yylocationp;
00904 
00905   if (yytype < YYNTOKENS)
00906     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
00907   else
00908     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
00909 
00910   YY_LOCATION_PRINT (yyoutput, *yylocationp);
00911   fprintf (yyoutput, ": ");
00912 
00913 # ifdef YYPRINT
00914   if (yytype < YYNTOKENS)
00915     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00916 # endif
00917   switch (yytype)
00918     {
00919       default:
00920         break;
00921     }
00922   YYFPRINTF (yyoutput, ")");
00923 }
00924 
00925 #endif /* ! YYDEBUG */
00926 /*-----------------------------------------------.
00927 | Release the memory associated to this symbol.  |
00928 `-----------------------------------------------*/
00929 
00930 #if defined (__STDC__) || defined (__cplusplus)
00931 static void
00932 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
00933 #else
00934 static void
00935 yydestruct (yymsg, yytype, yyvaluep, yylocationp)
00936     const char *yymsg;
00937     int yytype;
00938     YYSTYPE *yyvaluep;
00939     YYLTYPE *yylocationp;
00940 #endif
00941 {
00942   /* Pacify ``unused variable'' warnings.  */
00943   (void) yyvaluep;
00944   (void) yylocationp;
00945 
00946   if (!yymsg)
00947     yymsg = "Deleting";
00948   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
00949 
00950   switch (yytype)
00951     {
00952 
00953       default:
00954         break;
00955     }
00956 }
00957 
00958 
00959 /* Prevent warnings from -Wmissing-prototypes.  */
00960 
00961 #ifdef YYPARSE_PARAM
00962 # if defined (__STDC__) || defined (__cplusplus)
00963 int yyparse (void *YYPARSE_PARAM);
00964 # else
00965 int yyparse ();
00966 # endif
00967 #else /* ! YYPARSE_PARAM */
00968 #if defined (__STDC__) || defined (__cplusplus)
00969 int yyparse (void);
00970 #else
00971 int yyparse ();
00972 #endif
00973 #endif /* ! YYPARSE_PARAM */
00974 
00975 
00976 
00977 
00978 
00979 
00980 /*----------.
00981 | yyparse.  |
00982 `----------*/
00983 
00984 #ifdef YYPARSE_PARAM
00985 # if defined (__STDC__) || defined (__cplusplus)
00986 int yyparse (void *YYPARSE_PARAM)
00987 # else
00988 int yyparse (YYPARSE_PARAM)
00989   void *YYPARSE_PARAM;
00990 # endif
00991 #else /* ! YYPARSE_PARAM */
00992 #if defined (__STDC__) || defined (__cplusplus)
00993 int
00994 yyparse (void)
00995 #else
00996 int
00997 yyparse ()
00998 
00999 #endif
01000 #endif
01001 {
01002   /* The look-ahead symbol.  */
01003 int yychar;
01004 
01005 /* The semantic value of the look-ahead symbol.  */
01006 YYSTYPE yylval;
01007 
01008 /* Number of syntax errors so far.  */
01009 int yynerrs;
01010 /* Location data for the look-ahead symbol.  */
01011 YYLTYPE yylloc;
01012 
01013   register int yystate;
01014   register int yyn;
01015   int yyresult;
01016   /* Number of tokens to shift before error messages enabled.  */
01017   int yyerrstatus;
01018   /* Look-ahead token as an internal (translated) token number.  */
01019   int yytoken = 0;
01020 
01021   /* Three stacks and their tools:
01022      `yyss': related to states,
01023      `yyvs': related to semantic values,
01024      `yyls': related to locations.
01025 
01026      Refer to the stacks thru separate pointers, to allow yyoverflow
01027      to reallocate them elsewhere.  */
01028 
01029   /* The state stack.  */
01030   short int yyssa[YYINITDEPTH];
01031   short int *yyss = yyssa;
01032   register short int *yyssp;
01033 
01034   /* The semantic value stack.  */
01035   YYSTYPE yyvsa[YYINITDEPTH];
01036   YYSTYPE *yyvs = yyvsa;
01037   register YYSTYPE *yyvsp;
01038 
01039   /* The location stack.  */
01040   YYLTYPE yylsa[YYINITDEPTH];
01041   YYLTYPE *yyls = yylsa;
01042   YYLTYPE *yylsp;
01043   /* The locations where the error started and ended. */
01044   YYLTYPE yyerror_range[2];
01045 
01046 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
01047 
01048   YYSIZE_T yystacksize = YYINITDEPTH;
01049 
01050   /* The variables used to return semantic value and location from the
01051      action routines.  */
01052   YYSTYPE yyval;
01053   YYLTYPE yyloc;
01054 
01055   /* When reducing, the number of symbols on the RHS of the reduced
01056      rule.  */
01057   int yylen;
01058 
01059   YYDPRINTF ((stderr, "Starting parse\n"));
01060 
01061   yystate = 0;
01062   yyerrstatus = 0;
01063   yynerrs = 0;
01064   yychar = YYEMPTY;     /* Cause a token to be read.  */
01065 
01066   /* Initialize stack pointers.
01067      Waste one element of value and location stack
01068      so that they stay on the same level as the state stack.
01069      The wasted elements are never initialized.  */
01070 
01071   yyssp = yyss;
01072   yyvsp = yyvs;
01073   yylsp = yyls;
01074 #if YYLTYPE_IS_TRIVIAL
01075   /* Initialize the default location before parsing starts.  */
01076   yylloc.first_line   = yylloc.last_line   = 1;
01077   yylloc.first_column = yylloc.last_column = 0;
01078 #endif
01079 
01080 
01081   yyvsp[0] = yylval;
01082     yylsp[0] = yylloc;
01083 
01084   goto yysetstate;
01085 
01086 /*------------------------------------------------------------.
01087 | yynewstate -- Push a new state, which is found in yystate.  |
01088 `------------------------------------------------------------*/
01089  yynewstate:
01090   /* In all cases, when you get here, the value and location stacks
01091      have just been pushed. so pushing a state here evens the stacks.
01092      */
01093   yyssp++;
01094 
01095  yysetstate:
01096   *yyssp = yystate;
01097 
01098   if (yyss + yystacksize - 1 <= yyssp)
01099     {
01100       /* Get the current used size of the three stacks, in elements.  */
01101       YYSIZE_T yysize = yyssp - yyss + 1;
01102 
01103 #ifdef yyoverflow
01104       {
01105    /* Give user a chance to reallocate the stack. Use copies of
01106       these so that the &'s don't force the real ones into
01107       memory.  */
01108    YYSTYPE *yyvs1 = yyvs;
01109    short int *yyss1 = yyss;
01110    YYLTYPE *yyls1 = yyls;
01111 
01112    /* Each stack pointer address is followed by the size of the
01113       data in use in that stack, in bytes.  This used to be a
01114       conditional around just the two extra args, but that might
01115       be undefined if yyoverflow is a macro.  */
01116    yyoverflow ("parser stack overflow",
01117           &yyss1, yysize * sizeof (*yyssp),
01118           &yyvs1, yysize * sizeof (*yyvsp),
01119           &yyls1, yysize * sizeof (*yylsp),
01120           &yystacksize);
01121    yyls = yyls1;
01122    yyss = yyss1;
01123    yyvs = yyvs1;
01124       }
01125 #else /* no yyoverflow */
01126 # ifndef YYSTACK_RELOCATE
01127       goto yyoverflowlab;
01128 # else
01129       /* Extend the stack our own way.  */
01130       if (YYMAXDEPTH <= yystacksize)
01131    goto yyoverflowlab;
01132       yystacksize *= 2;
01133       if (YYMAXDEPTH < yystacksize)
01134    yystacksize = YYMAXDEPTH;
01135 
01136       {
01137    short int *yyss1 = yyss;
01138    union yyalloc *yyptr =
01139      (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01140    if (! yyptr)
01141      goto yyoverflowlab;
01142    YYSTACK_RELOCATE (yyss);
01143    YYSTACK_RELOCATE (yyvs);
01144    YYSTACK_RELOCATE (yyls);
01145 #  undef YYSTACK_RELOCATE
01146    if (yyss1 != yyssa)
01147      YYSTACK_FREE (yyss1);
01148       }
01149 # endif
01150 #endif /* no yyoverflow */
01151 
01152       yyssp = yyss + yysize - 1;
01153       yyvsp = yyvs + yysize - 1;
01154       yylsp = yyls + yysize - 1;
01155 
01156       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01157         (unsigned long int) yystacksize));
01158 
01159       if (yyss + yystacksize - 1 <= yyssp)
01160    YYABORT;
01161     }
01162 
01163   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01164 
01165   goto yybackup;
01166 
01167 /*-----------.
01168 | yybackup.  |
01169 `-----------*/
01170 yybackup:
01171 
01172 /* Do appropriate processing given the current state.  */
01173 /* Read a look-ahead token if we need one and don't already have one.  */
01174 /* yyresume: */
01175 
01176   /* First try to decide what to do without reference to look-ahead token.  */
01177 
01178   yyn = yypact[yystate];
01179   if (yyn == YYPACT_NINF)
01180     goto yydefault;
01181 
01182   /* Not known => get a look-ahead token if don't already have one.  */
01183 
01184   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
01185   if (yychar == YYEMPTY)
01186     {
01187       YYDPRINTF ((stderr, "Reading a token: "));
01188       yychar = YYLEX;
01189     }
01190 
01191   if (yychar <= YYEOF)
01192     {
01193       yychar = yytoken = YYEOF;
01194       YYDPRINTF ((stderr, "Now at end of input.\n"));
01195     }
01196   else
01197     {
01198       yytoken = YYTRANSLATE (yychar);
01199       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01200     }
01201 
01202   /* If the proper action on seeing token YYTOKEN is to reduce or to
01203      detect an error, take that action.  */
01204   yyn += yytoken;
01205   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01206     goto yydefault;
01207   yyn = yytable[yyn];
01208   if (yyn <= 0)
01209     {
01210       if (yyn == 0 || yyn == YYTABLE_NINF)
01211    goto yyerrlab;
01212       yyn = -yyn;
01213       goto yyreduce;
01214     }
01215 
01216   if (yyn == YYFINAL)
01217     YYACCEPT;
01218 
01219   /* Shift the look-ahead token.  */
01220   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01221 
01222   /* Discard the token being shifted unless it is eof.  */
01223   if (yychar != YYEOF)
01224     yychar = YYEMPTY;
01225 
01226   *++yyvsp = yylval;
01227   *++yylsp = yylloc;
01228 
01229   /* Count tokens shifted since error; after three, turn off error
01230      status.  */
01231   if (yyerrstatus)
01232     yyerrstatus--;
01233 
01234   yystate = yyn;
01235   goto yynewstate;
01236 
01237 
01238 /*-----------------------------------------------------------.
01239 | yydefault -- do the default action for the current state.  |
01240 `-----------------------------------------------------------*/
01241 yydefault:
01242   yyn = yydefact[yystate];
01243   if (yyn == 0)
01244     goto yyerrlab;
01245   goto yyreduce;
01246 
01247 
01248 /*-----------------------------.
01249 | yyreduce -- Do a reduction.  |
01250 `-----------------------------*/
01251 yyreduce:
01252   /* yyn is the number of a rule to reduce with.  */
01253   yylen = yyr2[yyn];
01254 
01255   /* If YYLEN is nonzero, implement the default value of the action:
01256      `$$ = $1'.
01257 
01258      Otherwise, the following line sets YYVAL to garbage.
01259      This behavior is undocumented and Bison
01260      users should not rely upon it.  Assigning to YYVAL
01261      unconditionally makes the parser a bit smaller, and it avoids a
01262      GCC warning that YYVAL may be used uninitialized.  */
01263   yyval = yyvsp[1-yylen];
01264 
01265   /* Default location. */
01266   YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);
01267   YY_REDUCE_PRINT (yyn);
01268   switch (yyn)
01269     {
01270         case 2:
01271 #line 165 "ast_expr2.y"
01272     { ((struct parse_io *)parseio)->val = (struct val *)calloc(sizeof(struct val),1);
01273               ((struct parse_io *)parseio)->val->type = (yyvsp[0].val)->type;
01274               if( (yyvsp[0].val)->type == AST_EXPR_integer )
01275               ((struct parse_io *)parseio)->val->u.i = (yyvsp[0].val)->u.i;
01276               else
01277               ((struct parse_io *)parseio)->val->u.s = (yyvsp[0].val)->u.s; 
01278            free((yyvsp[0].val));
01279          ;}
01280     break;
01281 
01282   case 3:
01283 #line 175 "ast_expr2.y"
01284     { (yyval.val)= (yyvsp[0].val);;}
01285     break;
01286 
01287   case 4:
01288 #line 176 "ast_expr2.y"
01289     { (yyval.val) = (yyvsp[-1].val); 
01290                           (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01291                      (yyloc).first_line=0; (yyloc).last_line=0;
01292                      DESTROY((yyvsp[-2].val)); DESTROY((yyvsp[0].val)); ;}
01293     break;
01294 
01295   case 5:
01296 #line 180 "ast_expr2.y"
01297     { (yyval.val) = op_or ((yyvsp[-2].val), (yyvsp[0].val));
01298                   DESTROY((yyvsp[-1].val));  
01299                          (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01300                    (yyloc).first_line=0; (yyloc).last_line=0;;}
01301     break;
01302 
01303   case 6:
01304 #line 184 "ast_expr2.y"
01305     { (yyval.val) = op_and ((yyvsp[-2].val), (yyvsp[0].val)); 
01306                   DESTROY((yyvsp[-1].val));  
01307                          (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01308                           (yyloc).first_line=0; (yyloc).last_line=0;;}
01309     break;
01310 
01311   case 7:
01312 #line 188 "ast_expr2.y"
01313     { (yyval.val) = op_eq ((yyvsp[-2].val), (yyvsp[0].val));
01314                   DESTROY((yyvsp[-1].val));  
01315                         (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column;
01316                    (yyloc).first_line=0; (yyloc).last_line=0;;}
01317     break;
01318 
01319   case 8:
01320 #line 192 "ast_expr2.y"
01321     { (yyval.val) = op_gt ((yyvsp[-2].val), (yyvsp[0].val));
01322                   DESTROY((yyvsp[-1].val));  
01323                          (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column;
01324                    (yyloc).first_line=0; (yyloc).last_line=0;;}
01325     break;
01326 
01327   case 9:
01328 #line 196 "ast_expr2.y"
01329     { (yyval.val) = op_lt ((yyvsp[-2].val), (yyvsp[0].val)); 
01330                   DESTROY((yyvsp[-1].val));  
01331                         (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01332                    (yyloc).first_line=0; (yyloc).last_line=0;;}
01333     break;
01334 
01335   case 10:
01336 #line 200 "ast_expr2.y"
01337     { (yyval.val) = op_ge ((yyvsp[-2].val), (yyvsp[0].val)); 
01338                   DESTROY((yyvsp[-1].val));  
01339                          (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01340                     (yyloc).first_line=0; (yyloc).last_line=0;;}
01341     break;
01342 
01343   case 11:
01344 #line 204 "ast_expr2.y"
01345     { (yyval.val) = op_le ((yyvsp[-2].val), (yyvsp[0].val)); 
01346                   DESTROY((yyvsp[-1].val));  
01347                          (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01348                     (yyloc).first_line=0; (yyloc).last_line=0;;}
01349     break;
01350 
01351   case 12:
01352 #line 208 "ast_expr2.y"
01353     { (yyval.val) = op_ne ((yyvsp[-2].val), (yyvsp[0].val)); 
01354                   DESTROY((yyvsp[-1].val));  
01355                          (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01356                     (yyloc).first_line=0; (yyloc).last_line=0;;}
01357     break;
01358 
01359   case 13:
01360 #line 212 "ast_expr2.y"
01361     { (yyval.val) = op_plus ((yyvsp[-2].val), (yyvsp[0].val)); 
01362                   DESTROY((yyvsp[-1].val));  
01363                           (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01364                      (yyloc).first_line=0; (yyloc).last_line=0;;}
01365     break;
01366 
01367   case 14:
01368 #line 216 "ast_expr2.y"
01369     { (yyval.val) = op_minus ((yyvsp[-2].val), (yyvsp[0].val)); 
01370                   DESTROY((yyvsp[-1].val));  
01371                            (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01372                      (yyloc).first_line=0; (yyloc).last_line=0;;}
01373     break;
01374 
01375   case 15:
01376 #line 220 "ast_expr2.y"
01377     { (yyval.val) = op_negate ((yyvsp[0].val)); 
01378                   DESTROY((yyvsp[-1].val));  
01379                            (yyloc).first_column = (yylsp[-1]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01380                      (yyloc).first_line=0; (yyloc).last_line=0;;}
01381     break;
01382 
01383   case 16:
01384 #line 224 "ast_expr2.y"
01385     { (yyval.val) = op_compl ((yyvsp[0].val)); 
01386                   DESTROY((yyvsp[-1].val));  
01387                            (yyloc).first_column = (yylsp[-1]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01388                      (yyloc).first_line=0; (yyloc).last_line=0;;}
01389     break;
01390 
01391   case 17:
01392 #line 228 "ast_expr2.y"
01393     { (yyval.val) = op_times ((yyvsp[-2].val), (yyvsp[0].val)); 
01394                   DESTROY((yyvsp[-1].val));  
01395                           (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01396                      (yyloc).first_line=0; (yyloc).last_line=0;;}
01397     break;
01398 
01399   case 18:
01400 #line 232 "ast_expr2.y"
01401     { (yyval.val) = op_div ((yyvsp[-2].val), (yyvsp[0].val)); 
01402                   DESTROY((yyvsp[-1].val));  
01403                          (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01404                     (yyloc).first_line=0; (yyloc).last_line=0;;}
01405     break;
01406 
01407   case 19:
01408 #line 236 "ast_expr2.y"
01409     { (yyval.val) = op_rem ((yyvsp[-2].val), (yyvsp[0].val)); 
01410                   DESTROY((yyvsp[-1].val));  
01411                          (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01412                     (yyloc).first_line=0; (yyloc).last_line=0;;}
01413     break;
01414 
01415   case 20:
01416 #line 240 "ast_expr2.y"
01417     { (yyval.val) = op_colon ((yyvsp[-2].val), (yyvsp[0].val)); 
01418                   DESTROY((yyvsp[-1].val));  
01419                            (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01420                      (yyloc).first_line=0; (yyloc).last_line=0;;}
01421     break;
01422 
01423   case 21:
01424 #line 244 "ast_expr2.y"
01425     { (yyval.val) = op_eqtilde ((yyvsp[-2].val), (yyvsp[0].val)); 
01426                   DESTROY((yyvsp[-1].val));  
01427                            (yyloc).first_column = (yylsp[-2]).first_column; (yyloc).last_column = (yylsp[0]).last_column; 
01428                      (yyloc).first_line=0; (yyloc).last_line=0;;}
01429     break;
01430 
01431   case 22:
01432 #line 248 "ast_expr2.y"
01433     { (yyval.val) = op_cond ((yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[0].val)); 
01434                   DESTROY((yyvsp[-3].val));  
01435                   DESTROY((yyvsp[-1].val));  
01436                            (yyloc).first_column = (yylsp[-4]).first_column; (yyloc).last_column = (yylsp[-2]).last_column; 
01437                      (yyloc).first_line=0; (yyloc).last_line=0;;}
01438     break;
01439 
01440 
01441     }
01442 
01443 /* Line 1037 of yacc.c.  */
01444 #line 1445 "ast_expr2.c"
01445 
01446   yyvsp -= yylen;
01447   yyssp -= yylen;
01448   yylsp -= yylen;
01449 
01450   YY_STACK_PRINT (yyss, yyssp);
01451 
01452   *++yyvsp = yyval;
01453   *++yylsp = yyloc;
01454 
01455   /* Now `shift' the result of the reduction.  Determine what state
01456      that goes to, based on the state we popped back to and the rule
01457      number reduced by.  */
01458 
01459   yyn = yyr1[yyn];
01460 
01461   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
01462   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01463     yystate = yytable[yystate];
01464   else
01465     yystate = yydefgoto[yyn - YYNTOKENS];
01466 
01467   goto yynewstate;
01468 
01469 
01470 /*------------------------------------.
01471 | yyerrlab -- here on detecting error |
01472 `------------------------------------*/
01473 yyerrlab:
01474   /* If not already recovering from an error, report this error.  */
01475   if (!yyerrstatus)
01476     {
01477       ++yynerrs;
01478 #if YYERROR_VERBOSE
01479       yyn = yypact[yystate];
01480 
01481       if (YYPACT_NINF < yyn && yyn < YYLAST)
01482    {
01483      YYSIZE_T yysize = 0;
01484      int yytype = YYTRANSLATE (yychar);
01485      const char* yyprefix;
01486      char *yymsg;
01487      int yyx;
01488 
01489      /* Start YYX at -YYN if negative to avoid negative indexes in
01490         YYCHECK.  */
01491      int yyxbegin = yyn < 0 ? -yyn : 0;
01492 
01493      /* Stay within bounds of both yycheck and yytname.  */
01494      int yychecklim = YYLAST - yyn;
01495      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01496      int yycount = 0;
01497 
01498      yyprefix = ", expecting ";
01499      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01500        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01501          {
01502       yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
01503       yycount += 1;
01504       if (yycount == 5)
01505         {
01506           yysize = 0;
01507           break;
01508         }
01509          }
01510      yysize += (sizeof ("syntax error, unexpected ")
01511            + yystrlen (yytname[yytype]));
01512      yymsg = (char *) YYSTACK_ALLOC (yysize);
01513      if (yymsg != 0)
01514        {
01515          char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
01516          yyp = yystpcpy (yyp, yytname[yytype]);
01517 
01518          if (yycount < 5)
01519       {
01520         yyprefix = ", expecting ";
01521         for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01522           if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01523             {
01524          yyp = yystpcpy (yyp, yyprefix);
01525          yyp = yystpcpy (yyp, yytname[yyx]);
01526          yyprefix = " or ";
01527             }
01528       }
01529          yyerror (yymsg);
01530          YYSTACK_FREE (yymsg);
01531        }
01532      else
01533        yyerror ("syntax error; also virtual memory exhausted");
01534    }
01535       else
01536 #endif /* YYERROR_VERBOSE */
01537    yyerror ("syntax error");
01538     }
01539 
01540   yyerror_range[0] = yylloc;
01541 
01542   if (yyerrstatus == 3)
01543     {
01544       /* If just tried and failed to reuse look-ahead token after an
01545     error, discard it.  */
01546 
01547       if (yychar <= YYEOF)
01548         {
01549           /* If at end of input, pop the error token,
01550         then the rest of the stack, then return failure.  */
01551      if (yychar == YYEOF)
01552         for (;;)
01553           {
01554                  yyerror_range[0] = *yylsp;
01555        YYPOPSTACK;
01556        if (yyssp == yyss)
01557          YYABORT;
01558        yydestruct ("Error: popping",
01559                              yystos[*yyssp], yyvsp, yylsp);
01560           }
01561         }
01562       else
01563    {
01564      yydestruct ("Error: discarding", yytoken, &yylval, &yylloc);
01565      yychar = YYEMPTY;
01566    }
01567     }
01568 
01569   /* Else will try to reuse look-ahead token after shifting the error
01570      token.  */
01571   goto yyerrlab1;
01572 
01573 
01574 /*---------------------------------------------------.
01575 | yyerrorlab -- error raised explicitly by YYERROR.  |
01576 `---------------------------------------------------*/
01577 yyerrorlab:
01578 
01579 #ifdef __GNUC__
01580   /* Pacify GCC when the user code never invokes YYERROR and the label
01581      yyerrorlab therefore never appears in user code.  */
01582   if (0)
01583      goto yyerrorlab;
01584 #endif
01585 
01586   yyerror_range[0] = yylsp[1-yylen];
01587   yylsp -= yylen;
01588   yyvsp -= yylen;
01589   yyssp -= yylen;
01590   yystate = *yyssp;
01591   goto yyerrlab1;
01592 
01593 
01594 /*-------------------------------------------------------------.
01595 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
01596 `-------------------------------------------------------------*/
01597 yyerrlab1:
01598   yyerrstatus = 3;   /* Each real token shifted decrements this.  */
01599 
01600   for (;;)
01601     {
01602       yyn = yypact[yystate];
01603       if (yyn != YYPACT_NINF)
01604    {
01605      yyn += YYTERROR;
01606      if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
01607        {
01608          yyn = yytable[yyn];
01609          if (0 < yyn)
01610       break;
01611        }
01612    }
01613 
01614       /* Pop the current state because it cannot handle the error token.  */
01615       if (yyssp == yyss)
01616    YYABORT;
01617 
01618       yyerror_range[0] = *yylsp;
01619       yydestruct ("Error: popping", yystos[yystate], yyvsp, yylsp);
01620       YYPOPSTACK;
01621       yystate = *yyssp;
01622       YY_STACK_PRINT (yyss, yyssp);
01623     }
01624 
01625   if (yyn == YYFINAL)
01626     YYACCEPT;
01627 
01628   *++yyvsp = yylval;
01629 
01630   yyerror_range[1] = yylloc;
01631   /* Using YYLLOC is tempting, but would change the location of
01632      the look-ahead.  YYLOC is available though. */
01633   YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
01634   *++yylsp = yyloc;
01635 
01636   /* Shift the error token. */
01637   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
01638 
01639   yystate = yyn;
01640   goto yynewstate;
01641 
01642 
01643 /*-------------------------------------.
01644 | yyacceptlab -- YYACCEPT comes here.  |
01645 `-------------------------------------*/
01646 yyacceptlab:
01647   yyresult = 0;
01648   goto yyreturn;
01649 
01650 /*-----------------------------------.
01651 | yyabortlab -- YYABORT comes here.  |
01652 `-----------------------------------*/
01653 yyabortlab:
01654   yydestruct ("Error: discarding lookahead",
01655               yytoken, &yylval, &yylloc);
01656   yychar = YYEMPTY;
01657   yyresult = 1;
01658   goto yyreturn;
01659 
01660 #ifndef yyoverflow
01661 /*----------------------------------------------.
01662 | yyoverflowlab -- parser overflow comes here.  |
01663 `----------------------------------------------*/
01664 yyoverflowlab:
01665   yyerror ("parser stack overflow");
01666   yyresult = 2;
01667   /* Fall through.  */
01668 #endif
01669 
01670 yyreturn:
01671 #ifndef yyoverflow
01672   if (yyss != yyssa)
01673     YYSTACK_FREE (yyss);
01674 #endif
01675   return yyresult;
01676 }
01677 
01678 
01679 #line 255 "ast_expr2.y"
01680 
01681 
01682 static struct val *
01683 make_integer (quad_t i)
01684 {
01685    struct val *vp;
01686 
01687    vp = (struct val *) malloc (sizeof (*vp));
01688    if (vp == NULL) {
01689       ast_log(LOG_WARNING, "malloc() failed\n");
01690       return(NULL);
01691    }
01692 
01693    vp->type = AST_EXPR_integer;
01694    vp->u.i  = i;
01695    return vp; 
01696 }
01697 
01698 static struct val *
01699 make_str (const char *s)
01700 {
01701    struct val *vp;
01702    size_t i;
01703    int isint;
01704 
01705    vp = (struct val *) malloc (sizeof (*vp));
01706    if (vp == NULL || ((vp->u.s = strdup (s)) == NULL)) {
01707       ast_log(LOG_WARNING,"malloc() failed\n");
01708       return(NULL);
01709    }
01710 
01711    for(i = 1, isint = isdigit(s[0]) || s[0] == '-';
01712        isint && i < strlen(s);
01713        i++)
01714    {
01715       if(!isdigit(s[i]))
01716           isint = 0;
01717    }
01718 
01719    if (isint)
01720       vp->type = AST_EXPR_numeric_string;
01721    else  
01722       vp->type = AST_EXPR_string;
01723 
01724    return vp;
01725 }
01726 
01727 
01728 static void
01729 free_value (struct val *vp)
01730 {  
01731    if (vp==NULL) {
01732       return;
01733    }
01734    if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
01735       free (vp->u.s);   
01736    free(vp);
01737 }
01738 
01739 
01740 static quad_t
01741 to_integer (struct val *vp)
01742 {
01743    quad_t i;
01744    
01745    if (vp == NULL) {
01746       ast_log(LOG_WARNING,"vp==NULL in to_integer()\n");
01747       return(0);
01748    }
01749 
01750    if (vp->type == AST_EXPR_integer)
01751       return 1;
01752 
01753    if (vp->type == AST_EXPR_string)
01754       return 0;
01755 
01756    /* vp->type == AST_EXPR_numeric_string, make it numeric */
01757    errno = 0;
01758    i  = strtoll(vp->u.s, (char**)NULL, 10);
01759    if (errno != 0) {
01760       ast_log(LOG_WARNING,"Conversion of %s to integer under/overflowed!\n", vp->u.s);
01761       free(vp->u.s);
01762       vp->u.s = 0;
01763       return(0);
01764    }
01765    free (vp->u.s);
01766    vp->u.i = i;
01767    vp->type = AST_EXPR_integer;
01768    return 1;
01769 }
01770 
01771 static void
01772 strip_quotes(struct val *vp)
01773 {
01774    if (vp->type != AST_EXPR_string && vp->type != AST_EXPR_numeric_string)
01775       return;
01776    
01777    if( vp->u.s[0] == '"' && vp->u.s[strlen(vp->u.s)-1] == '"' )
01778    {
01779       char *f, *t;
01780       f = vp->u.s;
01781       t = vp->u.s;
01782       
01783       while( *f )
01784       {
01785          if( *f  && *f != '"' )
01786             *t++ = *f++;
01787          else
01788             f++;
01789       }
01790       *t = *f;
01791    }
01792 }
01793 
01794 static void
01795 to_string (struct val *vp)
01796 {
01797    char *tmp;
01798 
01799    if (vp->type == AST_EXPR_string || vp->type == AST_EXPR_numeric_string)
01800       return;
01801 
01802    tmp = malloc ((size_t)25);
01803    if (tmp == NULL) {
01804       ast_log(LOG_WARNING,"malloc() failed\n");
01805       return;
01806    }
01807 
01808    sprintf(tmp, "%ld", (long int) vp->u.i);
01809    vp->type = AST_EXPR_string;
01810    vp->u.s  = tmp;
01811 }
01812 
01813 
01814 static int
01815 isstring (struct val *vp)
01816 {
01817    /* only TRUE if this string is not a valid integer */
01818    return (vp->type == AST_EXPR_string);
01819 }
01820 
01821 
01822 static int
01823 is_zero_or_null (struct val *vp)
01824 {
01825    if (vp->type == AST_EXPR_integer) {
01826       return (vp->u.i == 0);
01827    } else {
01828       return (*vp->u.s == 0 || (to_integer (vp) && vp->u.i == 0));
01829    }
01830    /* NOTREACHED */
01831 }
01832 
01833 #ifdef STANDALONE
01834 
01835 void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
01836 {
01837    va_list vars;
01838    va_start(vars,fmt);
01839    
01840         printf("LOG: lev:%d file:%s  line:%d func: %s  ",
01841                    level, file, line, function);
01842    vprintf(fmt, vars);
01843    fflush(stdout);
01844    va_end(vars);
01845 }
01846 
01847 
01848 int main(int argc,char **argv) {
01849    char s[4096];
01850    
01851    if (ast_expr(argv[1], s, sizeof(s)))
01852       printf("=====%s======\n",s);
01853    else
01854       printf("No result\n");
01855 }
01856 
01857 #endif
01858 
01859 #undef ast_yyerror
01860 #define ast_yyerror(x) ast_yyerror(x, YYLTYPE *yylloc, struct parse_io *parseio)
01861 
01862 /* I put the ast_yyerror func in the flex input file,
01863    because it refers to the buffer state. Best to
01864    let it access the BUFFER stuff there and not trying
01865    define all the structs, macros etc. in this file! */
01866 
01867 
01868 static struct val *
01869 op_or (struct val *a, struct val *b)
01870 {
01871    if (is_zero_or_null (a)) {
01872       free_value (a);
01873       return (b);
01874    } else {
01875       free_value (b);
01876       return (a);
01877    }
01878 }
01879       
01880 static struct val *
01881 op_and (struct val *a, struct val *b)
01882 {
01883    if (is_zero_or_null (a) || is_zero_or_null (b)) {
01884       free_value (a);
01885       free_value (b);
01886       return (make_integer ((quad_t)0));
01887    } else {
01888       free_value (b);
01889       return (a);
01890    }
01891 }
01892 
01893 static struct val *
01894 op_eq (struct val *a, struct val *b)
01895 {
01896    struct val *r; 
01897 
01898    if (isstring (a) || isstring (b)) {
01899       to_string (a);
01900       to_string (b); 
01901       r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) == 0));
01902    } else {
01903 #ifdef DEBUG_FOR_CONVERSIONS
01904       char buffer[2000];
01905       sprintf(buffer,"Converting '%s' and '%s' ", a->u.s, b->u.s);
01906 #endif
01907       (void)to_integer(a);
01908       (void)to_integer(b);
01909 #ifdef DEBUG_FOR_CONVERSIONS
01910       ast_log(LOG_WARNING,"%s to '%lld' and '%lld'\n", buffer, a->u.i, b->u.i);
01911 #endif
01912       r = make_integer ((quad_t)(a->u.i == b->u.i));
01913    }
01914 
01915    free_value (a);
01916    free_value (b);
01917    return r;
01918 }
01919 
01920 static struct val *
01921 op_gt (struct val *a, struct val *b)
01922 {
01923    struct val *r;
01924 
01925    if (isstring (a) || isstring (b)) {
01926       to_string (a);
01927       to_string (b);
01928       r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) > 0));
01929    } else {
01930       (void)to_integer(a);
01931       (void)to_integer(b);
01932       r = make_integer ((quad_t)(a->u.i > b->u.i));
01933    }
01934 
01935    free_value (a);
01936    free_value (b);
01937    return r;
01938 }
01939 
01940 static struct val *
01941 op_lt (struct val *a, struct val *b)
01942 {
01943    struct val *r;
01944 
01945    if (isstring (a) || isstring (b)) {
01946       to_string (a);
01947       to_string (b);
01948       r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) < 0));
01949    } else {
01950       (void)to_integer(a);
01951       (void)to_integer(b);
01952       r = make_integer ((quad_t)(a->u.i < b->u.i));
01953    }
01954 
01955    free_value (a);
01956    free_value (b);
01957    return r;
01958 }
01959 
01960 static struct val *
01961 op_ge (struct val *a, struct val *b)
01962 {
01963    struct val *r;
01964 
01965    if (isstring (a) || isstring (b)) {
01966       to_string (a);
01967       to_string (b);
01968       r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) >= 0));
01969    } else {
01970       (void)to_integer(a);
01971       (void)to_integer(b);
01972       r = make_integer ((quad_t)(a->u.i >= b->u.i));
01973    }
01974 
01975    free_value (a);
01976    free_value (b);
01977    return r;
01978 }
01979 
01980 static struct val *
01981 op_le (struct val *a, struct val *b)
01982 {
01983    struct val *r;
01984 
01985    if (isstring (a) || isstring (b)) {
01986       to_string (a);
01987       to_string (b);
01988       r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) <= 0));
01989    } else {
01990       (void)to_integer(a);
01991       (void)to_integer(b);
01992       r = make_integer ((quad_t)(a->u.i <= b->u.i));
01993    }
01994 
01995    free_value (a);
01996    free_value (b);
01997    return r;
01998 }
01999 
02000 static struct val *
02001 op_cond (struct val *a, struct val *b, struct val *c)
02002 {
02003    struct val *r;
02004 
02005    if( isstring(a) )
02006    {
02007       if( strlen(a->u.s) && strcmp(a->u.s, "\"\"") != 0 && strcmp(a->u.s,"0") != 0 )
02008       {
02009          free_value(a);
02010          free_value(c);
02011          r = b;
02012       }
02013       else
02014       {
02015          free_value(a);
02016          free_value(b);
02017          r = c;
02018       }
02019    }
02020    else
02021    {
02022       (void)to_integer(a);
02023       if( a->u.i )
02024       {
02025          free_value(a);
02026          free_value(c);
02027          r = b;
02028       }
02029       else
02030       {
02031          free_value(a);
02032          free_value(b);
02033          r = c;
02034       }
02035    }
02036    return r;
02037 }
02038 
02039 static struct val *
02040 op_ne (struct val *a, struct val *b)
02041 {
02042    struct val *r;
02043 
02044    if (isstring (a) || isstring (b)) {
02045       to_string (a);
02046       to_string (b);
02047       r = make_integer ((quad_t)(strcoll (a->u.s, b->u.s) != 0));
02048    } else {
02049       (void)to_integer(a);
02050       (void)to_integer(b);
02051       r = make_integer ((quad_t)(a->u.i != b->u.i));
02052    }
02053 
02054    free_value (a);
02055    free_value (b);
02056    return r;
02057 }
02058 
02059 static int
02060 chk_plus (quad_t a, quad_t b, quad_t r)
02061 {
02062    /* sum of two positive numbers must be positive */
02063    if (a > 0 && b > 0 && r <= 0)
02064       return 1;
02065    /* sum of two negative numbers must be negative */
02066    if (a < 0 && b < 0 && r >= 0)
02067       return 1;
02068    /* all other cases are OK */
02069    return 0;
02070 }
02071 
02072 static struct val *
02073 op_plus (struct val *a, struct val *b)
02074 {
02075    struct val *r;
02076 
02077    if (!to_integer (a)) {
02078       ast_log(LOG_WARNING,"non-numeric argument\n");
02079       if (!to_integer (b)) {
02080          free_value(a);
02081          free_value(b);
02082          return make_integer(0);
02083       } else {
02084          free_value(a);
02085          return (b);
02086       }
02087    } else if (!to_integer(b)) {
02088       free_value(b);
02089       return (a);
02090    }
02091 
02092    r = make_integer (/*(quad_t)*/(a->u.i + b->u.i));
02093    if (chk_plus (a->u.i, b->u.i, r->u.i)) {
02094       ast_log(LOG_WARNING,"overflow\n");
02095    }
02096    free_value (a);
02097    free_value (b);
02098    return r;
02099 }
02100 
02101 static int
02102 chk_minus (quad_t a, quad_t b, quad_t r)
02103 {
02104    /* special case subtraction of QUAD_MIN */
02105    if (b == QUAD_MIN) {
02106       if (a >= 0)
02107          return 1;
02108       else
02109          return 0;
02110    }
02111    /* this is allowed for b != QUAD_MIN */
02112    return chk_plus (a, -b, r);
02113 }
02114 
02115 static struct val *
02116 op_minus (struct val *a, struct val *b)
02117 {
02118    struct val *r;
02119 
02120    if (!to_integer (a)) {
02121       ast_log(LOG_WARNING, "non-numeric argument\n");
02122       if (!to_integer (b)) {
02123          free_value(a);
02124          free_value(b);
02125          return make_integer(0);
02126       } else {
02127          r = make_integer(0 - b->u.i);
02128          free_value(a);
02129          free_value(b);
02130          return (r);
02131       }
02132    } else if (!to_integer(b)) {
02133       ast_log(LOG_WARNING, "non-numeric argument\n");
02134       free_value(b);
02135       return (a);
02136    }
02137 
02138    r = make_integer (/*(quad_t)*/(a->u.i - b->u.i));
02139    if (chk_minus (a->u.i, b->u.i, r->u.i)) {
02140       ast_log(LOG_WARNING, "overflow\n");
02141    }
02142    free_value (a);
02143    free_value (b);
02144    return r;
02145 }
02146 
02147 static struct val *
02148 op_negate (struct val *a)
02149 {
02150    struct val *r;
02151 
02152    if (!to_integer (a) ) {
02153       free_value(a);
02154       ast_log(LOG_WARNING, "non-numeric argument\n");
02155       return make_integer(0);
02156    }
02157 
02158    r = make_integer (/*(quad_t)*/(- a->u.i));
02159    if (chk_minus (0, a->u.i, r->u.i)) {
02160       ast_log(LOG_WARNING, "overflow\n");
02161    }
02162    free_value (a);
02163    return r;
02164 }
02165 
02166 static struct val *
02167 op_compl (struct val *a)
02168 {
02169    int v1 = 1;
02170    struct val *r;
02171    
02172    if( !a )
02173    {
02174       v1 = 0;
02175    }
02176    else
02177    {
02178       switch( a->type )
02179       {
02180       case AST_EXPR_integer:
02181          if( a->u.i == 0 )
02182             v1 = 0;
02183          break;
02184          
02185       case AST_EXPR_string:
02186          if( a->u.s == 0 )
02187             v1 = 0;
02188          else
02189          {
02190             if( a->u.s[0] == 0 )
02191                v1 = 0;
02192             else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
02193                v1 = 0;
02194          }
02195          break;
02196          
02197       case AST_EXPR_numeric_string:
02198          if( a->u.s == 0 )
02199             v1 = 0;
02200          else
02201          {
02202             if( a->u.s[0] == 0 )
02203                v1 = 0;
02204             else if (strlen(a->u.s) == 1 && a->u.s[0] == '0' )
02205                v1 = 0;
02206          }
02207          break;
02208       }
02209    }
02210    
02211    r = make_integer (!v1);
02212    free_value (a);
02213    return r;
02214 }
02215 
02216 static int
02217 chk_times (quad_t a, quad_t b, quad_t r)
02218 {
02219    /* special case: first operand is 0, no overflow possible */
02220    if (a == 0)
02221       return 0;
02222    /* cerify that result of division matches second operand */
02223    if (r / a != b)
02224       return 1;
02225    return 0;
02226 }
02227 
02228 static struct val *
02229 op_times (struct val *a, struct val *b)
02230 {
02231    struct val *r;
02232 
02233    if (!to_integer (a) || !to_integer (b)) {
02234       free_value(a);
02235       free_value(b);
02236       ast_log(LOG_WARNING, "non-numeric argument\n");
02237       return(make_integer(0));
02238    }
02239 
02240    r = make_integer (/*(quad_t)*/(a->u.i * b->u.i));
02241    if (chk_times (a->u.i, b->u.i, r->u.i)) {
02242       ast_log(LOG_WARNING, "overflow\n");
02243    }
02244    free_value (a);
02245    free_value (b);
02246    return (r);
02247 }
02248 
02249 static int
02250 chk_div (quad_t a, quad_t b)
02251 {
02252    /* div by zero has been taken care of before */
02253    /* only QUAD_MIN / -1 causes overflow */
02254    if (a == QUAD_MIN && b == -1)
02255       return 1;
02256    /* everything else is OK */
02257    return 0;
02258 }
02259 
02260 static struct val *
02261 op_div (struct val *a, struct val *b)
02262 {
02263    struct val *r;
02264 
02265    if (!to_integer (a)) {
02266       free_value(a);
02267       free_value(b);
02268       ast_log(LOG_WARNING, "non-numeric argument\n");
02269       return make_integer(0);
02270    } else if (!to_integer (b)) {
02271       free_value(a);
02272       free_value(b);
02273       ast_log(LOG_WARNING, "non-numeric argument\n");
02274       return make_integer(INT_MAX);
02275    }
02276 
02277    if (b->u.i == 0) {
02278       ast_log(LOG_WARNING, "division by zero\n");     
02279       free_value(a);
02280       free_value(b);
02281       return make_integer(INT_MAX);
02282    }
02283 
02284    r = make_integer (/*(quad_t)*/(a->u.i / b->u.i));
02285    if (chk_div (a->u.i, b->u.i)) {
02286       ast_log(LOG_WARNING, "overflow\n");
02287    }
02288    free_value (a);
02289    free_value (b);
02290    return r;
02291 }
02292    
02293 static struct val *
02294 op_rem (struct val *a, struct val *b)
02295 {
02296    struct val *r;
02297 
02298    if (!to_integer (a) || !to_integer (b)) {
02299       ast_log(LOG_WARNING, "non-numeric argument\n");
02300       free_value(a);
02301       free_value(b);
02302       return make_integer(0);
02303    }
02304 
02305    if (b->u.i == 0) {
02306       ast_log(LOG_WARNING, "div by zero\n");
02307       free_value(a);
02308       return(b);
02309    }
02310 
02311    r = make_integer (/*(quad_t)*/(a->u.i % b->u.i));
02312    /* chk_rem necessary ??? */
02313    free_value (a);
02314    free_value (b);
02315    return r;
02316 }
02317    
02318 
02319 static struct val *
02320 op_colon (struct val *a, struct val *b)
02321 {
02322    regex_t rp;
02323    regmatch_t rm[2];
02324    char errbuf[256];
02325    int eval;
02326    struct val *v;
02327 
02328    /* coerce to both arguments to strings */
02329    to_string(a);
02330    to_string(b);
02331    /* strip double quotes from both -- they'll screw up the pattern, and the search string starting at ^ */
02332    strip_quotes(a);
02333    strip_quotes(b);
02334    /* compile regular expression */
02335    if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
02336       regerror (eval, &rp, errbuf, sizeof(errbuf));
02337       ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
02338       free_value(a);
02339       free_value(b);
02340       return make_str("");    
02341    }
02342 
02343    /* compare string against pattern */
02344    /* remember that patterns are anchored to the beginning of the line */
02345    if (regexec(&rp, a->u.s, (size_t)2, rm, 0) == 0 && rm[0].rm_so == 0) {
02346       if (rm[1].rm_so >= 0) {
02347          *(a->u.s + rm[1].rm_eo) = '\0';
02348          v = make_str (a->u.s + rm[1].rm_so);
02349 
02350       } else {
02351          v = make_integer ((quad_t)(rm[0].rm_eo - rm[0].rm_so));
02352       }
02353    } else {
02354       if (rp.re_nsub == 0) {
02355          v = make_integer ((quad_t)0);
02356       } else {
02357          v = make_str ("");
02358       }
02359    }
02360 
02361    /* free arguments and pattern buffer */
02362    free_value (a);
02363    free_value (b);
02364    regfree (&rp);
02365 
02366    return v;
02367 }
02368    
02369 
02370 static struct val *
02371 op_eqtilde (struct val *a, struct val *b)
02372 {
02373    regex_t rp;
02374    regmatch_t rm[2];
02375    char errbuf[256];
02376    int eval;
02377    struct val *v;
02378 
02379    /* coerce to both arguments to strings */
02380    to_string(a);
02381    to_string(b);
02382    /* strip double quotes from both -- they'll screw up the pattern, and the search string starting at ^ */
02383    strip_quotes(a);
02384    strip_quotes(b);
02385    /* compile regular expression */
02386    if ((eval = regcomp (&rp, b->u.s, REG_EXTENDED)) != 0) {
02387       regerror (eval, &rp, errbuf, sizeof(errbuf));
02388       ast_log(LOG_WARNING,"regcomp() error : %s",errbuf);
02389       free_value(a);
02390       free_value(b);
02391       return make_str("");    
02392    }
02393 
02394    /* compare string against pattern */
02395    /* remember that patterns are anchored to the beginning of the line */
02396    if (regexec(&rp, a->u.s, (size_t)2, rm, 0) == 0 ) {
02397       if (rm[1].rm_so >= 0) {
02398          *(a->u.s + rm[1].rm_eo) = '\0';
02399          v = make_str (a->u.s + rm[1].rm_so);
02400 
02401       } else {
02402          v = make_integer ((quad_t)(rm[0].rm_eo - rm[0].rm_so));
02403       }
02404    } else {
02405       if (rp.re_nsub == 0) {
02406          v = make_integer ((quad_t)0);
02407       } else {
02408          v = make_str ("");
02409       }
02410    }
02411 
02412    /* free arguments and pattern buffer */
02413    free_value (a);
02414    free_value (b);
02415    regfree (&rp);
02416 
02417    return v;
02418 }
02419 

Generated on Sat Mar 24 23:26:00 2007 for Asterisk - the Open Source PBX by  doxygen 1.4.6