Pretty and simple debug lib for parser rule?

[fasxmut]

As a new comer to boost spirit, I can not understand why I can not replace it in spirit x3 example rexpr_min/rexpr.cpp:

const auto quoted_string = x3::lexeme['"' >> *(x3::char_ - '"') >> '"'];

with set key_string to key:

const auto key_string = x3::lexeme[(x3::alpha | '_') >> *(x3::alpha | x3::digit | '_')];

When passing the final parser expr to x3::phrase_parse, it gives me huge lines of errror message, hard to read.

So is there a pretty and simple debug lib for boost spirit just like static_assert, std::same_as to dig the type and error?

[cppljevans]

This link gives some hints.

In short, use raw directive to get a string value. As expressed above, the attribute of key_string is not a string,but the following:

boost::fusion::deque 
< boost::optional 
  < char 
  >
, std::vector 
  < boost::optional 
    < char 
    >
  , std::allocator 
    < boost::optional 
      < char 
      >
    >
  >
>

In addition, when you removed the quotes around the key_string, this required a change to to rexpr_value_def:

    auto key_string_yes_784_lex =
        lexeme[(x3::alpha | '_') >> *(x3::alpha | x3::digit | '_')];
    auto key_string_yes_784_def =
        raw[key_string_yes_784_lex];
    auto key_string_not_784_def =
        lexeme['"' >> *(char_ - '"') >> '"'];
    auto key_string_def =
      #ifdef ISSUE784_TEST
        key_string_yes_784_def;
      #else
        key_string_not_784_def;
      #endif//ISSUE784_TEST
    auto rexpr_value_def =
      #ifdef ISSUE784_TEST
        key_string_not_784_def | rexpr;
      #else
        key_string | rexpr;
      #endif

when defined(ISSUE784_TEST).

This is because the rexpr_value_def requires quotes, but the key_string, as you've modified, does not.

Relevant docs are here.

Complete code illustrating solution is:

//Purpose:
//  Provide the test case illustrating:
//    https://github.com/boostorg/spirit/discussions/784
#define DEBUG_REXPR
#ifdef DEBUG_REXPR
  #include <boost/iostreams/utility/indent_scoped_ostreambuf.hpp>
  #include <boost/iostreams/utility/templ_expr/demangle_fmt_type.hpp>
