C++: String and unions bison

Question

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

Answer 1

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.

Answer 2

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.

Answer 3

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;  
}