зеркало из https://github.com/mozilla/gecko-dev.git
409 строки
13 KiB
C++
409 строки
13 KiB
C++
// Copyright 2007-2010 Baptiste Lepilleur
|
|
// Distributed under MIT license, or public domain if desired and
|
|
// recognized in your jurisdiction.
|
|
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
|
|
|
|
#ifndef CPPTL_JSON_READER_H_INCLUDED
|
|
#define CPPTL_JSON_READER_H_INCLUDED
|
|
|
|
#if !defined(JSON_IS_AMALGAMATION)
|
|
#include "features.h"
|
|
#include "value.h"
|
|
#endif // if !defined(JSON_IS_AMALGAMATION)
|
|
#include <deque>
|
|
#include <iosfwd>
|
|
#include <stack>
|
|
#include <string>
|
|
#include <istream>
|
|
|
|
// Disable warning C4251: <data member>: <type> needs to have dll-interface to
|
|
// be used by...
|
|
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4251)
|
|
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
|
#pragma pack(push, 8)
|
|
|
|
namespace Json {
|
|
|
|
/** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a
|
|
*Value.
|
|
*
|
|
* \deprecated Use CharReader and CharReaderBuilder.
|
|
*/
|
|
class JSON_API Reader {
|
|
public:
|
|
typedef char Char;
|
|
typedef const Char* Location;
|
|
|
|
/** \brief An error tagged with where in the JSON text it was encountered.
|
|
*
|
|
* The offsets give the [start, limit) range of bytes within the text. Note
|
|
* that this is bytes, not codepoints.
|
|
*
|
|
*/
|
|
struct StructuredError {
|
|
ptrdiff_t offset_start;
|
|
ptrdiff_t offset_limit;
|
|
JSONCPP_STRING message;
|
|
};
|
|
|
|
/** \brief Constructs a Reader allowing all features
|
|
* for parsing.
|
|
*/
|
|
Reader();
|
|
|
|
/** \brief Constructs a Reader allowing the specified feature set
|
|
* for parsing.
|
|
*/
|
|
Reader(const Features& features);
|
|
|
|
/** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
|
|
* document.
|
|
* \param document UTF-8 encoded string containing the document to read.
|
|
* \param root [out] Contains the root value of the document if it was
|
|
* successfully parsed.
|
|
* \param collectComments \c true to collect comment and allow writing them
|
|
* back during
|
|
* serialization, \c false to discard comments.
|
|
* This parameter is ignored if
|
|
* Features::allowComments_
|
|
* is \c false.
|
|
* \return \c true if the document was successfully parsed, \c false if an
|
|
* error occurred.
|
|
*/
|
|
bool
|
|
parse(const std::string& document, Value& root, bool collectComments = true);
|
|
|
|
/** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
|
|
document.
|
|
* \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the
|
|
document to read.
|
|
* \param endDoc Pointer on the end of the UTF-8 encoded string of the
|
|
document to read.
|
|
* Must be >= beginDoc.
|
|
* \param root [out] Contains the root value of the document if it was
|
|
* successfully parsed.
|
|
* \param collectComments \c true to collect comment and allow writing them
|
|
back during
|
|
* serialization, \c false to discard comments.
|
|
* This parameter is ignored if
|
|
Features::allowComments_
|
|
* is \c false.
|
|
* \return \c true if the document was successfully parsed, \c false if an
|
|
error occurred.
|
|
*/
|
|
bool parse(const char* beginDoc,
|
|
const char* endDoc,
|
|
Value& root,
|
|
bool collectComments = true);
|
|
|
|
/// \brief Parse from input stream.
|
|
/// \see Json::operator>>(std::istream&, Json::Value&).
|
|
bool parse(JSONCPP_ISTREAM& is, Value& root, bool collectComments = true);
|
|
|
|
/** \brief Returns a user friendly string that list errors in the parsed
|
|
* document.
|
|
* \return Formatted error message with the list of errors with their location
|
|
* in
|
|
* the parsed document. An empty string is returned if no error
|
|
* occurred
|
|
* during parsing.
|
|
* \deprecated Use getFormattedErrorMessages() instead (typo fix).
|
|
*/
|
|
JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.")
|
|
JSONCPP_STRING getFormatedErrorMessages() const;
|
|
|
|
/** \brief Returns a user friendly string that list errors in the parsed
|
|
* document.
|
|
* \return Formatted error message with the list of errors with their location
|
|
* in
|
|
* the parsed document. An empty string is returned if no error
|
|
* occurred
|
|
* during parsing.
|
|
*/
|
|
JSONCPP_STRING getFormattedErrorMessages() const;
|
|
|
|
/** \brief Returns a vector of structured erros encounted while parsing.
|
|
* \return A (possibly empty) vector of StructuredError objects. Currently
|
|
* only one error can be returned, but the caller should tolerate
|
|
* multiple
|
|
* errors. This can occur if the parser recovers from a non-fatal
|
|
* parse error and then encounters additional errors.
|
|
*/
|
|
std::vector<StructuredError> getStructuredErrors() const;
|
|
|
|
/** \brief Add a semantic error message.
|
|
* \param value JSON Value location associated with the error
|
|
* \param message The error message.
|
|
* \return \c true if the error was successfully added, \c false if the
|
|
* Value offset exceeds the document size.
|
|
*/
|
|
bool pushError(const Value& value, const JSONCPP_STRING& message);
|
|
|
|
/** \brief Add a semantic error message with extra context.
|
|
* \param value JSON Value location associated with the error
|
|
* \param message The error message.
|
|
* \param extra Additional JSON Value location to contextualize the error
|
|
* \return \c true if the error was successfully added, \c false if either
|
|
* Value offset exceeds the document size.
|
|
*/
|
|
bool pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra);
|
|
|
|
/** \brief Return whether there are any errors.
|
|
* \return \c true if there are no errors to report \c false if
|
|
* errors have occurred.
|
|
*/
|
|
bool good() const;
|
|
|
|
private:
|
|
enum TokenType {
|
|
tokenEndOfStream = 0,
|
|
tokenObjectBegin,
|
|
tokenObjectEnd,
|
|
tokenArrayBegin,
|
|
tokenArrayEnd,
|
|
tokenString,
|
|
tokenNumber,
|
|
tokenTrue,
|
|
tokenFalse,
|
|
tokenNull,
|
|
tokenArraySeparator,
|
|
tokenMemberSeparator,
|
|
tokenComment,
|
|
tokenError
|
|
};
|
|
|
|
class Token {
|
|
public:
|
|
TokenType type_;
|
|
Location start_;
|
|
Location end_;
|
|
};
|
|
|
|
class ErrorInfo {
|
|
public:
|
|
Token token_;
|
|
JSONCPP_STRING message_;
|
|
Location extra_;
|
|
};
|
|
|
|
typedef std::deque<ErrorInfo> Errors;
|
|
|
|
bool readToken(Token& token);
|
|
void skipSpaces();
|
|
bool match(Location pattern, int patternLength);
|
|
bool readComment();
|
|
bool readCStyleComment();
|
|
bool readCppStyleComment();
|
|
bool readString();
|
|
void readNumber();
|
|
bool readValue();
|
|
bool readObject(Token& token);
|
|
bool readArray(Token& token);
|
|
bool decodeNumber(Token& token);
|
|
bool decodeNumber(Token& token, Value& decoded);
|
|
bool decodeString(Token& token);
|
|
bool decodeString(Token& token, JSONCPP_STRING& decoded);
|
|
bool decodeDouble(Token& token);
|
|
bool decodeDouble(Token& token, Value& decoded);
|
|
bool decodeUnicodeCodePoint(Token& token,
|
|
Location& current,
|
|
Location end,
|
|
unsigned int& unicode);
|
|
bool decodeUnicodeEscapeSequence(Token& token,
|
|
Location& current,
|
|
Location end,
|
|
unsigned int& unicode);
|
|
bool addError(const JSONCPP_STRING& message, Token& token, Location extra = 0);
|
|
bool recoverFromError(TokenType skipUntilToken);
|
|
bool addErrorAndRecover(const JSONCPP_STRING& message,
|
|
Token& token,
|
|
TokenType skipUntilToken);
|
|
void skipUntilSpace();
|
|
Value& currentValue();
|
|
Char getNextChar();
|
|
void
|
|
getLocationLineAndColumn(Location location, int& line, int& column) const;
|
|
JSONCPP_STRING getLocationLineAndColumn(Location location) const;
|
|
void addComment(Location begin, Location end, CommentPlacement placement);
|
|
void skipCommentTokens(Token& token);
|
|
|
|
typedef std::stack<Value*> Nodes;
|
|
Nodes nodes_;
|
|
Errors errors_;
|
|
JSONCPP_STRING document_;
|
|
Location begin_;
|
|
Location end_;
|
|
Location current_;
|
|
Location lastValueEnd_;
|
|
Value* lastValue_;
|
|
JSONCPP_STRING commentsBefore_;
|
|
Features features_;
|
|
bool collectComments_;
|
|
}; // Reader
|
|
|
|
/** Interface for reading JSON from a char array.
|
|
*/
|
|
class JSON_API CharReader {
|
|
public:
|
|
virtual ~CharReader() {}
|
|
/** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a>
|
|
document.
|
|
* The document must be a UTF-8 encoded string containing the document to read.
|
|
*
|
|
* \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the
|
|
document to read.
|
|
* \param endDoc Pointer on the end of the UTF-8 encoded string of the
|
|
document to read.
|
|
* Must be >= beginDoc.
|
|
* \param root [out] Contains the root value of the document if it was
|
|
* successfully parsed.
|
|
* \param errs [out] Formatted error messages (if not NULL)
|
|
* a user friendly string that lists errors in the parsed
|
|
* document.
|
|
* \return \c true if the document was successfully parsed, \c false if an
|
|
error occurred.
|
|
*/
|
|
virtual bool parse(
|
|
char const* beginDoc, char const* endDoc,
|
|
Value* root, JSONCPP_STRING* errs) = 0;
|
|
|
|
class JSON_API Factory {
|
|
public:
|
|
virtual ~Factory() {}
|
|
/** \brief Allocate a CharReader via operator new().
|
|
* \throw std::exception if something goes wrong (e.g. invalid settings)
|
|
*/
|
|
virtual CharReader* newCharReader() const = 0;
|
|
}; // Factory
|
|
}; // CharReader
|
|
|
|
/** \brief Build a CharReader implementation.
|
|
|
|
Usage:
|
|
\code
|
|
using namespace Json;
|
|
CharReaderBuilder builder;
|
|
builder["collectComments"] = false;
|
|
Value value;
|
|
JSONCPP_STRING errs;
|
|
bool ok = parseFromStream(builder, std::cin, &value, &errs);
|
|
\endcode
|
|
*/
|
|
class JSON_API CharReaderBuilder : public CharReader::Factory {
|
|
public:
|
|
// Note: We use a Json::Value so that we can add data-members to this class
|
|
// without a major version bump.
|
|
/** Configuration of this builder.
|
|
These are case-sensitive.
|
|
Available settings (case-sensitive):
|
|
- `"collectComments": false or true`
|
|
- true to collect comment and allow writing them
|
|
back during serialization, false to discard comments.
|
|
This parameter is ignored if allowComments is false.
|
|
- `"allowComments": false or true`
|
|
- true if comments are allowed.
|
|
- `"strictRoot": false or true`
|
|
- true if root must be either an array or an object value
|
|
- `"allowDroppedNullPlaceholders": false or true`
|
|
- true if dropped null placeholders are allowed. (See StreamWriterBuilder.)
|
|
- `"allowNumericKeys": false or true`
|
|
- true if numeric object keys are allowed.
|
|
- `"allowSingleQuotes": false or true`
|
|
- true if '' are allowed for strings (both keys and values)
|
|
- `"stackLimit": integer`
|
|
- Exceeding stackLimit (recursive depth of `readValue()`) will
|
|
cause an exception.
|
|
- This is a security issue (seg-faults caused by deeply nested JSON),
|
|
so the default is low.
|
|
- `"failIfExtra": false or true`
|
|
- If true, `parse()` returns false when extra non-whitespace trails
|
|
the JSON value in the input string.
|
|
- `"rejectDupKeys": false or true`
|
|
- If true, `parse()` returns false when a key is duplicated within an object.
|
|
- `"allowSpecialFloats": false or true`
|
|
- If true, special float values (NaNs and infinities) are allowed
|
|
and their values are lossfree restorable.
|
|
|
|
You can examine 'settings_` yourself
|
|
to see the defaults. You can also write and read them just like any
|
|
JSON Value.
|
|
\sa setDefaults()
|
|
*/
|
|
Json::Value settings_;
|
|
|
|
CharReaderBuilder();
|
|
~CharReaderBuilder() JSONCPP_OVERRIDE;
|
|
|
|
CharReader* newCharReader() const JSONCPP_OVERRIDE;
|
|
|
|
/** \return true if 'settings' are legal and consistent;
|
|
* otherwise, indicate bad settings via 'invalid'.
|
|
*/
|
|
bool validate(Json::Value* invalid) const;
|
|
|
|
/** A simple way to update a specific setting.
|
|
*/
|
|
Value& operator[](JSONCPP_STRING key);
|
|
|
|
/** Called by ctor, but you can use this to reset settings_.
|
|
* \pre 'settings' != NULL (but Json::null is fine)
|
|
* \remark Defaults:
|
|
* \snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults
|
|
*/
|
|
static void setDefaults(Json::Value* settings);
|
|
/** Same as old Features::strictMode().
|
|
* \pre 'settings' != NULL (but Json::null is fine)
|
|
* \remark Defaults:
|
|
* \snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode
|
|
*/
|
|
static void strictMode(Json::Value* settings);
|
|
};
|
|
|
|
/** Consume entire stream and use its begin/end.
|
|
* Someday we might have a real StreamReader, but for now this
|
|
* is convenient.
|
|
*/
|
|
bool JSON_API parseFromStream(
|
|
CharReader::Factory const&,
|
|
JSONCPP_ISTREAM&,
|
|
Value* root, std::string* errs);
|
|
|
|
/** \brief Read from 'sin' into 'root'.
|
|
|
|
Always keep comments from the input JSON.
|
|
|
|
This can be used to read a file into a particular sub-object.
|
|
For example:
|
|
\code
|
|
Json::Value root;
|
|
cin >> root["dir"]["file"];
|
|
cout << root;
|
|
\endcode
|
|
Result:
|
|
\verbatim
|
|
{
|
|
"dir": {
|
|
"file": {
|
|
// The input stream JSON would be nested here.
|
|
}
|
|
}
|
|
}
|
|
\endverbatim
|
|
\throw std::exception on parse error.
|
|
\see Json::operator<<()
|
|
*/
|
|
JSON_API JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM&, Value&);
|
|
|
|
} // namespace Json
|
|
|
|
#pragma pack(pop)
|
|
|
|
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
#pragma warning(pop)
|
|
#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
|
|
|
|
#endif // CPPTL_JSON_READER_H_INCLUDED
|