I am building a compiler in flex and bison. The thing is that using char *
is giving a lot of problems so I'm trying to migrate everything to string
.
The only problem left is that there is a union
with strings. I know that this is not a standard, but by using pointers there should be no problem.
Relevant code:
#include <string>
using namespace std;
//-- SYMBOL SEMANTIC VALUES -----------------------------
%union {
struct lc{
string * code;
string * start;
string * verdadero;
string * falso;
string * next;
}code;
}
The weird thing is the error I'm receiving:
file.ypp:39:6: error: ‘string’ does not name a type
string * start;
file.ypp:40:6: error: ‘string’ does not name a type
string * verdadero;
file.ypp:41:6: error: ‘string’ does not name a type
string * falso;
file.ypp:42:6: error: ‘string’ does not name a type
string * next;
Edit: Forgot to mention that using std::string
inside the union
has the same problem
The problem is that the code in the %{
...%}
is only included the y.tab.c
file generated by bison. It in NOT included in the y.tab.h
file. The %union
code, on the other hand, IS included in y.tab.h
(it's part of the YYSTYPE
definition). So if your %union
depends on other declarations, simply putting those declarations (or an #include
) in %{
...%}
won't always work.
Instead, you need to manually insure that those declarations always occur before you #include "y.tab.h"
in any other file -- anywhere you have #include "y.tab.h"
make
sure you have #include <string>
(and the using
if you really want that) before the #include "y.tab.h"
line. Putting it all in another header file you include is a good option.
Alternately, with bison (but not yacc), you can use %code requires {
...}
in the first section of the .y
file. Anything in such a block will be copied verbatim into both the y.tab.h
and y.tab.c
files.
You should have a look at Bison 3 and its support for variants. The following example shows how to store real objects in the stack.
The most important parts to enable variant support are:
%define api.value.type variant
...
%token <::std::string> TEXT;
%token <int> NUMBER;
%printer { yyo << $$; } <*>;
%token END_OF_FILE 0;
%type <::std::string> item;
%type <::std::list<std::string>> list;
Here is a full example, taken from Bison.
%debug
%language "c++"
%defines
%define api.token.constructor
%define api.value.type variant
%define parse.assert
%locations
%code requires // *.hh
{
#include <list>
#include <string>
typedef std::list<std::string> strings_type;
}
%code // *.cc
{
#include <algorithm>
#include <iostream>
#include <iterator>
#include <sstream>
// Prototype of the yylex function providing subsequent tokens.
namespace yy
{
static parser::symbol_type yylex ();
}
// Printing a list of strings.
// Koening look up will look into std, since that's an std::list.
namespace std
{
std::ostream&
operator<< (std::ostream& o, const strings_type& ss)
{
o << "(" << &ss << ") {";
const char *sep = "";
for (strings_type::const_iterator i = ss.begin(), end = ss.end();
i != end; ++i)
{
o << sep << *i;
sep = ", ";
}
return o << "}";
}
}
// Conversion to string.
template <typename T>
inline
std::string
string_cast (const T& t)
{
std::ostringstream o;
o << t;
return o.str ();
}
}
%token <::std::string> TEXT;
%token <int> NUMBER;
%printer { yyo << $$; } <*>;
%token END_OF_FILE 0;
%type <::std::string> item;
%type <::std::list<std::string>> list;
%%
result:
list { std::cout << $1 << std::endl; }
;
list:
/* nothing */ { /* Generates an empty string list */ }
| list item { std::swap ($$, $1); $$.push_back ($2); }
;
item:
TEXT { std::swap ($$, $1); }
| NUMBER { $$ = string_cast ($1); }
;
%%
namespace yy
{
// The yylex function providing subsequent tokens:
// TEXT "I have three numbers for you."
// NUMBER 1
// NUMBER 2
// NUMBER 3
// TEXT "And that's all!"
// END_OF_FILE
static
parser::symbol_type
yylex ()
{
static int stage = -1;
++stage;
parser::location_type loc(0, stage + 1, stage + 1);
switch (stage)
{
case 0:
return parser::make_TEXT ("I have three numbers for you.", loc);
case 1:
case 2:
case 3:
return parser::make_NUMBER (stage, loc);
case 4:
return parser::make_TEXT ("And that's all!", loc);
default:
return parser::make_END_OF_FILE (loc);
}
}
// Mandatory error function
void
parser::error (const parser::location_type& loc, const std::string& msg)
{
std::cerr << loc << ": " << msg << std::endl;
}
}
int
main ()
{
yy::parser p;
p.set_debug_level (!!getenv ("YYDEBUG"));
return p.parse ();
}
Bison actually ships with several examples, including in C++. They should be installed on your machine, see /usr/local/share/doc/bison/examples/c++
(where /usr/local
depends on your configuration).
You can browse the C++ examples online on Savannah or on GitHub.
Seems the generated file does not get the namespace. Try using std::string* ... inside the struct lc { } and put the #include into the right place where it is included into the generated files.
EDIT: your file should look something like that:
%{
#include <string>
%}
%union {
struct lc{
std::string * code;
std::string * start;
std::string * verdadero;
std::string * falso;
std::string * next;
}code;
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With