diff options
Diffstat (limited to 'modules/gdscript/gd_compiler.cpp')
| -rw-r--r-- | modules/gdscript/gd_compiler.cpp | 1303 |
1 files changed, 618 insertions, 685 deletions
diff --git a/modules/gdscript/gd_compiler.cpp b/modules/gdscript/gd_compiler.cpp index 398c2cf82a..9591740438 100644 --- a/modules/gdscript/gd_compiler.cpp +++ b/modules/gdscript/gd_compiler.cpp @@ -29,53 +29,51 @@ #include "gd_compiler.h" #include "gd_script.h" -bool GDCompiler::_is_class_member_property(CodeGen & codegen, const StringName & p_name) { +bool GDCompiler::_is_class_member_property(CodeGen &codegen, const StringName &p_name) { if (!codegen.function_node || codegen.function_node->_static) return false; - return _is_class_member_property(codegen.script,p_name); + return _is_class_member_property(codegen.script, p_name); } -bool GDCompiler::_is_class_member_property(GDScript *owner, const StringName & p_name) { - +bool GDCompiler::_is_class_member_property(GDScript *owner, const StringName &p_name) { GDScript *scr = owner; - GDNativeClass *nc=NULL; - while(scr) { + GDNativeClass *nc = NULL; + while (scr) { if (scr->native.is_valid()) - nc=scr->native.ptr(); - scr=scr->_base; + nc = scr->native.ptr(); + scr = scr->_base; } - ERR_FAIL_COND_V(!nc,false); + ERR_FAIL_COND_V(!nc, false); - return ClassDB::has_property(nc->get_name(),p_name); + return ClassDB::has_property(nc->get_name(), p_name); } +void GDCompiler::_set_error(const String &p_error, const GDParser::Node *p_node) { -void GDCompiler::_set_error(const String& p_error,const GDParser::Node *p_node) { - - if (error!="") + if (error != "") return; - error=p_error; + error = p_error; if (p_node) { - err_line=p_node->line; - err_column=p_node->column; + err_line = p_node->line; + err_column = p_node->column; } else { - err_line=0; - err_column=0; + err_line = 0; + err_column = 0; } } -bool GDCompiler::_create_unary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level) { +bool GDCompiler::_create_unary_operator(CodeGen &codegen, const GDParser::OperatorNode *on, Variant::Operator op, int p_stack_level) { - ERR_FAIL_COND_V(on->arguments.size()!=1,false); + ERR_FAIL_COND_V(on->arguments.size() != 1, false); - int src_address_a = _parse_expression(codegen,on->arguments[0],p_stack_level); - if (src_address_a<0) + int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level); + if (src_address_a < 0) return false; codegen.opcodes.push_back(GDFunction::OPCODE_OPERATOR); // perform operator @@ -86,22 +84,20 @@ bool GDCompiler::_create_unary_operator(CodeGen& codegen,const GDParser::Operato return true; } -bool GDCompiler::_create_binary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level,bool p_initializer) { - - ERR_FAIL_COND_V(on->arguments.size()!=2,false); +bool GDCompiler::_create_binary_operator(CodeGen &codegen, const GDParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer) { + ERR_FAIL_COND_V(on->arguments.size() != 2, false); - int src_address_a = _parse_expression(codegen,on->arguments[0],p_stack_level,false,p_initializer); - if (src_address_a<0) + int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level, false, p_initializer); + if (src_address_a < 0) return false; - if (src_address_a&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) + if (src_address_a & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) p_stack_level++; //uses stack for return, increase stack - int src_address_b = _parse_expression(codegen,on->arguments[1],p_stack_level,false,p_initializer); - if (src_address_b<0) + int src_address_b = _parse_expression(codegen, on->arguments[1], p_stack_level, false, p_initializer); + if (src_address_b < 0) return false; - codegen.opcodes.push_back(GDFunction::OPCODE_OPERATOR); // perform operator codegen.opcodes.push_back(op); //which operator codegen.opcodes.push_back(src_address_a); // argument 1 @@ -109,7 +105,6 @@ bool GDCompiler::_create_binary_operator(CodeGen& codegen,const GDParser::Operat return true; } - /* int GDCompiler::_parse_subexpression(CodeGen& codegen,const GDParser::Node *p_expression) { @@ -128,55 +123,52 @@ int GDCompiler::_parse_subexpression(CodeGen& codegen,const GDParser::Node *p_ex } */ -int GDCompiler::_parse_assign_right_expression(CodeGen& codegen,const GDParser::OperatorNode *p_expression, int p_stack_level) { +int GDCompiler::_parse_assign_right_expression(CodeGen &codegen, const GDParser::OperatorNode *p_expression, int p_stack_level) { - Variant::Operator var_op=Variant::OP_MAX; + Variant::Operator var_op = Variant::OP_MAX; + switch (p_expression->op) { - switch(p_expression->op) { - - case GDParser::OperatorNode::OP_ASSIGN_ADD: var_op=Variant::OP_ADD; break; - case GDParser::OperatorNode::OP_ASSIGN_SUB: var_op=Variant::OP_SUBSTRACT; break; - case GDParser::OperatorNode::OP_ASSIGN_MUL: var_op=Variant::OP_MULTIPLY; break; - case GDParser::OperatorNode::OP_ASSIGN_DIV: var_op=Variant::OP_DIVIDE; break; - case GDParser::OperatorNode::OP_ASSIGN_MOD: var_op=Variant::OP_MODULE; break; - case GDParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT: var_op=Variant::OP_SHIFT_LEFT; break; - case GDParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT: var_op=Variant::OP_SHIFT_RIGHT; break; - case GDParser::OperatorNode::OP_ASSIGN_BIT_AND: var_op=Variant::OP_BIT_AND; break; - case GDParser::OperatorNode::OP_ASSIGN_BIT_OR: var_op=Variant::OP_BIT_OR; break; - case GDParser::OperatorNode::OP_ASSIGN_BIT_XOR: var_op=Variant::OP_BIT_XOR; break; + case GDParser::OperatorNode::OP_ASSIGN_ADD: var_op = Variant::OP_ADD; break; + case GDParser::OperatorNode::OP_ASSIGN_SUB: var_op = Variant::OP_SUBSTRACT; break; + case GDParser::OperatorNode::OP_ASSIGN_MUL: var_op = Variant::OP_MULTIPLY; break; + case GDParser::OperatorNode::OP_ASSIGN_DIV: var_op = Variant::OP_DIVIDE; break; + case GDParser::OperatorNode::OP_ASSIGN_MOD: var_op = Variant::OP_MODULE; break; + case GDParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT: var_op = Variant::OP_SHIFT_LEFT; break; + case GDParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT: var_op = Variant::OP_SHIFT_RIGHT; break; + case GDParser::OperatorNode::OP_ASSIGN_BIT_AND: var_op = Variant::OP_BIT_AND; break; + case GDParser::OperatorNode::OP_ASSIGN_BIT_OR: var_op = Variant::OP_BIT_OR; break; + case GDParser::OperatorNode::OP_ASSIGN_BIT_XOR: var_op = Variant::OP_BIT_XOR; break; case GDParser::OperatorNode::OP_INIT_ASSIGN: case GDParser::OperatorNode::OP_ASSIGN: { //none } break; - default: { + default: { ERR_FAIL_V(-1); } } - bool initializer = p_expression->op==GDParser::OperatorNode::OP_INIT_ASSIGN; + bool initializer = p_expression->op == GDParser::OperatorNode::OP_INIT_ASSIGN; - if (var_op==Variant::OP_MAX) { + if (var_op == Variant::OP_MAX) { - return _parse_expression(codegen,p_expression->arguments[1],p_stack_level,false,initializer); + return _parse_expression(codegen, p_expression->arguments[1], p_stack_level, false, initializer); } - if (!_create_binary_operator(codegen,p_expression,var_op,p_stack_level,initializer)) + if (!_create_binary_operator(codegen, p_expression, var_op, p_stack_level, initializer)) return -1; - int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode codegen.alloc_stack(p_stack_level); return dst_addr; - } -int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expression, int p_stack_level,bool p_root,bool p_initializer) { +int GDCompiler::_parse_expression(CodeGen &codegen, const GDParser::Node *p_expression, int p_stack_level, bool p_root, bool p_initializer) { - - switch(p_expression->type) { + switch (p_expression->type) { //should parse variable declaration and adjust stack accordingly... case GDParser::Node::TYPE_IDENTIFIER: { //return identifier @@ -185,16 +177,15 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre //This could be made much simpler by just indexing "self", but done this way (with custom self-addressing modes) increases peformance a lot. - const GDParser::IdentifierNode *in = static_cast<const GDParser::IdentifierNode*>(p_expression); + const GDParser::IdentifierNode *in = static_cast<const GDParser::IdentifierNode *>(p_expression); StringName identifier = in->name; - - if (_is_class_member_property(codegen,identifier)) { + if (_is_class_member_property(codegen, identifier)) { //get property codegen.opcodes.push_back(GDFunction::OPCODE_GET_MEMBER); // perform operator codegen.opcodes.push_back(codegen.get_name_map_pos(identifier)); // argument 2 (unary only takes one parameter) - int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode codegen.alloc_stack(p_stack_level); return dst_addr; @@ -204,8 +195,7 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre if (!p_initializer && codegen.stack_identifiers.has(identifier)) { int pos = codegen.stack_identifiers[identifier]; - return pos|(GDFunction::ADDR_TYPE_STACK_VARIABLE<<GDFunction::ADDR_BITS); - + return pos | (GDFunction::ADDR_TYPE_STACK_VARIABLE << GDFunction::ADDR_BITS); } //TRY MEMBERS! if (!codegen.function_node || !codegen.function_node->_static) { @@ -215,7 +205,7 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre if (codegen.script->member_indices.has(identifier)) { int idx = codegen.script->member_indices[identifier].index; - return idx|(GDFunction::ADDR_TYPE_MEMBER<<GDFunction::ADDR_BITS); //argument (stack root) + return idx | (GDFunction::ADDR_TYPE_MEMBER << GDFunction::ADDR_BITS); //argument (stack root) } } @@ -225,45 +215,44 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre while (owner) { GDScript *scr = owner; - GDNativeClass *nc=NULL; - while(scr) { + GDNativeClass *nc = NULL; + while (scr) { if (scr->constants.has(identifier)) { //int idx=scr->constants[identifier]; int idx = codegen.get_name_map_pos(identifier); - return idx|(GDFunction::ADDR_TYPE_CLASS_CONSTANT<<GDFunction::ADDR_BITS); //argument (stack root) + return idx | (GDFunction::ADDR_TYPE_CLASS_CONSTANT << GDFunction::ADDR_BITS); //argument (stack root) } if (scr->native.is_valid()) - nc=scr->native.ptr(); - scr=scr->_base; + nc = scr->native.ptr(); + scr = scr->_base; } // CLASS C++ Integer Constant if (nc) { - bool success=false; - int constant = ClassDB::get_integer_constant(nc->get_name(),identifier,&success); + bool success = false; + int constant = ClassDB::get_integer_constant(nc->get_name(), identifier, &success); if (success) { - Variant key=constant; + Variant key = constant; int idx; if (!codegen.constant_map.has(key)) { - idx=codegen.constant_map.size(); - codegen.constant_map[key]=idx; + idx = codegen.constant_map.size(); + codegen.constant_map[key] = idx; } else { - idx=codegen.constant_map[key]; + idx = codegen.constant_map[key]; } - return idx|(GDFunction::ADDR_TYPE_LOCAL_CONSTANT<<GDFunction::ADDR_BITS); //make it a local constant (faster access) + return idx | (GDFunction::ADDR_TYPE_LOCAL_CONSTANT << GDFunction::ADDR_BITS); //make it a local constant (faster access) } - } - owner=owner->_owner; + owner = owner->_owner; } /* @@ -278,58 +267,55 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) { int idx = GDScriptLanguage::get_singleton()->get_global_map()[identifier]; - return idx|(GDFunction::ADDR_TYPE_GLOBAL<<GDFunction::ADDR_BITS); //argument (stack root) + return idx | (GDFunction::ADDR_TYPE_GLOBAL << GDFunction::ADDR_BITS); //argument (stack root) } //not found, error - _set_error("Identifier not found: "+String(identifier),p_expression); + _set_error("Identifier not found: " + String(identifier), p_expression); return -1; - } break; case GDParser::Node::TYPE_CONSTANT: { //return constant - const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode*>(p_expression); - + const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode *>(p_expression); int idx; if (!codegen.constant_map.has(cn->value)) { - idx=codegen.constant_map.size(); - codegen.constant_map[cn->value]=idx; + idx = codegen.constant_map.size(); + codegen.constant_map[cn->value] = idx; } else { - idx=codegen.constant_map[cn->value]; + idx = codegen.constant_map[cn->value]; } - - return idx|(GDFunction::ADDR_TYPE_LOCAL_CONSTANT<<GDFunction::ADDR_BITS); //argument (stack root) + return idx | (GDFunction::ADDR_TYPE_LOCAL_CONSTANT << GDFunction::ADDR_BITS); //argument (stack root) } break; case GDParser::Node::TYPE_SELF: { //return constant if (codegen.function_node && codegen.function_node->_static) { - _set_error("'self' not present in static function!",p_expression); + _set_error("'self' not present in static function!", p_expression); return -1; } - return (GDFunction::ADDR_TYPE_SELF<<GDFunction::ADDR_BITS); + return (GDFunction::ADDR_TYPE_SELF << GDFunction::ADDR_BITS); } break; case GDParser::Node::TYPE_ARRAY: { - const GDParser::ArrayNode *an = static_cast<const GDParser::ArrayNode*>(p_expression); + const GDParser::ArrayNode *an = static_cast<const GDParser::ArrayNode *>(p_expression); Vector<int> values; - int slevel=p_stack_level; + int slevel = p_stack_level; - for(int i=0;i<an->elements.size();i++) { + for (int i = 0; i < an->elements.size(); i++) { - int ret = _parse_expression(codegen,an->elements[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, an->elements[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } @@ -339,10 +325,10 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre codegen.opcodes.push_back(GDFunction::OPCODE_CONSTRUCT_ARRAY); codegen.opcodes.push_back(values.size()); - for(int i=0;i<values.size();i++) + for (int i = 0; i < values.size(); i++) codegen.opcodes.push_back(values[i]); - int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode codegen.alloc_stack(p_stack_level); return dst_addr; @@ -350,27 +336,27 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre } break; case GDParser::Node::TYPE_DICTIONARY: { - const GDParser::DictionaryNode *dn = static_cast<const GDParser::DictionaryNode*>(p_expression); + const GDParser::DictionaryNode *dn = static_cast<const GDParser::DictionaryNode *>(p_expression); Vector<int> values; - int slevel=p_stack_level; + int slevel = p_stack_level; - for(int i=0;i<dn->elements.size();i++) { + for (int i = 0; i < dn->elements.size(); i++) { - int ret = _parse_expression(codegen,dn->elements[i].key,slevel); - if (ret<0) + int ret = _parse_expression(codegen, dn->elements[i].key, slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } values.push_back(ret); - ret = _parse_expression(codegen,dn->elements[i].value,slevel); - if (ret<0) + ret = _parse_expression(codegen, dn->elements[i].value, slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } @@ -380,10 +366,10 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre codegen.opcodes.push_back(GDFunction::OPCODE_CONSTRUCT_DICTIONARY); codegen.opcodes.push_back(dn->elements.size()); - for(int i=0;i<values.size();i++) + for (int i = 0; i < values.size(); i++) codegen.opcodes.push_back(values[i]); - int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode codegen.alloc_stack(p_stack_level); return dst_addr; @@ -392,27 +378,24 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre case GDParser::Node::TYPE_OPERATOR: { //hell breaks loose - const GDParser::OperatorNode *on = static_cast<const GDParser::OperatorNode*>(p_expression); - switch(on->op) { - + const GDParser::OperatorNode *on = static_cast<const GDParser::OperatorNode *>(p_expression); + switch (on->op) { //call/constructor operator case GDParser::OperatorNode::OP_PARENT_CALL: { - - ERR_FAIL_COND_V(on->arguments.size()<1,-1); + ERR_FAIL_COND_V(on->arguments.size() < 1, -1); const GDParser::IdentifierNode *in = (const GDParser::IdentifierNode *)on->arguments[0]; - Vector<int> arguments; int slevel = p_stack_level; - for(int i=1;i<on->arguments.size();i++) { + for (int i = 1; i < on->arguments.size(); i++) { - int ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } @@ -425,27 +408,27 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre codegen.opcodes.push_back(codegen.get_name_map_pos(in->name)); //instance codegen.opcodes.push_back(arguments.size()); //argument count codegen.alloc_call(arguments.size()); - for(int i=0;i<arguments.size();i++) + for (int i = 0; i < arguments.size(); i++) codegen.opcodes.push_back(arguments[i]); //arguments } break; case GDParser::OperatorNode::OP_CALL: { - if (on->arguments[0]->type==GDParser::Node::TYPE_TYPE) { + if (on->arguments[0]->type == GDParser::Node::TYPE_TYPE) { //construct a basic type - ERR_FAIL_COND_V(on->arguments.size()<1,-1); + ERR_FAIL_COND_V(on->arguments.size() < 1, -1); const GDParser::TypeNode *tn = (const GDParser::TypeNode *)on->arguments[0]; int vtype = tn->vtype; Vector<int> arguments; int slevel = p_stack_level; - for(int i=1;i<on->arguments.size();i++) { + for (int i = 1; i < on->arguments.size(); i++) { - int ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } @@ -457,24 +440,23 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre codegen.opcodes.push_back(vtype); //instance codegen.opcodes.push_back(arguments.size()); //argument count codegen.alloc_call(arguments.size()); - for(int i=0;i<arguments.size();i++) + for (int i = 0; i < arguments.size(); i++) codegen.opcodes.push_back(arguments[i]); //arguments - } else if (on->arguments[0]->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) { + } else if (on->arguments[0]->type == GDParser::Node::TYPE_BUILT_IN_FUNCTION) { //built in function - ERR_FAIL_COND_V(on->arguments.size()<1,-1); - + ERR_FAIL_COND_V(on->arguments.size() < 1, -1); Vector<int> arguments; int slevel = p_stack_level; - for(int i=1;i<on->arguments.size();i++) { + for (int i = 1; i < on->arguments.size(); i++) { - int ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } @@ -482,79 +464,74 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre arguments.push_back(ret); } - codegen.opcodes.push_back(GDFunction::OPCODE_CALL_BUILT_IN); - codegen.opcodes.push_back(static_cast<const GDParser::BuiltInFunctionNode*>(on->arguments[0])->function); - codegen.opcodes.push_back(on->arguments.size()-1); - codegen.alloc_call(on->arguments.size()-1); - for(int i=0;i<arguments.size();i++) + codegen.opcodes.push_back(static_cast<const GDParser::BuiltInFunctionNode *>(on->arguments[0])->function); + codegen.opcodes.push_back(on->arguments.size() - 1); + codegen.alloc_call(on->arguments.size() - 1); + for (int i = 0; i < arguments.size(); i++) codegen.opcodes.push_back(arguments[i]); } else { //regular function - ERR_FAIL_COND_V(on->arguments.size()<2,-1); + ERR_FAIL_COND_V(on->arguments.size() < 2, -1); const GDParser::Node *instance = on->arguments[0]; - if (instance->type==GDParser::Node::TYPE_SELF) { + if (instance->type == GDParser::Node::TYPE_SELF) { //room for optimization - } - Vector<int> arguments; int slevel = p_stack_level; - for(int i=0;i<on->arguments.size();i++) { + for (int i = 0; i < on->arguments.size(); i++) { int ret; - if (i==0 && on->arguments[i]->type==GDParser::Node::TYPE_SELF && codegen.function_node && codegen.function_node->_static) { + if (i == 0 && on->arguments[i]->type == GDParser::Node::TYPE_SELF && codegen.function_node && codegen.function_node->_static) { //static call to self - ret=(GDFunction::ADDR_TYPE_CLASS<<GDFunction::ADDR_BITS); - } else if (i==1) { + ret = (GDFunction::ADDR_TYPE_CLASS << GDFunction::ADDR_BITS); + } else if (i == 1) { - if (on->arguments[i]->type!=GDParser::Node::TYPE_IDENTIFIER) { - _set_error("Attempt to call a non-identifier.",on); + if (on->arguments[i]->type != GDParser::Node::TYPE_IDENTIFIER) { + _set_error("Attempt to call a non-identifier.", on); return -1; } - GDParser::IdentifierNode *id = static_cast<GDParser::IdentifierNode*>(on->arguments[i]); - ret=codegen.get_name_map_pos(id->name); + GDParser::IdentifierNode *id = static_cast<GDParser::IdentifierNode *>(on->arguments[i]); + ret = codegen.get_name_map_pos(id->name); } else { - ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } } arguments.push_back(ret); - } - codegen.opcodes.push_back(p_root?GDFunction::OPCODE_CALL:GDFunction::OPCODE_CALL_RETURN); // perform operator - codegen.opcodes.push_back(on->arguments.size()-2); - codegen.alloc_call(on->arguments.size()-2); - for(int i=0;i<arguments.size();i++) + codegen.opcodes.push_back(p_root ? GDFunction::OPCODE_CALL : GDFunction::OPCODE_CALL_RETURN); // perform operator + codegen.opcodes.push_back(on->arguments.size() - 2); + codegen.alloc_call(on->arguments.size() - 2); + for (int i = 0; i < arguments.size(); i++) codegen.opcodes.push_back(arguments[i]); } } break; case GDParser::OperatorNode::OP_YIELD: { - - ERR_FAIL_COND_V(on->arguments.size() && on->arguments.size()!=2,-1); + ERR_FAIL_COND_V(on->arguments.size() && on->arguments.size() != 2, -1); Vector<int> arguments; int slevel = p_stack_level; - for(int i=0;i<on->arguments.size();i++) { + for (int i = 0; i < on->arguments.size(); i++) { - int ret = _parse_expression(codegen,on->arguments[i],slevel); - if (ret<0) + int ret = _parse_expression(codegen, on->arguments[i], slevel); + if (ret < 0) return ret; - if (ret&(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)) { + if (ret & (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS)) { slevel++; codegen.alloc_stack(slevel); } @@ -562,8 +539,8 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre } //push call bytecode - codegen.opcodes.push_back(arguments.size()==0?GDFunction::OPCODE_YIELD:GDFunction::OPCODE_YIELD_SIGNAL); // basic type constructor - for(int i=0;i<arguments.size();i++) + codegen.opcodes.push_back(arguments.size() == 0 ? GDFunction::OPCODE_YIELD : GDFunction::OPCODE_YIELD_SIGNAL); // basic type constructor + for (int i = 0; i < arguments.size(); i++) codegen.opcodes.push_back(arguments[i]); //arguments codegen.opcodes.push_back(GDFunction::OPCODE_YIELD_RESUME); //next will be where to place the result :) @@ -574,60 +551,60 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre case GDParser::OperatorNode::OP_INDEX: case GDParser::OperatorNode::OP_INDEX_NAMED: { - ERR_FAIL_COND_V(on->arguments.size()!=2,-1); + ERR_FAIL_COND_V(on->arguments.size() != 2, -1); int slevel = p_stack_level; - bool named=(on->op==GDParser::OperatorNode::OP_INDEX_NAMED); + bool named = (on->op == GDParser::OperatorNode::OP_INDEX_NAMED); - int from = _parse_expression(codegen,on->arguments[0],slevel); - if (from<0) + int from = _parse_expression(codegen, on->arguments[0], slevel); + if (from < 0) return from; int index; if (named) { - if (on->arguments[0]->type==GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) { + if (on->arguments[0]->type == GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) { - GDParser::IdentifierNode* identifier = static_cast<GDParser::IdentifierNode*>(on->arguments[1]); - const Map<StringName,GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(identifier->name); + GDParser::IdentifierNode *identifier = static_cast<GDParser::IdentifierNode *>(on->arguments[1]); + const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(identifier->name); #ifdef DEBUG_ENABLED - if (MI && MI->get().getter==codegen.function_node->name) { - String n = static_cast<GDParser::IdentifierNode*>(on->arguments[1])->name; - _set_error("Must use '"+n+"' instead of 'self."+n+"' in getter.",on); + if (MI && MI->get().getter == codegen.function_node->name) { + String n = static_cast<GDParser::IdentifierNode *>(on->arguments[1])->name; + _set_error("Must use '" + n + "' instead of 'self." + n + "' in getter.", on); return -1; } #endif - if (MI && MI->get().getter=="") { + if (MI && MI->get().getter == "") { // Faster than indexing self (as if no self. had been used) - return (MI->get().index)|(GDFunction::ADDR_TYPE_MEMBER<<GDFunction::ADDR_BITS); + return (MI->get().index) | (GDFunction::ADDR_TYPE_MEMBER << GDFunction::ADDR_BITS); } } - index=codegen.get_name_map_pos(static_cast<GDParser::IdentifierNode*>(on->arguments[1])->name); + index = codegen.get_name_map_pos(static_cast<GDParser::IdentifierNode *>(on->arguments[1])->name); } else { - if (on->arguments[1]->type==GDParser::Node::TYPE_CONSTANT && static_cast<const GDParser::ConstantNode*>(on->arguments[1])->value.get_type()==Variant::STRING) { + if (on->arguments[1]->type == GDParser::Node::TYPE_CONSTANT && static_cast<const GDParser::ConstantNode *>(on->arguments[1])->value.get_type() == Variant::STRING) { //also, somehow, named (speed up anyway) - StringName name = static_cast<const GDParser::ConstantNode*>(on->arguments[1])->value; - index=codegen.get_name_map_pos(name); - named=true; + StringName name = static_cast<const GDParser::ConstantNode *>(on->arguments[1])->value; + index = codegen.get_name_map_pos(name); + named = true; } else { //regular indexing - if (from&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (from & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } - index = _parse_expression(codegen,on->arguments[1],slevel); - if (index<0) + index = _parse_expression(codegen, on->arguments[1], slevel); + if (index < 0) return index; } } - codegen.opcodes.push_back(named?GDFunction::OPCODE_GET_NAMED:GDFunction::OPCODE_GET); // perform operator + codegen.opcodes.push_back(named ? GDFunction::OPCODE_GET_NAMED : GDFunction::OPCODE_GET); // perform operator codegen.opcodes.push_back(from); // argument 1 codegen.opcodes.push_back(index); // argument 2 (unary only takes one parameter) @@ -636,66 +613,66 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre // AND operator with early out on failure - int res = _parse_expression(codegen,on->arguments[0],p_stack_level); - if (res<0) + int res = _parse_expression(codegen, on->arguments[0], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(res); - int jump_fail_pos=codegen.opcodes.size(); + int jump_fail_pos = codegen.opcodes.size(); codegen.opcodes.push_back(0); - res = _parse_expression(codegen,on->arguments[1],p_stack_level); - if (res<0) + res = _parse_expression(codegen, on->arguments[1], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(res); - int jump_fail_pos2=codegen.opcodes.size(); + int jump_fail_pos2 = codegen.opcodes.size(); codegen.opcodes.push_back(0); codegen.alloc_stack(p_stack_level); //it will be used.. codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_TRUE); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); - codegen.opcodes.push_back(codegen.opcodes.size()+3); - codegen.opcodes[jump_fail_pos]=codegen.opcodes.size(); - codegen.opcodes[jump_fail_pos2]=codegen.opcodes.size(); + codegen.opcodes.push_back(codegen.opcodes.size() + 3); + codegen.opcodes[jump_fail_pos] = codegen.opcodes.size(); + codegen.opcodes[jump_fail_pos2] = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_FALSE); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); - return p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS; + codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); + return p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS; } break; case GDParser::OperatorNode::OP_OR: { // OR operator with early out on success - int res = _parse_expression(codegen,on->arguments[0],p_stack_level); - if (res<0) + int res = _parse_expression(codegen, on->arguments[0], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF); codegen.opcodes.push_back(res); - int jump_success_pos=codegen.opcodes.size(); + int jump_success_pos = codegen.opcodes.size(); codegen.opcodes.push_back(0); - res = _parse_expression(codegen,on->arguments[1],p_stack_level); - if (res<0) + res = _parse_expression(codegen, on->arguments[1], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF); codegen.opcodes.push_back(res); - int jump_success_pos2=codegen.opcodes.size(); + int jump_success_pos2 = codegen.opcodes.size(); codegen.opcodes.push_back(0); codegen.alloc_stack(p_stack_level); //it will be used.. codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_FALSE); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); - codegen.opcodes.push_back(codegen.opcodes.size()+3); - codegen.opcodes[jump_success_pos]=codegen.opcodes.size(); - codegen.opcodes[jump_success_pos2]=codegen.opcodes.size(); + codegen.opcodes.push_back(codegen.opcodes.size() + 3); + codegen.opcodes[jump_success_pos] = codegen.opcodes.size(); + codegen.opcodes[jump_success_pos2] = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_TRUE); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); - return p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS; + codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); + return p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS; } break; // ternary operators @@ -703,70 +680,113 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre // x IF a ELSE y operator with early out on failure - int res = _parse_expression(codegen,on->arguments[0],p_stack_level); - if (res<0) + int res = _parse_expression(codegen, on->arguments[0], p_stack_level); + if (res < 0) return res; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(res); - int jump_fail_pos=codegen.opcodes.size(); + int jump_fail_pos = codegen.opcodes.size(); codegen.opcodes.push_back(0); - - res = _parse_expression(codegen,on->arguments[1],p_stack_level); - if (res<0) + res = _parse_expression(codegen, on->arguments[1], p_stack_level); + if (res < 0) return res; - + codegen.alloc_stack(p_stack_level); //it will be used.. codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.opcodes.push_back(res); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); - int jump_past_pos=codegen.opcodes.size(); + int jump_past_pos = codegen.opcodes.size(); codegen.opcodes.push_back(0); - - codegen.opcodes[jump_fail_pos]=codegen.opcodes.size(); - res = _parse_expression(codegen,on->arguments[2],p_stack_level); - if (res<0) + + codegen.opcodes[jump_fail_pos] = codegen.opcodes.size(); + res = _parse_expression(codegen, on->arguments[2], p_stack_level); + if (res < 0) return res; - + codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN); - codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.opcodes.push_back(res); - - codegen.opcodes[jump_past_pos]=codegen.opcodes.size(); - - return p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS; + + codegen.opcodes[jump_past_pos] = codegen.opcodes.size(); + + return p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS; } break; //unary operators - case GDParser::OperatorNode::OP_NEG: { if (!_create_unary_operator(codegen,on,Variant::OP_NEGATE,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_NOT: { if (!_create_unary_operator(codegen,on,Variant::OP_NOT,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_BIT_INVERT: { if (!_create_unary_operator(codegen,on,Variant::OP_BIT_NEGATE,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_PREINC: { } break; //? - case GDParser::OperatorNode::OP_PREDEC: { } break; - case GDParser::OperatorNode::OP_INC: { } break; - case GDParser::OperatorNode::OP_DEC: { } break; + case GDParser::OperatorNode::OP_NEG: { + if (!_create_unary_operator(codegen, on, Variant::OP_NEGATE, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_NOT: { + if (!_create_unary_operator(codegen, on, Variant::OP_NOT, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_BIT_INVERT: { + if (!_create_unary_operator(codegen, on, Variant::OP_BIT_NEGATE, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_PREINC: { + } break; //? + case GDParser::OperatorNode::OP_PREDEC: { + } break; + case GDParser::OperatorNode::OP_INC: { + } break; + case GDParser::OperatorNode::OP_DEC: { + } break; //binary operators (in precedence order) - case GDParser::OperatorNode::OP_IN: { if (!_create_binary_operator(codegen,on,Variant::OP_IN,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_EQUAL,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_NOT_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_NOT_EQUAL,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_LESS: { if (!_create_binary_operator(codegen,on,Variant::OP_LESS,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_LESS_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_LESS_EQUAL,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_GREATER: { if (!_create_binary_operator(codegen,on,Variant::OP_GREATER,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_GREATER_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_GREATER_EQUAL,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_ADD: { if (!_create_binary_operator(codegen,on,Variant::OP_ADD,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_SUB: { if (!_create_binary_operator(codegen,on,Variant::OP_SUBSTRACT,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_MUL: { if (!_create_binary_operator(codegen,on,Variant::OP_MULTIPLY,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_DIV: { if (!_create_binary_operator(codegen,on,Variant::OP_DIVIDE,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_MOD: { if (!_create_binary_operator(codegen,on,Variant::OP_MODULE,p_stack_level)) return -1;} break; + case GDParser::OperatorNode::OP_IN: { + if (!_create_binary_operator(codegen, on, Variant::OP_IN, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_EQUAL: { + if (!_create_binary_operator(codegen, on, Variant::OP_EQUAL, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_NOT_EQUAL: { + if (!_create_binary_operator(codegen, on, Variant::OP_NOT_EQUAL, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_LESS: { + if (!_create_binary_operator(codegen, on, Variant::OP_LESS, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_LESS_EQUAL: { + if (!_create_binary_operator(codegen, on, Variant::OP_LESS_EQUAL, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_GREATER: { + if (!_create_binary_operator(codegen, on, Variant::OP_GREATER, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_GREATER_EQUAL: { + if (!_create_binary_operator(codegen, on, Variant::OP_GREATER_EQUAL, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_ADD: { + if (!_create_binary_operator(codegen, on, Variant::OP_ADD, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_SUB: { + if (!_create_binary_operator(codegen, on, Variant::OP_SUBSTRACT, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_MUL: { + if (!_create_binary_operator(codegen, on, Variant::OP_MULTIPLY, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_DIV: { + if (!_create_binary_operator(codegen, on, Variant::OP_DIVIDE, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_MOD: { + if (!_create_binary_operator(codegen, on, Variant::OP_MODULE, p_stack_level)) return -1; + } break; //case GDParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break; //case GDParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_BIT_AND: { if (!_create_binary_operator(codegen,on,Variant::OP_BIT_AND,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_BIT_OR: { if (!_create_binary_operator(codegen,on,Variant::OP_BIT_OR,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_BIT_XOR: { if (!_create_binary_operator(codegen,on,Variant::OP_BIT_XOR,p_stack_level)) return -1;} break; - //shift - case GDParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break; - case GDParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break; + case GDParser::OperatorNode::OP_BIT_AND: { + if (!_create_binary_operator(codegen, on, Variant::OP_BIT_AND, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_BIT_OR: { + if (!_create_binary_operator(codegen, on, Variant::OP_BIT_OR, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_BIT_XOR: { + if (!_create_binary_operator(codegen, on, Variant::OP_BIT_XOR, p_stack_level)) return -1; + } break; + //shift + case GDParser::OperatorNode::OP_SHIFT_LEFT: { + if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_LEFT, p_stack_level)) return -1; + } break; + case GDParser::OperatorNode::OP_SHIFT_RIGHT: { + if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_RIGHT, p_stack_level)) return -1; + } break; //assignment operators case GDParser::OperatorNode::OP_ASSIGN_ADD: case GDParser::OperatorNode::OP_ASSIGN_SUB: @@ -781,63 +801,57 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre case GDParser::OperatorNode::OP_INIT_ASSIGN: case GDParser::OperatorNode::OP_ASSIGN: { - ERR_FAIL_COND_V(on->arguments.size()!=2,-1); - - - if (on->arguments[0]->type==GDParser::Node::TYPE_OPERATOR && (static_cast<GDParser::OperatorNode*>(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX || static_cast<GDParser::OperatorNode*>(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX_NAMED)) { - //SET (chained) MODE!! + ERR_FAIL_COND_V(on->arguments.size() != 2, -1); + if (on->arguments[0]->type == GDParser::Node::TYPE_OPERATOR && (static_cast<GDParser::OperatorNode *>(on->arguments[0])->op == GDParser::OperatorNode::OP_INDEX || static_cast<GDParser::OperatorNode *>(on->arguments[0])->op == GDParser::OperatorNode::OP_INDEX_NAMED)) { +//SET (chained) MODE!! #ifdef DEBUG_ENABLED - if (static_cast<GDParser::OperatorNode*>(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX_NAMED) { - const GDParser::OperatorNode* inon = static_cast<GDParser::OperatorNode*>(on->arguments[0]); - + if (static_cast<GDParser::OperatorNode *>(on->arguments[0])->op == GDParser::OperatorNode::OP_INDEX_NAMED) { + const GDParser::OperatorNode *inon = static_cast<GDParser::OperatorNode *>(on->arguments[0]); - if (inon->arguments[0]->type==GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) { + if (inon->arguments[0]->type == GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) { - const Map<StringName,GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(static_cast<GDParser::IdentifierNode*>(inon->arguments[1])->name); - if (MI && MI->get().setter==codegen.function_node->name) { - String n = static_cast<GDParser::IdentifierNode*>(inon->arguments[1])->name; - _set_error("Must use '"+n+"' instead of 'self."+n+"' in setter.",inon); + const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(static_cast<GDParser::IdentifierNode *>(inon->arguments[1])->name); + if (MI && MI->get().setter == codegen.function_node->name) { + String n = static_cast<GDParser::IdentifierNode *>(inon->arguments[1])->name; + _set_error("Must use '" + n + "' instead of 'self." + n + "' in setter.", inon); return -1; } } } #endif + int slevel = p_stack_level; - int slevel=p_stack_level; - - GDParser::OperatorNode* op = static_cast<GDParser::OperatorNode*>(on->arguments[0]); + GDParser::OperatorNode *op = static_cast<GDParser::OperatorNode *>(on->arguments[0]); /* Find chain of sets */ StringName assign_property; - List<GDParser::OperatorNode*> chain; + List<GDParser::OperatorNode *> chain; { //create get/set chain - GDParser::OperatorNode* n=op; - while(true) { + GDParser::OperatorNode *n = op; + while (true) { chain.push_back(n); - if (n->arguments[0]->type!=GDParser::Node::TYPE_OPERATOR) { + if (n->arguments[0]->type != GDParser::Node::TYPE_OPERATOR) { //check for a built-in property - if (n->arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER) { + if (n->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER) { - GDParser::IdentifierNode *identifier = static_cast<GDParser::IdentifierNode*>(n->arguments[0]); - if (_is_class_member_property(codegen,identifier->name)) { + GDParser::IdentifierNode *identifier = static_cast<GDParser::IdentifierNode *>(n->arguments[0]); + if (_is_class_member_property(codegen, identifier->name)) { assign_property = identifier->name; - } - } break; } - n = static_cast<GDParser::OperatorNode*>(n->arguments[0]); - if (n->op!=GDParser::OperatorNode::OP_INDEX && n->op!=GDParser::OperatorNode::OP_INDEX_NAMED) + n = static_cast<GDParser::OperatorNode *>(n->arguments[0]); + if (n->op != GDParser::OperatorNode::OP_INDEX && n->op != GDParser::OperatorNode::OP_INDEX_NAMED) break; } } @@ -845,23 +859,21 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre /* Chain of gets */ //get at (potential) root stack pos, so it can be returned - int prev_pos = _parse_expression(codegen,chain.back()->get()->arguments[0],slevel); - if (prev_pos<0) + int prev_pos = _parse_expression(codegen, chain.back()->get()->arguments[0], slevel); + if (prev_pos < 0) return prev_pos; - int retval=prev_pos; + int retval = prev_pos; //print_line("retval: "+itos(retval)); - if (retval&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (retval & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } - Vector<int> setchain; - - if (assign_property!=StringName()) { + if (assign_property != StringName()) { // recover and assign at the end, this allows stuff like // position.x+=2.0 @@ -871,37 +883,34 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre setchain.push_back(GDFunction::OPCODE_SET_MEMBER); } - for(List<GDParser::OperatorNode*>::Element *E=chain.back();E;E=E->prev()) { + for (List<GDParser::OperatorNode *>::Element *E = chain.back(); E; E = E->prev()) { - - if (E==chain.front()) //ignore first + if (E == chain.front()) //ignore first break; - bool named = E->get()->op==GDParser::OperatorNode::OP_INDEX_NAMED; + bool named = E->get()->op == GDParser::OperatorNode::OP_INDEX_NAMED; int key_idx; if (named) { - key_idx = codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode*>(E->get()->arguments[1])->name); + key_idx = codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode *>(E->get()->arguments[1])->name); //printf("named key %x\n",key_idx); } else { - if (prev_pos&(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)) { + if (prev_pos & (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS)) { slevel++; codegen.alloc_stack(slevel); } GDParser::Node *key = E->get()->arguments[1]; - key_idx = _parse_expression(codegen,key,slevel); + key_idx = _parse_expression(codegen, key, slevel); //printf("expr key %x\n",key_idx); - //stack was raised here if retval was stack but.. - } - if (key_idx<0) //error + if (key_idx < 0) //error return key_idx; codegen.opcodes.push_back(named ? GDFunction::OPCODE_GET_NAMED : GDFunction::OPCODE_GET); @@ -909,134 +918,116 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre codegen.opcodes.push_back(key_idx); slevel++; codegen.alloc_stack(slevel); - int dst_pos = (GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)|slevel; + int dst_pos = (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) | slevel; codegen.opcodes.push_back(dst_pos); - //add in reverse order, since it will be reverted - setchain.push_back(dst_pos); setchain.push_back(key_idx); setchain.push_back(prev_pos); setchain.push_back(named ? GDFunction::OPCODE_SET_NAMED : GDFunction::OPCODE_SET); - prev_pos=dst_pos; - + prev_pos = dst_pos; } setchain.invert(); - int set_index; - bool named=false; + bool named = false; + if (static_cast<const GDParser::OperatorNode *>(op)->op == GDParser::OperatorNode::OP_INDEX_NAMED) { - if (static_cast<const GDParser::OperatorNode*>(op)->op==GDParser::OperatorNode::OP_INDEX_NAMED) { - - - set_index=codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode*>(op->arguments[1])->name); - named=true; + set_index = codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode *>(op->arguments[1])->name); + named = true; } else { - set_index = _parse_expression(codegen,op->arguments[1],slevel+1); - named=false; + set_index = _parse_expression(codegen, op->arguments[1], slevel + 1); + named = false; } - - if (set_index<0) //error + if (set_index < 0) //error return set_index; - if (set_index&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (set_index & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } - - int set_value = _parse_assign_right_expression(codegen,on,slevel+1); - if (set_value<0) //error + int set_value = _parse_assign_right_expression(codegen, on, slevel + 1); + if (set_value < 0) //error return set_value; - codegen.opcodes.push_back(named?GDFunction::OPCODE_SET_NAMED:GDFunction::OPCODE_SET); + codegen.opcodes.push_back(named ? GDFunction::OPCODE_SET_NAMED : GDFunction::OPCODE_SET); codegen.opcodes.push_back(prev_pos); codegen.opcodes.push_back(set_index); codegen.opcodes.push_back(set_value); - for(int i=0;i<setchain.size();i++) { - + for (int i = 0; i < setchain.size(); i++) { codegen.opcodes.push_back(setchain[i]); } return retval; - - } else if (on->arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER && _is_class_member_property(codegen,static_cast<GDParser::IdentifierNode*>(on->arguments[0])->name)) { + } else if (on->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER && _is_class_member_property(codegen, static_cast<GDParser::IdentifierNode *>(on->arguments[0])->name)) { //assignment to member property int slevel = p_stack_level; - int src_address = _parse_assign_right_expression(codegen,on,slevel); - if (src_address<0) + int src_address = _parse_assign_right_expression(codegen, on, slevel); + if (src_address < 0) return -1; - StringName name = static_cast<GDParser::IdentifierNode*>(on->arguments[0])->name; + StringName name = static_cast<GDParser::IdentifierNode *>(on->arguments[0])->name; codegen.opcodes.push_back(GDFunction::OPCODE_SET_MEMBER); codegen.opcodes.push_back(codegen.get_name_map_pos(name)); codegen.opcodes.push_back(src_address); - return GDFunction::ADDR_TYPE_NIL<<GDFunction::ADDR_BITS; + return GDFunction::ADDR_TYPE_NIL << GDFunction::ADDR_BITS; } else { - - //REGULAR ASSIGNMENT MODE!! int slevel = p_stack_level; - int dst_address_a = _parse_expression(codegen,on->arguments[0],slevel,false,on->op==GDParser::OperatorNode::OP_INIT_ASSIGN); - if (dst_address_a<0) + int dst_address_a = _parse_expression(codegen, on->arguments[0], slevel, false, on->op == GDParser::OperatorNode::OP_INIT_ASSIGN); + if (dst_address_a < 0) return -1; - if (dst_address_a&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) { + if (dst_address_a & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) { slevel++; codegen.alloc_stack(slevel); } - int src_address_b = _parse_assign_right_expression(codegen,on,slevel); - if (src_address_b<0) + int src_address_b = _parse_assign_right_expression(codegen, on, slevel); + if (src_address_b < 0) return -1; - - - codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN); // perform operator codegen.opcodes.push_back(dst_address_a); // argument 1 codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter) return dst_address_a; //if anything, returns wathever was assigned or correct stack position - } - } break; case GDParser::OperatorNode::OP_EXTENDS: { - ERR_FAIL_COND_V(on->arguments.size()!=2,false); - + ERR_FAIL_COND_V(on->arguments.size() != 2, false); int slevel = p_stack_level; - int src_address_a = _parse_expression(codegen,on->arguments[0],slevel); - if (src_address_a<0) + int src_address_a = _parse_expression(codegen, on->arguments[0], slevel); + if (src_address_a < 0) return -1; - if (src_address_a&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) + if (src_address_a & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) slevel++; //uses stack for return, increase stack - int src_address_b = _parse_expression(codegen,on->arguments[1],slevel); - if (src_address_b<0) + int src_address_b = _parse_expression(codegen, on->arguments[1], slevel); + if (src_address_b < 0) return -1; codegen.opcodes.push_back(GDFunction::OPCODE_EXTENDS_TEST); // perform operator @@ -1046,14 +1037,13 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre } break; default: { - - ERR_EXPLAIN("Bug in bytecode compiler, unexpected operator #"+itos(on->op)+" in parse tree while parsing expression."); + ERR_EXPLAIN("Bug in bytecode compiler, unexpected operator #" + itos(on->op) + " in parse tree while parsing expression."); ERR_FAIL_V(0); //unreachable code } break; } - int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode codegen.alloc_stack(p_stack_level); return dst_addr; @@ -1064,47 +1054,43 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre ERR_EXPLAIN("Bug in bytecode compiler, unexpected node in parse tree while parsing expression."); ERR_FAIL_V(-1); //unreachable code } break; - - } ERR_FAIL_V(-1); //unreachable code } - -Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_block,int p_stack_level,int p_break_addr,int p_continue_addr) { +Error GDCompiler::_parse_block(CodeGen &codegen, const GDParser::BlockNode *p_block, int p_stack_level, int p_break_addr, int p_continue_addr) { codegen.push_stack_identifiers(); - int new_identifiers=0; - codegen.current_line=p_block->line; + int new_identifiers = 0; + codegen.current_line = p_block->line; - for(int i=0;i<p_block->statements.size();i++) { + for (int i = 0; i < p_block->statements.size(); i++) { const GDParser::Node *s = p_block->statements[i]; - - switch(s->type) { + switch (s->type) { case GDParser::Node::TYPE_NEWLINE: { #ifdef DEBUG_ENABLED - const GDParser::NewLineNode *nl = static_cast<const GDParser::NewLineNode*>(s); + const GDParser::NewLineNode *nl = static_cast<const GDParser::NewLineNode *>(s); codegen.opcodes.push_back(GDFunction::OPCODE_LINE); codegen.opcodes.push_back(nl->line); - codegen.current_line=nl->line; + codegen.current_line = nl->line; #endif } break; case GDParser::Node::TYPE_CONTROL_FLOW: { // try subblocks - const GDParser::ControlFlowNode *cf = static_cast<const GDParser::ControlFlowNode*>(s); + const GDParser::ControlFlowNode *cf = static_cast<const GDParser::ControlFlowNode *>(s); - switch(cf->cf_type) { + switch (cf->cf_type) { case GDParser::ControlFlowNode::CF_MATCH: { GDParser::MatchNode *match = cf->match; - + GDParser::IdentifierNode *id = memnew(GDParser::IdentifierNode); id->name = "#match_value"; - + // var #match_value // copied because there is no _parse_statement :( codegen.add_stack_identifier(id->name, p_stack_level++); @@ -1112,25 +1098,25 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo new_identifiers++; GDParser::OperatorNode *op = memnew(GDParser::OperatorNode); - op->op=GDParser::OperatorNode::OP_ASSIGN; + op->op = GDParser::OperatorNode::OP_ASSIGN; op->arguments.push_back(id); op->arguments.push_back(match->val_to_match); - + int ret = _parse_expression(codegen, op, p_stack_level); if (ret < 0) { return ERR_PARSE_ERROR; } - + // break address codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(codegen.opcodes.size() + 3); int break_addr = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(0); // break addr - + for (int j = 0; j < match->compiled_pattern_branches.size(); j++) { GDParser::MatchNode::CompiledPatternBranch branch = match->compiled_pattern_branches[j]; - + // jump over continue // jump unconditionally // continue address @@ -1139,87 +1125,81 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo if (ret < 0) { return ERR_PARSE_ERROR; } - + codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF); codegen.opcodes.push_back(ret); codegen.opcodes.push_back(codegen.opcodes.size() + 3); int continue_addr = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(0); - - - + Error err = _parse_block(codegen, branch.body, p_stack_level, p_break_addr, continue_addr); if (err) { return ERR_PARSE_ERROR; } - + codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(break_addr); - + codegen.opcodes[continue_addr + 1] = codegen.opcodes.size(); } - + codegen.opcodes[break_addr + 1] = codegen.opcodes.size(); - - + } break; - + case GDParser::ControlFlowNode::CF_IF: { #ifdef DEBUG_ENABLED codegen.opcodes.push_back(GDFunction::OPCODE_LINE); codegen.opcodes.push_back(cf->line); - codegen.current_line=cf->line; + codegen.current_line = cf->line; #endif - int ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false); - if (ret<0) + int ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false); + if (ret < 0) return ERR_PARSE_ERROR; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(ret); - int else_addr=codegen.opcodes.size(); + int else_addr = codegen.opcodes.size(); codegen.opcodes.push_back(0); //temporary - Error err = _parse_block(codegen,cf->body,p_stack_level,p_break_addr,p_continue_addr); + Error err = _parse_block(codegen, cf->body, p_stack_level, p_break_addr, p_continue_addr); if (err) return err; if (cf->body_else) { codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); - int end_addr=codegen.opcodes.size(); + int end_addr = codegen.opcodes.size(); codegen.opcodes.push_back(0); - codegen.opcodes[else_addr]=codegen.opcodes.size(); + codegen.opcodes[else_addr] = codegen.opcodes.size(); - Error err = _parse_block(codegen,cf->body_else,p_stack_level,p_break_addr,p_continue_addr); + Error err = _parse_block(codegen, cf->body_else, p_stack_level, p_break_addr, p_continue_addr); if (err) return err; - codegen.opcodes[end_addr]=codegen.opcodes.size(); + codegen.opcodes[end_addr] = codegen.opcodes.size(); } else { //end without else - codegen.opcodes[else_addr]=codegen.opcodes.size(); - + codegen.opcodes[else_addr] = codegen.opcodes.size(); } } break; case GDParser::ControlFlowNode::CF_FOR: { - - - int slevel=p_stack_level; - int iter_stack_pos=slevel; - int iterator_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); - int counter_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); - int container_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS); + int slevel = p_stack_level; + int iter_stack_pos = slevel; + int iterator_pos = (slevel++) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); + int counter_pos = (slevel++) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); + int container_pos = (slevel++) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS); codegen.alloc_stack(slevel); - codegen.push_stack_identifiers(); - codegen.add_stack_identifier(static_cast<const GDParser::IdentifierNode*>(cf->arguments[0])->name,iter_stack_pos); + codegen.push_stack_identifiers(); + codegen.add_stack_identifier(static_cast<const GDParser::IdentifierNode *>(cf->arguments[0])->name, iter_stack_pos); - int ret = _parse_expression(codegen,cf->arguments[1],slevel,false); - if (ret<0) + int ret = _parse_expression(codegen, cf->arguments[1], slevel, false); + if (ret < 0) return ERR_COMPILATION_FAILED; //assign container @@ -1231,32 +1211,29 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo codegen.opcodes.push_back(GDFunction::OPCODE_ITERATE_BEGIN); codegen.opcodes.push_back(counter_pos); codegen.opcodes.push_back(container_pos); - codegen.opcodes.push_back(codegen.opcodes.size()+4); + codegen.opcodes.push_back(codegen.opcodes.size() + 4); codegen.opcodes.push_back(iterator_pos); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); //skip code for next - codegen.opcodes.push_back(codegen.opcodes.size()+8); + codegen.opcodes.push_back(codegen.opcodes.size() + 8); //break loop - int break_pos=codegen.opcodes.size(); + int break_pos = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); //skip code for next codegen.opcodes.push_back(0); //skip code for next //next loop - int continue_pos=codegen.opcodes.size(); + int continue_pos = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_ITERATE); codegen.opcodes.push_back(counter_pos); codegen.opcodes.push_back(container_pos); codegen.opcodes.push_back(break_pos); codegen.opcodes.push_back(iterator_pos); - - Error err = _parse_block(codegen,cf->body,slevel,break_pos,continue_pos); + Error err = _parse_block(codegen, cf->body, slevel, break_pos, continue_pos); if (err) return err; - codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(continue_pos); - codegen.opcodes[break_pos+1]=codegen.opcodes.size(); - + codegen.opcodes[break_pos + 1] = codegen.opcodes.size(); codegen.pop_stack_identifiers(); @@ -1264,25 +1241,25 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo case GDParser::ControlFlowNode::CF_WHILE: { codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); - codegen.opcodes.push_back(codegen.opcodes.size()+3); - int break_addr=codegen.opcodes.size(); + codegen.opcodes.push_back(codegen.opcodes.size() + 3); + int break_addr = codegen.opcodes.size(); codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(0); - int continue_addr=codegen.opcodes.size(); + int continue_addr = codegen.opcodes.size(); - int ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false); - if (ret<0) + int ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false); + if (ret < 0) return ERR_PARSE_ERROR; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT); codegen.opcodes.push_back(ret); codegen.opcodes.push_back(break_addr); - Error err = _parse_block(codegen,cf->body,p_stack_level,break_addr,continue_addr); + Error err = _parse_block(codegen, cf->body, p_stack_level, break_addr, continue_addr); if (err) return err; codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); codegen.opcodes.push_back(continue_addr); - codegen.opcodes[break_addr+1]=codegen.opcodes.size(); + codegen.opcodes[break_addr + 1] = codegen.opcodes.size(); } break; case GDParser::ControlFlowNode::CF_SWITCH: { @@ -1290,9 +1267,9 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo } break; case GDParser::ControlFlowNode::CF_BREAK: { - if (p_break_addr<0) { + if (p_break_addr < 0) { - _set_error("'break'' not within loop",cf); + _set_error("'break'' not within loop", cf); return ERR_COMPILATION_FAILED; } codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); @@ -1301,9 +1278,9 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo } break; case GDParser::ControlFlowNode::CF_CONTINUE: { - if (p_continue_addr<0) { + if (p_continue_addr < 0) { - _set_error("'continue' not within loop",cf); + _set_error("'continue' not within loop", cf); return ERR_COMPILATION_FAILED; } @@ -1317,29 +1294,28 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo if (cf->arguments.size()) { - ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false); - if (ret<0) + ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false); + if (ret < 0) return ERR_PARSE_ERROR; } else { - ret=GDFunction::ADDR_TYPE_NIL << GDFunction::ADDR_BITS; + ret = GDFunction::ADDR_TYPE_NIL << GDFunction::ADDR_BITS; } codegen.opcodes.push_back(GDFunction::OPCODE_RETURN); codegen.opcodes.push_back(ret); } break; - } } break; case GDParser::Node::TYPE_ASSERT: { // try subblocks - const GDParser::AssertNode *as = static_cast<const GDParser::AssertNode*>(s); + const GDParser::AssertNode *as = static_cast<const GDParser::AssertNode *>(s); - int ret = _parse_expression(codegen,as->condition,p_stack_level,false); - if (ret<0) + int ret = _parse_expression(codegen, as->condition, p_stack_level, false); + if (ret < 0) return ERR_PARSE_ERROR; codegen.opcodes.push_back(GDFunction::OPCODE_ASSERT); @@ -1353,99 +1329,91 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo } break; case GDParser::Node::TYPE_LOCAL_VAR: { + const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode *>(s); - const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode*>(s); - - if (_is_class_member_property(codegen,lv->name)) { - _set_error("Name for local variable '"+String(lv->name)+"' can't shadow class property of the same name.",lv); + if (_is_class_member_property(codegen, lv->name)) { + _set_error("Name for local variable '" + String(lv->name) + "' can't shadow class property of the same name.", lv); return ERR_ALREADY_EXISTS; } - codegen.add_stack_identifier(lv->name,p_stack_level++); + codegen.add_stack_identifier(lv->name, p_stack_level++); codegen.alloc_stack(p_stack_level); new_identifiers++; } break; default: { //expression - int ret = _parse_expression(codegen,s,p_stack_level,true); - if (ret<0) + int ret = _parse_expression(codegen, s, p_stack_level, true); + if (ret < 0) return ERR_PARSE_ERROR; } break; - } - } codegen.pop_stack_identifiers(); return OK; } - -Error GDCompiler::_parse_function(GDScript *p_script,const GDParser::ClassNode *p_class,const GDParser::FunctionNode *p_func,bool p_for_ready) { +Error GDCompiler::_parse_function(GDScript *p_script, const GDParser::ClassNode *p_class, const GDParser::FunctionNode *p_func, bool p_for_ready) { Vector<int> bytecode; CodeGen codegen; - codegen.class_node=p_class; - codegen.script=p_script; - codegen.function_node=p_func; - codegen.stack_max=0; - codegen.current_line=0; - codegen.call_max=0; - codegen.debug_stack=ScriptDebugger::get_singleton()!=NULL; + codegen.class_node = p_class; + codegen.script = p_script; + codegen.function_node = p_func; + codegen.stack_max = 0; + codegen.current_line = 0; + codegen.call_max = 0; + codegen.debug_stack = ScriptDebugger::get_singleton() != NULL; Vector<StringName> argnames; - int stack_level=0; + int stack_level = 0; if (p_func) { - for(int i=0;i<p_func->arguments.size();i++) { - if (_is_class_member_property(p_script,p_func->arguments[i])) { - _set_error("Name for argument '"+String(p_func->arguments[i])+"' can't shadow class property of the same name.",p_func); + for (int i = 0; i < p_func->arguments.size(); i++) { + if (_is_class_member_property(p_script, p_func->arguments[i])) { + _set_error("Name for argument '" + String(p_func->arguments[i]) + "' can't shadow class property of the same name.", p_func); return ERR_ALREADY_EXISTS; } - codegen.add_stack_identifier(p_func->arguments[i],i); + codegen.add_stack_identifier(p_func->arguments[i], i); #ifdef TOOLS_ENABLED argnames.push_back(p_func->arguments[i]); #endif } - stack_level=p_func->arguments.size(); + stack_level = p_func->arguments.size(); } codegen.alloc_stack(stack_level); /* Parse initializer -if applies- */ - bool is_initializer=!p_for_ready && !p_func; + bool is_initializer = !p_for_ready && !p_func; - if (is_initializer || (p_func && String(p_func->name)=="_init")) { + if (is_initializer || (p_func && String(p_func->name) == "_init")) { //parse initializer for class members - if (!p_func && p_class->extends_used && p_script->native.is_null()){ + if (!p_func && p_class->extends_used && p_script->native.is_null()) { //call implicit parent constructor codegen.opcodes.push_back(GDFunction::OPCODE_CALL_SELF_BASE); codegen.opcodes.push_back(codegen.get_name_map_pos("_init")); codegen.opcodes.push_back(0); - codegen.opcodes.push_back((GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)|0); - + codegen.opcodes.push_back((GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) | 0); } - Error err = _parse_block(codegen,p_class->initializer,stack_level); + Error err = _parse_block(codegen, p_class->initializer, stack_level); if (err) return err; - is_initializer=true; - + is_initializer = true; } - if (p_for_ready || (p_func && String(p_func->name)=="_ready")) { + if (p_for_ready || (p_func && String(p_func->name) == "_ready")) { //parse initializer for class members if (p_class->ready->statements.size()) { - Error err = _parse_block(codegen,p_class->ready,stack_level); + Error err = _parse_block(codegen, p_class->ready, stack_level); if (err) return err; } - } - /* Parse default argument code -if applies- */ Vector<int> defarg_addr; @@ -1457,196 +1425,185 @@ Error GDCompiler::_parse_function(GDScript *p_script,const GDParser::ClassNode * codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_TO_DEF_ARGUMENT); defarg_addr.push_back(codegen.opcodes.size()); - for(int i=0;i<p_func->default_values.size();i++) { + for (int i = 0; i < p_func->default_values.size(); i++) { - _parse_expression(codegen,p_func->default_values[i],stack_level,true); + _parse_expression(codegen, p_func->default_values[i], stack_level, true); defarg_addr.push_back(codegen.opcodes.size()); } - defarg_addr.invert(); } - - - Error err = _parse_block(codegen,p_func->body,stack_level); + Error err = _parse_block(codegen, p_func->body, stack_level); if (err) return err; - func_name=p_func->name; + func_name = p_func->name; } else { if (p_for_ready) - func_name="_ready"; + func_name = "_ready"; else - func_name="_init"; + func_name = "_init"; } codegen.opcodes.push_back(GDFunction::OPCODE_END); - GDFunction *gdfunc=NULL; + GDFunction *gdfunc = NULL; /* if (String(p_func->name)=="") { //initializer func gdfunc = &p_script->initializer; */ //} else { //regular func - p_script->member_functions[func_name]=memnew(GDFunction); - gdfunc = p_script->member_functions[func_name]; + p_script->member_functions[func_name] = memnew(GDFunction); + gdfunc = p_script->member_functions[func_name]; //} if (p_func) { - gdfunc->_static=p_func->_static; - gdfunc->rpc_mode=p_func->rpc_mode; + gdfunc->_static = p_func->_static; + gdfunc->rpc_mode = p_func->rpc_mode; } #ifdef TOOLS_ENABLED - gdfunc->arg_names=argnames; + gdfunc->arg_names = argnames; #endif //constants if (codegen.constant_map.size()) { - gdfunc->_constant_count=codegen.constant_map.size(); + gdfunc->_constant_count = codegen.constant_map.size(); gdfunc->constants.resize(codegen.constant_map.size()); - gdfunc->_constants_ptr=&gdfunc->constants[0]; - const Variant *K=NULL; - while((K=codegen.constant_map.next(K))) { + gdfunc->_constants_ptr = &gdfunc->constants[0]; + const Variant *K = NULL; + while ((K = codegen.constant_map.next(K))) { int idx = codegen.constant_map[*K]; - gdfunc->constants[idx]=*K; + gdfunc->constants[idx] = *K; } } else { - gdfunc->_constants_ptr=NULL; - gdfunc->_constant_count=0; + gdfunc->_constants_ptr = NULL; + gdfunc->_constant_count = 0; } //global names if (codegen.name_map.size()) { gdfunc->global_names.resize(codegen.name_map.size()); gdfunc->_global_names_ptr = &gdfunc->global_names[0]; - for(Map<StringName,int>::Element *E=codegen.name_map.front();E;E=E->next()) { + for (Map<StringName, int>::Element *E = codegen.name_map.front(); E; E = E->next()) { - gdfunc->global_names[E->get()]=E->key(); + gdfunc->global_names[E->get()] = E->key(); } - gdfunc->_global_names_count=gdfunc->global_names.size(); + gdfunc->_global_names_count = gdfunc->global_names.size(); } else { gdfunc->_global_names_ptr = NULL; - gdfunc->_global_names_count =0; + gdfunc->_global_names_count = 0; } - if (codegen.opcodes.size()) { - gdfunc->code=codegen.opcodes; - gdfunc->_code_ptr=&gdfunc->code[0]; - gdfunc->_code_size=codegen.opcodes.size(); + gdfunc->code = codegen.opcodes; + gdfunc->_code_ptr = &gdfunc->code[0]; + gdfunc->_code_size = codegen.opcodes.size(); } else { - gdfunc->_code_ptr=NULL; - gdfunc->_code_size=0; + gdfunc->_code_ptr = NULL; + gdfunc->_code_size = 0; } if (defarg_addr.size()) { - gdfunc->default_arguments=defarg_addr; - gdfunc->_default_arg_count=defarg_addr.size()-1; - gdfunc->_default_arg_ptr=&gdfunc->default_arguments[0]; + gdfunc->default_arguments = defarg_addr; + gdfunc->_default_arg_count = defarg_addr.size() - 1; + gdfunc->_default_arg_ptr = &gdfunc->default_arguments[0]; } else { - gdfunc->_default_arg_count=0; - gdfunc->_default_arg_ptr=NULL; + gdfunc->_default_arg_count = 0; + gdfunc->_default_arg_ptr = NULL; } - gdfunc->_argument_count=p_func ? p_func->arguments.size() : 0; - gdfunc->_stack_size=codegen.stack_max; - gdfunc->_call_size=codegen.call_max; - gdfunc->name=func_name; + gdfunc->_argument_count = p_func ? p_func->arguments.size() : 0; + gdfunc->_stack_size = codegen.stack_max; + gdfunc->_call_size = codegen.call_max; + gdfunc->name = func_name; #ifdef DEBUG_ENABLED - if (ScriptDebugger::get_singleton()){ + if (ScriptDebugger::get_singleton()) { String signature; //path - if (p_script->get_path()!=String()) - signature+=p_script->get_path(); + if (p_script->get_path() != String()) + signature += p_script->get_path(); //loc if (p_func) { - signature+="::"+itos(p_func->body->line); + signature += "::" + itos(p_func->body->line); } else { - signature+="::0"; + signature += "::0"; } //funciton and class if (p_class->name) { - signature+="::"+String(p_class->name)+"."+String(func_name); + signature += "::" + String(p_class->name) + "." + String(func_name); } else { - signature+="::"+String(func_name); + signature += "::" + String(func_name); } - - - gdfunc->profile.signature=signature; + gdfunc->profile.signature = signature; } #endif - gdfunc->_script=p_script; - gdfunc->source=source; + gdfunc->_script = p_script; + gdfunc->source = source; #ifdef DEBUG_ENABLED { - gdfunc->func_cname=(String(source)+" - "+String(func_name)).utf8(); - gdfunc->_func_cname=gdfunc->func_cname.get_data(); - + gdfunc->func_cname = (String(source) + " - " + String(func_name)).utf8(); + gdfunc->_func_cname = gdfunc->func_cname.get_data(); } #endif if (p_func) { - gdfunc->_initial_line=p_func->line; + gdfunc->_initial_line = p_func->line; #ifdef TOOLS_ENABLED - p_script->member_lines[func_name]=p_func->line; + p_script->member_lines[func_name] = p_func->line; #endif } else { - gdfunc->_initial_line=0; + gdfunc->_initial_line = 0; } if (codegen.debug_stack) - gdfunc->stack_debug=codegen.stack_debug; + gdfunc->stack_debug = codegen.stack_debug; if (is_initializer) - p_script->initializer=gdfunc; - + p_script->initializer = gdfunc; return OK; } - - Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDParser::ClassNode *p_class, bool p_keep_state) { - Map<StringName,Ref<GDScript> > old_subclasses; + Map<StringName, Ref<GDScript> > old_subclasses; if (p_keep_state) { - old_subclasses=p_script->subclasses; + old_subclasses = p_script->subclasses; } - p_script->native=Ref<GDNativeClass>(); - p_script->base=Ref<GDScript>(); - p_script->_base=NULL; + p_script->native = Ref<GDNativeClass>(); + p_script->base = Ref<GDScript>(); + p_script->_base = NULL; p_script->members.clear(); p_script->constants.clear(); - for (Map<StringName,GDFunction*>::Element *E=p_script->member_functions.front();E;E=E->next()) { + for (Map<StringName, GDFunction *>::Element *E = p_script->member_functions.front(); E; E = E->next()) { memdelete(E->get()); } p_script->member_functions.clear(); p_script->member_indices.clear(); p_script->member_info.clear(); p_script->_signals.clear(); - p_script->initializer=NULL; + p_script->initializer = NULL; p_script->subclasses.clear(); - p_script->_owner=p_owner; - p_script->tool=p_class->tool; - p_script->name=p_class->name; - + p_script->_owner = p_owner; + p_script->tool = p_class->tool; + p_script->name = p_class->name; Ref<GDNativeClass> native; @@ -1656,8 +1613,7 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa Ref<GDScript> script; - - if (path!="") { + if (path != "") { //path (and optionally subclasses) if (path.is_rel_path()) { @@ -1667,47 +1623,46 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa if (p_owner) { GDScript *current_class = p_owner; while (current_class != NULL) { - base=current_class->get_path(); - if (base=="") + base = current_class->get_path(); + if (base == "") current_class = current_class->_owner; else break; } - } - else { + } else { base = p_script->get_path(); } - if (base=="" || base.is_rel_path()) { - _set_error("Could not resolve relative path for parent class: "+path,p_class); + if (base == "" || base.is_rel_path()) { + _set_error("Could not resolve relative path for parent class: " + path, p_class); return ERR_FILE_NOT_FOUND; } - path=base.get_base_dir().plus_file(path).simplify_path(); + path = base.get_base_dir().plus_file(path).simplify_path(); } script = ResourceLoader::load(path); if (script.is_null()) { - _set_error("Could not load base class: "+path,p_class); + _set_error("Could not load base class: " + path, p_class); return ERR_FILE_NOT_FOUND; } if (!script->valid) { - _set_error("Script not fully loaded (cyclic preload?): "+path,p_class); + _set_error("Script not fully loaded (cyclic preload?): " + path, p_class); return ERR_BUSY; } //print_line("EXTENDS PATH: "+path+" script is "+itos(script.is_valid())+" indices is "+itos(script->member_indices.size())+" valid? "+itos(script->valid)); if (p_class->extends_class.size()) { - for(int i=0;i<p_class->extends_class.size();i++) { + for (int i = 0; i < p_class->extends_class.size(); i++) { String sub = p_class->extends_class[i]; if (script->subclasses.has(sub)) { Ref<Script> subclass = script->subclasses[sub]; //avoid reference from dissapearing - script=subclass; + script = subclass; } else { - _set_error("Could not find subclass: "+sub,p_class); + _set_error("Could not find subclass: " + sub, p_class); return ERR_FILE_NOT_FOUND; } } @@ -1715,54 +1670,52 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa } else { - ERR_FAIL_COND_V(p_class->extends_class.size()==0,ERR_BUG); + ERR_FAIL_COND_V(p_class->extends_class.size() == 0, ERR_BUG); //look around for the subclasses - String base=p_class->extends_class[0]; + String base = p_class->extends_class[0]; GDScript *p = p_owner; Ref<GDScript> base_class; - while(p) { + while (p) { if (p->subclasses.has(base)) { - base_class=p->subclasses[base]; + base_class = p->subclasses[base]; break; } - p=p->_owner; + p = p->_owner; } if (base_class.is_valid()) { - for(int i=1;i<p_class->extends_class.size();i++) { + for (int i = 1; i < p_class->extends_class.size(); i++) { - String subclass=p_class->extends_class[i]; + String subclass = p_class->extends_class[i]; if (base_class->subclasses.has(subclass)) { - base_class=base_class->subclasses[subclass]; + base_class = base_class->subclasses[subclass]; } else { - _set_error("Could not find subclass: "+subclass,p_class); + _set_error("Could not find subclass: " + subclass, p_class); return ERR_FILE_NOT_FOUND; } } - script=base_class; - + script = base_class; } else { - if (p_class->extends_class.size()>1) { + if (p_class->extends_class.size() > 1) { - _set_error("Invalid inheritance (unknown class+subclasses)",p_class); + _set_error("Invalid inheritance (unknown class+subclasses)", p_class); return ERR_FILE_NOT_FOUND; - } //if not found, try engine classes if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) { - _set_error("Unknown class: '"+base+"'",p_class); + _set_error("Unknown class: '" + base + "'", p_class); return ERR_FILE_NOT_FOUND; } @@ -1770,66 +1723,62 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa native = GDScriptLanguage::get_singleton()->get_global_array()[base_idx]; if (!native.is_valid()) { - _set_error("Global not a class: '"+base+"'",p_class); + _set_error("Global not a class: '" + base + "'", p_class); return ERR_FILE_NOT_FOUND; } } - - } if (script.is_valid()) { - p_script->base=script; - p_script->_base=p_script->base.ptr(); - p_script->member_indices=script->member_indices; + p_script->base = script; + p_script->_base = p_script->base.ptr(); + p_script->member_indices = script->member_indices; } else if (native.is_valid()) { - p_script->native=native; + p_script->native = native; } else { - _set_error("Could not determine inheritance",p_class); + _set_error("Could not determine inheritance", p_class); return ERR_FILE_NOT_FOUND; } - - }else { + } else { // without extends, implicitly extend Reference int native_idx = GDScriptLanguage::get_singleton()->get_global_map()["Reference"]; native = GDScriptLanguage::get_singleton()->get_global_array()[native_idx]; ERR_FAIL_COND_V(native.is_null(), ERR_BUG); - p_script->native=native; + p_script->native = native; } //print_line("Script: "+p_script->get_path()+" indices: "+itos(p_script->member_indices.size())); - - for(int i=0;i<p_class->variables.size();i++) { + for (int i = 0; i < p_class->variables.size(); i++) { StringName name = p_class->variables[i].identifier; if (p_script->member_indices.has(name)) { - _set_error("Member '"+name+"' already exists (in current or parent class)",p_class); + _set_error("Member '" + name + "' already exists (in current or parent class)", p_class); return ERR_ALREADY_EXISTS; } - if (_is_class_member_property(p_script,name)) { - _set_error("Member '"+name+"' already exists as a class property.",p_class); + if (_is_class_member_property(p_script, name)) { + _set_error("Member '" + name + "' already exists as a class property.", p_class); return ERR_ALREADY_EXISTS; } - if (p_class->variables[i]._export.type!=Variant::NIL) { + if (p_class->variables[i]._export.type != Variant::NIL) { - p_script->member_info[name]=p_class->variables[i]._export; + p_script->member_info[name] = p_class->variables[i]._export; #ifdef TOOLS_ENABLED - if (p_class->variables[i].default_value.get_type()!=Variant::NIL) { + if (p_class->variables[i].default_value.get_type() != Variant::NIL) { - p_script->member_default_values[name]=p_class->variables[i].default_value; + p_script->member_default_values[name] = p_class->variables[i].default_value; } #endif } else { - p_script->member_info[name]=PropertyInfo(Variant::NIL,name,PROPERTY_HINT_NONE,"",PROPERTY_USAGE_SCRIPT_VARIABLE); + p_script->member_info[name] = PropertyInfo(Variant::NIL, name, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_SCRIPT_VARIABLE); } //int new_idx = p_script->member_indices.size(); @@ -1837,176 +1786,168 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa minfo.index = p_script->member_indices.size(); minfo.setter = p_class->variables[i].setter; minfo.getter = p_class->variables[i].getter; - minfo.rpc_mode=p_class->variables[i].rpc_mode; + minfo.rpc_mode = p_class->variables[i].rpc_mode; - p_script->member_indices[name]=minfo; + p_script->member_indices[name] = minfo; p_script->members.insert(name); #ifdef TOOLS_ENABLED - p_script->member_lines[name]=p_class->variables[i].line; + p_script->member_lines[name] = p_class->variables[i].line; #endif - - } - for(int i=0;i<p_class->constant_expressions.size();i++) { + for (int i = 0; i < p_class->constant_expressions.size(); i++) { StringName name = p_class->constant_expressions[i].identifier; - ERR_CONTINUE( p_class->constant_expressions[i].expression->type!=GDParser::Node::TYPE_CONSTANT ); + ERR_CONTINUE(p_class->constant_expressions[i].expression->type != GDParser::Node::TYPE_CONSTANT); - if (_is_class_member_property(p_script,name)) { - _set_error("Member '"+name+"' already exists as a class property.",p_class); + if (_is_class_member_property(p_script, name)) { + _set_error("Member '" + name + "' already exists as a class property.", p_class); return ERR_ALREADY_EXISTS; } - GDParser::ConstantNode *constant = static_cast<GDParser::ConstantNode*>(p_class->constant_expressions[i].expression); + GDParser::ConstantNode *constant = static_cast<GDParser::ConstantNode *>(p_class->constant_expressions[i].expression); - p_script->constants.insert(name,constant->value); - //p_script->constants[constant->value].make_const(); + p_script->constants.insert(name, constant->value); +//p_script->constants[constant->value].make_const(); #ifdef TOOLS_ENABLED - p_script->member_lines[name]=p_class->constant_expressions[i].expression->line; + p_script->member_lines[name] = p_class->constant_expressions[i].expression->line; #endif - } - for(int i=0;i<p_class->_signals.size();i++) { + for (int i = 0; i < p_class->_signals.size(); i++) { StringName name = p_class->_signals[i].name; GDScript *c = p_script; - while(c) { + while (c) { if (c->_signals.has(name)) { - _set_error("Signal '"+name+"' redefined (in current or parent class)",p_class); + _set_error("Signal '" + name + "' redefined (in current or parent class)", p_class); return ERR_ALREADY_EXISTS; } if (c->base.is_valid()) { - c=c->base.ptr(); + c = c->base.ptr(); } else { - c=NULL; + c = NULL; } } if (native.is_valid()) { - if (ClassDB::has_signal(native->get_name(),name)) { - _set_error("Signal '"+name+"' redefined (original in native class '"+String(native->get_name())+"')",p_class); + if (ClassDB::has_signal(native->get_name(), name)) { + _set_error("Signal '" + name + "' redefined (original in native class '" + String(native->get_name()) + "')", p_class); return ERR_ALREADY_EXISTS; } } - p_script->_signals[name]=p_class->_signals[i].arguments; + p_script->_signals[name] = p_class->_signals[i].arguments; } //parse sub-classes - for(int i=0;i<p_class->subclasses.size();i++) { + for (int i = 0; i < p_class->subclasses.size(); i++) { StringName name = p_class->subclasses[i]->name; Ref<GDScript> subclass; if (old_subclasses.has(name)) { - subclass=old_subclasses[name]; + subclass = old_subclasses[name]; } else { subclass.instance(); } - Error err = _parse_class(subclass.ptr(),p_script,p_class->subclasses[i],p_keep_state); + Error err = _parse_class(subclass.ptr(), p_script, p_class->subclasses[i], p_keep_state); if (err) return err; #ifdef TOOLS_ENABLED - p_script->member_lines[name]=p_class->subclasses[i]->line; + p_script->member_lines[name] = p_class->subclasses[i]->line; #endif - p_script->constants.insert(name,subclass); //once parsed, goes to the list of constants - p_script->subclasses.insert(name,subclass); - + p_script->constants.insert(name, subclass); //once parsed, goes to the list of constants + p_script->subclasses.insert(name, subclass); } - //parse methods - bool has_initializer=false; - bool has_ready=false; + bool has_initializer = false; + bool has_ready = false; - for(int i=0;i<p_class->functions.size();i++) { + for (int i = 0; i < p_class->functions.size(); i++) { - if (!has_initializer && p_class->functions[i]->name=="_init") - has_initializer=true; - if (!has_ready && p_class->functions[i]->name=="_ready") - has_ready=true; - Error err = _parse_function(p_script,p_class,p_class->functions[i]); + if (!has_initializer && p_class->functions[i]->name == "_init") + has_initializer = true; + if (!has_ready && p_class->functions[i]->name == "_ready") + has_ready = true; + Error err = _parse_function(p_script, p_class, p_class->functions[i]); if (err) return err; } //parse static methods - for(int i=0;i<p_class->static_functions.size();i++) { + for (int i = 0; i < p_class->static_functions.size(); i++) { - Error err = _parse_function(p_script,p_class,p_class->static_functions[i]); + Error err = _parse_function(p_script, p_class, p_class->static_functions[i]); if (err) return err; } - if (!has_initializer) { //create a constructor - Error err = _parse_function(p_script,p_class,NULL); + Error err = _parse_function(p_script, p_class, NULL); if (err) return err; } if (!has_ready && p_class->ready->statements.size()) { //create a constructor - Error err = _parse_function(p_script,p_class,NULL,true); + Error err = _parse_function(p_script, p_class, NULL, true); if (err) return err; } #ifdef DEBUG_ENABLED //validate setters/getters if debug is enabled - for(int i=0;i<p_class->variables.size();i++) { + for (int i = 0; i < p_class->variables.size(); i++) { if (p_class->variables[i].setter) { - const Map<StringName,GDFunction*>::Element *E=p_script->get_member_functions().find(p_class->variables[i].setter); + const Map<StringName, GDFunction *>::Element *E = p_script->get_member_functions().find(p_class->variables[i].setter); if (!E) { - _set_error("Setter function '"+String(p_class->variables[i].setter)+"' not found in class.",NULL); - err_line=p_class->variables[i].line; - err_column=0; + _set_error("Setter function '" + String(p_class->variables[i].setter) + "' not found in class.", NULL); + err_line = p_class->variables[i].line; + err_column = 0; return ERR_PARSE_ERROR; } if (E->get()->is_static()) { - _set_error("Setter function '"+String(p_class->variables[i].setter)+"' is static.",NULL); - err_line=p_class->variables[i].line; - err_column=0; + _set_error("Setter function '" + String(p_class->variables[i].setter) + "' is static.", NULL); + err_line = p_class->variables[i].line; + err_column = 0; return ERR_PARSE_ERROR; } - } if (p_class->variables[i].getter) { - const Map<StringName,GDFunction*>::Element *E=p_script->get_member_functions().find(p_class->variables[i].getter); + const Map<StringName, GDFunction *>::Element *E = p_script->get_member_functions().find(p_class->variables[i].getter); if (!E) { - _set_error("Getter function '"+String(p_class->variables[i].getter)+"' not found in class.",NULL); - err_line=p_class->variables[i].line; - err_column=0; + _set_error("Getter function '" + String(p_class->variables[i].getter) + "' not found in class.", NULL); + err_line = p_class->variables[i].line; + err_column = 0; return ERR_PARSE_ERROR; } if (E->get()->is_static()) { - _set_error("Getter function '"+String(p_class->variables[i].getter)+"' is static.",NULL); - err_line=p_class->variables[i].line; - err_column=0; + _set_error("Getter function '" + String(p_class->variables[i].getter) + "' is static.", NULL); + err_line = p_class->variables[i].line; + err_column = 0; return ERR_PARSE_ERROR; } - } } @@ -2014,96 +1955,88 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa if (p_keep_state) { - print_line("RELOAD KEEP "+p_script->path); - for (Set<Object*>::Element *E=p_script->instances.front();E;) { + print_line("RELOAD KEEP " + p_script->path); + for (Set<Object *>::Element *E = p_script->instances.front(); E;) { - Set<Object*>::Element *N = E->next(); + Set<Object *>::Element *N = E->next(); ScriptInstance *si = E->get()->get_script_instance(); if (si->is_placeholder()) { #ifdef TOOLS_ENABLED - PlaceHolderScriptInstance *psi = static_cast<PlaceHolderScriptInstance*>(si); + PlaceHolderScriptInstance *psi = static_cast<PlaceHolderScriptInstance *>(si); if (p_script->is_tool()) { //re-create as an instance p_script->placeholders.erase(psi); //remove placeholder - GDInstance* instance = memnew( GDInstance ); - instance->base_ref=E->get()->cast_to<Reference>(); + GDInstance *instance = memnew(GDInstance); + instance->base_ref = E->get()->cast_to<Reference>(); instance->members.resize(p_script->member_indices.size()); - instance->script=Ref<GDScript>(p_script); - instance->owner=E->get(); + instance->script = Ref<GDScript>(p_script); + instance->owner = E->get(); //needed for hot reloading - for(Map<StringName,GDScript::MemberInfo>::Element *E=p_script->member_indices.front();E;E=E->next()) { - instance->member_indices_cache[E->key()]=E->get().index; + for (Map<StringName, GDScript::MemberInfo>::Element *E = p_script->member_indices.front(); E; E = E->next()) { + instance->member_indices_cache[E->key()] = E->get().index; } instance->owner->set_script_instance(instance); - /* STEP 2, INITIALIZE AND CONSRTUCT */ Variant::CallError ce; - p_script->initializer->call(instance,NULL,0,ce); + p_script->initializer->call(instance, NULL, 0, ce); - if (ce.error!=Variant::CallError::CALL_OK) { + if (ce.error != Variant::CallError::CALL_OK) { //well, tough luck, not goinna do anything here } } #endif } else { - GDInstance *gi = static_cast<GDInstance*>(si); + GDInstance *gi = static_cast<GDInstance *>(si); gi->reload_members(); } - E=N; - + E = N; } - - } #endif - p_script->valid=true; + p_script->valid = true; return OK; } -Error GDCompiler::compile(const GDParser *p_parser,GDScript *p_script,bool p_keep_state) { +Error GDCompiler::compile(const GDParser *p_parser, GDScript *p_script, bool p_keep_state) { - err_line=-1; - err_column=-1; - error=""; - parser=p_parser; - const GDParser::Node* root = parser->get_parse_tree(); - ERR_FAIL_COND_V(root->type!=GDParser::Node::TYPE_CLASS,ERR_INVALID_DATA); + err_line = -1; + err_column = -1; + error = ""; + parser = p_parser; + const GDParser::Node *root = parser->get_parse_tree(); + ERR_FAIL_COND_V(root->type != GDParser::Node::TYPE_CLASS, ERR_INVALID_DATA); - source=p_script->get_path(); + source = p_script->get_path(); - Error err = _parse_class(p_script,NULL,static_cast<const GDParser::ClassNode*>(root),p_keep_state); + Error err = _parse_class(p_script, NULL, static_cast<const GDParser::ClassNode *>(root), p_keep_state); if (err) return err; return OK; - } String GDCompiler::get_error() const { return error; } -int GDCompiler::get_error_line() const{ +int GDCompiler::get_error_line() const { return err_line; } -int GDCompiler::get_error_column() const{ +int GDCompiler::get_error_column() const { return err_column; } -GDCompiler::GDCompiler() -{ +GDCompiler::GDCompiler() { } - - |