2016-06-18 14:46:12 +02:00
|
|
|
/*************************************************************************/
|
|
|
|
/* variant_parser.cpp */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
|
|
|
/* http://www.godotengine.org */
|
|
|
|
/*************************************************************************/
|
2017-01-01 22:01:57 +01:00
|
|
|
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
2016-06-18 14:46:12 +02:00
|
|
|
/* */
|
|
|
|
/* 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. */
|
|
|
|
/*************************************************************************/
|
2015-11-24 14:42:05 +01:00
|
|
|
#include "variant_parser.h"
|
|
|
|
#include "io/resource_loader.h"
|
|
|
|
#include "os/keyboard.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CharType 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();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-12-31 04:54:00 +01:00
|
|
|
CharType VariantParser::StreamString::get_char() {
|
|
|
|
|
|
|
|
if (pos>=s.length())
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return s[pos++];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VariantParser::StreamString::is_utf8() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
bool VariantParser::StreamString::is_eof() const {
|
|
|
|
return pos>s.length();
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char * VariantParser::tk_name[TK_MAX] = {
|
|
|
|
"'{'",
|
|
|
|
"'}'",
|
|
|
|
"'['",
|
|
|
|
"']'",
|
|
|
|
"'('",
|
|
|
|
"')'",
|
|
|
|
"identifier",
|
|
|
|
"string",
|
|
|
|
"number",
|
2015-12-31 18:30:50 +01:00
|
|
|
"color",
|
2015-11-24 14:42:05 +01:00
|
|
|
"':'",
|
|
|
|
"','",
|
2016-01-07 13:04:44 +01:00
|
|
|
"'.'",
|
2015-11-24 14:42:05 +01:00
|
|
|
"'='",
|
|
|
|
"EOF",
|
|
|
|
"ERROR"
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Error VariantParser::get_token(Stream *p_stream, Token& r_token, int &line, String &r_err_str) {
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
|
|
|
|
CharType cchar;
|
|
|
|
if (p_stream->saved) {
|
|
|
|
cchar=p_stream->saved;
|
|
|
|
p_stream->saved=0;
|
|
|
|
} else {
|
|
|
|
cchar=p_stream->get_char();
|
2015-11-29 00:56:14 +01:00
|
|
|
if (p_stream->is_eof()) {
|
|
|
|
r_token.type=TK_EOF;
|
|
|
|
return OK;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
};
|
2015-12-31 14:25:21 +01:00
|
|
|
case ';': {
|
|
|
|
|
|
|
|
while(true) {
|
|
|
|
CharType ch=p_stream->get_char();
|
|
|
|
if (p_stream->is_eof()) {
|
|
|
|
r_token.type=TK_EOF;
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
if (ch=='\n')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
};
|
2015-11-24 14:42:05 +01:00
|
|
|
case ',': {
|
|
|
|
|
|
|
|
r_token.type=TK_COMMA;
|
|
|
|
return OK;
|
|
|
|
};
|
2016-01-07 13:04:44 +01:00
|
|
|
case '.': {
|
|
|
|
|
|
|
|
r_token.type=TK_PERIOD;
|
|
|
|
return OK;
|
|
|
|
};
|
2015-11-24 14:42:05 +01:00
|
|
|
case '=': {
|
|
|
|
|
|
|
|
r_token.type=TK_EQUAL;
|
|
|
|
return OK;
|
|
|
|
};
|
2015-12-31 18:30:50 +01:00
|
|
|
case '#': {
|
|
|
|
|
|
|
|
|
|
|
|
String color_str="#";
|
|
|
|
while(true) {
|
|
|
|
CharType 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+=String::chr(ch);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
p_stream->saved=ch;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
r_token.value=Color::html(color_str);
|
|
|
|
r_token.type=TK_COLOR;
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
};
|
2015-11-24 14:42:05 +01:00
|
|
|
case '"': {
|
|
|
|
|
|
|
|
|
|
|
|
String str;
|
|
|
|
while(true) {
|
|
|
|
|
|
|
|
CharType 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...
|
|
|
|
CharType next = p_stream->get_char();
|
|
|
|
if (next==0) {
|
|
|
|
r_err_str="Unterminated String";
|
|
|
|
r_token.type=TK_ERROR;
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
CharType 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': {
|
|
|
|
//hexnumbarh - oct is deprecated
|
|
|
|
|
|
|
|
|
|
|
|
for(int j=0;j<4;j++) {
|
|
|
|
CharType 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;
|
|
|
|
}
|
|
|
|
CharType 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");
|
|
|
|
v=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
res<<=4;
|
|
|
|
res|=v;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} break;
|
|
|
|
//case '\"': res='\"'; break;
|
|
|
|
//case '\\': res='\\'; break;
|
|
|
|
//case '/': res='/'; break;
|
|
|
|
default: {
|
|
|
|
res = next;
|
|
|
|
//r_err_str="Invalid escape sequence";
|
|
|
|
//return ERR_PARSE_ERROR;
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
|
|
|
|
str+=res;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
if (ch=='\n')
|
|
|
|
line++;
|
|
|
|
str+=ch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
if (p_stream->is_utf8()) {
|
|
|
|
str.parse_utf8( str.ascii(true).get_data() );
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
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
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
String 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();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CharType 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;
|
|
|
|
} else {
|
|
|
|
reading=READING_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case READING_DEC: {
|
|
|
|
|
|
|
|
if (c>='0' && c<='9') {
|
|
|
|
|
|
|
|
} else if (c=='e') {
|
|
|
|
reading=READING_EXP;
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
} else {
|
|
|
|
reading=READING_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case READING_EXP: {
|
|
|
|
|
|
|
|
if (c>='0' && c<='9') {
|
|
|
|
exp_beg=true;
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
} else if ((c=='-' || c=='+') && !exp_sign && !exp_beg) {
|
2016-02-01 23:17:05 +01:00
|
|
|
if (c=='-')
|
|
|
|
is_float=true;
|
2015-11-24 14:42:05 +01:00
|
|
|
exp_sign=true;
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
} else {
|
|
|
|
reading=READING_DONE;
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (reading==READING_DONE)
|
|
|
|
break;
|
|
|
|
num+=String::chr(c);
|
|
|
|
c = p_stream->get_char();
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
p_stream->saved=c;
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
r_token.type=TK_NUMBER;
|
2016-02-01 23:17:05 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
if (is_float)
|
|
|
|
r_token.value=num.to_double();
|
|
|
|
else
|
|
|
|
r_token.value=num.to_int();
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
} else if ((cchar>='A' && cchar<='Z') || (cchar>='a' && cchar<='z') || cchar=='_') {
|
|
|
|
|
|
|
|
String id;
|
2015-11-29 00:56:14 +01:00
|
|
|
bool first=true;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
while((cchar>='A' && cchar<='Z') || (cchar>='a' && cchar<='z') || cchar=='_' || (!first && cchar>='0' && cchar<='9')) {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
id+=String::chr(cchar);
|
|
|
|
cchar=p_stream->get_char();
|
2015-11-29 00:56:14 +01:00
|
|
|
first=false;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
p_stream->saved=cchar;
|
|
|
|
|
|
|
|
r_token.type=TK_IDENTIFIER;
|
|
|
|
r_token.value=id;
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-12-31 04:31:00 +01:00
|
|
|
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 engine.cfg construct";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
String accum;
|
|
|
|
|
|
|
|
while(true) {
|
|
|
|
|
|
|
|
CharType c=p_stream->get_char();
|
|
|
|
|
|
|
|
if (p_stream->is_eof()) {
|
|
|
|
r_err_str="Unexpected EOF while parsing old-style engine.cfg 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++;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
template<class T>
|
|
|
|
Error VariantParser::_parse_construct(Stream *p_stream,Vector<T>& r_construct,int &line,String &r_err_str) {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
|
|
|
|
Token token;
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_PARENTHESIS_OPEN) {
|
2015-11-29 00:56:14 +01:00
|
|
|
r_err_str="Expected '(' in constructor";
|
2015-11-24 14:42:05 +01:00
|
|
|
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) {
|
2016-03-09 00:00:52 +01:00
|
|
|
//do none
|
2015-11-29 00:56:14 +01:00
|
|
|
} else if (token.type==TK_PARENTHESIS_CLOSE) {
|
2015-11-24 14:42:05 +01:00
|
|
|
break;
|
|
|
|
} else {
|
2015-11-29 00:56:14 +01:00
|
|
|
r_err_str="Expected ',' or ')' in constructor";
|
2015-11-24 14:42:05 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2016-01-11 03:22:48 +01:00
|
|
|
|
|
|
|
if (first && token.type==TK_PARENTHESIS_CLOSE) {
|
|
|
|
break;
|
|
|
|
} else if (token.type!=TK_NUMBER) {
|
2015-11-29 00:56:14 +01:00
|
|
|
r_err_str="Expected float in constructor";
|
2015-11-24 14:42:05 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
r_construct.push_back(token.value);
|
2015-11-29 00:56:14 +01:00
|
|
|
first=false;
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
Error VariantParser::parse_value(Token& token,Variant &value,Stream *p_stream,int &line,String &r_err_str,ResourceParser *p_res_parser) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* {
|
|
|
|
Error err = get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}*/
|
|
|
|
|
|
|
|
|
|
|
|
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) {
|
|
|
|
/*
|
|
|
|
VECTOR2, // 5
|
|
|
|
RECT2,
|
|
|
|
VECTOR3,
|
|
|
|
MATRIX32,
|
|
|
|
PLANE,
|
|
|
|
QUAT, // 10
|
|
|
|
_AABB, //sorry naming convention fail :( not like it's used often
|
|
|
|
MATRIX3,
|
|
|
|
TRANSFORM,
|
|
|
|
|
|
|
|
// misc types
|
|
|
|
COLOR,
|
|
|
|
IMAGE, // 15
|
|
|
|
NODE_PATH,
|
|
|
|
_RID,
|
|
|
|
OBJECT,
|
|
|
|
INPUT_EVENT,
|
|
|
|
DICTIONARY, // 20
|
|
|
|
ARRAY,
|
|
|
|
|
|
|
|
// arrays
|
|
|
|
RAW_ARRAY,
|
|
|
|
INT_ARRAY,
|
|
|
|
REAL_ARRAY,
|
|
|
|
STRING_ARRAY, // 25
|
|
|
|
VECTOR2_ARRAY,
|
|
|
|
VECTOR3_ARRAY,
|
|
|
|
COLOR_ARRAY,
|
|
|
|
|
|
|
|
VARIANT_MAX
|
|
|
|
|
|
|
|
*/
|
|
|
|
String id = token.value;
|
|
|
|
if (id=="true")
|
|
|
|
value=true;
|
|
|
|
else if (id=="false")
|
|
|
|
value=false;
|
2016-02-01 23:00:19 +01:00
|
|
|
else if (id=="null" || id=="nil")
|
2015-11-24 14:42:05 +01:00
|
|
|
value=Variant();
|
|
|
|
else if (id=="Vector2"){
|
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (args.size()!=2) {
|
|
|
|
r_err_str="Expected 2 arguments for constructor";
|
|
|
|
}
|
|
|
|
|
|
|
|
value=Vector2(args[0],args[1]);
|
|
|
|
return OK;
|
2015-12-12 21:10:43 +01:00
|
|
|
} 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) {
|
2015-12-12 23:21:43 +01:00
|
|
|
r_err_str="Expected 4 arguments for constructor";
|
2015-12-12 21:10:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
value=Rect2(args[0],args[1],args[2],args[3]);
|
|
|
|
return OK;
|
2015-11-24 14:42:05 +01:00
|
|
|
} else if (id=="Vector3"){
|
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (args.size()!=3) {
|
|
|
|
r_err_str="Expected 3 arguments for constructor";
|
|
|
|
}
|
|
|
|
|
|
|
|
value=Vector3(args[0],args[1],args[2]);
|
|
|
|
return OK;
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="Transform2D" || id=="Matrix32"){ //compatibility
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (args.size()!=6) {
|
|
|
|
r_err_str="Expected 6 arguments for constructor";
|
|
|
|
}
|
2017-01-11 04:52:51 +01:00
|
|
|
Transform2D m;
|
2015-11-24 14:42:05 +01:00
|
|
|
m[0]=Vector2(args[0],args[1]);
|
|
|
|
m[1]=Vector2(args[2],args[3]);
|
|
|
|
m[2]=Vector2(args[4],args[5]);
|
|
|
|
value=m;
|
|
|
|
return OK;
|
|
|
|
} else if (id=="Plane") {
|
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (args.size()!=4) {
|
|
|
|
r_err_str="Expected 4 arguments for constructor";
|
|
|
|
}
|
|
|
|
|
|
|
|
value=Plane(args[0],args[1],args[2],args[3]);
|
|
|
|
return OK;
|
|
|
|
} else if (id=="Quat") {
|
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (args.size()!=4) {
|
|
|
|
r_err_str="Expected 4 arguments for constructor";
|
|
|
|
}
|
|
|
|
|
|
|
|
value=Quat(args[0],args[1],args[2],args[3]);
|
|
|
|
return OK;
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="Rect3" || id=="AABB"){
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (args.size()!=6) {
|
|
|
|
r_err_str="Expected 6 arguments for constructor";
|
|
|
|
}
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
value=Rect3(Vector3(args[0],args[1],args[2]),Vector3(args[3],args[4],args[5]));
|
2015-11-24 14:42:05 +01:00
|
|
|
return OK;
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="Basis" || id=="Matrix3"){ //compatibility
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (args.size()!=9) {
|
|
|
|
r_err_str="Expected 9 arguments for constructor";
|
|
|
|
}
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
value=Basis(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
|
2015-11-24 14:42:05 +01:00
|
|
|
return OK;
|
|
|
|
} else if (id=="Transform"){
|
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (args.size()!=12) {
|
|
|
|
r_err_str="Expected 12 arguments for constructor";
|
|
|
|
}
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
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]));
|
2015-11-24 14:42:05 +01:00
|
|
|
return OK;
|
|
|
|
|
|
|
|
} else if (id=="Color") {
|
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (args.size()!=4) {
|
|
|
|
r_err_str="Expected 4 arguments for constructor";
|
|
|
|
}
|
|
|
|
|
|
|
|
value=Color(args[0],args[1],args[2],args[3]);
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
} else if (id=="Image") {
|
|
|
|
|
|
|
|
//:|
|
|
|
|
|
|
|
|
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_PARENTHESIS_CLOSE) {
|
|
|
|
value=Image(); // just an Image()
|
|
|
|
return OK;
|
|
|
|
} else if (token.type!=TK_NUMBER) {
|
|
|
|
r_err_str="Expected number (width)";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
|
|
|
|
int width=token.value;
|
|
|
|
if (token.type!=TK_COMMA) {
|
|
|
|
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 (height)";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
int height=token.value;
|
2015-11-29 00:56:14 +01:00
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (token.type!=TK_COMMA) {
|
|
|
|
r_err_str="Expected ','";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2016-10-03 21:33:42 +02:00
|
|
|
|
|
|
|
bool has_mipmaps=false;
|
|
|
|
|
|
|
|
if (token.type==TK_NUMBER) {
|
|
|
|
has_mipmaps=bool(token.value);
|
|
|
|
} else if (token.type==TK_IDENTIFIER && String(token.value)=="true") {
|
|
|
|
has_mipmaps=true;
|
|
|
|
} else if (token.type==TK_IDENTIFIER && String(token.value)=="false") {
|
|
|
|
has_mipmaps=false;
|
|
|
|
} else {
|
|
|
|
r_err_str="Expected number/true/false (mipmaps)";
|
2015-11-24 14:42:05 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
int mipmaps=token.value;
|
2015-11-29 00:56:14 +01:00
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (token.type!=TK_COMMA) {
|
|
|
|
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 (format)";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
String sformat=token.value;
|
|
|
|
|
2016-10-03 21:33:42 +02:00
|
|
|
Image::Format format=Image::FORMAT_MAX;
|
|
|
|
|
|
|
|
for(int i=0;i<Image::FORMAT_MAX;i++) {
|
|
|
|
if (Image::get_format_name(format)==sformat) {
|
|
|
|
format=Image::Format(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (format==Image::FORMAT_MAX) {
|
|
|
|
r_err_str="Unknown image format: "+String(sformat);
|
2015-11-24 14:42:05 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
2016-10-03 21:33:42 +02:00
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
int len = Image::get_image_data_size(width,height,format,mipmaps);
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> buffer;
|
2015-11-24 14:42:05 +01:00
|
|
|
buffer.resize(len);
|
|
|
|
|
|
|
|
if (buffer.size()!=len) {
|
|
|
|
r_err_str="Couldn't allocate image buffer of size: "+itos(len);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w=buffer.write();
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
for(int i=0;i<len;i++) {
|
2015-11-29 00:56:14 +01:00
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (token.type!=TK_COMMA) {
|
|
|
|
r_err_str="Expected ','";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (token.type!=TK_NUMBER) {
|
|
|
|
r_err_str="Expected number";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
w[i]=int(token.value);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Image img(width,height,mipmaps,format,buffer);
|
|
|
|
|
|
|
|
value=img;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
|
|
|
|
} 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) {
|
2015-11-29 00:56:14 +01:00
|
|
|
r_err_str="Expected string as argument for NodePath()";
|
2015-11-24 14:42:05 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
} else if (id=="Resource" || id=="SubResource" || id=="ExtResource") {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_PARENTHESIS_OPEN) {
|
|
|
|
r_err_str="Expected '('";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
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;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
value=res;
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
return OK;
|
2015-11-29 00:56:14 +01:00
|
|
|
} 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;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
return OK;
|
|
|
|
} else if (p_res_parser && id=="SubResource" && p_res_parser->sub_func){
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
RES res;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = p_res_parser->sub_func(p_res_parser->userdata,p_stream,res,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
value=res;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
} else {
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
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;
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
r_err_str="Expected string as argument for Resource().";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
} else if (id=="InputEvent") {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
String id = token.value;
|
|
|
|
|
|
|
|
InputEvent ie;
|
|
|
|
|
2016-10-03 02:40:53 +02:00
|
|
|
if (id=="NONE") {
|
|
|
|
|
|
|
|
ie.type=InputEvent::NONE;
|
|
|
|
|
|
|
|
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=="KEY") {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_COMMA) {
|
|
|
|
r_err_str="Expected ','";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
ie.type=InputEvent::KEY;
|
|
|
|
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type==TK_IDENTIFIER) {
|
|
|
|
String name=token.value;
|
|
|
|
ie.key.scancode=find_keycode(name);
|
|
|
|
} else if (token.type==TK_NUMBER) {
|
|
|
|
|
|
|
|
ie.key.scancode=token.value;
|
|
|
|
} else {
|
|
|
|
|
|
|
|
r_err_str="Expected string or integer for keycode";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
|
|
|
|
if (token.type==TK_COMMA) {
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
|
|
|
|
if (token.type!=TK_IDENTIFIER) {
|
|
|
|
r_err_str="Expected identifier with modifier flas";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
String mods=token.value;
|
|
|
|
|
|
|
|
if (mods.findn("C")!=-1)
|
|
|
|
ie.key.mod.control=true;
|
|
|
|
if (mods.findn("A")!=-1)
|
|
|
|
ie.key.mod.alt=true;
|
|
|
|
if (mods.findn("S")!=-1)
|
|
|
|
ie.key.mod.shift=true;
|
|
|
|
if (mods.findn("M")!=-1)
|
|
|
|
ie.key.mod.meta=true;
|
|
|
|
|
|
|
|
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 (token.type!=TK_PARENTHESIS_CLOSE) {
|
|
|
|
|
|
|
|
r_err_str="Expected ')' or modifier flags.";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
} else if (id=="MBUTTON") {
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_COMMA) {
|
|
|
|
r_err_str="Expected ','";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
ie.type=InputEvent::MOUSE_BUTTON;
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_NUMBER) {
|
|
|
|
r_err_str="Expected button index";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
ie.mouse_button.button_index = 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=="JBUTTON") {
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_COMMA) {
|
|
|
|
r_err_str="Expected ','";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2017-01-08 21:05:51 +01:00
|
|
|
ie.type=InputEvent::JOYPAD_BUTTON;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_NUMBER) {
|
|
|
|
r_err_str="Expected button index";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
ie.joy_button.button_index = 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=="JAXIS") {
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_COMMA) {
|
|
|
|
r_err_str="Expected ','";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2017-01-08 21:05:51 +01:00
|
|
|
ie.type=InputEvent::JOYPAD_MOTION;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_NUMBER) {
|
|
|
|
r_err_str="Expected axis index";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
ie.joy_motion.axis = token.value;
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2016-01-02 13:37:16 +01:00
|
|
|
|
|
|
|
if (token.type!=TK_COMMA) {
|
|
|
|
r_err_str="Expected ',' after axis index";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_NUMBER) {
|
|
|
|
r_err_str="Expected axis sign";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
ie.joy_motion.axis_value = token.value;
|
|
|
|
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
if (token.type!=TK_PARENTHESIS_CLOSE) {
|
2016-01-02 13:37:16 +01:00
|
|
|
r_err_str="Expected ')' for jaxis";
|
2015-11-24 14:42:05 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
r_err_str="Invalid input event type.";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
value=ie;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="PoolByteArray"|| id=="ByteArray") {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
Vector<uint8_t> args;
|
|
|
|
Error err = _parse_construct<uint8_t>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> arr;
|
2015-11-24 14:42:05 +01:00
|
|
|
{
|
|
|
|
int len=args.size();
|
|
|
|
arr.resize(len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Write w = arr.write();
|
2015-11-24 14:42:05 +01:00
|
|
|
for(int i=0;i<len;i++) {
|
|
|
|
w[i]=args[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
value=arr;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="PoolIntArray"|| id=="IntArray") {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2016-10-06 22:36:05 +02:00
|
|
|
Vector<int> args;
|
|
|
|
Error err = _parse_construct<int>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<int> arr;
|
2015-11-24 14:42:05 +01:00
|
|
|
{
|
|
|
|
int len=args.size();
|
|
|
|
arr.resize(len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<int>::Write w = arr.write();
|
2015-11-24 14:42:05 +01:00
|
|
|
for(int i=0;i<len;i++) {
|
2015-11-29 00:56:14 +01:00
|
|
|
w[i]=int(args[i]);
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
value=arr;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="PoolFloatArray"|| id=="FloatArray") {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<float> arr;
|
2015-11-24 14:42:05 +01:00
|
|
|
{
|
|
|
|
int len=args.size();
|
|
|
|
arr.resize(len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<float>::Write w = arr.write();
|
2015-11-24 14:42:05 +01:00
|
|
|
for(int i=0;i<len;i++) {
|
|
|
|
w[i]=args[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
value=arr;
|
|
|
|
|
|
|
|
return OK;
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="PoolStringArray"|| id=="StringArray") {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
|
|
|
|
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
|
2016-01-09 01:09:13 +01:00
|
|
|
} else if (token.type==TK_PARENTHESIS_CLOSE) {
|
2015-11-24 14:42:05 +01:00
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
r_err_str="Expected ',' or ')'";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2016-01-09 01:09:13 +01:00
|
|
|
|
2016-07-27 16:59:42 +02:00
|
|
|
if (token.type==TK_PARENTHESIS_CLOSE) {
|
|
|
|
break;
|
|
|
|
} else if (token.type!=TK_STRING) {
|
2016-03-09 00:00:52 +01:00
|
|
|
r_err_str="Expected string";
|
2015-11-24 14:42:05 +01:00
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2016-01-09 01:09:13 +01:00
|
|
|
first=false;
|
2015-11-24 14:42:05 +01:00
|
|
|
cs.push_back(token.value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<String> arr;
|
2015-11-24 14:42:05 +01:00
|
|
|
{
|
|
|
|
int len=cs.size();
|
|
|
|
arr.resize(len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<String>::Write w = arr.write();
|
2015-11-24 14:42:05 +01:00
|
|
|
for(int i=0;i<len;i++) {
|
|
|
|
w[i]=cs[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
value=arr;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="PoolVector2Array"|| id=="Vector2Array") {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Vector2> arr;
|
2015-11-24 14:42:05 +01:00
|
|
|
{
|
|
|
|
int len=args.size()/2;
|
|
|
|
arr.resize(len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Vector2>::Write w = arr.write();
|
2015-11-24 14:42:05 +01:00
|
|
|
for(int i=0;i<len;i++) {
|
|
|
|
w[i]=Vector2(args[i*2+0],args[i*2+1]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
value=arr;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="PoolVector3Array"|| id=="Vector3Array") {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Vector3> arr;
|
2015-11-24 14:42:05 +01:00
|
|
|
{
|
|
|
|
int len=args.size()/3;
|
|
|
|
arr.resize(len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Vector3>::Write w = arr.write();
|
2015-11-24 14:42:05 +01:00
|
|
|
for(int i=0;i<len;i++) {
|
|
|
|
w[i]=Vector3(args[i*3+0],args[i*3+1],args[i*3+2]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
value=arr;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
} else if (id=="PoolColorArray"|| id=="ColorArray") {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
Vector<float> args;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = _parse_construct<float>(p_stream,args,line,r_err_str);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Color> arr;
|
2015-11-24 14:42:05 +01:00
|
|
|
{
|
|
|
|
int len=args.size()/4;
|
|
|
|
arr.resize(len);
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Color>::Write w = arr.write();
|
2015-11-24 14:42:05 +01:00
|
|
|
for(int i=0;i<len;i++) {
|
2016-02-01 00:55:48 +01:00
|
|
|
w[i]=Color(args[i*4+0],args[i*4+1],args[i*4+2],args[i*4+3]);
|
2015-11-24 14:42:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
value=arr;
|
|
|
|
|
2015-12-31 04:31:00 +01:00
|
|
|
return OK;
|
|
|
|
} else if (id=="key") { // compatibility with engine.cfg
|
|
|
|
|
|
|
|
Vector<String> params;
|
|
|
|
Error err = _parse_enginecfg(p_stream,params,line,r_err_str);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
ERR_FAIL_COND_V(params.size()!=1 && params.size()!=2,ERR_PARSE_ERROR);
|
|
|
|
|
|
|
|
int scode=0;
|
|
|
|
|
|
|
|
if (params[0].is_numeric()) {
|
|
|
|
scode=params[0].to_int();
|
|
|
|
if (scode < 10) {
|
|
|
|
scode=KEY_0+scode;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
scode=find_keycode(params[0]);
|
|
|
|
|
|
|
|
InputEvent ie;
|
|
|
|
ie.type=InputEvent::KEY;
|
|
|
|
ie.key.scancode=scode;
|
|
|
|
|
|
|
|
if (params.size()==2) {
|
|
|
|
String mods=params[1];
|
|
|
|
if (mods.findn("C")!=-1)
|
|
|
|
ie.key.mod.control=true;
|
|
|
|
if (mods.findn("A")!=-1)
|
|
|
|
ie.key.mod.alt=true;
|
|
|
|
if (mods.findn("S")!=-1)
|
|
|
|
ie.key.mod.shift=true;
|
|
|
|
if (mods.findn("M")!=-1)
|
|
|
|
ie.key.mod.meta=true;
|
|
|
|
}
|
|
|
|
value=ie;
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
} else if (id=="mbutton") { // compatibility with engine.cfg
|
|
|
|
|
|
|
|
Vector<String> params;
|
|
|
|
Error err = _parse_enginecfg(p_stream,params,line,r_err_str);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
ERR_FAIL_COND_V(params.size()!=2,ERR_PARSE_ERROR);
|
|
|
|
|
|
|
|
InputEvent ie;
|
|
|
|
ie.type=InputEvent::MOUSE_BUTTON;
|
|
|
|
ie.device=params[0].to_int();
|
|
|
|
ie.mouse_button.button_index=params[1].to_int();
|
|
|
|
|
|
|
|
value=ie;
|
|
|
|
return OK;
|
|
|
|
} else if (id=="jbutton") { // compatibility with engine.cfg
|
|
|
|
|
|
|
|
Vector<String> params;
|
|
|
|
Error err = _parse_enginecfg(p_stream,params,line,r_err_str);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
ERR_FAIL_COND_V(params.size()!=2,ERR_PARSE_ERROR);
|
|
|
|
InputEvent ie;
|
2017-01-08 21:05:51 +01:00
|
|
|
ie.type=InputEvent::JOYPAD_BUTTON;
|
2015-12-31 04:31:00 +01:00
|
|
|
ie.device=params[0].to_int();
|
|
|
|
ie.joy_button.button_index=params[1].to_int();
|
|
|
|
|
|
|
|
value=ie;
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
} else if (id=="jaxis") { // compatibility with engine.cfg
|
|
|
|
|
|
|
|
Vector<String> params;
|
|
|
|
Error err = _parse_enginecfg(p_stream,params,line,r_err_str);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
ERR_FAIL_COND_V(params.size()!=2,ERR_PARSE_ERROR);
|
|
|
|
|
|
|
|
InputEvent ie;
|
2017-01-08 21:05:51 +01:00
|
|
|
ie.type=InputEvent::JOYPAD_MOTION;
|
2015-12-31 04:31:00 +01:00
|
|
|
ie.device=params[0].to_int();
|
2016-01-02 13:37:16 +01:00
|
|
|
int axis=params[1].to_int();
|
|
|
|
ie.joy_motion.axis=axis>>1;
|
|
|
|
ie.joy_motion.axis_value=axis&1?1:-1;
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
value= ie;
|
|
|
|
|
2016-01-07 13:04:44 +01:00
|
|
|
return OK;
|
|
|
|
} else if (id=="img") { // compatibility with engine.cfg
|
|
|
|
|
|
|
|
Token token;
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type!=TK_PARENTHESIS_OPEN) {
|
|
|
|
r_err_str="Expected '(' in old-style engine.cfg construct";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
while(true) {
|
|
|
|
CharType c = p_stream->get_char();
|
|
|
|
if (p_stream->is_eof()) {
|
|
|
|
r_err_str="Unexpected EOF in old style engine.cfg img()";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
if (c==')')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
value=Image();
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
return OK;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
r_err_str="Unexpected identifier: '"+id+"'.";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
VECTOR2, // 5
|
|
|
|
RECT2,
|
|
|
|
VECTOR3,
|
|
|
|
MATRIX32,
|
|
|
|
PLANE,
|
|
|
|
QUAT, // 10
|
|
|
|
_AABB, //sorry naming convention fail :( not like it's used often
|
|
|
|
MATRIX3,
|
|
|
|
TRANSFORM,
|
|
|
|
|
|
|
|
// misc types
|
|
|
|
COLOR,
|
|
|
|
IMAGE, // 15
|
|
|
|
NODE_PATH,
|
|
|
|
_RID,
|
|
|
|
OBJECT,
|
|
|
|
INPUT_EVENT,
|
|
|
|
DICTIONARY, // 20
|
|
|
|
ARRAY,
|
|
|
|
|
|
|
|
// arrays
|
|
|
|
RAW_ARRAY,
|
|
|
|
INT_ARRAY,
|
|
|
|
REAL_ARRAY,
|
|
|
|
STRING_ARRAY, // 25
|
|
|
|
VECTOR2_ARRAY,
|
|
|
|
VECTOR3_ARRAY,
|
|
|
|
COLOR_ARRAY,
|
|
|
|
|
|
|
|
VARIANT_MAX
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
} else if (token.type==TK_NUMBER) {
|
|
|
|
|
|
|
|
value=token.value;
|
|
|
|
return OK;
|
|
|
|
} else if (token.type==TK_STRING) {
|
|
|
|
|
2015-12-31 18:30:50 +01:00
|
|
|
value=token.value;
|
|
|
|
return OK;
|
|
|
|
} else if (token.type==TK_COLOR) {
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
value=token.value;
|
|
|
|
return OK;
|
|
|
|
} else {
|
|
|
|
r_err_str="Expected value, got "+String(tk_name[token.type])+".";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
while(true) {
|
|
|
|
|
|
|
|
if (p_stream->is_eof()) {
|
|
|
|
r_err_str="Unexpected End of File while parsing array";
|
|
|
|
return ERR_FILE_CORRUPT;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
while(true) {
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
if (p_stream->is_eof()) {
|
|
|
|
r_err_str="Unexpected End of File while parsing dictionary";
|
|
|
|
return ERR_FILE_CORRUPT;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-08 23:00:45 +01:00
|
|
|
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) {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
r_tag.fields.clear();
|
|
|
|
|
|
|
|
if (token.type!=TK_BRACKET_OPEN) {
|
|
|
|
r_err_str="Expected '['";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-08 23:00:45 +01:00
|
|
|
if (p_simple_tag) {
|
|
|
|
|
|
|
|
r_tag.name="";
|
|
|
|
r_tag.fields.clear();
|
|
|
|
|
|
|
|
while(true) {
|
|
|
|
|
|
|
|
CharType 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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
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;
|
2016-01-07 13:04:44 +01:00
|
|
|
bool parsing_tag=true;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
while(true) {
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
if (p_stream->is_eof()) {
|
|
|
|
r_err_str="Unexpected End of File while parsing tag: "+r_tag.name;
|
|
|
|
return ERR_FILE_CORRUPT;
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
get_token(p_stream,token,line,r_err_str);
|
|
|
|
if (token.type==TK_BRACKET_CLOSE)
|
|
|
|
break;
|
|
|
|
|
2016-01-07 13:04:44 +01:00
|
|
|
if (parsing_tag && token.type==TK_PERIOD) {
|
|
|
|
r_tag.name+="."; //support tags such as [someprop.Anroid] for specific platforms
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2016-01-07 13:16:11 +01:00
|
|
|
} else if (parsing_tag && token.type==TK_COLON) {
|
|
|
|
r_tag.name+=":"; //support tags such as [someprop.Anroid] for specific platforms
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2016-01-07 13:04:44 +01:00
|
|
|
} else {
|
|
|
|
parsing_tag=false;
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
if (token.type!=TK_IDENTIFIER) {
|
|
|
|
r_err_str="Expected Identifier";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
String id=token.value;
|
|
|
|
|
2016-01-07 13:04:44 +01:00
|
|
|
if (parsing_tag) {
|
|
|
|
r_tag.name+=id;
|
|
|
|
continue;
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
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;
|
2015-11-29 00:56:14 +01:00
|
|
|
Error err = parse_value(token,value,p_stream,line,r_err_str,p_res_parser);
|
2015-11-24 14:42:05 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
r_tag.fields[id]=value;
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-01-08 23:00:45 +01:00
|
|
|
Error VariantParser::parse_tag(Stream *p_stream, int &line, String &r_err_str, Tag& r_tag, ResourceParser *p_res_parser, bool p_simple_tag) {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
Token token;
|
|
|
|
get_token(p_stream,token,line,r_err_str);
|
2015-11-29 00:56:14 +01:00
|
|
|
|
|
|
|
if (token.type==TK_EOF) {
|
|
|
|
return ERR_FILE_EOF;
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
if (token.type!=TK_BRACKET_OPEN) {
|
|
|
|
r_err_str="Expected '['";
|
|
|
|
return ERR_PARSE_ERROR;
|
|
|
|
}
|
|
|
|
|
2016-01-08 23:00:45 +01:00
|
|
|
return _parse_tag(token,p_stream,line,r_err_str,r_tag,p_res_parser,p_simple_tag);
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-01-08 23:00:45 +01:00
|
|
|
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) {
|
2015-11-24 14:42:05 +01:00
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
|
|
|
|
//assign..
|
2016-01-06 09:39:05 +01:00
|
|
|
r_assign="";
|
2015-11-29 00:56:14 +01:00
|
|
|
String what;
|
|
|
|
|
|
|
|
while(true) {
|
|
|
|
|
|
|
|
|
|
|
|
CharType 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;
|
|
|
|
|
2015-12-31 14:25:21 +01:00
|
|
|
if (c==';') { //comment
|
|
|
|
while(true) {
|
|
|
|
CharType ch=p_stream->get_char();
|
|
|
|
if (p_stream->is_eof()) {
|
|
|
|
return ERR_FILE_EOF;
|
|
|
|
}
|
|
|
|
if (ch=='\n')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-11-29 00:56:14 +01:00
|
|
|
if (c=='[' && what.length()==0) {
|
|
|
|
//it's a tag!
|
|
|
|
p_stream->saved='['; //go back one
|
|
|
|
|
2016-01-08 23:00:45 +01:00
|
|
|
Error err = parse_tag(p_stream,line,r_err_str,r_tag,p_res_parser,p_simple_tag);
|
2015-11-29 00:56:14 +01:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c>32) {
|
2016-06-20 23:41:59 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
what=tk.value;
|
|
|
|
|
|
|
|
} else if (c!='=') {
|
2015-11-29 00:56:14 +01:00
|
|
|
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);
|
|
|
|
if (err) {
|
|
|
|
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
} else if (c=='\n') {
|
|
|
|
line++;
|
|
|
|
}
|
|
|
|
}
|
2015-11-24 14:42:05 +01:00
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2015-11-29 00:56:14 +01:00
|
|
|
|
|
|
|
if (token.type==TK_EOF) {
|
|
|
|
return ERR_FILE_EOF;
|
|
|
|
}
|
|
|
|
|
2015-11-24 14:42:05 +01:00
|
|
|
return parse_value(token,r_ret,p_stream,r_err_line,r_err_str,p_res_parser);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2016-06-13 15:16:43 +02:00
|
|
|
static String rtosfix(double p_value) {
|
|
|
|
|
2016-06-13 15:58:32 +02:00
|
|
|
|
2016-06-13 15:16:43 +02:00
|
|
|
if (p_value==0.0)
|
2016-06-13 15:58:32 +02:00
|
|
|
return "0"; //avoid negative zero (-0) being written, which may annoy git, svn, etc. for changes when they don't exist.
|
2016-06-13 15:16:43 +02:00
|
|
|
else
|
|
|
|
return rtoss(p_value);
|
|
|
|
}
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
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 int()) );
|
|
|
|
} break;
|
|
|
|
case Variant::REAL: {
|
|
|
|
|
2016-06-13 15:16:43 +02:00
|
|
|
String s = rtosfix(p_variant.operator real_t());
|
2016-01-10 15:51:05 +01:00
|
|
|
if (s.find(".")==-1 && s.find("e")==-1)
|
|
|
|
s+=".0";
|
|
|
|
p_store_string_func(p_store_string_ud, s );
|
2015-12-31 04:31:00 +01:00
|
|
|
} break;
|
|
|
|
case Variant::STRING: {
|
|
|
|
|
|
|
|
String str=p_variant;
|
|
|
|
|
|
|
|
str="\""+str.c_escape()+"\"";
|
|
|
|
p_store_string_func(p_store_string_ud, str );
|
|
|
|
} break;
|
|
|
|
case Variant::VECTOR2: {
|
|
|
|
|
|
|
|
Vector2 v = p_variant;
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,"Vector2( "+rtosfix(v.x) +", "+rtosfix(v.y)+" )" );
|
2015-12-31 04:31:00 +01:00
|
|
|
} break;
|
|
|
|
case Variant::RECT2: {
|
|
|
|
|
|
|
|
Rect2 aabb = p_variant;
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,"Rect2( "+rtosfix(aabb.pos.x) +", "+rtosfix(aabb.pos.y) +", "+rtosfix(aabb.size.x) +", "+rtosfix(aabb.size.y)+" )" );
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::VECTOR3: {
|
|
|
|
|
|
|
|
Vector3 v = p_variant;
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,"Vector3( "+rtosfix(v.x) +", "+rtosfix(v.y)+", "+rtosfix(v.z)+" )");
|
2015-12-31 04:31:00 +01:00
|
|
|
} break;
|
|
|
|
case Variant::PLANE: {
|
|
|
|
|
|
|
|
Plane p = p_variant;
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,"Plane( "+rtosfix(p.normal.x) +", "+rtosfix(p.normal.y)+", "+rtosfix(p.normal.z)+", "+rtosfix(p.d)+" )" );
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::RECT3: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
Rect3 aabb = p_variant;
|
|
|
|
p_store_string_func(p_store_string_ud,"Rect3( "+rtosfix(aabb.pos.x) +", "+rtosfix(aabb.pos.y) +", "+rtosfix(aabb.pos.z) +", "+rtosfix(aabb.size.x) +", "+rtosfix(aabb.size.y) +", "+rtosfix(aabb.size.z)+" )" );
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::QUAT: {
|
|
|
|
|
|
|
|
Quat quat = p_variant;
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,"Quat( "+rtosfix(quat.x)+", "+rtosfix(quat.y)+", "+rtosfix(quat.z)+", "+rtosfix(quat.w)+" )");
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::TRANSFORM2D: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
String s="Transform2D( ";
|
|
|
|
Transform2D m3 = p_variant;
|
2015-12-31 04:31:00 +01:00
|
|
|
for (int i=0;i<3;i++) {
|
|
|
|
for (int j=0;j<2;j++) {
|
|
|
|
|
|
|
|
if (i!=0 || j!=0)
|
|
|
|
s+=", ";
|
2016-06-13 15:16:43 +02:00
|
|
|
s+=rtosfix( m3.elements[i][j] );
|
2015-12-31 04:31:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
p_store_string_func(p_store_string_ud,s+" )");
|
|
|
|
|
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::BASIS: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
String s="Basis( ";
|
|
|
|
Basis m3 = p_variant;
|
2015-12-31 04:31:00 +01:00
|
|
|
for (int i=0;i<3;i++) {
|
|
|
|
for (int j=0;j<3;j++) {
|
|
|
|
|
|
|
|
if (i!=0 || j!=0)
|
|
|
|
s+=", ";
|
2016-06-13 15:16:43 +02:00
|
|
|
s+=rtosfix( m3.elements[i][j] );
|
2015-12-31 04:31:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
p_store_string_func(p_store_string_ud,s+" )");
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::TRANSFORM: {
|
|
|
|
|
|
|
|
String s="Transform( ";
|
|
|
|
Transform t = p_variant;
|
2017-01-11 04:52:51 +01:00
|
|
|
Basis &m3 = t.basis;
|
2015-12-31 04:31:00 +01:00
|
|
|
for (int i=0;i<3;i++) {
|
|
|
|
for (int j=0;j<3;j++) {
|
|
|
|
|
|
|
|
if (i!=0 || j!=0)
|
|
|
|
s+=", ";
|
2016-06-13 15:16:43 +02:00
|
|
|
s+=rtosfix( m3.elements[i][j] );
|
2015-12-31 04:31:00 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-13 15:16:43 +02:00
|
|
|
s=s+", "+rtosfix(t.origin.x) +", "+rtosfix(t.origin.y)+", "+rtosfix(t.origin.z);
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
p_store_string_func(p_store_string_ud,s+" )");
|
|
|
|
} break;
|
|
|
|
|
|
|
|
// misc types
|
|
|
|
case Variant::COLOR: {
|
|
|
|
|
|
|
|
Color c = p_variant;
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,"Color( "+rtosfix(c.r) +", "+rtosfix(c.g)+", "+rtosfix(c.b)+", "+rtosfix(c.a)+" )");
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::IMAGE: {
|
|
|
|
|
|
|
|
|
|
|
|
Image img=p_variant;
|
|
|
|
|
|
|
|
if (img.empty()) {
|
|
|
|
p_store_string_func(p_store_string_ud,"Image()");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
String imgstr="Image( ";
|
|
|
|
imgstr+=itos(img.get_width());
|
|
|
|
imgstr+=", "+itos(img.get_height());
|
2016-10-03 21:33:42 +02:00
|
|
|
imgstr+=", "+String(img.has_mipmaps()?"true":"false");
|
|
|
|
imgstr+=", "+Image::get_format_name(img.get_format());
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
String s;
|
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> data = img.get_data();
|
2015-12-31 04:31:00 +01:00
|
|
|
int len = data.size();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Read r = data.read();
|
2015-12-31 04:31:00 +01:00
|
|
|
const uint8_t *ptr=r.ptr();;
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
|
|
|
|
if (i>0)
|
|
|
|
s+=", ";
|
|
|
|
s+=itos(ptr[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
imgstr+=", ";
|
|
|
|
p_store_string_func(p_store_string_ud,imgstr);
|
|
|
|
p_store_string_func(p_store_string_ud,s);
|
|
|
|
p_store_string_func(p_store_string_ud," )");
|
|
|
|
} 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: {
|
|
|
|
|
|
|
|
RES res = p_variant;
|
|
|
|
if (res.is_null()) {
|
|
|
|
p_store_string_func(p_store_string_ud,"null");
|
|
|
|
break; // don't save it
|
|
|
|
}
|
|
|
|
|
|
|
|
String res_text;
|
|
|
|
|
|
|
|
if (p_encode_res_func) {
|
|
|
|
|
|
|
|
res_text=p_encode_res_func(p_encode_res_ud,res);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res_text==String() && res->get_path().is_resource_file()) {
|
|
|
|
|
|
|
|
//external resource
|
|
|
|
String path=res->get_path();
|
|
|
|
res_text="Resource( \""+path+"\")";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res_text==String())
|
|
|
|
res_text="null";
|
|
|
|
|
|
|
|
p_store_string_func(p_store_string_ud,res_text);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::INPUT_EVENT: {
|
|
|
|
|
2016-06-05 02:31:29 +02:00
|
|
|
String str="InputEvent(";
|
|
|
|
|
|
|
|
InputEvent ev=p_variant;
|
|
|
|
switch(ev.type) {
|
|
|
|
case InputEvent::KEY: {
|
|
|
|
|
|
|
|
str+="KEY,"+itos(ev.key.scancode);
|
|
|
|
String mod;
|
|
|
|
if (ev.key.mod.alt)
|
|
|
|
mod+="A";
|
|
|
|
if (ev.key.mod.shift)
|
|
|
|
mod+="S";
|
|
|
|
if (ev.key.mod.control)
|
|
|
|
mod+="C";
|
|
|
|
if (ev.key.mod.meta)
|
|
|
|
mod+="M";
|
|
|
|
|
|
|
|
if (mod!=String())
|
|
|
|
str+=","+mod;
|
|
|
|
} break;
|
|
|
|
case InputEvent::MOUSE_BUTTON: {
|
|
|
|
|
|
|
|
str+="MBUTTON,"+itos(ev.mouse_button.button_index);
|
|
|
|
} break;
|
2017-01-08 21:05:51 +01:00
|
|
|
case InputEvent::JOYPAD_BUTTON: {
|
2016-06-05 02:31:29 +02:00
|
|
|
str+="JBUTTON,"+itos(ev.joy_button.button_index);
|
|
|
|
|
|
|
|
} break;
|
2017-01-08 21:05:51 +01:00
|
|
|
case InputEvent::JOYPAD_MOTION: {
|
2016-06-05 02:31:29 +02:00
|
|
|
str+="JAXIS,"+itos(ev.joy_motion.axis)+","+itos(ev.joy_motion.axis_value);
|
|
|
|
} break;
|
2016-10-03 02:40:53 +02:00
|
|
|
case InputEvent::NONE: {
|
|
|
|
str+="NONE";
|
|
|
|
} break;
|
2016-06-05 02:31:29 +02:00
|
|
|
default: {}
|
|
|
|
}
|
|
|
|
|
|
|
|
str+=")";
|
|
|
|
|
|
|
|
p_store_string_func(p_store_string_ud,str); //will be added later
|
|
|
|
|
2015-12-31 04:31:00 +01:00
|
|
|
} 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,"{ ");
|
|
|
|
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,", ");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::POOL_BYTE_ARRAY: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
p_store_string_func(p_store_string_ud,"PoolByteArray( ");
|
2015-12-31 04:31:00 +01:00
|
|
|
String s;
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t> data = p_variant;
|
2015-12-31 04:31:00 +01:00
|
|
|
int len = data.size();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<uint8_t>::Read r = data.read();
|
2015-12-31 04:31:00 +01:00
|
|
|
const uint8_t *ptr=r.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;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::POOL_INT_ARRAY: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
p_store_string_func(p_store_string_ud,"PoolIntArray( ");
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<int> data = p_variant;
|
2015-12-31 04:31:00 +01:00
|
|
|
int len = data.size();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<int>::Read r = data.read();
|
2015-12-31 04:31:00 +01:00
|
|
|
const int *ptr=r.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;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::POOL_REAL_ARRAY: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
p_store_string_func(p_store_string_ud,"PoolFloatArray( ");
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<real_t> data = p_variant;
|
2015-12-31 04:31:00 +01:00
|
|
|
int len = data.size();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<real_t>::Read r = data.read();
|
2015-12-31 04:31:00 +01:00
|
|
|
const real_t *ptr=r.ptr();;
|
|
|
|
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
|
|
|
|
if (i>0)
|
|
|
|
p_store_string_func(p_store_string_ud,", ");
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,rtosfix(ptr[i]));
|
2015-12-31 04:31:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
p_store_string_func(p_store_string_ud," )");
|
|
|
|
|
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::POOL_STRING_ARRAY: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
p_store_string_func(p_store_string_ud,"PoolStringArray( ");
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<String> data = p_variant;
|
2015-12-31 04:31:00 +01:00
|
|
|
int len = data.size();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<String>::Read r = data.read();
|
2015-12-31 04:31:00 +01:00
|
|
|
const String *ptr=r.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];
|
2016-01-09 01:09:13 +01:00
|
|
|
p_store_string_func(p_store_string_ud,"\""+str.c_escape()+"\"");
|
2015-12-31 04:31:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
p_store_string_func(p_store_string_ud," )");
|
|
|
|
|
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::POOL_VECTOR2_ARRAY: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
p_store_string_func(p_store_string_ud,"PoolVector2Array( ");
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Vector2> data = p_variant;
|
2015-12-31 04:31:00 +01:00
|
|
|
int len = data.size();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Vector2>::Read r = data.read();
|
2015-12-31 04:31:00 +01:00
|
|
|
const Vector2 *ptr=r.ptr();;
|
|
|
|
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
|
|
|
|
if (i>0)
|
|
|
|
p_store_string_func(p_store_string_ud,", ");
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,rtosfix(ptr[i].x)+", "+rtosfix(ptr[i].y) );
|
2015-12-31 04:31:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
p_store_string_func(p_store_string_ud," )");
|
|
|
|
|
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::POOL_VECTOR3_ARRAY: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
p_store_string_func(p_store_string_ud,"PoolVector3Array( ");
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Vector3> data = p_variant;
|
2015-12-31 04:31:00 +01:00
|
|
|
int len = data.size();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Vector3>::Read r = data.read();
|
2015-12-31 04:31:00 +01:00
|
|
|
const Vector3 *ptr=r.ptr();;
|
|
|
|
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
|
|
|
|
if (i>0)
|
|
|
|
p_store_string_func(p_store_string_ud,", ");
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,rtosfix(ptr[i].x)+", "+rtosfix(ptr[i].y)+", "+rtosfix(ptr[i].z) );
|
2015-12-31 04:31:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
p_store_string_func(p_store_string_ud," )");
|
|
|
|
|
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::POOL_COLOR_ARRAY: {
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-11 04:52:51 +01:00
|
|
|
p_store_string_func(p_store_string_ud,"PoolColorArray( ");
|
2015-12-31 04:31:00 +01:00
|
|
|
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Color> data = p_variant;
|
2015-12-31 04:31:00 +01:00
|
|
|
int len = data.size();
|
2017-01-07 22:25:37 +01:00
|
|
|
PoolVector<Color>::Read r = data.read();
|
2015-12-31 04:31:00 +01:00
|
|
|
const Color *ptr=r.ptr();;
|
|
|
|
|
|
|
|
for (int i=0;i<len;i++) {
|
|
|
|
|
|
|
|
if (i>0)
|
|
|
|
p_store_string_func(p_store_string_ud,", ");
|
|
|
|
|
2016-06-13 15:16:43 +02:00
|
|
|
p_store_string_func(p_store_string_ud,rtosfix(ptr[i].r)+", "+rtosfix(ptr[i].g)+", "+rtosfix(ptr[i].b)+", "+rtosfix(ptr[i].a) );
|
2015-12-31 04:31:00 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
|
|
|
|
}
|