Boost Spirit：附加到字符串的子语法？

Question

我在玩 Boost.Spirit。作为一项更大工作的一部分，我正在尝试构建用于解析 C/C++ 样式字符串文字的语法。我遇到了一个问题：

我如何创建一个子语法附加一个std::string()结果到调用语法的std::string()属性（而不仅仅是 char?

这是我的代码，目前运行良好。（其实我已经得到了很多，包括'\n'等东西，但我把它精简了。）

#define BOOST_SPIRIT_UNICODE

#include <string>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>

using namespace boost;
using namespace boost::spirit;
using namespace boost::spirit::qi;

template < typename Iterator >
struct EscapedUnicode : grammar< Iterator, char() > // <-- should be std::string
{
    EscapedUnicode() : EscapedUnicode::base_type( escaped_unicode )
    {
        escaped_unicode %= "\" > ( ( "u" >> uint_parser< char, 16, 4, 4 >() )
                                  | ( "U" >> uint_parser< char, 16, 8, 8 >() ) );
    }

    rule< Iterator, char() > escaped_unicode;  // <-- should be std::string
};

template < typename Iterator >
struct QuotedString : grammar< Iterator, std::string() >
{
    QuotedString() : QuotedString::base_type( quoted_string )
    {
        quoted_string %= '"' >> *( escaped_unicode | ( char_ - ( '"' | eol ) ) ) >> '"';
    }

    EscapedUnicode< Iterator > escaped_unicode;
    rule< Iterator, std::string() > quoted_string;
};

int main()
{
    std::string input = "\"foo\u0041\"";
    typedef std::string::const_iterator iterator_type;
    QuotedString< iterator_type > qs;
    std::string result;
    bool r = parse( input.cbegin(), input.cend(), qs, result );
    std::cout << result << std::endl;
}

这会打印 fooA -- QuotedString 语法调用 EscapedUnicode 语法，这导致 char 被添加到 std::string 属性QuotedString (A, 0x41).

但是我当然需要为超过 0x7f 的任何内容生成一个 字符（字节）序列。 EscapedUnicode 需要生成一个 std::string，它必须附加到 QuotedString.

生成的字符串

这就是我遇到障碍的地方。我不明白 Boost.Spirit 与 Boost.Phoenix 协同作用的结果，我所做的任何尝试都会导致冗长且几乎无法辨认的与模板相关的编译器错误。

那么，我该怎么做呢？答案实际上不需要进行正确的 Unicode 转换；这是我需要解决的 std::string 问题。

Answer 1

应用的几点：

请不要覆盖 using namespace 高度通用的代码。 ADL 除非你能控制它，否则它会毁了你的一天
运算符 %= 是 自动规则分配 ，这意味着即使存在语义操作，也会强制进行自动属性传播。您不希望这样，因为如果您想编码为多字节字符串表示形式，uint_parser 公开的属性将不会（正确）自动传播。
输入字符串
```
std::string input = "\"foo\u0041\"";
```
需要
```
std::string input = "\"foo\u0041\"";
```
否则编译器甚至在解析器运行之前就进行了转义处理:)

下面是任务的具体技巧：

您需要将规则的声明属性更改为 Spirit 会自动 "flatten" 以简单顺序进行的设置。例如
```
quoted_string = '"' >> *(escaped_unicode | (qi::char_ - ('"' | qi::eol))) >> '"';
```
不会追加，因为替代的第一个分支产生一个字符序列，第二个分支产生单个字符。等效的以下拼写：
```
quoted_string = '"' >> *(escaped_unicode | +(qi::char_ - ('"' | qi::eol | "\u" | "\U"))) >> '"';
```
巧妙地触发Spirit中的附加启发式，这样我们就可以实现我们想要的without involving Semantic Actions。

剩下的很简单：

使用 Phoenix 函数对象实现实际编码：

struct encode_f {
    template <typename...> struct result { using type = void; };

    template <typename V, typename CP> void operator()(V& a, CP codepoint) const {
        // TODO implement desired encoding (e.g. UTF8)
        bio::stream<bio::back_insert_device<V> > os(a);
        os << "[" << std::hex << std::showbase << std::setw(std::numeric_limits<CP>::digits/4) << std::setfill('0') << codepoint << "]";
    }
};
boost::phoenix::function<encode_f> encode;

你可以这样使用：

escaped_unicode = '\' > ( ("u" >> uint_parser<uint16_t, 16, 4, 4>() [ encode(_val, _1) ])
                         | ("U" >> uint_parser<uint32_t, 16, 8, 8>() [ encode(_val, _1) ]) );

Because you mentioned you don't care about the specific encoding, I elected to encode the raw codepoint in 16bit or 32bit hex representation like [0x0041]. I pragmatically used Boost Iostreams which is capable of directly writing into the attribute's container type

使用BOOST_SPIRIT_DEBUG*宏

Live On Coliru

//#define BOOST_SPIRIT_UNICODE
//#define BOOST_SPIRIT_DEBUG

#include <string>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

// for demo re-encoding
#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/stream.hpp>
#include <iomanip>

namespace qi  = boost::spirit::qi;
namespace bio = boost::iostreams;
namespace phx = boost::phoenix;

template <typename Iterator, typename Attr = std::vector<char> > // or std::string for that matter
struct EscapedUnicode : qi::grammar<Iterator, Attr()>
{
    EscapedUnicode() : EscapedUnicode::base_type(escaped_unicode)
    {
        using namespace qi;

        escaped_unicode = '\' > ( ("u" >> uint_parser<uint16_t, 16, 4, 4>() [ encode(_val, _1) ])
                                 | ("U" >> uint_parser<uint32_t, 16, 8, 8>() [ encode(_val, _1) ]) );

        BOOST_SPIRIT_DEBUG_NODES((escaped_unicode))
    }

    struct encode_f {
        template <typename...> struct result { using type = void; };

        template <typename V, typename CP> void operator()(V& a, CP codepoint) const {
            // TODO implement desired encoding (e.g. UTF8)
            bio::stream<bio::back_insert_device<V> > os(a);
            os << "[0x" << std::hex << std::setw(std::numeric_limits<CP>::digits/4) << std::setfill('0') << codepoint << "]";
        }
    };
    boost::phoenix::function<encode_f> encode;

    qi::rule<Iterator, Attr()> escaped_unicode;
};

template <typename Iterator>
struct QuotedString : qi::grammar<Iterator, std::string()>
{
    QuotedString() : QuotedString::base_type(start)
    {
        start = quoted_string;
        quoted_string = '"' >> *(escaped_unicode | +(qi::char_ - ('"' | qi::eol | "\u" | "\U"))) >> '"';
        BOOST_SPIRIT_DEBUG_NODES((start)(quoted_string))
    }

    EscapedUnicode<Iterator> escaped_unicode;
    qi::rule<Iterator, std::string()> start;
    qi::rule<Iterator, std::vector<char>()> quoted_string;
};

int main() {
    std::string input = "\"foo\u0041\U00000041\"";

    typedef std::string::const_iterator iterator_type;
    QuotedString<iterator_type> qs;
    std::string result;
    bool r = parse( input.cbegin(), input.cend(), qs, result );
    std::cout << std::boolalpha << r << ": '" << result << "'\n";
}

打印：

true: 'foo[0x0041][0x00000041]'

Boost Spirit：附加到字符串的子语法？

Boost Spirit: Sub-grammar appending to string?

boost

boost-spirit

boost-spirit-qi

c++11