diff options
Diffstat (limited to 'modules/gdscript/gd_editor.cpp')
| -rw-r--r-- | modules/gdscript/gd_editor.cpp | 2016 |
1 files changed, 915 insertions, 1101 deletions
diff --git a/modules/gdscript/gd_editor.cpp b/modules/gdscript/gd_editor.cpp index 9dd41847d7..bd428941e0 100644 --- a/modules/gdscript/gd_editor.cpp +++ b/modules/gdscript/gd_editor.cpp @@ -26,8 +26,8 @@ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ -#include "gd_script.h" #include "gd_compiler.h" +#include "gd_script.h" #include "global_config.h" #include "os/file_access.h" @@ -35,73 +35,64 @@ void GDScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const p_delimiters->push_back("#"); p_delimiters->push_back("\"\"\" \"\"\""); - } void GDScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const { p_delimiters->push_back("\" \""); p_delimiters->push_back("' '"); - - } -Ref<Script> GDScriptLanguage::get_template(const String& p_class_name, const String& p_base_class_name) const { +Ref<Script> GDScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const { - String _template = String()+ - "extends %BASE%\n\n"+ - "# class member variables go here, for example:\n"+ - "# var a = 2\n"+ - "# var b = \"textvar\"\n\n"+ - "func _ready():\n"+ - "\t# Called every time the node is added to the scene.\n"+ - "\t# Initialization here\n"+ - "\tpass\n"; + String _template = String() + + "extends %BASE%\n\n" + + "# class member variables go here, for example:\n" + + "# var a = 2\n" + + "# var b = \"textvar\"\n\n" + + "func _ready():\n" + + "\t# Called every time the node is added to the scene.\n" + + "\t# Initialization here\n" + + "\tpass\n"; - _template = _template.replace("%BASE%",p_base_class_name); + _template = _template.replace("%BASE%", p_base_class_name); Ref<GDScript> script; script.instance(); script->set_source_code(_template); return script; - } - - - -bool GDScriptLanguage::validate(const String& p_script, int &r_line_error,int &r_col_error,String& r_test_error, const String& p_path,List<String> *r_functions) const { +bool GDScriptLanguage::validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions) const { GDParser parser; - Error err = parser.parse(p_script,p_path.get_base_dir(),true,p_path); + Error err = parser.parse(p_script, p_path.get_base_dir(), true, p_path); if (err) { - r_line_error=parser.get_error_line(); - r_col_error=parser.get_error_column(); - r_test_error=parser.get_error(); + r_line_error = parser.get_error_line(); + r_col_error = parser.get_error_column(); + r_test_error = parser.get_error(); return false; } else { const GDParser::Node *root = parser.get_parse_tree(); - ERR_FAIL_COND_V(root->type!=GDParser::Node::TYPE_CLASS,false); + ERR_FAIL_COND_V(root->type != GDParser::Node::TYPE_CLASS, false); - const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode*>(root); - Map<int,String> funcs; - for(int i=0;i<cl->functions.size();i++) { + const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode *>(root); + Map<int, String> funcs; + for (int i = 0; i < cl->functions.size(); i++) { - funcs[cl->functions[i]->line]=cl->functions[i]->name; + funcs[cl->functions[i]->line] = cl->functions[i]->name; } - for(int i=0;i<cl->static_functions.size();i++) { + for (int i = 0; i < cl->static_functions.size(); i++) { - funcs[cl->static_functions[i]->line]=cl->static_functions[i]->name; + funcs[cl->static_functions[i]->line] = cl->static_functions[i]->name; } - for (Map<int,String>::Element *E=funcs.front();E;E=E->next()) { + for (Map<int, String>::Element *E = funcs.front(); E; E = E->next()) { - r_functions->push_back(E->get()+":"+itos(E->key())); + r_functions->push_back(E->get() + ":" + itos(E->key())); } - - } return true; @@ -112,142 +103,133 @@ bool GDScriptLanguage::has_named_classes() const { return false; } -int GDScriptLanguage::find_function(const String& p_function,const String& p_code) const { +int GDScriptLanguage::find_function(const String &p_function, const String &p_code) const { GDTokenizerText tokenizer; tokenizer.set_code(p_code); - int indent=0; - while(tokenizer.get_token()!=GDTokenizer::TK_EOF && tokenizer.get_token()!=GDTokenizer::TK_ERROR) { + int indent = 0; + while (tokenizer.get_token() != GDTokenizer::TK_EOF && tokenizer.get_token() != GDTokenizer::TK_ERROR) { - if (tokenizer.get_token()==GDTokenizer::TK_NEWLINE) { - indent=tokenizer.get_token_line_indent(); + if (tokenizer.get_token() == GDTokenizer::TK_NEWLINE) { + indent = tokenizer.get_token_line_indent(); } //print_line("TOKEN: "+String(GDTokenizer::get_token_name(tokenizer.get_token()))); - if (indent==0 && tokenizer.get_token()==GDTokenizer::TK_PR_FUNCTION && tokenizer.get_token(1)==GDTokenizer::TK_IDENTIFIER) { + if (indent == 0 && tokenizer.get_token() == GDTokenizer::TK_PR_FUNCTION && tokenizer.get_token(1) == GDTokenizer::TK_IDENTIFIER) { String identifier = tokenizer.get_token_identifier(1); - if (identifier==p_function) { + if (identifier == p_function) { return tokenizer.get_token_line(); } } tokenizer.advance(); //print_line("NEXT: "+String(GDTokenizer::get_token_name(tokenizer.get_token()))); - } return -1; } Script *GDScriptLanguage::create_script() const { - return memnew( GDScript ); + return memnew(GDScript); } /* DEBUGGER FUNCTIONS */ - -bool GDScriptLanguage::debug_break_parse(const String& p_file, int p_line,const String& p_error) { +bool GDScriptLanguage::debug_break_parse(const String &p_file, int p_line, const String &p_error) { //break because of parse error - if (ScriptDebugger::get_singleton() && Thread::get_caller_ID()==Thread::get_main_ID()) { - - _debug_parse_err_line=p_line; - _debug_parse_err_file=p_file; - _debug_error=p_error; - ScriptDebugger::get_singleton()->debug(this,false); - return true; - } else { - return false; - } + if (ScriptDebugger::get_singleton() && Thread::get_caller_ID() == Thread::get_main_ID()) { + _debug_parse_err_line = p_line; + _debug_parse_err_file = p_file; + _debug_error = p_error; + ScriptDebugger::get_singleton()->debug(this, false); + return true; + } else { + return false; + } } -bool GDScriptLanguage::debug_break(const String& p_error,bool p_allow_continue) { - - if (ScriptDebugger::get_singleton() && Thread::get_caller_ID()==Thread::get_main_ID()) { +bool GDScriptLanguage::debug_break(const String &p_error, bool p_allow_continue) { - _debug_parse_err_line=-1; - _debug_parse_err_file=""; - _debug_error=p_error; - ScriptDebugger::get_singleton()->debug(this,p_allow_continue); - return true; - } else { - return false; - } + if (ScriptDebugger::get_singleton() && Thread::get_caller_ID() == Thread::get_main_ID()) { + _debug_parse_err_line = -1; + _debug_parse_err_file = ""; + _debug_error = p_error; + ScriptDebugger::get_singleton()->debug(this, p_allow_continue); + return true; + } else { + return false; + } } String GDScriptLanguage::debug_get_error() const { - return _debug_error; + return _debug_error; } int GDScriptLanguage::debug_get_stack_level_count() const { - if (_debug_parse_err_line>=0) + if (_debug_parse_err_line >= 0) return 1; - return _debug_call_stack_pos; } int GDScriptLanguage::debug_get_stack_level_line(int p_level) const { - if (_debug_parse_err_line>=0) + if (_debug_parse_err_line >= 0) return _debug_parse_err_line; - ERR_FAIL_INDEX_V(p_level,_debug_call_stack_pos,-1); + ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, -1); - int l = _debug_call_stack_pos - p_level -1; - - return *(_call_stack[l].line); + int l = _debug_call_stack_pos - p_level - 1; + return *(_call_stack[l].line); } String GDScriptLanguage::debug_get_stack_level_function(int p_level) const { - if (_debug_parse_err_line>=0) + if (_debug_parse_err_line >= 0) return ""; - ERR_FAIL_INDEX_V(p_level,_debug_call_stack_pos,""); - int l = _debug_call_stack_pos - p_level -1; - return _call_stack[l].function->get_name(); + ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, ""); + int l = _debug_call_stack_pos - p_level - 1; + return _call_stack[l].function->get_name(); } String GDScriptLanguage::debug_get_stack_level_source(int p_level) const { - if (_debug_parse_err_line>=0) + if (_debug_parse_err_line >= 0) return _debug_parse_err_file; - ERR_FAIL_INDEX_V(p_level,_debug_call_stack_pos,""); - int l = _debug_call_stack_pos - p_level -1; - return _call_stack[l].function->get_source(); - + ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, ""); + int l = _debug_call_stack_pos - p_level - 1; + return _call_stack[l].function->get_source(); } -void GDScriptLanguage::debug_get_stack_level_locals(int p_level,List<String> *p_locals, List<Variant> *p_values, int p_max_subitems,int p_max_depth) { +void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) { - if (_debug_parse_err_line>=0) + if (_debug_parse_err_line >= 0) return; - ERR_FAIL_INDEX(p_level,_debug_call_stack_pos); - int l = _debug_call_stack_pos - p_level -1; + ERR_FAIL_INDEX(p_level, _debug_call_stack_pos); + int l = _debug_call_stack_pos - p_level - 1; - GDFunction *f = _call_stack[l].function; + GDFunction *f = _call_stack[l].function; - List<Pair<StringName,int> > locals; + List<Pair<StringName, int> > locals; - f->debug_get_stack_member_state(*_call_stack[l].line,&locals); - for( List<Pair<StringName,int> >::Element *E = locals.front();E;E=E->next() ) { - - p_locals->push_back(E->get().first); - p_values->push_back(_call_stack[l].stack[E->get().second]); - } + f->debug_get_stack_member_state(*_call_stack[l].line, &locals); + for (List<Pair<StringName, int> >::Element *E = locals.front(); E; E = E->next()) { + p_locals->push_back(E->get().first); + p_values->push_back(_call_stack[l].stack[E->get().second]); + } } -void GDScriptLanguage::debug_get_stack_level_members(int p_level,List<String> *p_members, List<Variant> *p_values, int p_max_subitems,int p_max_depth) { +void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) { - if (_debug_parse_err_line>=0) + if (_debug_parse_err_line >= 0) return; - ERR_FAIL_INDEX(p_level,_debug_call_stack_pos); - int l = _debug_call_stack_pos - p_level -1; - + ERR_FAIL_INDEX(p_level, _debug_call_stack_pos); + int l = _debug_call_stack_pos - p_level - 1; GDInstance *instance = _call_stack[l].instance; @@ -255,25 +237,23 @@ void GDScriptLanguage::debug_get_stack_level_members(int p_level,List<String> *p return; Ref<GDScript> script = instance->get_script(); - ERR_FAIL_COND( script.is_null() ); - + ERR_FAIL_COND(script.is_null()); - const Map<StringName,GDScript::MemberInfo>& mi = script->debug_get_member_indices(); + const Map<StringName, GDScript::MemberInfo> &mi = script->debug_get_member_indices(); - for(const Map<StringName,GDScript::MemberInfo>::Element *E=mi.front();E;E=E->next()) { + for (const Map<StringName, GDScript::MemberInfo>::Element *E = mi.front(); E; E = E->next()) { p_members->push_back(E->key()); - p_values->push_back( instance->debug_get_member_by_index(E->get().index)); + p_values->push_back(instance->debug_get_member_by_index(E->get().index)); } - } -void GDScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems,int p_max_depth) { +void GDScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) { - //no globals are really reachable in gdscript + //no globals are really reachable in gdscript } -String GDScriptLanguage::debug_parse_stack_level_expression(int p_level,const String& p_expression,int p_max_subitems,int p_max_depth) { +String GDScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) { - if (_debug_parse_err_line>=0) + if (_debug_parse_err_line >= 0) return ""; return ""; } @@ -283,11 +263,9 @@ void GDScriptLanguage::get_recognized_extensions(List<String> *p_extensions) con p_extensions->push_back("gd"); } - void GDScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const { - - for(int i=0;i<GDFunctions::FUNC_MAX;i++) { + for (int i = 0; i < GDFunctions::FUNC_MAX; i++) { p_functions->push_back(GDFunctions::get_info(GDFunctions::Function(i))); } @@ -295,33 +273,33 @@ void GDScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const //not really "functions", but.. { MethodInfo mi; - mi.name="preload:Resource"; - mi.arguments.push_back(PropertyInfo(Variant::STRING,"path")); - mi.return_val=PropertyInfo(Variant::OBJECT,"",PROPERTY_HINT_RESOURCE_TYPE,"Resource"); + mi.name = "preload:Resource"; + mi.arguments.push_back(PropertyInfo(Variant::STRING, "path")); + mi.return_val = PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_RESOURCE_TYPE, "Resource"); p_functions->push_back(mi); } { MethodInfo mi; - mi.name="yield:GDFunctionState"; - mi.arguments.push_back(PropertyInfo(Variant::OBJECT,"object")); - mi.arguments.push_back(PropertyInfo(Variant::STRING,"signal")); + mi.name = "yield:GDFunctionState"; + mi.arguments.push_back(PropertyInfo(Variant::OBJECT, "object")); + mi.arguments.push_back(PropertyInfo(Variant::STRING, "signal")); mi.default_arguments.push_back(Variant::NIL); mi.default_arguments.push_back(Variant::STRING); p_functions->push_back(mi); } { MethodInfo mi; - mi.name="assert"; - mi.arguments.push_back(PropertyInfo(Variant::BOOL,"condition")); + mi.name = "assert"; + mi.arguments.push_back(PropertyInfo(Variant::BOOL, "condition")); p_functions->push_back(mi); } } -void GDScriptLanguage::get_public_constants(List<Pair<String,Variant> > *p_constants) const { +void GDScriptLanguage::get_public_constants(List<Pair<String, Variant> > *p_constants) const { - Pair<String,Variant> pi; - pi.first="PI"; - pi.second=Math_PI; + Pair<String, Variant> pi; + pi.first = "PI"; + pi.second = Math_PI; p_constants->push_back(pi); Pair<String, Variant> infinity; @@ -335,22 +313,21 @@ void GDScriptLanguage::get_public_constants(List<Pair<String,Variant> > *p_const p_constants->push_back(nan); } -String GDScriptLanguage::make_function(const String& p_class,const String& p_name,const PoolStringArray& p_args) const { +String GDScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const { - String s="func "+p_name+"("; + String s = "func " + p_name + "("; if (p_args.size()) { - s+=" "; - for(int i=0;i<p_args.size();i++) { - if (i>0) - s+=", "; - s+=p_args[i].get_slice(":",0); + s += " "; + for (int i = 0; i < p_args.size(); i++) { + if (i > 0) + s += ", "; + s += p_args[i].get_slice(":", 0); } - s+=" "; + s += " "; } - s+="):\n\tpass # replace with function body\n"; + s += "):\n\tpass # replace with function body\n"; return s; - } #if defined(DEBUG_METHODS_ENABLED) && defined(TOOLS_ENABLED) @@ -361,17 +338,14 @@ struct GDCompletionIdentifier { Ref<GDScript> script; Variant::Type type; Variant value; //im case there is a value, also return it - }; - - -static GDCompletionIdentifier _get_type_from_variant(const Variant& p_variant) { +static GDCompletionIdentifier _get_type_from_variant(const Variant &p_variant) { GDCompletionIdentifier t; - t.type=p_variant.get_type(); - t.value=p_variant; - if (p_variant.get_type()==Variant::OBJECT) { + t.type = p_variant.get_type(); + t.value = p_variant; + if (p_variant.get_type() == Variant::OBJECT) { Object *obj = p_variant; if (obj) { /* @@ -380,19 +354,19 @@ static GDCompletionIdentifier _get_type_from_variant(const Variant& p_variant) { t.value=Variant(); } else { */ - t.obj_type=obj->get_class(); + t.obj_type = obj->get_class(); //} } } return t; } -static GDCompletionIdentifier _get_type_from_pinfo(const PropertyInfo& p_info) { +static GDCompletionIdentifier _get_type_from_pinfo(const PropertyInfo &p_info) { GDCompletionIdentifier t; - t.type=p_info.type; - if (p_info.hint==PROPERTY_HINT_RESOURCE_TYPE) { - t.obj_type=p_info.hint_string; + t.type = p_info.type; + if (p_info.hint == PROPERTY_HINT_RESOURCE_TYPE) { + t.obj_type = p_info.hint_string; } return t; } @@ -402,15 +376,11 @@ struct GDCompletionContext { const GDParser::ClassNode *_class; const GDParser::FunctionNode *function; const GDParser::BlockNode *block; - Object* base; + Object *base; String base_path; - }; - -static Ref<Reference> _get_parent_class(GDCompletionContext& context) { - - +static Ref<Reference> _get_parent_class(GDCompletionContext &context) { if (context._class->extends_used) { //do inheritance @@ -419,12 +389,12 @@ static Ref<Reference> _get_parent_class(GDCompletionContext& context) { Ref<GDScript> script; Ref<GDNativeClass> native; - if (path!="") { + if (path != "") { //path (and optionally subclasses) if (path.is_rel_path()) { - path=context.base_path.plus_file(path); + path = context.base_path.plus_file(path); } if (ScriptCodeCompletionCache::get_sigleton()) @@ -443,12 +413,12 @@ static Ref<Reference> _get_parent_class(GDCompletionContext& context) { if (context._class->extends_class.size()) { - for(int i=0;i<context._class->extends_class.size();i++) { + for (int i = 0; i < context._class->extends_class.size(); i++) { String sub = context._class->extends_class[i]; if (script->get_subclasses().has(sub)) { - script=script->get_subclasses()[sub]; + script = script->get_subclasses()[sub]; } else { return REF(); @@ -461,17 +431,16 @@ static Ref<Reference> _get_parent_class(GDCompletionContext& context) { } else { - if (context._class->extends_class.size()==0) { + if (context._class->extends_class.size() == 0) { ERR_PRINT("BUG"); return REF(); } - String base=context._class->extends_class[0]; + String base = context._class->extends_class[0]; - if (context._class->extends_class.size()>1) { + if (context._class->extends_class.size() > 1) { return REF(); - } //if not found, try engine classes if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) { @@ -482,22 +451,19 @@ static Ref<Reference> _get_parent_class(GDCompletionContext& context) { int base_idx = GDScriptLanguage::get_singleton()->get_global_map()[base]; native = GDScriptLanguage::get_singleton()->get_global_array()[base_idx]; return native; - } - } return Ref<Reference>(); } - -static GDCompletionIdentifier _get_native_class(GDCompletionContext& context) { +static GDCompletionIdentifier _get_native_class(GDCompletionContext &context) { //eeh... GDCompletionIdentifier id; - id.type=Variant::NIL; + id.type = Variant::NIL; - REF pc = _get_parent_class(context); + REF pc = _get_parent_class(context); if (!pc.is_valid()) { return id; } @@ -507,204 +473,191 @@ static GDCompletionIdentifier _get_native_class(GDCompletionContext& context) { if (s.is_null() && nc.is_null()) { return id; } - while(!s.is_null()) { - nc=s->get_native(); - s=s->get_base(); + while (!s.is_null()) { + nc = s->get_native(); + s = s->get_base(); } if (nc.is_null()) { return id; } - - - id.type=Variant::OBJECT; + id.type = Variant::OBJECT; if (context.base) - id.value=context.base; - id.obj_type=nc->get_name(); + id.value = context.base; + id.obj_type = nc->get_name(); return id; } -static bool _guess_identifier_type(GDCompletionContext& context,int p_line,const StringName& p_identifier,GDCompletionIdentifier &r_type); - +static bool _guess_identifier_type(GDCompletionContext &context, int p_line, const StringName &p_identifier, GDCompletionIdentifier &r_type); -static bool _guess_expression_type(GDCompletionContext& context,const GDParser::Node* p_node,int p_line,GDCompletionIdentifier &r_type) { +static bool _guess_expression_type(GDCompletionContext &context, const GDParser::Node *p_node, int p_line, GDCompletionIdentifier &r_type) { + if (p_node->type == GDParser::Node::TYPE_CONSTANT) { - if (p_node->type==GDParser::Node::TYPE_CONSTANT) { + const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode *>(p_node); - const GDParser::ConstantNode *cn=static_cast<const GDParser::ConstantNode *>(p_node); - - r_type=_get_type_from_variant(cn->value); + r_type = _get_type_from_variant(cn->value); return true; - } else if (p_node->type==GDParser::Node::TYPE_DICTIONARY) { - - r_type.type=Variant::DICTIONARY; + } else if (p_node->type == GDParser::Node::TYPE_DICTIONARY) { + r_type.type = Variant::DICTIONARY; //what the heck, fill it anyway const GDParser::DictionaryNode *an = static_cast<const GDParser::DictionaryNode *>(p_node); Dictionary d; - for(int i=0;i<an->elements.size();i++) { + for (int i = 0; i < an->elements.size(); i++) { GDCompletionIdentifier k; - if (_guess_expression_type(context,an->elements[i].key,p_line,k) && k.value.get_type()!=Variant::NIL) { + if (_guess_expression_type(context, an->elements[i].key, p_line, k) && k.value.get_type() != Variant::NIL) { GDCompletionIdentifier v; - if (_guess_expression_type(context,an->elements[i].value,p_line,v)) { - d[k.value]=v.value; + if (_guess_expression_type(context, an->elements[i].value, p_line, v)) { + d[k.value] = v.value; } - } } - r_type.value=d; + r_type.value = d; return true; - } else if (p_node->type==GDParser::Node::TYPE_ARRAY) { + } else if (p_node->type == GDParser::Node::TYPE_ARRAY) { - r_type.type=Variant::ARRAY; + r_type.type = Variant::ARRAY; //what the heck, fill it anyway const GDParser::ArrayNode *an = static_cast<const GDParser::ArrayNode *>(p_node); Array arr; arr.resize(an->elements.size()); - for(int i=0;i<an->elements.size();i++) { + for (int i = 0; i < an->elements.size(); i++) { GDCompletionIdentifier ci; - if (_guess_expression_type(context,an->elements[i],p_line,ci)) { - arr[i]=ci.value; + if (_guess_expression_type(context, an->elements[i], p_line, ci)) { + arr[i] = ci.value; } } - r_type.value=arr; + r_type.value = arr; return true; - } else if (p_node->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) { + } else if (p_node->type == GDParser::Node::TYPE_BUILT_IN_FUNCTION) { - MethodInfo mi = GDFunctions::get_info(static_cast<const GDParser::BuiltInFunctionNode*>(p_node)->function); - r_type=_get_type_from_pinfo(mi.return_val); + MethodInfo mi = GDFunctions::get_info(static_cast<const GDParser::BuiltInFunctionNode *>(p_node)->function); + r_type = _get_type_from_pinfo(mi.return_val); return true; - } else if (p_node->type==GDParser::Node::TYPE_IDENTIFIER) { + } else if (p_node->type == GDParser::Node::TYPE_IDENTIFIER) { - return _guess_identifier_type(context,p_line-1,static_cast<const GDParser::IdentifierNode *>(p_node)->name,r_type); - } else if (p_node->type==GDParser::Node::TYPE_SELF) { + return _guess_identifier_type(context, p_line - 1, static_cast<const GDParser::IdentifierNode *>(p_node)->name, r_type); + } else if (p_node->type == GDParser::Node::TYPE_SELF) { //eeh... - r_type=_get_native_class(context); - return r_type.type!=Variant::NIL; - - } else if (p_node->type==GDParser::Node::TYPE_OPERATOR) { + r_type = _get_native_class(context); + return r_type.type != Variant::NIL; + } else if (p_node->type == GDParser::Node::TYPE_OPERATOR) { const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(p_node); - if (op->op==GDParser::OperatorNode::OP_CALL) { - if (op->arguments[0]->type==GDParser::Node::TYPE_TYPE) { + if (op->op == GDParser::OperatorNode::OP_CALL) { + if (op->arguments[0]->type == GDParser::Node::TYPE_TYPE) { const GDParser::TypeNode *tn = static_cast<const GDParser::TypeNode *>(op->arguments[0]); - r_type.type=tn->vtype; + r_type.type = tn->vtype; return true; - } else if (op->arguments[0]->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) { - + } else if (op->arguments[0]->type == GDParser::Node::TYPE_BUILT_IN_FUNCTION) { const GDParser::BuiltInFunctionNode *bin = static_cast<const GDParser::BuiltInFunctionNode *>(op->arguments[0]); - return _guess_expression_type(context,bin,p_line,r_type); - - } else if (op->arguments.size()>1 && op->arguments[1]->type==GDParser::Node::TYPE_IDENTIFIER) { + return _guess_expression_type(context, bin, p_line, r_type); + } else if (op->arguments.size() > 1 && op->arguments[1]->type == GDParser::Node::TYPE_IDENTIFIER) { GDCompletionIdentifier base; - if (!_guess_expression_type(context,op->arguments[0],p_line,base)) + if (!_guess_expression_type(context, op->arguments[0], p_line, base)) return false; StringName id = static_cast<const GDParser::IdentifierNode *>(op->arguments[1])->name; - if (base.type==Variant::OBJECT) { + if (base.type == Variant::OBJECT) { - if (id.operator String()=="new" && base.value.get_type()==Variant::OBJECT) { + if (id.operator String() == "new" && base.value.get_type() == Variant::OBJECT) { Object *obj = base.value; if (obj && obj->cast_to<GDNativeClass>()) { GDNativeClass *gdnc = obj->cast_to<GDNativeClass>(); - r_type.type=Variant::OBJECT; - r_type.value=Variant(); - r_type.obj_type=gdnc->get_name(); + r_type.type = Variant::OBJECT; + r_type.value = Variant(); + r_type.obj_type = gdnc->get_name(); return true; } } - if (ClassDB::has_method(base.obj_type,id)) { + if (ClassDB::has_method(base.obj_type, id)) { #ifdef TOOLS_ENABLED - MethodBind *mb = ClassDB::get_method(base.obj_type,id); + MethodBind *mb = ClassDB::get_method(base.obj_type, id); PropertyInfo pi = mb->get_argument_info(-1); //try calling the function if constant and all args are constant, should not crash.. Object *baseptr = base.value; + if (mb->is_const() && pi.type == Variant::OBJECT) { - if (mb->is_const() && pi.type==Variant::OBJECT) { - - bool all_valid=true; + bool all_valid = true; Vector<Variant> args; - for(int i=2;i<op->arguments.size();i++) { + for (int i = 2; i < op->arguments.size(); i++) { GDCompletionIdentifier arg; - if (_guess_expression_type(context,op->arguments[i],p_line,arg)) { - if (arg.value.get_type()!=Variant::NIL && arg.value.get_type()!=Variant::OBJECT) { // calling with object seems dangerous, i don' t know + if (_guess_expression_type(context, op->arguments[i], p_line, arg)) { + if (arg.value.get_type() != Variant::NIL && arg.value.get_type() != Variant::OBJECT) { // calling with object seems dangerous, i don' t know args.push_back(arg.value); } else { - all_valid=false; + all_valid = false; break; } } else { - all_valid=false; + all_valid = false; } } - if (all_valid && String(id)=="get_node" && ClassDB::is_parent_class(base.obj_type,"Node") && args.size()) { + if (all_valid && String(id) == "get_node" && ClassDB::is_parent_class(base.obj_type, "Node") && args.size()) { - String arg1=args[0]; + String arg1 = args[0]; if (arg1.begins_with("/root/")) { - String which = arg1.get_slice("/",2); - if (which!="") { + String which = arg1.get_slice("/", 2); + if (which != "") { List<PropertyInfo> props; GlobalConfig::get_singleton()->get_property_list(&props); //print_line("find singleton"); - for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) { + for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) { String s = E->get().name; if (!s.begins_with("autoload/")) continue; //print_line("found "+s); - String name = s.get_slice("/",1); + String name = s.get_slice("/", 1); //print_line("name: "+name+", which: "+which); - if (name==which) { + if (name == which) { String script = GlobalConfig::get_singleton()->get(s); if (!script.begins_with("res://")) { - script="res://"+script; + script = "res://" + script; } if (!script.ends_with(".gd")) { //not a script, try find the script anyway, //may have some success - script=script.get_basename()+".gd"; + script = script.get_basename() + ".gd"; } if (FileAccess::exists(script)) { //print_line("is a script"); - Ref<Script> scr; if (ScriptCodeCompletionCache::get_sigleton()) scr = ScriptCodeCompletionCache::get_sigleton()->get_cached_resource(script); else scr = ResourceLoader::load(script); - - r_type.obj_type="Node"; - r_type.type=Variant::OBJECT; - r_type.script=scr; - r_type.value=Variant(); + r_type.obj_type = "Node"; + r_type.type = Variant::OBJECT; + r_type.script = scr; + r_type.value = Variant(); return true; - } } } @@ -712,40 +665,34 @@ static bool _guess_expression_type(GDCompletionContext& context,const GDParser:: } } - - if (baseptr) { if (all_valid) { - Vector<const Variant*> argptr; - for(int i=0;i<args.size();i++) { + Vector<const Variant *> argptr; + for (int i = 0; i < args.size(); i++) { argptr.push_back(&args[i]); } Variant::CallError ce; - Variant ret=mb->call(baseptr,argptr.ptr(),argptr.size(),ce); + Variant ret = mb->call(baseptr, argptr.ptr(), argptr.size(), ce); + if (ce.error == Variant::CallError::CALL_OK && ret.get_type() != Variant::NIL) { - if (ce.error==Variant::CallError::CALL_OK && ret.get_type()!=Variant::NIL) { + if (ret.get_type() != Variant::OBJECT || ret.operator Object *() != NULL) { - if (ret.get_type()!=Variant::OBJECT || ret.operator Object*()!=NULL) { - - r_type=_get_type_from_variant(ret); + r_type = _get_type_from_variant(ret); return true; } } - } } } - r_type.type=pi.type; - if (pi.hint==PROPERTY_HINT_RESOURCE_TYPE) { - r_type.obj_type=pi.hint_string; + r_type.type = pi.type; + if (pi.hint == PROPERTY_HINT_RESOURCE_TYPE) { + r_type.obj_type = pi.hint_string; } - - return true; #else return false; @@ -756,115 +703,108 @@ static bool _guess_expression_type(GDCompletionContext& context,const GDParser:: } else { //method for some variant.. Variant::CallError ce; - Variant v = Variant::construct(base.type,NULL,0,ce); + Variant v = Variant::construct(base.type, NULL, 0, ce); List<MethodInfo> mi; v.get_method_list(&mi); - for (List<MethodInfo>::Element *E=mi.front();E;E=E->next()) { - - if (!E->get().name.begins_with("_") && E->get().name==id.operator String()) { + for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) { + if (!E->get().name.begins_with("_") && E->get().name == id.operator String()) { MethodInfo mi = E->get(); - r_type.type=mi.return_val.type; - if (mi.return_val.hint==PROPERTY_HINT_RESOURCE_TYPE) { - r_type.obj_type=mi.return_val.hint_string; + r_type.type = mi.return_val.type; + if (mi.return_val.hint == PROPERTY_HINT_RESOURCE_TYPE) { + r_type.obj_type = mi.return_val.hint_string; } return true; } } - } - - } - } else if (op->op==GDParser::OperatorNode::OP_INDEX || op->op==GDParser::OperatorNode::OP_INDEX_NAMED) { + } else if (op->op == GDParser::OperatorNode::OP_INDEX || op->op == GDParser::OperatorNode::OP_INDEX_NAMED) { GDCompletionIdentifier p1; GDCompletionIdentifier p2; + if (op->op == GDParser::OperatorNode::OP_INDEX_NAMED) { - - if (op->op==GDParser::OperatorNode::OP_INDEX_NAMED) { - - if (op->arguments[1]->type==GDParser::Node::TYPE_IDENTIFIER) { - String id = static_cast<const GDParser::IdentifierNode*>(op->arguments[1])->name; - p2.type=Variant::STRING; - p2.value=id; + if (op->arguments[1]->type == GDParser::Node::TYPE_IDENTIFIER) { + String id = static_cast<const GDParser::IdentifierNode *>(op->arguments[1])->name; + p2.type = Variant::STRING; + p2.value = id; } } else { if (op->arguments[1]) { - if (!_guess_expression_type(context,op->arguments[1],p_line,p2)) { + if (!_guess_expression_type(context, op->arguments[1], p_line, p2)) { return false; } } } - if (op->arguments[0]->type==GDParser::Node::TYPE_ARRAY) { + if (op->arguments[0]->type == GDParser::Node::TYPE_ARRAY) { const GDParser::ArrayNode *an = static_cast<const GDParser::ArrayNode *>(op->arguments[0]); if (p2.value.is_num()) { int index = p2.value; - if (index<0 || index>=an->elements.size()) + if (index < 0 || index >= an->elements.size()) return false; - return _guess_expression_type(context,an->elements[index],p_line,r_type); + return _guess_expression_type(context, an->elements[index], p_line, r_type); } - } else if (op->arguments[0]->type==GDParser::Node::TYPE_DICTIONARY) { + } else if (op->arguments[0]->type == GDParser::Node::TYPE_DICTIONARY) { const GDParser::DictionaryNode *dn = static_cast<const GDParser::DictionaryNode *>(op->arguments[0]); - if (p2.value.get_type()==Variant::NIL) + if (p2.value.get_type() == Variant::NIL) return false; - for(int i=0;i<dn->elements.size();i++) { + for (int i = 0; i < dn->elements.size(); i++) { GDCompletionIdentifier k; - if (!_guess_expression_type(context,dn->elements[i].key,p_line,k)) { + if (!_guess_expression_type(context, dn->elements[i].key, p_line, k)) { return false; } - if (k.value.get_type()==Variant::NIL) + if (k.value.get_type() == Variant::NIL) return false; - if (k.value==p2.value) { + if (k.value == p2.value) { - return _guess_expression_type(context,dn->elements[i].value,p_line,r_type); + return _guess_expression_type(context, dn->elements[i].value, p_line, r_type); } } } else { if (op->arguments[0]) { - if (!_guess_expression_type(context,op->arguments[0],p_line,p1)) { + if (!_guess_expression_type(context, op->arguments[0], p_line, p1)) { return false; } - } - if (p1.value.get_type()==Variant::OBJECT) { + if (p1.value.get_type() == Variant::OBJECT) { //?? - } else if (p1.value.get_type()!=Variant::NIL) { + } else if (p1.value.get_type() != Variant::NIL) { bool valid; - Variant ret = p1.value.get(p2.value,&valid); + Variant ret = p1.value.get(p2.value, &valid); if (valid) { - r_type=_get_type_from_variant(ret); + r_type = _get_type_from_variant(ret); return true; } } else { - if (p1.type!=Variant::NIL) { + if (p1.type != Variant::NIL) { Variant::CallError ce; - Variant base = Variant::construct(p1.type,NULL,0,ce); + Variant base = Variant::construct(p1.type, NULL, 0, ce); bool valid; - Variant ret = base.get(p2.value,&valid); + Variant ret = base.get(p2.value, &valid); if (valid) { - r_type=_get_type_from_variant(ret); + r_type = _get_type_from_variant(ret); return true; } } @@ -873,127 +813,115 @@ static bool _guess_expression_type(GDCompletionContext& context,const GDParser:: } else { - Variant::Operator vop = Variant::OP_MAX; - switch(op->op) { - case GDParser::OperatorNode::OP_ADD: vop=Variant::OP_ADD; break; - case GDParser::OperatorNode::OP_SUB: vop=Variant::OP_SUBSTRACT; break; - case GDParser::OperatorNode::OP_MUL: vop=Variant::OP_MULTIPLY; break; - case GDParser::OperatorNode::OP_DIV: vop=Variant::OP_DIVIDE; break; - case GDParser::OperatorNode::OP_MOD: vop=Variant::OP_MODULE; break; - case GDParser::OperatorNode::OP_SHIFT_LEFT: vop=Variant::OP_SHIFT_LEFT; break; - case GDParser::OperatorNode::OP_SHIFT_RIGHT: vop=Variant::OP_SHIFT_RIGHT; break; - case GDParser::OperatorNode::OP_BIT_AND: vop=Variant::OP_BIT_AND; break; - case GDParser::OperatorNode::OP_BIT_OR: vop=Variant::OP_BIT_OR; break; - case GDParser::OperatorNode::OP_BIT_XOR: vop=Variant::OP_BIT_XOR; break; - default:{} - + switch (op->op) { + case GDParser::OperatorNode::OP_ADD: vop = Variant::OP_ADD; break; + case GDParser::OperatorNode::OP_SUB: vop = Variant::OP_SUBSTRACT; break; + case GDParser::OperatorNode::OP_MUL: vop = Variant::OP_MULTIPLY; break; + case GDParser::OperatorNode::OP_DIV: vop = Variant::OP_DIVIDE; break; + case GDParser::OperatorNode::OP_MOD: vop = Variant::OP_MODULE; break; + case GDParser::OperatorNode::OP_SHIFT_LEFT: vop = Variant::OP_SHIFT_LEFT; break; + case GDParser::OperatorNode::OP_SHIFT_RIGHT: vop = Variant::OP_SHIFT_RIGHT; break; + case GDParser::OperatorNode::OP_BIT_AND: vop = Variant::OP_BIT_AND; break; + case GDParser::OperatorNode::OP_BIT_OR: vop = Variant::OP_BIT_OR; break; + case GDParser::OperatorNode::OP_BIT_XOR: vop = Variant::OP_BIT_XOR; break; + default: {} } - - - if (vop==Variant::OP_MAX) + if (vop == Variant::OP_MAX) return false; - - GDCompletionIdentifier p1; GDCompletionIdentifier p2; if (op->arguments[0]) { - if (!_guess_expression_type(context,op->arguments[0],p_line,p1)) { + if (!_guess_expression_type(context, op->arguments[0], p_line, p1)) { return false; } - } - if (op->arguments.size()>1) { - if (!_guess_expression_type(context,op->arguments[1],p_line,p2)) { + if (op->arguments.size() > 1) { + if (!_guess_expression_type(context, op->arguments[1], p_line, p2)) { return false; } } Variant::CallError ce; - bool v1_use_value = p1.value.get_type()!=Variant::NIL && p1.value.get_type()!=Variant::OBJECT; - Variant v1 = (v1_use_value)?p1.value:Variant::construct(p1.type,NULL,0,ce); - bool v2_use_value = p2.value.get_type()!=Variant::NIL && p2.value.get_type()!=Variant::OBJECT; - Variant v2 = (v2_use_value)?p2.value:Variant::construct(p2.type,NULL,0,ce); + bool v1_use_value = p1.value.get_type() != Variant::NIL && p1.value.get_type() != Variant::OBJECT; + Variant v1 = (v1_use_value) ? p1.value : Variant::construct(p1.type, NULL, 0, ce); + bool v2_use_value = p2.value.get_type() != Variant::NIL && p2.value.get_type() != Variant::OBJECT; + Variant v2 = (v2_use_value) ? p2.value : Variant::construct(p2.type, NULL, 0, ce); // avoid potential invalid ops - if ((vop==Variant::OP_DIVIDE || vop==Variant::OP_MODULE) && v2.get_type()==Variant::INT) { - v2=1; - v2_use_value=false; + if ((vop == Variant::OP_DIVIDE || vop == Variant::OP_MODULE) && v2.get_type() == Variant::INT) { + v2 = 1; + v2_use_value = false; } - if (vop==Variant::OP_DIVIDE && v2.get_type()==Variant::REAL) { - v2=1.0; - v2_use_value=false; + if (vop == Variant::OP_DIVIDE && v2.get_type() == Variant::REAL) { + v2 = 1.0; + v2_use_value = false; } Variant r; bool valid; - Variant::evaluate(vop,v1,v2,r,valid); + Variant::evaluate(vop, v1, v2, r, valid); if (!valid) return false; - r_type.type=r.get_type(); + r_type.type = r.get_type(); if (v1_use_value && v2_use_value) - r_type.value=r; + r_type.value = r; return true; - } - } return false; } - -static bool _guess_identifier_type_in_block(GDCompletionContext& context,int p_line,const StringName& p_identifier,GDCompletionIdentifier &r_type) { - +static bool _guess_identifier_type_in_block(GDCompletionContext &context, int p_line, const StringName &p_identifier, GDCompletionIdentifier &r_type) { GDCompletionIdentifier gdi = _get_native_class(context); - if (gdi.obj_type!=StringName()) { + if (gdi.obj_type != StringName()) { bool valid; - Variant::Type t = ClassDB::get_property_type(gdi.obj_type,p_identifier,&valid); - if (t!=Variant::NIL && valid) { - r_type.type=t; + Variant::Type t = ClassDB::get_property_type(gdi.obj_type, p_identifier, &valid); + if (t != Variant::NIL && valid) { + r_type.type = t; return true; } } - const GDParser::Node *last_assign=NULL; - int last_assign_line=-1; + const GDParser::Node *last_assign = NULL; + int last_assign_line = -1; - for (int i=0;i<context.block->statements.size();i++) { + for (int i = 0; i < context.block->statements.size(); i++) { - if (context.block->statements[i]->line>p_line) + if (context.block->statements[i]->line > p_line) continue; + if (context.block->statements[i]->type == GDParser::BlockNode::TYPE_LOCAL_VAR) { - if (context.block->statements[i]->type==GDParser::BlockNode::TYPE_LOCAL_VAR) { - - const GDParser::LocalVarNode *lv=static_cast<const GDParser::LocalVarNode *>(context.block->statements[i]); + const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode *>(context.block->statements[i]); - if (lv->assign && lv->name==p_identifier) { + if (lv->assign && lv->name == p_identifier) { - last_assign=lv->assign; - last_assign_line=context.block->statements[i]->line; + last_assign = lv->assign; + last_assign_line = context.block->statements[i]->line; } } - if (context.block->statements[i]->type==GDParser::BlockNode::TYPE_OPERATOR) { + if (context.block->statements[i]->type == GDParser::BlockNode::TYPE_OPERATOR) { const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(context.block->statements[i]); - if (op->op==GDParser::OperatorNode::OP_ASSIGN) { + if (op->op == GDParser::OperatorNode::OP_ASSIGN) { - if (op->arguments.size() && op->arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER) { + if (op->arguments.size() && op->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER) { const GDParser::IdentifierNode *id = static_cast<const GDParser::IdentifierNode *>(op->arguments[0]); - if (id->name==p_identifier) { + if (id->name == p_identifier) { - last_assign=op->arguments[1]; - last_assign_line=context.block->statements[i]->line; + last_assign = op->arguments[1]; + last_assign_line = context.block->statements[i]->line; } } } @@ -1003,20 +931,18 @@ static bool _guess_identifier_type_in_block(GDCompletionContext& context,int p_l //use the last assignment, (then backwards?) if (last_assign) { - return _guess_expression_type(context,last_assign,last_assign_line,r_type); + return _guess_expression_type(context, last_assign, last_assign_line, r_type); } - return false; } +static bool _guess_identifier_from_assignment_in_function(GDCompletionContext &context, int p_src_line, const StringName &p_identifier, const StringName &p_function, GDCompletionIdentifier &r_type) { -static bool _guess_identifier_from_assignment_in_function(GDCompletionContext& context, int p_src_line, const StringName& p_identifier, const StringName& p_function,GDCompletionIdentifier &r_type) { - - const GDParser::FunctionNode* func=NULL; - for(int i=0;i<context._class->functions.size();i++) { - if (context._class->functions[i]->name==p_function) { - func=context._class->functions[i]; + const GDParser::FunctionNode *func = NULL; + for (int i = 0; i < context._class->functions.size(); i++) { + if (context._class->functions[i]->name == p_function) { + func = context._class->functions[i]; break; } } @@ -1024,23 +950,23 @@ static bool _guess_identifier_from_assignment_in_function(GDCompletionContext& c if (!func) return false; - for(int i=0;i<func->body->statements.size();i++) { + for (int i = 0; i < func->body->statements.size(); i++) { if (func->body->statements[i]->line == p_src_line) { break; } - if (func->body->statements[i]->type==GDParser::BlockNode::TYPE_OPERATOR) { + if (func->body->statements[i]->type == GDParser::BlockNode::TYPE_OPERATOR) { const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(func->body->statements[i]); - if (op->op==GDParser::OperatorNode::OP_ASSIGN) { + if (op->op == GDParser::OperatorNode::OP_ASSIGN) { - if (op->arguments.size() && op->arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER) { + if (op->arguments.size() && op->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER) { const GDParser::IdentifierNode *id = static_cast<const GDParser::IdentifierNode *>(op->arguments[0]); - if (id->name==p_identifier) { + if (id->name == p_identifier) { - return _guess_expression_type(context,op->arguments[1],func->body->statements[i]->line,r_type); + return _guess_expression_type(context, op->arguments[1], func->body->statements[i]->line, r_type); } } } @@ -1050,66 +976,62 @@ static bool _guess_identifier_from_assignment_in_function(GDCompletionContext& c return false; } -static bool _guess_identifier_type(GDCompletionContext& context,int p_line,const StringName& p_identifier,GDCompletionIdentifier &r_type) { +static bool _guess_identifier_type(GDCompletionContext &context, int p_line, const StringName &p_identifier, GDCompletionIdentifier &r_type) { //go to block first + const GDParser::BlockNode *block = context.block; - const GDParser::BlockNode *block=context.block; - - while(block) { + while (block) { GDCompletionContext c = context; - c.block=block; + c.block = block; - if (_guess_identifier_type_in_block(c,p_line,p_identifier,r_type)) { + if (_guess_identifier_type_in_block(c, p_line, p_identifier, r_type)) { return true; } - block=block->parent_block; + block = block->parent_block; } //guess from argument if virtual - if (context.function && context.function->name!=StringName()) { + if (context.function && context.function->name != StringName()) { int argindex = -1; - for(int i=0;i<context.function->arguments.size();i++) { + for (int i = 0; i < context.function->arguments.size(); i++) { - if (context.function->arguments[i]==p_identifier) { - argindex=i; + if (context.function->arguments[i] == p_identifier) { + argindex = i; break; } - } - if (argindex!=-1) { - GDCompletionIdentifier id =_get_native_class(context); - if (id.type==Variant::OBJECT && id.obj_type!=StringName()) { + if (argindex != -1) { + GDCompletionIdentifier id = _get_native_class(context); + if (id.type == Variant::OBJECT && id.obj_type != StringName()) { //this kinda sucks but meh List<MethodInfo> vmethods; - ClassDB::get_virtual_methods(id.obj_type,&vmethods); - for (List<MethodInfo>::Element *E=vmethods.front();E;E=E->next()) { - + ClassDB::get_virtual_methods(id.obj_type, &vmethods); + for (List<MethodInfo>::Element *E = vmethods.front(); E; E = E->next()) { - if (E->get().name==context.function->name && argindex<E->get().arguments.size()) { + if (E->get().name == context.function->name && argindex < E->get().arguments.size()) { - PropertyInfo arg=E->get().arguments[argindex]; + PropertyInfo arg = E->get().arguments[argindex]; int scp = arg.name.find(":"); - if (scp!=-1) { + if (scp != -1) { - - r_type.type=Variant::OBJECT; - r_type.obj_type=arg.name.substr(scp+1,arg.name.length()); + r_type.type = Variant::OBJECT; + r_type.obj_type = arg.name.substr(scp + 1, arg.name.length()); return true; } else { - r_type.type=arg.type; - if (arg.hint==PROPERTY_HINT_RESOURCE_TYPE) - r_type.obj_type=arg.hint_string; + r_type.type = arg.type; + if (arg.hint == PROPERTY_HINT_RESOURCE_TYPE) + r_type.obj_type = arg.hint_string; return true; } } @@ -1120,40 +1042,40 @@ static bool _guess_identifier_type(GDCompletionContext& context,int p_line,const //guess type in constant - for(int i=0;i<context._class->constant_expressions.size();i++) { + for (int i = 0; i < context._class->constant_expressions.size(); i++) { - if (context._class->constant_expressions[i].identifier==p_identifier) { + if (context._class->constant_expressions[i].identifier == p_identifier) { - ERR_FAIL_COND_V( context._class->constant_expressions[i].expression->type!=GDParser::Node::TYPE_CONSTANT, false ); - r_type=_get_type_from_variant(static_cast<const GDParser::ConstantNode*>(context._class->constant_expressions[i].expression)->value ); + ERR_FAIL_COND_V(context._class->constant_expressions[i].expression->type != GDParser::Node::TYPE_CONSTANT, false); + r_type = _get_type_from_variant(static_cast<const GDParser::ConstantNode *>(context._class->constant_expressions[i].expression)->value); return true; } } if (!(context.function && context.function->_static)) { - for(int i=0;i<context._class->variables.size();i++) { + for (int i = 0; i < context._class->variables.size(); i++) { - if (context._class->variables[i].identifier==p_identifier) { + if (context._class->variables[i].identifier == p_identifier) { - if (context._class->variables[i]._export.type!=Variant::NIL) { + if (context._class->variables[i]._export.type != Variant::NIL) { - r_type=_get_type_from_pinfo(context._class->variables[i]._export); + r_type = _get_type_from_pinfo(context._class->variables[i]._export); return true; } else if (context._class->variables[i].expression) { - bool rtype = _guess_expression_type(context,context._class->variables[i].expression,context._class->variables[i].line,r_type); - if (rtype && r_type.type!=Variant::NIL) + bool rtype = _guess_expression_type(context, context._class->variables[i].expression, context._class->variables[i].line, r_type); + if (rtype && r_type.type != Variant::NIL) return true; //return _guess_expression_type(context,context._class->variables[i].expression,context._class->variables[i].line,r_type); } //try to guess from assignment in construtor or _ready - if (_guess_identifier_from_assignment_in_function(context,p_line+1,p_identifier,"_ready",r_type)) + if (_guess_identifier_from_assignment_in_function(context, p_line + 1, p_identifier, "_ready", r_type)) return true; - if (_guess_identifier_from_assignment_in_function(context,p_line+1,p_identifier,"_enter_tree",r_type)) + if (_guess_identifier_from_assignment_in_function(context, p_line + 1, p_identifier, "_enter_tree", r_type)) return true; - if (_guess_identifier_from_assignment_in_function(context,p_line+1,p_identifier,"_init",r_type)) + if (_guess_identifier_from_assignment_in_function(context, p_line + 1, p_identifier, "_init", r_type)) return true; return false; @@ -1165,115 +1087,107 @@ static bool _guess_identifier_type(GDCompletionContext& context,int p_line,const List<PropertyInfo> props; GlobalConfig::get_singleton()->get_property_list(&props); - for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) { + for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) { String s = E->get().name; if (!s.begins_with("autoload/")) continue; - String name = s.get_slice("/",1); - if (name==String(p_identifier)) { + String name = s.get_slice("/", 1); + if (name == String(p_identifier)) { String path = GlobalConfig::get_singleton()->get(s); if (path.begins_with("*")) { - String script =path.substr(1,path.length()); + String script = path.substr(1, path.length()); if (!script.ends_with(".gd")) { //not a script, try find the script anyway, //may have some success - script=script.get_basename()+".gd"; + script = script.get_basename() + ".gd"; } if (FileAccess::exists(script)) { //print_line("is a script"); - Ref<Script> scr; if (ScriptCodeCompletionCache::get_sigleton()) scr = ScriptCodeCompletionCache::get_sigleton()->get_cached_resource(script); else scr = ResourceLoader::load(script); - - r_type.obj_type="Node"; - r_type.type=Variant::OBJECT; - r_type.script=scr; - r_type.value=Variant(); + r_type.obj_type = "Node"; + r_type.type = Variant::OBJECT; + r_type.script = scr; + r_type.value = Variant(); return true; - } } } - } //global - for(Map<StringName,int>::Element *E=GDScriptLanguage::get_singleton()->get_global_map().front();E;E=E->next()) { - if (E->key()==p_identifier) { + for (Map<StringName, int>::Element *E = GDScriptLanguage::get_singleton()->get_global_map().front(); E; E = E->next()) { + if (E->key() == p_identifier) { - r_type=_get_type_from_variant(GDScriptLanguage::get_singleton()->get_global_array()[E->get()]); + r_type = _get_type_from_variant(GDScriptLanguage::get_singleton()->get_global_array()[E->get()]); return true; } - } return false; } - -static void _find_identifiers_in_block(GDCompletionContext& context,int p_line,bool p_only_functions,Set<String>& result) { +static void _find_identifiers_in_block(GDCompletionContext &context, int p_line, bool p_only_functions, Set<String> &result) { if (p_only_functions) return; - for (int i=0;i<context.block->statements.size();i++) { + for (int i = 0; i < context.block->statements.size(); i++) { - if (context.block->statements[i]->line>p_line) + if (context.block->statements[i]->line > p_line) continue; + if (context.block->statements[i]->type == GDParser::BlockNode::TYPE_LOCAL_VAR) { - if (context.block->statements[i]->type==GDParser::BlockNode::TYPE_LOCAL_VAR) { - - const GDParser::LocalVarNode *lv=static_cast<const GDParser::LocalVarNode *>(context.block->statements[i]); + const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode *>(context.block->statements[i]); result.insert(lv->name.operator String()); } } } -static void _find_identifiers_in_class(GDCompletionContext& context,bool p_static,bool p_only_functions,Set<String>& result) { +static void _find_identifiers_in_class(GDCompletionContext &context, bool p_static, bool p_only_functions, Set<String> &result) { if (!p_static && !p_only_functions) { - for(int i=0;i<context._class->variables.size();i++) { + for (int i = 0; i < context._class->variables.size(); i++) { result.insert(context._class->variables[i].identifier); } } if (!p_only_functions) { - for(int i=0;i<context._class->constant_expressions.size();i++) { + for (int i = 0; i < context._class->constant_expressions.size(); i++) { result.insert(context._class->constant_expressions[i].identifier); } - for(int i=0;i<context._class->subclasses.size();i++) { + for (int i = 0; i < context._class->subclasses.size(); i++) { result.insert(context._class->subclasses[i]->name); } - } - for(int i=0;i<context._class->static_functions.size();i++) { + for (int i = 0; i < context._class->static_functions.size(); i++) { if (context._class->static_functions[i]->arguments.size()) - result.insert(context._class->static_functions[i]->name.operator String()+"("); + result.insert(context._class->static_functions[i]->name.operator String() + "("); else - result.insert(context._class->static_functions[i]->name.operator String()+"()"); + result.insert(context._class->static_functions[i]->name.operator String() + "()"); } if (!p_static) { - for(int i=0;i<context._class->functions.size();i++) { + for (int i = 0; i < context._class->functions.size(); i++) { if (context._class->functions[i]->arguments.size()) - result.insert(context._class->functions[i]->name.operator String()+"("); + result.insert(context._class->functions[i]->name.operator String() + "("); else - result.insert(context._class->functions[i]->name.operator String()+"()"); + result.insert(context._class->functions[i]->name.operator String() + "()"); } } @@ -1281,135 +1195,130 @@ static void _find_identifiers_in_class(GDCompletionContext& context,bool p_stati Ref<Reference> base = _get_parent_class(context); - while(true) { + while (true) { Ref<GDScript> script = base; Ref<GDNativeClass> nc = base; if (script.is_valid()) { if (!p_static && !p_only_functions) { - for (const Set<StringName>::Element *E=script->get_members().front();E;E=E->next()) { + for (const Set<StringName>::Element *E = script->get_members().front(); E; E = E->next()) { result.insert(E->get().operator String()); } } if (!p_only_functions) { - for (const Map<StringName,Variant>::Element *E=script->get_constants().front();E;E=E->next()) { + for (const Map<StringName, Variant>::Element *E = script->get_constants().front(); E; E = E->next()) { result.insert(E->key().operator String()); } } - for (const Map<StringName,GDFunction*>::Element *E=script->get_member_functions().front();E;E=E->next()) { + for (const Map<StringName, GDFunction *>::Element *E = script->get_member_functions().front(); E; E = E->next()) { if (!p_static || E->get()->is_static()) { if (E->get()->get_argument_count()) - result.insert(E->key().operator String()+"("); + result.insert(E->key().operator String() + "("); else - result.insert(E->key().operator String()+"()"); + result.insert(E->key().operator String() + "()"); } } - if (!p_only_functions) { - for (const Map<StringName,Ref<GDScript> >::Element *E=script->get_subclasses().front();E;E=E->next()) { + if (!p_only_functions) { + for (const Map<StringName, Ref<GDScript> >::Element *E = script->get_subclasses().front(); E; E = E->next()) { result.insert(E->key().operator String()); } } - base=script->get_base(); + base = script->get_base(); if (base.is_null()) - base=script->get_native(); + base = script->get_native(); } else if (nc.is_valid()) { StringName type = nc->get_name(); if (!p_only_functions) { - List<String> constants; - ClassDB::get_integer_constant_list(type,&constants); - for(List<String>::Element *E=constants.front();E;E=E->next()) { + ClassDB::get_integer_constant_list(type, &constants); + for (List<String>::Element *E = constants.front(); E; E = E->next()) { result.insert(E->get()); } List<PropertyInfo> pinfo; - ClassDB::get_property_list(type,&pinfo); + ClassDB::get_property_list(type, &pinfo); - for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) { - if (E->get().usage&(PROPERTY_USAGE_GROUP|PROPERTY_USAGE_CATEGORY)) + for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) { + if (E->get().usage & (PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY)) continue; - if (E->get().name.find("/")!=-1) + if (E->get().name.find("/") != -1) continue; result.insert(E->get().name); } - } List<MethodInfo> methods; - ClassDB::get_method_list(type,&methods); - for(List<MethodInfo>::Element *E=methods.front();E;E=E->next()) { + ClassDB::get_method_list(type, &methods); + for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) { if (E->get().name.begins_with("_")) continue; if (E->get().arguments.size()) - result.insert(E->get().name+"("); + result.insert(E->get().name + "("); else - result.insert(E->get().name+"()"); + result.insert(E->get().name + "()"); } - - break; } else break; - } - } -static void _find_identifiers(GDCompletionContext& context,int p_line,bool p_only_functions,Set<String>& result) { +static void _find_identifiers(GDCompletionContext &context, int p_line, bool p_only_functions, Set<String> &result) { - const GDParser::BlockNode *block=context.block; + const GDParser::BlockNode *block = context.block; if (context.function) { - const GDParser::FunctionNode* f = context.function; + const GDParser::FunctionNode *f = context.function; - for (int i=0;i<f->arguments.size();i++) { + for (int i = 0; i < f->arguments.size(); i++) { result.insert(f->arguments[i].operator String()); } } - while(block) { + while (block) { GDCompletionContext c = context; - c.block=block; + c.block = block; - _find_identifiers_in_block(c,p_line,p_only_functions,result); - block=block->parent_block; + _find_identifiers_in_block(c, p_line, p_only_functions, result); + block = block->parent_block; } - const GDParser::ClassNode *clss=context._class; + const GDParser::ClassNode *clss = context._class; - bool _static=context.function && context.function->_static; + bool _static = context.function && context.function->_static; - while(clss) { + while (clss) { GDCompletionContext c = context; - c._class=clss; - c.block=NULL; - c.function=NULL; - _find_identifiers_in_class(c,_static,p_only_functions,result); - clss=clss->owner; + c._class = clss; + c.block = NULL; + c.function = NULL; + _find_identifiers_in_class(c, _static, p_only_functions, result); + clss = clss->owner; } - for(int i=0;i<GDFunctions::FUNC_MAX;i++) { + for (int i = 0; i < GDFunctions::FUNC_MAX; i++) { result.insert(GDFunctions::get_func_name(GDFunctions::Function(i))); } - static const char*_type_names[Variant::VARIANT_MAX]={ - "null","bool","int","float","String","Vector2","Rect2","Vector3","Transform2D","Plane","Quat","AABB","Basis","Transform", - "Color","Image","NodePath","RID","Object","InputEvent","Dictionary","Array","RawArray","IntArray","FloatArray","StringArray", - "Vector2Array","Vector3Array","ColorArray"}; + static const char *_type_names[Variant::VARIANT_MAX] = { + "null", "bool", "int", "float", "String", "Vector2", "Rect2", "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform", + "Color", "Image", "NodePath", "RID", "Object", "InputEvent", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray", + "Vector2Array", "Vector3Array", "ColorArray" + }; - for(int i=0;i<Variant::VARIANT_MAX;i++) { + for (int i = 0; i < Variant::VARIANT_MAX; i++) { result.insert(_type_names[i]); } @@ -1417,37 +1326,34 @@ static void _find_identifiers(GDCompletionContext& context,int p_line,bool p_onl List<PropertyInfo> props; GlobalConfig::get_singleton()->get_property_list(&props); - for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) { + for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) { String s = E->get().name; if (!s.begins_with("autoload/")) continue; - String name = s.get_slice("/",1); + String name = s.get_slice("/", 1); String path = GlobalConfig::get_singleton()->get(s); if (path.begins_with("*")) { result.insert(name); } - } - - for(const Map<StringName,int>::Element *E=GDScriptLanguage::get_singleton()->get_global_map().front();E;E=E->next()) { + for (const Map<StringName, int>::Element *E = GDScriptLanguage::get_singleton()->get_global_map().front(); E; E = E->next()) { result.insert(E->key().operator String()); } } - -static String _get_visual_datatype(const PropertyInfo& p_info,bool p_isarg=true) { +static String _get_visual_datatype(const PropertyInfo &p_info, bool p_isarg = true) { String n = p_info.name; int idx = n.find(":"); - if (idx!=-1) { - return n.substr(idx+1,n.length()); + if (idx != -1) { + return n.substr(idx + 1, n.length()); } - if (p_info.type==Variant::OBJECT && p_info.hint==PROPERTY_HINT_RESOURCE_TYPE) + if (p_info.type == Variant::OBJECT && p_info.hint == PROPERTY_HINT_RESOURCE_TYPE) return p_info.hint_string; - if (p_info.type==Variant::NIL) { + if (p_info.type == Variant::NIL) { if (p_isarg) return "var"; else @@ -1457,74 +1363,68 @@ static String _get_visual_datatype(const PropertyInfo& p_info,bool p_isarg=true) return Variant::get_type_name(p_info.type); } -static void _make_function_hint(const GDParser::FunctionNode* p_func,int p_argidx,String& arghint) { +static void _make_function_hint(const GDParser::FunctionNode *p_func, int p_argidx, String &arghint) { - arghint="func "+p_func->name+"("; - for (int i=0;i<p_func->arguments.size();i++) { - if (i>0) - arghint+=", "; + arghint = "func " + p_func->name + "("; + for (int i = 0; i < p_func->arguments.size(); i++) { + if (i > 0) + arghint += ", "; else - arghint+=" "; + arghint += " "; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - arghint+=p_func->arguments[i].operator String(); - int deffrom = p_func->arguments.size()-p_func->default_values.size(); + arghint += p_func->arguments[i].operator String(); + int deffrom = p_func->arguments.size() - p_func->default_values.size(); - if (i>=deffrom) { - int defidx = deffrom-i; + if (i >= deffrom) { + int defidx = deffrom - i; - if (defidx>=0 && defidx<p_func->default_values.size()) { + if (defidx >= 0 && defidx < p_func->default_values.size()) { - if (p_func->default_values[defidx]->type==GDParser::Node::TYPE_OPERATOR) { - - const GDParser::OperatorNode *op=static_cast<const GDParser::OperatorNode *>(p_func->default_values[defidx]); - if (op->op==GDParser::OperatorNode::OP_ASSIGN) { - const GDParser::ConstantNode *cn=static_cast<const GDParser::ConstantNode *>(op->arguments[1]); - arghint+="="+cn->value.get_construct_string(); + if (p_func->default_values[defidx]->type == GDParser::Node::TYPE_OPERATOR) { + const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(p_func->default_values[defidx]); + if (op->op == GDParser::OperatorNode::OP_ASSIGN) { + const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode *>(op->arguments[1]); + arghint += "=" + cn->value.get_construct_string(); } } else { - } } } - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } } - if (p_func->arguments.size()>0) - arghint+=" "; - arghint+=")"; + if (p_func->arguments.size() > 0) + arghint += " "; + arghint += ")"; } - -static void _find_type_arguments(GDCompletionContext& context,const GDParser::Node*p_node,int p_line,const StringName& p_method,const GDCompletionIdentifier& id, int p_argidx, Set<String>& result, String& arghint) { - +static void _find_type_arguments(GDCompletionContext &context, const GDParser::Node *p_node, int p_line, const StringName &p_method, const GDCompletionIdentifier &id, int p_argidx, Set<String> &result, String &arghint) { //print_line("find type arguments?"); - if (id.type==Variant::INPUT_EVENT && String(p_method)=="is_action" && p_argidx==0) { + if (id.type == Variant::INPUT_EVENT && String(p_method) == "is_action" && p_argidx == 0) { List<PropertyInfo> pinfo; GlobalConfig::get_singleton()->get_property_list(&pinfo); - for(List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) { - const PropertyInfo &pi=E->get(); + for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) { + const PropertyInfo &pi = E->get(); if (!pi.name.begins_with("input/")) continue; - String name = pi.name.substr(pi.name.find("/")+1,pi.name.length()); - result.insert("\""+name+"\""); + String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length()); + result.insert("\"" + name + "\""); } + } else if (id.type == Variant::OBJECT && id.obj_type != StringName()) { - } else if (id.type==Variant::OBJECT && id.obj_type!=StringName()) { - - - MethodBind *m = ClassDB::get_method(id.obj_type,p_method); + MethodBind *m = ClassDB::get_method(id.obj_type, p_method); if (!m) { //not in static method, see script @@ -1532,51 +1432,49 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No Ref<GDScript> on_script; if (id.value.get_type()) { - Object *obj=id.value; - + Object *obj = id.value; if (obj) { - GDScript *scr = obj->cast_to<GDScript>(); if (scr) { while (scr) { - for (const Map<StringName,GDFunction*>::Element *E=scr->get_member_functions().front();E;E=E->next()) { - if (E->get()->is_static() && p_method==E->get()->get_name()) { - arghint="static func "+String(p_method)+"("; - for(int i=0;i<E->get()->get_argument_count();i++) { - if (i>0) - arghint+=", "; + for (const Map<StringName, GDFunction *>::Element *E = scr->get_member_functions().front(); E; E = E->next()) { + if (E->get()->is_static() && p_method == E->get()->get_name()) { + arghint = "static func " + String(p_method) + "("; + for (int i = 0; i < E->get()->get_argument_count(); i++) { + if (i > 0) + arghint += ", "; else - arghint+=" "; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + arghint += " "; + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - arghint+="var "+E->get()->get_argument_name(i); - int deffrom = E->get()->get_argument_count()-E->get()->get_default_argument_count(); - if (i>=deffrom) { - int defidx = deffrom-i; - if (defidx>=0 && defidx<E->get()->get_default_argument_count()) { - arghint+="="+E->get()->get_default_argument(defidx).get_construct_string(); + arghint += "var " + E->get()->get_argument_name(i); + int deffrom = E->get()->get_argument_count() - E->get()->get_default_argument_count(); + if (i >= deffrom) { + int defidx = deffrom - i; + if (defidx >= 0 && defidx < E->get()->get_default_argument_count()) { + arghint += "=" + E->get()->get_default_argument(defidx).get_construct_string(); } } - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } } - arghint+=")"; + arghint += ")"; return; //found } } if (scr->get_base().is_valid()) - scr=scr->get_base().ptr(); + scr = scr->get_base().ptr(); else - scr=NULL; + scr = NULL; } } else { - on_script=obj->get_script(); + on_script = obj->get_script(); } } } @@ -1584,7 +1482,7 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No //print_line("but it has a script?"); if (!on_script.is_valid() && id.script.is_valid()) { //print_line("yes"); - on_script=id.script; + on_script = id.script; } if (on_script.is_valid()) { @@ -1596,110 +1494,108 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No String code = scr->get_source_code(); //print_line("has source code!"); - if (code!="") { + if (code != "") { //if there is code, parse it. This way is slower but updates in real-time GDParser p; //Error parse(const String& p_code, const String& p_base_path="", bool p_just_validate=false,const String& p_self_path="",bool p_for_completion=false); - Error err = p.parse(scr->get_source_code(),scr->get_path().get_base_dir(),true,"",false); + Error err = p.parse(scr->get_source_code(), scr->get_path().get_base_dir(), true, "", false); - if (err==OK) { + if (err == OK) { //print_line("checking the functions..."); //only if ok, otherwise use what is cached on the script //GDParser::ClassNode *base = p. const GDParser::Node *root = p.get_parse_tree(); - ERR_FAIL_COND(root->type!=GDParser::Node::TYPE_CLASS); + ERR_FAIL_COND(root->type != GDParser::Node::TYPE_CLASS); - const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode*>(root); + const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode *>(root); - const GDParser::FunctionNode* func=NULL; - bool st=false; + const GDParser::FunctionNode *func = NULL; + bool st = false; - for(int i=0;i<cl->functions.size();i++) { + for (int i = 0; i < cl->functions.size(); i++) { //print_line(String(cl->functions[i]->name)+" vs "+String(p_method)); - if (cl->functions[i]->name==p_method) { - func=cl->functions[i]; + if (cl->functions[i]->name == p_method) { + func = cl->functions[i]; } } - for(int i=0;i<cl->static_functions.size();i++) { + for (int i = 0; i < cl->static_functions.size(); i++) { //print_line(String(cl->static_functions[i]->name)+" vs "+String(p_method)); - if (cl->static_functions[i]->name==p_method) { - func=cl->static_functions[i]; - st=true; + if (cl->static_functions[i]->name == p_method) { + func = cl->static_functions[i]; + st = true; } - } if (func) { - arghint="func "+String(p_method)+"("; + arghint = "func " + String(p_method) + "("; if (st) - arghint="static "+arghint; - for(int i=0;i<func->arguments.size();i++) { - if (i>0) - arghint+=", "; + arghint = "static " + arghint; + for (int i = 0; i < func->arguments.size(); i++) { + if (i > 0) + arghint += ", "; else - arghint+=" "; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + arghint += " "; + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - arghint+="var "+String(func->arguments[i]); - int deffrom = func->arguments.size()-func->default_values.size(); - if (i>=deffrom) { + arghint += "var " + String(func->arguments[i]); + int deffrom = func->arguments.size() - func->default_values.size(); + if (i >= deffrom) { - int defidx = deffrom-i; + int defidx = deffrom - i; - if (defidx>=0 && defidx<func->default_values.size() && func->default_values[defidx]->type==GDParser::Node::TYPE_OPERATOR) { - const GDParser::OperatorNode *op=static_cast<const GDParser::OperatorNode *>(func->default_values[defidx]); - if (op->op==GDParser::OperatorNode::OP_ASSIGN) { - const GDParser::ConstantNode *cn=static_cast<const GDParser::ConstantNode *>(op->arguments[1]); - arghint+="="+cn->value.get_construct_string(); + if (defidx >= 0 && defidx < func->default_values.size() && func->default_values[defidx]->type == GDParser::Node::TYPE_OPERATOR) { + const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(func->default_values[defidx]); + if (op->op == GDParser::OperatorNode::OP_ASSIGN) { + const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode *>(op->arguments[1]); + arghint += "=" + cn->value.get_construct_string(); } } } - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } } - arghint+=" )"; + arghint += " )"; return; } } else { //print_line("failed parsing?"); - code=""; + code = ""; } - } - if (code=="") { + if (code == "") { - for (const Map<StringName,GDFunction*>::Element *E=scr->get_member_functions().front();E;E=E->next()) { - if (p_method==E->get()->get_name()) { - arghint="func "+String(p_method)+"("; - for(int i=0;i<E->get()->get_argument_count();i++) { - if (i>0) - arghint+=", "; + for (const Map<StringName, GDFunction *>::Element *E = scr->get_member_functions().front(); E; E = E->next()) { + if (p_method == E->get()->get_name()) { + arghint = "func " + String(p_method) + "("; + for (int i = 0; i < E->get()->get_argument_count(); i++) { + if (i > 0) + arghint += ", "; else - arghint+=" "; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + arghint += " "; + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - arghint+="var "+E->get()->get_argument_name(i); - int deffrom = E->get()->get_argument_count()-E->get()->get_default_argument_count(); - if (i>=deffrom) { - int defidx = deffrom-i; - if (defidx>=0 && defidx<E->get()->get_default_argument_count()) { - arghint+="="+E->get()->get_default_argument(defidx).get_construct_string(); + arghint += "var " + E->get()->get_argument_name(i); + int deffrom = E->get()->get_argument_count() - E->get()->get_default_argument_count(); + if (i >= deffrom) { + int defidx = deffrom - i; + if (defidx >= 0 && defidx < E->get()->get_default_argument_count()) { + arghint += "=" + E->get()->get_default_argument(defidx).get_construct_string(); } } - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } } - arghint+=")"; + arghint += ")"; return; //found } } @@ -1721,46 +1617,43 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No } if (scr->get_base().is_valid()) - scr=scr->get_base().ptr(); + scr = scr->get_base().ptr(); else - scr=NULL; + scr = NULL; } } } - } else { //regular method - if (p_method.operator String()=="connect") { - + if (p_method.operator String() == "connect") { - if (p_argidx==0) { + if (p_argidx == 0) { List<MethodInfo> sigs; - ClassDB::get_signal_list(id.obj_type,&sigs); + ClassDB::get_signal_list(id.obj_type, &sigs); if (id.script.is_valid()) { id.script->get_script_signal_list(&sigs); - } else if (id.value.get_type()==Variant::OBJECT) { + } else if (id.value.get_type() == Variant::OBJECT) { Object *obj = id.value; if (obj && !obj->get_script().is_null()) { - Ref<Script> scr=obj->get_script(); + Ref<Script> scr = obj->get_script(); if (scr.is_valid()) { scr->get_script_signal_list(&sigs); } } } - for (List<MethodInfo>::Element *E=sigs.front();E;E=E->next()) { - result.insert("\""+E->get().name+"\""); + for (List<MethodInfo>::Element *E = sigs.front(); E; E = E->next()) { + result.insert("\"" + E->get().name + "\""); } - } else if (p_argidx==2){ - + } else if (p_argidx == 2) { if (context._class) { - for(int i=0;i<context._class->functions.size();i++) { - result.insert("\""+context._class->functions[i]->name+"\""); + for (int i = 0; i < context._class->functions.size(); i++) { + result.insert("\"" + context._class->functions[i]->name + "\""); } } } @@ -1773,173 +1666,163 @@ static void _find_type_arguments(GDCompletionContext& context,const GDParser::No }*/ } else { - if (p_argidx==0 && (String(p_method)=="get_node" || String(p_method)=="has_node") && ClassDB::is_parent_class(id.obj_type,"Node")) { + if (p_argidx == 0 && (String(p_method) == "get_node" || String(p_method) == "has_node") && ClassDB::is_parent_class(id.obj_type, "Node")) { List<PropertyInfo> props; GlobalConfig::get_singleton()->get_property_list(&props); - for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) { + for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) { String s = E->get().name; if (!s.begins_with("autoload/")) continue; //print_line("found "+s); - String name = s.get_slice("/",1); - result.insert("\"/root/"+name+"\""); + String name = s.get_slice("/", 1); + result.insert("\"/root/" + name + "\""); } } - Object *obj=id.value; + Object *obj = id.value; if (obj) { List<String> options; - obj->get_argument_options(p_method,p_argidx,&options); + obj->get_argument_options(p_method, p_argidx, &options); - for(List<String>::Element *E=options.front();E;E=E->next()) { + for (List<String>::Element *E = options.front(); E; E = E->next()) { result.insert(E->get()); } } - } - arghint = _get_visual_datatype(m->get_argument_info(-1),false)+" "+p_method.operator String()+String("("); + arghint = _get_visual_datatype(m->get_argument_info(-1), false) + " " + p_method.operator String() + String("("); - for(int i=0;i<m->get_argument_count();i++) { - if (i>0) - arghint+=", "; + for (int i = 0; i < m->get_argument_count(); i++) { + if (i > 0) + arghint += ", "; else - arghint+=" "; + arghint += " "; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } String n = m->get_argument_info(i).name; int dp = n.find(":"); - if (dp!=-1) - n=n.substr(0,dp); - arghint+=_get_visual_datatype(m->get_argument_info(i))+" "+n; - int deffrom = m->get_argument_count()-m->get_default_argument_count(); + if (dp != -1) + n = n.substr(0, dp); + arghint += _get_visual_datatype(m->get_argument_info(i)) + " " + n; + int deffrom = m->get_argument_count() - m->get_default_argument_count(); + if (i >= deffrom) { + int defidx = i - deffrom; - if (i>=deffrom) { - int defidx = i-deffrom; - - if (defidx>=0 && defidx<m->get_default_argument_count()) { - Variant v= m->get_default_argument(i); - arghint+="="+v.get_construct_string(); + if (defidx >= 0 && defidx < m->get_default_argument_count()) { + Variant v = m->get_default_argument(i); + arghint += "=" + v.get_construct_string(); } } - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - } - if (m->get_argument_count()>0) - arghint+=" "; - + if (m->get_argument_count() > 0) + arghint += " "; - arghint+=")"; + arghint += ")"; } - } } +static void _find_call_arguments(GDCompletionContext &context, const GDParser::Node *p_node, int p_line, int p_argidx, Set<String> &result, String &arghint) { -static void _find_call_arguments(GDCompletionContext& context,const GDParser::Node* p_node, int p_line,int p_argidx, Set<String>& result, String& arghint) { - - - - if (!p_node || p_node->type!=GDParser::Node::TYPE_OPERATOR) { + if (!p_node || p_node->type != GDParser::Node::TYPE_OPERATOR) { return; } const GDParser::OperatorNode *op = static_cast<const GDParser::OperatorNode *>(p_node); - if (op->op!=GDParser::OperatorNode::OP_CALL) { + if (op->op != GDParser::OperatorNode::OP_CALL) { return; } - if (op->arguments[0]->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) { + if (op->arguments[0]->type == GDParser::Node::TYPE_BUILT_IN_FUNCTION) { //complete built-in function - const GDParser::BuiltInFunctionNode *fn = static_cast<const GDParser::BuiltInFunctionNode*>(op->arguments[0]); + const GDParser::BuiltInFunctionNode *fn = static_cast<const GDParser::BuiltInFunctionNode *>(op->arguments[0]); MethodInfo mi = GDFunctions::get_info(fn->function); - arghint = _get_visual_datatype(mi.return_val,false)+" "+GDFunctions::get_func_name(fn->function)+String("("); - for(int i=0;i<mi.arguments.size();i++) { - if (i>0) - arghint+=", "; + arghint = _get_visual_datatype(mi.return_val, false) + " " + GDFunctions::get_func_name(fn->function) + String("("); + for (int i = 0; i < mi.arguments.size(); i++) { + if (i > 0) + arghint += ", "; else - arghint+=" "; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + arghint += " "; + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - arghint+=_get_visual_datatype(mi.arguments[i])+" "+mi.arguments[i].name; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + arghint += _get_visual_datatype(mi.arguments[i]) + " " + mi.arguments[i].name; + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - } - if (mi.arguments.size()>0) - arghint+=" "; - arghint+=")"; + if (mi.arguments.size() > 0) + arghint += " "; + arghint += ")"; - } else if (op->arguments[0]->type==GDParser::Node::TYPE_TYPE) { + } else if (op->arguments[0]->type == GDParser::Node::TYPE_TYPE) { //complete constructor - const GDParser::TypeNode *tn = static_cast<const GDParser::TypeNode*>(op->arguments[0]); + const GDParser::TypeNode *tn = static_cast<const GDParser::TypeNode *>(op->arguments[0]); List<MethodInfo> mil; - Variant::get_constructor_list(tn->vtype,&mil); + Variant::get_constructor_list(tn->vtype, &mil); - for(List<MethodInfo>::Element *E=mil.front();E;E=E->next()) { + for (List<MethodInfo>::Element *E = mil.front(); E; E = E->next()) { MethodInfo mi = E->get(); - if (mi.arguments.size()==0) + if (mi.arguments.size() == 0) continue; if (E->prev()) - arghint+="\n"; - arghint += Variant::get_type_name(tn->vtype)+" "+Variant::get_type_name(tn->vtype)+String("("); - for(int i=0;i<mi.arguments.size();i++) { - if (i>0) - arghint+=", "; + arghint += "\n"; + arghint += Variant::get_type_name(tn->vtype) + " " + Variant::get_type_name(tn->vtype) + String("("); + for (int i = 0; i < mi.arguments.size(); i++) { + if (i > 0) + arghint += ", "; else - arghint+=" "; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + arghint += " "; + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - arghint+=_get_visual_datatype(mi.arguments[i])+" "+mi.arguments[i].name; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + arghint += _get_visual_datatype(mi.arguments[i]) + " " + mi.arguments[i].name; + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - } - if (mi.arguments.size()>0) - arghint+=" "; - arghint+=")"; + if (mi.arguments.size() > 0) + arghint += " "; + arghint += ")"; } - } else if (op->arguments.size()>=2 && op->arguments[1]->type==GDParser::Node::TYPE_IDENTIFIER) { + } else if (op->arguments.size() >= 2 && op->arguments[1]->type == GDParser::Node::TYPE_IDENTIFIER) { //make sure identifier exists... - const GDParser::IdentifierNode *id=static_cast<const GDParser::IdentifierNode *>(op->arguments[1]); + const GDParser::IdentifierNode *id = static_cast<const GDParser::IdentifierNode *>(op->arguments[1]); - if (op->arguments[0]->type==GDParser::Node::TYPE_SELF) { + if (op->arguments[0]->type == GDParser::Node::TYPE_SELF) { //self, look up - for(int i=0;i<context._class->static_functions.size();i++) { - if (context._class->static_functions[i]->name==id->name) { - _make_function_hint(context._class->static_functions[i],p_argidx,arghint); + for (int i = 0; i < context._class->static_functions.size(); i++) { + if (context._class->static_functions[i]->name == id->name) { + _make_function_hint(context._class->static_functions[i], p_argidx, arghint); return; } } if (context.function && !context.function->_static) { - for(int i=0;i<context._class->functions.size();i++) { - if (context._class->functions[i]->name==id->name) { - _make_function_hint(context._class->functions[i],p_argidx,arghint); + for (int i = 0; i < context._class->functions.size(); i++) { + if (context._class->functions[i]->name == id->name) { + _make_function_hint(context._class->functions[i], p_argidx, arghint); return; } } @@ -1947,64 +1830,61 @@ static void _find_call_arguments(GDCompletionContext& context,const GDParser::No Ref<Reference> base = _get_parent_class(context); - while(true) { + while (true) { Ref<GDScript> script = base; Ref<GDNativeClass> nc = base; if (script.is_valid()) { + for (const Map<StringName, GDFunction *>::Element *E = script->get_member_functions().front(); E; E = E->next()) { - for (const Map<StringName,GDFunction*>::Element *E=script->get_member_functions().front();E;E=E->next()) { - - if (E->key()==id->name) { + if (E->key() == id->name) { if (context.function && context.function->_static && !E->get()->is_static()) continue; - - arghint = "func "+id->name.operator String()+String("("); - for(int i=0;i<E->get()->get_argument_count();i++) { - if (i>0) - arghint+=", "; + arghint = "func " + id->name.operator String() + String("("); + for (int i = 0; i < E->get()->get_argument_count(); i++) { + if (i > 0) + arghint += ", "; else - arghint+=" "; - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + arghint += " "; + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - arghint+=E->get()->get_argument_name(i); - int deffrom = E->get()->get_argument_count()-E->get()->get_default_argument_count(); - if (i>=deffrom) { - int defidx = deffrom-i; - if (defidx>=0 && defidx<E->get()->get_default_argument_count()) { - arghint+="="+E->get()->get_default_argument(defidx).get_construct_string(); + arghint += E->get()->get_argument_name(i); + int deffrom = E->get()->get_argument_count() - E->get()->get_default_argument_count(); + if (i >= deffrom) { + int defidx = deffrom - i; + if (defidx >= 0 && defidx < E->get()->get_default_argument_count()) { + arghint += "=" + E->get()->get_default_argument(defidx).get_construct_string(); } } - if (i==p_argidx) { - arghint+=String::chr(0xFFFF); + if (i == p_argidx) { + arghint += String::chr(0xFFFF); } - } - if (E->get()->get_argument_count()>0) - arghint+=" "; - arghint+=")"; + if (E->get()->get_argument_count() > 0) + arghint += " "; + arghint += ")"; return; } } - base=script->get_base(); + base = script->get_base(); if (base.is_null()) - base=script->get_native(); + base = script->get_native(); } else if (nc.is_valid()) { if (context.function && !context.function->_static) { GDCompletionIdentifier ci; - ci.type=Variant::OBJECT; - ci.obj_type=nc->get_name(); + ci.type = Variant::OBJECT; + ci.obj_type = nc->get_name(); if (!context._class->owner) - ci.value=context.base; + ci.value = context.base; - _find_type_arguments(context,p_node,p_line,id->name,ci,p_argidx,result,arghint); + _find_type_arguments(context, p_node, p_line, id->name, ci, p_argidx, result, arghint); //guess type.. /* List<MethodInfo> methods; @@ -2019,20 +1899,17 @@ static void _find_call_arguments(GDCompletionContext& context,const GDParser::No break; } else break; - } } else { //indexed lookup GDCompletionIdentifier ci; - if (_guess_expression_type(context,op->arguments[0],p_line,ci)) { + if (_guess_expression_type(context, op->arguments[0], p_line, ci)) { - _find_type_arguments(context,p_node,p_line,id->name,ci,p_argidx,result,arghint); + _find_type_arguments(context, p_node, p_line, id->name, ci, p_argidx, result, arghint); return; } - } - } #if 0 bool _static=context.function->_static; @@ -2127,42 +2004,40 @@ static void _find_call_arguments(GDCompletionContext& context,const GDParser::No } #endif - } -Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base_path, Object*p_owner, List<String>* r_options, String &r_call_hint) { +Error GDScriptLanguage::complete_code(const String &p_code, const String &p_base_path, Object *p_owner, List<String> *r_options, String &r_call_hint) { GDParser p; - p.parse(p_code,p_base_path,false,"",true); - bool isfunction=false; + p.parse(p_code, p_base_path, false, "", true); + bool isfunction = false; Set<String> options; GDCompletionContext context; - context._class=p.get_completion_class(); - context.block=p.get_completion_block(); - context.function=p.get_completion_function(); - context.base=p_owner; - context.base_path=p_base_path; + context._class = p.get_completion_class(); + context.block = p.get_completion_block(); + context.function = p.get_completion_function(); + context.base = p_owner; + context.base_path = p_base_path; - switch(p.get_completion_type()) { + switch (p.get_completion_type()) { case GDParser::COMPLETION_NONE: { } break; case GDParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: { List<StringName> constants; - Variant::get_numeric_constants_for_type(p.get_completion_built_in_constant(),&constants); - for(List<StringName>::Element *E=constants.front();E;E=E->next()) { + Variant::get_numeric_constants_for_type(p.get_completion_built_in_constant(), &constants); + for (List<StringName>::Element *E = constants.front(); E; E = E->next()) { options.insert(E->get().operator String()); } - } break; case GDParser::COMPLETION_FUNCTION: - isfunction=true; + isfunction = true; case GDParser::COMPLETION_IDENTIFIER: { - _find_identifiers(context,p.get_completion_line(),isfunction,options); + _find_identifiers(context, p.get_completion_line(), isfunction, options); } break; case GDParser::COMPLETION_PARENT_FUNCTION: { @@ -2171,98 +2046,91 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base if (p_owner) { List<String> opts; - p_owner->get_argument_options("get_node",0,&opts); + p_owner->get_argument_options("get_node", 0, &opts); - for (List<String>::Element *E=opts.front();E;E=E->next()) { + for (List<String>::Element *E = opts.front(); E; E = E->next()) { String opt = E->get().strip_edges(); if (opt.begins_with("\"") && opt.ends_with("\"")) { - String idopt=opt.substr(1,opt.length()-2); - if (idopt.replace("/","_").is_valid_identifier()) { + String idopt = opt.substr(1, opt.length() - 2); + if (idopt.replace("/", "_").is_valid_identifier()) { options.insert(idopt); } else { options.insert(opt); } } } - } } break; case GDParser::COMPLETION_METHOD: - isfunction=true; + isfunction = true; case GDParser::COMPLETION_INDEX: { const GDParser::Node *node = p.get_completion_node(); - if (node->type!=GDParser::Node::TYPE_OPERATOR) + if (node->type != GDParser::Node::TYPE_OPERATOR) break; - - - GDCompletionIdentifier t; - if (_guess_expression_type(context,static_cast<const GDParser::OperatorNode *>(node)->arguments[0],p.get_completion_line(),t)) { + if (_guess_expression_type(context, static_cast<const GDParser::OperatorNode *>(node)->arguments[0], p.get_completion_line(), t)) { - if (t.type==Variant::OBJECT && t.obj_type=="GDNativeClass") { + if (t.type == Variant::OBJECT && t.obj_type == "GDNativeClass") { //native enum Ref<GDNativeClass> gdn = t.value; if (gdn.is_valid()) { StringName cn = gdn->get_name(); List<String> cnames; - ClassDB::get_integer_constant_list(cn,&cnames); - for (List<String>::Element *E=cnames.front();E;E=E->next()) { + ClassDB::get_integer_constant_list(cn, &cnames); + for (List<String>::Element *E = cnames.front(); E; E = E->next()) { options.insert(E->get()); } List<PropertyInfo> pinfo; - ClassDB::get_property_list(cn,&pinfo); + ClassDB::get_property_list(cn, &pinfo); - for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) { - if (E->get().usage&(PROPERTY_USAGE_GROUP|PROPERTY_USAGE_CATEGORY)) + for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) { + if (E->get().usage & (PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY)) continue; - if (E->get().name.find("/")!=-1) + if (E->get().name.find("/") != -1) continue; options.insert(E->get().name); } } - } else if (t.type==Variant::OBJECT && t.obj_type!=StringName()) { + } else if (t.type == Variant::OBJECT && t.obj_type != StringName()) { Ref<GDScript> on_script; if (t.value.get_type()) { - Object *obj=t.value; - + Object *obj = t.value; if (obj) { - GDScript *scr = obj->cast_to<GDScript>(); if (scr) { while (scr) { if (!isfunction) { - for (const Map<StringName,Variant>::Element *E=scr->get_constants().front();E;E=E->next()) { + for (const Map<StringName, Variant>::Element *E = scr->get_constants().front(); E; E = E->next()) { options.insert(E->key()); } } - for (const Map<StringName,GDFunction*>::Element *E=scr->get_member_functions().front();E;E=E->next()) { + for (const Map<StringName, GDFunction *>::Element *E = scr->get_member_functions().front(); E; E = E->next()) { if (E->get()->is_static()) options.insert(E->key()); } if (scr->get_base().is_valid()) - scr=scr->get_base().ptr(); + scr = scr->get_base().ptr(); else - scr=NULL; + scr = NULL; } } else { - on_script=obj->get_script(); + on_script = obj->get_script(); } } } - if (!on_script.is_valid() && t.script.is_valid()) { - on_script=t.script; + on_script = t.script; } if (on_script.is_valid()) { @@ -2273,132 +2141,119 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base String code = scr->get_source_code(); - if (code!="") { + if (code != "") { //if there is code, parse it. This way is slower but updates in real-time GDParser p; - Error err = p.parse(scr->get_source_code(),scr->get_path().get_base_dir(),true,"",false); + Error err = p.parse(scr->get_source_code(), scr->get_path().get_base_dir(), true, "", false); - if (err==OK) { + if (err == OK) { //only if ok, otherwise use what is cached on the script //GDParser::ClassNode *base = p. const GDParser::Node *root = p.get_parse_tree(); - ERR_FAIL_COND_V(root->type!=GDParser::Node::TYPE_CLASS,ERR_PARSE_ERROR); + ERR_FAIL_COND_V(root->type != GDParser::Node::TYPE_CLASS, ERR_PARSE_ERROR); - const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode*>(root); + const GDParser::ClassNode *cl = static_cast<const GDParser::ClassNode *>(root); - for(int i=0;i<cl->functions.size();i++) { + for (int i = 0; i < cl->functions.size(); i++) { if (cl->functions[i]->arguments.size()) - options.insert(String(cl->functions[i]->name)+"("); + options.insert(String(cl->functions[i]->name) + "("); else - options.insert(String(cl->functions[i]->name)+"()"); + options.insert(String(cl->functions[i]->name) + "()"); } - for(int i=0;i<cl->static_functions.size();i++) { + for (int i = 0; i < cl->static_functions.size(); i++) { if (cl->static_functions[i]->arguments.size()) - options.insert(String(cl->static_functions[i]->name)+"("); + options.insert(String(cl->static_functions[i]->name) + "("); else - options.insert(String(cl->static_functions[i]->name)+"()"); - + options.insert(String(cl->static_functions[i]->name) + "()"); } if (!isfunction) { - for(int i=0;i<cl->variables.size();i++) { + for (int i = 0; i < cl->variables.size(); i++) { options.insert(String(cl->variables[i].identifier)); } - for(int i=0;i<cl->constant_expressions.size();i++) { + for (int i = 0; i < cl->constant_expressions.size(); i++) { options.insert(String(cl->constant_expressions[i].identifier)); } - } - } else { - code=""; //well, then no code + code = ""; //well, then no code } - } - if (code=="") { + if (code == "") { //use class directly, no code was found if (!isfunction) { - for (const Map<StringName,Variant>::Element *E=scr->get_constants().front();E;E=E->next()) { + for (const Map<StringName, Variant>::Element *E = scr->get_constants().front(); E; E = E->next()) { options.insert(E->key()); } } - for (const Map<StringName,GDFunction*>::Element *E=scr->get_member_functions().front();E;E=E->next()) { + for (const Map<StringName, GDFunction *>::Element *E = scr->get_member_functions().front(); E; E = E->next()) { if (E->get()->get_argument_count()) - options.insert(String(E->key())+"()"); + options.insert(String(E->key()) + "()"); else - options.insert(String(E->key())+"("); - + options.insert(String(E->key()) + "("); } - for (const Set<StringName>::Element *E=scr->get_members().front();E;E=E->next()) { + for (const Set<StringName>::Element *E = scr->get_members().front(); E; E = E->next()) { options.insert(E->get()); } } if (scr->get_base().is_valid()) - scr=scr->get_base().ptr(); + scr = scr->get_base().ptr(); else - scr=NULL; + scr = NULL; } } } - - - - - if (!isfunction) { - ClassDB::get_integer_constant_list(t.obj_type,r_options); + ClassDB::get_integer_constant_list(t.obj_type, r_options); List<PropertyInfo> pinfo; - ClassDB::get_property_list(t.obj_type,&pinfo); + ClassDB::get_property_list(t.obj_type, &pinfo); - for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) { - if (E->get().usage&(PROPERTY_USAGE_GROUP|PROPERTY_USAGE_CATEGORY)) + for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) { + if (E->get().usage & (PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY)) continue; - if (E->get().name.find("/")!=-1) + if (E->get().name.find("/") != -1) continue; r_options->push_back(E->get().name); } } - List<MethodInfo> mi; - ClassDB::get_method_list(t.obj_type,&mi); - for (List<MethodInfo>::Element *E=mi.front();E;E=E->next()) { + ClassDB::get_method_list(t.obj_type, &mi); + for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) { if (E->get().name.begins_with("_")) continue; if (E->get().arguments.size()) - options.insert(E->get().name+"("); + options.insert(E->get().name + "("); else - options.insert(E->get().name+"()"); - + options.insert(E->get().name + "()"); } } else { - - if (t.type==Variant::INPUT_EVENT) { + if (t.type == Variant::INPUT_EVENT) { //this is hardcoded otherwise it's not obvious Set<String> exclude; - for(int i=0;i<InputEvent::TYPE_MAX;i++) { + for (int i = 0; i < InputEvent::TYPE_MAX; i++) { InputEvent ie; - ie.type=InputEvent::Type(i); - static const char*evnames[]={ + ie.type = InputEvent::Type(i); + static const char *evnames[] = { "# Common", "# Key", "# MouseMotion", @@ -2414,22 +2269,20 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base Variant v = ie; - if (i==0) { + if (i == 0) { List<MethodInfo> mi; v.get_method_list(&mi); - for (List<MethodInfo>::Element *E=mi.front();E;E=E->next()) { - r_options->push_back(E->get().name+"("); - + for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) { + r_options->push_back(E->get().name + "("); } - } List<PropertyInfo> pi; v.get_property_list(&pi); - for (List<PropertyInfo>::Element *E=pi.front();E;E=E->next()) { + for (List<PropertyInfo>::Element *E = pi.front(); E; E = E->next()) { - if (i==0) + if (i == 0) exclude.insert(E->get().name); else if (exclude.has(E->get().name)) continue; @@ -2439,67 +2292,64 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base } return OK; } else { - if (t.value.get_type()==Variant::NIL) { + if (t.value.get_type() == Variant::NIL) { Variant::CallError ce; - t.value=Variant::construct(t.type,NULL,0,ce); + t.value = Variant::construct(t.type, NULL, 0, ce); } - if (!isfunction) { List<PropertyInfo> pl; t.value.get_property_list(&pl); - for (List<PropertyInfo>::Element *E=pl.front();E;E=E->next()) { + for (List<PropertyInfo>::Element *E = pl.front(); E; E = E->next()) { - if (E->get().name.find("/")==-1) + if (E->get().name.find("/") == -1) options.insert(E->get().name); } } List<MethodInfo> mi; t.value.get_method_list(&mi); - for (List<MethodInfo>::Element *E=mi.front();E;E=E->next()) { + for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) { if (E->get().arguments.size()) - options.insert(E->get().name+"("); + options.insert(E->get().name + "("); else - options.insert(E->get().name+"()"); - + options.insert(E->get().name + "()"); } } } } - } break; case GDParser::COMPLETION_CALL_ARGUMENTS: { - _find_call_arguments(context,p.get_completion_node(),p.get_completion_line(),p.get_completion_argument_index(),options,r_call_hint); + _find_call_arguments(context, p.get_completion_node(), p.get_completion_line(), p.get_completion_argument_index(), options, r_call_hint); } break; case GDParser::COMPLETION_VIRTUAL_FUNC: { GDCompletionIdentifier cid = _get_native_class(context); - if (cid.obj_type!=StringName()) { + if (cid.obj_type != StringName()) { List<MethodInfo> vm; - ClassDB::get_virtual_methods(cid.obj_type,&vm); - for(List<MethodInfo>::Element *E=vm.front();E;E=E->next()) { + ClassDB::get_virtual_methods(cid.obj_type, &vm); + for (List<MethodInfo>::Element *E = vm.front(); E; E = E->next()) { - MethodInfo &mi=E->get(); + MethodInfo &mi = E->get(); String m = mi.name; - if (m.find(":")!=-1) - m=m.substr(0,m.find(":")); - m+="("; + if (m.find(":") != -1) + m = m.substr(0, m.find(":")); + m += "("; if (mi.arguments.size()) { - for(int i=0;i<mi.arguments.size();i++) { - if (i>0) - m+=", "; - String n =mi.arguments[i].name; - if (n.find(":")!=-1) - n=n.substr(0,n.find(":")); - m+=n; + for (int i = 0; i < mi.arguments.size(); i++) { + if (i > 0) + m += ", "; + String n = mi.arguments[i].name; + if (n.find(":") != -1) + n = n.substr(0, n.find(":")); + m += n; } } - m+="):"; + m += "):"; options.insert(m); } @@ -2510,24 +2360,22 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base const GDParser::Node *node = p.get_completion_node(); GDCompletionIdentifier t; - if (!_guess_expression_type(context,node,p.get_completion_line(),t)) + if (!_guess_expression_type(context, node, p.get_completion_line(), t)) break; - if (t.type==Variant::OBJECT && t.obj_type!=StringName()) { + if (t.type == Variant::OBJECT && t.obj_type != StringName()) { List<MethodInfo> sigs; - ClassDB::get_signal_list(t.obj_type,&sigs); - for (List<MethodInfo>::Element *E=sigs.front();E;E=E->next()) { - options.insert("\""+E->get().name+"\""); + ClassDB::get_signal_list(t.obj_type, &sigs); + for (List<MethodInfo>::Element *E = sigs.front(); E; E = E->next()) { + options.insert("\"" + E->get().name + "\""); } } } break; - } - - for(Set<String>::Element *E=options.front();E;E=E->next()) { + for (Set<String>::Element *E = options.front(); E; E = E->next()) { r_options->push_back(E->get()); } @@ -2536,25 +2384,23 @@ Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base #else -Error GDScriptLanguage::complete_code(const String& p_code, const String& p_base_path, Object*p_owner, List<String>* r_options, String &r_call_hint) { +Error GDScriptLanguage::complete_code(const String &p_code, const String &p_base_path, Object *p_owner, List<String> *r_options, String &r_call_hint) { return OK; } #endif - -void GDScriptLanguage::auto_indent_code(String& p_code,int p_from_line,int p_to_line) const { - +void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const { Vector<String> lines = p_code.split("\n"); List<int> indent_stack; - for(int i=0;i<lines.size();i++) { + for (int i = 0; i < lines.size(); i++) { String l = lines[i]; - int tc=0; - for(int j=0;j<l.length();j++) { - if (l[j]==' ' || l[j]=='\t') { + int tc = 0; + for (int j = 0; j < l.length(); j++) { + if (l[j] == ' ' || l[j] == '\t') { tc++; } else { @@ -2562,252 +2408,237 @@ void GDScriptLanguage::auto_indent_code(String& p_code,int p_from_line,int p_to_ } } - - String st = l.substr(tc,l.length()).strip_edges(); - if (st=="" || st.begins_with("#")) + String st = l.substr(tc, l.length()).strip_edges(); + if (st == "" || st.begins_with("#")) continue; //ignore! - int ilevel=0; + int ilevel = 0; if (indent_stack.size()) { - ilevel=indent_stack.back()->get(); + ilevel = indent_stack.back()->get(); } - if (tc>ilevel) { + if (tc > ilevel) { indent_stack.push_back(tc); - } else if (tc<ilevel) { - while(indent_stack.size() && indent_stack.back()->get()>tc) { + } else if (tc < ilevel) { + while (indent_stack.size() && indent_stack.back()->get() > tc) { indent_stack.pop_back(); } - if (indent_stack.size() && indent_stack.back()->get()!=tc) + if (indent_stack.size() && indent_stack.back()->get() != tc) indent_stack.push_back(tc); //this is not right but gets the job done } - if (i>=p_from_line) { + if (i >= p_from_line) { - l=""; - for(int j=0;j<indent_stack.size();j++) - l+="\t"; - l+=st; + l = ""; + for (int j = 0; j < indent_stack.size(); j++) + l += "\t"; + l += st; - - } else if (i>p_to_line) { + } else if (i > p_to_line) { break; } //print_line(itos(indent_stack.size())+","+itos(tc)+": "+l); - lines[i]=l; + lines[i] = l; } - p_code=""; - for(int i=0;i<lines.size();i++) { - if (i>0) - p_code+="\n"; - p_code+=lines[i]; + p_code = ""; + for (int i = 0; i < lines.size(); i++) { + if (i > 0) + p_code += "\n"; + p_code += lines[i]; } - } #ifdef TOOLS_ENABLED -Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol,const String& p_base_path, Object*p_owner,LookupResult& r_result) { - +Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol, const String &p_base_path, Object *p_owner, LookupResult &r_result) { //before parsing, try the usual stuff if (ClassDB::class_exists(p_symbol)) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS; - r_result.class_name=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS; + r_result.class_name = p_symbol; return OK; } - for(int i=0;i<Variant::VARIANT_MAX;i++) { + for (int i = 0; i < Variant::VARIANT_MAX; i++) { Variant::Type t = Variant::Type(i); - if (Variant::get_type_name(t)==p_symbol) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS; - r_result.class_name=Variant::get_type_name(t); + if (Variant::get_type_name(t) == p_symbol) { + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS; + r_result.class_name = Variant::get_type_name(t); return OK; } } - for(int i=0;i<GDFunctions::FUNC_MAX;i++) { - if (GDFunctions::get_func_name(GDFunctions::Function(i))==p_symbol) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; - r_result.class_name="@GDScript"; - r_result.class_member=p_symbol; + for (int i = 0; i < GDFunctions::FUNC_MAX; i++) { + if (GDFunctions::get_func_name(GDFunctions::Function(i)) == p_symbol) { + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.class_name = "@GDScript"; + r_result.class_member = p_symbol; return OK; } } GDParser p; - p.parse(p_code,p_base_path,false,"",true); + p.parse(p_code, p_base_path, false, "", true); - if (p.get_completion_type()==GDParser::COMPLETION_NONE) + if (p.get_completion_type() == GDParser::COMPLETION_NONE) return ERR_CANT_RESOLVE; GDCompletionContext context; - context._class=p.get_completion_class(); - context.block=p.get_completion_block(); - context.function=p.get_completion_function(); - context.base=p_owner; - context.base_path=p_base_path; - bool isfunction=false; + context._class = p.get_completion_class(); + context.block = p.get_completion_block(); + context.function = p.get_completion_function(); + context.base = p_owner; + context.base_path = p_base_path; + bool isfunction = false; - switch(p.get_completion_type()) { + switch (p.get_completion_type()) { case GDParser::COMPLETION_GET_NODE: case GDParser::COMPLETION_NONE: { } break; case GDParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; - r_result.class_name=Variant::get_type_name(p.get_completion_built_in_constant()); - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.class_name = Variant::get_type_name(p.get_completion_built_in_constant()); + r_result.class_member = p_symbol; return OK; } break; case GDParser::COMPLETION_FUNCTION: { - if (context._class && context._class->functions.size()) { - for(int i=0;i<context._class->functions.size();i++) { - if (context._class->functions[i]->name==p_symbol) { - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=context._class->functions[i]->line; + for (int i = 0; i < context._class->functions.size(); i++) { + if (context._class->functions[i]->name == p_symbol) { + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = context._class->functions[i]->line; return OK; } } } Ref<GDScript> parent = _get_parent_class(context); - while(parent.is_valid()) { + while (parent.is_valid()) { int line = parent->get_member_line(p_symbol); - if (line>=0) { - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=line; - r_result.script=parent; + if (line >= 0) { + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = line; + r_result.script = parent; return OK; - } - parent=parent->get_base(); + parent = parent->get_base(); } GDCompletionIdentifier identifier = _get_native_class(context); - print_line("identifier: "+String(identifier.obj_type)); + print_line("identifier: " + String(identifier.obj_type)); - if (ClassDB::has_method(identifier.obj_type,p_symbol)) { + if (ClassDB::has_method(identifier.obj_type, p_symbol)) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; - r_result.class_name=identifier.obj_type; - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.class_name = identifier.obj_type; + r_result.class_member = p_symbol; return OK; } - } break; case GDParser::COMPLETION_IDENTIFIER: { //check if a function if (p.get_completion_identifier_is_function()) { if (context._class && context._class->functions.size()) { - for(int i=0;i<context._class->functions.size();i++) { - if (context._class->functions[i]->name==p_symbol) { - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=context._class->functions[i]->line; + for (int i = 0; i < context._class->functions.size(); i++) { + if (context._class->functions[i]->name == p_symbol) { + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = context._class->functions[i]->line; return OK; } } } Ref<GDScript> parent = _get_parent_class(context); - while(parent.is_valid()) { + while (parent.is_valid()) { int line = parent->get_member_line(p_symbol); - if (line>=0) { - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=line; - r_result.script=parent; + if (line >= 0) { + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = line; + r_result.script = parent; return OK; - } - parent=parent->get_base(); + parent = parent->get_base(); } GDCompletionIdentifier identifier = _get_native_class(context); + if (ClassDB::has_method(identifier.obj_type, p_symbol)) { - if (ClassDB::has_method(identifier.obj_type,p_symbol)) { - - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; - r_result.class_name=identifier.obj_type; - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.class_name = identifier.obj_type; + r_result.class_member = p_symbol; return OK; } } else { - GDCompletionIdentifier gdi = _get_native_class(context); - if (gdi.obj_type!=StringName()) { + if (gdi.obj_type != StringName()) { bool valid; - Variant::Type t = ClassDB::get_property_type(gdi.obj_type,p_symbol,&valid); - if (t!=Variant::NIL && valid) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY; - r_result.class_name=gdi.obj_type; - r_result.class_member=p_symbol; + Variant::Type t = ClassDB::get_property_type(gdi.obj_type, p_symbol, &valid); + if (t != Variant::NIL && valid) { + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY; + r_result.class_name = gdi.obj_type; + r_result.class_member = p_symbol; return OK; - } } - const GDParser::BlockNode *block=context.block; + const GDParser::BlockNode *block = context.block; //search in blocks going up (local var?) - while(block) { - + while (block) { + for (int i = 0; i < block->statements.size(); i++) { - for (int i=0;i<block->statements.size();i++) { - - if (block->statements[i]->line>p.get_completion_line()) + if (block->statements[i]->line > p.get_completion_line()) continue; + if (block->statements[i]->type == GDParser::BlockNode::TYPE_LOCAL_VAR) { - if (block->statements[i]->type==GDParser::BlockNode::TYPE_LOCAL_VAR) { - - const GDParser::LocalVarNode *lv=static_cast<const GDParser::LocalVarNode *>(block->statements[i]); + const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode *>(block->statements[i]); - if (lv->assign && lv->name==p_symbol) { + if (lv->assign && lv->name == p_symbol) { - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=block->statements[i]->line; + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = block->statements[i]->line; return OK; } } } - block=block->parent_block; + block = block->parent_block; } //guess from function arguments - if (context.function && context.function->name!=StringName()) { + if (context.function && context.function->name != StringName()) { - for(int i=0;i<context.function->arguments.size();i++) { + for (int i = 0; i < context.function->arguments.size(); i++) { - if (context.function->arguments[i]==p_symbol) { - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=context.function->line; + if (context.function->arguments[i] == p_symbol) { + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = context.function->line; return OK; } - } } //guess in class constants - for(int i=0;i<context._class->constant_expressions.size();i++) { + for (int i = 0; i < context._class->constant_expressions.size(); i++) { - if (context._class->constant_expressions[i].identifier==p_symbol) { - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=context._class->constant_expressions[i].expression->line; + if (context._class->constant_expressions[i].identifier == p_symbol) { + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = context._class->constant_expressions[i].expression->line; return OK; } } @@ -2815,12 +2646,12 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol //guess in class variables if (!(context.function && context.function->_static)) { - for(int i=0;i<context._class->variables.size();i++) { + for (int i = 0; i < context._class->variables.size(); i++) { - if (context._class->variables[i].identifier==p_symbol) { + if (context._class->variables[i].identifier == p_symbol) { - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=context._class->variables[i].line; + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = context._class->variables[i].line; return OK; } } @@ -2830,29 +2661,29 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol List<PropertyInfo> props; GlobalConfig::get_singleton()->get_property_list(&props); - for(List<PropertyInfo>::Element *E=props.front();E;E=E->next()) { + for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) { String s = E->get().name; if (!s.begins_with("autoload/")) continue; - String name = s.get_slice("/",1); - if (name==String(p_symbol)) { + String name = s.get_slice("/", 1); + if (name == String(p_symbol)) { String path = GlobalConfig::get_singleton()->get(s); if (path.begins_with("*")) { - String script =path.substr(1,path.length()); + String script = path.substr(1, path.length()); if (!script.ends_with(".gd")) { //not a script, try find the script anyway, //may have some success - script=script.get_basename()+".gd"; + script = script.get_basename() + ".gd"; } if (FileAccess::exists(script)) { - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=0; - r_result.script=ResourceLoader::load(script); + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = 0; + r_result.script = ResourceLoader::load(script); return OK; } } @@ -2860,33 +2691,32 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol } //global - for(Map<StringName,int>::Element *E=GDScriptLanguage::get_singleton()->get_global_map().front();E;E=E->next()) { - if (E->key()==p_symbol) { + for (Map<StringName, int>::Element *E = GDScriptLanguage::get_singleton()->get_global_map().front(); E; E = E->next()) { + if (E->key() == p_symbol) { Variant value = GDScriptLanguage::get_singleton()->get_global_array()[E->get()]; - if (value.get_type()==Variant::OBJECT) { + if (value.get_type() == Variant::OBJECT) { Object *obj = value; if (obj) { if (obj->cast_to<GDNativeClass>()) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS; - r_result.class_name=obj->cast_to<GDNativeClass>()->get_name(); + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS; + r_result.class_name = obj->cast_to<GDNativeClass>()->get_name(); } else { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS; - r_result.class_name=obj->get_class(); + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS; + r_result.class_name = obj->get_class(); } return OK; } } else { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; - r_result.class_name="@Global Scope"; - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.class_name = "@Global Scope"; + r_result.class_member = p_symbol; return OK; } } - } #if 0 GDCompletionIdentifier identifier; @@ -2907,122 +2737,109 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol } break; case GDParser::COMPLETION_METHOD: - isfunction=true; + isfunction = true; case GDParser::COMPLETION_INDEX: { const GDParser::Node *node = p.get_completion_node(); - if (node->type!=GDParser::Node::TYPE_OPERATOR) + if (node->type != GDParser::Node::TYPE_OPERATOR) break; - - - GDCompletionIdentifier t; - if (_guess_expression_type(context,static_cast<const GDParser::OperatorNode *>(node)->arguments[0],p.get_completion_line(),t)) { + if (_guess_expression_type(context, static_cast<const GDParser::OperatorNode *>(node)->arguments[0], p.get_completion_line(), t)) { - if (t.type==Variant::OBJECT && t.obj_type=="GDNativeClass") { + if (t.type == Variant::OBJECT && t.obj_type == "GDNativeClass") { //native enum Ref<GDNativeClass> gdn = t.value; if (gdn.is_valid()) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; - r_result.class_name=gdn->get_name(); - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.class_name = gdn->get_name(); + r_result.class_member = p_symbol; return OK; - } - } else if (t.type==Variant::OBJECT && t.obj_type!=StringName()) { + } else if (t.type == Variant::OBJECT && t.obj_type != StringName()) { Ref<GDScript> on_script; if (t.value.get_type()) { - Object *obj=t.value; - + Object *obj = t.value; if (obj) { - - on_script=obj->get_script(); + on_script = obj->get_script(); if (on_script.is_valid()) { int loc = on_script->get_member_line(p_symbol); - if (loc>=0) { - r_result.script=on_script; - r_result.type=ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; - r_result.location=loc; + if (loc >= 0) { + r_result.script = on_script; + r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION; + r_result.location = loc; return OK; } } } } - if (ClassDB::has_method(t.obj_type,p_symbol)) { + if (ClassDB::has_method(t.obj_type, p_symbol)) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; - r_result.class_name=t.obj_type; - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.class_name = t.obj_type; + r_result.class_member = p_symbol; return OK; - } bool success; - ClassDB::get_integer_constant(t.obj_type,p_symbol,&success); + ClassDB::get_integer_constant(t.obj_type, p_symbol, &success); if (success) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; - r_result.class_name=t.obj_type; - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.class_name = t.obj_type; + r_result.class_member = p_symbol; return OK; } - - ClassDB::get_property_type(t.obj_type,p_symbol,&success); + ClassDB::get_property_type(t.obj_type, p_symbol, &success); if (success) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY; - r_result.class_name=t.obj_type; - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY; + r_result.class_name = t.obj_type; + r_result.class_member = p_symbol; return OK; } - } else { Variant::CallError ce; - Variant v = Variant::construct(t.type,NULL,0,ce); + Variant v = Variant::construct(t.type, NULL, 0, ce); bool valid; - v.get_numeric_constant_value(t.type,p_symbol,&valid); + v.get_numeric_constant_value(t.type, p_symbol, &valid); if (valid) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; - r_result.class_name=Variant::get_type_name(t.type); - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT; + r_result.class_name = Variant::get_type_name(t.type); + r_result.class_member = p_symbol; return OK; } //todo check all inputevent types for property - v.get(p_symbol,&valid); + v.get(p_symbol, &valid); if (valid) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY; - r_result.class_name=Variant::get_type_name(t.type); - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY; + r_result.class_name = Variant::get_type_name(t.type); + r_result.class_member = p_symbol; return OK; } if (v.has_method(p_symbol)) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; - r_result.class_name=Variant::get_type_name(t.type); - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.class_name = Variant::get_type_name(t.type); + r_result.class_member = p_symbol; return OK; - } - - } } - } break; case GDParser::COMPLETION_CALL_ARGUMENTS: { @@ -3032,18 +2849,17 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol GDCompletionIdentifier cid = _get_native_class(context); - if (cid.obj_type!=StringName()) { + if (cid.obj_type != StringName()) { List<MethodInfo> vm; - ClassDB::get_virtual_methods(cid.obj_type,&vm); - for(List<MethodInfo>::Element *E=vm.front();E;E=E->next()) { + ClassDB::get_virtual_methods(cid.obj_type, &vm); + for (List<MethodInfo>::Element *E = vm.front(); E; E = E->next()) { - if (p_symbol==E->get().name) { + if (p_symbol == E->get().name) { - r_result.type=ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; - r_result.class_name=cid.obj_type; - r_result.class_member=p_symbol; + r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD; + r_result.class_name = cid.obj_type; + r_result.class_member = p_symbol; return OK; - } } } @@ -3053,10 +2869,8 @@ Error GDScriptLanguage::lookup_code(const String& p_code, const String& p_symbol return ERR_CANT_RESOLVE; } break; - } - return ERR_CANT_RESOLVE; } |