summaryrefslogtreecommitdiffstats
path: root/modules/gdscript/gd_compiler.cpp
diff options
context:
space:
mode:
authorRémi Verschelde <rverschelde@gmail.com>2017-03-05 16:44:50 +0100
committerRémi Verschelde <rverschelde@gmail.com>2017-03-05 16:44:50 +0100
commit5dbf1809c6e3e905b94b8764e99491e608122261 (patch)
tree5e5a5360db15d86d59ec8c6e4f7eb511388c5a9a /modules/gdscript/gd_compiler.cpp
parent45438e9918d421b244bfd7776a30e67dc7f2d3e3 (diff)
downloadredot-engine-5dbf1809c6e3e905b94b8764e99491e608122261.tar.gz
A Whole New World (clang-format edition)
I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
Diffstat (limited to 'modules/gdscript/gd_compiler.cpp')
-rw-r--r--modules/gdscript/gd_compiler.cpp1303
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() {
}
-
-