Compiler Explorer

Source code

//OriginalSource:
//  http://coliru.stacked-crooked.com/a/b4de81a919bec94a
//LinkedToFrom:
//  https://stackoverflow.com/questions/74963861/parse-html-with-boost-spirit-x3
//===============
#define USING_COLIRU
#include <iomanip>
#include <iostream>
#include <string>
//#define ISSUE749_EXE_TRACE
#ifdef ISSUE749_EXE_TRACE
  #pragma push_macro("FILE_SHORT")
  #define FILE_SHORT "issue749/coliru_sehe-debug-simple-rule_defn.cpp"
  #include <boost/iostreams/utility/templ_expr/demangle_fmt_type.hpp>
  #include <boost/utility/trace_scope.hpp>
  using boost::trace_scope;
#else
  struct trace_scope
    {
        std::string tag;
        trace_scope(std::string tag_)
          : tag(tag_)
          {  std::cout<<"{tag="<<tag<<";\n";
          }
        ~trace_scope()
          {  std::cout<<"}tag="<<tag<<";\n";
          }
    };
#endif//ISSUE749_EXE_TRACE

//#define BOOST_SPIRIT_X3_DEBUG
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/x3/support/traits/print_attribute.hpp>
#ifndef USE_UNFOLD_LEFT
  #include <boost/spirit/home/x3/support/ast/variant.hpp>
#endif  
namespace x3 = boost::spirit::x3;
#ifdef USING_COLIRU
/*=============================================================================
    Copyright (c) 2022 Larry Joe Evans

#ifdef USING_COLIRU
/*=============================================================================
    Copyright (c) 2022 Larry Joe Evans
    Copyright (c) 2001-2014 Joel de Guzman
    Copyright (c) 2001-2012 Hartmut Kaiser
    http://spirit.sourceforge.net/

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)
=============================================================================*/
#if !defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_NOV_9_2022_1831CST)
#define BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_NOV_9_2022_1831CST
//#define BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE
#ifdef BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE
  #define FILE_SHORT "make_transform_parser/*/traits/transform_attribute_tagged.hpp"
  #include <boost/iostreams/utility/templ_expr/demangle_fmt_type.hpp>
  #include <boost/utility/trace_scope.hpp>
  #include <type_traits>
#endif//BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE
#include <boost/spirit/home/x3/support/traits/move_to.hpp>
namespace boost { namespace spirit { namespace x3 { namespace traits
{
    ///////////////////////////////////////////////////////////////////////////
    //  transform_attribute_tagged
    //
    //  Sometimes the user needs to transform the attribute types for certain
    //  attributes. This template can be used as a customization point, where
    //  the user is able specify specific transformation rules for any attribute
    //  type.
    ///////////////////////////////////////////////////////////////////////////
      struct 
    transform_tag_default
      {};
      template 
      < typename Exposed 
        //Attribute type that's transformed from, then transformed to.
      , typename Transformed
        //"in between transform", i.e. used internally, i.e. not exposed.
      , typename TransformTag=transform_tag_default
        //distinguishes between transforms with same Exposed and Transformed
        //but different transformations.
        //One particulary important distinction is when TransformTag=rule_id<ID>
        //where ID occurs in some rule<ID,Attribute> declaration.
      >
      struct 
    transform_attribute_tagged
      {
        using type=Transformed;

#if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
        static void trace_tmpl(std::string func="trace_tmpl")
        {
            std::cout
              <<stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':',func
                )
              ;
            std::cout<<"\n:transform_attribute_tagged="<<demangle_fmt_type<transform_attribute_tagged>()<<";\n";        
        }
      #endif//defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
      
            static 
          type 
        pre(Exposed&) 
          { return Transformed(); 
          }
            static 
          auto
        post(Exposed& exposed, Transformed const& transformed)
          {
          #if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_TRANSFORMED_TAGGED_TRACE)
            trace_tmpl(__func__);
          #endif
            traits::move_to(transformed, exposed);
            return true;
          }
      };
    // handle case where no transformation is required as the types are the same
      template 
      < typename Exposed
      , typename TransformTag
      >
      struct 
    transform_attribute_tagged
      < Exposed
      , Exposed
      , TransformTag
      >
      {
        using type=Exposed&;

#if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
        static void trace_tmpl(std::string func="trace_tmpl")
        {
            std::cout
              <<stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':',func
                )
              ;
            std::cout<<":transform_attribute_tagged="<<demangle_fmt_type<transform_attribute_tagged>()<<";\n";        
        }
      #endif//defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
      
