m4_divert(-1)
-
# C++ skeleton for Bison
-# Copyright (C) 2002 Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003 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
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
# 02111-1307 USA
+## ---------------- ##
+## Default values. ##
+## ---------------- ##
-# b4_sint_type(MAX)
-# -----------------
-# Return the smallest signed int type able to handle the number MAX.
-m4_define([b4_sint_type],
-[m4_if(m4_eval([$1 <= 127]), [1], [signed char],
- m4_eval([$1 <= 32767]), [1], [signed short],
- [signed int])])
+# Default Parser class name.
+m4_define_default([b4_parser_class_name], [Parser])
-# b4_uint_type(MAX)
-# -----------------
-# Return the smallest unsigned int type able to handle the number MAX.
-m4_define([b4_uint_type],
-[m4_if(m4_eval([$1 <= 255]), [1], [unsigned char],
- m4_eval([$1 <= 65535]), [1], [unsigned short],
- [unsigned int])])
+
+## ----------------- ##
+## Semantic Values. ##
+## ----------------- ##
# b4_lhs_value([TYPE])
# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
# symbols on RHS.
m4_define([b4_rhs_value],
-[semantic_stack_@<:@m4_eval([$1 - $2])@:>@m4_ifval([$3], [.$3])])
+[semantic_stack_@{m4_eval([$1 - $2])@}m4_ifval([$3], [.$3])])
+m4_define_default([b4_location_type], [Location])
# b4_lhs_location()
# -----------------
# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
# on RHS.
m4_define([b4_rhs_location],
-[location_stack_@<:@m4_eval([$1 - $2])@:>@])
-
-
-# b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
-# -----------------------------------------
-# Output the definition of this token as #define.
-m4_define([b4_token_define],
-[#define $1 $2
-])
-
-
-# b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
-# -------------------------------------------------------
-# Output the definition of the tokens as #define.
-m4_define([b4_token_defines],
-[m4_map([b4_token_define], [$@])])
-
-m4_define_default([b4_input_suffix], [.y])
-
-m4_define_default([b4_output_parser_suffix],
-[m4_translit(b4_input_suffix, [yY], [cC])])
-
-m4_define_default([b4_output_parser_name],
-[b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]])
-
+[location_stack_@{m4_eval([$1 - $2])@}])
-m4_define_default([b4_output_header_suffix],
-[m4_translit(b4_input_suffix, [yY], [hH])])
-
-m4_define_default([b4_output_header_name],
-[b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]])
-
-m4_define_default([b4_header_guard],
- [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name),
- [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
m4_define([b4_inherit],
[m4_ifdef([b4_root],
],
[])])
-m4_define([b4_copyright],
- [/* -*- C++ -*- */
-/* A Bison parser, made from b4_filename,
- by GNU bison b4_version. */
-
-/* Skeleton output parser for bison,
- 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, 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. */])
+# We do want M4 expansion after # for CPP macros.
+m4_changecom()
m4_divert(0)dnl
-#output "b4_output_header_name"
-b4_copyright
-#ifndef b4_header_guard
-# define b4_header_guard
+m4_if(b4_defines_flag, 0, [],
+[@output @output_header_name@
+b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
+ [2002, 2003])[
+/* FIXME: This is wrong, we want computed header guards.
+ I don't know why the macros are missing now. :( */
+#ifndef PARSER_HEADER_H
+# define PARSER_HEADER_H
#include "stack.hh"
#include "location.hh"
#include <iostream>
/* Using locations. */
-#define YYLSP_NEEDED b4_locations_flag
+#define YYLSP_NEEDED ]b4_locations_flag[
-/* Copy the first part of user declarations. */
-b4_pre_prologue
+]b4_token_defines(b4_tokens)[
-/* Line __line__ of __file__. */
-#line __oline__ "__ofile__"
+/* Copy the first part of user declarations. */
+]b4_pre_prologue[
-/* Tokens. */
-b4_token_defines(b4_tokens)
+]/* Line __line__ of lalr1.cc. */
+b4_syncline([@oline@], [@ofile@])[
/* Enabling traces. */
#ifndef YYDEBUG
-# define YYDEBUG b4_debug
+# define YYDEBUG ]b4_debug[
#endif
/* Enabling verbose error message. */
#ifndef YYERROR_VERBOSE
-# define YYERROR_VERBOSE b4_error_verbose
+# define YYERROR_VERBOSE ]b4_error_verbose[
#endif
#ifndef YYSTYPE
-m4_ifdef([b4_stype],
-[#line b4_stype_line "b4_filename"
+]m4_ifdef([b4_stype],
+[b4_syncline([b4_stype_line], [b4_filename])
typedef union b4_stype yystype;
-/* Line __line__ of __file__. */
-#line __oline__ "__ofile__"],
-[typedef int yystype;])
+/* Line __line__ of lalr1.cc. */
+b4_syncline([@oline@], [@ofile@])],
+[typedef int yystype;])[
# define YYSTYPE yystype
#endif
/* Copy the second part of user declarations. */
-b4_post_prologue
+]b4_post_prologue[
-/* Line __line__ of __file__. */
-#line __oline__ "__ofile__"
+]/* Line __line__ of lalr1.cc. */
+b4_syncline([@oline@], [@ofile@])[
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
- Current.last_line = Rhs[[N]].last_line; \
- Current.last_column = Rhs[[N]].last_column;
+ Current.end = Rhs[N].end;
#endif
-m4_if(b4_locations_flag, [0], [],
-[#ifndef YYLTYPE
-typedef struct yyltype
-{
- int first_line;
- int first_column;
- int last_line;
- int last_column;
-} yyltype;
-# define YYLTYPE yyltype
-#endif])
-
namespace yy
{
- class b4_name;
+ class ]b4_parser_class_name[;
template < typename P >
struct Traits
};
template < >
- struct Traits< b4_name >
+ struct Traits< ]b4_parser_class_name[ >
{
- typedef b4_uint_type(b4_translate_max) TokenNumberType;
- typedef b4_sint_type(b4_rhs_max) RhsNumberType;
+ typedef ]b4_int_type_for([b4_translate])[ TokenNumberType;
+ typedef ]b4_int_type_for([b4_rhs])[ RhsNumberType;
typedef int StateType;
typedef yystype SemanticType;
- typedef b4_ltype LocationType;
+ typedef ]b4_location_type[ LocationType;
};
}
namespace yy
{
- class b4_name b4_inherit
+ class ]b4_parser_class_name b4_inherit[
{
public:
- typedef Traits< b4_name >::TokenNumberType TokenNumberType;
- typedef Traits< b4_name >::RhsNumberType RhsNumberType;
- typedef Traits< b4_name >::StateType StateType;
- typedef Traits< b4_name >::SemanticType SemanticType;
- typedef Traits< b4_name >::LocationType LocationType;
+ typedef Traits< ]b4_parser_class_name[ >::TokenNumberType TokenNumberType;
+ typedef Traits< ]b4_parser_class_name[ >::RhsNumberType RhsNumberType;
+ typedef Traits< ]b4_parser_class_name[ >::StateType StateType;
+ typedef Traits< ]b4_parser_class_name[ >::SemanticType SemanticType;
+ typedef Traits< ]b4_parser_class_name[ >::LocationType LocationType;
typedef Stack< StateType > StateStack;
typedef Stack< SemanticType > SemanticStack;
typedef Stack< LocationType > LocationStack;
#if YYLSP_NEEDED
- b4_name (bool debug,
- LocationType initlocation[]b4_param) :
- b4_constructor[]debug_ (debug),
+ ]b4_parser_class_name[ (bool debug,
+ LocationType initlocation][]b4_param[) :
+ ]b4_constructor[][debug_ (debug),
cdebug_ (std::cerr),
initlocation_ (initlocation)
#else
- b4_name (bool debug[]b4_param) :
- b4_constructor[]debug_ (debug),
+ ]b4_parser_class_name[ (bool debug][]b4_param[) :
+ ]b4_constructor[][debug_ (debug),
cdebug_ (std::cerr)
#endif
{
}
- virtual ~b4_name ()
+ virtual ~]b4_parser_class_name[ ()
{
}
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 b4_uint_type(b4_r1_max) r1_[[]];
- static const b4_uint_type(b4_r2_max) r2_[[]];
+ static const ]b4_int_type_for([b4_pact])[ pact_[];
+ static const ]b4_int_type_for([b4_pact])[ pact_ninf_;
+ static const ]b4_int_type_for([b4_defact])[ defact_[];
+ static const ]b4_int_type_for([b4_pgoto])[ pgoto_[];
+ static const ]b4_int_type_for([b4_defgoto])[ defgoto_[];
+ static const ]b4_int_type_for([b4_table])[ table_[];
+ static const ]b4_int_type_for([b4_table])[ table_ninf_;
+ static const ]b4_int_type_for([b4_check])[ check_[];
+ static const ]b4_int_type_for([b4_r1])[ r1_[];
+ static const ]b4_int_type_for([b4_r2])[ r2_[];
#if YYDEBUG || YYERROR_VERBOSE
- static const char* const name_[[]];
+ static const char* const name_[];
#endif
/* More tables, for debugging. */
#if YYDEBUG
- static const RhsNumberType rhs_[[]];
- static const b4_uint_type(b4_prhs_max) prhs_[[]];
- static const b4_uint_type(b4_rline_max) rline_[[]];
- static const b4_uint_type(b4_stos_max) stos_[[]];
- static const short token_number_[[]];
+ static const RhsNumberType rhs_[];
+ static const ]b4_int_type_for([b4_prhs])[ prhs_[];
+ static const ]b4_int_type_for([b4_rline])[ rline_[];
+ static const ]b4_int_type_for([b4_stos])[ stos_[];
+ static const ]b4_int_type_for([b4_toknum])[ token_number_[];
#endif
/* Even more tables. */
/* Constants. */
static const int eof_;
+ /* LAST_ -- Last index in TABLE_. */
static const int last_;
- static const int flag_;
static const int nnts_;
- static const int nsym_;
static const int empty_;
static const int final_;
static const int terror_;
static const int errcode_;
static const int ntokens_;
- static const int initdepth_;
static const unsigned user_token_number_max_;
static const TokenNumberType undef_token_;
SemanticType value;
LocationType location;
- /* @$ and $$. */
+ /* @@$ and $$. */
SemanticType yyval;
LocationType yyloc;
};
}
-#endif /* not b4_header_guard */
-
-#output "b4_output_prefix[]b4_output_infix[].cc"
-b4_copyright
+#endif /* ! defined PARSER_HEADER_H */]
+])dnl
+@output @output_parser_name@
+b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
+ [2002, 2003])
-#include "b4_output_header_name"
+m4_if(b4_defines_flag, 0, [], [#include @output_header_name@])[
/* Enable debugging if requested. */
#if YYDEBUG
# define YYCDEBUG if (0) cdebug_
#endif /* !YYDEBUG */
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrlab1
+
+
int
-yy::b4_name::parse ()
+yy::]b4_parser_class_name[::parse ()
{
int nerrs = 0;
int errstatus = 0;
- /* Initialize stack. */
+ /* Initialize the stacks. The initial state will be pushed in
+ yynewstate, since the latter expects the semantical and the
+ location values to have been already stored, initialize these
+ stacks with a primary value. */
state_stack_ = StateStack (0);
semantic_stack_ = SemanticStack (1);
location_stack_ = LocationStack (1);
yybackup:
/* Try to take a decision without lookahead. */
- n_ = pact_[[state_]];
- if (n_ == flag_)
+ n_ = pact_[state_];
+ if (n_ == pact_ninf_)
goto yydefault;
/* Read a lookahead token. */
if (debug_)
{
YYCDEBUG << "Next token is " << looka_
- << " (" << name_[[ilooka_]];
+ << " (" << name_[ilooka_];
print_ ();
YYCDEBUG << ')' << std::endl;
}
}
n_ += ilooka_;
- if (n_ < 0 || n_ > last_ || check_[[n_]] != ilooka_)
+ if (n_ < 0 || last_ < n_ || check_[n_] != ilooka_)
goto yydefault;
/* Reduce or error. */
- n_ = table_[[n_]];
+ n_ = table_[n_];
if (n_ < 0)
{
- if (n_ == flag_)
+ if (n_ == table_ninf_)
goto yyerrlab;
else
{
goto yyacceptlab;
/* Shift the lookahead token. */
+#if YYDEBUG
YYCDEBUG << "Shifting token " << looka_
- << " (" << name_[[ilooka_]] << "), ";
+ << " (" << name_[ilooka_] << "), ";
+#endif
/* Discard the token being shifted unless it is eof. */
if (looka_ != eof_)
/* Default action. */
yydefault:
- n_ = defact_[[state_]];
+ n_ = defact_[state_];
if (n_ == 0)
goto yyerrlab;
goto yyreduce;
/* Reduce. */
yyreduce:
- len_ = r2_[[n_]];
+ len_ = r2_[n_];
if (len_)
{
- yyval = semantic_stack_[[len_ - 1]];
- yyloc = location_stack_[[len_ - 1]];
+ yyval = semantic_stack_[len_ - 1];
+ yyloc = location_stack_[len_ - 1];
}
else
{
- yyval = semantic_stack_[[0]];
- yyloc = location_stack_[[0]];
+ yyval = semantic_stack_[0];
+ yyloc = location_stack_[0];
}
#if YYDEBUG
if (debug_)
{
+ // Short files will use "unsigned char" for line numbers,
+ // in which case they will be output as character litterals
+ // by "<<".
+ unsigned yylno = rline_[n_];
YYCDEBUG << "Reducing via rule " << n_ - 1
- << " (line " << rline_[[n_]] << "), ";
- for (b4_uint_type(b4_prhs_max) i = prhs_[[n_]];
- rhs_[[i]] >= 0; ++i)
- YYCDEBUG << name_[[rhs_[i]]] << ' ';
- YYCDEBUG << "-> " << name_[[r1_[n_]]] << std::endl;
+ << " (line " << yylno << "), ";
+ for (]b4_int_type_for([b4_prhs])[ i = prhs_[n_];
+ 0 <= rhs_[i]; ++i)
+ YYCDEBUG << name_[rhs_[i]] << ' ';
+ YYCDEBUG << "-> " << name_[r1_[n_]] << std::endl;
}
#endif
switch (n_)
{
- b4_actions
+ ]b4_actions[
}
-/* Line __line__ of __file__. */
-#line __oline__ "__ofile__"
+]/* Line __line__ of lalr1.cc. */
+b4_syncline([@oline@], [@ofile@])[
state_stack_.pop (len_);
semantic_stack_.pop (len_);
location_stack_.push (yyloc);
/* 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_]];
+ n_ = r1_[n_];
+ state_ = pgoto_[n_ - ntokens_] + state_stack_[0];
+ if (0 <= state_ && state_ <= last_ && check_[state_] == state_stack_[0])
+ state_ = table_[state_];
else
- state_ = defgoto_[[n_ - ntokens_]];
+ state_ = defgoto_[n_ - ntokens_];
goto yynewstate;
/* Report and recover from errors. This is very incomplete. */
++nerrs;
#if YYERROR_VERBOSE
- n_ = pact_[[state_]];
- if (n_ > flag_ && n_ < last_)
+ n_ = pact_[state_];
+ if (pact_ninf_ < n_ && n_ < last_)
{
- message = "parse error, unexpected ";
- message += name_[[ilooka_]];
+ message = "syntax error, unexpected ";
+ message += name_[ilooka_];
{
int count = 0;
- for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
- if (check_[[x + n_]] == x)
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. */
+ int xbegin = n_ < 0 ? -n_ : 0;
+ /* Stay within bounds of both yycheck and yytname. */
+ int checklim = last_ - n_;
+ int xend = checklim < ntokens_ ? checklim : ntokens_;
+ for (int x = xbegin; x < xend; ++x)
+ if (check_[x + n_] == x && x != terror_)
++count;
if (count < 5)
{
count = 0;
- for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x)
- if (check_[[x + n_]] == x)
+ for (int x = xbegin; x < xend; ++x)
+ if (check_[x + n_] == x && x != terror_)
{
message += (!count++) ? ", expecting " : " or ";
- message += name_[[x]];
+ message += name_[x];
}
}
}
}
else
#endif
- message = "parse error";
+ message = "syntax error";
error_ ();
}
goto yyerrlab1;
- /* Error raised explicitly by an action. */
+
+ /*----------------------------------------------------.
+ | yyerrlab1 -- error raised explicitly by an action. |
+ `----------------------------------------------------*/
yyerrlab1:
if (errstatus == 3)
{
/* Return failure if at end of input. */
if (looka_ == eof_)
goto yyabortlab;
+#if YYDEBUG
YYCDEBUG << "Discarding token " << looka_
- << " (" << name_[[ilooka_]] << ")." << std::endl;
+ << " (" << name_[ilooka_] << ")." << std::endl;
+#endif
looka_ = empty_;
}
for (;;)
{
- n_ = pact_[[state_]];
- if (n_ != flag_)
+ n_ = pact_[state_];
+ if (n_ != pact_ninf_)
{
n_ += terror_;
- if (0 <= n_ && n_ <= last_ && check_[[n_]] == terror_)
+ if (0 <= n_ && n_ <= last_ && check_[n_] == terror_)
{
- n_ = table_[[n_]];
+ n_ = table_[n_];
if (0 < n_)
break;
}
}
/* Pop the current state because it cannot handle the error token. */
- if (!state_stack_.height ())
+ if (state_stack_.height () == 1)
goto yyabortlab;
#if YYDEBUG
if (debug_)
{
- if (stos_[[state_]] < ntokens_)
+ if (stos_[state_] < ntokens_)
{
YYCDEBUG << "Error: popping token "
- << token_number_[[stos_[state_]]]
- << " (" << name_[[stos_[state_]]];
+ << token_number_[stos_[state_]]
+ << " (" << name_[stos_[state_]];
# ifdef YYPRINT
- YYPRINT (stderr, token_number_[[stos_[state_]]],
+ YYPRINT (stderr, token_number_[stos_[state_]],
semantic_stack_.top ());
# endif
YYCDEBUG << ')' << std::endl;
else
{
YYCDEBUG << "Error: popping nonterminal ("
- << name_[[stos_[state_]]] << ')' << std::endl;
+ << name_[stos_[state_]] << ')' << std::endl;
}
}
#endif
- state_ = (state_stack_.pop (), state_stack_[[0]]);
+ state_ = (state_stack_.pop (), state_stack_[0]);
semantic_stack_.pop ();
location_stack_.pop ();;
}
void
-yy::b4_name::lex_ ()
+yy::]b4_parser_class_name[::lex_ ()
{
#if YYLSP_NEEDED
looka_ = yylex (&value, &location);
#endif
}
-/* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
-const short
-yy::b4_name::pact_[[]] =
+const ]b4_int_type_for([b4_pact]) yy::b4_parser_class_name::pact_ninf_ = b4_pact_ninf[;
+const ]b4_int_type_for([b4_pact])[
+yy::]b4_parser_class_name[::pact_[] =
{
- b4_pact
+ ]b4_pact[
};
-/* YYDEFACT[[S]] -- default rule to reduce with in state S when YYTABLE
+/* 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::b4_name::defact_[[]] =
+const ]b4_int_type_for([b4_defact])[
+yy::]b4_parser_class_name[::defact_[] =
{
- b4_defact
+ ]b4_defact[
};
-/* YYPGOTO[[NTERM-NUM]]. */
-const short
-yy::b4_name::pgoto_[[]] =
+/* YYPGOTO[NTERM-NUM]. */
+const ]b4_int_type_for([b4_pgoto])[
+yy::]b4_parser_class_name[::pgoto_[] =
{
- b4_pgoto
+ ]b4_pgoto[
};
-/* YYDEFGOTO[[NTERM-NUM]]. */
-const short
-yy::b4_name::defgoto_[[]] =
+/* YYDEFGOTO[NTERM-NUM]. */
+const ]b4_int_type_for([b4_defgoto])[
+yy::]b4_parser_class_name[::defgoto_[] =
{
- b4_defgoto
+ ]b4_defgoto[
};
-/* YYTABLE[[YYPACT[STATE-NUM]]]. What to do in state STATE-NUM. If
+/* 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::b4_name::table_[[]] =
+const ]b4_int_type_for([b4_table]) yy::b4_parser_class_name::table_ninf_ = b4_table_ninf[;
+const ]b4_int_type_for([b4_table])[
+yy::]b4_parser_class_name[::table_[] =
{
- b4_table
+ ]b4_table[
};
/* YYCHECK. */
-const short
-yy::b4_name::check_[[]] =
+const ]b4_int_type_for([b4_check])[
+yy::]b4_parser_class_name[::check_[] =
{
- b4_check
+ ]b4_check[
};
#if YYDEBUG
-/* STOS_[[STATE-NUM]] -- The (internal number of the) accessing
+/* STOS_[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
-const b4_uint_type(b4_stos_max)
-yy::b4_name::stos_[[]] =
+const ]b4_int_type_for([b4_stos])[
+yy::]b4_parser_class_name[::stos_[] =
{
- b4_stos
+ ]b4_stos[
};
-/* TOKEN_NUMBER_[[YYLEX-NUM]] -- Internal token number corresponding
+/* TOKEN_NUMBER_[YYLEX-NUM] -- Internal token number corresponding
to YYLEX-NUM. */
-const short
-yy::b4_name::token_number_[[]] =
+const ]b4_int_type_for([b4_toknum])[
+yy::]b4_parser_class_name[::token_number_[] =
{
- b4_toknum
+ ]b4_toknum[
};
#endif
-/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */
-const b4_uint_type(b4_r1_max)
-yy::b4_name::r1_[[]] =
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+const ]b4_int_type_for([b4_r1])[
+yy::]b4_parser_class_name[::r1_[] =
{
- b4_r1
+ ]b4_r1[
};
-/* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN. */
-const b4_uint_type(b4_r2_max)
-yy::b4_name::r2_[[]] =
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
+const ]b4_int_type_for([b4_r2])[
+yy::]b4_parser_class_name[::r2_[] =
{
- b4_r2
+ ]b4_r2[
};
#if YYDEBUG || YYERROR_VERBOSE
-/* YYTNAME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
const char*
-const yy::b4_name::name_[[]] =
+const yy::]b4_parser_class_name[::name_[] =
{
- b4_tname
+ ]b4_tname[
};
#endif
#if YYDEBUG
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-const yy::b4_name::RhsNumberType
-yy::b4_name::rhs_[[]] =
+const yy::]b4_parser_class_name[::RhsNumberType
+yy::]b4_parser_class_name[::rhs_[] =
{
- b4_rhs
+ ]b4_rhs[
};
-/* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
-const b4_uint_type(b4_prhs_max)
-yy::b4_name::prhs_[[]] =
+const ]b4_int_type_for([b4_prhs])[
+yy::]b4_parser_class_name[::prhs_[] =
{
- b4_prhs
+ ]b4_prhs[
};
-/* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */
-const b4_uint_type(b4_rline_max)
-yy::b4_name::rline_[[]] =
+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
+const ]b4_int_type_for([b4_rline])[
+yy::]b4_parser_class_name[::rline_[] =
{
- b4_rline
+ ]b4_rline[
};
#endif
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
-yy::b4_name::TokenNumberType
-yy::b4_name::translate_ (int token)
+yy::]b4_parser_class_name[::TokenNumberType
+yy::]b4_parser_class_name[::translate_ (int token)
{
static
const TokenNumberType
- translate_[[]] =
+ translate_[] =
{
- b4_translate
+ ]b4_translate[
};
if ((unsigned) token <= user_token_number_max_)
- return translate_[[token]];
+ return translate_[token];
else
return undef_token_;
}
-const int yy::b4_name::eof_ = 0;
-const int yy::b4_name::last_ = b4_last;
-const int yy::b4_name::flag_ = b4_flag;
-const int yy::b4_name::nnts_ = b4_nnts;
-const int yy::b4_name::nsym_ = b4_nsym;
-const int yy::b4_name::empty_ = -2;
-const int yy::b4_name::final_ = b4_final;
-const int yy::b4_name::terror_ = 1;
-const int yy::b4_name::errcode_ = 256;
-const int yy::b4_name::ntokens_ = b4_ntokens;
-const int yy::b4_name::initdepth_ = b4_initdepth;
-
-const unsigned yy::b4_name::user_token_number_max_ = b4_user_token_number_max;
-const yy::b4_name::TokenNumberType yy::b4_name::undef_token_ = b4_undef_token_number;
+const int yy::]b4_parser_class_name[::eof_ = 0;
+const int yy::]b4_parser_class_name[::last_ = ]b4_last[;
+const int yy::]b4_parser_class_name[::nnts_ = ]b4_nterms_number[;
+const int yy::]b4_parser_class_name[::empty_ = -2;
+const int yy::]b4_parser_class_name[::final_ = ]b4_final_state_number[;
+const int yy::]b4_parser_class_name[::terror_ = 1;
+const int yy::]b4_parser_class_name[::errcode_ = 256;
+const int yy::]b4_parser_class_name[::ntokens_ = ]b4_tokens_number[;
-b4_epilogue
+const unsigned yy::]b4_parser_class_name[::user_token_number_max_ = ]b4_user_token_number_max[;
+const yy::]b4_parser_class_name[::TokenNumberType yy::]b4_parser_class_name[::undef_token_ = ]b4_undef_token_number[;
-#output "stack.hh"
-b4_copyright
+]b4_epilogue
+dnl
+@output stack.hh
+b4_copyright([Stack handling for Bison C++ parsers], [2002, 2003])[
#ifndef BISON_STACK_HH
# define BISON_STACK_HH
inline
T&
- operator [[]] (unsigned index)
+ operator [] (unsigned index)
{
- return seq_[[index]];
+ return seq_[index];
}
inline
const T&
- operator [[]] (unsigned index) const
+ operator [] (unsigned index) const
{
- return seq_[[index]];
+ return seq_[index];
}
inline
inline
const T&
- operator [[]] (unsigned index) const
+ operator [] (unsigned index) const
{
- return stack_[[range_ - index]];
+ return stack_[range_ - index];
}
private:
};
}
-#endif // not BISON_STACK_HH
+#endif // not BISON_STACK_HH]
+dnl
+@output position.hh
+b4_copyright([Position class for Bison C++ parsers], [2002, 2003])[
+
+/**
+ ** \file position.hh
+ ** Define the Location class.
+ */
-#output "location.hh"
-b4_copyright
+#ifndef BISON_POSITION_HH
+# define BISON_POSITION_HH
+
+# include <iostream>
+# include <string>
+
+namespace yy
+{
+ /** \brief Abstract a Position. */
+ class Position
+ {
+ public:
+ /** \brief Initial column number. */
+ static const unsigned int initial_column = 0;
+ /** \brief Initial line number. */
+ static const unsigned int initial_line = 1;
+
+ /** \name Ctor & dtor.
+ ** \{ */
+ public:
+ /** \brief Construct a Position. */
+ Position () :
+ filename (),
+ line (initial_line),
+ column (initial_column)
+ {
+ }
+ /** \} */
+
+
+ /** \name Line and Column related manipulators
+ ** \{ */
+ public:
+ /** \brief (line related) Advance to the LINES next lines. */
+ inline void lines (int lines = 1)
+ {
+ column = initial_column;
+ line += lines;
+ }
+
+ /** \brief (column related) Advance to the COLUMNS next columns. */
+ inline void columns (int columns = 1)
+ {
+ int leftmost = initial_column;
+ int current = column;
+ if (leftmost <= current + columns)
+ column += columns;
+ else
+ column = initial_column;
+ }
+ /** \} */
+
+ public:
+ /** \brief File name to which this position refers. */
+ std::string filename;
+ /** \brief Current line number. */
+ unsigned int line;
+ /** \brief Current column number. */
+ unsigned int column;
+ };
+
+ /** \brief Add and assign a Position. */
+ inline const Position&
+ operator+= (Position& res, const int width)
+ {
+ res.columns (width);
+ return res;
+ }
+
+ /** \brief Add two Position objects. */
+ inline const Position
+ operator+ (const Position& begin, const int width)
+ {
+ Position res = begin;
+ return res += width;
+ }
+
+ /** \brief Add and assign a Position. */
+ inline const Position&
+ operator-= (Position& res, const int width)
+ {
+ return res += -width;
+ }
+
+ /** \brief Add two Position objects. */
+ inline const Position
+ operator- (const Position& begin, const int width)
+ {
+ return begin + -width;
+ }
+
+ /** \brief Intercept output stream redirection.
+ ** \param ostr the destination output stream
+ ** \param pos a reference to the Position to redirect
+ */
+ inline std::ostream&
+ operator<< (std::ostream& ostr, const Position& pos)
+ {
+ if (pos.filename != "")
+ ostr << pos.filename << ':';
+ return ostr << pos.line << '.' << pos.column;
+ }
+
+}
+#endif // not BISON_POSITION_HH]
+@output location.hh
+b4_copyright([Location class for Bison C++ parsers], [2002, 2003])[
+
+/**
+ ** \file location.hh
+ ** Define the Location class.
+ */
#ifndef BISON_LOCATION_HH
# define BISON_LOCATION_HH
+# include <iostream>
+# include <string>
+# include "position.hh"
+
namespace yy
{
- struct Position
+
+ /** \brief Abstract a Location. */
+ class Location
{
- int line;
- int column;
+ /** \name Ctor & dtor.
+ ** \{ */
+ public:
+ /** \brief Construct a Location. */
+ Location (void) :
+ begin (),
+ end ()
+ {
+ }
+ /** \} */
+
+
+ /** \name Line and Column related manipulators
+ ** \{ */
+ public:
+ /** \brief Reset initial location to final location. */
+ inline void step (void)
+ {
+ begin = end;
+ }
+
+ /** \brief Extend the current location to the COLUMNS next columns. */
+ inline void columns (unsigned columns = 1)
+ {
+ end += columns;
+ }
+
+ /** \brief Extend the current location to the LINES next lines. */
+ inline void lines (unsigned lines = 1)
+ {
+ end.lines (lines);
+ }
+ /** \} */
+
+
+ public:
+ /** \brief Beginning of the located region. */
+ Position begin;
+ /** \brief End of the located region. */
+ Position end;
};
- struct Location
+ /** \brief Join two Location objects to create a Location. */
+ inline const Location operator+ (const Location& begin, const Location& end)
{
- Position first;
- Position last;
- };
+ Location res = begin;
+ res.end = end.end;
+ return res;
+ }
+
+ /** \brief Add two Location objects */
+ inline const Location operator+ (const Location& begin, unsigned width)
+ {
+ Location res = begin;
+ res.columns (width);
+ return res;
+ }
+
+ /** \brief Add and assign a Location */
+ inline Location &operator+= (Location& res, unsigned width)
+ {
+ res.columns (width);
+ return res;
+ }
+
+ /** \brief Intercept output stream redirection.
+ ** \param ostr the destination output stream
+ ** \param loc a reference to the Location to redirect
+ **
+ ** Avoid duplicate information.
+ */
+ inline std::ostream& operator<< (std::ostream& ostr, const Location& loc)
+ {
+ Position last = loc.end - 1;
+ ostr << loc.begin;
+ if (loc.begin.filename != last.filename)
+ ostr << '-' << last;
+ else if (loc.begin.line != last.line)
+ ostr << '-' << last.line << '.' << last.column;
+ else if (loc.begin.column != last.column)
+ ostr << '-' << last.column;
+ return ostr;
+ }
+
}
-#endif // not BISON_LOCATION_HH
+#endif // not BISON_LOCATION_HH]
projects / bison.git / blobdiff