Reorganized core/ directory, it was too fatty already

-Removed FuncRef, since Callable makes it obsolete
-Removed int_types.h as its obsolete in c++11+
-Changed color names code

1 files changed, 1803 insertions, 0 deletions

diff --git a/core/variant/variant_parser.cpp b/core/variant/variant_parser.cpp
new file mode 100644
index 0000000000..5a0bbf041b
--- /dev/null
+++ b/core/variant/variant_parser.cpp
@@ -0,0 +1,1803 @@
+/*************************************************************************/
+/*  variant_parser.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* 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 "variant_parser.h"
+
+#include "core/input/input_event.h"
+#include "core/io/resource_loader.h"
+#include "core/os/keyboard.h"
+#include "core/string/string_buffer.h"
+
+char32_t VariantParser::StreamFile::get_char() {
+	return f->get_8();
+}
+
+bool VariantParser::StreamFile::is_utf8() const {
+	return true;
+}
+
+bool VariantParser::StreamFile::is_eof() const {
+	return f->eof_reached();
+}
+
+char32_t VariantParser::StreamString::get_char() {
+	if (pos > s.length()) {
+		return 0;
+	} else if (pos == s.length()) {
+		// You need to try to read again when you have reached the end for EOF to be reported,
+		// so this works the same as files (like StreamFile does)
+		pos++;
+		return 0;
+	} else {
+		return s[pos++];
+	}
+}
+
+bool VariantParser::StreamString::is_utf8() const {
+	return false;
+}
+
+bool VariantParser::StreamString::is_eof() const {
+	return pos > s.length();
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+
+const char *VariantParser::tk_name[TK_MAX] = {
+	"'{'",
+	"'}'",
+	"'['",
+	"']'",
+	"'('",
+	"')'",
+	"identifier",
+	"string",
+	"string_name",
+	"number",
+	"color",
+	"':'",
+	"','",
+	"'.'",
+	"'='",
+	"EOF",
+	"ERROR"
+};
+
+Error VariantParser::get_token(Stream *p_stream, Token &r_token, int &line, String &r_err_str) {
+	bool string_name = false;
+
+	while (true) {
+		char32_t cchar;
+		if (p_stream->saved) {
+			cchar = p_stream->saved;
+			p_stream->saved = 0;
+		} else {
+			cchar = p_stream->get_char();
+			if (p_stream->is_eof()) {
+				r_token.type = TK_EOF;
+				return OK;
+			}
+		}
+
+		switch (cchar) {
+			case '\n': {
+				line++;
+				break;
+			}
+			case 0: {
+				r_token.type = TK_EOF;
+				return OK;
+			} break;
+			case '{': {
+				r_token.type = TK_CURLY_BRACKET_OPEN;
+				return OK;
+			}
+			case '}': {
+				r_token.type = TK_CURLY_BRACKET_CLOSE;
+				return OK;
+			}
+			case '[': {
+				r_token.type = TK_BRACKET_OPEN;
+				return OK;
+			}
+			case ']': {
+				r_token.type = TK_BRACKET_CLOSE;
+				return OK;
+			}
+			case '(': {
+				r_token.type = TK_PARENTHESIS_OPEN;
+				return OK;
+			}
+			case ')': {
+				r_token.type = TK_PARENTHESIS_CLOSE;
+				return OK;
+			}
+			case ':': {
+				r_token.type = TK_COLON;
+				return OK;
+			}
+			case ';': {
+				while (true) {
+					char32_t ch = p_stream->get_char();
+					if (p_stream->is_eof()) {
+						r_token.type = TK_EOF;
+						return OK;
+					}
+					if (ch == '\n') {
+						break;
+					}
+				}
+
+				break;
+			}
+			case ',': {
+				r_token.type = TK_COMMA;
+				return OK;
+			}
+			case '.': {
+				r_token.type = TK_PERIOD;
+				return OK;
+			}
+			case '=': {
+				r_token.type = TK_EQUAL;
+				return OK;
+			}
+			case '#': {
+				StringBuffer<> color_str;
+				color_str += '#';
+				while (true) {
+					char32_t ch = p_stream->get_char();
+					if (p_stream->is_eof()) {
+						r_token.type = TK_EOF;
+						return OK;
+					} else if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) {
+						color_str += ch;
+
+					} else {
+						p_stream->saved = ch;
+						break;
+					}
+				}
+
+				r_token.value = Color::html(color_str.as_string());
+				r_token.type = TK_COLOR;
+				return OK;
+			}
+			case '@': {
+				cchar = p_stream->get_char();
+				if (cchar != '"') {
+					r_err_str = "Expected '\"' after '@'";
+					r_token.type = TK_ERROR;
+					return ERR_PARSE_ERROR;
+				}
+
+				string_name = true;
+				[[fallthrough]];
+			}
+			case '"': {
+				String str;
+				while (true) {
+					char32_t ch = p_stream->get_char();
+
+					if (ch == 0) {
+						r_err_str = "Unterminated String";
+						r_token.type = TK_ERROR;
+						return ERR_PARSE_ERROR;
+					} else if (ch == '"') {
+						break;
+					} else if (ch == '\\') {
+						//escaped characters...
+						char32_t next = p_stream->get_char();
+						if (next == 0) {
+							r_err_str = "Unterminated String";
+							r_token.type = TK_ERROR;
+							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_stream->get_char();
+									if (c == 0) {
+										r_err_str = "Unterminated String";
+										r_token.type = TK_ERROR;
+										return ERR_PARSE_ERROR;
+									}
+									if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
+										r_err_str = "Malformed hex constant in string";
+										r_token.type = TK_ERROR;
+										return ERR_PARSE_ERROR;
+									}
+									char32_t v;
+									if (c >= '0' && c <= '9') {
+										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;
+								}
+
+							} break;
+							default: {
+								res = next;
+							} break;
+						}
+
+						str += res;
+
+					} else {
+						if (ch == '\n') {
+							line++;
+						}
+						str += ch;
+					}
+				}
+
+				if (p_stream->is_utf8()) {
+					str.parse_utf8(str.ascii(true).get_data());
+				}
+				if (string_name) {
+					r_token.type = TK_STRING_NAME;
+					r_token.value = StringName(str);
+					string_name = false; //reset
+				} else {
+					r_token.type = TK_STRING;
+					r_token.value = str;
+				}
+				return OK;
+
+			} break;
+			default: {
+				if (cchar <= 32) {
+					break;
+				}
+
+				if (cchar == '-' || (cchar >= '0' && cchar <= '9')) {
+					//a number
+
+					StringBuffer<> num;
+#define READING_SIGN 0
+#define READING_INT 1
+#define READING_DEC 2
+#define READING_EXP 3
+#define READING_DONE 4
+					int reading = READING_INT;
+
+					if (cchar == '-') {
+						num += '-';
+						cchar = p_stream->get_char();
+					}
+
+					char32_t c = cchar;
+					bool exp_sign = false;
+					bool exp_beg = false;
+					bool is_float = false;
+
+					while (true) {
+						switch (reading) {
+							case READING_INT: {
+								if (c >= '0' && c <= '9') {
+									//pass
+								} else if (c == '.') {
+									reading = READING_DEC;
+									is_float = true;
+								} else if (c == 'e') {
+									reading = READING_EXP;
+									is_float = true;
+								} else {
+									reading = READING_DONE;
+								}
+
+							} break;
+							case READING_DEC: {
+								if (c >= '0' && c <= '9') {
+								} else if (c == 'e') {
+									reading = READING_EXP;
+								} else {
+									reading = READING_DONE;
+								}
+
+							} break;
+							case READING_EXP: {
+								if (c >= '0' && c <= '9') {
+									exp_beg = true;
+
+								} else if ((c == '-' || c == '+') && !exp_sign && !exp_beg) {
+									exp_sign = true;
+
+								} else {
+									reading = READING_DONE;
+								}
+							} break;
+						}
+
+						if (reading == READING_DONE) {
+							break;
+						}
+						num += c;
+						c = p_stream->get_char();
+					}
+
+					p_stream->saved = c;
+
+					r_token.type = TK_NUMBER;
+
+					if (is_float) {
+						r_token.value = num.as_double();
+					} else {
+						r_token.value = num.as_int();
+					}
+					return OK;
+
+				} else if ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_') {
+					StringBuffer<> id;
+					bool first = true;
+
+					while ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_' || (!first && cchar >= '0' && cchar <= '9')) {
+						id += cchar;
+						cchar = p_stream->get_char();
+						first = false;
+					}
+
+					p_stream->saved = cchar;
+
+					r_token.type = TK_IDENTIFIER;
+					r_token.value = id.as_string();
+					return OK;
+				} else {
+					r_err_str = "Unexpected character.";
+					r_token.type = TK_ERROR;
+					return ERR_PARSE_ERROR;
+				}
+			}
+		}
+	}
+
+	r_token.type = TK_ERROR;
+	return ERR_PARSE_ERROR;
+}
+
+Error VariantParser::_parse_enginecfg(Stream *p_stream, Vector<String> &strings, int &line, String &r_err_str) {
+	Token token;
+	get_token(p_stream, token, line, r_err_str);
+	if (token.type != TK_PARENTHESIS_OPEN) {
+		r_err_str = "Expected '(' in old-style project.godot construct";
+		return ERR_PARSE_ERROR;
+	}
+
+	String accum;
+
+	while (true) {
+		char32_t c = p_stream->get_char();
+
+		if (p_stream->is_eof()) {
+			r_err_str = "Unexpected EOF while parsing old-style project.godot construct";
+			return ERR_PARSE_ERROR;
+		}
+
+		if (c == ',') {
+			strings.push_back(accum.strip_edges());
+			accum = String();
+		} else if (c == ')') {
+			strings.push_back(accum.strip_edges());
+			return OK;
+		} else if (c == '\n') {
+			line++;
+		}
+	}
+}
+
+template <class T>
+Error VariantParser::_parse_construct(Stream *p_stream, Vector<T> &r_construct, int &line, String &r_err_str) {
+	Token token;
+	get_token(p_stream, token, line, r_err_str);
+	if (token.type != TK_PARENTHESIS_OPEN) {
+		r_err_str = "Expected '(' in constructor";
+		return ERR_PARSE_ERROR;
+	}
+
+	bool first = true;
+	while (true) {
+		if (!first) {
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type == TK_COMMA) {
+				//do none
+			} else if (token.type == TK_PARENTHESIS_CLOSE) {
+				break;
+			} else {
+				r_err_str = "Expected ',' or ')' in constructor";
+				return ERR_PARSE_ERROR;
+			}
+		}
+		get_token(p_stream, token, line, r_err_str);
+
+		if (first && token.type == TK_PARENTHESIS_CLOSE) {
+			break;
+		} else if (token.type != TK_NUMBER) {
+			r_err_str = "Expected float in constructor";
+			return ERR_PARSE_ERROR;
+		}
+
+		r_construct.push_back(token.value);
+		first = false;
+	}
+
+	return OK;
+}
+
+Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, int &line, String &r_err_str, ResourceParser *p_res_parser) {
+	if (token.type == TK_CURLY_BRACKET_OPEN) {
+		Dictionary d;
+		Error err = _parse_dictionary(d, p_stream, line, r_err_str, p_res_parser);
+		if (err) {
+			return err;
+		}
+		value = d;
+		return OK;
+	} else if (token.type == TK_BRACKET_OPEN) {
+		Array a;
+		Error err = _parse_array(a, p_stream, line, r_err_str, p_res_parser);
+		if (err) {
+			return err;
+		}
+		value = a;
+		return OK;
+	} 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" || id == "nil") {
+			value = Variant();
+		} else if (id == "inf") {
+			value = Math_INF;
+		} else if (id == "nan") {
+			value = Math_NAN;
+		} else if (id == "Vector2") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 2) {
+				r_err_str = "Expected 2 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Vector2(args[0], args[1]);
+		} else if (id == "Vector2i") {
+			Vector<int32_t> args;
+			Error err = _parse_construct<int32_t>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 2) {
+				r_err_str = "Expected 2 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Vector2i(args[0], args[1]);
+		} else if (id == "Rect2") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 4) {
+				r_err_str = "Expected 4 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Rect2(args[0], args[1], args[2], args[3]);
+		} else if (id == "Rect2i") {
+			Vector<int32_t> args;
+			Error err = _parse_construct<int32_t>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 4) {
+				r_err_str = "Expected 4 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Rect2i(args[0], args[1], args[2], args[3]);
+		} else if (id == "Vector3") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 3) {
+				r_err_str = "Expected 3 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Vector3(args[0], args[1], args[2]);
+		} else if (id == "Vector3i") {
+			Vector<int32_t> args;
+			Error err = _parse_construct<int32_t>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 3) {
+				r_err_str = "Expected 3 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Vector3i(args[0], args[1], args[2]);
+		} else if (id == "Transform2D" || id == "Matrix32") { //compatibility
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 6) {
+				r_err_str = "Expected 6 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			Transform2D m;
+			m[0] = Vector2(args[0], args[1]);
+			m[1] = Vector2(args[2], args[3]);
+			m[2] = Vector2(args[4], args[5]);
+			value = m;
+		} else if (id == "Plane") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 4) {
+				r_err_str = "Expected 4 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Plane(args[0], args[1], args[2], args[3]);
+		} else if (id == "Quat") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 4) {
+				r_err_str = "Expected 4 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Quat(args[0], args[1], args[2], args[3]);
+		} else if (id == "AABB" || id == "Rect3") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 6) {
+				r_err_str = "Expected 6 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = AABB(Vector3(args[0], args[1], args[2]), Vector3(args[3], args[4], args[5]));
+		} else if (id == "Basis" || id == "Matrix3") { //compatibility
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 9) {
+				r_err_str = "Expected 9 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Basis(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
+		} else if (id == "Transform") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 12) {
+				r_err_str = "Expected 12 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Transform(Basis(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]), Vector3(args[9], args[10], args[11]));
+		} else if (id == "Color") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			if (args.size() != 4) {
+				r_err_str = "Expected 4 arguments for constructor";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = Color(args[0], args[1], args[2], args[3]);
+		} else if (id == "NodePath") {
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_PARENTHESIS_OPEN) {
+				r_err_str = "Expected '('";
+				return ERR_PARSE_ERROR;
+			}
+
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_STRING) {
+				r_err_str = "Expected string as argument for NodePath()";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = NodePath(String(token.value));
+
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_PARENTHESIS_CLOSE) {
+				r_err_str = "Expected ')'";
+				return ERR_PARSE_ERROR;
+			}
+		} else if (id == "RID") {
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_PARENTHESIS_OPEN) {
+				r_err_str = "Expected '('";
+				return ERR_PARSE_ERROR;
+			}
+
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_NUMBER) {
+				r_err_str = "Expected number as argument";
+				return ERR_PARSE_ERROR;
+			}
+
+			value = token.value;
+
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_PARENTHESIS_CLOSE) {
+				r_err_str = "Expected ')'";
+				return ERR_PARSE_ERROR;
+			}
+		} else if (id == "Object") {
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_PARENTHESIS_OPEN) {
+				r_err_str = "Expected '('";
+				return ERR_PARSE_ERROR;
+			}
+
+			get_token(p_stream, token, line, r_err_str);
+
+			if (token.type != TK_IDENTIFIER) {
+				r_err_str = "Expected identifier with type of object";
+				return ERR_PARSE_ERROR;
+			}
+
+			String type = token.value;
+
+			Object *obj = ClassDB::instance(type);
+
+			if (!obj) {
+				r_err_str = "Can't instance Object() of type: " + type;
+				return ERR_PARSE_ERROR;
+			}
+
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_COMMA) {
+				r_err_str = "Expected ',' after object type";
+				return ERR_PARSE_ERROR;
+			}
+
+			bool at_key = true;
+			String key;
+			Token token2;
+			bool need_comma = false;
+
+			while (true) {
+				if (p_stream->is_eof()) {
+					r_err_str = "Unexpected End of File while parsing Object()";
+					return ERR_FILE_CORRUPT;
+				}
+
+				if (at_key) {
+					Error err = get_token(p_stream, token2, line, r_err_str);
+					if (err != OK) {
+						return err;
+					}
+
+					if (token2.type == TK_PARENTHESIS_CLOSE) {
+						Reference *reference = Object::cast_to<Reference>(obj);
+						if (reference) {
+							value = REF(reference);
+						} else {
+							value = obj;
+						}
+						return OK;
+					}
+
+					if (need_comma) {
+						if (token2.type != TK_COMMA) {
+							r_err_str = "Expected '}' or ','";
+							return ERR_PARSE_ERROR;
+						} else {
+							need_comma = false;
+							continue;
+						}
+					}
+
+					if (token2.type != TK_STRING) {
+						r_err_str = "Expected property name as string";
+						return ERR_PARSE_ERROR;
+					}
+
+					key = token2.value;
+
+					err = get_token(p_stream, token2, line, r_err_str);
+
+					if (err != OK) {
+						return err;
+					}
+					if (token2.type != TK_COLON) {
+						r_err_str = "Expected ':'";
+						return ERR_PARSE_ERROR;
+					}
+					at_key = false;
+				} else {
+					Error err = get_token(p_stream, token2, line, r_err_str);
+					if (err != OK) {
+						return err;
+					}
+
+					Variant v;
+					err = parse_value(token2, v, p_stream, line, r_err_str, p_res_parser);
+					if (err) {
+						return err;
+					}
+					obj->set(key, v);
+					need_comma = true;
+					at_key = true;
+				}
+			}
+		} else if (id == "Resource" || id == "SubResource" || id == "ExtResource") {
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_PARENTHESIS_OPEN) {
+				r_err_str = "Expected '('";
+				return ERR_PARSE_ERROR;
+			}
+
+			if (p_res_parser && id == "Resource" && p_res_parser->func) {
+				RES res;
+				Error err = p_res_parser->func(p_res_parser->userdata, p_stream, res, line, r_err_str);
+				if (err) {
+					return err;
+				}
+
+				value = res;
+			} else if (p_res_parser && id == "ExtResource" && p_res_parser->ext_func) {
+				RES res;
+				Error err = p_res_parser->ext_func(p_res_parser->userdata, p_stream, res, line, r_err_str);
+				if (err) {
+					return err;
+				}
+
+				value = res;
+			} else if (p_res_parser && id == "SubResource" && p_res_parser->sub_func) {
+				RES res;
+				Error err = p_res_parser->sub_func(p_res_parser->userdata, p_stream, res, line, r_err_str);
+				if (err) {
+					return err;
+				}
+
+				value = res;
+			} else {
+				get_token(p_stream, token, line, r_err_str);
+				if (token.type == TK_STRING) {
+					String path = token.value;
+					RES res = ResourceLoader::load(path);
+					if (res.is_null()) {
+						r_err_str = "Can't load resource at path: '" + path + "'.";
+						return ERR_PARSE_ERROR;
+					}
+
+					get_token(p_stream, token, line, r_err_str);
+					if (token.type != TK_PARENTHESIS_CLOSE) {
+						r_err_str = "Expected ')'";
+						return ERR_PARSE_ERROR;
+					}
+
+					value = res;
+				} else {
+					r_err_str = "Expected string as argument for Resource().";
+					return ERR_PARSE_ERROR;
+				}
+			}
+		} else if (id == "PackedByteArray" || id == "PoolByteArray" || id == "ByteArray") {
+			Vector<uint8_t> args;
+			Error err = _parse_construct<uint8_t>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			Vector<uint8_t> arr;
+			{
+				int len = args.size();
+				arr.resize(len);
+				uint8_t *w = arr.ptrw();
+				for (int i = 0; i < len; i++) {
+					w[i] = args[i];
+				}
+			}
+
+			value = arr;
+		} else if (id == "PackedInt32Array" || id == "PackedIntArray" || id == "PoolIntArray" || id == "IntArray") {
+			Vector<int32_t> args;
+			Error err = _parse_construct<int32_t>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			Vector<int32_t> arr;
+			{
+				int32_t len = args.size();
+				arr.resize(len);
+				int32_t *w = arr.ptrw();
+				for (int32_t i = 0; i < len; i++) {
+					w[i] = int32_t(args[i]);
+				}
+			}
+
+			value = arr;
+		} else if (id == "PackedInt64Array") {
+			Vector<int64_t> args;
+			Error err = _parse_construct<int64_t>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			Vector<int64_t> arr;
+			{
+				int64_t len = args.size();
+				arr.resize(len);
+				int64_t *w = arr.ptrw();
+				for (int64_t i = 0; i < len; i++) {
+					w[i] = int64_t(args[i]);
+				}
+			}
+
+			value = arr;
+		} else if (id == "PackedFloat32Array" || id == "PackedRealArray" || id == "PoolRealArray" || id == "FloatArray") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			Vector<float> arr;
+			{
+				int len = args.size();
+				arr.resize(len);
+				float *w = arr.ptrw();
+				for (int i = 0; i < len; i++) {
+					w[i] = args[i];
+				}
+			}
+
+			value = arr;
+		} else if (id == "PackedFloat64Array") {
+			Vector<double> args;
+			Error err = _parse_construct<double>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			Vector<double> arr;
+			{
+				int len = args.size();
+				arr.resize(len);
+				double *w = arr.ptrw();
+				for (int i = 0; i < len; i++) {
+					w[i] = args[i];
+				}
+			}
+
+			value = arr;
+		} else if (id == "PackedStringArray" || id == "PoolStringArray" || id == "StringArray") {
+			get_token(p_stream, token, line, r_err_str);
+			if (token.type != TK_PARENTHESIS_OPEN) {
+				r_err_str = "Expected '('";
+				return ERR_PARSE_ERROR;
+			}
+
+			Vector<String> cs;
+
+			bool first = true;
+			while (true) {
+				if (!first) {
+					get_token(p_stream, token, line, r_err_str);
+					if (token.type == TK_COMMA) {
+						//do none
+					} else if (token.type == TK_PARENTHESIS_CLOSE) {
+						break;
+					} else {
+						r_err_str = "Expected ',' or ')'";
+						return ERR_PARSE_ERROR;
+					}
+				}
+				get_token(p_stream, token, line, r_err_str);
+
+				if (token.type == TK_PARENTHESIS_CLOSE) {
+					break;
+				} else if (token.type != TK_STRING) {
+					r_err_str = "Expected string";
+					return ERR_PARSE_ERROR;
+				}
+
+				first = false;
+				cs.push_back(token.value);
+			}
+
+			Vector<String> arr;
+			{
+				int len = cs.size();
+				arr.resize(len);
+				String *w = arr.ptrw();
+				for (int i = 0; i < len; i++) {
+					w[i] = cs[i];
+				}
+			}
+
+			value = arr;
+		} else if (id == "PackedVector2Array" || id == "PoolVector2Array" || id == "Vector2Array") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			Vector<Vector2> arr;
+			{
+				int len = args.size() / 2;
+				arr.resize(len);
+				Vector2 *w = arr.ptrw();
+				for (int i = 0; i < len; i++) {
+					w[i] = Vector2(args[i * 2 + 0], args[i * 2 + 1]);
+				}
+			}
+
+			value = arr;
+		} else if (id == "PackedVector3Array" || id == "PoolVector3Array" || id == "Vector3Array") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			Vector<Vector3> arr;
+			{
+				int len = args.size() / 3;
+				arr.resize(len);
+				Vector3 *w = arr.ptrw();
+				for (int i = 0; i < len; i++) {
+					w[i] = Vector3(args[i * 3 + 0], args[i * 3 + 1], args[i * 3 + 2]);
+				}
+			}
+
+			value = arr;
+		} else if (id == "PackedColorArray" || id == "PoolColorArray" || id == "ColorArray") {
+			Vector<float> args;
+			Error err = _parse_construct<float>(p_stream, args, line, r_err_str);
+			if (err) {
+				return err;
+			}
+
+			Vector<Color> arr;
+			{
+				int len = args.size() / 4;
+				arr.resize(len);
+				Color *w = arr.ptrw();
+				for (int i = 0; i < len; i++) {
+					w[i] = Color(args[i * 4 + 0], args[i * 4 + 1], args[i * 4 + 2], args[i * 4 + 3]);
+				}
+			}
+
+			value = arr;
+		} else {
+			r_err_str = "Unexpected identifier: '" + id + "'.";
+			return ERR_PARSE_ERROR;
+		}
+
+		// All above branches end up here unless they had an early return.
+		return OK;
+	} else if (token.type == TK_NUMBER) {
+		value = token.value;
+		return OK;
+	} else if (token.type == TK_STRING) {
+		value = token.value;
+		return OK;
+	} else if (token.type == TK_STRING_NAME) {
+		value = token.value;
+		return OK;
+	} else if (token.type == TK_COLOR) {
+		value = token.value;
+		return OK;
+	} else {
+		r_err_str = "Expected value, got " + String(tk_name[token.type]) + ".";
+		return ERR_PARSE_ERROR;
+	}
+}
+
+Error VariantParser::_parse_array(Array &array, Stream *p_stream, int &line, String &r_err_str, ResourceParser *p_res_parser) {
+	Token token;
+	bool need_comma = false;
+
+	while (true) {
+		if (p_stream->is_eof()) {
+			r_err_str = "Unexpected End of File while parsing array";
+			return ERR_FILE_CORRUPT;
+		}
+
+		Error err = get_token(p_stream, 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(token, v, p_stream, line, r_err_str, p_res_parser);
+		if (err) {
+			return err;
+		}
+
+		array.push_back(v);
+		need_comma = true;
+	}
+}
+
+Error VariantParser::_parse_dictionary(Dictionary &object, Stream *p_stream, int &line, String &r_err_str, ResourceParser *p_res_parser) {
+	bool at_key = true;
+	Variant key;
+	Token token;
+	bool need_comma = false;
+
+	while (true) {
+		if (p_stream->is_eof()) {
+			r_err_str = "Unexpected End of File while parsing dictionary";
+			return ERR_FILE_CORRUPT;
+		}
+
+		if (at_key) {
+			Error err = get_token(p_stream, 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;
+				}
+			}
+
+			err = parse_value(token, key, p_stream, line, r_err_str, p_res_parser);
+
+			if (err) {
+				return err;
+			}
+
+			err = get_token(p_stream, 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_stream, token, line, r_err_str);
+			if (err != OK) {
+				return err;
+			}
+
+			Variant v;
+			err = parse_value(token, v, p_stream, line, r_err_str, p_res_parser);
+			if (err) {
+				return err;
+			}
+			object[key] = v;
+			need_comma = true;
+			at_key = true;
+		}
+	}
+}
+
+Error VariantParser::_parse_tag(Token &token, Stream *p_stream, int &line, String &r_err_str, Tag &r_tag, ResourceParser *p_res_parser, bool p_simple_tag) {
+	r_tag.fields.clear();
+
+	if (token.type != TK_BRACKET_OPEN) {
+		r_err_str = "Expected '['";
+		return ERR_PARSE_ERROR;
+	}
+
+	if (p_simple_tag) {
+		r_tag.name = "";
+		r_tag.fields.clear();
+
+		while (true) {
+			char32_t c = p_stream->get_char();
+			if (p_stream->is_eof()) {
+				r_err_str = "Unexpected EOF while parsing simple tag";
+				return ERR_PARSE_ERROR;
+			}
+			if (c == ']') {
+				break;
+			}
+			r_tag.name += String::chr(c);
+		}
+
+		r_tag.name = r_tag.name.strip_edges();
+
+		return OK;
+	}
+
+	get_token(p_stream, token, line, r_err_str);
+
+	if (token.type != TK_IDENTIFIER) {
+		r_err_str = "Expected identifier (tag name)";
+		return ERR_PARSE_ERROR;
+	}
+
+	r_tag.name = token.value;
+	bool parsing_tag = true;
+
+	while (true) {
+		if (p_stream->is_eof()) {
+			r_err_str = "Unexpected End of File while parsing tag: " + r_tag.name;
+			return ERR_FILE_CORRUPT;
+		}
+
+		get_token(p_stream, token, line, r_err_str);
+		if (token.type == TK_BRACKET_CLOSE) {
+			break;
+		}
+
+		if (parsing_tag && token.type == TK_PERIOD) {
+			r_tag.name += "."; //support tags such as [someprop.Android] for specific platforms
+			get_token(p_stream, token, line, r_err_str);
+		} else if (parsing_tag && token.type == TK_COLON) {
+			r_tag.name += ":"; //support tags such as [someprop.Android] for specific platforms
+			get_token(p_stream, token, line, r_err_str);
+		} else {
+			parsing_tag = false;
+		}
+
+		if (token.type != TK_IDENTIFIER) {
+			r_err_str = "Expected Identifier";
+			return ERR_PARSE_ERROR;
+		}
+
+		String id = token.value;
+
+		if (parsing_tag) {
+			r_tag.name += id;
+			continue;
+		}
+
+		get_token(p_stream, token, line, r_err_str);
+		if (token.type != TK_EQUAL) {
+			return ERR_PARSE_ERROR;
+		}
+
+		get_token(p_stream, token, line, r_err_str);
+		Variant value;
+		Error err = parse_value(token, value, p_stream, line, r_err_str, p_res_parser);
+		if (err) {
+			return err;
+		}
+
+		r_tag.fields[id] = value;
+	}
+
+	return OK;
+}
+
+Error VariantParser::parse_tag(Stream *p_stream, int &line, String &r_err_str, Tag &r_tag, ResourceParser *p_res_parser, bool p_simple_tag) {
+	Token token;
+	get_token(p_stream, token, line, r_err_str);
+
+	if (token.type == TK_EOF) {
+		return ERR_FILE_EOF;
+	}
+
+	if (token.type != TK_BRACKET_OPEN) {
+		r_err_str = "Expected '['";
+		return ERR_PARSE_ERROR;
+	}
+
+	return _parse_tag(token, p_stream, line, r_err_str, r_tag, p_res_parser, p_simple_tag);
+}
+
+Error VariantParser::parse_tag_assign_eof(Stream *p_stream, int &line, String &r_err_str, Tag &r_tag, String &r_assign, Variant &r_value, ResourceParser *p_res_parser, bool p_simple_tag) {
+	//assign..
+	r_assign = "";
+	String what;
+
+	while (true) {
+		char32_t c;
+		if (p_stream->saved) {
+			c = p_stream->saved;
+			p_stream->saved = 0;
+
+		} else {
+			c = p_stream->get_char();
+		}
+
+		if (p_stream->is_eof()) {
+			return ERR_FILE_EOF;
+		}
+
+		if (c == ';') { //comment
+			while (true) {
+				char32_t ch = p_stream->get_char();
+				if (p_stream->is_eof()) {
+					return ERR_FILE_EOF;
+				}
+				if (ch == '\n') {
+					break;
+				}
+			}
+			continue;
+		}
+
+		if (c == '[' && what.length() == 0) {
+			//it's a tag!
+			p_stream->saved = '['; //go back one
+
+			Error err = parse_tag(p_stream, line, r_err_str, r_tag, p_res_parser, p_simple_tag);
+
+			return err;
+		}
+
+		if (c > 32) {
+			if (c == '"') { //quoted
+				p_stream->saved = '"';
+				Token tk;
+				Error err = get_token(p_stream, tk, line, r_err_str);
+				if (err) {
+					return err;
+				}
+				if (tk.type != TK_STRING) {
+					r_err_str = "Error reading quoted string";
+					return ERR_INVALID_DATA;
+				}
+
+				what = tk.value;
+
+			} else if (c != '=') {
+				what += String::chr(c);
+			} else {
+				r_assign = what;
+				Token token;
+				get_token(p_stream, token, line, r_err_str);
+				Error err = parse_value(token, r_value, p_stream, line, r_err_str, p_res_parser);
+				return err;
+			}
+		} else if (c == '\n') {
+			line++;
+		}
+	}
+}
+
+Error VariantParser::parse(Stream *p_stream, Variant &r_ret, String &r_err_str, int &r_err_line, ResourceParser *p_res_parser) {
+	Token token;
+	Error err = get_token(p_stream, token, r_err_line, r_err_str);
+	if (err) {
+		return err;
+	}
+
+	if (token.type == TK_EOF) {
+		return ERR_FILE_EOF;
+	}
+
+	return parse_value(token, r_ret, p_stream, r_err_line, r_err_str, p_res_parser);
+}
+
+//////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+static String rtosfix(double p_value) {
+	if (p_value == 0.0) {
+		return "0"; //avoid negative zero (-0) being written, which may annoy git, svn, etc. for changes when they don't exist.
+	} else {
+		return rtoss(p_value);
+	}
+}
+
+Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_string_func, void *p_store_string_ud, EncodeResourceFunc p_encode_res_func, void *p_encode_res_ud) {
+	switch (p_variant.get_type()) {
+		case Variant::NIL: {
+			p_store_string_func(p_store_string_ud, "null");
+		} break;
+		case Variant::BOOL: {
+			p_store_string_func(p_store_string_ud, p_variant.operator bool() ? "true" : "false");
+		} break;
+		case Variant::INT: {
+			p_store_string_func(p_store_string_ud, itos(p_variant.operator int64_t()));
+		} break;
+		case Variant::FLOAT: {
+			String s = rtosfix(p_variant.operator real_t());
+			if (s != "inf" && s != "nan") {
+				if (s.find(".") == -1 && s.find("e") == -1) {
+					s += ".0";
+				}
+			}
+			p_store_string_func(p_store_string_ud, s);
+		} break;
+		case Variant::STRING: {
+			String str = p_variant;
+
+			str = "\"" + str.c_escape_multiline() + "\"";
+			p_store_string_func(p_store_string_ud, str);
+		} break;
+		case Variant::VECTOR2: {
+			Vector2 v = p_variant;
+			p_store_string_func(p_store_string_ud, "Vector2( " + rtosfix(v.x) + ", " + rtosfix(v.y) + " )");
+		} break;
+		case Variant::VECTOR2I: {
+			Vector2i v = p_variant;
+			p_store_string_func(p_store_string_ud, "Vector2i( " + itos(v.x) + ", " + itos(v.y) + " )");
+		} break;
+		case Variant::RECT2: {
+			Rect2 aabb = p_variant;
+			p_store_string_func(p_store_string_ud, "Rect2( " + rtosfix(aabb.position.x) + ", " + rtosfix(aabb.position.y) + ", " + rtosfix(aabb.size.x) + ", " + rtosfix(aabb.size.y) + " )");
+
+		} break;
+		case Variant::RECT2I: {
+			Rect2i aabb = p_variant;
+			p_store_string_func(p_store_string_ud, "Rect2i( " + itos(aabb.position.x) + ", " + itos(aabb.position.y) + ", " + itos(aabb.size.x) + ", " + itos(aabb.size.y) + " )");
+
+		} break;
+		case Variant::VECTOR3: {
+			Vector3 v = p_variant;
+			p_store_string_func(p_store_string_ud, "Vector3( " + rtosfix(v.x) + ", " + rtosfix(v.y) + ", " + rtosfix(v.z) + " )");
+		} break;
+		case Variant::VECTOR3I: {
+			Vector3i v = p_variant;
+			p_store_string_func(p_store_string_ud, "Vector3i( " + itos(v.x) + ", " + itos(v.y) + ", " + itos(v.z) + " )");
+		} break;
+		case Variant::PLANE: {
+			Plane p = p_variant;
+			p_store_string_func(p_store_string_ud, "Plane( " + rtosfix(p.normal.x) + ", " + rtosfix(p.normal.y) + ", " + rtosfix(p.normal.z) + ", " + rtosfix(p.d) + " )");
+
+		} break;
+		case Variant::AABB: {
+			AABB aabb = p_variant;
+			p_store_string_func(p_store_string_ud, "AABB( " + rtosfix(aabb.position.x) + ", " + rtosfix(aabb.position.y) + ", " + rtosfix(aabb.position.z) + ", " + rtosfix(aabb.size.x) + ", " + rtosfix(aabb.size.y) + ", " + rtosfix(aabb.size.z) + " )");
+
+		} break;
+		case Variant::QUAT: {
+			Quat quat = p_variant;
+			p_store_string_func(p_store_string_ud, "Quat( " + rtosfix(quat.x) + ", " + rtosfix(quat.y) + ", " + rtosfix(quat.z) + ", " + rtosfix(quat.w) + " )");
+
+		} break;
+		case Variant::TRANSFORM2D: {
+			String s = "Transform2D( ";
+			Transform2D m3 = p_variant;
+			for (int i = 0; i < 3; i++) {
+				for (int j = 0; j < 2; j++) {
+					if (i != 0 || j != 0) {
+						s += ", ";
+					}
+					s += rtosfix(m3.elements[i][j]);
+				}
+			}
+
+			p_store_string_func(p_store_string_ud, s + " )");
+
+		} break;
+		case Variant::BASIS: {
+			String s = "Basis( ";
+			Basis m3 = p_variant;
+			for (int i = 0; i < 3; i++) {
+				for (int j = 0; j < 3; j++) {
+					if (i != 0 || j != 0) {
+						s += ", ";
+					}
+					s += rtosfix(m3.elements[i][j]);
+				}
+			}
+
+			p_store_string_func(p_store_string_ud, s + " )");
+
+		} break;
+		case Variant::TRANSFORM: {
+			String s = "Transform( ";
+			Transform t = p_variant;
+			Basis &m3 = t.basis;
+			for (int i = 0; i < 3; i++) {
+				for (int j = 0; j < 3; j++) {
+					if (i != 0 || j != 0) {
+						s += ", ";
+					}
+					s += rtosfix(m3.elements[i][j]);
+				}
+			}
+
+			s = s + ", " + rtosfix(t.origin.x) + ", " + rtosfix(t.origin.y) + ", " + rtosfix(t.origin.z);
+
+			p_store_string_func(p_store_string_ud, s + " )");
+		} break;
+
+		// misc types
+		case Variant::COLOR: {
+			Color c = p_variant;
+			p_store_string_func(p_store_string_ud, "Color( " + rtosfix(c.r) + ", " + rtosfix(c.g) + ", " + rtosfix(c.b) + ", " + rtosfix(c.a) + " )");
+
+		} break;
+		case Variant::STRING_NAME: {
+			String str = p_variant;
+
+			str = "@\"" + str.c_escape() + "\"";
+			p_store_string_func(p_store_string_ud, str);
+
+		} break;
+		case Variant::NODE_PATH: {
+			String str = p_variant;
+
+			str = "NodePath(\"" + str.c_escape() + "\")";
+			p_store_string_func(p_store_string_ud, str);
+
+		} break;
+
+		case Variant::OBJECT: {
+			Object *obj = p_variant;
+
+			if (!obj) {
+				p_store_string_func(p_store_string_ud, "null");
+				break; // don't save it
+			}
+
+			RES res = p_variant;
+			if (res.is_valid()) {
+				//is resource
+				String res_text;
+
+				//try external function
+				if (p_encode_res_func) {
+					res_text = p_encode_res_func(p_encode_res_ud, res);
+				}
+
+				//try path because it's a file
+				if (res_text == String() && res->get_path().is_resource_file()) {
+					//external resource
+					String path = res->get_path();
+					res_text = "Resource( \"" + path + "\")";
+				}
+
+				//could come up with some sort of text
+				if (res_text != String()) {
+					p_store_string_func(p_store_string_ud, res_text);
+					break;
+				}
+			}
+
+			//store as generic object
+
+			p_store_string_func(p_store_string_ud, "Object(" + obj->get_class() + ",");
+
+			List<PropertyInfo> props;
+			obj->get_property_list(&props);
+			bool first = true;
+			for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+				if (E->get().usage & PROPERTY_USAGE_STORAGE || E->get().usage & PROPERTY_USAGE_SCRIPT_VARIABLE) {
+					//must be serialized
+
+					if (first) {
+						first = false;
+					} else {
+						p_store_string_func(p_store_string_ud, ",");
+					}
+
+					p_store_string_func(p_store_string_ud, "\"" + E->get().name + "\":");
+					write(obj->get(E->get().name), p_store_string_func, p_store_string_ud, p_encode_res_func, p_encode_res_ud);
+				}
+			}
+
+			p_store_string_func(p_store_string_ud, ")\n");
+
+		} break;
+
+		case Variant::DICTIONARY: {
+			Dictionary dict = p_variant;
+
+			List<Variant> keys;
+			dict.get_key_list(&keys);
+			keys.sort();
+
+			p_store_string_func(p_store_string_ud, "{\n");
+			for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
+				/*
+				if (!_check_type(dict[E->get()]))
+					continue;
+				*/
+				write(E->get(), p_store_string_func, p_store_string_ud, p_encode_res_func, p_encode_res_ud);
+				p_store_string_func(p_store_string_ud, ": ");
+				write(dict[E->get()], p_store_string_func, p_store_string_ud, p_encode_res_func, p_encode_res_ud);
+				if (E->next()) {
+					p_store_string_func(p_store_string_ud, ",\n");
+				} else {
+					p_store_string_func(p_store_string_ud, "\n");
+				}
+			}
+
+			p_store_string_func(p_store_string_ud, "}");
+
+		} break;
+		case Variant::ARRAY: {
+			p_store_string_func(p_store_string_ud, "[ ");
+			Array array = p_variant;
+			int len = array.size();
+			for (int i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+				write(array[i], p_store_string_func, p_store_string_ud, p_encode_res_func, p_encode_res_ud);
+			}
+			p_store_string_func(p_store_string_ud, " ]");
+
+		} break;
+
+		case Variant::PACKED_BYTE_ARRAY: {
+			p_store_string_func(p_store_string_ud, "PackedByteArray( ");
+			String s;
+			Vector<uint8_t> data = p_variant;
+			int len = data.size();
+			const uint8_t *ptr = data.ptr();
+
+			for (int i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+
+				p_store_string_func(p_store_string_ud, itos(ptr[i]));
+			}
+
+			p_store_string_func(p_store_string_ud, " )");
+
+		} break;
+		case Variant::PACKED_INT32_ARRAY: {
+			p_store_string_func(p_store_string_ud, "PackedInt32Array( ");
+			Vector<int32_t> data = p_variant;
+			int32_t len = data.size();
+			const int32_t *ptr = data.ptr();
+
+			for (int32_t i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+
+				p_store_string_func(p_store_string_ud, itos(ptr[i]));
+			}
+
+			p_store_string_func(p_store_string_ud, " )");
+
+		} break;
+		case Variant::PACKED_INT64_ARRAY: {
+			p_store_string_func(p_store_string_ud, "PackedInt64Array( ");
+			Vector<int64_t> data = p_variant;
+			int64_t len = data.size();
+			const int64_t *ptr = data.ptr();
+
+			for (int64_t i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+
+				p_store_string_func(p_store_string_ud, itos(ptr[i]));
+			}
+
+			p_store_string_func(p_store_string_ud, " )");
+
+		} break;
+		case Variant::PACKED_FLOAT32_ARRAY: {
+			p_store_string_func(p_store_string_ud, "PackedFloat32Array( ");
+			Vector<float> data = p_variant;
+			int len = data.size();
+			const float *ptr = data.ptr();
+
+			for (int i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+				p_store_string_func(p_store_string_ud, rtosfix(ptr[i]));
+			}
+
+			p_store_string_func(p_store_string_ud, " )");
+
+		} break;
+		case Variant::PACKED_FLOAT64_ARRAY: {
+			p_store_string_func(p_store_string_ud, "PackedFloat64Array( ");
+			Vector<double> data = p_variant;
+			int len = data.size();
+			const double *ptr = data.ptr();
+
+			for (int i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+				p_store_string_func(p_store_string_ud, rtosfix(ptr[i]));
+			}
+
+			p_store_string_func(p_store_string_ud, " )");
+
+		} break;
+		case Variant::PACKED_STRING_ARRAY: {
+			p_store_string_func(p_store_string_ud, "PackedStringArray( ");
+			Vector<String> data = p_variant;
+			int len = data.size();
+			const String *ptr = data.ptr();
+
+			String s;
+			//write_string("\n");
+
+			for (int i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+				String str = ptr[i];
+				p_store_string_func(p_store_string_ud, "\"" + str.c_escape() + "\"");
+			}
+
+			p_store_string_func(p_store_string_ud, " )");
+
+		} break;
+		case Variant::PACKED_VECTOR2_ARRAY: {
+			p_store_string_func(p_store_string_ud, "PackedVector2Array( ");
+			Vector<Vector2> data = p_variant;
+			int len = data.size();
+			const Vector2 *ptr = data.ptr();
+
+			for (int i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+				p_store_string_func(p_store_string_ud, rtosfix(ptr[i].x) + ", " + rtosfix(ptr[i].y));
+			}
+
+			p_store_string_func(p_store_string_ud, " )");
+
+		} break;
+		case Variant::PACKED_VECTOR3_ARRAY: {
+			p_store_string_func(p_store_string_ud, "PackedVector3Array( ");
+			Vector<Vector3> data = p_variant;
+			int len = data.size();
+			const Vector3 *ptr = data.ptr();
+
+			for (int i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+				p_store_string_func(p_store_string_ud, rtosfix(ptr[i].x) + ", " + rtosfix(ptr[i].y) + ", " + rtosfix(ptr[i].z));
+			}
+
+			p_store_string_func(p_store_string_ud, " )");
+
+		} break;
+		case Variant::PACKED_COLOR_ARRAY: {
+			p_store_string_func(p_store_string_ud, "PackedColorArray( ");
+
+			Vector<Color> data = p_variant;
+			int len = data.size();
+			const Color *ptr = data.ptr();
+
+			for (int i = 0; i < len; i++) {
+				if (i > 0) {
+					p_store_string_func(p_store_string_ud, ", ");
+				}
+
+				p_store_string_func(p_store_string_ud, rtosfix(ptr[i].r) + ", " + rtosfix(ptr[i].g) + ", " + rtosfix(ptr[i].b) + ", " + rtosfix(ptr[i].a));
+			}
+			p_store_string_func(p_store_string_ud, " )");
+
+		} break;
+		default: {
+		}
+	}
+
+	return OK;
+}
+
+static Error _write_to_str(void *ud, const String &p_string) {
+	String *str = (String *)ud;
+	(*str) += p_string;
+	return OK;
+}
+
+Error VariantWriter::write_to_string(const Variant &p_variant, String &r_string, EncodeResourceFunc p_encode_res_func, void *p_encode_res_ud) {
+	r_string = String();
+
+	return write(p_variant, _write_to_str, &r_string, p_encode_res_func, p_encode_res_ud);
+}