        static type pre(Exposed& val) 
        { 
          #if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
            trace_tmpl(__func__);
          #endif//BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE
            return val;
        }
        static bool post(Exposed&, Exposed const&) 
        {
          #if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
            trace_tmpl(__func__);
          #endif//BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE
            return true;
        }
          
      };
      template 
      < typename Transformed
      , typename TransformTag
      >
      struct 
    transform_attribute_tagged
      < unused_type
      , Transformed
      , TransformTag
      >
      {
        using Exposed=unused_type;
        using type=Transformed;

#if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
        static void trace_tmpl(std::string func="trace_tmpl")
        {
            std::cout
              <<stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':',func
                )
              ;
            std::cout<<":transform_attribute_tagged="<<demangle_fmt_type<transform_attribute_tagged>()<<";\n";        
        }
      #endif//defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
      
        static type pre(Exposed const&) 
          { return Transformed();
          }
        static bool post(Exposed&, Exposed const&) 
        {
          #if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
            boost::trace_scope ts
              ( stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':', __func__
                )
              );
            std::cout<<"transform_attribute_tagged:"<<__func__<<":Exposed==unused_type;\n";
          #endif//BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE
          return true;
        }
          
      };
      template 
      < typename TransformTag
      >
      struct 
    transform_attribute_tagged
      < unused_type
      , unused_type
      , TransformTag
      >
      {
        using Exposed=unused_type;
        using Transformed=unused_type;
        using type=unused_type;

#if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
        static void trace_tmpl(std::string func="trace_tmpl")
        {
            std::cout
              <<stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':',func
                )
              ;
            std::cout<<":transform_attribute_tagged="<<demangle_fmt_type<transform_attribute_tagged>()<<";\n";        
        }
      #endif//defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
      
        static type pre(Exposed const&) 
          { return Transformed();
          }
        static bool post(Exposed&, Exposed const&) 
        {
          #if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE)
            boost::trace_scope ts
              ( stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':', __func__
                )
              );
            std::cout<<"transform_attribute_tagged:"<<__func__<<":Exposed==unused_type,Transformed==unused_type;\n";
          #endif//BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE
            return true;
        }
          
      };
}}}}

#ifdef BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE
  #pragma pop_macro("FILE_SHORT")
#endif//BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE
#endif
#else
  #include <boost/spirit/home/x3/support/traits/transform_attribute_tagged.hpp>
#endif//USING_COLIRU

#include <boost/spirit/home/x3/support/traits/attribute_of.hpp>
#include <boost/spirit/home/x3/core/parse.hpp>

