diff --git a/bin/tests/test_gdscript.cpp b/bin/tests/test_gdscript.cpp index 847be39fb4a..9670e6af6e4 100644 --- a/bin/tests/test_gdscript.cpp +++ b/bin/tests/test_gdscript.cpp @@ -864,7 +864,7 @@ MainLoop* test(TestType p_test) { if (p_test==TEST_TOKENIZER) { - GDTokenizer tk; + GDTokenizerText tk; tk.set_code(code); int line=-1; while(tk.get_token()!=GDTokenizer::TK_EOF) { @@ -969,8 +969,16 @@ MainLoop* test(TestType p_test) { + } else if (p_test==TEST_BYTECODE) { + + Vector buf = GDTokenizerBuffer::parse_code_string(code); + String dst = test.basename()+".gdc"; + FileAccess *fw = FileAccess::open(dst,FileAccess::WRITE); + fw->store_buffer(buf.ptr(),buf.size()); + memdelete(fw); } + #if 0 Parser parser; Error err = parser.parse(code); diff --git a/bin/tests/test_gdscript.h b/bin/tests/test_gdscript.h index c3869abb8e8..1659880c2a7 100644 --- a/bin/tests/test_gdscript.h +++ b/bin/tests/test_gdscript.h @@ -36,7 +36,8 @@ namespace TestGDScript { enum TestType { TEST_TOKENIZER, TEST_PARSER, - TEST_COMPILER + TEST_COMPILER, + TEST_BYTECODE, }; MainLoop* test(TestType p_type); diff --git a/bin/tests/test_main.cpp b/bin/tests/test_main.cpp index eb63a7af84d..5d66f35f24c 100644 --- a/bin/tests/test_main.cpp +++ b/bin/tests/test_main.cpp @@ -152,6 +152,11 @@ MainLoop* test_main(String p_test,const List& p_args) { return TestGDScript::test(TestGDScript::TEST_COMPILER); } + if (p_test=="gd_bytecode") { + + return TestGDScript::test(TestGDScript::TEST_BYTECODE); + } + if (p_test=="image") { return TestImage::test(); diff --git a/core/io/resource_loader.cpp b/core/io/resource_loader.cpp index 3bae6be83c9..13dac6ed162 100644 --- a/core/io/resource_loader.cpp +++ b/core/io/resource_loader.cpp @@ -192,6 +192,7 @@ RES ResourceLoader::load(const String &p_path,const String& p_type_hint,bool p_n res->set_last_modified_time(mt); } #endif + print_line("LOADED: "+res->get_path()); return res; } @@ -246,7 +247,7 @@ String ResourceLoader::find_complete_path(const String& p_path,const String& p_t String path = local_path+E->get(); - if (FileAccess::exists(path)) { + if (PathRemap::get_singleton()->has_remap(path) || FileAccess::exists(path)) { candidates.push_back(path); } diff --git a/core/variant_op.cpp b/core/variant_op.cpp index 109e4ab3873..50908bbf942 100644 --- a/core/variant_op.cpp +++ b/core/variant_op.cpp @@ -1319,7 +1319,7 @@ void Variant::set(const Variant& p_index, const Variant& p_value, bool *r_valid) return; int type=p_value; - if (type<0 || type>=6) + if (type<0 || type>=InputEvent::TYPE_MAX) return; //fail valid=true; ie.type=InputEvent::Type(type); @@ -2765,6 +2765,7 @@ void Variant::get_property_list(List *p_list) const { InputEvent ie = operator InputEvent(); + p_list->push_back( PropertyInfo(Variant::INT,"type")); p_list->push_back( PropertyInfo(Variant::INT,"device")); p_list->push_back( PropertyInfo(Variant::INT,"ID")); diff --git a/core/vmap.h b/core/vmap.h index c6c3d50bc75..516299280be 100644 --- a/core/vmap.h +++ b/core/vmap.h @@ -142,6 +142,12 @@ public: } + int find_nearest(const T& p_val) const { + + bool exact; + return _find(p_val,exact); + + } _FORCE_INLINE_ int size() const { return _data.size(); } _FORCE_INLINE_ bool empty() const { return _data.empty(); } diff --git a/main/main.cpp b/main/main.cpp index 8ed49a38e45..7d19c2ebcf5 100644 --- a/main/main.cpp +++ b/main/main.cpp @@ -1365,6 +1365,10 @@ void Main::cleanup() { OS::get_singleton()->_execpath=""; OS::get_singleton()->_local_clipboard=""; +#ifdef TOOLS_ENABLED + EditorNode::unregister_editor_types(); +#endif + unregister_driver_types(); unregister_module_types(); unregister_scene_types(); diff --git a/modules/gdscript/gd_editor.cpp b/modules/gdscript/gd_editor.cpp index c10cadf83f8..f8717c292f9 100644 --- a/modules/gdscript/gd_editor.cpp +++ b/modules/gdscript/gd_editor.cpp @@ -106,7 +106,7 @@ bool GDScriptLanguage::has_named_classes() const { int GDScriptLanguage::find_function(const String& p_function,const String& p_code) const { - GDTokenizer tokenizer; + GDTokenizerText tokenizer; tokenizer.set_code(p_code); int indent=0; while(tokenizer.get_token()!=GDTokenizer::TK_EOF && tokenizer.get_token()!=GDTokenizer::TK_ERROR) { diff --git a/modules/gdscript/gd_parser.cpp b/modules/gdscript/gd_parser.cpp index e558ceb4167..fb4f56aa8fe 100644 --- a/modules/gdscript/gd_parser.cpp +++ b/modules/gdscript/gd_parser.cpp @@ -54,18 +54,18 @@ T* GDParser::alloc_node() { if (!head) head=t; - t->line=tokenizer.get_token_line(); - t->column=tokenizer.get_token_column(); + t->line=tokenizer->get_token_line(); + t->column=tokenizer->get_token_column(); return t; } bool GDParser::_end_statement() { - if (tokenizer.get_token()==GDTokenizer::TK_SEMICOLON) { - tokenizer.advance(); + if (tokenizer->get_token()==GDTokenizer::TK_SEMICOLON) { + tokenizer->advance(); return true; //handle next - } else if (tokenizer.get_token()==GDTokenizer::TK_NEWLINE || tokenizer.get_token()==GDTokenizer::TK_EOF) { + } else if (tokenizer->get_token()==GDTokenizer::TK_NEWLINE || tokenizer->get_token()==GDTokenizer::TK_EOF) { return true; //will be handled properly } @@ -75,14 +75,14 @@ bool GDParser::_end_statement() { bool GDParser::_enter_indent_block(BlockNode* p_block) { - if (tokenizer.get_token()!=GDTokenizer::TK_COLON) { + if (tokenizer->get_token()!=GDTokenizer::TK_COLON) { _set_error("':' expected at end of line."); return false; } - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_NEWLINE) { + if (tokenizer->get_token()!=GDTokenizer::TK_NEWLINE) { _set_error("newline expected after ':'."); return false; @@ -90,35 +90,35 @@ bool GDParser::_enter_indent_block(BlockNode* p_block) { while(true) { - if (tokenizer.get_token()!=GDTokenizer::TK_NEWLINE) { + if (tokenizer->get_token()!=GDTokenizer::TK_NEWLINE) { return false; //wtf - } else if (tokenizer.get_token(1)!=GDTokenizer::TK_NEWLINE) { + } else if (tokenizer->get_token(1)!=GDTokenizer::TK_NEWLINE) { - int indent = tokenizer.get_token_line_indent(); + int indent = tokenizer->get_token_line_indent(); int current = tab_level.back()->get(); if (indent<=current) return false; tab_level.push_back(indent); - tokenizer.advance(); + tokenizer->advance(); return true; } else if (p_block) { NewLineNode *nl = alloc_node(); - nl->line=tokenizer.get_token_line(); + nl->line=tokenizer->get_token_line(); p_block->statements.push_back(nl); } - tokenizer.advance(); // go to next newline + tokenizer->advance(); // go to next newline } } bool GDParser::_parse_arguments(Node* p_parent,Vector& p_args,bool p_static) { - if (tokenizer.get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) { - tokenizer.advance(); + if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) { + tokenizer->advance(); } else { while(true) { @@ -130,19 +130,19 @@ bool GDParser::_parse_arguments(Node* p_parent,Vector& p_args,bool p_stat p_args.push_back(arg); - if (tokenizer.get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) { - tokenizer.advance(); + if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) { + tokenizer->advance(); break; - } else if (tokenizer.get_token()==GDTokenizer::TK_COMMA) { + } else if (tokenizer->get_token()==GDTokenizer::TK_COMMA) { - if (tokenizer.get_token(1)==GDTokenizer::TK_PARENTHESIS_CLOSE) { + if (tokenizer->get_token(1)==GDTokenizer::TK_PARENTHESIS_CLOSE) { _set_error("Expression expected"); return false; } - tokenizer.advance(); + tokenizer->advance(); } else { // something is broken _set_error("Expected ',' or ')'"); @@ -174,45 +174,45 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ /* Parse Operand */ /*****************/ - if (tokenizer.get_token()==GDTokenizer::TK_PARENTHESIS_OPEN) { + if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_OPEN) { //subexpression () - tokenizer.advance(); + tokenizer->advance(); Node* subexpr = _parse_expression(p_parent,p_static); if (!subexpr) return NULL; - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { _set_error("Expected ')' in expression"); return NULL; } - tokenizer.advance(); + tokenizer->advance(); expr=subexpr; - } else if (tokenizer.get_token()==GDTokenizer::TK_CONSTANT) { + } else if (tokenizer->get_token()==GDTokenizer::TK_CONSTANT) { //constant defined by tokenizer ConstantNode *constant = alloc_node(); - constant->value=tokenizer.get_token_constant(); - tokenizer.advance(); + constant->value=tokenizer->get_token_constant(); + tokenizer->advance(); expr=constant; - } else if (tokenizer.get_token()==GDTokenizer::TK_PR_PRELOAD) { + } else if (tokenizer->get_token()==GDTokenizer::TK_PR_PRELOAD) { //constant defined by tokenizer - tokenizer.advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) { + tokenizer->advance(); + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) { _set_error("Expected '(' after 'preload'"); return NULL; } - tokenizer.advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_CONSTANT || tokenizer.get_token_constant().get_type()!=Variant::STRING) { + tokenizer->advance(); + if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type()!=Variant::STRING) { _set_error("Expected string constant as 'preload' argument."); return NULL; } - String path = tokenizer.get_token_constant(); + String path = tokenizer->get_token_constant(); if (!path.is_abs_path() && base_path!="") path=base_path+"/"+path; @@ -222,20 +222,20 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ return NULL; } - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { _set_error("Expected ')' after 'preload' path"); return NULL; } ConstantNode *constant = alloc_node(); constant->value=res; - tokenizer.advance(); + tokenizer->advance(); expr=constant; - } else if (tokenizer.get_token()==GDTokenizer::TK_SELF) { + } else if (tokenizer->get_token()==GDTokenizer::TK_SELF) { if (p_static) { _set_error("'self'' not allowed in static function or constant expression"); @@ -243,18 +243,18 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ } //constant defined by tokenizer SelfNode *self = alloc_node(); - tokenizer.advance(); + tokenizer->advance(); expr=self; - } else if (tokenizer.get_token()==GDTokenizer::TK_BUILT_IN_TYPE && tokenizer.get_token(1)==GDTokenizer::TK_PERIOD) { + } else if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token(1)==GDTokenizer::TK_PERIOD) { - Variant::Type bi_type = tokenizer.get_token_type(); - tokenizer.advance(2); - if (tokenizer.get_token()!=GDTokenizer::TK_IDENTIFIER) { + Variant::Type bi_type = tokenizer->get_token_type(); + tokenizer->advance(2); + if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) { _set_error("Built-in type constant expected after '.'"); return NULL; } - StringName identifier = tokenizer.get_token_identifier(); + StringName identifier = tokenizer->get_token_identifier(); if (!Variant::has_numeric_constant(bi_type,identifier)) { _set_error("Static constant '"+identifier.operator String()+"' not present in built-in type "+Variant::get_type_name(bi_type)+"."); @@ -264,23 +264,23 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ ConstantNode *cn = alloc_node(); cn->value=Variant::get_numeric_constant_value(bi_type,identifier); expr=cn; - tokenizer.advance(); + tokenizer->advance(); - } else if (tokenizer.get_token(1)==GDTokenizer::TK_PARENTHESIS_OPEN && (tokenizer.get_token()==GDTokenizer::TK_BUILT_IN_TYPE || tokenizer.get_token()==GDTokenizer::TK_IDENTIFIER || tokenizer.get_token()==GDTokenizer::TK_BUILT_IN_FUNC)) { + } else if (tokenizer->get_token(1)==GDTokenizer::TK_PARENTHESIS_OPEN && (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE || tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER || tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_FUNC)) { //function or constructor OperatorNode *op = alloc_node(); op->op=OperatorNode::OP_CALL; - if (tokenizer.get_token()==GDTokenizer::TK_BUILT_IN_TYPE) { + if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE) { TypeNode *tn = alloc_node(); - tn->vtype=tokenizer.get_token_type(); + tn->vtype=tokenizer->get_token_type(); op->arguments.push_back(tn); - } else if (tokenizer.get_token()==GDTokenizer::TK_BUILT_IN_FUNC) { + } else if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_FUNC) { BuiltInFunctionNode *bn = alloc_node(); - bn->function=tokenizer.get_token_built_in_func(); + bn->function=tokenizer->get_token_built_in_func(); op->arguments.push_back(bn); } else { @@ -288,25 +288,25 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ op->arguments.push_back(self); IdentifierNode* id = alloc_node(); - id->name=tokenizer.get_token_identifier(); + id->name=tokenizer->get_token_identifier(); op->arguments.push_back(id); } - tokenizer.advance(2); + tokenizer->advance(2); if (!_parse_arguments(op,op->arguments,p_static)) return NULL; expr=op; - } else if (tokenizer.get_token()==GDTokenizer::TK_IDENTIFIER) { + } else if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER) { //identifier (reference) IdentifierNode *id = alloc_node(); - id->name=tokenizer.get_token_identifier(); - tokenizer.advance(); + id->name=tokenizer->get_token_identifier(); + tokenizer->advance(); expr=id; - } else if (/*tokenizer.get_token()==GDTokenizer::TK_OP_ADD ||*/ tokenizer.get_token()==GDTokenizer::TK_OP_SUB || tokenizer.get_token()==GDTokenizer::TK_OP_NOT || tokenizer.get_token()==GDTokenizer::TK_OP_BIT_INVERT) { + } else if (/*tokenizer->get_token()==GDTokenizer::TK_OP_ADD ||*/ tokenizer->get_token()==GDTokenizer::TK_OP_SUB || tokenizer->get_token()==GDTokenizer::TK_OP_NOT || tokenizer->get_token()==GDTokenizer::TK_OP_BIT_INVERT) { //single prefix operators like !expr -expr ++expr --expr OperatorNode *op = alloc_node(); @@ -314,7 +314,7 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ Expression e; e.is_op=true; - switch(tokenizer.get_token()) { + switch(tokenizer->get_token()) { case GDTokenizer::TK_OP_SUB: e.op=OperatorNode::OP_NEG; break; case GDTokenizer::TK_OP_NOT: e.op=OperatorNode::OP_NOT; break; case GDTokenizer::TK_OP_BIT_INVERT: e.op=OperatorNode::OP_BIT_INVERT;; break; @@ -322,9 +322,9 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ } - tokenizer.advance(); + tokenizer->advance(); - if (e.op!=OperatorNode::OP_NOT && tokenizer.get_token()==GDTokenizer::TK_OP_NOT) { + if (e.op!=OperatorNode::OP_NOT && tokenizer->get_token()==GDTokenizer::TK_OP_NOT) { _set_error("Misplaced 'not'."); return NULL; } @@ -339,34 +339,34 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ op->arguments.push_back(subexpr); expr=op;*/ - } else if (tokenizer.get_token()==GDTokenizer::TK_BRACKET_OPEN) { + } else if (tokenizer->get_token()==GDTokenizer::TK_BRACKET_OPEN) { // array - tokenizer.advance(); + tokenizer->advance(); ArrayNode *arr = alloc_node(); bool expecting_comma=false; while(true) { - if (tokenizer.get_token()==GDTokenizer::TK_EOF) { + if (tokenizer->get_token()==GDTokenizer::TK_EOF) { _set_error("Unterminated array"); return NULL; - } else if (tokenizer.get_token()==GDTokenizer::TK_BRACKET_CLOSE) { - tokenizer.advance(); + } else if (tokenizer->get_token()==GDTokenizer::TK_BRACKET_CLOSE) { + tokenizer->advance(); break; - } else if (tokenizer.get_token()==GDTokenizer::TK_NEWLINE) { + } else if (tokenizer->get_token()==GDTokenizer::TK_NEWLINE) { - tokenizer.advance(); //ignore newline - } else if (tokenizer.get_token()==GDTokenizer::TK_COMMA) { + tokenizer->advance(); //ignore newline + } else if (tokenizer->get_token()==GDTokenizer::TK_COMMA) { if (!expecting_comma) { _set_error("expression or ']' expected"); return NULL; } expecting_comma=false; - tokenizer.advance(); //ignore newline + tokenizer->advance(); //ignore newline } else { //parse expression if (expecting_comma) { @@ -382,9 +382,9 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ } expr=arr; - } else if (tokenizer.get_token()==GDTokenizer::TK_CURLY_BRACKET_OPEN) { + } else if (tokenizer->get_token()==GDTokenizer::TK_CURLY_BRACKET_OPEN) { // array - tokenizer.advance(); + tokenizer->advance(); DictionaryNode *dict = alloc_node(); @@ -403,12 +403,12 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ while(true) { - if (tokenizer.get_token()==GDTokenizer::TK_EOF) { + if (tokenizer->get_token()==GDTokenizer::TK_EOF) { _set_error("Unterminated dictionary"); return NULL; - } else if (tokenizer.get_token()==GDTokenizer::TK_CURLY_BRACKET_CLOSE) { + } else if (tokenizer->get_token()==GDTokenizer::TK_CURLY_BRACKET_CLOSE) { if (expecting==DICT_EXPECT_COLON) { _set_error("':' expected"); @@ -418,12 +418,12 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ _set_error("value expected"); return NULL; } - tokenizer.advance(); + tokenizer->advance(); break; - } else if (tokenizer.get_token()==GDTokenizer::TK_NEWLINE) { + } else if (tokenizer->get_token()==GDTokenizer::TK_NEWLINE) { - tokenizer.advance(); //ignore newline - } else if (tokenizer.get_token()==GDTokenizer::TK_COMMA) { + tokenizer->advance(); //ignore newline + } else if (tokenizer->get_token()==GDTokenizer::TK_COMMA) { if (expecting==DICT_EXPECT_KEY) { _set_error("key or '}' expected"); @@ -439,9 +439,9 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ } expecting=DICT_EXPECT_KEY; - tokenizer.advance(); //ignore newline + tokenizer->advance(); //ignore newline - } else if (tokenizer.get_token()==GDTokenizer::TK_COLON) { + } else if (tokenizer->get_token()==GDTokenizer::TK_COLON) { if (expecting==DICT_EXPECT_KEY) { _set_error("key or '}' expected"); @@ -457,7 +457,7 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ } expecting=DICT_EXPECT_VALUE; - tokenizer.advance(); //ignore newline + tokenizer->advance(); //ignore newline } else { if (expecting==DICT_EXPECT_COMMA) { @@ -471,12 +471,12 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ if (expecting==DICT_EXPECT_KEY) { - if (tokenizer.get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer.get_token(1)==GDTokenizer::TK_OP_ASSIGN) { + if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token(1)==GDTokenizer::TK_OP_ASSIGN) { //lua style identifier, easier to write ConstantNode *cn = alloc_node(); - cn->value = tokenizer.get_token_identifier(); + cn->value = tokenizer->get_token_identifier(); key = cn; - tokenizer.advance(2); + tokenizer->advance(2); expecting=DICT_EXPECT_VALUE; } else { //python/js style more flexible @@ -506,10 +506,10 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ expr=dict; - } else if (tokenizer.get_token()==GDTokenizer::TK_PERIOD && tokenizer.get_token(1)==GDTokenizer::TK_IDENTIFIER && tokenizer.get_token(2)==GDTokenizer::TK_PARENTHESIS_OPEN) { + } else if (tokenizer->get_token()==GDTokenizer::TK_PERIOD && tokenizer->get_token(1)==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token(2)==GDTokenizer::TK_PARENTHESIS_OPEN) { // parent call - tokenizer.advance(); //goto identifier + tokenizer->advance(); //goto identifier OperatorNode *op = alloc_node(); op->op=OperatorNode::OP_PARENT_CALL; @@ -519,10 +519,10 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ forbidden for now */ IdentifierNode* id = alloc_node(); - id->name=tokenizer.get_token_identifier(); + id->name=tokenizer->get_token_identifier(); op->arguments.push_back(id); - tokenizer.advance(2); + tokenizer->advance(2); if (!_parse_arguments(op,op->arguments,p_static)) return NULL; @@ -534,7 +534,7 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ print_line("found bug?"); - _set_error("Error parsing expression, misplaced: "+String(tokenizer.get_token_name(tokenizer.get_token()))); + _set_error("Error parsing expression, misplaced: "+String(tokenizer->get_token_name(tokenizer->get_token()))); return NULL; //nothing } @@ -553,31 +553,31 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ //expressions can be indexed any number of times - if (tokenizer.get_token()==GDTokenizer::TK_PERIOD) { + if (tokenizer->get_token()==GDTokenizer::TK_PERIOD) { //indexing using "." - if (tokenizer.get_token(1)!=GDTokenizer::TK_IDENTIFIER && tokenizer.get_token(1)!=GDTokenizer::TK_BUILT_IN_FUNC ) { + if (tokenizer->get_token(1)!=GDTokenizer::TK_IDENTIFIER && tokenizer->get_token(1)!=GDTokenizer::TK_BUILT_IN_FUNC ) { _set_error("Expected identifier as member"); return NULL; - } else if (tokenizer.get_token(2)==GDTokenizer::TK_PARENTHESIS_OPEN) { + } else if (tokenizer->get_token(2)==GDTokenizer::TK_PARENTHESIS_OPEN) { //call!! OperatorNode * op = alloc_node(); op->op=OperatorNode::OP_CALL; IdentifierNode * id = alloc_node(); - if (tokenizer.get_token(1)==GDTokenizer::TK_BUILT_IN_FUNC ) { + if (tokenizer->get_token(1)==GDTokenizer::TK_BUILT_IN_FUNC ) { //small hack so built in funcs don't obfuscate methods - id->name=GDFunctions::get_func_name(tokenizer.get_token_built_in_func(1)); + id->name=GDFunctions::get_func_name(tokenizer->get_token_built_in_func(1)); } else { - id->name=tokenizer.get_token_identifier(1); + id->name=tokenizer->get_token_identifier(1); } op->arguments.push_back(expr); // call what op->arguments.push_back(id); // call func //get arguments - tokenizer.advance(3); + tokenizer->advance(3); if (!_parse_arguments(op,op->arguments,p_static)) return NULL; expr=op; @@ -588,36 +588,36 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ op->op=OperatorNode::OP_INDEX_NAMED; IdentifierNode * id = alloc_node(); - id->name=tokenizer.get_token_identifier(1); + id->name=tokenizer->get_token_identifier(1); op->arguments.push_back(expr); op->arguments.push_back(id); expr=op; - tokenizer.advance(2); + tokenizer->advance(2); } - } else if (tokenizer.get_token()==GDTokenizer::TK_BRACKET_OPEN) { + } else if (tokenizer->get_token()==GDTokenizer::TK_BRACKET_OPEN) { //indexing using "[]" OperatorNode * op = alloc_node(); op->op=OperatorNode::OP_INDEX; - tokenizer.advance(1); + tokenizer->advance(1); Node *subexpr = _parse_expression(op,p_static); if (!subexpr) { return NULL; } - if (tokenizer.get_token()!=GDTokenizer::TK_BRACKET_CLOSE) { + if (tokenizer->get_token()!=GDTokenizer::TK_BRACKET_CLOSE) { _set_error("Expected ']'"); return NULL; } op->arguments.push_back(expr); op->arguments.push_back(subexpr); - tokenizer.advance(1); + tokenizer->advance(1); expr=op; } else @@ -641,7 +641,7 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ //assign, if allowed is only alowed on the first operator #define _VALIDATE_ASSIGN if (!p_allow_assign) { _set_error("Unexpected assign."); return NULL; } p_allow_assign=false; - switch(tokenizer.get_token()) { //see operator + switch(tokenizer->get_token()) { //see operator case GDTokenizer::TK_OP_IN: op=OperatorNode::OP_IN; break; case GDTokenizer::TK_OP_EQUAL: op=OperatorNode::OP_EQUAL ; break; @@ -682,7 +682,7 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_ e.is_op=true; e.op=op; expression.push_back(e); - tokenizer.advance(); + tokenizer->advance(); } else { break; } @@ -1190,18 +1190,18 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { NewLineNode *nl = alloc_node(); - nl->line=tokenizer.get_token_line(); + nl->line=tokenizer->get_token_line(); p_block->statements.push_back(nl); #endif while(true) { - GDTokenizer::Token token = tokenizer.get_token(); + GDTokenizer::Token token = tokenizer->get_token(); if (error_set) return; if (indent_level>tab_level.back()->get()) { - p_block->end_line=tokenizer.get_token_line(); + p_block->end_line=tokenizer->get_token_line(); return; //go back a level } @@ -1209,7 +1209,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { case GDTokenizer::TK_EOF: - p_block->end_line=tokenizer.get_token_line(); + p_block->end_line=tokenizer->get_token_line(); case GDTokenizer::TK_ERROR: { return; //go back @@ -1219,38 +1219,38 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { case GDTokenizer::TK_NEWLINE: { NewLineNode *nl = alloc_node(); - nl->line=tokenizer.get_token_line(); + nl->line=tokenizer->get_token_line(); p_block->statements.push_back(nl); if (!_parse_newline()) { if (!error_set) { - p_block->end_line=tokenizer.get_token_line(); + p_block->end_line=tokenizer->get_token_line(); } return; } } break; case GDTokenizer::TK_CF_PASS: { - if (tokenizer.get_token(1)!=GDTokenizer::TK_SEMICOLON && tokenizer.get_token(1)!=GDTokenizer::TK_NEWLINE ) { + if (tokenizer->get_token(1)!=GDTokenizer::TK_SEMICOLON && tokenizer->get_token(1)!=GDTokenizer::TK_NEWLINE ) { _set_error("Expected ';' or ."); return; } - tokenizer.advance(); + tokenizer->advance(); } break; case GDTokenizer::TK_PR_VAR: { //variale declaration and (eventual) initialization - tokenizer.advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_IDENTIFIER) { + tokenizer->advance(); + if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) { _set_error("Expected identifier for local variable name."); return; } - StringName n = tokenizer.get_token_identifier(); - tokenizer.advance(); + StringName n = tokenizer->get_token_identifier(); + tokenizer->advance(); p_block->variables.push_back(n); //line? - p_block->variable_lines.push_back(tokenizer.get_token_line()); + p_block->variable_lines.push_back(tokenizer->get_token_line()); //must know when the local variable is declared @@ -1260,9 +1260,9 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { Node *assigned=NULL; - if (tokenizer.get_token()==GDTokenizer::TK_OP_ASSIGN) { + if (tokenizer->get_token()==GDTokenizer::TK_OP_ASSIGN) { - tokenizer.advance(); + tokenizer->advance(); Node *subexpr=NULL; subexpr = _parse_and_reduce_expression(p_block,p_static); @@ -1294,7 +1294,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { } break; case GDTokenizer::TK_CF_IF: { - tokenizer.advance(); + tokenizer->advance(); Node *condition = _parse_and_reduce_expression(p_block,p_static); if (!condition) return; @@ -1308,7 +1308,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { p_block->sub_blocks.push_back(cf_if->body); if (!_enter_indent_block(cf_if->body)) { - p_block->end_line=tokenizer.get_token_line(); + p_block->end_line=tokenizer->get_token_line(); return; } @@ -1319,16 +1319,16 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { while(true) { - while(tokenizer.get_token()==GDTokenizer::TK_NEWLINE) { - tokenizer.advance(); + while(tokenizer->get_token()==GDTokenizer::TK_NEWLINE) { + tokenizer->advance(); } if (tab_level.back()->get() < indent_level) { //not at current indent level - p_block->end_line=tokenizer.get_token_line(); + p_block->end_line=tokenizer->get_token_line(); return; } - if (tokenizer.get_token()==GDTokenizer::TK_CF_ELIF) { + if (tokenizer->get_token()==GDTokenizer::TK_CF_ELIF) { if (tab_level.back()->get() > indent_level) { @@ -1336,7 +1336,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { return; } - tokenizer.advance(); + tokenizer->advance(); cf_if->body_else=alloc_node(); p_block->sub_blocks.push_back(cf_if->body_else); @@ -1358,7 +1358,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { if (!_enter_indent_block(cf_if->body)) { - p_block->end_line=tokenizer.get_token_line(); + p_block->end_line=tokenizer->get_token_line(); return; } @@ -1367,7 +1367,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { return; - } else if (tokenizer.get_token()==GDTokenizer::TK_CF_ELSE) { + } else if (tokenizer->get_token()==GDTokenizer::TK_CF_ELSE) { if (tab_level.back()->get() > indent_level) { @@ -1376,12 +1376,12 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { } - tokenizer.advance(); + tokenizer->advance(); cf_if->body_else=alloc_node(); p_block->sub_blocks.push_back(cf_if->body_else); if (!_enter_indent_block(cf_if->body_else)) { - p_block->end_line=tokenizer.get_token_line(); + p_block->end_line=tokenizer->get_token_line(); return; } _parse_block(cf_if->body_else,p_static); @@ -1400,7 +1400,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { } break; case GDTokenizer::TK_CF_WHILE: { - tokenizer.advance(); + tokenizer->advance(); Node *condition = _parse_and_reduce_expression(p_block,p_static); if (!condition) return; @@ -1414,7 +1414,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { p_block->sub_blocks.push_back(cf_while->body); if (!_enter_indent_block(cf_while->body)) { - p_block->end_line=tokenizer.get_token_line(); + p_block->end_line=tokenizer->get_token_line(); return; } @@ -1425,24 +1425,24 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { } break; case GDTokenizer::TK_CF_FOR: { - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_IDENTIFIER) { + if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) { _set_error("identifier expected after 'for'"); } IdentifierNode *id = alloc_node(); - id->name=tokenizer.get_token_identifier(); + id->name=tokenizer->get_token_identifier(); - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_OP_IN) { + if (tokenizer->get_token()!=GDTokenizer::TK_OP_IN) { _set_error("'in' expected after identifier"); return; } - tokenizer.advance(); + tokenizer->advance(); Node *container = _parse_and_reduce_expression(p_block,p_static); if (!container) @@ -1458,7 +1458,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { p_block->sub_blocks.push_back(cf_for->body); if (!_enter_indent_block(cf_for->body)) { - p_block->end_line=tokenizer.get_token_line(); + p_block->end_line=tokenizer->get_token_line(); return; } @@ -1469,7 +1469,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { } break; case GDTokenizer::TK_CF_CONTINUE: { - tokenizer.advance(); + tokenizer->advance(); ControlFlowNode *cf_continue = alloc_node(); cf_continue->cf_type=ControlFlowNode::CF_CONTINUE; p_block->statements.push_back(cf_continue); @@ -1480,7 +1480,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { } break; case GDTokenizer::TK_CF_BREAK: { - tokenizer.advance(); + tokenizer->advance(); ControlFlowNode *cf_break = alloc_node(); cf_break->cf_type=ControlFlowNode::CF_BREAK; p_block->statements.push_back(cf_break); @@ -1491,13 +1491,13 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { } break; case GDTokenizer::TK_CF_RETURN: { - tokenizer.advance(); + tokenizer->advance(); ControlFlowNode *cf_return = alloc_node(); cf_return->cf_type=ControlFlowNode::CF_RETURN; - if (tokenizer.get_token()==GDTokenizer::TK_SEMICOLON || tokenizer.get_token()==GDTokenizer::TK_NEWLINE || tokenizer.get_token()==GDTokenizer::TK_EOF) { + if (tokenizer->get_token()==GDTokenizer::TK_SEMICOLON || tokenizer->get_token()==GDTokenizer::TK_NEWLINE || tokenizer->get_token()==GDTokenizer::TK_EOF) { //expect end of statement p_block->statements.push_back(cf_return); if (!_end_statement()) { @@ -1520,7 +1520,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { } break; case GDTokenizer::TK_PR_ASSERT: { - tokenizer.advance(); + tokenizer->advance(); Node *condition = _parse_and_reduce_expression(p_block,p_static); if (!condition) return; @@ -1548,11 +1548,11 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { /* case GDTokenizer::TK_CF_LOCAL: { - if (tokenizer.get_token(1)!=GDTokenizer::TK_SEMICOLON && tokenizer.get_token(1)!=GDTokenizer::TK_NEWLINE ) { + if (tokenizer->get_token(1)!=GDTokenizer::TK_SEMICOLON && tokenizer->get_token(1)!=GDTokenizer::TK_NEWLINE ) { _set_error("Expected ';' or ."); } - tokenizer.advance(); + tokenizer->advance(); } break; */ @@ -1563,9 +1563,9 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) { bool GDParser::_parse_newline() { - if (tokenizer.get_token(1)!=GDTokenizer::TK_EOF && tokenizer.get_token(1)!=GDTokenizer::TK_NEWLINE) { + if (tokenizer->get_token(1)!=GDTokenizer::TK_EOF && tokenizer->get_token(1)!=GDTokenizer::TK_NEWLINE) { - int indent = tokenizer.get_token_line_indent(); + int indent = tokenizer->get_token_line_indent(); int current_indent = tab_level.back()->get(); if (indent>current_indent) { @@ -1593,12 +1593,12 @@ bool GDParser::_parse_newline() { current_indent = tab_level.back()->get(); } - tokenizer.advance(); + tokenizer->advance(); return false; } } - tokenizer.advance(); + tokenizer->advance(); return true; } @@ -1622,11 +1622,11 @@ void GDParser::_parse_extends(ClassNode *p_class) { p_class->extends_used=true; //see if inheritance happens from a file - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()==GDTokenizer::TK_CONSTANT) { + if (tokenizer->get_token()==GDTokenizer::TK_CONSTANT) { - Variant constant = tokenizer.get_token_constant(); + Variant constant = tokenizer->get_token_constant(); if (constant.get_type()!=Variant::STRING) { _set_error("'extends' constant must be a string."); @@ -1634,27 +1634,27 @@ void GDParser::_parse_extends(ClassNode *p_class) { } p_class->extends_file=constant; - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_PERIOD) { + if (tokenizer->get_token()!=GDTokenizer::TK_PERIOD) { return; } else - tokenizer.advance(); + tokenizer->advance(); } while(true) { - if (tokenizer.get_token()!=GDTokenizer::TK_IDENTIFIER) { + if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) { _set_error("Invalid 'extends' syntax, expected string constant (path) and/or identifier (parent class)."); return; } - StringName identifier=tokenizer.get_token_identifier(); + StringName identifier=tokenizer->get_token_identifier(); p_class->extends_class.push_back(identifier); - tokenizer.advance(1); - if (tokenizer.get_token()!=GDTokenizer::TK_PERIOD) + tokenizer->advance(1); + if (tokenizer->get_token()!=GDTokenizer::TK_PERIOD) return; } @@ -1666,19 +1666,19 @@ void GDParser::_parse_class(ClassNode *p_class) { while(true) { - GDTokenizer::Token token = tokenizer.get_token(); + GDTokenizer::Token token = tokenizer->get_token(); if (error_set) return; if (indent_level>tab_level.back()->get()) { - p_class->end_line=tokenizer.get_token_line(); + p_class->end_line=tokenizer->get_token_line(); return; //go back a level } switch(token) { case GDTokenizer::TK_EOF: - p_class->end_line=tokenizer.get_token_line(); + p_class->end_line=tokenizer->get_token_line(); case GDTokenizer::TK_ERROR: { return; //go back //end of file! @@ -1686,7 +1686,7 @@ void GDParser::_parse_class(ClassNode *p_class) { case GDTokenizer::TK_NEWLINE: { if (!_parse_newline()) { if (!error_set) { - p_class->end_line=tokenizer.get_token_line(); + p_class->end_line=tokenizer->get_token_line(); } return; } @@ -1709,7 +1709,7 @@ void GDParser::_parse_class(ClassNode *p_class) { } p_class->tool=true; - tokenizer.advance(); + tokenizer->advance(); } break; case GDTokenizer::TK_PR_CLASS: { @@ -1718,13 +1718,13 @@ void GDParser::_parse_class(ClassNode *p_class) { StringName name; StringName extends; - if (tokenizer.get_token(1)!=GDTokenizer::TK_IDENTIFIER) { + if (tokenizer->get_token(1)!=GDTokenizer::TK_IDENTIFIER) { _set_error("'class' syntax: 'class :' or 'class extends :'"); return; } - name = tokenizer.get_token_identifier(1); - tokenizer.advance(2); + name = tokenizer->get_token_identifier(1); + tokenizer->advance(2); ClassNode *newclass = alloc_node(); newclass->initializer = alloc_node(); @@ -1733,7 +1733,7 @@ void GDParser::_parse_class(ClassNode *p_class) { p_class->subclasses.push_back(newclass); - if (tokenizer.get_token()==GDTokenizer::TK_PR_EXTENDS) { + if (tokenizer->get_token()==GDTokenizer::TK_PR_EXTENDS) { _parse_extends(newclass); if (error_set) @@ -1751,12 +1751,12 @@ void GDParser::_parse_class(ClassNode *p_class) { /* this is for functions.... case GDTokenizer::TK_CF_PASS: { - tokenizer.advance(1); + tokenizer->advance(1); } break; */ case GDTokenizer::TK_PR_STATIC: { - tokenizer.advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_PR_FUNCTION) { + tokenizer->advance(); + if (tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) { _set_error("Expected 'func'."); return; @@ -1767,19 +1767,19 @@ void GDParser::_parse_class(ClassNode *p_class) { bool _static=false; - if (tokenizer.get_token(-1)==GDTokenizer::TK_PR_STATIC) { + if (tokenizer->get_token(-1)==GDTokenizer::TK_PR_STATIC) { _static=true; } - if (tokenizer.get_token(1)!=GDTokenizer::TK_IDENTIFIER) { + if (tokenizer->get_token(1)!=GDTokenizer::TK_IDENTIFIER) { _set_error("Expected identifier after 'func' (syntax: 'func ([arguments]):' )."); return; } - StringName name = tokenizer.get_token_identifier(1); + StringName name = tokenizer->get_token_identifier(1); for(int i=0;ifunctions.size();i++) { if (p_class->functions[i]->name==name) { @@ -1791,56 +1791,56 @@ void GDParser::_parse_class(ClassNode *p_class) { _set_error("Function '"+String(name)+"' already exists in this class (at line: "+itos(p_class->static_functions[i]->line)+")."); } } - tokenizer.advance(2); + tokenizer->advance(2); - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) { + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) { _set_error("Expected '(' after identifier (syntax: 'func ([arguments]):' )."); return; } - tokenizer.advance(); + tokenizer->advance(); Vector arguments; Vector default_values; - int fnline = tokenizer.get_token_line(); + int fnline = tokenizer->get_token_line(); - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { //has arguments bool defaulting=false; while(true) { - if (tokenizer.get_token()==GDTokenizer::TK_PR_VAR) { + if (tokenizer->get_token()==GDTokenizer::TK_PR_VAR) { - tokenizer.advance(); //var before the identifier is allowed + tokenizer->advance(); //var before the identifier is allowed } - if (tokenizer.get_token()!=GDTokenizer::TK_IDENTIFIER) { + if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) { _set_error("Expected identifier for argument."); return; } - StringName argname=tokenizer.get_token_identifier(); + StringName argname=tokenizer->get_token_identifier(); arguments.push_back(argname); - tokenizer.advance(); + tokenizer->advance(); - if (defaulting && tokenizer.get_token()!=GDTokenizer::TK_OP_ASSIGN) { + if (defaulting && tokenizer->get_token()!=GDTokenizer::TK_OP_ASSIGN) { _set_error("Default parameter expected."); return; } - //tokenizer.advance(); + //tokenizer->advance(); - if (tokenizer.get_token()==GDTokenizer::TK_OP_ASSIGN) { + if (tokenizer->get_token()==GDTokenizer::TK_OP_ASSIGN) { defaulting=true; - tokenizer.advance(1); + tokenizer->advance(1); Node *defval=NULL; defval=_parse_and_reduce_expression(p_class,_static); @@ -1864,10 +1864,10 @@ void GDParser::_parse_class(ClassNode *p_class) { default_values.push_back(on); } - if (tokenizer.get_token()==GDTokenizer::TK_COMMA) { - tokenizer.advance(); + if (tokenizer->get_token()==GDTokenizer::TK_COMMA) { + tokenizer->advance(); continue; - } else if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { + } else if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { _set_error("Expected ',' or ')'."); return; @@ -1879,7 +1879,7 @@ void GDParser::_parse_class(ClassNode *p_class) { } - tokenizer.advance(); + tokenizer->advance(); BlockNode *block = alloc_node(); @@ -1895,24 +1895,24 @@ void GDParser::_parse_class(ClassNode *p_class) { id->name="_init"; cparent->arguments.push_back(id); - if (tokenizer.get_token()==GDTokenizer::TK_PERIOD) { - tokenizer.advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) { + if (tokenizer->get_token()==GDTokenizer::TK_PERIOD) { + tokenizer->advance(); + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) { _set_error("expected '(' for parent constructor arguments."); } - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { //has arguments while(true) { Node *arg = _parse_and_reduce_expression(p_class,_static); cparent->arguments.push_back(arg); - if (tokenizer.get_token()==GDTokenizer::TK_COMMA) { - tokenizer.advance(); + if (tokenizer->get_token()==GDTokenizer::TK_COMMA) { + tokenizer->advance(); continue; - } else if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { + } else if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { _set_error("Expected ',' or ')'."); return; @@ -1923,12 +1923,12 @@ void GDParser::_parse_class(ClassNode *p_class) { } } - tokenizer.advance(); + tokenizer->advance(); } } else { - if (tokenizer.get_token()==GDTokenizer::TK_PERIOD) { + if (tokenizer->get_token()==GDTokenizer::TK_PERIOD) { _set_error("Parent constructor call found for a class without inheritance."); return; @@ -1963,41 +1963,41 @@ void GDParser::_parse_class(ClassNode *p_class) { } break; case GDTokenizer::TK_PR_EXPORT: { - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()==GDTokenizer::TK_PARENTHESIS_OPEN) { + if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_OPEN) { - tokenizer.advance(); - if (tokenizer.get_token()==GDTokenizer::TK_BUILT_IN_TYPE) { + tokenizer->advance(); + if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE) { - Variant::Type type = tokenizer.get_token_type(); + Variant::Type type = tokenizer->get_token_type(); if (type==Variant::NIL) { _set_error("Can't export null type."); return; } current_export.type=type; - tokenizer.advance(); - if (tokenizer.get_token()==GDTokenizer::TK_COMMA) { + tokenizer->advance(); + if (tokenizer->get_token()==GDTokenizer::TK_COMMA) { // hint expected next! - tokenizer.advance(); + tokenizer->advance(); switch(current_export.type) { case Variant::INT: { - if (tokenizer.get_token()==GDTokenizer::TK_CONSTANT && tokenizer.get_token_constant().get_type()==Variant::STRING) { + if (tokenizer->get_token()==GDTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type()==Variant::STRING) { //enumeration current_export.hint=PROPERTY_HINT_ENUM; bool first=true; while(true) { - if (tokenizer.get_token()!=GDTokenizer::TK_CONSTANT || tokenizer.get_token_constant().get_type()!=Variant::STRING) { + if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type()!=Variant::STRING) { current_export=PropertyInfo(); _set_error("Expected a string constant in enumeration hint."); } - String c = tokenizer.get_token_constant(); + String c = tokenizer->get_token_constant(); if (!first) current_export.hint_string+=","; else @@ -2005,16 +2005,16 @@ void GDParser::_parse_class(ClassNode *p_class) { current_export.hint_string+=c.xml_escape(); - tokenizer.advance(); - if (tokenizer.get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) + tokenizer->advance(); + if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) break; - if (tokenizer.get_token()!=GDTokenizer::TK_COMMA) { + if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) { current_export=PropertyInfo(); _set_error("Expected ')' or ',' in enumeration hint."); } - tokenizer.advance(); + tokenizer->advance(); } @@ -2024,7 +2024,7 @@ void GDParser::_parse_class(ClassNode *p_class) { }; case Variant::REAL: { - if (tokenizer.get_token()!=GDTokenizer::TK_CONSTANT || !tokenizer.get_token_constant().is_num()) { + if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) { current_export=PropertyInfo(); _set_error("Expected a range in numeric hint."); @@ -2033,119 +2033,119 @@ void GDParser::_parse_class(ClassNode *p_class) { //enumeration current_export.hint=PROPERTY_HINT_RANGE; - current_export.hint_string=tokenizer.get_token_constant().operator String(); - tokenizer.advance(); + current_export.hint_string=tokenizer->get_token_constant().operator String(); + tokenizer->advance(); - if (tokenizer.get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) { + if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) { current_export.hint_string="0,"+current_export.hint_string; break; } - if (tokenizer.get_token()!=GDTokenizer::TK_COMMA) { + if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) { current_export=PropertyInfo(); _set_error("Expected ',' or ')' in numeric range hint."); } - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_CONSTANT || !tokenizer.get_token_constant().is_num()) { + if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) { current_export=PropertyInfo(); _set_error("Expected a number as upper bound in numeric range hint."); } - current_export.hint_string+=","+tokenizer.get_token_constant().operator String(); - tokenizer.advance(); + current_export.hint_string+=","+tokenizer->get_token_constant().operator String(); + tokenizer->advance(); - if (tokenizer.get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) + if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) break; - if (tokenizer.get_token()!=GDTokenizer::TK_COMMA) { + if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) { current_export=PropertyInfo(); _set_error("Expected ',' or ')' in numeric range hint."); } - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_CONSTANT || !tokenizer.get_token_constant().is_num()) { + if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) { current_export=PropertyInfo(); _set_error("Expected a number as step in numeric range hint."); } - current_export.hint_string+=","+tokenizer.get_token_constant().operator String(); - tokenizer.advance(); + current_export.hint_string+=","+tokenizer->get_token_constant().operator String(); + tokenizer->advance(); } break; case Variant::STRING: { - if (tokenizer.get_token()==GDTokenizer::TK_CONSTANT && tokenizer.get_token_constant().get_type()==Variant::STRING) { + if (tokenizer->get_token()==GDTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type()==Variant::STRING) { //enumeration current_export.hint=PROPERTY_HINT_ENUM; bool first=true; while(true) { - if (tokenizer.get_token()!=GDTokenizer::TK_CONSTANT || tokenizer.get_token_constant().get_type()!=Variant::STRING) { + if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type()!=Variant::STRING) { current_export=PropertyInfo(); _set_error("Expected a string constant in enumeration hint."); } - String c = tokenizer.get_token_constant(); + String c = tokenizer->get_token_constant(); if (!first) current_export.hint_string+=","; else first=false; current_export.hint_string+=c.xml_escape(); - tokenizer.advance(); - if (tokenizer.get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) + tokenizer->advance(); + if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) break; - if (tokenizer.get_token()!=GDTokenizer::TK_COMMA) { + if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) { current_export=PropertyInfo(); _set_error("Expected ')' or ',' in enumeration hint."); return; } - tokenizer.advance(); + tokenizer->advance(); } break; } - if (tokenizer.get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer.get_token_identifier()=="DIR") { + if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier()=="DIR") { current_export.hint=PROPERTY_HINT_DIR; - tokenizer.advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { + tokenizer->advance(); + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { _set_error("Expected ')' in hint."); return; } break; } - if (tokenizer.get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer.get_token_identifier()=="FILE") { + if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier()=="FILE") { current_export.hint=PROPERTY_HINT_FILE; - tokenizer.advance(); + tokenizer->advance(); - if (tokenizer.get_token()==GDTokenizer::TK_COMMA) { + if (tokenizer->get_token()==GDTokenizer::TK_COMMA) { - tokenizer.advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_CONSTANT || tokenizer.get_token_constant().get_type()!=Variant::STRING) { + tokenizer->advance(); + if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type()!=Variant::STRING) { _set_error("Expected string constant with filter"); return; } - current_export.hint_string=tokenizer.get_token_constant(); - tokenizer.advance(); + current_export.hint_string=tokenizer->get_token_constant(); + tokenizer->advance(); } - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { _set_error("Expected ')' in hint."); return; } @@ -2154,14 +2154,14 @@ void GDParser::_parse_class(ClassNode *p_class) { } break; case Variant::COLOR: { - if (tokenizer.get_token()!=GDTokenizer::TK_IDENTIFIER ) { + if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER ) { current_export=PropertyInfo(); _set_error("Color type hint expects RGB or RGBA as hints"); return; } - String identifier = tokenizer.get_token_identifier(); + String identifier = tokenizer->get_token_identifier(); if (identifier=="RGB") { current_export.hint=PROPERTY_HINT_COLOR_NO_ALPHA; } else if (identifier=="RGBA") { @@ -2171,7 +2171,7 @@ void GDParser::_parse_class(ClassNode *p_class) { _set_error("Color type hint expects RGB or RGBA as hints"); return; } - tokenizer.advance(); + tokenizer->advance(); } break; default: { @@ -2184,9 +2184,9 @@ void GDParser::_parse_class(ClassNode *p_class) { } - } else if (tokenizer.get_token()==GDTokenizer::TK_IDENTIFIER) { + } else if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER) { - String identifier = tokenizer.get_token_identifier(); + String identifier = tokenizer->get_token_identifier(); if (!ObjectTypeDB::is_type(identifier,"Resource")) { current_export=PropertyInfo(); @@ -2197,10 +2197,10 @@ void GDParser::_parse_class(ClassNode *p_class) { current_export.hint=PROPERTY_HINT_RESOURCE_TYPE; current_export.hint_string=identifier; - tokenizer.advance(); + tokenizer->advance(); } - if (tokenizer.get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { + if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) { current_export=PropertyInfo(); _set_error("Expected ')' or ',' after export hint."); @@ -2208,11 +2208,11 @@ void GDParser::_parse_class(ClassNode *p_class) { } - tokenizer.advance(); + tokenizer->advance(); } - if (tokenizer.get_token()!=GDTokenizer::TK_PR_VAR) { + if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) { current_export=PropertyInfo(); _set_error("Expected 'var'."); @@ -2224,26 +2224,26 @@ void GDParser::_parse_class(ClassNode *p_class) { //variale declaration and (eventual) initialization ClassNode::Member member; - bool autoexport = tokenizer.get_token(-1)==GDTokenizer::TK_PR_EXPORT; + bool autoexport = tokenizer->get_token(-1)==GDTokenizer::TK_PR_EXPORT; if (current_export.type!=Variant::NIL) { member._export=current_export; current_export=PropertyInfo(); } - tokenizer.advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_IDENTIFIER) { + tokenizer->advance(); + if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) { _set_error("Expected identifier for member variable name."); return; } - member.identifier=tokenizer.get_token_identifier(); + member.identifier=tokenizer->get_token_identifier(); member._export.name=member.identifier; - tokenizer.advance(); + tokenizer->advance(); p_class->variables.push_back(member); - if (tokenizer.get_token()!=GDTokenizer::TK_OP_ASSIGN) { + if (tokenizer->get_token()!=GDTokenizer::TK_OP_ASSIGN) { if (autoexport) { @@ -2253,9 +2253,9 @@ void GDParser::_parse_class(ClassNode *p_class) { break; } #ifdef DEBUG_ENABLED - int line = tokenizer.get_token_line(); + int line = tokenizer->get_token_line(); #endif - tokenizer.advance(); + tokenizer->advance(); Node *subexpr=NULL; @@ -2324,22 +2324,22 @@ void GDParser::_parse_class(ClassNode *p_class) { ClassNode::Constant constant; - tokenizer.advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_IDENTIFIER) { + tokenizer->advance(); + if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) { _set_error("Expected name (identifier) for constant."); return; } - constant.identifier=tokenizer.get_token_identifier(); - tokenizer.advance(); + constant.identifier=tokenizer->get_token_identifier(); + tokenizer->advance(); - if (tokenizer.get_token()!=GDTokenizer::TK_OP_ASSIGN) { + if (tokenizer->get_token()!=GDTokenizer::TK_OP_ASSIGN) { _set_error("Constant expects assignment."); return; } - tokenizer.advance(); + tokenizer->advance(); Node *subexpr=NULL; @@ -2362,7 +2362,7 @@ void GDParser::_parse_class(ClassNode *p_class) { default: { - _set_error(String()+"Unexpected token: "+tokenizer.get_token_name(tokenizer.get_token())+":"+tokenizer.get_token_identifier()); + _set_error(String()+"Unexpected token: "+tokenizer->get_token_name(tokenizer->get_token())+":"+tokenizer->get_token_identifier()); return; } break; @@ -2382,8 +2382,8 @@ void GDParser::_set_error(const String& p_error, int p_line, int p_column) { return; //allow no further errors error=p_error; - error_line=p_line<0?tokenizer.get_token_line():p_line; - error_column=p_column<0?tokenizer.get_token_column():p_column; + error_line=p_line<0?tokenizer->get_token_line():p_line; + error_column=p_column<0?tokenizer->get_token_column():p_column; error_set=true; } @@ -2402,12 +2402,11 @@ int GDParser::get_error_column() const { } -Error GDParser::parse(const String& p_code,const String& p_base_path) { +Error GDParser::_parse(const String& p_base_path) { + base_path=p_base_path; - tokenizer.set_code(p_code); - clear(); //assume class @@ -2416,9 +2415,9 @@ Error GDParser::parse(const String& p_code,const String& p_base_path) { _parse_class(main_class); - if (tokenizer.get_token()==GDTokenizer::TK_ERROR) { + if (tokenizer->get_token()==GDTokenizer::TK_ERROR) { error_set=false; - _set_error("Parse Error: "+tokenizer.get_token_error()); + _set_error("Parse Error: "+tokenizer->get_token_error()); } if (error_set) { @@ -2428,6 +2427,31 @@ Error GDParser::parse(const String& p_code,const String& p_base_path) { return OK; } +Error GDParser::parse_bytecode(const Vector &p_bytecode,const String& p_base_path) { + + GDTokenizerBuffer *tb = memnew( GDTokenizerBuffer ); + tb->set_code_buffer(p_bytecode); + tokenizer=tb; + Error ret = _parse(p_base_path); + memdelete(tb); + tokenizer=NULL; + return ret; +} + + +Error GDParser::parse(const String& p_code,const String& p_base_path) { + + + GDTokenizerText *tt = memnew( GDTokenizerText ); + tt->set_code(p_code); + + tokenizer=tt; + Error ret = _parse(p_base_path); + memdelete(tt); + tokenizer=NULL; + return ret; +} + const GDParser::Node *GDParser::get_parse_tree() const { return head; @@ -2459,6 +2483,7 @@ GDParser::GDParser() { head=NULL; list=NULL; + tokenizer=NULL; clear(); } diff --git a/modules/gdscript/gd_parser.h b/modules/gdscript/gd_parser.h index 80114953409..1925808cac5 100644 --- a/modules/gdscript/gd_parser.h +++ b/modules/gdscript/gd_parser.h @@ -343,10 +343,12 @@ public: ProgramNode() { type=TYPE_PROGRAM; } }; */ + + private: - GDTokenizer tokenizer; + GDTokenizer *tokenizer; Node *head; @@ -380,12 +382,15 @@ private: void _parse_class(ClassNode *p_class); bool _end_statement(); + Error _parse(const String& p_base_path); + public: String get_error() const; int get_error_line() const; int get_error_column() const; Error parse(const String& p_code,const String& p_base_path=""); + Error parse_bytecode(const Vector &p_bytecode,const String& p_base_path=""); const Node *get_parse_tree() const; diff --git a/modules/gdscript/gd_script.cpp b/modules/gdscript/gd_script.cpp index 5679e1e066b..29857e6be67 100644 --- a/modules/gdscript/gd_script.cpp +++ b/modules/gdscript/gd_script.cpp @@ -1416,7 +1416,7 @@ Error GDScript::reload() { String basedir=path; if (basedir=="") - basedir==get_path(); + basedir=get_path(); if (basedir!="") basedir=basedir.get_base_dir(); @@ -1560,6 +1560,49 @@ void GDScript::_bind_methods() { } + + +Error GDScript::load_byte_code(const String& p_path) { + + Vector bytecode = FileAccess::get_file_as_array(p_path); + ERR_FAIL_COND_V(bytecode.size()==0,ERR_PARSE_ERROR); + path=p_path; + + String basedir=path; + + if (basedir=="") + basedir=get_path(); + + if (basedir!="") + basedir=basedir.get_base_dir(); + + valid=false; + GDParser parser; + Error err = parser.parse_bytecode(bytecode,basedir); + if (err) { + _err_print_error("GDScript::load_byte_code",path.empty()?"built-in":(const char*)path.utf8().get_data(),parser.get_error_line(),("Parse Error: "+parser.get_error()).utf8().get_data()); + ERR_FAIL_V(ERR_PARSE_ERROR); + } + + GDCompiler compiler; + err = compiler.compile(&parser,this); + + if (err) { + _err_print_error("GDScript::load_byte_code",path.empty()?"built-in":(const char*)path.utf8().get_data(),compiler.get_error_line(),("Compile Error: "+compiler.get_error()).utf8().get_data()); + ERR_FAIL_V(ERR_COMPILATION_FAILED); + } + + valid=true; + + for(Map >::Element *E=subclasses.front();E;E=E->next()) { + + _set_subclass_path(E->get(),path); + } + + return OK; +} + + Error GDScript::load_source_code(const String& p_path) { @@ -2153,24 +2196,39 @@ RES ResourceFormatLoaderGDScript::load(const String &p_path,const String& p_orig Ref scriptres(script); - Error err = script->load_source_code(p_path); + if (p_path.ends_with(".gdc")) { - if (err!=OK) { + script->set_script_path(p_original_path); // script needs this. + script->set_path(p_original_path); + Error err = script->load_byte_code(p_path); - ERR_FAIL_COND_V(err!=OK, RES()); + + if (err!=OK) { + + ERR_FAIL_COND_V(err!=OK, RES()); + } + + } else { + Error err = script->load_source_code(p_path); + + if (err!=OK) { + + ERR_FAIL_COND_V(err!=OK, RES()); + } + + script->set_script_path(p_original_path); // script needs this. + script->set_path(p_original_path); + //script->set_name(p_path.get_file()); + + script->reload(); } - script->set_script_path(p_original_path); // script needs this. - script->set_path(p_original_path); - //script->set_name(p_path.get_file()); - - script->reload(); - return scriptres; } void ResourceFormatLoaderGDScript::get_recognized_extensions(List *p_extensions) const { p_extensions->push_back("gd"); + p_extensions->push_back("gdc"); } bool ResourceFormatLoaderGDScript::handles_type(const String& p_type) const { @@ -2180,7 +2238,8 @@ bool ResourceFormatLoaderGDScript::handles_type(const String& p_type) const { String ResourceFormatLoaderGDScript::get_resource_type(const String &p_path) const { - if (p_path.extension().to_lower()=="gd") + String el = p_path.extension().to_lower(); + if (el=="gd" || el=="gdc") return "GDScript"; return ""; } diff --git a/modules/gdscript/gd_script.h b/modules/gdscript/gd_script.h index 70dec4e8eec..55bc547e8da 100644 --- a/modules/gdscript/gd_script.h +++ b/modules/gdscript/gd_script.h @@ -261,6 +261,7 @@ public: virtual String get_node_type() const; void set_script_path(const String& p_path) { path=p_path; } //because subclasses need a path too... Error load_source_code(const String& p_path); + Error load_byte_code(const String& p_path); virtual ScriptLanguage *get_language() const; diff --git a/modules/gdscript/gd_tokenizer.cpp b/modules/gdscript/gd_tokenizer.cpp index f7320799a5b..ff9be7926b8 100644 --- a/modules/gdscript/gd_tokenizer.cpp +++ b/modules/gdscript/gd_tokenizer.cpp @@ -29,6 +29,9 @@ #include "gd_tokenizer.h" #include "print_string.h" #include "gd_functions.h" +#include "io/marshalls.h" +#include "map.h" + const char* GDTokenizer::token_names[TK_MAX]={ "Empty", "Identifier", @@ -128,7 +131,7 @@ static bool _is_hex(CharType c) { return (c>='0' && c<='9') || (c>='a' && c<='f') || (c>='A' && c<='F'); } -void GDTokenizer::_make_token(Token p_type) { +void GDTokenizerText::_make_token(Token p_type) { TokenData &tk=tk_rb[tk_rb_pos]; @@ -138,7 +141,7 @@ void GDTokenizer::_make_token(Token p_type) { tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE; } -void GDTokenizer::_make_identifier(const StringName& p_identifier) { +void GDTokenizerText::_make_identifier(const StringName& p_identifier) { TokenData &tk=tk_rb[tk_rb_pos]; @@ -151,7 +154,7 @@ void GDTokenizer::_make_identifier(const StringName& p_identifier) { } -void GDTokenizer::_make_built_in_func(GDFunctions::Function p_func) { +void GDTokenizerText::_make_built_in_func(GDFunctions::Function p_func) { TokenData &tk=tk_rb[tk_rb_pos]; @@ -163,7 +166,7 @@ void GDTokenizer::_make_built_in_func(GDFunctions::Function p_func) { tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE; } -void GDTokenizer::_make_constant(const Variant& p_constant) { +void GDTokenizerText::_make_constant(const Variant& p_constant) { TokenData &tk=tk_rb[tk_rb_pos]; @@ -176,7 +179,7 @@ void GDTokenizer::_make_constant(const Variant& p_constant) { } -void GDTokenizer::_make_type(const Variant::Type& p_type) { +void GDTokenizerText::_make_type(const Variant::Type& p_type) { TokenData &tk=tk_rb[tk_rb_pos]; @@ -191,7 +194,7 @@ void GDTokenizer::_make_type(const Variant::Type& p_type) { } -void GDTokenizer::_make_error(const String& p_error) { +void GDTokenizerText::_make_error(const String& p_error) { error_flag=true; last_error=p_error; @@ -206,7 +209,7 @@ void GDTokenizer::_make_error(const String& p_error) { } -void GDTokenizer::_make_newline(int p_spaces) { +void GDTokenizerText::_make_newline(int p_spaces) { TokenData &tk=tk_rb[tk_rb_pos]; tk.type=TK_NEWLINE; @@ -216,7 +219,7 @@ void GDTokenizer::_make_newline(int p_spaces) { tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE; } -void GDTokenizer::_advance() { +void GDTokenizerText::_advance() { if (error_flag) { //parser broke @@ -859,7 +862,7 @@ void GDTokenizer::_advance() { } -void GDTokenizer::set_code(const String& p_code) { +void GDTokenizerText::set_code(const String& p_code) { code=p_code; len = p_code.length(); @@ -878,7 +881,7 @@ void GDTokenizer::set_code(const String& p_code) { _advance(); } -GDTokenizer::Token GDTokenizer::get_token(int p_offset) const { +GDTokenizerText::Token GDTokenizerText::get_token(int p_offset) const { ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, TK_ERROR); ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, TK_ERROR); @@ -886,7 +889,7 @@ GDTokenizer::Token GDTokenizer::get_token(int p_offset) const { return tk_rb[ofs].type; } -int GDTokenizer::get_token_line(int p_offset) const { +int GDTokenizerText::get_token_line(int p_offset) const { ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, -1); ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, -1); @@ -894,7 +897,7 @@ int GDTokenizer::get_token_line(int p_offset) const { return tk_rb[ofs].line; } -int GDTokenizer::get_token_column(int p_offset) const { +int GDTokenizerText::get_token_column(int p_offset) const { ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, -1); ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, -1); @@ -902,7 +905,7 @@ int GDTokenizer::get_token_column(int p_offset) const { return tk_rb[ofs].col; } -const Variant& GDTokenizer::get_token_constant(int p_offset) const { +const Variant& GDTokenizerText::get_token_constant(int p_offset) const { ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, tk_rb[0].constant); ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, tk_rb[0].constant); @@ -910,7 +913,7 @@ const Variant& GDTokenizer::get_token_constant(int p_offset) const { ERR_FAIL_COND_V(tk_rb[ofs].type!=TK_CONSTANT,tk_rb[0].constant); return tk_rb[ofs].constant; } -StringName GDTokenizer::get_token_identifier(int p_offset) const { +StringName GDTokenizerText::get_token_identifier(int p_offset) const { ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, StringName()); ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, StringName()); @@ -921,7 +924,7 @@ StringName GDTokenizer::get_token_identifier(int p_offset) const { } -GDFunctions::Function GDTokenizer::get_token_built_in_func(int p_offset) const { +GDFunctions::Function GDTokenizerText::get_token_built_in_func(int p_offset) const { ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, GDFunctions::FUNC_MAX); ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, GDFunctions::FUNC_MAX); @@ -932,7 +935,7 @@ GDFunctions::Function GDTokenizer::get_token_built_in_func(int p_offset) const { } -Variant::Type GDTokenizer::get_token_type(int p_offset) const { +Variant::Type GDTokenizerText::get_token_type(int p_offset) const { ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, Variant::NIL); ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, Variant::NIL); @@ -944,7 +947,7 @@ Variant::Type GDTokenizer::get_token_type(int p_offset) const { } -int GDTokenizer::get_token_line_indent(int p_offset) const { +int GDTokenizerText::get_token_line_indent(int p_offset) const { ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, 0); ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, 0); @@ -955,7 +958,7 @@ int GDTokenizer::get_token_line_indent(int p_offset) const { } -String GDTokenizer::get_token_error(int p_offset) const { +String GDTokenizerText::get_token_error(int p_offset) const { ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, String()); ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, String()); @@ -965,9 +968,377 @@ String GDTokenizer::get_token_error(int p_offset) const { return tk_rb[ofs].constant; } -void GDTokenizer::advance(int p_amount) { +void GDTokenizerText::advance(int p_amount) { ERR_FAIL_COND( p_amount <=0 ); for(int i=0;i & p_buffer) { + + + const uint8_t *buf=p_buffer.ptr(); + int total_len=p_buffer.size(); + ERR_FAIL_COND_V( p_buffer.size()<24 || p_buffer[0]!='G' || p_buffer[1]!='D' || p_buffer[2]!='S' || p_buffer[3]!='C',ERR_INVALID_DATA); + + int version = decode_uint32(&buf[4]); + if (version>1) { + ERR_EXPLAIN("Bytecode is too New!"); + ERR_FAIL_COND_V(version>BYTECODE_VERSION,ERR_INVALID_DATA); + } + int identifier_count = decode_uint32(&buf[8]); + int constant_count = decode_uint32(&buf[12]); + int line_count = decode_uint32(&buf[16]); + int token_count = decode_uint32(&buf[20]); + + const uint8_t *b=buf; + + b=&buf[24]; + total_len-=24; + + identifiers.resize(identifier_count); + for(int i=0;itotal_len,ERR_INVALID_DATA); + b+=4; + Vector cs; + cs.resize(len); + for(int j=0;jtotal_len,ERR_INVALID_DATA); + + for(int i=0;i GDTokenizerBuffer::parse_code_string(const String& p_code) { + + Vector buf; + + + Map identifier_map; + HashMap constant_map; + Map line_map; + Vector token_array; + + GDTokenizerText tt; + tt.set_code(p_code); + int line=-1; + int col=0; + + while(true) { + + if (tt.get_token_line()!=line) { + + line=tt.get_token_line(); + line_map[line]=token_array.size(); + } + + uint32_t token=tt.get_token(); + switch(tt.get_token()) { + + case TK_IDENTIFIER: { + StringName id = tt.get_token_identifier(); + if (!identifier_map.has(id)) { + int idx = identifier_map.size(); + identifier_map[id]=idx; + } + token|=identifier_map[id]<()); + } break; + default: {} + + }; + + token_array.push_back(token); + + if (tt.get_token()==TK_EOF) + break; + tt.advance(); + + } + + //reverse maps + + Map rev_identifier_map; + for(Map::Element *E=identifier_map.front();E;E=E->next()) { + rev_identifier_map[E->get()]=E->key(); + } + + Map rev_constant_map; + const Variant *K =NULL; + while((K=constant_map.next(K))) { + rev_constant_map[constant_map[*K]]=*K; + } + + Map rev_line_map; + for(Map::Element *E=line_map.front();E;E=E->next()) { + rev_line_map[E->get()]=E->key(); + } + + //save header + buf.resize(24); + buf[0]='G'; + buf[1]='D'; + buf[2]='S'; + buf[3]='C'; + encode_uint32(BYTECODE_VERSION,&buf[4]); + encode_uint32(identifier_map.size(),&buf[8]); + encode_uint32(constant_map.size(),&buf[12]); + encode_uint32(line_map.size(),&buf[16]); + encode_uint32(token_array.size(),&buf[20]); + + //save identifiers + + for(Map::Element *E=rev_identifier_map.front();E;E=E->next()) { + + CharString cs = String(E->get()).utf8(); + int len = cs.length()+1; + int extra = 4-(len%4); + if (extra==4) + extra=0; + + uint8_t ibuf[4]; + encode_uint32(len+extra,ibuf); + for(int i=0;i<4;i++) { + buf.push_back(ibuf[i]); + } + for(int i=0;i::Element *E=rev_constant_map.front();E;E=E->next()) { + + int len; + Error err = encode_variant(E->get(),NULL,len); + ERR_FAIL_COND_V(err!=OK,Vector()); + int pos=buf.size(); + buf.resize(pos+len); + encode_variant(E->get(),&buf[pos],len); + } + + for(Map::Element *E=rev_line_map.front();E;E=E->next()) { + + uint8_t ibuf[8]; + encode_uint32(E->key(),&ibuf[0]); + encode_uint32(E->get(),&ibuf[4]); + for(int i=0;i<8;i++) + buf.push_back(ibuf[i]); + } + + for(int i=0;i=tokens.size()) + return TK_EOF; + + return GDTokenizerBuffer::Token(tokens[offset]&TOKEN_MASK); +} + + +StringName GDTokenizerBuffer::get_token_identifier(int p_offset) const{ + + int offset = token+p_offset; + + ERR_FAIL_INDEX_V(offset,tokens.size(),StringName()); + uint32_t identifier = tokens[offset]>>TOKEN_BITS; + ERR_FAIL_INDEX_V(identifier,identifiers.size(),StringName()); + + return identifiers[identifier]; +} + +GDFunctions::Function GDTokenizerBuffer::get_token_built_in_func(int p_offset) const{ + + int offset = token+p_offset; + ERR_FAIL_INDEX_V(offset,tokens.size(),GDFunctions::FUNC_MAX); + return GDFunctions::Function(tokens[offset]>>TOKEN_BITS); +} + +Variant::Type GDTokenizerBuffer::get_token_type(int p_offset) const{ + + int offset = token+p_offset; + ERR_FAIL_INDEX_V(offset,tokens.size(),Variant::NIL); + + return Variant::Type(tokens[offset]>>TOKEN_BITS); +} + +int GDTokenizerBuffer::get_token_line(int p_offset) const{ + + int offset = token+p_offset; + int pos = lines.find_nearest(offset); + + if (pos<0) + return -1; + if (pos>=lines.size()) + pos=lines.size()-1; + + uint32_t l = lines.getv(pos); + return l&TOKEN_LINE_MASK; + +} +int GDTokenizerBuffer::get_token_column(int p_offset) const{ + + int offset = token+p_offset; + int pos = lines.find_nearest(offset); + if (pos<0) + return -1; + if (pos>=lines.size()) + pos=lines.size()-1; + + uint32_t l = lines.getv(pos); + return l>>TOKEN_LINE_BITS; + +} +int GDTokenizerBuffer::get_token_line_indent(int p_offset) const{ + + int offset = token+p_offset; + ERR_FAIL_INDEX_V(offset,tokens.size(),0); + return tokens[offset]>>TOKEN_BITS; +} +const Variant& GDTokenizerBuffer::get_token_constant(int p_offset) const{ + + + int offset = token+p_offset; + ERR_FAIL_INDEX_V(offset,tokens.size(),nil); + uint32_t constant = tokens[offset]>>TOKEN_BITS; + ERR_FAIL_INDEX_V(constant,constants.size(),nil); + return constants[constant]; + +} +String GDTokenizerBuffer::get_token_error(int p_offset) const{ + + ERR_FAIL_V(String()); +} + +void GDTokenizerBuffer::advance(int p_amount){ + + ERR_FAIL_INDEX(p_amount+token,tokens.size()); + token+=p_amount; +} +GDTokenizerBuffer::GDTokenizerBuffer(){ + + token=0; + +} + diff --git a/modules/gdscript/gd_tokenizer.h b/modules/gdscript/gd_tokenizer.h index 24ee2be7ad4..c517e07b898 100644 --- a/modules/gdscript/gd_tokenizer.h +++ b/modules/gdscript/gd_tokenizer.h @@ -33,6 +33,8 @@ #include "variant.h" #include "string_db.h" #include "gd_functions.h" +#include "vmap.h" + class GDTokenizer { public: @@ -117,11 +119,28 @@ public: TK_MAX }; - - -private: - +protected: static const char* token_names[TK_MAX]; +public: + static const char *get_token_name(Token p_token); + + virtual const Variant& get_token_constant(int p_offset=0) const=0; + virtual Token get_token(int p_offset=0) const=0; + virtual StringName get_token_identifier(int p_offset=0) const=0; + virtual GDFunctions::Function get_token_built_in_func(int p_offset=0) const=0; + virtual Variant::Type get_token_type(int p_offset=0) const=0; + virtual int get_token_line(int p_offset=0) const=0; + virtual int get_token_column(int p_offset=0) const=0; + virtual int get_token_line_indent(int p_offset=0) const=0; + virtual String get_token_error(int p_offset=0) const=0; + virtual void advance(int p_amount=1)=0; + + virtual ~GDTokenizer(){}; + +}; + +class GDTokenizerText : public GDTokenizer { + enum { MAX_LOOKAHEAD=4, TK_RB_SIZE=MAX_LOOKAHEAD*2+1 @@ -162,20 +181,59 @@ private: void _advance(); public: - static const char *get_token_name(Token p_token); void set_code(const String& p_code); - Token get_token(int p_offset=0) const; - const Variant& get_token_constant(int p_offset=0) const; - StringName get_token_identifier(int p_offset=0) const; - GDFunctions::Function get_token_built_in_func(int p_offset=0) const; - Variant::Type get_token_type(int p_offset=0) const; - int get_token_line(int p_offset=0) const; - int get_token_column(int p_offset=0) const; - int get_token_line_indent(int p_offset=0) const; + virtual Token get_token(int p_offset=0) const; + virtual StringName get_token_identifier(int p_offset=0) const; + virtual GDFunctions::Function get_token_built_in_func(int p_offset=0) const; + virtual Variant::Type get_token_type(int p_offset=0) const; + virtual int get_token_line(int p_offset=0) const; + virtual int get_token_column(int p_offset=0) const; + virtual int get_token_line_indent(int p_offset=0) const; + virtual const Variant& get_token_constant(int p_offset=0) const; + virtual String get_token_error(int p_offset=0) const; + virtual void advance(int p_amount=1); +}; - String get_token_error(int p_offset=0) const; - void advance(int p_amount=1); + + + +class GDTokenizerBuffer : public GDTokenizer { + + + enum { + + TOKEN_BYTE_MASK=0x80, + TOKEN_BITS=8, + TOKEN_MASK=(1< identifiers; + Vector constants; + VMap lines; + Vector tokens; + Variant nil; + int token; + +public: + + + Error set_code_buffer(const Vector & p_buffer); + static Vector parse_code_string(const String& p_code); + virtual Token get_token(int p_offset=0) const; + virtual StringName get_token_identifier(int p_offset=0) const; + virtual GDFunctions::Function get_token_built_in_func(int p_offset=0) const; + virtual Variant::Type get_token_type(int p_offset=0) const; + virtual int get_token_line(int p_offset=0) const; + virtual int get_token_column(int p_offset=0) const; + virtual int get_token_line_indent(int p_offset=0) const; + virtual const Variant& get_token_constant(int p_offset=0) const; + virtual String get_token_error(int p_offset=0) const; + virtual void advance(int p_amount=1); + GDTokenizerBuffer(); }; #endif // TOKENIZER_H diff --git a/modules/gdscript/register_types.cpp b/modules/gdscript/register_types.cpp index d2d7bf426ab..6bcd12857b4 100644 --- a/modules/gdscript/register_types.cpp +++ b/modules/gdscript/register_types.cpp @@ -13,11 +13,60 @@ #include "gd_script.h" #include "io/resource_loader.h" +#include "os/file_access.h" + GDScriptLanguage *script_language_gd=NULL; ResourceFormatLoaderGDScript *resource_loader_gd=NULL; ResourceFormatSaverGDScript *resource_saver_gd=NULL; +#ifdef TOOLS_ENABLED + +#include "tools/editor/editor_import_export.h" +#include "gd_tokenizer.h" +#include "tools/editor/editor_node.h" + +class EditorExportGDScript : public EditorExportPlugin { + + OBJ_TYPE(EditorExportGDScript,EditorExportPlugin); + +public: + + virtual Vector custom_export(String& p_path,const Ref &p_platform) { + //compile gdscript to bytecode + if (p_path.ends_with(".gd")) { + Vector file = FileAccess::get_file_as_array(p_path); + if (file.empty()) + return file; + String txt; + txt.parse_utf8((const char*)file.ptr(),file.size()); + file = GDTokenizerBuffer::parse_code_string(txt); + if (!file.empty()) { + print_line("PREV: "+p_path); + p_path=p_path.basename()+".gdc"; + print_line("NOW: "+p_path); + return file; + } + + } + + return Vector(); + } + + + EditorExportGDScript(){} + +}; + +static void register_editor_plugin() { + + Ref egd = memnew( EditorExportGDScript ); + EditorImportExport::get_singleton()->add_export_plugin(egd); +} + + +#endif + void register_gdscript_types() { @@ -30,6 +79,11 @@ void register_gdscript_types() { resource_saver_gd=memnew( ResourceFormatSaverGDScript ); ResourceSaver::add_resource_format_saver(resource_saver_gd); +#ifdef TOOLS_ENABLED + + EditorNode::add_init_callback(register_editor_plugin); +#endif + } void unregister_gdscript_types() { @@ -43,4 +97,4 @@ void unregister_gdscript_types() { if (resource_saver_gd) memdelete( resource_saver_gd ); -} \ No newline at end of file +} diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp index a3917f729c6..b9e44d50530 100644 --- a/scene/2d/tile_map.cpp +++ b/scene/2d/tile_map.cpp @@ -585,8 +585,8 @@ TileMap::TileMap() { center_x=false; center_y=false; - fp_adjust=0.1; - fp_adjust=0.1; + fp_adjust=0.4; + fp_adjust=0.4; } TileMap::~TileMap() { diff --git a/tools/editor/editor_node.cpp b/tools/editor/editor_node.cpp index ae350e3b998..2f7b6759b94 100644 --- a/tools/editor/editor_node.cpp +++ b/tools/editor/editor_node.cpp @@ -3058,6 +3058,12 @@ void EditorNode::register_editor_types() { // ObjectTypeDB::register_type(); } +void EditorNode::unregister_editor_types() { + + _init_callbacks.clear(); +} + + void EditorNode::stop_child_process() { _menu_option_confirm(RUN_STOP,false); @@ -3193,6 +3199,7 @@ void EditorNode::_file_dialog_unregister(FileDialog *p_dialog){ singleton->file_dialogs.erase(p_dialog); } +Vector EditorNode::_init_callbacks; Error EditorNode::export_platform(const String& p_platform, const String& p_path, bool p_debug,const String& p_password,bool p_quit_after) { @@ -4155,6 +4162,8 @@ EditorNode::EditorNode() { // Ref it = gui_base->get_icon("logo","Icons"); // OS::get_singleton()->set_icon( it->get_data() ); + for(int i=0;i<_init_callbacks.size();i++) + _init_callbacks[i](); } diff --git a/tools/editor/editor_node.h b/tools/editor/editor_node.h index 30504aa08e9..87f17247c3d 100644 --- a/tools/editor/editor_node.h +++ b/tools/editor/editor_node.h @@ -91,6 +91,9 @@ + +typedef void (*EditorNodeInitCallback)(); + class EditorNode : public Node { OBJ_TYPE( EditorNode, Node ); @@ -393,6 +396,8 @@ class EditorNode : public Node { static EditorNode *singleton; + static Vector _init_callbacks; + protected: void _notification(int p_what); static void _bind_methods(); @@ -463,6 +468,7 @@ public: Error export_platform(const String& p_platform, const String& p_path, bool p_debug,const String& p_password,bool p_quit_after=false); static void register_editor_types(); + static void unregister_editor_types(); Control *get_gui_base() { return gui_base; } @@ -481,6 +487,8 @@ public: ~EditorNode(); void get_singleton(const char* arg1, bool arg2); + static void add_init_callback(EditorNodeInitCallback p_callback) { _init_callbacks.push_back(p_callback); } + }; diff --git a/tools/editor/editor_settings.cpp b/tools/editor/editor_settings.cpp index 53b5a8a47da..09d55650c86 100644 --- a/tools/editor/editor_settings.cpp +++ b/tools/editor/editor_settings.cpp @@ -413,7 +413,7 @@ void EditorSettings::_load_defaults() { set("on_save/compress_binary_resources",true); set("on_save/save_modified_external_resources",true); set("on_save/save_paths_as_relative",false); - set("on_save/save_paths_without_extension",true); + set("on_save/save_paths_without_extension",false); set("text_editor/create_signal_callbacks",true); diff --git a/tools/editor/io_plugins/editor_font_import_plugin.cpp b/tools/editor/io_plugins/editor_font_import_plugin.cpp index 7c38b105fdf..4de68c7f4ca 100644 --- a/tools/editor/io_plugins/editor_font_import_plugin.cpp +++ b/tools/editor/io_plugins/editor_font_import_plugin.cpp @@ -884,15 +884,20 @@ Ref EditorFontImportPlugin::generate_font(const Refcharacter>512) + continue; for(int j=0;jcharacter>512) + continue; + FT_Vector delta; FT_Get_Kerning( face, font_data_list[i]->glyph,font_data_list[j]->glyph, FT_KERNING_DEFAULT, &delta );