Show
Ignore:
Timestamp:
13.07.2000 10:21:53 (20 years ago)
Author:
sjboddie
Message:

merged changes to trunk into New_Config_Format branch

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • branches/New_Config_Format-branch/gsdl/packages/mg/src/text/bool_parser.c

    r531 r1279  
    1 #ifndef lint 
    2 static char yysccsid[] = "@(#)yaccpar   1.9 (Berkeley) 02/21/93"; 
    3 #endif 
    4 #define YYBYACC 1 
    5 #define YYMAJOR 1 
    6 #define YYMINOR 9 
    7 #define yyclearin (yychar=(-1)) 
    8 #define yyerrok (yyerrflag=0) 
    9 #define YYRECOVERING (yyerrflag!=0) 
    10 #define YYPREFIX "yy" 
    11 #line 25 "bool_parser.y" 
     1 
     2/*  A Bison parser, made from bool_parser.y 
     3 by  GNU Bison version 1.27 
     4  */ 
     5 
     6#define YYBISON 1  /* Identify Bison output.  */ 
     7 
     8#define TERM    257 
     9 
     10#line 24 "bool_parser.y" 
     11 
    1212  
    1313#include "sysfuncs.h" 
     
    4848static u_long invf_ptr; 
    4949static u_long invf_len; 
    50 #line 65 "bool_parser.y" 
     50 
     51#line 66 "bool_parser.y" 
    5152typedef union { 
    5253  char *text; 
    5354  bool_tree_node *node; 
    5455} YYSTYPE; 
    55 #line 55 "y.tab.c" 
    56 #define TERM 257 
    57 #define YYERRCODE 256 
    58 short yylhs[] = {                                        -1, 
    59     0,    1,    1,    1,    1,    2,    2,    3,    3,    3, 
    60     4,    4, 
    61 }; 
    62 short yylen[] = {                                         2, 
    63     1,    1,    3,    1,    1,    1,    2,    3,    2,    1, 
    64     3,    1, 
    65 }; 
    66 short yydefred[] = {                                      0, 
    67     2,    0,    4,    5,    0,    0,    6,   10,    0,    0, 
    68     0,    7,    0,    9,    0,    3,    8,    0, 
    69 }; 
    70 short yydgoto[] = {                                       6, 
    71     7,    8,    9,   10, 
    72 }; 
    73 short yysindex[] = {                                    -32, 
    74     0,  -32,    0,    0,  -32,    0,    0,    0,  -33, -118, 
    75   -37,    0,  -32,    0,  -32,    0,    0,  -33, 
    76 }; 
    77 short yyrindex[] = {                                      0, 
    78     0,    0,    0,    0,    0,    0,    0,    0,    2,   12, 
    79     0,    0,    0,    0,    0,    0,    0,    3, 
    80 }; 
    81 short yygindex[] = {                                      0, 
    82     0,    6,   -2,   14, 
    83 }; 
    84 #define YYTABLESIZE 225 
    85 short yytable[] = {                                       5, 
    86     5,   12,   11,   16,   13,   15,    2,    2,    3,    3, 
    87    12,    1,   18,    0,   14,   11,    0,    0,   17,    0, 
    88     0,    0,    0,   14,    0,    0,    0,    0,    0,    0, 
    89     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    90     0,    0,   12,   11,    0,    0,    0,    0,    0,    0, 
    91     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    92     0,    4,    4,    0,    0,    0,    0,    0,    0,    0, 
    93     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    94     0,    0,    0,    0,    0,    0,   15,    0,    0,    0, 
    95     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    96     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    97     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    98     0,    0,    0,    0,    0,   12,   11,    0,    0,    0, 
    99     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    100     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    101     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    102     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    103     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    104     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    105     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    106     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    107     0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
    108     0,    0,    0,    1,    1, 
    109 }; 
    110 short yycheck[] = {                                      33, 
    111    33,    0,    0,   41,   38,  124,   40,   40,   42,   42, 
    112     5,    0,   15,   -1,    9,    2,   -1,   -1,   13,   -1, 
    113    -1,   -1,   -1,   18,   -1,   -1,   -1,   -1,   -1,   -1, 
    114    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    115    -1,   -1,   41,   41,   -1,   -1,   -1,   -1,   -1,   -1, 
    116    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    117    -1,   95,   95,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    118    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    119    -1,   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1, 
    120    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    121    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    122    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    123    -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,   -1, 
    124    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    125    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    126    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    127    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    128    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    129    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    130    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    131    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    132    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
    133    -1,   -1,   -1,  257,  257, 
    134 }; 
    135 #define YYFINAL 6 
    136 #ifndef YYDEBUG 
    137 #define YYDEBUG 0 
    138 #endif 
    139 #define YYMAXTOKEN 257 
    140 #if YYDEBUG 
    141 char *yyname[] = { 
    142 "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
    143 "'!'",0,0,0,0,"'&'",0,"'('","')'","'*'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
    144 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'_'",0,0,0,0,0, 
    145 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
    146 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
    147 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
    148 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
    149 "TERM", 
    150 }; 
    151 char *yyrule[] = { 
    152 "$accept : query", 
    153 "query : or", 
    154 "term : TERM", 
    155 "term : '(' or ')'", 
    156 "term : '*'", 
    157 "term : '_'", 
    158 "not : term", 
    159 "not : '!' not", 
    160 "and : and '&' not", 
    161 "and : and not", 
    162 "and : not", 
    163 "or : or '|' and", 
    164 "or : and", 
    165 }; 
    166 #endif 
    167 #ifdef YYSTACKSIZE 
     56#include <stdio.h> 
     57 
     58#ifndef __cplusplus 
     59#ifndef __STDC__ 
     60#define const 
     61#endif 
     62#endif 
     63 
     64 
     65 
     66#define YYFINAL     20 
     67#define YYFLAG      -32768 
     68#define YYNTBASE    11 
     69 
     70#define YYTRANSLATE(x) ((unsigned)(x) <= 257 ? yytranslate[x] : 16) 
     71 
     72static const char yytranslate[] = {     0, 
     73     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     74     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     75     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     76     2,     2,     8,     2,     2,     2,     2,     9,     2,     4, 
     77     5,     6,     2,     2,     2,     2,     2,     2,     2,     2, 
     78     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     79     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     80     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     81     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     82     2,     2,     2,     2,     7,     2,     2,     2,     2,     2, 
     83     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     84     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     85     2,     2,     2,    10,     2,     2,     2,     2,     2,     2, 
     86     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     87     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     88     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     89     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     90     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     91     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     92     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     93     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     94     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     95     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     96     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     97     2,     2,     2,     2,     2,     2,     2,     2,     2,     2, 
     98     2,     2,     2,     2,     2,     1,     3 
     99}; 
     100 
     101#if YYDEBUG != 0 
     102static const short yyprhs[] = {     0, 
     103     0,     2,     4,     8,    10,    12,    14,    17,    21,    24, 
     104    26,    30 
     105}; 
     106 
     107static const short yyrhs[] = {    15, 
     108     0,     3,     0,     4,    15,     5,     0,     6,     0,     7, 
     109     0,    12,     0,     8,    13,     0,    14,     9,    13,     0, 
     110    14,    13,     0,    13,     0,    15,    10,    14,     0,    14, 
     111     0 
     112}; 
     113 
     114#endif 
     115 
     116#if YYDEBUG != 0 
     117static const short yyrline[] = { 0, 
     118    76,    80,    81,    82,    83,    86,    87,    90,    91,    92, 
     119    95,    96 
     120}; 
     121#endif 
     122 
     123 
     124#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) 
     125 
     126static const char * const yytname[] = {   "$","error","$undefined.","TERM","'('", 
     127"')'","'*'","'_'","'!'","'&'","'|'","query","term","not","and","or", NULL 
     128}; 
     129#endif 
     130 
     131static const short yyr1[] = {     0, 
     132    11,    12,    12,    12,    12,    13,    13,    14,    14,    14, 
     133    15,    15 
     134}; 
     135 
     136static const short yyr2[] = {     0, 
     137     1,     1,     3,     1,     1,     1,     2,     3,     2,     1, 
     138     3,     1 
     139}; 
     140 
     141static const short yydefact[] = {     0, 
     142     2,     0,     4,     5,     0,     6,    10,    12,     1,     0, 
     143     7,     0,     9,     0,     3,     8,    11,     0,     0,     0 
     144}; 
     145 
     146static const short yydefgoto[] = {    18, 
     147     6,     7,     8,     9 
     148}; 
     149 
     150static const short yypact[] = {    10, 
     151-32768,    10,-32768,-32768,    10,-32768,-32768,     2,    -9,    14, 
     152-32768,    10,-32768,    10,-32768,-32768,     2,     4,    15,-32768 
     153}; 
     154 
     155static const short yypgoto[] = {-32768, 
     156-32768,    -5,   -12,    18 
     157}; 
     158 
     159 
     160#define YYLAST      24 
     161 
     162 
     163static const short yytable[] = {    11, 
     164    14,    17,    13,    19,     1,     2,    16,     3,     4,     5, 
     165    12,    13,     1,     2,    20,     3,     4,     5,    15,    10, 
     166     0,     0,     0,    14 
     167}; 
     168 
     169static const short yycheck[] = {     5, 
     170    10,    14,     8,     0,     3,     4,    12,     6,     7,     8, 
     171     9,    17,     3,     4,     0,     6,     7,     8,     5,     2, 
     172    -1,    -1,    -1,    10 
     173}; 
     174/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */ 
     175#line 3 "/usr/share/bison.simple" 
     176/* This file comes from bison-1.27.  */ 
     177 
     178/* Skeleton output parser for bison, 
     179   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. 
     180 
     181   This program is free software; you can redistribute it and/or modify 
     182   it under the terms of the GNU General Public License as published by 
     183   the Free Software Foundation; either version 2, or (at your option) 
     184   any later version. 
     185 
     186   This program is distributed in the hope that it will be useful, 
     187   but WITHOUT ANY WARRANTY; without even the implied warranty of 
     188   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     189   GNU General Public License for more details. 
     190 
     191   You should have received a copy of the GNU General Public License 
     192   along with this program; if not, write to the Free Software 
     193   Foundation, Inc., 59 Temple Place - Suite 330, 
     194   Boston, MA 02111-1307, USA.  */ 
     195 
     196/* As a special exception, when this file is copied by Bison into a 
     197   Bison output file, you may use that output file without restriction. 
     198   This special exception was added by the Free Software Foundation 
     199   in version 1.24 of Bison.  */ 
     200 
     201/* This is the parser code that is written into each bison parser 
     202  when the %semantic_parser declaration is not specified in the grammar. 
     203  It was written by Richard Stallman by simplifying the hairy parser 
     204  used when %semantic_parser is specified.  */ 
     205 
     206#ifndef YYSTACK_USE_ALLOCA 
     207#ifdef alloca 
     208#define YYSTACK_USE_ALLOCA 
     209#else /* alloca not defined */ 
     210#ifdef __GNUC__ 
     211#define YYSTACK_USE_ALLOCA 
     212#define alloca __builtin_alloca 
     213#else /* not GNU C.  */ 
     214#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) 
     215#define YYSTACK_USE_ALLOCA 
     216#include <alloca.h> 
     217#else /* not sparc */ 
     218/* We think this test detects Watcom and Microsoft C.  */ 
     219/* This used to test MSDOS, but that is a bad idea 
     220   since that symbol is in the user namespace.  */ 
     221#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) 
     222#if 0 /* No need for malloc.h, which pollutes the namespace; 
     223     instead, just don't use alloca.  */ 
     224#include <malloc.h> 
     225#endif 
     226#else /* not MSDOS, or __TURBOC__ */ 
     227#if defined(_AIX) 
     228/* I don't know what this was needed for, but it pollutes the namespace. 
     229   So I turned it off.   rms, 2 May 1997.  */ 
     230/* #include <malloc.h>  */ 
     231 #pragma alloca 
     232#define YYSTACK_USE_ALLOCA 
     233#else /* not MSDOS, or __TURBOC__, or _AIX */ 
     234#if 0 
     235#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, 
     236         and on HPUX 10.  Eventually we can turn this on.  */ 
     237#define YYSTACK_USE_ALLOCA 
     238#define alloca __builtin_alloca 
     239#endif /* __hpux */ 
     240#endif 
     241#endif /* not _AIX */ 
     242#endif /* not MSDOS, or __TURBOC__ */ 
     243#endif /* not sparc */ 
     244#endif /* not GNU C */ 
     245#endif /* alloca not defined */ 
     246#endif /* YYSTACK_USE_ALLOCA not defined */ 
     247 
     248#ifdef YYSTACK_USE_ALLOCA 
     249#define YYSTACK_ALLOC alloca 
     250#else 
     251#define YYSTACK_ALLOC malloc 
     252#endif 
     253 
     254/* Note: there must be only one dollar sign in this file. 
     255   It is replaced by the list of actions, each action 
     256   as one case of the switch.  */ 
     257 
     258#define yyerrok     (yyerrstatus = 0) 
     259#define yyclearin   (yychar = YYEMPTY) 
     260#define YYEMPTY     -2 
     261#define YYEOF       0 
     262#define YYACCEPT    goto yyacceptlab 
     263#define YYABORT     goto yyabortlab 
     264#define YYERROR     goto yyerrlab1 
     265/* Like YYERROR except do call yyerror. 
     266   This remains here temporarily to ease the 
     267   transition to the new meaning of YYERROR, for GCC. 
     268   Once GCC version 2 has supplanted version 1, this can go.  */ 
     269#define YYFAIL      goto yyerrlab 
     270#define YYRECOVERING()  (!!yyerrstatus) 
     271#define YYBACKUP(token, value) \ 
     272do                              \ 
     273  if (yychar == YYEMPTY && yylen == 1)              \ 
     274    { yychar = (token), yylval = (value);           \ 
     275      yychar1 = YYTRANSLATE (yychar);               \ 
     276      YYPOPSTACK;                       \ 
     277      goto yybackup;                        \ 
     278    }                               \ 
     279  else                              \ 
     280    { yyerror ("syntax error: cannot back up"); YYERROR; }  \ 
     281while (0) 
     282 
     283#define YYTERROR    1 
     284#define YYERRCODE   256 
     285 
     286#ifndef YYPURE 
     287#define YYLEX       yylex() 
     288#endif 
     289 
     290#ifdef YYPURE 
     291#ifdef YYLSP_NEEDED 
     292#ifdef YYLEX_PARAM 
     293#define YYLEX       yylex(&yylval, &yylloc, YYLEX_PARAM) 
     294#else 
     295#define YYLEX       yylex(&yylval, &yylloc) 
     296#endif 
     297#else /* not YYLSP_NEEDED */ 
     298#ifdef YYLEX_PARAM 
     299#define YYLEX       yylex(&yylval, YYLEX_PARAM) 
     300#else 
     301#define YYLEX       yylex(&yylval) 
     302#endif 
     303#endif /* not YYLSP_NEEDED */ 
     304#endif 
     305 
     306/* If nonreentrant, generate the variables here */ 
     307 
     308#ifndef YYPURE 
     309 
     310int yychar;         /*  the lookahead symbol        */ 
     311YYSTYPE yylval;         /*  the semantic value of the       */ 
     312                /*  lookahead symbol            */ 
     313 
     314#ifdef YYLSP_NEEDED 
     315YYLTYPE yylloc;         /*  location data for the lookahead */ 
     316                /*  symbol              */ 
     317#endif 
     318 
     319int yynerrs;            /*  number of parse errors so far       */ 
     320#endif  /* not YYPURE */ 
     321 
     322#if YYDEBUG != 0 
     323int yydebug;            /*  nonzero means print parse trace */ 
     324/* Since this is uninitialized, it does not stop multiple parsers 
     325   from coexisting.  */ 
     326#endif 
     327 
     328/*  YYINITDEPTH indicates the initial size of the parser's stacks   */ 
     329 
     330#ifndef YYINITDEPTH 
     331#define YYINITDEPTH 200 
     332#endif 
     333 
     334/*  YYMAXDEPTH is the maximum size the stacks can grow to 
     335    (effective only if the built-in stack extension method is used).  */ 
     336 
     337#if YYMAXDEPTH == 0 
    168338#undef YYMAXDEPTH 
    169 #define YYMAXDEPTH YYSTACKSIZE 
     339#endif 
     340 
     341#ifndef YYMAXDEPTH 
     342#define YYMAXDEPTH 10000 
     343#endif 
     344 
     345/* Define __yy_memcpy.  Note that the size argument 
     346   should be passed with type unsigned int, because that is what the non-GCC 
     347   definitions require.  With GCC, __builtin_memcpy takes an arg 
     348   of type size_t, but it can handle unsigned int.  */ 
     349 
     350#if __GNUC__ > 1        /* GNU C and GNU C++ define this.  */ 
     351#define __yy_memcpy(TO,FROM,COUNT)  __builtin_memcpy(TO,FROM,COUNT) 
     352#else               /* not GNU C or C++ */ 
     353#ifndef __cplusplus 
     354 
     355/* This is the most reliable way to avoid incompatibilities 
     356   in available built-in functions on various systems.  */ 
     357static void 
     358__yy_memcpy (to, from, count) 
     359     char *to; 
     360     char *from; 
     361     unsigned int count; 
     362{ 
     363  register char *f = from; 
     364  register char *t = to; 
     365  register int i = count; 
     366 
     367  while (i-- > 0) 
     368    *t++ = *f++; 
     369} 
     370 
     371#else /* __cplusplus */ 
     372 
     373/* This is the most reliable way to avoid incompatibilities 
     374   in available built-in functions on various systems.  */ 
     375static void 
     376__yy_memcpy (char *to, char *from, unsigned int count) 
     377{ 
     378  register char *t = to; 
     379  register char *f = from; 
     380  register int i = count; 
     381 
     382  while (i-- > 0) 
     383    *t++ = *f++; 
     384} 
     385 
     386#endif 
     387#endif 
     388 
     389#line 216 "/usr/share/bison.simple" 
     390 
     391/* The user can define YYPARSE_PARAM as the name of an argument to be passed 
     392   into yyparse.  The argument should have type void *. 
     393   It should actually point to an object. 
     394   Grammar actions can access the variable by casting it 
     395   to the proper pointer type.  */ 
     396 
     397#ifdef YYPARSE_PARAM 
     398#ifdef __cplusplus 
     399#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM 
     400#define YYPARSE_PARAM_DECL 
     401#else /* not __cplusplus */ 
     402#define YYPARSE_PARAM_ARG YYPARSE_PARAM 
     403#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; 
     404#endif /* not __cplusplus */ 
     405#else /* not YYPARSE_PARAM */ 
     406#define YYPARSE_PARAM_ARG 
     407#define YYPARSE_PARAM_DECL 
     408#endif /* not YYPARSE_PARAM */ 
     409 
     410/* Prevent warning if -Wstrict-prototypes.  */ 
     411#ifdef __GNUC__ 
     412#ifdef YYPARSE_PARAM 
     413int yyparse (void *); 
    170414#else 
    171 #ifdef YYMAXDEPTH 
    172 #define YYSTACKSIZE YYMAXDEPTH 
     415int yyparse (void); 
     416#endif 
     417#endif 
     418 
     419int 
     420yyparse(YYPARSE_PARAM_ARG) 
     421     YYPARSE_PARAM_DECL 
     422{ 
     423  register int yystate; 
     424  register int yyn; 
     425  register short *yyssp; 
     426  register YYSTYPE *yyvsp; 
     427  int yyerrstatus;  /*  number of tokens to shift before error messages enabled */ 
     428  int yychar1 = 0;      /*  lookahead token as an internal (translated) token number */ 
     429 
     430  short yyssa[YYINITDEPTH]; /*  the state stack         */ 
     431  YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack        */ 
     432 
     433  short *yyss = yyssa;      /*  refer to the stacks thru separate pointers */ 
     434  YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */ 
     435 
     436#ifdef YYLSP_NEEDED 
     437  YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack          */ 
     438  YYLTYPE *yyls = yylsa; 
     439  YYLTYPE *yylsp; 
     440 
     441#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--) 
    173442#else 
    174 #define YYSTACKSIZE 500 
    175 #define YYMAXDEPTH 500 
    176 #endif 
    177 #endif 
    178 int yydebug; 
    179 int yynerrs; 
    180 int yyerrflag; 
    181 int yychar; 
    182 short *yyssp; 
    183 YYSTYPE *yyvsp; 
    184 YYSTYPE yyval; 
    185 YYSTYPE yylval; 
    186 short yyss[YYSTACKSIZE]; 
    187 YYSTYPE yyvs[YYSTACKSIZE]; 
    188 #define yystacksize YYSTACKSIZE 
     443#define YYPOPSTACK   (yyvsp--, yyssp--) 
     444#endif 
     445 
     446  int yystacksize = YYINITDEPTH; 
     447  int yyfree_stacks = 0; 
     448 
     449#ifdef YYPURE 
     450  int yychar; 
     451  YYSTYPE yylval; 
     452  int yynerrs; 
     453#ifdef YYLSP_NEEDED 
     454  YYLTYPE yylloc; 
     455#endif 
     456#endif 
     457 
     458  YYSTYPE yyval;        /*  the variable used to return     */ 
     459                /*  semantic values from the action */ 
     460                /*  routines                */ 
     461 
     462  int yylen; 
     463 
     464#if YYDEBUG != 0 
     465  if (yydebug) 
     466    fprintf(stderr, "Starting parse\n"); 
     467#endif 
     468 
     469  yystate = 0; 
     470  yyerrstatus = 0; 
     471  yynerrs = 0; 
     472  yychar = YYEMPTY;     /* Cause a token to be read.  */ 
     473 
     474  /* Initialize stack pointers. 
     475     Waste one element of value and location stack 
     476     so that they stay on the same level as the state stack. 
     477     The wasted elements are never initialized.  */ 
     478 
     479  yyssp = yyss - 1; 
     480  yyvsp = yyvs; 
     481#ifdef YYLSP_NEEDED 
     482  yylsp = yyls; 
     483#endif 
     484 
     485/* Push a new state, which is found in  yystate  .  */ 
     486/* In all cases, when you get here, the value and location stacks 
     487   have just been pushed. so pushing a state here evens the stacks.  */ 
     488yynewstate: 
     489 
     490  *++yyssp = yystate; 
     491 
     492  if (yyssp >= yyss + yystacksize - 1) 
     493    { 
     494      /* Give user a chance to reallocate the stack */ 
     495      /* Use copies of these so that the &'s don't force the real ones into memory. */ 
     496      YYSTYPE *yyvs1 = yyvs; 
     497      short *yyss1 = yyss; 
     498#ifdef YYLSP_NEEDED 
     499      YYLTYPE *yyls1 = yyls; 
     500#endif 
     501 
     502      /* Get the current used size of the three stacks, in elements.  */ 
     503      int size = yyssp - yyss + 1; 
     504 
     505#ifdef yyoverflow 
     506      /* Each stack pointer address is followed by the size of 
     507     the data in use in that stack, in bytes.  */ 
     508#ifdef YYLSP_NEEDED 
     509      /* This used to be a conditional around just the two extra args, 
     510     but that might be undefined if yyoverflow is a macro.  */ 
     511      yyoverflow("parser stack overflow", 
     512         &yyss1, size * sizeof (*yyssp), 
     513         &yyvs1, size * sizeof (*yyvsp), 
     514         &yyls1, size * sizeof (*yylsp), 
     515         &yystacksize); 
     516#else 
     517      yyoverflow("parser stack overflow", 
     518         &yyss1, size * sizeof (*yyssp), 
     519         &yyvs1, size * sizeof (*yyvsp), 
     520         &yystacksize); 
     521#endif 
     522 
     523      yyss = yyss1; yyvs = yyvs1; 
     524#ifdef YYLSP_NEEDED 
     525      yyls = yyls1; 
     526#endif 
     527#else /* no yyoverflow */ 
     528      /* Extend the stack our own way.  */ 
     529      if (yystacksize >= YYMAXDEPTH) 
     530    { 
     531      yyerror("parser stack overflow"); 
     532      if (yyfree_stacks) 
     533        { 
     534          free (yyss); 
     535          free (yyvs); 
     536#ifdef YYLSP_NEEDED 
     537          free (yyls); 
     538#endif 
     539        } 
     540      return 2; 
     541    } 
     542      yystacksize *= 2; 
     543      if (yystacksize > YYMAXDEPTH) 
     544    yystacksize = YYMAXDEPTH; 
     545#ifndef YYSTACK_USE_ALLOCA 
     546      yyfree_stacks = 1; 
     547#endif 
     548      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); 
     549      __yy_memcpy ((char *)yyss, (char *)yyss1, 
     550           size * (unsigned int) sizeof (*yyssp)); 
     551      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); 
     552      __yy_memcpy ((char *)yyvs, (char *)yyvs1, 
     553           size * (unsigned int) sizeof (*yyvsp)); 
     554#ifdef YYLSP_NEEDED 
     555      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); 
     556      __yy_memcpy ((char *)yyls, (char *)yyls1, 
     557           size * (unsigned int) sizeof (*yylsp)); 
     558#endif 
     559#endif /* no yyoverflow */ 
     560 
     561      yyssp = yyss + size - 1; 
     562      yyvsp = yyvs + size - 1; 
     563#ifdef YYLSP_NEEDED 
     564      yylsp = yyls + size - 1; 
     565#endif 
     566 
     567#if YYDEBUG != 0 
     568      if (yydebug) 
     569    fprintf(stderr, "Stack size increased to %d\n", yystacksize); 
     570#endif 
     571 
     572      if (yyssp >= yyss + yystacksize - 1) 
     573    YYABORT; 
     574    } 
     575 
     576#if YYDEBUG != 0 
     577  if (yydebug) 
     578    fprintf(stderr, "Entering state %d\n", yystate); 
     579#endif 
     580 
     581  goto yybackup; 
     582 yybackup: 
     583 
     584/* Do appropriate processing given the current state.  */ 
     585/* Read a lookahead token if we need one and don't already have one.  */ 
     586/* yyresume: */ 
     587 
     588  /* First try to decide what to do without reference to lookahead token.  */ 
     589 
     590  yyn = yypact[yystate]; 
     591  if (yyn == YYFLAG) 
     592    goto yydefault; 
     593 
     594  /* Not known => get a lookahead token if don't already have one.  */ 
     595 
     596  /* yychar is either YYEMPTY or YYEOF 
     597     or a valid token in external form.  */ 
     598 
     599  if (yychar == YYEMPTY) 
     600    { 
     601#if YYDEBUG != 0 
     602      if (yydebug) 
     603    fprintf(stderr, "Reading a token: "); 
     604#endif 
     605      yychar = YYLEX; 
     606    } 
     607 
     608  /* Convert token to internal form (in yychar1) for indexing tables with */ 
     609 
     610  if (yychar <= 0)      /* This means end of input. */ 
     611    { 
     612      yychar1 = 0; 
     613      yychar = YYEOF;       /* Don't call YYLEX any more */ 
     614 
     615#if YYDEBUG != 0 
     616      if (yydebug) 
     617    fprintf(stderr, "Now at end of input.\n"); 
     618#endif 
     619    } 
     620  else 
     621    { 
     622      yychar1 = YYTRANSLATE(yychar); 
     623 
     624#if YYDEBUG != 0 
     625      if (yydebug) 
     626    { 
     627      fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); 
     628      /* Give the individual parser a way to print the precise meaning 
     629         of a token, for further debugging info.  */ 
     630#ifdef YYPRINT 
     631      YYPRINT (stderr, yychar, yylval); 
     632#endif 
     633      fprintf (stderr, ")\n"); 
     634    } 
     635#endif 
     636    } 
     637 
     638  yyn += yychar1; 
     639  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) 
     640    goto yydefault; 
     641 
     642  yyn = yytable[yyn]; 
     643 
     644  /* yyn is what to do for this token type in this state. 
     645     Negative => reduce, -yyn is rule number. 
     646     Positive => shift, yyn is new state. 
     647       New state is final state => don't bother to shift, 
     648       just return success. 
     649     0, or most negative number => error.  */ 
     650 
     651  if (yyn < 0) 
     652    { 
     653      if (yyn == YYFLAG) 
     654    goto yyerrlab; 
     655      yyn = -yyn; 
     656      goto yyreduce; 
     657    } 
     658  else if (yyn == 0) 
     659    goto yyerrlab; 
     660 
     661  if (yyn == YYFINAL) 
     662    YYACCEPT; 
     663 
     664  /* Shift the lookahead token.  */ 
     665 
     666#if YYDEBUG != 0 
     667  if (yydebug) 
     668    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); 
     669#endif 
     670 
     671  /* Discard the token being shifted unless it is eof.  */ 
     672  if (yychar != YYEOF) 
     673    yychar = YYEMPTY; 
     674 
     675  *++yyvsp = yylval; 
     676#ifdef YYLSP_NEEDED 
     677  *++yylsp = yylloc; 
     678#endif 
     679 
     680  /* count tokens shifted since error; after three, turn off error status.  */ 
     681  if (yyerrstatus) yyerrstatus--; 
     682 
     683  yystate = yyn; 
     684  goto yynewstate; 
     685 
     686/* Do the default action for the current state.  */ 
     687yydefault: 
     688 
     689  yyn = yydefact[yystate]; 
     690  if (yyn == 0) 
     691    goto yyerrlab; 
     692 
     693/* Do a reduction.  yyn is the number of a rule to reduce with.  */ 
     694yyreduce: 
     695  yylen = yyr2[yyn]; 
     696  if (yylen > 0) 
     697    yyval = yyvsp[1-yylen]; /* implement default value of the action */ 
     698 
     699#if YYDEBUG != 0 
     700  if (yydebug) 
     701    { 
     702      int i; 
     703 
     704      fprintf (stderr, "Reducing via rule %d (line %d), ", 
     705           yyn, yyrline[yyn]); 
     706 
     707      /* Print the symbols being reduced, and their result.  */ 
     708      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) 
     709    fprintf (stderr, "%s ", yytname[yyrhs[i]]); 
     710      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); 
     711    } 
     712#endif 
     713 
     714 
     715  switch (yyn) { 
     716 
     717case 1: 
     718#line 76 "bool_parser.y" 
     719{ tree_base = yyvsp[0].node;; 
     720    break;} 
     721case 2: 
     722#line 80 "bool_parser.y" 
     723{ yyval.node = CreateBoolTermNode(term_list, yyvsp[0].text, 1, word_num, count, doc_count, invf_ptr, invf_len, stemmer_num); ; 
     724    break;} 
     725case 3: 
     726#line 81 "bool_parser.y" 
     727{ yyval.node = yyvsp[-1].node; ; 
     728    break;} 
     729case 4: 
     730#line 82 "bool_parser.y" 
     731{ yyval.node = CreateBoolTreeNode(N_all, NULL, NULL); ; 
     732    break;} 
     733case 5: 
     734#line 83 "bool_parser.y" 
     735{ yyval.node = CreateBoolTreeNode(N_none, NULL, NULL); ; 
     736    break;} 
     737case 7: 
     738#line 87 "bool_parser.y" 
     739{ yyval.node = CreateBoolTreeNode(N_not, yyvsp[0].node, NULL); ; 
     740    break;} 
     741case 8: 
     742#line 90 "bool_parser.y" 
     743{ yyval.node = CreateBoolTreeNode(N_and, yyvsp[-2].node, yyvsp[0].node); ; 
     744    break;} 
     745case 9: 
     746#line 91 "bool_parser.y" 
     747{ yyval.node = CreateBoolTreeNode(N_and, yyvsp[-1].node, yyvsp[0].node); ; 
     748    break;} 
     749case 11: 
     750#line 95 "bool_parser.y" 
     751{ yyval.node = CreateBoolTreeNode(N_or, yyvsp[-2].node, yyvsp[0].node); ; 
     752    break;} 
     753} 
     754   /* the action file gets copied in in place of this dollarsign */ 
     755#line 542 "/usr/share/bison.simple" 
     756 
     757  yyvsp -= yylen; 
     758  yyssp -= yylen; 
     759#ifdef YYLSP_NEEDED 
     760  yylsp -= yylen; 
     761#endif 
     762 
     763#if YYDEBUG != 0 
     764  if (yydebug) 
     765    { 
     766      short *ssp1 = yyss - 1; 
     767      fprintf (stderr, "state stack now"); 
     768      while (ssp1 != yyssp) 
     769    fprintf (stderr, " %d", *++ssp1); 
     770      fprintf (stderr, "\n"); 
     771    } 
     772#endif 
     773 
     774  *++yyvsp = yyval; 
     775 
     776#ifdef YYLSP_NEEDED 
     777  yylsp++; 
     778  if (yylen == 0) 
     779    { 
     780      yylsp->first_line = yylloc.first_line; 
     781      yylsp->first_column = yylloc.first_column; 
     782      yylsp->last_line = (yylsp-1)->last_line; 
     783      yylsp->last_column = (yylsp-1)->last_column; 
     784      yylsp->text = 0; 
     785    } 
     786  else 
     787    { 
     788      yylsp->last_line = (yylsp+yylen-1)->last_line; 
     789      yylsp->last_column = (yylsp+yylen-1)->last_column; 
     790    } 
     791#endif 
     792 
     793  /* Now "shift" the result of the reduction. 
     794     Determine what state that goes to, 
     795     based on the state we popped back to 
     796     and the rule number reduced by.  */ 
     797 
     798  yyn = yyr1[yyn]; 
     799 
     800  yystate = yypgoto[yyn - YYNTBASE] + *yyssp; 
     801  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) 
     802    yystate = yytable[yystate]; 
     803  else 
     804    yystate = yydefgoto[yyn - YYNTBASE]; 
     805 
     806  goto yynewstate; 
     807 
     808yyerrlab:   /* here on detecting error */ 
     809 
     810  if (! yyerrstatus) 
     811    /* If not already recovering from an error, report this error.  */ 
     812    { 
     813      ++yynerrs; 
     814 
     815#ifdef YYERROR_VERBOSE 
     816      yyn = yypact[yystate]; 
     817 
     818      if (yyn > YYFLAG && yyn < YYLAST) 
     819    { 
     820      int size = 0; 
     821      char *msg; 
     822      int x, count; 
     823 
     824      count = 0; 
     825      /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */ 
     826      for (x = (yyn < 0 ? -yyn : 0); 
     827           x < (sizeof(yytname) / sizeof(char *)); x++) 
     828        if (yycheck[x + yyn] == x) 
     829          size += strlen(yytname[x]) + 15, count++; 
     830      msg = (char *) malloc(size + 15); 
     831      if (msg != 0) 
     832        { 
     833          strcpy(msg, "parse error"); 
     834 
     835          if (count < 5) 
     836        { 
     837          count = 0; 
     838          for (x = (yyn < 0 ? -yyn : 0); 
     839               x < (sizeof(yytname) / sizeof(char *)); x++) 
     840            if (yycheck[x + yyn] == x) 
     841              { 
     842            strcat(msg, count == 0 ? ", expecting `" : " or `"); 
     843            strcat(msg, yytname[x]); 
     844            strcat(msg, "'"); 
     845            count++; 
     846              } 
     847        } 
     848          yyerror(msg); 
     849          free(msg); 
     850        } 
     851      else 
     852        yyerror ("parse error; also virtual memory exceeded"); 
     853    } 
     854      else 
     855#endif /* YYERROR_VERBOSE */ 
     856    yyerror("parse error"); 
     857    } 
     858 
     859  goto yyerrlab1; 
     860yyerrlab1:   /* here on error raised explicitly by an action */ 
     861 
     862  if (yyerrstatus == 3) 
     863    { 
     864      /* if just tried and failed to reuse lookahead token after an error, discard it.  */ 
     865 
     866      /* return failure if at end of input */ 
     867      if (yychar == YYEOF) 
     868    YYABORT; 
     869 
     870#if YYDEBUG != 0 
     871      if (yydebug) 
     872    fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); 
     873#endif 
     874 
     875      yychar = YYEMPTY; 
     876    } 
     877 
     878  /* Else will try to reuse lookahead token 
     879     after shifting the error token.  */ 
     880 
     881  yyerrstatus = 3;      /* Each real token shifted decrements this */ 
     882 
     883  goto yyerrhandle; 
     884 
     885yyerrdefault:  /* current state does not do anything special for the error token. */ 
     886 
     887#if 0 
     888  /* This is wrong; only states that explicitly want error tokens 
     889     should shift them.  */ 
     890  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/ 
     891  if (yyn) goto yydefault; 
     892#endif 
     893 
     894yyerrpop:   /* pop the current state because it cannot handle the error token */ 
     895 
     896  if (yyssp == yyss) YYABORT; 
     897  yyvsp--; 
     898  yystate = *--yyssp; 
     899#ifdef YYLSP_NEEDED 
     900  yylsp--; 
     901#endif 
     902 
     903#if YYDEBUG != 0 
     904  if (yydebug) 
     905    { 
     906      short *ssp1 = yyss - 1; 
     907      fprintf (stderr, "Error: state stack now"); 
     908      while (ssp1 != yyssp) 
     909    fprintf (stderr, " %d", *++ssp1); 
     910      fprintf (stderr, "\n"); 
     911    } 
     912#endif 
     913 
     914yyerrhandle: 
     915 
     916  yyn = yypact[yystate]; 
     917  if (yyn == YYFLAG) 
     918    goto yyerrdefault; 
     919 
     920  yyn += YYTERROR; 
     921  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) 
     922    goto yyerrdefault; 
     923 
     924  yyn = yytable[yyn]; 
     925  if (yyn < 0) 
     926    { 
     927      if (yyn == YYFLAG) 
     928    goto yyerrpop; 
     929      yyn = -yyn; 
     930      goto yyreduce; 
     931    } 
     932  else if (yyn == 0) 
     933    goto yyerrpop; 
     934 
     935  if (yyn == YYFINAL) 
     936    YYACCEPT; 
     937 
     938#if YYDEBUG != 0 
     939  if (yydebug) 
     940    fprintf(stderr, "Shifting error token, "); 
     941#endif 
     942 
     943  *++yyvsp = yylval; 
     944#ifdef YYLSP_NEEDED 
     945  *++yylsp = yylloc; 
     946#endif 
     947 
     948  yystate = yyn; 
     949  goto yynewstate; 
     950 
     951 yyacceptlab: 
     952  /* YYACCEPT comes here.  */ 
     953  if (yyfree_stacks) 
     954    { 
     955      free (yyss); 
     956      free (yyvs); 
     957#ifdef YYLSP_NEEDED 
     958      free (yyls); 
     959#endif 
     960    } 
     961  return 0; 
     962 
     963 yyabortlab: 
     964  /* YYABORT comes here.  */ 
     965  if (yyfree_stacks) 
     966    { 
     967      free (yyss); 
     968      free (yyvs); 
     969#ifdef YYLSP_NEEDED 
     970      free (yyls); 
     971#endif 
     972    } 
     973  return 1; 
     974} 
    189975#line 99 "bool_parser.y" 
     976 
    190977  
    191978/* Bison on one mips machine defined "const" to be nothing but 
     
    3811168bool_tree_node * 
    3821169ParseBool(char *query_line, int query_len, 
    383           TermList **the_term_list, int the_stemmer_num, int the_stem_method,  
    384       int *res, 
     1170          TermList **the_term_list, int the_stemmer_num, int the_stem_method, int *res, 
    3851171      stemmed_dict * the_sd, int is_indexed,   /* [RPAP - Jan 97: Stem Index Change] */ 
    3861172      QueryTermList **the_query_term_list)  /* [RPAP - Feb 97: Term Frequency] */ 
     
    4071193  
    4081194 
    409 #line 407 "y.tab.c" 
    410 #define YYABORT goto yyabort 
    411 #define YYREJECT goto yyabort 
    412 #define YYACCEPT goto yyaccept 
    413 #define YYERROR goto yyerrlab 
    414 int 
    415 yyparse() 
    416 { 
    417     register int yym, yyn, yystate; 
    418 #if YYDEBUG 
    419     register char *yys; 
    420     extern char *getenv(); 
    421  
    422     if (yys = getenv("YYDEBUG")) 
    423     { 
    424         yyn = *yys; 
    425         if (yyn >= '0' && yyn <= '9') 
    426             yydebug = yyn - '0'; 
    427     } 
    428 #endif 
    429  
    430     yynerrs = 0; 
    431     yyerrflag = 0; 
    432     yychar = (-1); 
    433  
    434     yyssp = yyss; 
    435     yyvsp = yyvs; 
    436     *yyssp = yystate = 0; 
    437  
    438 yyloop: 
    439     if (yyn = yydefred[yystate]) goto yyreduce; 
    440     if (yychar < 0) 
    441     { 
    442         if ((yychar = yylex()) < 0) yychar = 0; 
    443 #if YYDEBUG 
    444         if (yydebug) 
    445         { 
    446             yys = 0; 
    447             if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; 
    448             if (!yys) yys = "illegal-symbol"; 
    449             printf("%sdebug: state %d, reading %d (%s)\n", 
    450                     YYPREFIX, yystate, yychar, yys); 
    451         } 
    452 #endif 
    453     } 
    454     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && 
    455             yyn <= YYTABLESIZE && yycheck[yyn] == yychar) 
    456     { 
    457 #if YYDEBUG 
    458         if (yydebug) 
    459             printf("%sdebug: state %d, shifting to state %d\n", 
    460                     YYPREFIX, yystate, yytable[yyn]); 
    461 #endif 
    462         if (yyssp >= yyss + yystacksize - 1) 
    463         { 
    464             goto yyoverflow; 
    465         } 
    466         *++yyssp = yystate = yytable[yyn]; 
    467         *++yyvsp = yylval; 
    468         yychar = (-1); 
    469         if (yyerrflag > 0)  --yyerrflag; 
    470         goto yyloop; 
    471     } 
    472     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && 
    473             yyn <= YYTABLESIZE && yycheck[yyn] == yychar) 
    474     { 
    475         yyn = yytable[yyn]; 
    476         goto yyreduce; 
    477     } 
    478     if (yyerrflag) goto yyinrecovery; 
    479 #ifdef lint 
    480     goto yynewerror; 
    481 #endif 
    482 yynewerror: 
    483     yyerror("syntax error"); 
    484 #ifdef lint 
    485     goto yyerrlab; 
    486 #endif 
    487 yyerrlab: 
    488     ++yynerrs; 
    489 yyinrecovery: 
    490     if (yyerrflag < 3) 
    491     { 
    492         yyerrflag = 3; 
    493         for (;;) 
    494         { 
    495             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && 
    496                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) 
    497             { 
    498 #if YYDEBUG 
    499                 if (yydebug) 
    500                     printf("%sdebug: state %d, error recovery shifting\ 
    501  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]); 
    502 #endif 
    503                 if (yyssp >= yyss + yystacksize - 1) 
    504                 { 
    505                     goto yyoverflow; 
    506                 } 
    507                 *++yyssp = yystate = yytable[yyn]; 
    508                 *++yyvsp = yylval; 
    509                 goto yyloop; 
    510             } 
    511             else 
    512             { 
    513 #if YYDEBUG 
    514                 if (yydebug) 
    515                     printf("%sdebug: error recovery discarding state %d\n", 
    516                             YYPREFIX, *yyssp); 
    517 #endif 
    518                 if (yyssp <= yyss) goto yyabort; 
    519                 --yyssp; 
    520                 --yyvsp; 
    521             } 
    522         } 
    523     } 
    524     else 
    525     { 
    526         if (yychar == 0) goto yyabort; 
    527 #if YYDEBUG 
    528         if (yydebug) 
    529         { 
    530             yys = 0; 
    531             if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; 
    532             if (!yys) yys = "illegal-symbol"; 
    533             printf("%sdebug: state %d, error recovery discards token %d (%s)\n", 
    534                     YYPREFIX, yystate, yychar, yys); 
    535         } 
    536 #endif 
    537         yychar = (-1); 
    538         goto yyloop; 
    539     } 
    540 yyreduce: 
    541 #if YYDEBUG 
    542     if (yydebug) 
    543         printf("%sdebug: state %d, reducing by rule %d (%s)\n", 
    544                 YYPREFIX, yystate, yyn, yyrule[yyn]); 
    545 #endif 
    546     yym = yylen[yyn]; 
    547     yyval = yyvsp[1-yym]; 
    548     switch (yyn) 
    549     { 
    550 case 1: 
    551 #line 75 "bool_parser.y" 
    552 { tree_base = yyvsp[0].node;} 
    553 break; 
    554 case 2: 
    555 #line 79 "bool_parser.y" 
    556 { yyval.node = CreateBoolTermNode(term_list, yyvsp[0].text, 1, word_num, count, doc_count, invf_ptr, invf_len, stemmer_num); } 
    557 break; 
    558 case 3: 
    559 #line 80 "bool_parser.y" 
    560 { yyval.node = yyvsp[-1].node; } 
    561 break; 
    562 case 4: 
    563 #line 81 "bool_parser.y" 
    564 { yyval.node = CreateBoolTreeNode(N_all, NULL, NULL); } 
    565 break; 
    566 case 5: 
    567 #line 82 "bool_parser.y" 
    568 { yyval.node = CreateBoolTreeNode(N_none, NULL, NULL); } 
    569 break; 
    570 case 7: 
    571 #line 86 "bool_parser.y" 
    572 { yyval.node = CreateBoolTreeNode(N_not, yyvsp[0].node, NULL); } 
    573 break; 
    574 case 8: 
    575 #line 89 "bool_parser.y" 
    576 { yyval.node = CreateBoolTreeNode(N_and, yyvsp[-2].node, yyvsp[0].node); } 
    577 break; 
    578 case 9: 
    579 #line 90 "bool_parser.y" 
    580 { yyval.node = CreateBoolTreeNode(N_and, yyvsp[-1].node, yyvsp[0].node); } 
    581 break; 
    582 case 11: 
    583 #line 94 "bool_parser.y" 
    584 { yyval.node = CreateBoolTreeNode(N_or, yyvsp[-2].node, yyvsp[0].node); } 
    585 break; 
    586 #line 584 "y.tab.c" 
    587     } 
    588     yyssp -= yym; 
    589     yystate = *yyssp; 
    590     yyvsp -= yym; 
    591     yym = yylhs[yyn]; 
    592     if (yystate == 0 && yym == 0) 
    593     { 
    594 #if YYDEBUG 
    595         if (yydebug) 
    596             printf("%sdebug: after reduction, shifting from state 0 to\ 
    597  state %d\n", YYPREFIX, YYFINAL); 
    598 #endif 
    599         yystate = YYFINAL; 
    600         *++yyssp = YYFINAL; 
    601         *++yyvsp = yyval; 
    602         if (yychar < 0) 
    603         { 
    604             if ((yychar = yylex()) < 0) yychar = 0; 
    605 #if YYDEBUG 
    606             if (yydebug) 
    607             { 
    608                 yys = 0; 
    609                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; 
    610                 if (!yys) yys = "illegal-symbol"; 
    611                 printf("%sdebug: state %d, reading %d (%s)\n", 
    612                         YYPREFIX, YYFINAL, yychar, yys); 
    613             } 
    614 #endif 
    615         } 
    616         if (yychar == 0) goto yyaccept; 
    617         goto yyloop; 
    618     } 
    619     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && 
    620             yyn <= YYTABLESIZE && yycheck[yyn] == yystate) 
    621         yystate = yytable[yyn]; 
    622     else 
    623         yystate = yydgoto[yym]; 
    624 #if YYDEBUG 
    625     if (yydebug) 
    626         printf("%sdebug: after reduction, shifting from state %d \ 
    627 to state %d\n", YYPREFIX, *yyssp, yystate); 
    628 #endif 
    629     if (yyssp >= yyss + yystacksize - 1) 
    630     { 
    631         goto yyoverflow; 
    632     } 
    633     *++yyssp = yystate; 
    634     *++yyvsp = yyval; 
    635     goto yyloop; 
    636 yyoverflow: 
    637     yyerror("yacc stack overflow"); 
    638 yyabort: 
    639     return (1); 
    640 yyaccept: 
    641     return (0); 
    642 } 
    643