namespace boost{namespace spirit{namespace x3{namespace traits
{
  template
  < typename FromParser
  , typename ToAttribute
  , typename TransformTag=transform_tag_default
  >
struct transform_parser_attribute
  : x3::parser
    < transform_parser_attribute
      < FromParser
      , ToAttribute
      , TransformTag
      >
    >
  //A parser using FromParser, but transforming FromParser's attribute 
  //to a ToAttribute.
  {
  private:
      FromParser from_parser;
  public:
  
      transform_parser_attribute(FromParser p)
        : from_parser(p)
        {
          #if 0 && defined(BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE)
            boost::trace_scope ts
            ( stringify
              ( FILE_SHORT
              , ':', __LINE__
              , ':', __func__,"(FromParser p)"
              )
            );
            std::cout<<":*this="<<demangle_fmt_type<transform_parser_attribute>()<<";\n";
          #endif//BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
        }
      using attribute_type = ToAttribute;
        template
        < typename Iterator
        , typename Ctx
        , typename Rctx
        >
        bool 
      parse
        ( Iterator& f, Iterator l
        , Ctx&context
        , Rctx&r_ctx
        , ToAttribute& to_attr
        ) const
        {
            using to_attribute_type=ToAttribute;
            using from_attribute_type=typename attribute_of<FromParser,Ctx>::type;
            using transform = 
                traits::transform_attribute_tagged
                < to_attribute_type
                , from_attribute_type
                , TransformTag
                >;
            using transform_type=typename transform::type;
          #ifdef BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
            boost::trace_scope ts
              ( stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':', __func__,"(,Ctx&,Rctx&,ToAttribute&)"
                )
              );
            std::cout<<":FromParser=\n"<<demangle_fmt_type<FromParser>()<<";\n";
            std::cout<<":ToAttribute=\n"<<demangle_fmt_type<ToAttribute>()<<";\n";
            std::cout<<":TransformTag=\n"<<demangle_fmt_type<TransformTag>()<<";\n";
            std::cout<<":from_attribute_type=\n"<<demangle_fmt_type<from_attribute_type>()<<";\n";          
            std::cout<<":transform_type=\n"<<demangle_fmt_type<transform_type>()<<";\n";
            //transform::trace_tmpl();
          #endif//BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
            transform_type from_attr=transform::pre(to_attr);
            bool result=
              from_parser.parse
              ( f, l
              , context
              , r_ctx
              , from_attr
              );
          #ifdef BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
            std::cout<<FILE_SHORT<<':'<<__LINE__<<":result.parse="<<result<<";\n";
          #endif//BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
            if(result)
            {
                result=transform::post(to_attr,from_attr);
              #ifdef BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
                std::cout<<FILE_SHORT<<':'<<__LINE__<<":result.post="<<result<<";\n";
              #endif//BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
            }
            return result;
        }
        template
        < typename Iterator
        , typename Ctx
        >
        bool 
      parse
        ( Iterator& f, Iterator l
        , Ctx&context
        , ToAttribute& to_attr
        ) const
        {
          #ifdef BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
            boost::trace_scope ts
              ( stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':', __func__,"(,Ctx&,ToAttribute&)"
                )
              );
            std::cout<<":FromParser="<<demangle_fmt_type<FromParser>()<<";\n";
            std::cout<<":ToAttribute="<<demangle_fmt_type<ToAttribute>()<<";\n";
            std::cout<<":TransformTag="<<demangle_fmt_type<TransformTag>()<<";\n";
            std::cout<<":Ctx="<<demangle_fmt_type<Ctx>()<<";\n";
          #endif//BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
            bool result=from_parser.parse
              ( f, l
              , context
              , context
              , to_attr
              );
            return result;
        }
  };
  template
  < typename ToAttribute
  , typename FromParser
  , typename TransformTag=transform_tag_default
  >
  auto
make_transform_parser
  ( FromParser from_parser
  )
  {  return transform_parser_attribute<FromParser,ToAttribute,TransformTag>{from_parser};
  }
}}}}
#ifdef BOOST_SPIRIT_X3_CORE_MAKE_TRANSFORM_PARSER_TRACE
  #pragma pop_macro("FILE_SHORT")
#endif  
#endif

#else
  #include <boost/spirit/home/x3/core/make_transform_parser.hpp>
#endif//USING_COLIRU
#include <boost/fusion/sequence/intrinsic/at_c.hpp>

using namespace std::string_literals;

namespace Ast {
    struct html_tag_block;

using tag_header = unsigned int;
    using html_content = unsigned int;
  #ifndef USE_UNFOLD_LEFT
    #define SPIRIT_X3_ALTERNATIVE_VARIANT x3::variant
  #endif
    using html_element =
        SPIRIT_X3_ALTERNATIVE_VARIANT
        < html_content
        , boost::recursive_wrapper<html_tag_block>
        >;
        
    using html_elements = std::vector<html_element>;

struct html_tag_block {
        tag_header    header;
        html_elements children;
    };
} // namespace Ast

BOOST_FUSION_ADAPT_STRUCT(Ast::html_tag_block, header, children)

namespace Parser {
    struct tag_block__rid;
    struct html_element__rid;
    
      auto 
    tag_name_
      = x3::uint_
      ;
      auto 
    tag_header_
      = 
      (  '<' 
      >> tag_name_ 
      >> '>'
      )
      ;
      auto 
    tag_footer_
      = 
      (  "</"
      >> tag_name_ 
      >> '>'
      )
      ;
      x3::rule<tag_block__rid, Ast::html_tag_block>
    tag_block_    = "TagBlock"
      ;
    auto html_content_ = 
      x3::uint_
      /*
       * This corresponds to "The content" described in
       * item 3 of
       * https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web/HTML_basics#anatomy_of_an_html_element
       */
      ;
    auto html_element__def = 
        html_content_ 
      | tag_block_
      ;
      x3::rule<html_element__rid, Ast::html_element> 
    html_element_ = "HtmlElement"
      ;
      auto 
    tag_block_def =
         tag_header_
      >> *html_element_ 
      >> tag_footer_
      ;
}

