1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/json/json_reader.h"
#include "base/json/json_parser.h"
#include "base/logging.h"
#include "base/values.h"
namespace base {
// Values 1000 and above are used by JSONFileValueSerializer::JsonFileError.
COMPILE_ASSERT(JSONReader::JSON_PARSE_ERROR_COUNT < 1000,
json_reader_error_out_of_bounds);
const char JSONReader::kInvalidEscape[] =
"Invalid escape sequence.";
const char JSONReader::kSyntaxError[] =
"Syntax error.";
const char JSONReader::kUnexpectedToken[] =
"Unexpected token.";
const char JSONReader::kTrailingComma[] =
"Trailing comma not allowed.";
const char JSONReader::kTooMuchNesting[] =
"Too much nesting.";
const char JSONReader::kUnexpectedDataAfterRoot[] =
"Unexpected data after root element.";
const char JSONReader::kUnsupportedEncoding[] =
"Unsupported encoding. JSON must be UTF-8.";
const char JSONReader::kUnquotedDictionaryKey[] =
"Dictionary keys must be quoted.";
JSONReader::JSONReader()
: JSONReader(JSON_PARSE_RFC) {
}
JSONReader::JSONReader(int options)
: parser_(new internal::JSONParser(options)) {
}
JSONReader::~JSONReader() {
}
// static
Value* JSONReader::DeprecatedRead(const std::string& json) {
return Read(json).release();
}
// static
scoped_ptr<Value> JSONReader::Read(const std::string& json) {
internal::JSONParser parser(JSON_PARSE_RFC);
return make_scoped_ptr(parser.Parse(json));
}
// static
Value* JSONReader::DeprecatedRead(const std::string& json, int options) {
return Read(json, options).release();
}
// static
scoped_ptr<Value> JSONReader::Read(const std::string& json, int options) {
internal::JSONParser parser(options);
return make_scoped_ptr(parser.Parse(json));
}
// static
Value* JSONReader::DeprecatedReadAndReturnError(const std::string& json,
int options,
int* error_code_out,
std::string* error_msg_out) {
return ReadAndReturnError(json, options, error_code_out, error_msg_out)
.release();
}
// static
scoped_ptr<Value> JSONReader::ReadAndReturnError(const std::string& json,
int options,
int* error_code_out,
std::string* error_msg_out) {
internal::JSONParser parser(options);
scoped_ptr<Value> root(parser.Parse(json));
if (!root) {
if (error_code_out)
*error_code_out = parser.error_code();
if (error_msg_out)
*error_msg_out = parser.GetErrorMessage();
}
return root;
}
// static
std::string JSONReader::ErrorCodeToString(JsonParseError error_code) {
switch (error_code) {
case JSON_NO_ERROR:
return std::string();
case JSON_INVALID_ESCAPE:
return kInvalidEscape;
case JSON_SYNTAX_ERROR:
return kSyntaxError;
case JSON_UNEXPECTED_TOKEN:
return kUnexpectedToken;
case JSON_TRAILING_COMMA:
return kTrailingComma;
case JSON_TOO_MUCH_NESTING:
return kTooMuchNesting;
case JSON_UNEXPECTED_DATA_AFTER_ROOT:
return kUnexpectedDataAfterRoot;
case JSON_UNSUPPORTED_ENCODING:
return kUnsupportedEncoding;
case JSON_UNQUOTED_DICTIONARY_KEY:
return kUnquotedDictionaryKey;
default:
NOTREACHED();
return std::string();
}
}
scoped_ptr<Value> JSONReader::ReadToValue(const std::string& json) {
return make_scoped_ptr(parser_->Parse(json));
}
JSONReader::JsonParseError JSONReader::error_code() const {
return parser_->error_code();
}
std::string JSONReader::GetErrorMessage() const {
return parser_->GetErrorMessage();
}
} // namespace base
|