#endif//DEBUG_REXPR  
/*=============================================================================
    Copyright (c) 2001-2015 Joel de Guzman

    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
///////////////////////////////////////////////////////////////////////////////
//
//  A simple parser for X3 intended as a minimal starting point.
//  'rexpr' is a parser for a language resembling a minimal subset
//  of json, but limited to a dictionary (composed of key=value pairs)
//  where the value can itself be a string or a recursive dictionary.
//
//  Example:
//
//  {
//      "color" = "blue"
//      "size" = "29 cm."
//      "position" = {
//          "x" = "123"
//          "y" = "456"
//      }
//  }
//
///////////////////////////////////////////////////////////////////////////////

#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/x3/support/ast/variant.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/std_pair.hpp>
#include <boost/fusion/include/io.hpp>

#include <iostream>
#include <fstream>
#include <string>
#include <map>

///////////////////////////////////////////////////////////////////////////////
//  Our AST
///////////////////////////////////////////////////////////////////////////////
namespace client { namespace ast
{
    namespace fusion = boost::fusion;
    namespace x3 = boost::spirit::x3;

    struct rexpr;

    struct rexpr_value : x3::variant<
            std::string
          , x3::forward_ast<rexpr>
        >
    {
        using base_type::base_type;
        using base_type::operator=;
    };

    typedef std::map<std::string, rexpr_value> rexpr_map;
    typedef std::pair<std::string, rexpr_value> rexpr_key_value;

    struct rexpr
    {
        rexpr_map entries;
    };
}}

// We need to tell fusion about our rexpr struct
// to make it a first-class fusion citizen
BOOST_FUSION_ADAPT_STRUCT(client::ast::rexpr,
    entries
)
#define ISSUE784_TEST
///////////////////////////////////////////////////////////////////////////////
//  AST processing
///////////////////////////////////////////////////////////////////////////////
namespace client { namespace ast
{
    ///////////////////////////////////////////////////////////////////////////
    //  Print out the rexpr tree
    ///////////////////////////////////////////////////////////////////////////
    int const tabsize = 4;

    struct rexpr_printer
    {
        typedef void result_type;

        rexpr_printer(int indent = 0)
          : indent(indent) {}

        void operator()(rexpr const& ast) const
        {
            std::cout << '{' << std::endl;
            for (auto const& entry : ast.entries)
            {
                tab(indent+tabsize);
              #ifdef ISSUE784_TEST
                std::cout        << entry.first << " = ";
              #else
                std::cout << '"' << entry.first << "\" = ";
              #endif
                boost::apply_visitor(rexpr_printer(indent+tabsize), entry.second);
            }
            tab(indent);
            std::cout << '}' << std::endl;
        }

        void operator()(std::string const& text) const
        {
            std::cout << '"' << text << '"' << std::endl;
        }

        void tab(int spaces) const
        {
            for (int i = 0; i < spaces; ++i)
                std::cout << ' ';
        }

        int indent;
    };
}}
///////////////////////////////////////////////////////////////////////////////
//  Our rexpr grammar
///////////////////////////////////////////////////////////////////////////////
namespace client { namespace parser
{
    namespace x3 = boost::spirit::x3;
    namespace ascii = boost::spirit::x3::ascii;

    using x3::lit;
    using x3::lexeme;
    using x3::raw;

    using ascii::char_;
    using ascii::string;

    x3::rule<class rexpr_value, ast::rexpr_value>
        rexpr_value = "rexpr_value";

    x3::rule<class rexpr, ast::rexpr>
        rexpr = "rexpr";

    x3::rule<class rexpr_key_value, ast::rexpr_key_value>
        rexpr_key_value = "rexpr_key_value";
        
    x3::rule<class key_string, std::string>
        key_string = "key_string";
        
    auto key_string_yes_784_lex =
        lexeme[(x3::alpha | '_') >> *(x3::alpha | x3::digit | '_')];
    auto key_string_yes_784_def =
        raw[key_string_yes_784_lex];
    auto key_string_not_784_def =
        lexeme['"' >> *(char_ - '"') >> '"'];
    auto key_string_def =
      #ifdef ISSUE784_TEST
        key_string_yes_784_def;
      #else
        key_string_not_784_def;
      #endif//ISSUE784_TEST
    auto rexpr_value_def =
      #ifdef ISSUE784_TEST
        key_string_not_784_def | rexpr;
      #else
        key_string | rexpr;
      #endif

    auto rexpr_key_value_def =
        key_string >> '=' >> rexpr_value;

    auto rexpr_def =
        '{' >> *rexpr_key_value >> '}';

    BOOST_SPIRIT_DEFINE(rexpr_value, rexpr, rexpr_key_value, key_string);
}}

///////////////////////////////////////////////////////////////////////////////
//  Main program
///////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
  #ifdef DEBUG_REXPR
      boost::iostreams::indent_scoped_ostreambuf<char>
    indent_outbuf(std::cout,2);
    std::cout<<std::boolalpha;
    namespace x3 = boost::spirit::x3;
    {
      using namespace client::parser;
      using lex_yes_784=decltype(key_string_yes_784_lex);
      using aof_lex_yes_784=typename x3::traits::attribute_of<lex_yes_784,x3::unused_type>::type;
      std::cout<<":aof_lex_yes_784=\n"<<demangle_fmt_type<aof_lex_yes_784>()<<";\n";
      using def_yes_784=decltype(key_string_yes_784_def);
      using aof_def_yes_784=typename x3::traits::attribute_of<def_yes_784,x3::unused_type>::type;
      std::cout<<":aof_def_yes_784=\n"<<demangle_fmt_type<aof_def_yes_784>()<<";\n";
      using def_not_784=decltype(key_string_not_784_def);
      using aof_def_not_784=typename x3::traits::attribute_of<def_not_784,x3::unused_type>::type;
      std::cout<<":aof_def_not_784=\n"<<demangle_fmt_type<aof_def_not_784>()<<";\n";
    }
  #endif//DEBUG_REXPR
    

    using client::parser::rexpr; // Our grammar

    using boost::spirit::x3::ascii::space;
    
      struct
    inp_expect_t
      { std::string inp
      ; bool expected
      ;};
    bool all_as_expected=true;
    for 
    ( inp_expect_t inp_expect_v
    #ifdef ISSUE784_TEST
    : { inp_expect_t
        { R"(
{
    color = "blue"
    size = "29 cm."
    position = {
        x = "123"
        y = "456"
    }
}
          )"
        , true
        }
    #else
    : { inp_expect_t
        { R"(
{
    "color" = "blue"
    "size" = "29 cm."
    "position" = {
        "x" = "123"
        "y" = "456"
    }
}
          )"
        , true
        }
    #endif//ISSUE784_TEST
      }//: { inp_expect_t
    )
    {
        std::cout<<":inp="<<inp_expect_v.inp<<";\n";
        client::ast::rexpr tree_ast; // Our tree
        auto iter = inp_expect_v.inp.begin();
        auto end = inp_expect_v.inp.end();
        bool result = 
          x3::phrase_parse
          ( iter, end
          , rexpr
          , x3::ascii::space
          , tree_ast
          );
        bool at_end = (iter == end);
        std::cout << ":at_end="<<at_end<<"\n";
        if(!at_end)
        { std::string remaining_input(iter,end)
        ; std::cout << "  :remaining input="<<remaining_input<<"\n"
        ;}
        std::cout << ":tree_ast=\n";
        client::ast::rexpr_printer printer;
        printer(tree_ast);
        bool actual=result&&at_end;
        bool expected=inp_expect_v.expected;
        std::cout<<":expected="<<expected<<":actual="<<actual<<"\n";
        bool const now_as_expected=expected==actual;
        std::cout<<":now_as_expected="<<now_as_expected<<"\n";
        all_as_expected&=now_as_expected;
        std::cout << "-------------------------\n";
        if (actual)
        {
            std::cout << "Parsing succeeded\n";
        }
        else
        {
            std::cout << "Parsing failed\n";
        }
        std::cout << "-------------------------\n";
    }
    std::cout<<":all_as_expected="<<all_as_expected<<"\n";
    return 0;    
}

That code includes debug macros, DEBUG_REXPR which you'll have to disable since leaving enabled will cause compiler to attempt to #include debug files only located on my local disk.