namespace boost { namespace spirit { namespace x3 { namespace traits
{
      template 
      < typename ToFrom
      >
      struct 
    transform_attribute_tagged
      < Ast::html_tag_block
      , ToFrom
      , x3::detail::rule_id<Parser::tag_block__rid>
      >
      {
        using FromTo=Ast::html_tag_block;
        using type=ToFrom;

#define BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE_HTML_TAG
      #if defined(ISSUE749_EXE_TRACE) && defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE_HTML_TAG)
        static void trace_tmpl(std::string func="trace_tmpl")
        {
            std::cout
              <<stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':',func
                )
              ;
            std::cout<<"\n:transform_attribute_tagged=\n"<<demangle_fmt_type<transform_attribute_tagged>()<<";\n";        
        }
      #endif//defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE_HTML_TAG)
      
        static type pre(FromTo&) 
          { return ToFrom(); 
          }
        static bool post(FromTo& val, ToFrom const& attribute)
          {
          #if defined(ISSUE749_EXE_TRACE) && defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE_HTML_TAG)
            std::cout
              <<stringify
                ( FILE_SHORT
                , ':', __LINE__
                , ':',__func__
                )
              ;
            std::cout<<":FromTo=\n"<<demangle_fmt_type<FromTo>()<<";\n";
            std::cout<<":ToFrom=\n"<<demangle_fmt_type<ToFrom>()<<";\n";
          #endif
            using boost::fusion::at_c;
            auto tag_beg=at_c<0>(attribute);
            auto tag_end=at_c<2>(attribute);
            bool const matched=tag_beg == tag_end;
          #if defined(BOOST_SPIRIT_X3_TRAITS_TRANSFORM_ATTRIBUTE_TAGGED_TRACE_HTML_TAG)
            std::cout<<":tag_beg="<<tag_beg<<";\n";
            std::cout<<":tag_end="<<tag_end<<";\n";
            std::cout<<":matched="<<matched<<";\n";
          #endif
            if(matched)
            {
                at_c<0>(val)=at_c<0>(attribute);
                at_c<1>(val)=at_c<1>(attribute);
            }
            return matched;
          }
      };
}}}}

namespace Parser {
    #ifdef USE_RULE_DEFN
        auto
      tag_block__def =
        tag_block_def
        ;
    #else
        using
      tag_block_def_t=decltype(tag_block_def)
        ;
        auto 
      tag_block__def =
        x3::traits::make_transform_parser
        < Ast::html_tag_block
        , tag_block_def_t
        , x3::detail::rule_id<Parser::tag_block__rid>
        >
        ( tag_block_def
        )
        ;
    #endif
    
    BOOST_SPIRIT_DEFINE(tag_block_, html_element_)
}

namespace unit_tests {
    template <bool ShouldSucceed = true, typename P>
    void test(P const& start, std::initializer_list<std::string> cases) {
        for (auto input : cases) {
            typename x3::traits::attribute_of<P, x3::unused_type>::type attr_of;
          #ifdef ISSUE749_EXE_TRACE
            std::cout<<":attr_of=\n"<<demangle_fmt_type(attr_of)<<";\n";
          #endif
            auto ok = phrase_parse(input.begin(), input.end(), start, x3::space, attr_of);
            std::cout 
              << quoted(input) << " -> " 
              << (ok ? "SUCCEEDED" : "FAILED") << " and "
              << (ShouldSucceed ? "ShouldSucceed" : "ShouldFail")
              << std::endl;
            std::cout<<":result attr_of=\n";
            x3::traits::print_attribute(std::cout,attr_of);
            std::cout<<";\n";
        }
    }
}

int main() {
  #if 1 && defined(ISSUE749_EXE_TRACE)
      boost::iostreams::indent_scoped_ostreambuf<char>
    indent_outbuf(std::cout,2);
  #endif
    std::cout<<std::boolalpha;
  #if 0
    { 
        trace_scope ts("tag_name_");
        unit_tests::test
        ( Parser::tag_name_
        , { R"(123)"
          , R"(456)"
          }
        );
    }
  #endif
  #if 1
    {
        trace_scope ts("html_element_ pass");
        unit_tests::test
        ( Parser::html_element_
        , { R"(999)"
          , R"(<0></0>)"
          , R"(<1>777 888</1>)"
          //R"(<0><1>11</1><2>22</2></0>)"
          }
        );
    }
  #endif
  #if 1
    {
        trace_scope ts("html_element_ fail");
        unit_tests::test<false>
        ( Parser::html_element_
        , { R"(<0></1>)"
          , R"(<0>999</1>)"
          }
        );
    }
  #endif                            
}
#ifdef ISSUE749_EXE_TRACE
  #pragma pop_macro("FILE_SHORT")
#endif