Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-04 07:31:16 +00:00
Code Issues Projects Releases Packages Wiki Activity
godot/core/io/json.cpp
aaronp64 f13b4b760a Improve JSON::stringify performance 
- Changed stringify to call static function _stringify directly, instead of creating JSON object
- Changed colon and end_statement from String to const char * to avoid extra allocations in each _stringify call
- Pass result String reference to each _stringify call to append to instead of allocating new String in each call

These changes make JSON::stringify around 2-3x faster in most cases
2025-05-06 18:27:32 -04:00

1603 lines
42 KiB
C++
Raw Blame History

/**************************************************************************/
/* json.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "json.h"
#include "core/config/engine.h"
#include "core/object/script_language.h"
#include "core/variant/container_type_validate.h"
const char *JSON::tk_name[TK_MAX] = {
"'{'",
"'}'",
"'['",
"']'",
"identifier",
"string",
"number",
"':'",
"','",
"EOF",
};
void JSON::_add_indent(String &r_result, const String &p_indent, int p_size) {
for (int i = 0; i < p_size; i++) {
r_result += p_indent;
}
}
void JSON::_stringify(String &r_result, const Variant &p_var, const String &p_indent, int p_cur_indent, bool p_sort_keys, HashSet<const void *> &p_markers, bool p_full_precision) {
if (p_cur_indent > Variant::MAX_RECURSION_DEPTH) {
r_result += "...";
ERR_FAIL_MSG("JSON structure is too deep. Bailing.");
}
const char *colon = p_indent.is_empty() ? ":" : ": ";
const char *end_statement = p_indent.is_empty() ? "" : "\n";
switch (p_var.get_type()) {
case Variant::NIL:
r_result += "null";
return;
case Variant::BOOL:
r_result += p_var.operator bool() ? "true" : "false";
return;
case Variant::INT:
r_result += itos(p_var);
return;
case Variant::FLOAT: {
double num = p_var;
// Only for exactly 0. If we have approximately 0 let the user decide how much
// precision they want.
if (num == double(0)) {
r_result += "0.0";
return;
}
double magnitude = std::log10(Math::abs(num));
int total_digits = p_full_precision ? 17 : 14;
int precision = MAX(1, total_digits - (int)Math::floor(magnitude));
r_result += String::num(num, precision);
return;
}
case Variant::PACKED_INT32_ARRAY:
case Variant::PACKED_INT64_ARRAY:
case Variant::PACKED_FLOAT32_ARRAY:
case Variant::PACKED_FLOAT64_ARRAY:
case Variant::PACKED_STRING_ARRAY:
case Variant::ARRAY: {
Array a = p_var;
if (p_markers.has(a.id())) {
r_result += "\"[...]\"";
ERR_FAIL_MSG("Converting circular structure to JSON.");
}
if (a.is_empty()) {
r_result += "[]";
return;
}
r_result += '[';
r_result += end_statement;
p_markers.insert(a.id());
bool first = true;
for (const Variant &var : a) {
if (first) {
first = false;
} else {
r_result += ',';
r_result += end_statement;
}
_add_indent(r_result, p_indent, p_cur_indent + 1);
_stringify(r_result, var, p_indent, p_cur_indent + 1, p_sort_keys, p_markers);
}
r_result += end_statement;
_add_indent(r_result, p_indent, p_cur_indent);
r_result += ']';
p_markers.erase(a.id());
return;
}
case Variant::DICTIONARY: {
Dictionary d = p_var;
if (p_markers.has(d.id())) {
r_result += "\"{...}\"";
ERR_FAIL_MSG("Converting circular structure to JSON.");
}
r_result += '{';
r_result += end_statement;
p_markers.insert(d.id());
LocalVector<Variant> keys = d.get_key_list();
if (p_sort_keys) {
keys.sort_custom<StringLikeVariantOrder>();
}
bool first_key = true;
for (const Variant &key : keys) {
if (first_key) {
first_key = false;
} else {
r_result += ',';
r_result += end_statement;
}
_add_indent(r_result, p_indent, p_cur_indent + 1);
_stringify(r_result, String(key), p_indent, p_cur_indent + 1, p_sort_keys, p_markers);
r_result += colon;
_stringify(r_result, d[key], p_indent, p_cur_indent + 1, p_sort_keys, p_markers);
}
r_result += end_statement;
_add_indent(r_result, p_indent, p_cur_indent);
r_result += '}';
p_markers.erase(d.id());
return;
}
default:
r_result += '"';
r_result += String(p_var).json_escape();
r_result += '"';
return;
}
}
Error JSON::_get_token(const char32_t *p_str, int &index, int p_len, Token &r_token, int &line, String &r_err_str) {
while (p_len > 0) {
switch (p_str[index]) {
case '\n': {
line++;
index++;
break;
}
case 0: {
r_token.type = TK_EOF;
return OK;
} break;
case '{': {
r_token.type = TK_CURLY_BRACKET_OPEN;
index++;
return OK;
}
case '}': {
r_token.type = TK_CURLY_BRACKET_CLOSE;
index++;
return OK;
}
case '[': {
r_token.type = TK_BRACKET_OPEN;
index++;
return OK;
}
case ']': {
r_token.type = TK_BRACKET_CLOSE;
index++;
return OK;
}
case ':': {
r_token.type = TK_COLON;
index++;
return OK;
}
case ',': {
r_token.type = TK_COMMA;
index++;
return OK;
}
case '"': {
index++;
String str;
while (true) {
if (p_str[index] == 0) {
r_err_str = "Unterminated string";
return ERR_PARSE_ERROR;
} else if (p_str[index] == '"') {
index++;
break;
} else if (p_str[index] == '\\') {
//escaped characters...
index++;
char32_t next = p_str[index];
if (next == 0) {
r_err_str = "Unterminated string";
return ERR_PARSE_ERROR;
}
char32_t res = 0;
switch (next) {
case 'b':
res = 8;
break;
case 't':
res = 9;
break;
case 'n':
res = 10;
break;
case 'f':
res = 12;
break;
case 'r':
res = 13;
break;
case 'u': {
// hex number
for (int j = 0; j < 4; j++) {
char32_t c = p_str[index + j + 1];
if (c == 0) {
r_err_str = "Unterminated string";
return ERR_PARSE_ERROR;
}
if (!is_hex_digit(c)) {
r_err_str = "Malformed hex constant in string";
return ERR_PARSE_ERROR;
}
char32_t v;
if (is_digit(c)) {
v = c - '0';
} else if (c >= 'a' && c <= 'f') {
v = c - 'a';
v += 10;
} else if (c >= 'A' && c <= 'F') {
v = c - 'A';
v += 10;
} else {
ERR_PRINT("Bug parsing hex constant.");
v = 0;
}
res <<= 4;
res |= v;
}
index += 4; //will add at the end anyway
if ((res & 0xfffffc00) == 0xd800) {
if (p_str[index + 1] != '\\' || p_str[index + 2] != 'u') {
r_err_str = "Invalid UTF-16 sequence in string, unpaired lead surrogate";
return ERR_PARSE_ERROR;
}
index += 2;
char32_t trail = 0;
for (int j = 0; j < 4; j++) {
char32_t c = p_str[index + j + 1];
if (c == 0) {
r_err_str = "Unterminated string";
return ERR_PARSE_ERROR;
}
if (!is_hex_digit(c)) {
r_err_str = "Malformed hex constant in string";
return ERR_PARSE_ERROR;
}
char32_t v;
if (is_digit(c)) {
v = c - '0';
} else if (c >= 'a' && c <= 'f') {
v = c - 'a';
v += 10;
} else if (c >= 'A' && c <= 'F') {
v = c - 'A';
v += 10;
} else {
ERR_PRINT("Bug parsing hex constant.");
v = 0;
}
trail <<= 4;
trail |= v;
}
if ((trail & 0xfffffc00) == 0xdc00) {
res = (res << 10UL) + trail - ((0xd800 << 10UL) + 0xdc00 - 0x10000);
index += 4; //will add at the end anyway
} else {
r_err_str = "Invalid UTF-16 sequence in string, unpaired lead surrogate";
return ERR_PARSE_ERROR;
}
} else if ((res & 0xfffffc00) == 0xdc00) {
r_err_str = "Invalid UTF-16 sequence in string, unpaired trail surrogate";
return ERR_PARSE_ERROR;
}
} break;
case '"':
case '\\':
case '/': {
res = next;
} break;
default: {
r_err_str = "Invalid escape sequence";
return ERR_PARSE_ERROR;
}
}
str += res;
} else {
if (p_str[index] == '\n') {
line++;
}
str += p_str[index];
}
index++;
}
r_token.type = TK_STRING;
r_token.value = str;
return OK;
} break;
default: {
if (p_str[index] <= 32) {
index++;
break;
}
if (p_str[index] == '-' || is_digit(p_str[index])) {
//a number
const char32_t *rptr;
double number = String::to_float(&p_str[index], &rptr);
index += (rptr - &p_str[index]);
r_token.type = TK_NUMBER;
r_token.value = number;
return OK;
} else if (is_ascii_alphabet_char(p_str[index])) {
String id;
while (is_ascii_alphabet_char(p_str[index])) {
id += p_str[index];
index++;
}
r_token.type = TK_IDENTIFIER;
r_token.value = id;
return OK;
} else {
r_err_str = "Unexpected character";
return ERR_PARSE_ERROR;
}
}
}
}
r_err_str = "Unknown error getting token";
return ERR_PARSE_ERROR;
}
Error JSON::_parse_value(Variant &value, Token &token, const char32_t *p_str, int &index, int p_len, int &line, int p_depth, String &r_err_str) {
if (p_depth > Variant::MAX_RECURSION_DEPTH) {
r_err_str = "JSON structure is too deep";
return ERR_OUT_OF_MEMORY;
}
if (token.type == TK_CURLY_BRACKET_OPEN) {
Dictionary d;
Error err = _parse_object(d, p_str, index, p_len, line, p_depth + 1, r_err_str);
if (err) {
return err;
}
value = d;
} else if (token.type == TK_BRACKET_OPEN) {
Array a;
Error err = _parse_array(a, p_str, index, p_len, line, p_depth + 1, r_err_str);
if (err) {
return err;
}
value = a;
} else if (token.type == TK_IDENTIFIER) {
String id = token.value;
if (id == "true") {
value = true;
} else if (id == "false") {
value = false;
} else if (id == "null") {
value = Variant();
} else {
r_err_str = vformat("Expected 'true', 'false', or 'null', got '%s'", id);
return ERR_PARSE_ERROR;
}
} else if (token.type == TK_NUMBER) {
value = token.value;
} else if (token.type == TK_STRING) {
value = token.value;
} else {
r_err_str = vformat("Expected value, got '%s'", String(tk_name[token.type]));
return ERR_PARSE_ERROR;
}
return OK;
}
Error JSON::_parse_array(Array &array, const char32_t *p_str, int &index, int p_len, int &line, int p_depth, String &r_err_str) {
Token token;
bool need_comma = false;
while (index < p_len) {
Error err = _get_token(p_str, index, p_len, token, line, r_err_str);
if (err != OK) {
return err;
}
if (token.type == TK_BRACKET_CLOSE) {
return OK;
}
if (need_comma) {
if (token.type != TK_COMMA) {
r_err_str = "Expected ','";
return ERR_PARSE_ERROR;
} else {
need_comma = false;
continue;
}
}
Variant v;
err = _parse_value(v, token, p_str, index, p_len, line, p_depth, r_err_str);
if (err) {
return err;
}
array.push_back(v);
need_comma = true;
}
r_err_str = "Expected ']'";
return ERR_PARSE_ERROR;
}
Error JSON::_parse_object(Dictionary &object, const char32_t *p_str, int &index, int p_len, int &line, int p_depth, String &r_err_str) {
bool at_key = true;
String key;
Token token;
bool need_comma = false;
while (index < p_len) {
if (at_key) {
Error err = _get_token(p_str, index, p_len, token, line, r_err_str);
if (err != OK) {
return err;
}
if (token.type == TK_CURLY_BRACKET_CLOSE) {
return OK;
}
if (need_comma) {
if (token.type != TK_COMMA) {
r_err_str = "Expected '}' or ','";
return ERR_PARSE_ERROR;
} else {
need_comma = false;
continue;
}
}
if (token.type != TK_STRING) {
r_err_str = "Expected key";
return ERR_PARSE_ERROR;
}
key = token.value;
err = _get_token(p_str, index, p_len, token, line, r_err_str);
if (err != OK) {
return err;
}
if (token.type != TK_COLON) {
r_err_str = "Expected ':'";
return ERR_PARSE_ERROR;
}
at_key = false;
} else {
Error err = _get_token(p_str, index, p_len, token, line, r_err_str);
if (err != OK) {
return err;
}
Variant v;
err = _parse_value(v, token, p_str, index, p_len, line, p_depth, r_err_str);
if (err) {
return err;
}
object[key] = v;
need_comma = true;
at_key = true;
}
}
r_err_str = "Expected '}'";
return ERR_PARSE_ERROR;
}
void JSON::set_data(const Variant &p_data) {
data = p_data;
text.clear();
}
Error JSON::_parse_string(const String &p_json, Variant &r_ret, String &r_err_str, int &r_err_line) {
const char32_t *str = p_json.ptr();
int idx = 0;
int len = p_json.length();
Token token;
r_err_line = 0;
String aux_key;
Error err = _get_token(str, idx, len, token, r_err_line, r_err_str);
if (err) {
return err;
}
err = _parse_value(r_ret, token, str, idx, len, r_err_line, 0, r_err_str);
// Check if EOF is reached
// or it's a type of the next token.
if (err == OK && idx < len) {
err = _get_token(str, idx, len, token, r_err_line, r_err_str);
if (err || token.type != TK_EOF) {
r_err_str = "Expected 'EOF'";
// Reset return value to empty `Variant`
r_ret = Variant();
return ERR_PARSE_ERROR;
}
}
return err;
}
Error JSON::parse(const String &p_json_string, bool p_keep_text) {
Error err = _parse_string(p_json_string, data, err_str, err_line);
if (err == Error::OK) {
err_line = 0;
}
if (p_keep_text) {
text = p_json_string;
}
return err;
}
String JSON::get_parsed_text() const {
return text;
}
String JSON::stringify(const Variant &p_var, const String &p_indent, bool p_sort_keys, bool p_full_precision) {
String result;
HashSet<const void *> markers;
_stringify(result, p_var, p_indent, 0, p_sort_keys, markers, p_full_precision);
return result;
}
Variant JSON::parse_string(const String &p_json_string) {
Ref<JSON> json;
json.instantiate();
Error error = json->parse(p_json_string);
ERR_FAIL_COND_V_MSG(error != Error::OK, Variant(), vformat("Parse JSON failed. Error at line %d: %s", json->get_error_line(), json->get_error_message()));
return json->get_data();
}
void JSON::_bind_methods() {
ClassDB::bind_static_method("JSON", D_METHOD("stringify", "data", "indent", "sort_keys", "full_precision"), &JSON::stringify, DEFVAL(""), DEFVAL(true), DEFVAL(false));
ClassDB::bind_static_method("JSON", D_METHOD("parse_string", "json_string"), &JSON::parse_string);
ClassDB::bind_method(D_METHOD("parse", "json_text", "keep_text"), &JSON::parse, DEFVAL(false));
ClassDB::bind_method(D_METHOD("get_data"), &JSON::get_data);
ClassDB::bind_method(D_METHOD("set_data", "data"), &JSON::set_data);
ClassDB::bind_method(D_METHOD("get_parsed_text"), &JSON::get_parsed_text);
ClassDB::bind_method(D_METHOD("get_error_line"), &JSON::get_error_line);
ClassDB::bind_method(D_METHOD("get_error_message"), &JSON::get_error_message);
ClassDB::bind_static_method("JSON", D_METHOD("from_native", "variant", "full_objects"), &JSON::from_native, DEFVAL(false));
ClassDB::bind_static_method("JSON", D_METHOD("to_native", "json", "allow_objects"), &JSON::to_native, DEFVAL(false));
ADD_PROPERTY(PropertyInfo(Variant::NIL, "data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT), "set_data", "get_data"); // Ensures that it can be serialized as binary.
}
#define TYPE "type"
#define ELEM_TYPE "elem_type"
#define KEY_TYPE "key_type"
#define VALUE_TYPE "value_type"
#define ARGS "args"
#define PROPS "props"
static bool _encode_container_type(Dictionary &r_dict, const String &p_key, const ContainerType &p_type, bool p_full_objects) {
if (p_type.builtin_type != Variant::NIL) {
if (p_type.script.is_valid()) {
ERR_FAIL_COND_V(!p_full_objects, false);
const String path = p_type.script->get_path();
ERR_FAIL_COND_V_MSG(path.is_empty() || !path.begins_with("res://"), false, "Failed to encode a path to a custom script for a container type.");
r_dict[p_key] = path;
} else if (p_type.class_name != StringName()) {
ERR_FAIL_COND_V(!p_full_objects, false);
r_dict[p_key] = String(p_type.class_name);
} else {
// No need to check `p_full_objects` since `class_name` should be non-empty for `builtin_type == Variant::OBJECT`.
r_dict[p_key] = Variant::get_type_name(p_type.builtin_type);
}
}
return true;
}
Variant JSON::_from_native(const Variant &p_variant, bool p_full_objects, int p_depth) {
#define RETURN_ARGS \
Dictionary ret; \
ret[TYPE] = Variant::get_type_name(p_variant.get_type()); \
ret[ARGS] = args; \
return ret
switch (p_variant.get_type()) {
case Variant::NIL:
case Variant::BOOL: {
return p_variant;
} break;
case Variant::INT: {
return "i:" + String(p_variant);
} break;
case Variant::FLOAT: {
return "f:" + String(p_variant);
} break;
case Variant::STRING: {
return "s:" + String(p_variant);
} break;
case Variant::STRING_NAME: {
return "sn:" + String(p_variant);
} break;
case Variant::NODE_PATH: {
return "np:" + String(p_variant);
} break;
case Variant::RID:
case Variant::CALLABLE:
case Variant::SIGNAL: {
Dictionary ret;
ret[TYPE] = Variant::get_type_name(p_variant.get_type());
return ret;
} break;
case Variant::VECTOR2: {
const Vector2 v = p_variant;
Array args = { v.x, v.y };
RETURN_ARGS;
} break;
case Variant::VECTOR2I: {
const Vector2i v = p_variant;
Array args = { v.x, v.y };
RETURN_ARGS;
} break;
case Variant::RECT2: {
const Rect2 r = p_variant;
Array args = { r.position.x, r.position.y, r.size.width, r.size.height };
RETURN_ARGS;
} break;
case Variant::RECT2I: {
const Rect2i r = p_variant;
Array args = { r.position.x, r.position.y, r.size.width, r.size.height };
RETURN_ARGS;
} break;
case Variant::VECTOR3: {
const Vector3 v = p_variant;
Array args = { v.x, v.y, v.z };
RETURN_ARGS;
} break;
case Variant::VECTOR3I: {
const Vector3i v = p_variant;
Array args = { v.x, v.y, v.z };
RETURN_ARGS;
} break;
case Variant::TRANSFORM2D: {
const Transform2D t = p_variant;
Array args = { t[0].x, t[0].y, t[1].x, t[1].y, t[2].x, t[2].y };
RETURN_ARGS;
} break;
case Variant::VECTOR4: {
const Vector4 v = p_variant;
Array args = { v.x, v.y, v.z, v.w };
RETURN_ARGS;
} break;
case Variant::VECTOR4I: {
const Vector4i v = p_variant;
Array args = { v.x, v.y, v.z, v.w };
RETURN_ARGS;
} break;
case Variant::PLANE: {
const Plane p = p_variant;
Array args = { p.normal.x, p.normal.y, p.normal.z, p.d };
RETURN_ARGS;
} break;
case Variant::QUATERNION: {
const Quaternion q = p_variant;
Array args = { q.x, q.y, q.z, q.w };
RETURN_ARGS;
} break;
case Variant::AABB: {
const AABB aabb = p_variant;
Array args = { aabb.position.x, aabb.position.y, aabb.position.z, aabb.size.x, aabb.size.y, aabb.size.z };
RETURN_ARGS;
} break;
case Variant::BASIS: {
const Basis b = p_variant;
Array args = { b.get_column(0).x, b.get_column(0).y, b.get_column(0).z,
b.get_column(1).x, b.get_column(1).y, b.get_column(1).z,
b.get_column(2).x, b.get_column(2).y, b.get_column(2).z };
RETURN_ARGS;
} break;
case Variant::TRANSFORM3D: {
const Transform3D t = p_variant;
Array args = { t.basis.get_column(0).x, t.basis.get_column(0).y, t.basis.get_column(0).z,
t.basis.get_column(1).x, t.basis.get_column(1).y, t.basis.get_column(1).z,
t.basis.get_column(2).x, t.basis.get_column(2).y, t.basis.get_column(2).z,
t.origin.x, t.origin.y, t.origin.z };
RETURN_ARGS;
} break;
case Variant::PROJECTION: {
const Projection p = p_variant;
Array args = { p[0].x, p[0].y, p[0].z, p[0].w,
p[1].x, p[1].y, p[1].z, p[1].w,
p[2].x, p[2].y, p[2].z, p[2].w,
p[3].x, p[3].y, p[3].z, p[3].w };
RETURN_ARGS;
} break;
case Variant::COLOR: {
const Color c = p_variant;
Array args = { c.r, c.g, c.b, c.a };
RETURN_ARGS;
} break;
case Variant::OBJECT: {
ERR_FAIL_COND_V(!p_full_objects, Variant());
ERR_FAIL_COND_V_MSG(p_depth > Variant::MAX_RECURSION_DEPTH, Variant(), "Variant is too deep. Bailing.");
const Object *obj = p_variant.get_validated_object();
if (obj == nullptr) {
return Variant();
}
ERR_FAIL_COND_V(!ClassDB::can_instantiate(obj->get_class()), Variant());
List<PropertyInfo> prop_list;
obj->get_property_list(&prop_list);
Array props;
for (const PropertyInfo &pi : prop_list) {
if (!(pi.usage & PROPERTY_USAGE_STORAGE)) {
continue;
}
Variant value;
if (pi.name == CoreStringName(script)) {
const Ref<Script> script = obj->get_script();
if (script.is_valid()) {
const String path = script->get_path();
ERR_FAIL_COND_V_MSG(path.is_empty() || !path.begins_with("res://"), Variant(), "Failed to encode a path to a custom script.");
value = path;
}
} else {
value = obj->get(pi.name);
}
props.push_back(pi.name);
props.push_back(_from_native(value, p_full_objects, p_depth + 1));
}
Dictionary ret;
ret[TYPE] = obj->get_class();
ret[PROPS] = props;
return ret;
} break;
case Variant::DICTIONARY: {
const Dictionary dict = p_variant;
Array args;
Dictionary ret;
ret[TYPE] = Variant::get_type_name(p_variant.get_type());
if (!_encode_container_type(ret, KEY_TYPE, dict.get_key_type(), p_full_objects)) {
return Variant();
}
if (!_encode_container_type(ret, VALUE_TYPE, dict.get_value_type(), p_full_objects)) {
return Variant();
}
ret[ARGS] = args;
ERR_FAIL_COND_V_MSG(p_depth > Variant::MAX_RECURSION_DEPTH, ret, "Variant is too deep. Bailing.");
for (const KeyValue<Variant, Variant> &kv : dict) {
args.push_back(_from_native(kv.key, p_full_objects, p_depth + 1));
args.push_back(_from_native(kv.value, p_full_objects, p_depth + 1));
}
return ret;
} break;
case Variant::ARRAY: {
const Array arr = p_variant;
Variant ret;
Array args;
if (arr.is_typed()) {
Dictionary d;
d[TYPE] = Variant::get_type_name(p_variant.get_type());
if (!_encode_container_type(d, ELEM_TYPE, arr.get_element_type(), p_full_objects)) {
return Variant();
}
d[ARGS] = args;
ret = d;
} else {
ret = args;
}
ERR_FAIL_COND_V_MSG(p_depth > Variant::MAX_RECURSION_DEPTH, ret, "Variant is too deep. Bailing.");
for (int i = 0; i < arr.size(); i++) {
args.push_back(_from_native(arr[i], p_full_objects, p_depth + 1));
}
return ret;
} break;
case Variant::PACKED_BYTE_ARRAY: {
const PackedByteArray arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
args.push_back(arr[i]);
}
RETURN_ARGS;
} break;
case Variant::PACKED_INT32_ARRAY: {
const PackedInt32Array arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
args.push_back(arr[i]);
}
RETURN_ARGS;
} break;
case Variant::PACKED_INT64_ARRAY: {
const PackedInt64Array arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
args.push_back(arr[i]);
}
RETURN_ARGS;
} break;
case Variant::PACKED_FLOAT32_ARRAY: {
const PackedFloat32Array arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
args.push_back(arr[i]);
}
RETURN_ARGS;
} break;
case Variant::PACKED_FLOAT64_ARRAY: {
const PackedFloat64Array arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
args.push_back(arr[i]);
}
RETURN_ARGS;
} break;
case Variant::PACKED_STRING_ARRAY: {
const PackedStringArray arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
args.push_back(arr[i]);
}
RETURN_ARGS;
} break;
case Variant::PACKED_VECTOR2_ARRAY: {
const PackedVector2Array arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
Vector2 v = arr[i];
args.push_back(v.x);
args.push_back(v.y);
}
RETURN_ARGS;
} break;
case Variant::PACKED_VECTOR3_ARRAY: {
const PackedVector3Array arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
Vector3 v = arr[i];
args.push_back(v.x);
args.push_back(v.y);
args.push_back(v.z);
}
RETURN_ARGS;
} break;
case Variant::PACKED_COLOR_ARRAY: {
const PackedColorArray arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
Color v = arr[i];
args.push_back(v.r);
args.push_back(v.g);
args.push_back(v.b);
args.push_back(v.a);
}
RETURN_ARGS;
} break;
case Variant::PACKED_VECTOR4_ARRAY: {
const PackedVector4Array arr = p_variant;
Array args;
for (int i = 0; i < arr.size(); i++) {
Vector4 v = arr[i];
args.push_back(v.x);
args.push_back(v.y);
args.push_back(v.z);
args.push_back(v.w);
}
RETURN_ARGS;
} break;
case Variant::VARIANT_MAX: {
// Nothing to do.
} break;
}
#undef RETURN_ARGS
ERR_FAIL_V_MSG(Variant(), vformat(R"(Unhandled Variant type "%s".)", Variant::get_type_name(p_variant.get_type())));
}
static bool _decode_container_type(const Dictionary &p_dict, const String &p_key, ContainerType &r_type, bool p_allow_objects) {
if (!p_dict.has(p_key)) {
return true;
}
const String type_name = p_dict[p_key];
const Variant::Type builtin_type = Variant::get_type_by_name(type_name);
if (builtin_type < Variant::VARIANT_MAX && builtin_type != Variant::OBJECT) {
r_type.builtin_type = builtin_type;
return true;
}
if (ClassDB::class_exists(type_name)) {
ERR_FAIL_COND_V(!p_allow_objects, false);
r_type.builtin_type = Variant::OBJECT;
r_type.class_name = type_name;
return true;
}
if (type_name.begins_with("res://")) {
ERR_FAIL_COND_V(!p_allow_objects, false);
ERR_FAIL_COND_V_MSG(!ResourceLoader::exists(type_name, "Script"), false, vformat(R"(Invalid script path "%s".)", type_name));
const Ref<Script> script = ResourceLoader::load(type_name, "Script");
ERR_FAIL_COND_V_MSG(script.is_null(), false, vformat(R"(Can't load script at path "%s".)", type_name));
r_type.builtin_type = Variant::OBJECT;
r_type.class_name = script->get_instance_base_type();
r_type.script = script;
return true;
}
ERR_FAIL_V_MSG(false, vformat(R"(Invalid type "%s".)", type_name));
}
Variant JSON::_to_native(const Variant &p_json, bool p_allow_objects, int p_depth) {
switch (p_json.get_type()) {
case Variant::NIL:
case Variant::BOOL: {
return p_json;
} break;
case Variant::STRING: {
const String s = p_json;
if (s.begins_with("i:")) {
return s.substr(2).to_int();
} else if (s.begins_with("f:")) {
return s.substr(2).to_float();
} else if (s.begins_with("s:")) {
return s.substr(2);
} else if (s.begins_with("sn:")) {
return StringName(s.substr(3));
} else if (s.begins_with("np:")) {
return NodePath(s.substr(3));
}
ERR_FAIL_V_MSG(Variant(), "Invalid string, the type prefix is not recognized.");
} break;
case Variant::DICTIONARY: {
const Dictionary dict = p_json;
ERR_FAIL_COND_V(!dict.has(TYPE), Variant());
#define LOAD_ARGS() \
ERR_FAIL_COND_V(!dict.has(ARGS), Variant()); \
const Array args = dict[ARGS]
#define LOAD_ARGS_CHECK_SIZE(m_size) \
ERR_FAIL_COND_V(!dict.has(ARGS), Variant()); \
const Array args = dict[ARGS]; \
ERR_FAIL_COND_V(args.size() != (m_size), Variant())
#define LOAD_ARGS_CHECK_FACTOR(m_factor) \
ERR_FAIL_COND_V(!dict.has(ARGS), Variant()); \
const Array args = dict[ARGS]; \
ERR_FAIL_COND_V(args.size() % (m_factor) != 0, Variant())
switch (Variant::get_type_by_name(dict[TYPE])) {
case Variant::NIL:
case Variant::BOOL: {
ERR_FAIL_V_MSG(Variant(), vformat(R"(Unexpected "%s": Variant type "%s" is JSON-compliant.)", TYPE, dict[TYPE]));
} break;
case Variant::INT:
case Variant::FLOAT:
case Variant::STRING:
case Variant::STRING_NAME:
case Variant::NODE_PATH: {
ERR_FAIL_V_MSG(Variant(), vformat(R"(Unexpected "%s": Variant type "%s" must be represented as a string.)", TYPE, dict[TYPE]));
} break;
case Variant::RID: {
return RID();
} break;
case Variant::CALLABLE: {
return Callable();
} break;
case Variant::SIGNAL: {
return Signal();
} break;
case Variant::VECTOR2: {
LOAD_ARGS_CHECK_SIZE(2);
Vector2 v;
v.x = args[0];
v.y = args[1];
return v;
} break;
case Variant::VECTOR2I: {
LOAD_ARGS_CHECK_SIZE(2);
Vector2i v;
v.x = args[0];
v.y = args[1];
return v;
} break;
case Variant::RECT2: {
LOAD_ARGS_CHECK_SIZE(4);
Rect2 r;
r.position = Point2(args[0], args[1]);
r.size = Size2(args[2], args[3]);
return r;
} break;
case Variant::RECT2I: {
LOAD_ARGS_CHECK_SIZE(4);
Rect2i r;
r.position = Point2i(args[0], args[1]);
r.size = Size2i(args[2], args[3]);
return r;
} break;
case Variant::VECTOR3: {
LOAD_ARGS_CHECK_SIZE(3);
Vector3 v;
v.x = args[0];
v.y = args[1];
v.z = args[2];
return v;
} break;
case Variant::VECTOR3I: {
LOAD_ARGS_CHECK_SIZE(3);
Vector3i v;
v.x = args[0];
v.y = args[1];
v.z = args[2];
return v;
} break;
case Variant::TRANSFORM2D: {
LOAD_ARGS_CHECK_SIZE(6);
Transform2D t;
t[0] = Vector2(args[0], args[1]);
t[1] = Vector2(args[2], args[3]);
t[2] = Vector2(args[4], args[5]);
return t;
} break;
case Variant::VECTOR4: {
LOAD_ARGS_CHECK_SIZE(4);
Vector4 v;
v.x = args[0];
v.y = args[1];
v.z = args[2];
v.w = args[3];
return v;
} break;
case Variant::VECTOR4I: {
LOAD_ARGS_CHECK_SIZE(4);
Vector4i v;
v.x = args[0];
v.y = args[1];
v.z = args[2];
v.w = args[3];
return v;
} break;
case Variant::PLANE: {
LOAD_ARGS_CHECK_SIZE(4);
Plane p;
p.normal = Vector3(args[0], args[1], args[2]);
p.d = args[3];
return p;
} break;
case Variant::QUATERNION: {
LOAD_ARGS_CHECK_SIZE(4);
Quaternion q;
q.x = args[0];
q.y = args[1];
q.z = args[2];
q.w = args[3];
return q;
} break;
case Variant::AABB: {
LOAD_ARGS_CHECK_SIZE(6);
AABB aabb;
aabb.position = Vector3(args[0], args[1], args[2]);
aabb.size = Vector3(args[3], args[4], args[5]);
return aabb;
} break;
case Variant::BASIS: {
LOAD_ARGS_CHECK_SIZE(9);
Basis b;
b.set_column(0, Vector3(args[0], args[1], args[2]));
b.set_column(1, Vector3(args[3], args[4], args[5]));
b.set_column(2, Vector3(args[6], args[7], args[8]));
return b;
} break;
case Variant::TRANSFORM3D: {
LOAD_ARGS_CHECK_SIZE(12);
Transform3D t;
t.basis.set_column(0, Vector3(args[0], args[1], args[2]));
t.basis.set_column(1, Vector3(args[3], args[4], args[5]));
t.basis.set_column(2, Vector3(args[6], args[7], args[8]));
t.origin = Vector3(args[9], args[10], args[11]);
return t;
} break;
case Variant::PROJECTION: {
LOAD_ARGS_CHECK_SIZE(16);
Projection p;
p[0] = Vector4(args[0], args[1], args[2], args[3]);
p[1] = Vector4(args[4], args[5], args[6], args[7]);
p[2] = Vector4(args[8], args[9], args[10], args[11]);
p[3] = Vector4(args[12], args[13], args[14], args[15]);
return p;
} break;
case Variant::COLOR: {
LOAD_ARGS_CHECK_SIZE(4);
Color c;
c.r = args[0];
c.g = args[1];
c.b = args[2];
c.a = args[3];
return c;
} break;
case Variant::OBJECT: {
// Nothing to do at this stage. `Object` should be treated as a class, not as a built-in type.
} break;
case Variant::DICTIONARY: {
LOAD_ARGS_CHECK_FACTOR(2);
ContainerType key_type;
if (!_decode_container_type(dict, KEY_TYPE, key_type, p_allow_objects)) {
return Variant();
}
ContainerType value_type;
if (!_decode_container_type(dict, VALUE_TYPE, value_type, p_allow_objects)) {
return Variant();
}
Dictionary ret;
if (key_type.builtin_type != Variant::NIL || value_type.builtin_type != Variant::NIL) {
ret.set_typed(key_type, value_type);
}
ERR_FAIL_COND_V_MSG(p_depth > Variant::MAX_RECURSION_DEPTH, ret, "Variant is too deep. Bailing.");
for (int i = 0; i < args.size() / 2; i++) {
ret[_to_native(args[i * 2 + 0], p_allow_objects, p_depth + 1)] = _to_native(args[i * 2 + 1], p_allow_objects, p_depth + 1);
}
return ret;
} break;
case Variant::ARRAY: {
LOAD_ARGS();
ContainerType elem_type;
if (!_decode_container_type(dict, ELEM_TYPE, elem_type, p_allow_objects)) {
return Variant();
}
Array ret;
if (elem_type.builtin_type != Variant::NIL) {
ret.set_typed(elem_type);
}
ERR_FAIL_COND_V_MSG(p_depth > Variant::MAX_RECURSION_DEPTH, ret, "Variant is too deep. Bailing.");
ret.resize(args.size());
for (int i = 0; i < args.size(); i++) {
ret[i] = _to_native(args[i], p_allow_objects, p_depth + 1);
}
return ret;
} break;
case Variant::PACKED_BYTE_ARRAY: {
LOAD_ARGS();
PackedByteArray arr;
arr.resize(args.size());
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = args[i];
}
return arr;
} break;
case Variant::PACKED_INT32_ARRAY: {
LOAD_ARGS();
PackedInt32Array arr;
arr.resize(args.size());
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = args[i];
}
return arr;
} break;
case Variant::PACKED_INT64_ARRAY: {
LOAD_ARGS();
PackedInt64Array arr;
arr.resize(args.size());
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = args[i];
}
return arr;
} break;
case Variant::PACKED_FLOAT32_ARRAY: {
LOAD_ARGS();
PackedFloat32Array arr;
arr.resize(args.size());
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = args[i];
}
return arr;
} break;
case Variant::PACKED_FLOAT64_ARRAY: {
LOAD_ARGS();
PackedFloat64Array arr;
arr.resize(args.size());
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = args[i];
}
return arr;
} break;
case Variant::PACKED_STRING_ARRAY: {
LOAD_ARGS();
PackedStringArray arr;
arr.resize(args.size());
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = args[i];
}
return arr;
} break;
case Variant::PACKED_VECTOR2_ARRAY: {
LOAD_ARGS_CHECK_FACTOR(2);
PackedVector2Array arr;
arr.resize(args.size() / 2);
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = Vector2(args[i * 2 + 0], args[i * 2 + 1]);
}
return arr;
} break;
case Variant::PACKED_VECTOR3_ARRAY: {
LOAD_ARGS_CHECK_FACTOR(3);
PackedVector3Array arr;
arr.resize(args.size() / 3);
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = Vector3(args[i * 3 + 0], args[i * 3 + 1], args[i * 3 + 2]);
}
return arr;
} break;
case Variant::PACKED_COLOR_ARRAY: {
LOAD_ARGS_CHECK_FACTOR(4);
PackedColorArray arr;
arr.resize(args.size() / 4);
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = Color(args[i * 4 + 0], args[i * 4 + 1], args[i * 4 + 2], args[i * 4 + 3]);
}
return arr;
} break;
case Variant::PACKED_VECTOR4_ARRAY: {
LOAD_ARGS_CHECK_FACTOR(4);
PackedVector4Array arr;
arr.resize(args.size() / 4);
for (int i = 0; i < arr.size(); i++) {
arr.write[i] = Vector4(args[i * 4 + 0], args[i * 4 + 1], args[i * 4 + 2], args[i * 4 + 3]);
}
return arr;
} break;
case Variant::VARIANT_MAX: {
// Nothing to do.
} break;
}
#undef LOAD_ARGS
#undef LOAD_ARGS_CHECK_SIZE
#undef LOAD_ARGS_CHECK_FACTOR
if (ClassDB::class_exists(dict[TYPE])) {
ERR_FAIL_COND_V(!p_allow_objects, Variant());
ERR_FAIL_COND_V_MSG(p_depth > Variant::MAX_RECURSION_DEPTH, Variant(), "Variant is too deep. Bailing.");
ERR_FAIL_COND_V(!dict.has(PROPS), Variant());
const Array props = dict[PROPS];
ERR_FAIL_COND_V(props.size() % 2 != 0, Variant());
ERR_FAIL_COND_V(!ClassDB::can_instantiate(dict[TYPE]), Variant());
Object *obj = ClassDB::instantiate(dict[TYPE]);
ERR_FAIL_NULL_V(obj, Variant());
// Avoid premature free `RefCounted`. This must be done before properties are initialized,
// since script functions (setters, implicit initializer) may be called. See GH-68666.
Variant variant;
if (Object::cast_to<RefCounted>(obj)) {
const Ref<RefCounted> ref = Ref<RefCounted>(Object::cast_to<RefCounted>(obj));
variant = ref;
} else {
variant = obj;
}
for (int i = 0; i < props.size() / 2; i++) {
const StringName name = props[i * 2 + 0];
const Variant value = _to_native(props[i * 2 + 1], p_allow_objects, p_depth + 1);
if (name == CoreStringName(script) && value.get_type() != Variant::NIL) {
const String path = value;
ERR_FAIL_COND_V_MSG(path.is_empty() || !path.begins_with("res://") || !ResourceLoader::exists(path, "Script"),
Variant(),
vformat(R"(Invalid script path "%s".)", path));
const Ref<Script> script = ResourceLoader::load(path, "Script");
ERR_FAIL_COND_V_MSG(script.is_null(), Variant(), vformat(R"(Can't load script at path "%s".)", path));
obj->set_script(script);
} else {
obj->set(name, value);
}
}
return variant;
}
ERR_FAIL_V_MSG(Variant(), vformat(R"(Invalid type "%s".)", dict[TYPE]));
} break;
case Variant::ARRAY: {
ERR_FAIL_COND_V_MSG(p_depth > Variant::MAX_RECURSION_DEPTH, Array(), "Variant is too deep. Bailing.");
const Array arr = p_json;
Array ret;
ret.resize(arr.size());
for (int i = 0; i < arr.size(); i++) {
ret[i] = _to_native(arr[i], p_allow_objects, p_depth + 1);
}
return ret;
} break;
default: {
// Nothing to do.
} break;
}
ERR_FAIL_V_MSG(Variant(), vformat(R"(Variant type "%s" is not JSON-compliant.)", Variant::get_type_name(p_json.get_type())));
}
#undef TYPE
#undef ELEM_TYPE
#undef KEY_TYPE
#undef VALUE_TYPE
#undef ARGS
#undef PROPS
////////////
Ref<Resource> ResourceFormatLoaderJSON::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
if (r_error) {
*r_error = ERR_FILE_CANT_OPEN;
}
if (!FileAccess::exists(p_path)) {
*r_error = ERR_FILE_NOT_FOUND;
return Ref<Resource>();
}
Ref<JSON> json;
json.instantiate();
Error err = json->parse(FileAccess::get_file_as_string(p_path), Engine::get_singleton()->is_editor_hint());
if (err != OK) {
String err_text = "Error parsing JSON file at '" + p_path + "', on line " + itos(json->get_error_line()) + ": " + json->get_error_message();
if (Engine::get_singleton()->is_editor_hint()) {
// If running on editor, still allow opening the JSON so the code editor can edit it.
WARN_PRINT(err_text);
} else {
if (r_error) {
*r_error = err;
}
ERR_PRINT(err_text);
return Ref<Resource>();
}
}
if (r_error) {
*r_error = OK;
}
return json;
}
void ResourceFormatLoaderJSON::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back("json");
}
bool ResourceFormatLoaderJSON::handles_type(const String &p_type) const {
return (p_type == "JSON");
}
String ResourceFormatLoaderJSON::get_resource_type(const String &p_path) const {
String el = p_path.get_extension().to_lower();
if (el == "json") {
return "JSON";
}
return "";
}
Error ResourceFormatSaverJSON::save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags) {
Ref<JSON> json = p_resource;
ERR_FAIL_COND_V(json.is_null(), ERR_INVALID_PARAMETER);
String source = json->get_parsed_text().is_empty() ? JSON::stringify(json->get_data(), "\t", false, true) : json->get_parsed_text();
Error err;
Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::WRITE, &err);
ERR_FAIL_COND_V_MSG(err, err, vformat("Cannot save json '%s'.", p_path));
file->store_string(source);
if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) {
return ERR_CANT_CREATE;
}
return OK;
}
void ResourceFormatSaverJSON::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
Ref<JSON> json = p_resource;
if (json.is_valid()) {
p_extensions->push_back("json");
}
}
bool ResourceFormatSaverJSON::recognize(const Ref<Resource> &p_resource) const {
return p_resource->get_class_name() == "JSON"; //only json, not inherited
}
Reference in a new issue View git blame Copy permalink