Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-09 20:33:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

* src/bison.simple, src/bison.hairy, src/bison.c++: Move to...

Browse Source 
* data/: here.
This commit is contained in:
Akim Demaille
2002-02-05 09:57:52 +00:00
parent 894dd62eb2
commit 5bb18f9a19
20 changed files with 41 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
data/Makefile.am Normal file
View File

@@ -0,0 +1,18 @@
## Copyright 2002 Free Software Foundation, Inc.
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
## 02111-1307 USA
dist_pkgdata_DATA = bison.simple bison.hairy bison.c++

523
data/bison.c++ Normal file
View File

@@ -0,0 +1,523 @@
%%{section} %%{output-prefix} %%{output-infix} %%".hh"
/* -*- C++ -*- */
/* A Bison parser, made from %%filename,
by GNU bison %%version. */
/* Skeleton output parser for bison,
Copyright 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
#include "stack.hh"
/* #include "parser.hh" */
#include "location.hh"
namespace yy
{
class %%{name};
template < typename P >
struct Traits
{
};
template < >
struct Traits< %%{name} >
{
typedef int StateType;
typedef %%{stype} SemanticType;
typedef Location LocationType;
};
}
%%{prologue}
namespace yy
{
class %%{name}
{
public:
typedef Traits< %%{name} >::StateType StateType;
typedef Traits< %%{name} >::SemanticType SemanticType;
typedef Traits< %%{name} >::LocationType LocationType;
typedef Stack< StateType > StateStack;
typedef Stack< SemanticType > SemanticStack;
typedef Stack< LocationType > LocationStack;
%%{name} () : debug (1)
{
looka = empty;
}
virtual int parse ();
private:
/* Call to lexical analyser. */
virtual
void
lex ()
{
looka = yylex (&value);
}
/* Stacks. */
StateStack state_stack;
SemanticStack semantic_stack;
LocationStack location_stack;
/* Tables. */
static const short pact_[];
static const short defact_[];
static const short pgoto_[];
static const short defgoto_[];
static const short table_[];
static const short check_[];
static const short line_[];
static const short r1_[];
static const short r2_[];
static const char* const name_[];
/* More tables, for debugging. */
/* FIXME: These tables should not be printed when not in debug
mode. %%ifdef? */
static const short rhs_[];
static const short prhs_[];
static const short rline_[];
/* Even more tables. */
static inline char translate (int token);
/* Eof and empty. */
static const int eof;
static const int empty;
/* State. */
int n;
int len;
int debug;
int state;
/* Lookahead. */
int looka;
int ilooka;
/* @$ and $$. */
SemanticType value;
LocationType location;
};
}
%%{section} %%{output-prefix} %%{output-infix} %%".cc"
#include "%%{output-prefix}%%{output-infix}.hh"
/* Enable debugging if requested. */
#if %%{debug}
# include <cstdio>
# define YYFPRINTF std::fprintf
# define YYDPRINTF(Args) \
do { \
if (debug) \
YYFPRINTF Args; \
} while (0)
/* Nonzero means print parse trace. [The following comment makes no
sense to me. Could someone clarify it? --akim] Since this is
uninitialized, it does not stop multiple parsers from coexisting.
*/
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
#endif /* !YYDEBUG */
/* Tokens. */
%%{tokendef}
int
yy::%%{name}::parse ()
{
/* Initialize stack. */
state_stack = StateStack (0);
semantic_stack = SemanticStack (1);
location_stack = LocationStack (1);
/* Reserve initial space. The C parser needed that, but is it really
useful here? */
state_stack.reserve (%%{initdepth});
semantic_stack.reserve (%%{initdepth});
location_stack.reserve (%%{initdepth});
/* Start. */
state = 0;
YYDPRINTF ((stderr, "Starting parse\n"));
/* New state. */
yynewstate:
state_stack.push (state);
YYDPRINTF ((stderr, "Entering state %d\n", state));
/* Backup. */
yybackup:
/* Try to take a decision without lookahead. */
n = pact_[state];
if (n == %%{flag})
goto yydefault;
/* Read a lookahead token. */
if (looka == empty)
{
YYDPRINTF ((stderr, "Reading a token: "));
lex ();
}
/* Convert token to internal form. */
if (looka <= 0)
{
looka = eof;
ilooka = 0;
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
ilooka = translate (looka);
#if %%{debug}
YYFPRINTF (stderr, "Next token is %d (%s", looka, name_[ilooka]);
YYFPRINTF (stderr, ")\n");
#endif
}
n += ilooka;
if (n < 0 || n > %%{last} || check_[n] != ilooka)
goto yydefault;
/* Reduce or error. */
n = table_[n];
if (n < 0)
{
if (n == %%{flag})
goto yyerrlab;
else
{
n = -n;
goto yyreduce;
}
}
else if (n == 0)
goto yyerrlab;
/* Accept? */
if (n == %%{final})
goto yyacceptlab;
/* Shift the lookahead token. */
YYDPRINTF ((stderr, "Shifting token %d (%s), ", looka, name_[ilooka]));
/* Discard the token being shifted unless it is eof. */
if (looka != eof)
looka = empty;
semantic_stack.push (value);
location_stack.push (location);
state = n;
goto yynewstate;
/* Default action. */
yydefault:
n = defact_[state];
if (n == 0)
goto yyerrlab;
/* Reduce. */
yyreduce:
len = r2_[n];
value = semantic_stack[1 - len];
location = location_stack[1 - len];
#if %%{debug}
if (debug)
{
YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", n - 1, rline_[n]);
for (unsigned i = prhs_[n];
rhs_[i] >= 0; ++i)
YYFPRINTF (stderr, "%s ", name_[rhs_[i]]);
YYFPRINTF (stderr, "-> %s\n", name_[r1_[n]]);
}
#endif
{
SemanticType& yyval (value);
SemanticStack& yyvsp (semantic_stack);
switch (n)
{
%%{actions}
}
}
state_stack.pop (len);
semantic_stack.pop (len);
location_stack.pop (len);
#if %%{debug}
if (debug)
{
YYFPRINTF (stderr, "state stack now");
for (StateStack::ConstIterator i = state_stack.begin ();
i != state_stack.end (); ++i)
YYFPRINTF (stderr, " %d", *i);
YYFPRINTF (stderr, "\n");
}
#endif
semantic_stack.push (value);
location_stack.push (location);
/* Shift the result of the reduction. */
n = r1_[n];
state = pgoto_[n - %%{ntokens}] + state_stack[0];
if (state >= 0 && state <= %%{last} && check_[state] == state_stack[0])
state = table_[state];
else
state = defgoto_[n - %%{ntokens}];
goto yynewstate;
/* Report and recover from errors. This is very incomplete. */
yyerrlab:
std::cerr << "Parse error." << std::endl; // FIXME: Need something like yyerror?
return 1;
/* Accept. */
yyacceptlab:
return 0;
}
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
const short
yy::%%{name}::pact_[] =
{
%%{pact}
};
/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
doesn't specify something else to do. Zero means the default is an
error. */
const short
yy::%%{name}::defact_[] =
{
%%{defact}
};
/* YYPGOTO[NTERM-NUM]. */
const short
yy::%%{name}::pgoto_[] =
{
%%{pgoto}
};
/* YYDEFGOTO[NTERM-NUM]. */
const short
yy::%%{name}::defgoto_[] =
{
%%{defgoto}
};
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which
number is the opposite. If zero, do what YYDEFACT says. */
const short
yy::%%{name}::table_[] =
{
%%{table}
};
/* YYCHECK. */
const short
yy::%%{name}::check_[] =
{
%%{check}
};
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
const short
yy::%%{name}::line_[] =
{
%%{line}
};
/*YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
const short
yy::%%{name}::r1_[] =
{
%%{r1}
};
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
const short
yy::%%{name}::r2_[] =
{
%%{r2}
};
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
const char*
const yy::%%{name}::name_[] =
{
%%{tname}
};
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
const short
yy::%%{name}::rhs_[] =
{
%%{rhs}
};
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
const short
yy::%%{name}::prhs_[] =
{
%%{prhs}
};
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
const short
yy::%%{name}::rline_[] =
{
%%{rline}
};
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
char
yy::%%{name}::translate (int token)
{
static
const char
translate_[] =
{
%%{translate}
};
return ((unsigned)(token) <= %%{maxtok} ? translate_[token] : %%{nsym});
}
const int yy::%%{name}::eof = 0;
const int yy::%%{name}::empty = -2;
%%{epilogue}
%%{section} %%"stack.hh"
#ifndef BISON_STACK_HH
# define BISON_STACK_HH
#include <vector>
namespace yy
{
template < class T, class S = std::vector< T > >
class Stack
{
public:
typedef typename S::iterator Iterator;
typedef typename S::const_iterator ConstIterator;
Stack () : seq_ ()
{
}
Stack (unsigned n) : seq_ (n)
{
}
inline
T&
operator [] (int index)
{
return seq_[seq_.size () - 1 + index];
}
inline
const T&
operator [] (int index) const
{
return seq_[seq_.size () - 1 + index];
}
inline
void
push (const T& t)
{
seq_.push_back (t);
}
inline
void
pop (unsigned n = 1)
{
for (; n; --n)
seq_.pop_back ();
}
inline
void
reserve (unsigned n)
{
seq_.reserve (n);
}
inline ConstIterator begin () const { return seq_.begin (); }
inline ConstIterator end () const { return seq_.end (); }
private:
S seq_;
};
}
#endif // not BISON_STACK_HH
%%{section} %%"location.hh"
#ifndef BISON_LOCATION_HH
# define BISON_LOCATION_HH
namespace yy
{
struct Position
{
int line;
int column;
};
struct Location
{
Position first;
Position last;
};
}
#endif // not BISON_LOCATION_HH

336
data/bison.hairy Normal file
View File

@@ -0,0 +1,336 @@
%%{section} %%{output-prefix} %%{output-infix} %%".c"
/* -*- C -*- */
/* YYERROR and YYCOST are set by guards. If yyerror is set to a
nonzero value by a guard, the reduction with which the guard is
associated is not performed, and the error recovery mechanism is
invoked. Yycost indicates the cost of performing the reduction
given the attributes of the symbols. */
static int yyerror;
static int yycost;
/* YYMAXDEPTH indicates the size of the parser's state and value
stacks. */
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 500
#endif
/* YYMAXRULES must be at least as large as the number of rules that
could be placed in the rule queue. That number could be determined
from the grammar and the size of the stack, but, as yet, it is not.
*/
#ifndef YYMAXRULES
# define YYMAXRULES 100
#endif
#ifndef YYMAXBACKUP
# define YYMAXBACKUP 100
#endif
/* The state stack. */
static short yyss[YYMAXDEPTH];
/* The semantic value stack. */
static YYSTYPE yyvs[YYMAXDEPTH];
/* The location stack. */
static YYLTYPE yyls[YYMAXDEPTH];
/* The rule queue. */
static short yyrq[YYMAXRULES];
/* The lookahead symbol. */
static int yychar;
/* the semantic value of the lookahead symbol. */
static YYSTYPE yylval;
/* the semantic value for the state at the top of the state stack. */
static YYSTYPE yytval;
/* the variable used to return semantic values from the action
routines. */
static YYSTYPE yyval;
/* location data for the lookahead symbol. */
static YYLTYPE yylloc;
/* location data for the state at the top of the state stack. */
static YYLTYPE yytloc;
static int yynunlexed;
static short yyunchar[YYMAXBACKUP];
static YYSTYPE yyunval[YYMAXBACKUP];
static YYLTYPE yyunloc[YYMAXBACKUP];
/* a pointer to the top of the state stack; only set during error
recovery. */
static short *yygssp;
/* a pointer to the top of the value stack; only set during error
recovery. */
static YYSTYPE *yygvsp;
/* a pointer to the top of the location stack; only set during error
recovery. */
static YYLTYPE *yyglsp;
/*--------------------------------------------------------------------.
| Yyget is an interface between the parser and the lexical analyzer. |
| It is costly to provide such an interface, but it avoids requiring |
| the lexical analyzer to be able to back up the scan. |
`--------------------------------------------------------------------*/
static inline void
yyget (void)
{
if (yynunlexed > 0)
{
yynunlexed--;
yychar = yyunchar[yynunlexed];
yylval = yyunval[yynunlexed];
yylloc = yyunloc[yynunlexed];
}
else if (yychar <= 0)
yychar = 0;
else
{
yychar = yylex ();
if (yychar < 0)
yychar = 0;
else
yychar = YYTRANSLATE (yychar);
}
}
static inline void
yyunlex (int chr, YYSTYPE val, YYLTYPE loc)
{
yyunchar[yynunlexed] = chr;
yyunval[yynunlexed] = val;
yyunloc[yynunlexed] = loc;
yynunlexed++;
}
static inline void
yyrestore (short *first, short *last)
{
short *ssp;
short *rp;
int symbol;
int state;
int tvalsaved;
ssp = yygssp;
yyunlex (yychar, yylval, yylloc);
tvalsaved = 0;
while (first != last)
{
symbol = yystos[*ssp];
if (symbol < YYNTBASE)
{
yyunlex (symbol, yytval, yytloc);
tvalsaved = 1;
ssp--;
}
ssp--;
if (first == yyrq)
first = yyrq + YYMAXRULES;
first--;
for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++)
{
if (symbol < YYNTBASE)
state = yytable[yypact[*ssp] + symbol];
else
{
state = yypgoto[symbol - YYNTBASE] + *ssp;
if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp)
state = yytable[state];
else
state = yydefgoto[symbol - YYNTBASE];
}
*++ssp = state;
}
}
if (!tvalsaved && ssp > yyss)
{
yyunlex (yystos[*ssp], yytval, yytloc);
ssp--;
}
yygssp = ssp;
}
int
yyparse (void)
{
int yystate;
int yyn;
short *yyssp;
short *yyrq0;
short *yyptr;
YYSTYPE *yyvsp;
int yylen;
YYLTYPE *yylsp;
short *yyrq1;
short *yyrq2;
yystate = 0;
yyssp = yyss - 1;
yyvsp = yyvs - 1;
yylsp = yyls - 1;
yyrq0 = yyrq;
yyrq1 = yyrq0;
yyrq2 = yyrq0;
yychar = yylex ();
if (yychar < 0)
yychar = 0;
else
yychar = YYTRANSLATE (yychar);
yynewstate:
if (yyssp >= yyss + YYMAXDEPTH - 1)
{
yyabort ("Parser Stack Overflow");
YYABORT;
}
*++yyssp = yystate;
yyresume:
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yydefault;
yyn += yychar;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar)
goto yydefault;
yyn = yytable[yyn];
if (yyn < 0)
{
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrlab;
yystate = yyn;
yyptr = yyrq2;
while (yyptr != yyrq1)
{
yyn = *yyptr++;
yylen = yyr2[yyn];
yyvsp -= yylen;
yylsp -= yylen;
yyguard (yyn, yyvsp, yylsp);
if (yyerror)
goto yysemerr;
yyaction (yyn, yyvsp, yylsp);
*++yyvsp = yyval;
yylsp++;
if (yylen == 0)
{
yylsp->first_line = yytloc.first_line;
yylsp->first_column = yytloc.first_column;
yylsp->last_line = (yylsp - 1)->last_line;
yylsp->last_column = (yylsp - 1)->last_column;
yylsp->text = 0;
}
else
{
yylsp->last_line = (yylsp + yylen - 1)->last_line;
yylsp->last_column = (yylsp + yylen - 1)->last_column;
}
if (yyptr == yyrq + YYMAXRULES)
yyptr = yyrq;
}
if (yystate == YYFINAL)
YYACCEPT;
yyrq2 = yyptr;
yyrq1 = yyrq0;
*++yyvsp = yytval;
*++yylsp = yytloc;
yytval = yylval;
yytloc = yylloc;
yyget ();
goto yynewstate;
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
yyreduce:
*yyrq0++ = yyn;
if (yyrq0 == yyrq + YYMAXRULES)
yyrq0 = yyrq;
if (yyrq0 == yyrq2)
{
yyabort ("Parser Rule Queue Overflow");
YYABORT;
}
yyssp -= yyr2[yyn];
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTBASE];
goto yynewstate;
yysemerr:
*--yyptr = yyn;
yyrq2 = yyptr;
yyvsp += yyr2[yyn];
yyerrlab:
yygssp = yyssp;
yygvsp = yyvsp;
yyglsp = yylsp;
yyrestore (yyrq0, yyrq2);
yyrecover ();
yystate = *yygssp;
yyssp = yygssp;
yyvsp = yygvsp;
yyrq0 = yyrq;
yyrq1 = yyrq0;
yyrq2 = yyrq0;
goto yyresume;
}
%%{actions}

1141
data/bison.simple Normal file
View File

File diff suppressed because it is too large Load Diff