使用QJsonDocument将子字符串解析为JSON

Parse a substring as JSON using QJsonDocument

本文关键字：JSON 字符串 QJsonDocument 使用      更新时间：2023-10-16

我有一个字符串，其中包含(不是是) json编码的数据，如以下示例:

foo([1, 2, 3], "some more stuff")
    |        |
  start     end   (of JSON-encoded data)

我们在应用程序中使用的完整语言包含json编码的数据，而语言的其余部分是微不足道的(只是递归的东西)。当在递归解析器中从左到右解析这样的字符串时，我知道什么时候遇到json编码的值，就像这里从索引4开始的[1, 2, 3]。解析完这个子字符串后，我需要知道结束位置，以便继续解析字符串的其余部分。

我想把这个子字符串传递给一个经过良好测试的json解析器，比如Qt5中的QJsonDocument。但是在阅读文档时，没有可能将子字符串解析为JSON，这意味着一旦解析的数据结束(在这里消费]之后)控制返回而不报告解析错误。此外，我需要知道结束位置以继续解析我自己的内容(这里剩余的字符串是, "some more stuff"))。

为了做到这一点，我过去使用一个自定义JSON解析器，它通过引用获取当前位置，并在完成解析后更新它。但是由于它是业务应用程序的安全关键部分，我们不想再坚持使用我自己制作的解析器了。我的意思是有QJsonDocument，所以为什么不使用它。(我们已经使用了Qt5)

作为一种变通方法，我正在考虑这种方法:

  • 让QJsonDocument解析从当前位置开始的子字符串(这是无效的JSON)
  • 错误报告一个意外字符，这是JSON
    • 之外的某个位置
  • 让QJsonDocument再次解析，但这次是具有正确结束位置的子字符串

第二个想法是编写一个"JSON结束扫描器"，它接受整个字符串，一个开始位置并返回JSON编码数据的结束位置。这也需要解析，因为不匹配的括号/圆括号可能出现在字符串值中，但是与完全手工制作的json解析器相比，编写(和使用)这样的类应该更容易(也更安全)。

谁有更好的主意?

我使用Spirit Qi滚动了一个基于http://www.ietf.org/rfc/rfc4627.txt的快速解析器[*]。

它实际上不解析为AST，但它解析所有JSON有效负载，这实际上比这里需要的要多一点。

示例这里 (http://liveworkspace.org/code/3k4Yor$2)输出:

Non-JSON part of input starts after valid JSON: ', "some more stuff")'

根据OP给出的测试:

const std::string input("foo([1, 2, 3], "some more stuff")");
// set to start of JSON
auto f(begin(input)), l(end(input));
std::advance(f, 4);
bool ok = doParse(f, l); // updates f to point after the start of valid JSON
if (ok) 
    std::cout << "Non-JSON part of input starts after valid JSON: '" << std::string(f, l) << "'n";

我已经测试了其他几个更复杂的JSON文档(包括多行)。

注释:

  • 我使解析器基于迭代器，所以它很可能很容易与Qt字符串(?)
  • 如果你想禁止多行片段，将标题符从qi::space更改为qi::blank
  • 有一个关于数字解析的一致性快捷方式(见TODO)，它不会影响这个答案的有效性(见注释)。
从技术上讲，

[*]更像是一个解析器存根，因为它不会转换成其他东西。它基本上是一个词法分析器承担了太多的工作:)

示例的完整代码:

// #define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>
namespace qi = boost::spirit::qi;
template <typename It, typename Skipper = qi::space_type>
    struct parser : qi::grammar<It, Skipper>
{
    parser() : parser::base_type(json)
    {
        // 2.1 values
        value = qi::lit("false") | "null" | "true" | object | array | number | string;
        // 2.2 objects
        object = '{' >> -(member % ',') >> '}';
        member = string >> ':' >> value;
        // 2.3 Arrays
        array = '[' >> -(value % ',') >> ']';
        // 2.4.  Numbers
        // Note out spirit grammar takes a shortcut, as the RFC specification is more restrictive:
        //
        // However non of the above affect any structure characters (:,{}[] and double quotes) so it doesn't
        // matter for the current purpose. For full compliance, this remains TODO:
        //
        //    Numeric values that cannot be represented as sequences of digits
        //    (such as Infinity and NaN) are not permitted.
        //     number = [ minus ] int [ frac ] [ exp ]
        //     decimal-point = %x2E       ; .
        //     digit1-9 = %x31-39         ; 1-9
        //     e = %x65 / %x45            ; e E
        //     exp = e [ minus / plus ] 1*DIGIT
        //     frac = decimal-point 1*DIGIT
        //     int = zero / ( digit1-9 *DIGIT )
        //     minus = %x2D               ; -
        //     plus = %x2B                ; +
        //     zero = %x30                ; 0
        number = qi::double_; // shortcut :)
        // 2.5 Strings
        string = qi::lexeme [ '"' >> *char_ >> '"' ];
        static const qi::uint_parser<uint32_t, 16, 4, 4> _4HEXDIG;
        char_ = ~qi::char_(""\") |
               qi::char_("x5C") >> (       //  (reverse solidus)
                   qi::char_("x22") |      // "    quotation mark  U+0022
                   qi::char_("x5C") |      //     reverse solidus U+005C
                   qi::char_("x2F") |      // /    solidus         U+002F
                   qi::char_("x62") |      // b    backspace       U+0008
                   qi::char_("x66") |      // f    form feed       U+000C
                   qi::char_("x6E") |      // n    line feed       U+000A
                   qi::char_("x72") |      // r    carriage return U+000D
                   qi::char_("x74") |      // t    tab             U+0009
                   qi::char_("x75") >> _4HEXDIG )  // uXXXX                U+XXXX
               ;
        // entry point
        json = value;
        BOOST_SPIRIT_DEBUG_NODES(
                (json)(value)(object)(member)(array)(number)(string)(char_));
    }
  private:
    qi::rule<It, Skipper> json, value, object, member, array, number, string;
    qi::rule<It> char_;
};
template <typename It>
bool tryParseAsJson(It& f, It l) // note: first iterator gets updated
{
    static const parser<It, qi::space_type> p;
    try
    {
        return qi::phrase_parse(f,l,p,qi::space);
    } catch(const qi::expectation_failure<It>& e)
    {
        // expectation points not currently used, but we could tidy up the grammar to bail on unexpected tokens
        std::string frag(e.first, e.last);
        std::cerr << e.what() << "'" << frag << "'n";
        return false;
    }
}
int main()
{
#if 0
    // read full stdin
    std::cin.unsetf(std::ios::skipws);
    std::istream_iterator<char> it(std::cin), pte;
    const std::string input(it, pte);
    // set up parse iterators
    auto f(begin(input)), l(end(input));
#else
    const std::string input("foo([1, 2, 3], "some more stuff")");
    // set to start of JSON
    auto f(begin(input)), l(end(input));
    std::advance(f, 4);
#endif
    bool ok = tryParseAsJson(f, l); // updates f to point after the end of valid JSON
    if (ok) 
        std::cout << "Non-JSON part of input starts after valid JSON: '" << std::string(f, l) << "'n";
    return ok? 0 : 255;
}
相关文章：