search_parser.cxx

Go to the documentation of this file.
00001 /* A Bison parser, made by GNU Bison 2.3.  */
00002 
00003 /* Skeleton implementation for Bison's Yacc-like parsers in C
00004 
00005    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
00006    Free Software Foundation, Inc.
00007 
00008    This program is free software; you can redistribute it and/or modify
00009    it under the terms of the GNU General Public License as published by
00010    the Free Software Foundation; either version 2, or (at your option)
00011    any later version.
00012 
00013    This program is distributed in the hope that it will be useful,
00014    but WITHOUT ANY WARRANTY; without even the implied warranty of
00015    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016    GNU General Public License for more details.
00017 
00018    You should have received a copy of the GNU General Public License
00019    along with this program; if not, write to the Free Software
00020    Foundation, Inc., 51 Franklin Street, Fifth Floor,
00021    Boston, MA 02110-1301, USA.  */
00022 
00023 /* As a special exception, you may create a larger work that contains
00024    part or all of the Bison parser skeleton and distribute that work
00025    under terms of your choice, so long as that work isn't itself a
00026    parser generator using the skeleton or a modified version thereof
00027    as a parser skeleton.  Alternatively, if you modify or redistribute
00028    the parser skeleton itself, you may (at your option) remove this
00029    special exception, which will cause the skeleton and the resulting
00030    Bison output files to be licensed under the GNU General Public
00031    License without this special exception.
00032 
00033    This special exception was added by the Free Software Foundation in
00034    version 2.2 of Bison.  */
00035 
00036 /* C LALR(1) parser skeleton written by Richard Stallman, by
00037    simplifying the original so-called "semantic" parser.  */
00038 
00039 /* All symbols defined below should begin with yy or YY, to avoid
00040    infringing on user name space.  This should be done even for local
00041    variables, as they might otherwise be expanded by user macros.
00042    There are some unavoidable exceptions within include files to
00043    define necessary library symbols; they are noted "INFRINGES ON
00044    USER NAME SPACE" below.  */
00045 
00046 /* Identify Bison output.  */
00047 #define YYBISON 1
00048 
00049 /* Bison version.  */
00050 #define YYBISON_VERSION "2.3"
00051 
00052 /* Skeleton name.  */
00053 #define YYSKELETON_NAME "yacc.c"
00054 
00055 /* Pure parsers.  */
00056 #define YYPURE 1
00057 
00058 /* Using locations.  */
00059 #define YYLSP_NEEDED 0
00060 
00061 /* Substitute the variable and function names.  */
00062 #define yyparse search_parse
00063 #define yylex   search_lex
00064 #define yyerror search_error
00065 #define yylval  search_lval
00066 #define yychar  search_char
00067 #define yydebug search_debug
00068 #define yynerrs search_nerrs
00069 
00070 
00071 /* Tokens.  */
00072 #ifndef YYTOKENTYPE
00073 # define YYTOKENTYPE
00074    /* Put the tokens into the symbol table, so that GDB and other debuggers
00075       know about them.  */
00076    enum yytokentype {
00077      T_WORD = 258
00078    };
00079 #endif
00080 /* Tokens.  */
00081 #define T_WORD 258
00082 
00083 
00084 
00085 
00086 /* Copy the first part of user declarations.  */
00087 
00088 
00089 //
00090 // Part of the ht://Dig package   <http://www.htdig.org/>
00091 // Copyright (c) 1999, 2000, 2001 The ht://Dig Group
00092 // For copyright details, see the file COPYING in your distribution
00093 // or the GNU General Public License version 2 or later
00094 // <http://www.gnu.org/copyleft/gpl.html>
00095 //
00096 // $Id: search__parser_8cxx-source.html,v 1.1 2008/06/08 10:21:55 sebdiaz Exp $
00097 //
00098 #ifdef HAVE_CONFIG_H
00099 #include <config.h>
00100 #endif /* HAVE_CONFIG_H */
00101 
00102 #ifdef HAVE_STDLIB_H
00103 #include <unistd.h>
00104 #endif /* HAVE_STDLIB_H */
00105 #ifdef HAVE_UNISTD_H
00106 #include <unistd.h>
00107 #endif /* HAVE_UNISTD_H */
00108 #ifdef HAVE_MALLOC_H
00109 #include <malloc.h>
00110 #endif /* HAVE_MALLOC_H */
00111 
00112 #include <stdio.h>
00113 
00114 #include <unac.h>
00115 #include <WordTree.h>
00116 #include <mifluzsearch.h>
00117 
00118 #define YYPARSE_PARAM parm
00119 #define YYLEX_PARAM parm
00120 
00121 
00122 class WordTreeList {
00123  public:
00124   WordTreeList(WordTree* node) {
00125     values = (WordTree**)malloc(sizeof(WordTree*));
00126     values[0] = node;
00127     values_length = 1;
00128   }
00129 
00130   void Push(WordTree* node) {
00131     values = (WordTree**)realloc(values, sizeof(WordTree*) * (values_length + 1));
00132     values[values_length] = node;
00133     values_length++;
00134   }
00135   
00136   WordTree** values;
00137   int values_length;
00138 };
00139 
00140 
00141 
00142 /* Enabling traces.  */
00143 #ifndef YYDEBUG
00144 # define YYDEBUG 0
00145 #endif
00146 
00147 /* Enabling verbose error messages.  */
00148 #ifdef YYERROR_VERBOSE
00149 # undef YYERROR_VERBOSE
00150 # define YYERROR_VERBOSE 1
00151 #else
00152 # define YYERROR_VERBOSE 0
00153 #endif
00154 
00155 /* Enabling the token table.  */
00156 #ifndef YYTOKEN_TABLE
00157 # define YYTOKEN_TABLE 0
00158 #endif
00159 
00160 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00161 typedef union YYSTYPE
00162 
00163 {
00164   WordTree* node;
00165   WordTreeList* list;
00166 }
00167 /* Line 187 of yacc.c.  */
00168 
00169         YYSTYPE;
00170 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00171 # define YYSTYPE_IS_DECLARED 1
00172 # define YYSTYPE_IS_TRIVIAL 1
00173 #endif
00174 
00175 
00176 
00177 /* Copy the second part of user declarations.  */
00178 
00179 
00180 static int yylex(YYSTYPE *lvalp, void* inputp);
00181 static int yyerror(char* message);
00182 
00183 
00184 /* Line 216 of yacc.c.  */
00185 
00186 
00187 #ifdef short
00188 # undef short
00189 #endif
00190 
00191 #ifdef YYTYPE_UINT8
00192 typedef YYTYPE_UINT8 yytype_uint8;
00193 #else
00194 typedef unsigned char yytype_uint8;
00195 #endif
00196 
00197 #ifdef YYTYPE_INT8
00198 typedef YYTYPE_INT8 yytype_int8;
00199 #elif (defined __STDC__ || defined __C99__FUNC__ \
00200      || defined __cplusplus || defined _MSC_VER)
00201 typedef signed char yytype_int8;
00202 #else
00203 typedef short int yytype_int8;
00204 #endif
00205 
00206 #ifdef YYTYPE_UINT16
00207 typedef YYTYPE_UINT16 yytype_uint16;
00208 #else
00209 typedef unsigned short int yytype_uint16;
00210 #endif
00211 
00212 #ifdef YYTYPE_INT16
00213 typedef YYTYPE_INT16 yytype_int16;
00214 #else
00215 typedef short int yytype_int16;
00216 #endif
00217 
00218 #ifndef YYSIZE_T
00219 # ifdef __SIZE_TYPE__
00220 #  define YYSIZE_T __SIZE_TYPE__
00221 # elif defined size_t
00222 #  define YYSIZE_T size_t
00223 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00224      || defined __cplusplus || defined _MSC_VER)
00225 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00226 #  define YYSIZE_T size_t
00227 # else
00228 #  define YYSIZE_T unsigned int
00229 # endif
00230 #endif
00231 
00232 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00233 
00234 #ifndef YY_
00235 # if YYENABLE_NLS
00236 #  if ENABLE_NLS
00237 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00238 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00239 #  endif
00240 # endif
00241 # ifndef YY_
00242 #  define YY_(msgid) msgid
00243 # endif
00244 #endif
00245 
00246 /* Suppress unused-variable warnings by "using" E.  */
00247 #if ! defined lint || defined __GNUC__
00248 # define YYUSE(e) ((void) (e))
00249 #else
00250 # define YYUSE(e) /* empty */
00251 #endif
00252 
00253 /* Identity function, used to suppress warnings about constant conditions.  */
00254 #ifndef lint
00255 # define YYID(n) (n)
00256 #else
00257 #if (defined __STDC__ || defined __C99__FUNC__ \
00258      || defined __cplusplus || defined _MSC_VER)
00259 static int
00260 YYID (int i)
00261 #else
00262 static int
00263 YYID (i)
00264     int i;
00265 #endif
00266 {
00267   return i;
00268 }
00269 #endif
00270 
00271 #if ! defined yyoverflow || YYERROR_VERBOSE
00272 
00273 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00274 
00275 # ifdef YYSTACK_USE_ALLOCA
00276 #  if YYSTACK_USE_ALLOCA
00277 #   ifdef __GNUC__
00278 #    define YYSTACK_ALLOC __builtin_alloca
00279 #   elif defined __BUILTIN_VA_ARG_INCR
00280 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00281 #   elif defined _AIX
00282 #    define YYSTACK_ALLOC __alloca
00283 #   elif defined _MSC_VER
00284 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00285 #    define alloca _alloca
00286 #   else
00287 #    define YYSTACK_ALLOC alloca
00288 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00289      || defined __cplusplus || defined _MSC_VER)
00290 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00291 #     ifndef _STDLIB_H
00292 #      define _STDLIB_H 1
00293 #     endif
00294 #    endif
00295 #   endif
00296 #  endif
00297 # endif
00298 
00299 # ifdef YYSTACK_ALLOC
00300    /* Pacify GCC's `empty if-body' warning.  */
00301 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00302 #  ifndef YYSTACK_ALLOC_MAXIMUM
00303     /* The OS might guarantee only one guard page at the bottom of the stack,
00304        and a page size can be as small as 4096 bytes.  So we cannot safely
00305        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00306        to allow for a few compiler-allocated temporary stack slots.  */
00307 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
00308 #  endif
00309 # else
00310 #  define YYSTACK_ALLOC YYMALLOC
00311 #  define YYSTACK_FREE YYFREE
00312 #  ifndef YYSTACK_ALLOC_MAXIMUM
00313 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00314 #  endif
00315 #  if (defined __cplusplus && ! defined _STDLIB_H \
00316        && ! ((defined YYMALLOC || defined malloc) \
00317              && (defined YYFREE || defined free)))
00318 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00319 #   ifndef _STDLIB_H
00320 #    define _STDLIB_H 1
00321 #   endif
00322 #  endif
00323 #  ifndef YYMALLOC
00324 #   define YYMALLOC malloc
00325 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00326      || defined __cplusplus || defined _MSC_VER)
00327 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00328 #   endif
00329 #  endif
00330 #  ifndef YYFREE
00331 #   define YYFREE free
00332 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00333      || defined __cplusplus || defined _MSC_VER)
00334 void free (void *); /* INFRINGES ON USER NAME SPACE */
00335 #   endif
00336 #  endif
00337 # endif
00338 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
00339 
00340 
00341 #if (! defined yyoverflow \
00342      && (! defined __cplusplus \
00343          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00344 
00345 /* A type that is properly aligned for any stack member.  */
00346 union yyalloc
00347 {
00348   yytype_int16 yyss;
00349   YYSTYPE yyvs;
00350   };
00351 
00352 /* The size of the maximum gap between one aligned stack and the next.  */
00353 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00354 
00355 /* The size of an array large to enough to hold all stacks, each with
00356    N elements.  */
00357 # define YYSTACK_BYTES(N) \
00358      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
00359       + YYSTACK_GAP_MAXIMUM)
00360 
00361 /* Copy COUNT objects from FROM to TO.  The source and destination do
00362    not overlap.  */
00363 # ifndef YYCOPY
00364 #  if defined __GNUC__ && 1 < __GNUC__
00365 #   define YYCOPY(To, From, Count) \
00366       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00367 #  else
00368 #   define YYCOPY(To, From, Count)              \
00369       do                                        \
00370         {                                       \
00371           YYSIZE_T yyi;                         \
00372           for (yyi = 0; yyi < (Count); yyi++)   \
00373             (To)[yyi] = (From)[yyi];            \
00374         }                                       \
00375       while (YYID (0))
00376 #  endif
00377 # endif
00378 
00379 /* Relocate STACK from its old location to the new one.  The
00380    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00381    elements in the stack, and YYPTR gives the new location of the
00382    stack.  Advance YYPTR to a properly aligned location for the next
00383    stack.  */
00384 # define YYSTACK_RELOCATE(Stack)                                        \
00385     do                                                                  \
00386       {                                                                 \
00387         YYSIZE_T yynewbytes;                                            \
00388         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
00389         Stack = &yyptr->Stack;                                          \
00390         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00391         yyptr += yynewbytes / sizeof (*yyptr);                          \
00392       }                                                                 \
00393     while (YYID (0))
00394 
00395 #endif
00396 
00397 /* YYFINAL -- State number of the termination state.  */
00398 #define YYFINAL  2
00399 /* YYLAST -- Last index in YYTABLE.  */
00400 #define YYLAST   11
00401 
00402 /* YYNTOKENS -- Number of terminals.  */
00403 #define YYNTOKENS  7
00404 /* YYNNTS -- Number of nonterminals.  */
00405 #define YYNNTS  6
00406 /* YYNRULES -- Number of rules.  */
00407 #define YYNRULES  11
00408 /* YYNRULES -- Number of states.  */
00409 #define YYNSTATES  16
00410 
00411 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00412 #define YYUNDEFTOK  2
00413 #define YYMAXUTOK   258
00414 
00415 #define YYTRANSLATE(YYX)                                                \
00416   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00417 
00418 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00419 static const yytype_uint8 yytranslate[] =
00420 {
00421        0,     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,     6,     2,     2,     2,     2,     2,
00425        2,     2,     2,     4,     2,     5,     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,     2,     2,     2,     2,
00445        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00446        2,     2,     2,     2,     2,     2,     1,     2,     3
00447 };
00448 
00449 #if YYDEBUG
00450 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00451    YYRHS.  */
00452 static const yytype_uint8 yyprhs[] =
00453 {
00454        0,     0,     3,     4,     7,     9,    12,    15,    17,    19,
00455       23,    25
00456 };
00457 
00458 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
00459 static const yytype_int8 yyrhs[] =
00460 {
00461        8,     0,    -1,    -1,     8,     9,    -1,    10,    -1,     4,
00462       10,    -1,     5,    10,    -1,    11,    -1,     3,    -1,     6,
00463       12,     6,    -1,     3,    -1,    12,     3,    -1
00464 };
00465 
00466 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00467 static const yytype_uint8 yyrline[] =
00468 {
00469        0,    74,    74,    79,   116,   117,   126,   136,   137,   139,
00470      153,   157
00471 };
00472 #endif
00473 
00474 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00475 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00476    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
00477 static const char *const yytname[] =
00478 {
00479   "$end", "error", "$undefined", "T_WORD", "'+'", "'-'", "'\"'",
00480   "$accept", "input", "expr", "sentence", "literal", "words", 0
00481 };
00482 #endif
00483 
00484 # ifdef YYPRINT
00485 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00486    token YYLEX-NUM.  */
00487 static const yytype_uint16 yytoknum[] =
00488 {
00489        0,   256,   257,   258,    43,    45,    34
00490 };
00491 # endif
00492 
00493 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00494 static const yytype_uint8 yyr1[] =
00495 {
00496        0,     7,     8,     8,     9,     9,     9,    10,    10,    11,
00497       12,    12
00498 };
00499 
00500 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00501 static const yytype_uint8 yyr2[] =
00502 {
00503        0,     2,     0,     2,     1,     2,     2,     1,     1,     3,
00504        1,     2
00505 };
00506 
00507 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00508    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00509    means the default is an error.  */
00510 static const yytype_uint8 yydefact[] =
00511 {
00512        2,     0,     1,     8,     0,     0,     0,     3,     4,     7,
00513        5,     6,    10,     0,    11,     9
00514 };
00515 
00516 /* YYDEFGOTO[NTERM-NUM].  */
00517 static const yytype_int8 yydefgoto[] =
00518 {
00519       -1,     1,     7,     8,     9,    13
00520 };
00521 
00522 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00523    STATE-NUM.  */
00524 #define YYPACT_NINF -4
00525 static const yytype_int8 yypact[] =
00526 {
00527       -4,     0,    -4,    -4,     4,     4,     6,    -4,    -4,    -4,
00528       -4,    -4,    -4,     5,    -4,    -4
00529 };
00530 
00531 /* YYPGOTO[NTERM-NUM].  */
00532 static const yytype_int8 yypgoto[] =
00533 {
00534       -4,    -4,    -4,    -3,    -4,    -4
00535 };
00536 
00537 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00538    positive, shift that token.  If negative, reduce the rule which
00539    number is the opposite.  If zero, do what YYDEFACT says.
00540    If YYTABLE_NINF, syntax error.  */
00541 #define YYTABLE_NINF -1
00542 static const yytype_uint8 yytable[] =
00543 {
00544        2,    10,    11,     3,     4,     5,     6,     3,    14,    12,
00545        6,    15
00546 };
00547 
00548 static const yytype_uint8 yycheck[] =
00549 {
00550        0,     4,     5,     3,     4,     5,     6,     3,     3,     3,
00551        6,     6
00552 };
00553 
00554 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00555    symbol of state STATE-NUM.  */
00556 static const yytype_uint8 yystos[] =
00557 {
00558        0,     8,     0,     3,     4,     5,     6,     9,    10,    11,
00559       10,    10,     3,    12,     3,     6
00560 };
00561 
00562 #define yyerrok         (yyerrstatus = 0)
00563 #define yyclearin       (yychar = YYEMPTY)
00564 #define YYEMPTY         (-2)
00565 #define YYEOF           0
00566 
00567 #define YYACCEPT        goto yyacceptlab
00568 #define YYABORT         goto yyabortlab
00569 #define YYERROR         goto yyerrorlab
00570 
00571 
00572 /* Like YYERROR except do call yyerror.  This remains here temporarily
00573    to ease the transition to the new meaning of YYERROR, for GCC.
00574    Once GCC version 2 has supplanted version 1, this can go.  */
00575 
00576 #define YYFAIL          goto yyerrlab
00577 
00578 #define YYRECOVERING()  (!!yyerrstatus)
00579 
00580 #define YYBACKUP(Token, Value)                                  \
00581 do                                                              \
00582   if (yychar == YYEMPTY && yylen == 1)                          \
00583     {                                                           \
00584       yychar = (Token);                                         \
00585       yylval = (Value);                                         \
00586       yytoken = YYTRANSLATE (yychar);                           \
00587       YYPOPSTACK (1);                                           \
00588       goto yybackup;                                            \
00589     }                                                           \
00590   else                                                          \
00591     {                                                           \
00592       yyerror (YY_("syntax error: cannot back up")); \
00593       YYERROR;                                                  \
00594     }                                                           \
00595 while (YYID (0))
00596 
00597 
00598 #define YYTERROR        1
00599 #define YYERRCODE       256
00600 
00601 
00602 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
00603    If N is 0, then set CURRENT to the empty location which ends
00604    the previous symbol: RHS[0] (always defined).  */
00605 
00606 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00607 #ifndef YYLLOC_DEFAULT
00608 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
00609     do                                                                  \
00610       if (YYID (N))                                                    \
00611         {                                                               \
00612           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
00613           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
00614           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
00615           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
00616         }                                                               \
00617       else                                                              \
00618         {                                                               \
00619           (Current).first_line   = (Current).last_line   =              \
00620             YYRHSLOC (Rhs, 0).last_line;                                \
00621           (Current).first_column = (Current).last_column =              \
00622             YYRHSLOC (Rhs, 0).last_column;                              \
00623         }                                                               \
00624     while (YYID (0))
00625 #endif
00626 
00627 
00628 /* YY_LOCATION_PRINT -- Print the location on the stream.
00629    This macro was not mandated originally: define only if we know
00630    we won't break user code: when these are the locations we know.  */
00631 
00632 #ifndef YY_LOCATION_PRINT
00633 # if YYLTYPE_IS_TRIVIAL
00634 #  define YY_LOCATION_PRINT(File, Loc)                  \
00635      fprintf (File, "%d.%d-%d.%d",                      \
00636               (Loc).first_line, (Loc).first_column,     \
00637               (Loc).last_line,  (Loc).last_column)
00638 # else
00639 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00640 # endif
00641 #endif
00642 
00643 
00644 /* YYLEX -- calling `yylex' with the right arguments.  */
00645 
00646 #ifdef YYLEX_PARAM
00647 # define YYLEX yylex (&yylval, YYLEX_PARAM)
00648 #else
00649 # define YYLEX yylex (&yylval)
00650 #endif
00651 
00652 /* Enable debugging if requested.  */
00653 #if YYDEBUG
00654 
00655 # ifndef YYFPRINTF
00656 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
00657 #  define YYFPRINTF fprintf
00658 # endif
00659 
00660 # define YYDPRINTF(Args)                        \
00661 do {                                            \
00662   if (yydebug)                                  \
00663     YYFPRINTF Args;                             \
00664 } while (YYID (0))
00665 
00666 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
00667 do {                                                                      \
00668   if (yydebug)                                                            \
00669     {                                                                     \
00670       YYFPRINTF (stderr, "%s ", Title);                                   \
00671       yy_symbol_print (stderr,                                            \
00672                   Type, Value); \
00673       YYFPRINTF (stderr, "\n");                                           \
00674     }                                                                     \
00675 } while (YYID (0))
00676 
00677 
00678 /*--------------------------------.
00679 | Print this symbol on YYOUTPUT.  |
00680 `--------------------------------*/
00681 
00682 /*ARGSUSED*/
00683 #if (defined __STDC__ || defined __C99__FUNC__ \
00684      || defined __cplusplus || defined _MSC_VER)
00685 static void
00686 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
00687 #else
00688 static void
00689 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
00690     FILE *yyoutput;
00691     int yytype;
00692     YYSTYPE const * const yyvaluep;
00693 #endif
00694 {
00695   if (!yyvaluep)
00696     return;
00697 # ifdef YYPRINT
00698   if (yytype < YYNTOKENS)
00699     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00700 # else
00701   YYUSE (yyoutput);
00702 # endif
00703   switch (yytype)
00704     {
00705       default:
00706         break;
00707     }
00708 }
00709 
00710 
00711 /*--------------------------------.
00712 | Print this symbol on YYOUTPUT.  |
00713 `--------------------------------*/
00714 
00715 #if (defined __STDC__ || defined __C99__FUNC__ \
00716      || defined __cplusplus || defined _MSC_VER)
00717 static void
00718 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
00719 #else
00720 static void
00721 yy_symbol_print (yyoutput, yytype, yyvaluep)
00722     FILE *yyoutput;
00723     int yytype;
00724     YYSTYPE const * const yyvaluep;
00725 #endif
00726 {
00727   if (yytype < YYNTOKENS)
00728     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
00729   else
00730     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
00731 
00732   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
00733   YYFPRINTF (yyoutput, ")");
00734 }
00735 
00736 /*------------------------------------------------------------------.
00737 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
00738 | TOP (included).                                                   |
00739 `------------------------------------------------------------------*/
00740 
00741 #if (defined __STDC__ || defined __C99__FUNC__ \
00742      || defined __cplusplus || defined _MSC_VER)
00743 static void
00744 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
00745 #else
00746 static void
00747 yy_stack_print (bottom, top)
00748     yytype_int16 *bottom;
00749     yytype_int16 *top;
00750 #endif
00751 {
00752   YYFPRINTF (stderr, "Stack now");
00753   for (; bottom <= top; ++bottom)
00754     YYFPRINTF (stderr, " %d", *bottom);
00755   YYFPRINTF (stderr, "\n");
00756 }
00757 
00758 # define YY_STACK_PRINT(Bottom, Top)                            \
00759 do {                                                            \
00760   if (yydebug)                                                  \
00761     yy_stack_print ((Bottom), (Top));                           \
00762 } while (YYID (0))
00763 
00764 
00765 /*------------------------------------------------.
00766 | Report that the YYRULE is going to be reduced.  |
00767 `------------------------------------------------*/
00768 
00769 #if (defined __STDC__ || defined __C99__FUNC__ \
00770      || defined __cplusplus || defined _MSC_VER)
00771 static void
00772 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
00773 #else
00774 static void
00775 yy_reduce_print (yyvsp, yyrule)
00776     YYSTYPE *yyvsp;
00777     int yyrule;
00778 #endif
00779 {
00780   int yynrhs = yyr2[yyrule];
00781   int yyi;
00782   unsigned long int yylno = yyrline[yyrule];
00783   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
00784              yyrule - 1, yylno);
00785   /* The symbols being reduced.  */
00786   for (yyi = 0; yyi < yynrhs; yyi++)
00787     {
00788       fprintf (stderr, "   $%d = ", yyi + 1);
00789       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
00790                        &(yyvsp[(yyi + 1) - (yynrhs)])
00791                                        );
00792       fprintf (stderr, "\n");
00793     }
00794 }
00795 
00796 # define YY_REDUCE_PRINT(Rule)          \
00797 do {                                    \
00798   if (yydebug)                          \
00799     yy_reduce_print (yyvsp, Rule); \
00800 } while (YYID (0))
00801 
00802 /* Nonzero means print parse trace.  It is left uninitialized so that
00803    multiple parsers can coexist.  */
00804 int yydebug;
00805 #else /* !YYDEBUG */
00806 # define YYDPRINTF(Args)
00807 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
00808 # define YY_STACK_PRINT(Bottom, Top)
00809 # define YY_REDUCE_PRINT(Rule)
00810 #endif /* !YYDEBUG */
00811 
00812 
00813 /* YYINITDEPTH -- initial size of the parser's stacks.  */
00814 #ifndef YYINITDEPTH
00815 # define YYINITDEPTH 200
00816 #endif
00817 
00818 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
00819    if the built-in stack extension method is used).
00820 
00821    Do not make this value too large; the results are undefined if
00822    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
00823    evaluated with infinite-precision integer arithmetic.  */
00824 
00825 #ifndef YYMAXDEPTH
00826 # define YYMAXDEPTH 10000
00827 #endif
00828 
00829 
00830 
00831 #if YYERROR_VERBOSE
00832 
00833 # ifndef yystrlen
00834 #  if defined __GLIBC__ && defined _STRING_H
00835 #   define yystrlen strlen
00836 #  else
00837 /* Return the length of YYSTR.  */
00838 #if (defined __STDC__ || defined __C99__FUNC__ \
00839      || defined __cplusplus || defined _MSC_VER)
00840 static YYSIZE_T
00841 yystrlen (const char *yystr)
00842 #else
00843 static YYSIZE_T
00844 yystrlen (yystr)
00845     const char *yystr;
00846 #endif
00847 {
00848   YYSIZE_T yylen;
00849   for (yylen = 0; yystr[yylen]; yylen++)
00850     continue;
00851   return yylen;
00852 }
00853 #  endif
00854 # endif
00855 
00856 # ifndef yystpcpy
00857 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
00858 #   define yystpcpy stpcpy
00859 #  else
00860 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
00861    YYDEST.  */
00862 #if (defined __STDC__ || defined __C99__FUNC__ \
00863      || defined __cplusplus || defined _MSC_VER)
00864 static char *
00865 yystpcpy (char *yydest, const char *yysrc)
00866 #else
00867 static char *
00868 yystpcpy (yydest, yysrc)
00869     char *yydest;
00870     const char *yysrc;
00871 #endif
00872 {
00873   char *yyd = yydest;
00874   const char *yys = yysrc;
00875 
00876   while ((*yyd++ = *yys++) != '\0')
00877     continue;
00878 
00879   return yyd - 1;
00880 }
00881 #  endif
00882 # endif
00883 
00884 # ifndef yytnamerr
00885 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
00886    quotes and backslashes, so that it's suitable for yyerror.  The
00887    heuristic is that double-quoting is unnecessary unless the string
00888    contains an apostrophe, a comma, or backslash (other than
00889    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
00890    null, do not copy; instead, return the length of what the result
00891    would have been.  */
00892 static YYSIZE_T
00893 yytnamerr (char *yyres, const char *yystr)
00894 {
00895   if (*yystr == '"')
00896     {
00897       YYSIZE_T yyn = 0;
00898       char const *yyp = yystr;
00899 
00900       for (;;)
00901         switch (*++yyp)
00902           {
00903           case '\'':
00904           case ',':
00905             goto do_not_strip_quotes;
00906 
00907           case '\\':
00908             if (*++yyp != '\\')
00909               goto do_not_strip_quotes;
00910             /* Fall through.  */
00911           default:
00912             if (yyres)
00913               yyres[yyn] = *yyp;
00914             yyn++;
00915             break;
00916 
00917           case '"':
00918             if (yyres)
00919               yyres[yyn] = '\0';
00920             return yyn;
00921           }
00922     do_not_strip_quotes: ;
00923     }
00924 
00925   if (! yyres)
00926     return yystrlen (yystr);
00927 
00928   return yystpcpy (yyres, yystr) - yyres;
00929 }
00930 # endif
00931 
00932 /* Copy into YYRESULT an error message about the unexpected token
00933    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
00934    including the terminating null byte.  If YYRESULT is null, do not
00935    copy anything; just return the number of bytes that would be
00936    copied.  As a special case, return 0 if an ordinary "syntax error"
00937    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
00938    size calculation.  */
00939 static YYSIZE_T
00940 yysyntax_error (char *yyresult, int yystate, int yychar)
00941 {
00942   int yyn = yypact[yystate];
00943 
00944   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
00945     return 0;
00946   else
00947     {
00948       int yytype = YYTRANSLATE (yychar);
00949       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
00950       YYSIZE_T yysize = yysize0;
00951       YYSIZE_T yysize1;
00952       int yysize_overflow = 0;
00953       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
00954       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
00955       int yyx;
00956 
00957 # if 0
00958       /* This is so xgettext sees the translatable formats that are
00959          constructed on the fly.  */
00960       YY_("syntax error, unexpected %s");
00961       YY_("syntax error, unexpected %s, expecting %s");
00962       YY_("syntax error, unexpected %s, expecting %s or %s");
00963       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
00964       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
00965 # endif
00966       char *yyfmt;
00967       char const *yyf;
00968       static char const yyunexpected[] = "syntax error, unexpected %s";
00969       static char const yyexpecting[] = ", expecting %s";
00970       static char const yyor[] = " or %s";
00971       char yyformat[sizeof yyunexpected
00972                     + sizeof yyexpecting - 1
00973                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
00974                        * (sizeof yyor - 1))];
00975       char const *yyprefix = yyexpecting;
00976 
00977       /* Start YYX at -YYN if negative to avoid negative indexes in
00978          YYCHECK.  */
00979       int yyxbegin = yyn < 0 ? -yyn : 0;
00980 
00981       /* Stay within bounds of both yycheck and yytname.  */
00982       int yychecklim = YYLAST - yyn + 1;
00983       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
00984       int yycount = 1;
00985 
00986       yyarg[0] = yytname[yytype];
00987       yyfmt = yystpcpy (yyformat, yyunexpected);
00988 
00989       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
00990         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
00991           {
00992             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
00993               {
00994                 yycount = 1;
00995                 yysize = yysize0;
00996                 yyformat[sizeof yyunexpected - 1] = '\0';
00997                 break;
00998               }
00999             yyarg[yycount++] = yytname[yyx];
01000             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01001             yysize_overflow |= (yysize1 < yysize);
01002             yysize = yysize1;
01003             yyfmt = yystpcpy (yyfmt, yyprefix);
01004             yyprefix = yyor;
01005           }
01006 
01007       yyf = YY_(yyformat);
01008       yysize1 = yysize + yystrlen (yyf);
01009       yysize_overflow |= (yysize1 < yysize);
01010       yysize = yysize1;
01011 
01012       if (yysize_overflow)
01013         return YYSIZE_MAXIMUM;
01014 
01015       if (yyresult)
01016         {
01017           /* Avoid sprintf, as that infringes on the user's name space.
01018              Don't have undefined behavior even if the translation
01019              produced a string with the wrong number of "%s"s.  */
01020           char *yyp = yyresult;
01021           int yyi = 0;
01022           while ((*yyp = *yyf) != '\0')
01023             {
01024               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
01025                 {
01026                   yyp += yytnamerr (yyp, yyarg[yyi++]);
01027                   yyf += 2;
01028                 }
01029               else
01030                 {
01031                   yyp++;
01032                   yyf++;
01033                 }
01034             }
01035         }
01036       return yysize;
01037     }
01038 }
01039 #endif /* YYERROR_VERBOSE */
01040 
01041 
01042 /*-----------------------------------------------.
01043 | Release the memory associated to this symbol.  |
01044 `-----------------------------------------------*/
01045 
01046 /*ARGSUSED*/
01047 #if (defined __STDC__ || defined __C99__FUNC__ \
01048      || defined __cplusplus || defined _MSC_VER)
01049 static void
01050 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
01051 #else
01052 static void
01053 yydestruct (yymsg, yytype, yyvaluep)
01054     const char *yymsg;
01055     int yytype;
01056     YYSTYPE *yyvaluep;
01057 #endif
01058 {
01059   YYUSE (yyvaluep);
01060 
01061   if (!yymsg)
01062     yymsg = "Deleting";
01063   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01064 
01065   switch (yytype)
01066     {
01067 
01068       default:
01069         break;
01070     }
01071 }
01072 
01073 
01074 /* Prevent warnings from -Wmissing-prototypes.  */
01075 
01076 #ifdef YYPARSE_PARAM
01077 #if defined __STDC__ || defined __cplusplus
01078 int yyparse (void *YYPARSE_PARAM);
01079 #else
01080 int yyparse ();
01081 #endif
01082 #else /* ! YYPARSE_PARAM */
01083 #if defined __STDC__ || defined __cplusplus
01084 int yyparse (void);
01085 #else
01086 int yyparse ();
01087 #endif
01088 #endif /* ! YYPARSE_PARAM */
01089 
01090 
01091 
01092 
01093 
01094 
01095 /*----------.
01096 | yyparse.  |
01097 `----------*/
01098 
01099 #ifdef YYPARSE_PARAM
01100 #if (defined __STDC__ || defined __C99__FUNC__ \
01101      || defined __cplusplus || defined _MSC_VER)
01102 int
01103 yyparse (void *YYPARSE_PARAM)
01104 #else
01105 int
01106 yyparse (YYPARSE_PARAM)
01107     void *YYPARSE_PARAM;
01108 #endif
01109 #else /* ! YYPARSE_PARAM */
01110 #if (defined __STDC__ || defined __C99__FUNC__ \
01111      || defined __cplusplus || defined _MSC_VER)
01112 int
01113 yyparse (void)
01114 #else
01115 int
01116 yyparse ()
01117 
01118 #endif
01119 #endif
01120 {
01121   /* The look-ahead symbol.  */
01122 int yychar;
01123 
01124 /* The semantic value of the look-ahead symbol.  */
01125 YYSTYPE yylval;
01126 
01127 /* Number of syntax errors so far.  */
01128 int yynerrs;
01129 
01130   int yystate;
01131   int yyn;
01132   int yyresult;
01133   /* Number of tokens to shift before error messages enabled.  */
01134   int yyerrstatus;
01135   /* Look-ahead token as an internal (translated) token number.  */
01136   int yytoken = 0;
01137 #if YYERROR_VERBOSE
01138   /* Buffer for error messages, and its allocated size.  */
01139   char yymsgbuf[128];
01140   char *yymsg = yymsgbuf;
01141   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
01142 #endif
01143 
01144   /* Three stacks and their tools:
01145      `yyss': related to states,
01146      `yyvs': related to semantic values,
01147      `yyls': related to locations.
01148 
01149      Refer to the stacks thru separate pointers, to allow yyoverflow
01150      to reallocate them elsewhere.  */
01151 
01152   /* The state stack.  */
01153   yytype_int16 yyssa[YYINITDEPTH];
01154   yytype_int16 *yyss = yyssa;
01155   yytype_int16 *yyssp;
01156 
01157   /* The semantic value stack.  */
01158   YYSTYPE yyvsa[YYINITDEPTH];
01159   YYSTYPE *yyvs = yyvsa;
01160   YYSTYPE *yyvsp;
01161 
01162 
01163 
01164 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
01165 
01166   YYSIZE_T yystacksize = YYINITDEPTH;
01167 
01168   /* The variables used to return semantic value and location from the
01169      action routines.  */
01170   YYSTYPE yyval;
01171 
01172 
01173   /* The number of symbols on the RHS of the reduced rule.
01174      Keep to zero when no symbol should be popped.  */
01175   int yylen = 0;
01176 
01177   YYDPRINTF ((stderr, "Starting parse\n"));
01178 
01179   yystate = 0;
01180   yyerrstatus = 0;
01181   yynerrs = 0;
01182   yychar = YYEMPTY;             /* Cause a token to be read.  */
01183 
01184   /* Initialize stack pointers.
01185      Waste one element of value and location stack
01186      so that they stay on the same level as the state stack.
01187      The wasted elements are never initialized.  */
01188 
01189   yyssp = yyss;
01190   yyvsp = yyvs;
01191 
01192   goto yysetstate;
01193 
01194 /*------------------------------------------------------------.
01195 | yynewstate -- Push a new state, which is found in yystate.  |
01196 `------------------------------------------------------------*/
01197  yynewstate:
01198   /* In all cases, when you get here, the value and location stacks
01199      have just been pushed.  So pushing a state here evens the stacks.  */
01200   yyssp++;
01201 
01202  yysetstate:
01203   *yyssp = yystate;
01204 
01205   if (yyss + yystacksize - 1 <= yyssp)
01206     {
01207       /* Get the current used size of the three stacks, in elements.  */
01208       YYSIZE_T yysize = yyssp - yyss + 1;
01209 
01210 #ifdef yyoverflow
01211       {
01212         /* Give user a chance to reallocate the stack.  Use copies of
01213            these so that the &'s don't force the real ones into
01214            memory.  */
01215         YYSTYPE *yyvs1 = yyvs;
01216         yytype_int16 *yyss1 = yyss;
01217 
01218 
01219         /* Each stack pointer address is followed by the size of the
01220            data in use in that stack, in bytes.  This used to be a
01221            conditional around just the two extra args, but that might
01222            be undefined if yyoverflow is a macro.  */
01223         yyoverflow (YY_("memory exhausted"),
01224                     &yyss1, yysize * sizeof (*yyssp),
01225                     &yyvs1, yysize * sizeof (*yyvsp),
01226 
01227                     &yystacksize);
01228 
01229         yyss = yyss1;
01230         yyvs = yyvs1;
01231       }
01232 #else /* no yyoverflow */
01233 # ifndef YYSTACK_RELOCATE
01234       goto yyexhaustedlab;
01235 # else
01236       /* Extend the stack our own way.  */
01237       if (YYMAXDEPTH <= yystacksize)
01238         goto yyexhaustedlab;
01239       yystacksize *= 2;
01240       if (YYMAXDEPTH < yystacksize)
01241         yystacksize = YYMAXDEPTH;
01242 
01243       {
01244         yytype_int16 *yyss1 = yyss;
01245         union yyalloc *yyptr =
01246           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01247         if (! yyptr)
01248           goto yyexhaustedlab;
01249         YYSTACK_RELOCATE (yyss);
01250         YYSTACK_RELOCATE (yyvs);
01251 
01252 #  undef YYSTACK_RELOCATE
01253         if (yyss1 != yyssa)
01254           YYSTACK_FREE (yyss1);
01255       }
01256 # endif
01257 #endif /* no yyoverflow */
01258 
01259       yyssp = yyss + yysize - 1;
01260       yyvsp = yyvs + yysize - 1;
01261 
01262 
01263       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01264                   (unsigned long int) yystacksize));
01265 
01266       if (yyss + yystacksize - 1 <= yyssp)
01267         YYABORT;
01268     }
01269 
01270   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01271 
01272   goto yybackup;
01273 
01274 /*-----------.
01275 | yybackup.  |
01276 `-----------*/
01277 yybackup:
01278 
01279   /* Do appropriate processing given the current state.  Read a
01280      look-ahead token if we need one and don't already have one.  */
01281 
01282   /* First try to decide what to do without reference to look-ahead token.  */
01283   yyn = yypact[yystate];
01284   if (yyn == YYPACT_NINF)
01285     goto yydefault;
01286 
01287   /* Not known => get a look-ahead token if don't already have one.  */
01288 
01289   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
01290   if (yychar == YYEMPTY)
01291     {
01292       YYDPRINTF ((stderr, "Reading a token: "));
01293       yychar = YYLEX;
01294     }
01295 
01296   if (yychar <= YYEOF)
01297     {
01298       yychar = yytoken = YYEOF;
01299       YYDPRINTF ((stderr, "Now at end of input.\n"));
01300     }
01301   else
01302     {
01303       yytoken = YYTRANSLATE (yychar);
01304       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01305     }
01306 
01307   /* If the proper action on seeing token YYTOKEN is to reduce or to
01308      detect an error, take that action.  */
01309   yyn += yytoken;
01310   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01311     goto yydefault;
01312   yyn = yytable[yyn];
01313   if (yyn <= 0)
01314     {
01315       if (yyn == 0 || yyn == YYTABLE_NINF)
01316         goto yyerrlab;
01317       yyn = -yyn;
01318       goto yyreduce;
01319     }
01320 
01321   if (yyn == YYFINAL)
01322     YYACCEPT;
01323 
01324   /* Count tokens shifted since error; after three, turn off error
01325      status.  */
01326   if (yyerrstatus)
01327     yyerrstatus--;
01328 
01329   /* Shift the look-ahead token.  */
01330   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01331 
01332   /* Discard the shifted token unless it is eof.  */
01333   if (yychar != YYEOF)
01334     yychar = YYEMPTY;
01335 
01336   yystate = yyn;
01337   *++yyvsp = yylval;
01338 
01339   goto yynewstate;
01340 
01341 
01342 /*-----------------------------------------------------------.
01343 | yydefault -- do the default action for the current state.  |
01344 `-----------------------------------------------------------*/
01345 yydefault:
01346   yyn = yydefact[yystate];
01347   if (yyn == 0)
01348     goto yyerrlab;
01349   goto yyreduce;
01350 
01351 
01352 /*-----------------------------.
01353 | yyreduce -- Do a reduction.  |
01354 `-----------------------------*/
01355 yyreduce:
01356   /* yyn is the number of a rule to reduce with.  */
01357   yylen = yyr2[yyn];
01358 
01359   /* If YYLEN is nonzero, implement the default value of the action:
01360      `$$ = $1'.
01361 
01362      Otherwise, the following line sets YYVAL to garbage.
01363      This behavior is undocumented and Bison
01364      users should not rely upon it.  Assigning to YYVAL
01365      unconditionally makes the parser a bit smaller, and it avoids a
01366      GCC warning that YYVAL may be used uninitialized.  */
01367   yyval = yyvsp[1-yylen];
01368 
01369 
01370   YY_REDUCE_PRINT (yyn);
01371   switch (yyn)
01372     {
01373         case 2:
01374 
01375     {
01376           MifluzSearchInput* input = (MifluzSearchInput*)parm;
01377           (yyval.node) = 0;
01378           input->query = 0;
01379         }
01380     break;
01381 
01382   case 3:
01383 
01384     {
01385           MifluzSearchInput* input = (MifluzSearchInput*)parm;
01386           if((yyval.node) == 0) {
01387             /*
01388              * Single node is kept as is
01389              */
01390             (yyval.node) = (yyvsp[(2) - (2)].node);
01391           } else if((yyval.node)->IsA() == WORD_TREE_OR ||
01392                     (yyval.node)->IsA() == WORD_TREE_OPTIONAL) {
01393             /*
01394              * Additional nodes are pushed in OR or OPTIONAL because it exists.
01395              */
01396             WordTreeOperand* op_or = (WordTreeOperand*)(yyval.node);
01397             op_or->cursors = (WordTree**)realloc(op_or->cursors, sizeof(WordTree*) * (op_or->cursors_length + 1));
01398             op_or->cursors[op_or->cursors_length] = (yyvsp[(2) - (2)].node);
01399             op_or->cursors_length++;
01400             (yyval.node) = op_or;
01401           } else {
01402             /*
01403              * Additional node implies we build an OR or OPTIONAL node to hold
01404              * the node collection.
01405              */
01406             WordTreeOperand* op_or;
01407             if(input->or_method == WORD_SEARCH_OR)
01408               op_or = new WordTreeOr(input->words, "");
01409             else
01410               op_or = new WordTreeOptional(input->words, "");
01411             op_or->cursors = (WordTree**)malloc(sizeof(WordTree*) * 2);
01412             op_or->cursors_length = 2;
01413             op_or->cursors[0] = (yyval.node); /* The existing node */
01414             op_or->cursors[1] = (yyvsp[(2) - (2)].node); /* The new node */
01415             (yyval.node) = op_or;
01416           }
01417           input->query = (yyval.node);
01418         }
01419     break;
01420 
01421   case 5:
01422 
01423     {
01424           MifluzSearchInput* input = (MifluzSearchInput*)parm;
01425           WordTreeMandatory* mandatory = new WordTreeMandatory(input->words, "");
01426           mandatory->cursors = (WordTree**)malloc(sizeof(WordTree*));
01427           mandatory->cursors_length = 1;
01428           mandatory->cursors[0] = (yyvsp[(2) - (2)].node);
01429           (yyval.node) = mandatory;
01430         }
01431     break;
01432 
01433   case 6:
01434 
01435     {
01436           MifluzSearchInput* input = (MifluzSearchInput*)parm;
01437           WordTreeNot* op_not = new WordTreeNot(input->words, "");
01438           op_not->cursors = (WordTree**)malloc(sizeof(WordTree*));
01439           op_not->cursors_length = 1;
01440           op_not->cursors[0] = (yyvsp[(2) - (2)].node);
01441           (yyval.node) = op_not;
01442         }
01443     break;
01444 
01445   case 9:
01446 
01447     {
01448           MifluzSearchInput* input = (MifluzSearchInput*)parm;
01449           if((yyvsp[(2) - (3)].list)->values_length == 1)
01450             (yyval.node) = (yyvsp[(2) - (3)].list)->values[0];
01451           else {
01452             WordTreeNear* near = new WordTreeNear(input->words, "");
01453             near->cursors = (yyvsp[(2) - (3)].list)->values;
01454             near->cursors_length = (yyvsp[(2) - (3)].list)->values_length;
01455             near->proximity = 1;
01456             (yyval.node) = near;
01457           }
01458         }
01459     break;
01460 
01461   case 10:
01462 
01463     {
01464           (yyval.list) = new WordTreeList((yyvsp[(1) - (1)].node));
01465         }
01466     break;
01467 
01468   case 11:
01469 
01470     {
01471           (yyvsp[(1) - (2)].list)->Push((yyvsp[(2) - (2)].node));
01472           (yyval.list) = (yyvsp[(1) - (2)].list);
01473         }
01474     break;
01475 
01476 
01477 /* Line 1267 of yacc.c.  */
01478 
01479       default: break;
01480     }
01481   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
01482 
01483   YYPOPSTACK (yylen);
01484   yylen = 0;
01485   YY_STACK_PRINT (yyss, yyssp);
01486 
01487   *++yyvsp = yyval;
01488 
01489 
01490   /* Now `shift' the result of the reduction.  Determine what state
01491      that goes to, based on the state we popped back to and the rule
01492      number reduced by.  */
01493 
01494   yyn = yyr1[yyn];
01495 
01496   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
01497   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01498     yystate = yytable[yystate];
01499   else
01500     yystate = yydefgoto[yyn - YYNTOKENS];
01501 
01502   goto yynewstate;
01503 
01504 
01505 /*------------------------------------.
01506 | yyerrlab -- here on detecting error |
01507 `------------------------------------*/
01508 yyerrlab:
01509   /* If not already recovering from an error, report this error.  */
01510   if (!yyerrstatus)
01511     {
01512       ++yynerrs;
01513 #if ! YYERROR_VERBOSE
01514       yyerror (YY_("syntax error"));
01515 #else
01516       {
01517         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
01518         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
01519           {
01520             YYSIZE_T yyalloc = 2 * yysize;
01521             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
01522               yyalloc = YYSTACK_ALLOC_MAXIMUM;
01523             if (yymsg != yymsgbuf)
01524               YYSTACK_FREE (yymsg);
01525             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
01526             if (yymsg)
01527               yymsg_alloc = yyalloc;
01528             else
01529               {
01530                 yymsg = yymsgbuf;
01531                 yymsg_alloc = sizeof yymsgbuf;
01532               }
01533           }
01534 
01535         if (0 < yysize && yysize <= yymsg_alloc)
01536           {
01537             (void) yysyntax_error (yymsg, yystate, yychar);
01538             yyerror (yymsg);
01539           }
01540         else
01541           {
01542             yyerror (YY_("syntax error"));
01543             if (yysize != 0)
01544               goto yyexhaustedlab;
01545           }
01546       }
01547 #endif
01548     }
01549 
01550 
01551 
01552   if (yyerrstatus == 3)
01553     {
01554       /* If just tried and failed to reuse look-ahead token after an
01555          error, discard it.  */
01556 
01557       if (yychar <= YYEOF)
01558         {
01559           /* Return failure if at end of input.  */
01560           if (yychar == YYEOF)
01561             YYABORT;
01562         }
01563       else
01564         {
01565           yydestruct ("Error: discarding",
01566                       yytoken, &yylval);
01567           yychar = YYEMPTY;
01568         }
01569     }
01570 
01571   /* Else will try to reuse look-ahead token after shifting the error
01572      token.  */
01573   goto yyerrlab1;
01574 
01575 
01576 /*---------------------------------------------------.
01577 | yyerrorlab -- error raised explicitly by YYERROR.  |
01578 `---------------------------------------------------*/
01579 yyerrorlab:
01580 
01581   /* Pacify compilers like GCC when the user code never invokes
01582      YYERROR and the label yyerrorlab therefore never appears in user
01583      code.  */
01584   if (/*CONSTCOND*/ 0)
01585      goto yyerrorlab;
01586 
01587   /* Do not reclaim the symbols of the rule which action triggered
01588      this YYERROR.  */
01589   YYPOPSTACK (yylen);
01590   yylen = 0;
01591   YY_STACK_PRINT (yyss, yyssp);
01592   yystate = *yyssp;
01593   goto yyerrlab1;
01594 
01595 
01596 /*-------------------------------------------------------------.
01597 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
01598 `-------------------------------------------------------------*/
01599 yyerrlab1:
01600   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
01601 
01602   for (;;)
01603     {
01604       yyn = yypact[yystate];
01605       if (yyn != YYPACT_NINF)
01606         {
01607           yyn += YYTERROR;
01608           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
01609             {
01610               yyn = yytable[yyn];
01611               if (0 < yyn)
01612                 break;
01613             }
01614         }
01615 
01616       /* Pop the current state because it cannot handle the error token.  */
01617       if (yyssp == yyss)
01618         YYABORT;
01619 
01620 
01621       yydestruct ("Error: popping",
01622                   yystos[yystate], yyvsp);
01623       YYPOPSTACK (1);
01624       yystate = *yyssp;
01625       YY_STACK_PRINT (yyss, yyssp);
01626     }
01627 
01628   if (yyn == YYFINAL)
01629     YYACCEPT;
01630 
01631   *++yyvsp = yylval;
01632 
01633 
01634   /* Shift the error token.  */
01635   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
01636 
01637   yystate = yyn;
01638   goto yynewstate;
01639 
01640 
01641 /*-------------------------------------.
01642 | yyacceptlab -- YYACCEPT comes here.  |
01643 `-------------------------------------*/
01644 yyacceptlab:
01645   yyresult = 0;
01646   goto yyreturn;
01647 
01648 /*-----------------------------------.
01649 | yyabortlab -- YYABORT comes here.  |
01650 `-----------------------------------*/
01651 yyabortlab:
01652   yyresult = 1;
01653   goto yyreturn;
01654 
01655 #ifndef yyoverflow
01656 /*-------------------------------------------------.
01657 | yyexhaustedlab -- memory exhaustion comes here.  |
01658 `-------------------------------------------------*/
01659 yyexhaustedlab:
01660   yyerror (YY_("memory exhausted"));
01661   yyresult = 2;
01662   /* Fall through.  */
01663 #endif
01664 
01665 yyreturn:
01666   if (yychar != YYEOF && yychar != YYEMPTY)
01667      yydestruct ("Cleanup: discarding lookahead",
01668                  yytoken, &yylval);
01669   /* Do not reclaim the symbols of the rule which action triggered
01670      this YYABORT or YYACCEPT.  */
01671   YYPOPSTACK (yylen);
01672   YY_STACK_PRINT (yyss, yyssp);
01673   while (yyssp != yyss)
01674     {
01675       yydestruct ("Cleanup: popping",
01676                   yystos[*yyssp], yyvsp);
01677       YYPOPSTACK (1);
01678     }
01679 #ifndef yyoverflow
01680   if (yyss != yyssa)
01681     YYSTACK_FREE (yyss);
01682 #endif
01683 #if YYERROR_VERBOSE
01684   if (yymsg != yymsgbuf)
01685     YYSTACK_FREE (yymsg);
01686 #endif
01687   /* Make sure YYID is used.  */
01688   return YYID (yyresult);
01689 }
01690 
01691 
01692 
01693 
01694 
01695 #include <ctype.h>
01696 
01697 static int search_lex(YYSTYPE *lvalp, void* inputp)
01698 {
01699   MifluzSearchInput* input = (MifluzSearchInput*)inputp;
01700   char* word = 0;
01701   int word_length = 0;
01702   int& pointer = input->pointer;
01703   char*& buffer = input->buffer;
01704   int& buffer_length = input->buffer_length;
01705   WordTree*& literal = lvalp->node;
01706   literal = 0;
01707 
01708   while(pointer < buffer_length) {
01709     switch(buffer[pointer]) {
01710     case '"':
01711     case '+':
01712     case '-':
01713       return buffer[pointer++];
01714       break;
01715     default:
01716       if(isalnum(buffer[pointer])) {
01717         word = buffer + pointer;
01718         while(pointer < buffer_length && isalnum(buffer[pointer]) && word_length < input->maximum_word_length) {
01719           buffer[pointer] = tolower(buffer[pointer]);
01720           word_length++;
01721           pointer++;
01722         }
01723         /*
01724          * Truncate words whose length is greater than maximum_word_length.
01725          */
01726         while(pointer < buffer_length && isalnum(buffer[pointer]))
01727           pointer++;
01728         
01729         input->words_verbatim.Add(new String(word, word_length));
01730         char* word_unaccent = 0;
01731         size_t word_unaccent_length = 0;
01732         if(unac_string(input->charset, word, word_length, &word_unaccent, &word_unaccent_length) == -1) {
01733           fprintf(stderr, "search_lex: unaccent failed");
01734           perror("");
01735           return EOF;
01736         }
01737         input->words_unaccent.Add(new String(word_unaccent, word_unaccent_length));
01738         literal = new WordTreeLiteral(input->words, word_unaccent, word_unaccent_length, "");
01739         free(word_unaccent);
01740         return T_WORD;
01741       } else
01742         pointer++;
01743     }
01744   }
01745 
01746   return 0;
01747 }
01748 
01749 static int search_error(char* message)
01750 {
01751   fprintf(stderr, "search_parser: %s\n", message);
01752   return 0;
01753 }
01754 
01755 /*
01756  Local Variables: ***
01757  mode: C ***
01758  End: ***
01759 */
01760 

Generated on Sun Jun 8 10:56:40 2008 for GNUmifluz by  doxygen 1.5.5