From 5dbf1809c6e3e905b94b8764e99491e608122261 Mon Sep 17 00:00:00 2001
From: Rémi Verschelde
Date: Sun, 5 Mar 2017 16:44:50 +0100
Subject: A Whole New World (clang-format edition)

I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?

I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon

A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format

A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code
---
 modules/gdscript/gd_script.cpp | 1069 ++++++++++++++++++----------------------
 1 file changed, 474 insertions(+), 595 deletions(-)

(limited to 'modules/gdscript/gd_script.cpp')

diff --git a/modules/gdscript/gd_script.cpp b/modules/gdscript/gd_script.cpp
index 4e72bc39a..e1cc75acf 100644
--- a/modules/gdscript/gd_script.cpp
+++ b/modules/gdscript/gd_script.cpp
@@ -27,18 +27,18 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "gd_script.h"
+#include "gd_compiler.h"
 #include "global_config.h"
 #include "global_constants.h"
-#include "gd_compiler.h"
-#include "os/file_access.h"
 #include "io/file_access_encrypted.h"
+#include "os/file_access.h"
 #include "os/os.h"
 
 ///////////////////////////
 
-GDNativeClass::GDNativeClass(const StringName& p_name) {
+GDNativeClass::GDNativeClass(const StringName &p_name) {
 
-	name=p_name;
+	name = p_name;
 }
 
 /*void GDNativeClass::call_multilevel(const StringName& p_method,const Variant** p_args,int p_argcount){
@@ -46,33 +46,30 @@ GDNativeClass::GDNativeClass(const StringName& p_name) {
 
 }*/
 
-
-bool GDNativeClass::_get(const StringName& p_name,Variant &r_ret) const {
+bool GDNativeClass::_get(const StringName &p_name, Variant &r_ret) const {
 
 	bool ok;
 	int v = ClassDB::get_integer_constant(name, p_name, &ok);
 
 	if (ok) {
-		r_ret=v;
+		r_ret = v;
 		return true;
 	} else {
 		return false;
 	}
 }
 
-
 void GDNativeClass::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("new"),&GDNativeClass::_new);
-
+	ClassDB::bind_method(D_METHOD("new"), &GDNativeClass::_new);
 }
 
 Variant GDNativeClass::_new() {
 
 	Object *o = instance();
 	if (!o) {
-		ERR_EXPLAIN("Class type: '"+String(name)+"' is not instantiable.");
-		ERR_FAIL_COND_V(!o,Variant());
+		ERR_EXPLAIN("Class type: '" + String(name) + "' is not instantiable.");
+		ERR_FAIL_COND_V(!o, Variant());
 	}
 
 	Reference *ref = o->cast_to<Reference>();
@@ -81,7 +78,6 @@ Variant GDNativeClass::_new() {
 	} else {
 		return o;
 	}
-
 }
 
 Object *GDNativeClass::instance() {
@@ -89,27 +85,24 @@ Object *GDNativeClass::instance() {
 	return ClassDB::instance(name);
 }
 
-
-
-GDInstance* GDScript::_create_instance(const Variant** p_args,int p_argcount,Object *p_owner,bool p_isref,Variant::CallError& r_error) {
-
+GDInstance *GDScript::_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_isref, Variant::CallError &r_error) {
 
 	/* STEP 1, CREATE */
 
-	GDInstance* instance = memnew( GDInstance );
-	instance->base_ref=p_isref;
+	GDInstance *instance = memnew(GDInstance);
+	instance->base_ref = p_isref;
 	instance->members.resize(member_indices.size());
-	instance->script=Ref<GDScript>(this);
-	instance->owner=p_owner;
+	instance->script = Ref<GDScript>(this);
+	instance->owner = p_owner;
 #ifdef DEBUG_ENABLED
 	//needed for hot reloading
-	for(Map<StringName,MemberInfo>::Element *E=member_indices.front();E;E=E->next()) {
-		instance->member_indices_cache[E->key()]=E->get().index;
+	for (Map<StringName, MemberInfo>::Element *E = member_indices.front(); E; E = E->next()) {
+		instance->member_indices_cache[E->key()] = E->get().index;
 	}
 #endif
 	instance->owner->set_script_instance(instance);
 
-	/* STEP 2, INITIALIZE AND CONSRTUCT */
+/* STEP 2, INITIALIZE AND CONSRTUCT */
 
 #ifndef NO_THREADS
 	GDScriptLanguage::singleton->lock->lock();
@@ -121,10 +114,10 @@ GDInstance* GDScript::_create_instance(const Variant** p_args,int p_argcount,Obj
 	GDScriptLanguage::singleton->lock->unlock();
 #endif
 
-	initializer->call(instance,p_args,p_argcount,r_error);
+	initializer->call(instance, p_args, p_argcount, r_error);
 
-	if (r_error.error!=Variant::CallError::CALL_OK) {
-		instance->script=Ref<GDScript>();
+	if (r_error.error != Variant::CallError::CALL_OK) {
+		instance->script = Ref<GDScript>();
 		instance->owner->set_script_instance(NULL);
 #ifndef NO_THREADS
 		GDScriptLanguage::singleton->lock->lock();
@@ -134,47 +127,45 @@ GDInstance* GDScript::_create_instance(const Variant** p_args,int p_argcount,Obj
 		GDScriptLanguage::singleton->lock->unlock();
 #endif
 
-		ERR_FAIL_COND_V(r_error.error!=Variant::CallError::CALL_OK, NULL); //error constructing
+		ERR_FAIL_COND_V(r_error.error != Variant::CallError::CALL_OK, NULL); //error constructing
 	}
 
 	//@TODO make thread safe
 	return instance;
-
 }
 
-Variant GDScript::_new(const Variant** p_args,int p_argcount,Variant::CallError& r_error) {
+Variant GDScript::_new(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
 
 	/* STEP 1, CREATE */
 
 	if (!valid) {
-		r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 		return Variant();
 	}
 
-	r_error.error=Variant::CallError::CALL_OK;
+	r_error.error = Variant::CallError::CALL_OK;
 	REF ref;
-	Object *owner=NULL;
+	Object *owner = NULL;
 
-	GDScript *_baseptr=this;
+	GDScript *_baseptr = this;
 	while (_baseptr->_base) {
-		_baseptr=_baseptr->_base;
+		_baseptr = _baseptr->_base;
 	}
 
 	ERR_FAIL_COND_V(_baseptr->native.is_null(), Variant());
 
 	if (_baseptr->native.ptr()) {
-		owner=_baseptr->native->instance();
+		owner = _baseptr->native->instance();
 	} else {
-		owner=memnew( Reference ); //by default, no base means use reference
+		owner = memnew(Reference); //by default, no base means use reference
 	}
 
-	Reference *r=owner->cast_to<Reference>();
+	Reference *r = owner->cast_to<Reference>();
 	if (r) {
-		ref=REF(r);
+		ref = REF(r);
 	}
 
-
-	GDInstance* instance = _create_instance(p_args,p_argcount,owner,r!=NULL,r_error);
+	GDInstance *instance = _create_instance(p_args, p_argcount, owner, r != NULL, r_error);
 	if (!instance) {
 		if (ref.is_null()) {
 			memdelete(owner); //no owner, sorry
@@ -193,13 +184,12 @@ bool GDScript::can_instance() const {
 
 	//return valid; //any script in GDscript can instance
 	return valid || (!tool && !ScriptServer::is_scripting_enabled());
-
 }
 
 Ref<Script> GDScript::get_base_script() const {
 
 	if (_base) {
-		return Ref<GDScript>( _base );
+		return Ref<GDScript>(_base);
 	} else {
 		return Ref<Script>();
 	}
@@ -218,14 +208,11 @@ struct _GDScriptMemberSort {
 
 	int index;
 	StringName name;
-	_FORCE_INLINE_ bool operator<(const _GDScriptMemberSort& p_member) const { return index < p_member.index; }
-
+	_FORCE_INLINE_ bool operator<(const _GDScriptMemberSort &p_member) const { return index < p_member.index; }
 };
 
-
 #ifdef TOOLS_ENABLED
 
-
 void GDScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
 
 	placeholders.erase(p_placeholder);
@@ -275,86 +262,80 @@ void GDScript::_update_placeholder(PlaceHolderScriptInstance *p_placeholder) {
 }*/
 #endif
 
-
 void GDScript::get_script_method_list(List<MethodInfo> *p_list) const {
 
-	for (const Map<StringName,GDFunction*>::Element *E=member_functions.front();E;E=E->next()) {
+	for (const Map<StringName, GDFunction *>::Element *E = member_functions.front(); E; E = E->next()) {
 		MethodInfo mi;
-		mi.name=E->key();
-		for(int i=0;i<E->get()->get_argument_count();i++) {
+		mi.name = E->key();
+		for (int i = 0; i < E->get()->get_argument_count(); i++) {
 			PropertyInfo arg;
-			arg.type=Variant::NIL; //variant
-			arg.name=E->get()->get_argument_name(i);
+			arg.type = Variant::NIL; //variant
+			arg.name = E->get()->get_argument_name(i);
 			mi.arguments.push_back(arg);
 		}
 
-		mi.return_val.name="Variant";
+		mi.return_val.name = "Variant";
 		p_list->push_back(mi);
 	}
 }
 
 void GDScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 
-	const GDScript *sptr=this;
+	const GDScript *sptr = this;
 	List<PropertyInfo> props;
 
-	while(sptr) {
+	while (sptr) {
 
 		Vector<_GDScriptMemberSort> msort;
-		for(Map<StringName,PropertyInfo>::Element *E=sptr->member_info.front();E;E=E->next()) {
+		for (Map<StringName, PropertyInfo>::Element *E = sptr->member_info.front(); E; E = E->next()) {
 
 			_GDScriptMemberSort ms;
 			ERR_CONTINUE(!sptr->member_indices.has(E->key()));
-			ms.index=sptr->member_indices[E->key()].index;
-			ms.name=E->key();
+			ms.index = sptr->member_indices[E->key()].index;
+			ms.name = E->key();
 			msort.push_back(ms);
-
 		}
 
 		msort.sort();
 		msort.invert();
-		for(int i=0;i<msort.size();i++) {
+		for (int i = 0; i < msort.size(); i++) {
 
 			props.push_front(sptr->member_info[msort[i].name]);
-
 		}
 
 		sptr = sptr->_base;
 	}
 
-	for (List<PropertyInfo>::Element *E=props.front();E;E=E->next()) {
+	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
 		p_list->push_back(E->get());
 	}
-
 }
 
-bool GDScript::has_method(const StringName& p_method) const {
+bool GDScript::has_method(const StringName &p_method) const {
 
 	return member_functions.has(p_method);
 }
 
-MethodInfo GDScript::get_method_info(const StringName& p_method) const {
+MethodInfo GDScript::get_method_info(const StringName &p_method) const {
 
-	const Map<StringName,GDFunction*>::Element *E=member_functions.find(p_method);
+	const Map<StringName, GDFunction *>::Element *E = member_functions.find(p_method);
 	if (!E)
 		return MethodInfo();
 
 	MethodInfo mi;
-	mi.name=E->key();
-	for(int i=0;i<E->get()->get_argument_count();i++) {
+	mi.name = E->key();
+	for (int i = 0; i < E->get()->get_argument_count(); i++) {
 		PropertyInfo arg;
-		arg.type=Variant::NIL; //variant
-		arg.name=E->get()->get_argument_name(i);
+		arg.type = Variant::NIL; //variant
+		arg.name = E->get()->get_argument_name(i);
 		mi.arguments.push_back(arg);
 	}
 
-	mi.return_val.name="Variant";
+	mi.return_val.name = "Variant";
 	return mi;
-
 }
 
-
-bool GDScript::get_property_default_value(const StringName& p_property, Variant &r_value) const {
+bool GDScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
 
 #ifdef TOOLS_ENABLED
 
@@ -363,26 +344,23 @@ bool GDScript::get_property_default_value(const StringName& p_property, Variant
 		print_line("\t"+String(String(I->key())+":"+String(I->get())));
 	}
 	*/
-	const Map<StringName,Variant>::Element *E=member_default_values_cache.find(p_property);
+	const Map<StringName, Variant>::Element *E = member_default_values_cache.find(p_property);
 	if (E) {
-		r_value=E->get();
+		r_value = E->get();
 		return true;
 	}
 
 	if (base_cache.is_valid()) {
-		return base_cache->get_property_default_value(p_property,r_value);
+		return base_cache->get_property_default_value(p_property, r_value);
 	}
 #endif
 	return false;
-
 }
 
-ScriptInstance* GDScript::instance_create(Object *p_this) {
-
+ScriptInstance *GDScript::instance_create(Object *p_this) {
 
 	if (!tool && !ScriptServer::is_scripting_enabled()) {
 
-
 #ifdef TOOLS_ENABLED
 
 		//instance a fake script for editing the values
@@ -392,7 +370,7 @@ ScriptInstance* GDScript::instance_create(Object *p_this) {
 		for(List<PropertyInfo>::Element *E=plist.front();E;E=E->next()) {
 			print_line(E->get().name);
 		}*/
-		PlaceHolderScriptInstance *si = memnew( PlaceHolderScriptInstance(GDScriptLanguage::get_singleton(),Ref<Script>(this),p_this) );
+		PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(GDScriptLanguage::get_singleton(), Ref<Script>(this), p_this));
 		placeholders.insert(si);
 		//_update_placeholder(si);
 		_update_exports();
@@ -402,32 +380,30 @@ ScriptInstance* GDScript::instance_create(Object *p_this) {
 #endif
 	}
 
-	GDScript *top=this;
-	while(top->_base)
-		top=top->_base;
+	GDScript *top = this;
+	while (top->_base)
+		top = top->_base;
 
 	if (top->native.is_valid()) {
-		if (!ClassDB::is_parent_class(p_this->get_class_name(),top->native->get_name())) {
+		if (!ClassDB::is_parent_class(p_this->get_class_name(), top->native->get_name())) {
 
 			if (ScriptDebugger::get_singleton()) {
-				GDScriptLanguage::get_singleton()->debug_break_parse(get_path(),0,"Script inherits from native type '"+String(top->native->get_name())+"', so it can't be instanced in object of type: '"+p_this->get_class()+"'");
+				GDScriptLanguage::get_singleton()->debug_break_parse(get_path(), 0, "Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instanced in object of type: '" + p_this->get_class() + "'");
 			}
-			ERR_EXPLAIN("Script inherits from native type '"+String(top->native->get_name())+"', so it can't be instanced in object of type: '"+p_this->get_class()+"'");
+			ERR_EXPLAIN("Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instanced in object of type: '" + p_this->get_class() + "'");
 			ERR_FAIL_V(NULL);
-
 		}
 	}
 
 	Variant::CallError unchecked_error;
-	return _create_instance(NULL,0,p_this,p_this->cast_to<Reference>(),unchecked_error);
-
+	return _create_instance(NULL, 0, p_this, p_this->cast_to<Reference>(), unchecked_error);
 }
 bool GDScript::instance_has(const Object *p_this) const {
 
 #ifndef NO_THREADS
 	GDScriptLanguage::singleton->lock->lock();
 #endif
-	bool hasit = instances.has((Object*)p_this);
+	bool hasit = instances.has((Object *)p_this);
 
 #ifndef NO_THREADS
 	GDScriptLanguage::singleton->lock->unlock();
@@ -438,39 +414,37 @@ bool GDScript::instance_has(const Object *p_this) const {
 
 bool GDScript::has_source_code() const {
 
-	return source!="";
+	return source != "";
 }
 String GDScript::get_source_code() const {
 
 	return source;
 }
-void GDScript::set_source_code(const String& p_code) {
+void GDScript::set_source_code(const String &p_code) {
 
-	if (source==p_code)
+	if (source == p_code)
 		return;
-	source=p_code;
+	source = p_code;
 #ifdef TOOLS_ENABLED
-	source_changed_cache=true;
-	//print_line("SC CHANGED "+get_path());
+	source_changed_cache = true;
+//print_line("SC CHANGED "+get_path());
 #endif
-
 }
 
 #ifdef TOOLS_ENABLED
-void GDScript::_update_exports_values(Map<StringName,Variant>& values, List<PropertyInfo> &propnames) {
+void GDScript::_update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames) {
 
 	if (base_cache.is_valid()) {
-		base_cache->_update_exports_values(values,propnames);
+		base_cache->_update_exports_values(values, propnames);
 	}
 
-	for(Map<StringName,Variant>::Element *E=member_default_values_cache.front();E;E=E->next()) {
-		values[E->key()]=E->get();
+	for (Map<StringName, Variant>::Element *E = member_default_values_cache.front(); E; E = E->next()) {
+		values[E->key()] = E->get();
 	}
 
-	for (List<PropertyInfo>::Element *E=members_cache.front();E;E=E->next()) {
+	for (List<PropertyInfo>::Element *E = members_cache.front(); E; E = E->next()) {
 		propnames.push_back(E->get());
 	}
-
 }
 #endif
 
@@ -478,90 +452,87 @@ bool GDScript::_update_exports() {
 
 #ifdef TOOLS_ENABLED
 
-	bool changed=false;
+	bool changed = false;
 
 	if (source_changed_cache) {
 		//print_line("updating source for "+get_path());
-		source_changed_cache=false;
-		changed=true;
+		source_changed_cache = false;
+		changed = true;
 
-		String basedir=path;
+		String basedir = path;
 
-		if (basedir=="")
-			basedir=get_path();
+		if (basedir == "")
+			basedir = get_path();
 
-		if (basedir!="")
-			basedir=basedir.get_base_dir();
+		if (basedir != "")
+			basedir = basedir.get_base_dir();
 
 		GDParser parser;
-		Error err = parser.parse(source,basedir,true,path);
+		Error err = parser.parse(source, basedir, true, path);
 
-		if (err==OK) {
+		if (err == OK) {
 
-			const GDParser::Node* root = parser.get_parse_tree();
-			ERR_FAIL_COND_V(root->type!=GDParser::Node::TYPE_CLASS,false);
+			const GDParser::Node *root = parser.get_parse_tree();
+			ERR_FAIL_COND_V(root->type != GDParser::Node::TYPE_CLASS, false);
 
-			const GDParser::ClassNode *c = static_cast<const GDParser::ClassNode*>(root);
+			const GDParser::ClassNode *c = static_cast<const GDParser::ClassNode *>(root);
 
 			if (base_cache.is_valid()) {
 				base_cache->inheriters_cache.erase(get_instance_ID());
-				base_cache=Ref<GDScript>();
+				base_cache = Ref<GDScript>();
 			}
 
-
-			if (c->extends_used && String(c->extends_file)!="" && String(c->extends_file) != get_path()) {
+			if (c->extends_used && String(c->extends_file) != "" && String(c->extends_file) != get_path()) {
 
 				String path = c->extends_file;
 				if (path.is_rel_path()) {
 
 					String base = get_path();
-					if (base=="" || base.is_rel_path()) {
+					if (base == "" || base.is_rel_path()) {
 
-						ERR_PRINT(("Could not resolve relative path for parent class: "+path).utf8().get_data());
+						ERR_PRINT(("Could not resolve relative path for parent class: " + path).utf8().get_data());
 					} else {
-						path=base.get_base_dir().plus_file(path);
+						path = base.get_base_dir().plus_file(path);
 					}
 				}
 
-				if (path!=get_path()) {
+				if (path != get_path()) {
 
 					Ref<GDScript> bf = ResourceLoader::load(path);
 
 					if (bf.is_valid()) {
 
 						//print_line("parent is: "+bf->get_path());
-						base_cache=bf;
+						base_cache = bf;
 						bf->inheriters_cache.insert(get_instance_ID());
 
 						//bf->_update_exports(p_instances,true,false);
-
 					}
 				} else {
-					ERR_PRINT(("Path extending itself in  "+path).utf8().get_data());
+					ERR_PRINT(("Path extending itself in  " + path).utf8().get_data());
 				}
 			}
 
 			members_cache.clear();
 			member_default_values_cache.clear();
 
-			for(int i=0;i<c->variables.size();i++) {
-				if (c->variables[i]._export.type==Variant::NIL)
+			for (int i = 0; i < c->variables.size(); i++) {
+				if (c->variables[i]._export.type == Variant::NIL)
 					continue;
 
 				members_cache.push_back(c->variables[i]._export);
 				//print_line("found "+c->variables[i]._export.name);
-				member_default_values_cache[c->variables[i].identifier]=c->variables[i].default_value;
+				member_default_values_cache[c->variables[i].identifier] = c->variables[i].default_value;
 			}
 
 			_signals.clear();
 
-			for(int i=0;i<c->_signals.size();i++) {
-				_signals[c->_signals[i].name]=c->_signals[i].arguments;
+			for (int i = 0; i < c->_signals.size(); i++) {
+				_signals[c->_signals[i].name] = c->_signals[i].arguments;
 			}
 		}
 	} else {
 		//print_line("unchaged is "+get_path());
-
 	}
 
 	if (base_cache.is_valid()) {
@@ -575,13 +546,13 @@ bool GDScript::_update_exports() {
 		//print_line("updating placeholders for "+get_path());
 
 		//update placeholders if any
-		Map<StringName,Variant> values;
+		Map<StringName, Variant> values;
 		List<PropertyInfo> propnames;
-		_update_exports_values(values,propnames);
+		_update_exports_values(values, propnames);
 
-		for (Set<PlaceHolderScriptInstance*>::Element *E=placeholders.front();E;E=E->next()) {
+		for (Set<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) {
 
-			E->get()->update(propnames,values);
+			E->get()->update(propnames, values);
 		}
 	}
 
@@ -597,14 +568,14 @@ void GDScript::update_exports() {
 
 	_update_exports();
 
-	Set<ObjectID> copy=inheriters_cache; //might get modified
+	Set<ObjectID> copy = inheriters_cache; //might get modified
 
 	//print_line("update exports for "+get_path()+" ic: "+itos(copy.size()));
-	for(Set<ObjectID>::Element *E=copy.front();E;E=E->next()) {
-		Object *id=ObjectDB::get_instance(E->get());
+	for (Set<ObjectID>::Element *E = copy.front(); E; E = E->next()) {
+		Object *id = ObjectDB::get_instance(E->get());
 		if (!id)
 			continue;
-		GDScript *s=id->cast_to<GDScript>();
+		GDScript *s = id->cast_to<GDScript>();
 		if (!s)
 			continue;
 		s->update_exports();
@@ -613,12 +584,12 @@ void GDScript::update_exports() {
 #endif
 }
 
-void GDScript::_set_subclass_path(Ref<GDScript>& p_sc,const String& p_path) {
+void GDScript::_set_subclass_path(Ref<GDScript> &p_sc, const String &p_path) {
 
-	p_sc->path=p_path;
-	for(Map<StringName,Ref<GDScript> >::Element *E=p_sc->subclasses.front();E;E=E->next()) {
+	p_sc->path = p_path;
+	for (Map<StringName, Ref<GDScript> >::Element *E = p_sc->subclasses.front(); E; E = E->next()) {
 
-		_set_subclass_path(E->get(),p_path);
+		_set_subclass_path(E->get(), p_path);
 	}
 }
 
@@ -633,58 +604,54 @@ Error GDScript::reload(bool p_keep_state) {
 	GDScriptLanguage::singleton->lock->unlock();
 #endif
 
-	ERR_FAIL_COND_V(!p_keep_state && has_instances,ERR_ALREADY_IN_USE);
-
-	String basedir=path;
-
-	if (basedir=="")
-		basedir=get_path();
+	ERR_FAIL_COND_V(!p_keep_state && has_instances, ERR_ALREADY_IN_USE);
 
-	if (basedir!="")
-		basedir=basedir.get_base_dir();
+	String basedir = path;
 
+	if (basedir == "")
+		basedir = get_path();
 
+	if (basedir != "")
+		basedir = basedir.get_base_dir();
 
-
-	valid=false;
+	valid = false;
 	GDParser parser;
-	Error err = parser.parse(source,basedir,false,path);
+	Error err = parser.parse(source, basedir, false, path);
 	if (err) {
 		if (ScriptDebugger::get_singleton()) {
-			GDScriptLanguage::get_singleton()->debug_break_parse(get_path(),parser.get_error_line(),"Parser Error: "+parser.get_error());
+			GDScriptLanguage::get_singleton()->debug_break_parse(get_path(), parser.get_error_line(), "Parser Error: " + parser.get_error());
 		}
-		_err_print_error("GDScript::reload",path.empty()?"built-in":(const char*)path.utf8().get_data(),parser.get_error_line(),("Parse Error: "+parser.get_error()).utf8().get_data(),ERR_HANDLER_SCRIPT);
+		_err_print_error("GDScript::reload", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), parser.get_error_line(), ("Parse Error: " + parser.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
 		ERR_FAIL_V(ERR_PARSE_ERROR);
 	}
 
-
 	bool can_run = ScriptServer::is_scripting_enabled() || parser.is_tool_script();
 
 	GDCompiler compiler;
-	err = compiler.compile(&parser,this,p_keep_state);
+	err = compiler.compile(&parser, this, p_keep_state);
 
 	if (err) {
 
 		if (can_run) {
 			if (ScriptDebugger::get_singleton()) {
-				GDScriptLanguage::get_singleton()->debug_break_parse(get_path(),compiler.get_error_line(),"Parser Error: "+compiler.get_error());
+				GDScriptLanguage::get_singleton()->debug_break_parse(get_path(), compiler.get_error_line(), "Parser Error: " + compiler.get_error());
 			}
-			_err_print_error("GDScript::reload",path.empty()?"built-in":(const char*)path.utf8().get_data(),compiler.get_error_line(),("Compile Error: "+compiler.get_error()).utf8().get_data(),ERR_HANDLER_SCRIPT);
+			_err_print_error("GDScript::reload", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), compiler.get_error_line(), ("Compile Error: " + compiler.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
 			ERR_FAIL_V(ERR_COMPILATION_FAILED);
 		} else {
 			return err;
 		}
 	}
 
-	valid=true;
+	valid = true;
 
-	for(Map<StringName,Ref<GDScript> >::Element *E=subclasses.front();E;E=E->next()) {
+	for (Map<StringName, Ref<GDScript> >::Element *E = subclasses.front(); E; E = E->next()) {
 
-		_set_subclass_path(E->get(),path);
+		_set_subclass_path(E->get(), path);
 	}
 
 #ifdef TOOLS_ENABLED
-	/*for (Set<PlaceHolderScriptInstance*>::Element *E=placeholders.front();E;E=E->next()) {
+/*for (Set<PlaceHolderScriptInstance*>::Element *E=placeholders.front();E;E=E->next()) {
 
 		_update_placeholder(E->get());
 	}*/
@@ -702,74 +669,67 @@ ScriptLanguage *GDScript::get_language() const {
 	return GDScriptLanguage::get_singleton();
 }
 
+Variant GDScript::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
 
-Variant GDScript::call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error) {
+	GDScript *top = this;
+	while (top) {
 
-
-	GDScript *top=this;
-	while(top) {
-
-		Map<StringName,GDFunction*>::Element *E=top->member_functions.find(p_method);
+		Map<StringName, GDFunction *>::Element *E = top->member_functions.find(p_method);
 		if (E) {
 
 			if (!E->get()->is_static()) {
-				WARN_PRINT(String("Can't call non-static function: '"+String(p_method)+"' in script.").utf8().get_data());
+				WARN_PRINT(String("Can't call non-static function: '" + String(p_method) + "' in script.").utf8().get_data());
 			}
 
-			return E->get()->call(NULL,p_args,p_argcount,r_error);
+			return E->get()->call(NULL, p_args, p_argcount, r_error);
 		}
-		top=top->_base;
+		top = top->_base;
 	}
 
 	//none found, regular
 
-	return Script::call(p_method,p_args,p_argcount,r_error);
-
+	return Script::call(p_method, p_args, p_argcount, r_error);
 }
 
-bool GDScript::_get(const StringName& p_name,Variant &r_ret) const {
+bool GDScript::_get(const StringName &p_name, Variant &r_ret) const {
 
 	{
 
-
-		const GDScript *top=this;
-		while(top) {
+		const GDScript *top = this;
+		while (top) {
 
 			{
-				const Map<StringName,Variant>::Element *E=top->constants.find(p_name);
+				const Map<StringName, Variant>::Element *E = top->constants.find(p_name);
 				if (E) {
 
-					r_ret= E->get();
+					r_ret = E->get();
 					return true;
 				}
 			}
 
 			{
-				const Map<StringName,Ref<GDScript> >::Element *E=subclasses.find(p_name);
+				const Map<StringName, Ref<GDScript> >::Element *E = subclasses.find(p_name);
 				if (E) {
 
-					r_ret=E->get();
+					r_ret = E->get();
 					return true;
 				}
 			}
-			top=top->_base;
+			top = top->_base;
 		}
 
-		if (p_name==GDScriptLanguage::get_singleton()->strings._script_source) {
+		if (p_name == GDScriptLanguage::get_singleton()->strings._script_source) {
 
-			r_ret=get_source_code();
+			r_ret = get_source_code();
 			return true;
 		}
 	}
 
-
-
 	return false;
-
 }
-bool GDScript::_set(const StringName& p_name, const Variant& p_value) {
+bool GDScript::_set(const StringName &p_name, const Variant &p_value) {
 
-	if (p_name==GDScriptLanguage::get_singleton()->strings._script_source) {
+	if (p_name == GDScriptLanguage::get_singleton()->strings._script_source) {
 
 		set_source_code(p_value);
 		reload();
@@ -781,159 +741,147 @@ bool GDScript::_set(const StringName& p_name, const Variant& p_value) {
 
 void GDScript::_get_property_list(List<PropertyInfo> *p_properties) const {
 
-	p_properties->push_back( PropertyInfo(Variant::STRING,"script/source",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR) );
+	p_properties->push_back(PropertyInfo(Variant::STRING, "script/source", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
 }
 
-
 void GDScript::_bind_methods() {
 
-	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT,"new",&GDScript::_new,MethodInfo(Variant::OBJECT,"new"));
-
-	ClassDB::bind_method(D_METHOD("get_as_byte_code"),&GDScript::get_as_byte_code);
+	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "new", &GDScript::_new, MethodInfo(Variant::OBJECT, "new"));
 
+	ClassDB::bind_method(D_METHOD("get_as_byte_code"), &GDScript::get_as_byte_code);
 }
 
-
 Vector<uint8_t> GDScript::get_as_byte_code() const {
 
 	GDTokenizerBuffer tokenizer;
 	return tokenizer.parse_code_string(source);
 };
 
-
-Error GDScript::load_byte_code(const String& p_path) {
+Error GDScript::load_byte_code(const String &p_path) {
 
 	Vector<uint8_t> bytecode;
 
 	if (p_path.ends_with("gde")) {
 
-		FileAccess *fa = FileAccess::open(p_path,FileAccess::READ);
-		ERR_FAIL_COND_V(!fa,ERR_CANT_OPEN);
-		FileAccessEncrypted *fae = memnew( FileAccessEncrypted );
-		ERR_FAIL_COND_V(!fae,ERR_CANT_OPEN);
+		FileAccess *fa = FileAccess::open(p_path, FileAccess::READ);
+		ERR_FAIL_COND_V(!fa, ERR_CANT_OPEN);
+		FileAccessEncrypted *fae = memnew(FileAccessEncrypted);
+		ERR_FAIL_COND_V(!fae, ERR_CANT_OPEN);
 		Vector<uint8_t> key;
 		key.resize(32);
-		for(int i=0;i<key.size();i++) {
-			key[i]=script_encryption_key[i];
+		for (int i = 0; i < key.size(); i++) {
+			key[i] = script_encryption_key[i];
 		}
-		Error err = fae->open_and_parse(fa,key,FileAccessEncrypted::MODE_READ);
-		ERR_FAIL_COND_V(err,err);
+		Error err = fae->open_and_parse(fa, key, FileAccessEncrypted::MODE_READ);
+		ERR_FAIL_COND_V(err, err);
 		bytecode.resize(fae->get_len());
-		fae->get_buffer(bytecode.ptr(),bytecode.size());
+		fae->get_buffer(bytecode.ptr(), bytecode.size());
 		memdelete(fae);
 	} else {
 
 		bytecode = FileAccess::get_file_as_array(p_path);
 	}
-	ERR_FAIL_COND_V(bytecode.size()==0,ERR_PARSE_ERROR);
-	path=p_path;
+	ERR_FAIL_COND_V(bytecode.size() == 0, ERR_PARSE_ERROR);
+	path = p_path;
 
-	String basedir=path;
+	String basedir = path;
 
-	if (basedir=="")
-		basedir=get_path();
+	if (basedir == "")
+		basedir = get_path();
 
-	if (basedir!="")
-		basedir=basedir.get_base_dir();
+	if (basedir != "")
+		basedir = basedir.get_base_dir();
 
-	valid=false;
+	valid = false;
 	GDParser parser;
-	Error err = parser.parse_bytecode(bytecode,basedir,get_path());
+	Error err = parser.parse_bytecode(bytecode, basedir, get_path());
 	if (err) {
-		_err_print_error("GDScript::load_byte_code",path.empty()?"built-in":(const char*)path.utf8().get_data(),parser.get_error_line(),("Parse Error: "+parser.get_error()).utf8().get_data(),ERR_HANDLER_SCRIPT);
+		_err_print_error("GDScript::load_byte_code", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), parser.get_error_line(), ("Parse Error: " + parser.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
 		ERR_FAIL_V(ERR_PARSE_ERROR);
 	}
 
 	GDCompiler compiler;
-	err = compiler.compile(&parser,this);
+	err = compiler.compile(&parser, this);
 
 	if (err) {
-		_err_print_error("GDScript::load_byte_code",path.empty()?"built-in":(const char*)path.utf8().get_data(),compiler.get_error_line(),("Compile Error: "+compiler.get_error()).utf8().get_data(),ERR_HANDLER_SCRIPT);
+		_err_print_error("GDScript::load_byte_code", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), compiler.get_error_line(), ("Compile Error: " + compiler.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
 		ERR_FAIL_V(ERR_COMPILATION_FAILED);
 	}
 
-	valid=true;
+	valid = true;
 
-	for(Map<StringName,Ref<GDScript> >::Element *E=subclasses.front();E;E=E->next()) {
+	for (Map<StringName, Ref<GDScript> >::Element *E = subclasses.front(); E; E = E->next()) {
 
-		_set_subclass_path(E->get(),path);
+		_set_subclass_path(E->get(), path);
 	}
 
 	return OK;
 }
 
-
-Error GDScript::load_source_code(const String& p_path) {
-
+Error GDScript::load_source_code(const String &p_path) {
 
 	PoolVector<uint8_t> sourcef;
 	Error err;
-	FileAccess *f=FileAccess::open(p_path,FileAccess::READ,&err);
+	FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
 	if (err) {
 
-		ERR_FAIL_COND_V(err,err);
+		ERR_FAIL_COND_V(err, err);
 	}
 
 	int len = f->get_len();
-	sourcef.resize(len+1);
+	sourcef.resize(len + 1);
 	PoolVector<uint8_t>::Write w = sourcef.write();
-	int r = f->get_buffer(w.ptr(),len);
+	int r = f->get_buffer(w.ptr(), len);
 	f->close();
 	memdelete(f);
-	ERR_FAIL_COND_V(r!=len,ERR_CANT_OPEN);
-	w[len]=0;
+	ERR_FAIL_COND_V(r != len, ERR_CANT_OPEN);
+	w[len] = 0;
 
 	String s;
-	if (s.parse_utf8((const char*)w.ptr())) {
+	if (s.parse_utf8((const char *)w.ptr())) {
 
-		ERR_EXPLAIN("Script '"+p_path+"' contains invalid unicode (utf-8), so it was not loaded. Please ensure that scripts are saved in valid utf-8 unicode.");
+		ERR_EXPLAIN("Script '" + p_path + "' contains invalid unicode (utf-8), so it was not loaded. Please ensure that scripts are saved in valid utf-8 unicode.");
 		ERR_FAIL_V(ERR_INVALID_DATA);
 	}
 
-	source=s;
+	source = s;
 #ifdef TOOLS_ENABLED
-	source_changed_cache=true;
+	source_changed_cache = true;
 #endif
 	//print_line("LSC :"+get_path());
-	path=p_path;
+	path = p_path;
 	return OK;
-
 }
 
-
-const Map<StringName,GDFunction*>& GDScript::debug_get_member_functions() const {
+const Map<StringName, GDFunction *> &GDScript::debug_get_member_functions() const {
 
 	return member_functions;
 }
 
-
-
 StringName GDScript::debug_get_member_by_index(int p_idx) const {
 
+	for (const Map<StringName, MemberInfo>::Element *E = member_indices.front(); E; E = E->next()) {
 
-	for(const Map<StringName,MemberInfo>::Element *E=member_indices.front();E;E=E->next()) {
-
-		if (E->get().index==p_idx)
+		if (E->get().index == p_idx)
 			return E->key();
 	}
 
 	return "<error>";
 }
 
-
 Ref<GDScript> GDScript::get_base() const {
 
 	return base;
 }
 
-bool GDScript::has_script_signal(const StringName& p_signal) const {
+bool GDScript::has_script_signal(const StringName &p_signal) const {
 	if (_signals.has(p_signal))
 		return true;
 	if (base.is_valid()) {
 		return base->has_script_signal(p_signal);
 	}
 #ifdef TOOLS_ENABLED
-	else if (base_cache.is_valid()){
+	else if (base_cache.is_valid()) {
 		return base_cache->has_script_signal(p_signal);
 	}
 
@@ -942,13 +890,13 @@ bool GDScript::has_script_signal(const StringName& p_signal) const {
 }
 void GDScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
 
-	for(const Map<StringName,Vector<StringName> >::Element *E=_signals.front();E;E=E->next()) {
+	for (const Map<StringName, Vector<StringName> >::Element *E = _signals.front(); E; E = E->next()) {
 
 		MethodInfo mi;
-		mi.name=E->key();
-		for(int i=0;i<E->get().size();i++) {
+		mi.name = E->key();
+		for (int i = 0; i < E->get().size(); i++) {
 			PropertyInfo arg;
-			arg.name=E->get()[i];
+			arg.name = E->get()[i];
 			mi.arguments.push_back(arg);
 		}
 		r_signals->push_back(mi);
@@ -958,27 +906,25 @@ void GDScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
 		base->get_script_signal_list(r_signals);
 	}
 #ifdef TOOLS_ENABLED
-	else if (base_cache.is_valid()){
+	else if (base_cache.is_valid()) {
 		base_cache->get_script_signal_list(r_signals);
 	}
 
 #endif
-
 }
 
+GDScript::GDScript()
+	: script_list(this) {
 
-GDScript::GDScript() : script_list(this) {
-
-
-	_static_ref=this;
-	valid=false;
-	subclass_count=0;
-	initializer=NULL;
-	_base=NULL;
-	_owner=NULL;
-	tool=false;
+	_static_ref = this;
+	valid = false;
+	subclass_count = 0;
+	initializer = NULL;
+	_base = NULL;
+	_owner = NULL;
+	tool = false;
 #ifdef TOOLS_ENABLED
-	source_changed_cache=false;
+	source_changed_cache = false;
 #endif
 
 #ifdef DEBUG_ENABLED
@@ -994,12 +940,12 @@ GDScript::GDScript() : script_list(this) {
 }
 
 GDScript::~GDScript() {
-	for (Map<StringName,GDFunction*>::Element *E=member_functions.front();E;E=E->next()) {
-		memdelete( E->get() );
+	for (Map<StringName, GDFunction *>::Element *E = member_functions.front(); E; E = E->next()) {
+		memdelete(E->get());
 	}
 
-	for (Map<StringName,Ref<GDScript> >::Element *E=subclasses.front();E;E=E->next()) {
-		E->get()->_owner=NULL; //bye, you are no longer owned cause I died
+	for (Map<StringName, Ref<GDScript> >::Element *E = subclasses.front(); E; E = E->next()) {
+		E->get()->_owner = NULL; //bye, you are no longer owned cause I died
 	}
 
 #ifdef DEBUG_ENABLED
@@ -1014,48 +960,41 @@ GDScript::~GDScript() {
 #endif
 }
 
-
-
-
-
 //////////////////////////////
 //         INSTANCE         //
 //////////////////////////////
 
-
-bool GDInstance::set(const StringName& p_name, const Variant& p_value) {
+bool GDInstance::set(const StringName &p_name, const Variant &p_value) {
 
 	//member
 	{
-		const Map<StringName,GDScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
+		const Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
 		if (E) {
 			if (E->get().setter) {
-				const Variant *val=&p_value;
+				const Variant *val = &p_value;
 				Variant::CallError err;
-				call(E->get().setter,&val,1,err);
-				if (err.error==Variant::CallError::CALL_OK) {
+				call(E->get().setter, &val, 1, err);
+				if (err.error == Variant::CallError::CALL_OK) {
 					return true; //function exists, call was successful
 				}
-			}
-			else
+			} else
 				members[E->get().index] = p_value;
 			return true;
 		}
 	}
 
-	GDScript *sptr=script.ptr();
-	while(sptr) {
-
+	GDScript *sptr = script.ptr();
+	while (sptr) {
 
-		Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._set);
+		Map<StringName, GDFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._set);
 		if (E) {
 
-			Variant name=p_name;
-			const Variant *args[2]={&name,&p_value};
+			Variant name = p_name;
+			const Variant *args[2] = { &name, &p_value };
 
 			Variant::CallError err;
-			Variant ret = E->get()->call(this,(const Variant**)args,2,err);
-			if (err.error==Variant::CallError::CALL_OK && ret.get_type()==Variant::BOOL && ret.operator bool())
+			Variant ret = E->get()->call(this, (const Variant **)args, 2, err);
+			if (err.error == Variant::CallError::CALL_OK && ret.get_type() == Variant::BOOL && ret.operator bool())
 				return true;
 		}
 		sptr = sptr->_base;
@@ -1064,54 +1003,50 @@ bool GDInstance::set(const StringName& p_name, const Variant& p_value) {
 	return false;
 }
 
-bool GDInstance::get(const StringName& p_name, Variant &r_ret) const {
+bool GDInstance::get(const StringName &p_name, Variant &r_ret) const {
 
-
-
-	const GDScript *sptr=script.ptr();
-	while(sptr) {
+	const GDScript *sptr = script.ptr();
+	while (sptr) {
 
 		{
-			const Map<StringName,GDScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
+			const Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
 			if (E) {
 				if (E->get().getter) {
 					Variant::CallError err;
-					r_ret=const_cast<GDInstance*>(this)->call(E->get().getter,NULL,0,err);
-					if (err.error==Variant::CallError::CALL_OK) {
+					r_ret = const_cast<GDInstance *>(this)->call(E->get().getter, NULL, 0, err);
+					if (err.error == Variant::CallError::CALL_OK) {
 						return true;
 					}
 				}
-				r_ret=members[E->get().index];
+				r_ret = members[E->get().index];
 				return true; //index found
-
 			}
 		}
 
 		{
 
 			const GDScript *sl = sptr;
-			while(sl) {
-				const Map<StringName,Variant>::Element *E = sl->constants.find(p_name);
+			while (sl) {
+				const Map<StringName, Variant>::Element *E = sl->constants.find(p_name);
 				if (E) {
-					r_ret=E->get();
+					r_ret = E->get();
 					return true; //index found
-
 				}
-				sl=sl->_base;
+				sl = sl->_base;
 			}
 		}
 
 		{
-			const Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get);
+			const Map<StringName, GDFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get);
 			if (E) {
 
-				Variant name=p_name;
-				const Variant *args[1]={&name};
+				Variant name = p_name;
+				const Variant *args[1] = { &name };
 
 				Variant::CallError err;
-				Variant ret = const_cast<GDFunction*>(E->get())->call(const_cast<GDInstance*>(this),(const Variant**)args,1,err);
-				if (err.error==Variant::CallError::CALL_OK && ret.get_type()!=Variant::NIL) {
-					r_ret=ret;
+				Variant ret = const_cast<GDFunction *>(E->get())->call(const_cast<GDInstance *>(this), (const Variant **)args, 1, err);
+				if (err.error == Variant::CallError::CALL_OK && ret.get_type() != Variant::NIL) {
+					r_ret = ret;
 					return true;
 				}
 			}
@@ -1120,94 +1055,86 @@ bool GDInstance::get(const StringName& p_name, Variant &r_ret) const {
 	}
 
 	return false;
-
 }
 
-Variant::Type GDInstance::get_property_type(const StringName& p_name,bool *r_is_valid) const {
+Variant::Type GDInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
 
-
-	const GDScript *sptr=script.ptr();
-	while(sptr) {
+	const GDScript *sptr = script.ptr();
+	while (sptr) {
 
 		if (sptr->member_info.has(p_name)) {
 			if (r_is_valid)
-				*r_is_valid=true;
+				*r_is_valid = true;
 			return sptr->member_info[p_name].type;
 		}
 		sptr = sptr->_base;
 	}
 
 	if (r_is_valid)
-		*r_is_valid=false;
+		*r_is_valid = false;
 	return Variant::NIL;
 }
 
 void GDInstance::get_property_list(List<PropertyInfo> *p_properties) const {
 	// exported members, not doen yet!
 
-	const GDScript *sptr=script.ptr();
+	const GDScript *sptr = script.ptr();
 	List<PropertyInfo> props;
 
-	while(sptr) {
-
+	while (sptr) {
 
-		const Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get_property_list);
+		const Map<StringName, GDFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get_property_list);
 		if (E) {
 
-
 			Variant::CallError err;
-			Variant ret = const_cast<GDFunction*>(E->get())->call(const_cast<GDInstance*>(this),NULL,0,err);
-			if (err.error==Variant::CallError::CALL_OK) {
+			Variant ret = const_cast<GDFunction *>(E->get())->call(const_cast<GDInstance *>(this), NULL, 0, err);
+			if (err.error == Variant::CallError::CALL_OK) {
 
-				if (ret.get_type()!=Variant::ARRAY) {
+				if (ret.get_type() != Variant::ARRAY) {
 
 					ERR_EXPLAIN("Wrong type for _get_property list, must be an array of dictionaries.");
 					ERR_FAIL();
 				}
 				Array arr = ret;
-				for(int i=0;i<arr.size();i++) {
+				for (int i = 0; i < arr.size(); i++) {
 
 					Dictionary d = arr[i];
 					ERR_CONTINUE(!d.has("name"));
 					ERR_CONTINUE(!d.has("type"));
 					PropertyInfo pinfo;
-					pinfo.type = Variant::Type( d["type"].operator int());
-					ERR_CONTINUE(pinfo.type<0 || pinfo.type>=Variant::VARIANT_MAX );
+					pinfo.type = Variant::Type(d["type"].operator int());
+					ERR_CONTINUE(pinfo.type < 0 || pinfo.type >= Variant::VARIANT_MAX);
 					pinfo.name = d["name"];
-					ERR_CONTINUE(pinfo.name=="");
+					ERR_CONTINUE(pinfo.name == "");
 					if (d.has("hint"))
-						pinfo.hint=PropertyHint(d["hint"].operator int());
+						pinfo.hint = PropertyHint(d["hint"].operator int());
 					if (d.has("hint_string"))
-						pinfo.hint_string=d["hint_string"];
+						pinfo.hint_string = d["hint_string"];
 					if (d.has("usage"))
-						pinfo.usage=d["usage"];
+						pinfo.usage = d["usage"];
 
 					props.push_back(pinfo);
-
 				}
-
 			}
 		}
 
 		//instance a fake script for editing the values
 
 		Vector<_GDScriptMemberSort> msort;
-		for(Map<StringName,PropertyInfo>::Element *E=sptr->member_info.front();E;E=E->next()) {
+		for (Map<StringName, PropertyInfo>::Element *E = sptr->member_info.front(); E; E = E->next()) {
 
 			_GDScriptMemberSort ms;
 			ERR_CONTINUE(!sptr->member_indices.has(E->key()));
-			ms.index=sptr->member_indices[E->key()].index;
-			ms.name=E->key();
+			ms.index = sptr->member_indices[E->key()].index;
+			ms.name = E->key();
 			msort.push_back(ms);
-
 		}
 
 		msort.sort();
 		msort.invert();
-		for(int i=0;i<msort.size();i++) {
+		for (int i = 0; i < msort.size(); i++) {
 
 			props.push_front(sptr->member_info[msort[i].name]);
-
 		}
 #if 0
 		if (sptr->member_functions.has("_get_property_list")) {
@@ -1256,7 +1183,7 @@ void GDInstance::get_property_list(List<PropertyInfo> *p_properties) const {
 
 	//props.invert();
 
-	for (List<PropertyInfo>::Element *E=props.front();E;E=E->next()) {
+	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
 
 		p_properties->push_back(E->get());
 	}
@@ -1264,28 +1191,27 @@ void GDInstance::get_property_list(List<PropertyInfo> *p_properties) const {
 
 void GDInstance::get_method_list(List<MethodInfo> *p_list) const {
 
-	const GDScript *sptr=script.ptr();
-	while(sptr) {
+	const GDScript *sptr = script.ptr();
+	while (sptr) {
 
-		for (Map<StringName,GDFunction*>::Element *E = sptr->member_functions.front();E;E=E->next()) {
+		for (Map<StringName, GDFunction *>::Element *E = sptr->member_functions.front(); E; E = E->next()) {
 
 			MethodInfo mi;
-			mi.name=E->key();
-			mi.flags|=METHOD_FLAG_FROM_SCRIPT;
-			for(int i=0;i<E->get()->get_argument_count();i++)
-				mi.arguments.push_back(PropertyInfo(Variant::NIL,"arg"+itos(i)));
+			mi.name = E->key();
+			mi.flags |= METHOD_FLAG_FROM_SCRIPT;
+			for (int i = 0; i < E->get()->get_argument_count(); i++)
+				mi.arguments.push_back(PropertyInfo(Variant::NIL, "arg" + itos(i)));
 			p_list->push_back(mi);
 		}
 		sptr = sptr->_base;
 	}
-
 }
 
-bool GDInstance::has_method(const StringName& p_method) const {
+bool GDInstance::has_method(const StringName &p_method) const {
 
-	const GDScript *sptr=script.ptr();
-	while(sptr) {
-		const Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(p_method);
+	const GDScript *sptr = script.ptr();
+	while (sptr) {
+		const Map<StringName, GDFunction *>::Element *E = sptr->member_functions.find(p_method);
 		if (E)
 			return true;
 		sptr = sptr->_base;
@@ -1293,81 +1219,74 @@ bool GDInstance::has_method(const StringName& p_method) const {
 
 	return false;
 }
-Variant GDInstance::call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error) {
+Variant GDInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
 
 	//printf("calling %ls:%i method %ls\n", script->get_path().c_str(), -1, String(p_method).c_str());
 
-	GDScript *sptr=script.ptr();
-	while(sptr) {
-		Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(p_method);
+	GDScript *sptr = script.ptr();
+	while (sptr) {
+		Map<StringName, GDFunction *>::Element *E = sptr->member_functions.find(p_method);
 		if (E) {
-			return E->get()->call(this,p_args,p_argcount,r_error);
+			return E->get()->call(this, p_args, p_argcount, r_error);
 		}
 		sptr = sptr->_base;
 	}
-	r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+	r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 	return Variant();
 }
 
-void GDInstance::call_multilevel(const StringName& p_method,const Variant** p_args,int p_argcount) {
+void GDInstance::call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount) {
 
-	GDScript *sptr=script.ptr();
+	GDScript *sptr = script.ptr();
 	Variant::CallError ce;
 
-	while(sptr) {
-		Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(p_method);
+	while (sptr) {
+		Map<StringName, GDFunction *>::Element *E = sptr->member_functions.find(p_method);
 		if (E) {
-			E->get()->call(this,p_args,p_argcount,ce);
+			E->get()->call(this, p_args, p_argcount, ce);
 		}
 		sptr = sptr->_base;
 	}
-
 }
 
-
-void GDInstance::_ml_call_reversed(GDScript *sptr,const StringName& p_method,const Variant** p_args,int p_argcount) {
+void GDInstance::_ml_call_reversed(GDScript *sptr, const StringName &p_method, const Variant **p_args, int p_argcount) {
 
 	if (sptr->_base)
-		_ml_call_reversed(sptr->_base,p_method,p_args,p_argcount);
+		_ml_call_reversed(sptr->_base, p_method, p_args, p_argcount);
 
 	Variant::CallError ce;
 
-	Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(p_method);
+	Map<StringName, GDFunction *>::Element *E = sptr->member_functions.find(p_method);
 	if (E) {
-		E->get()->call(this,p_args,p_argcount,ce);
+		E->get()->call(this, p_args, p_argcount, ce);
 	}
-
 }
 
-void GDInstance::call_multilevel_reversed(const StringName& p_method,const Variant** p_args,int p_argcount) {
+void GDInstance::call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount) {
 
 	if (script.ptr()) {
-		_ml_call_reversed(script.ptr(),p_method,p_args,p_argcount);
+		_ml_call_reversed(script.ptr(), p_method, p_args, p_argcount);
 	}
 }
 
-
-
 void GDInstance::notification(int p_notification) {
 
 	//notification is not virutal, it gets called at ALL levels just like in C.
-	Variant value=p_notification;
-	const Variant *args[1]={&value };
+	Variant value = p_notification;
+	const Variant *args[1] = { &value };
 
-	GDScript *sptr=script.ptr();
-	while(sptr) {
-		Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._notification);
+	GDScript *sptr = script.ptr();
+	while (sptr) {
+		Map<StringName, GDFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._notification);
 		if (E) {
 			Variant::CallError err;
-			E->get()->call(this,args,1,err);
-			if (err.error!=Variant::CallError::CALL_OK) {
+			E->get()->call(this, args, 1, err);
+			if (err.error != Variant::CallError::CALL_OK) {
 				//print error about notification call
-
 			}
 		}
 		sptr = sptr->_base;
 	}
-
 }
 
 Ref<Script> GDInstance::get_script() const {
@@ -1380,46 +1299,42 @@ ScriptLanguage *GDInstance::get_language() {
 	return GDScriptLanguage::get_singleton();
 }
 
-GDInstance::RPCMode GDInstance::get_rpc_mode(const StringName& p_method) const {
+GDInstance::RPCMode GDInstance::get_rpc_mode(const StringName &p_method) const {
 
 	const GDScript *cscript = script.ptr();
 
-	while(cscript) {
-		const Map<StringName,GDFunction*>::Element *E=cscript->member_functions.find(p_method);
+	while (cscript) {
+		const Map<StringName, GDFunction *>::Element *E = cscript->member_functions.find(p_method);
 		if (E) {
 
-			if (E->get()->get_rpc_mode()!=RPC_MODE_DISABLED) {
+			if (E->get()->get_rpc_mode() != RPC_MODE_DISABLED) {
 				return E->get()->get_rpc_mode();
 			}
-
 		}
-		cscript=cscript->_base;
+		cscript = cscript->_base;
 	}
 
 	return RPC_MODE_DISABLED;
 }
 
-GDInstance::RPCMode GDInstance::get_rset_mode(const StringName& p_variable) const {
+GDInstance::RPCMode GDInstance::get_rset_mode(const StringName &p_variable) const {
 
 	const GDScript *cscript = script.ptr();
 
-	while(cscript) {
-		const Map<StringName,GDScript::MemberInfo>::Element *E=cscript->member_indices.find(p_variable);
+	while (cscript) {
+		const Map<StringName, GDScript::MemberInfo>::Element *E = cscript->member_indices.find(p_variable);
 		if (E) {
 
 			if (E->get().rpc_mode) {
 				return E->get().rpc_mode;
 			}
-
 		}
-		cscript=cscript->_base;
+		cscript = cscript->_base;
 	}
 
 	return RPC_MODE_DISABLED;
 }
 
-
-
 void GDInstance::reload_members() {
 
 #ifdef DEBUG_ENABLED
@@ -1430,44 +1345,42 @@ void GDInstance::reload_members() {
 	new_members.resize(script->member_indices.size());
 
 	//pass the values to the new indices
-	for(Map<StringName,GDScript::MemberInfo>::Element *E=script->member_indices.front();E;E=E->next()) {
+	for (Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
 
 		if (member_indices_cache.has(E->key())) {
 			Variant value = members[member_indices_cache[E->key()]];
-			new_members[E->get().index]=value;
+			new_members[E->get().index] = value;
 		}
-
 	}
 
 	//apply
-	members=new_members;
+	members = new_members;
 
 	//pass the values to the new indices
 	member_indices_cache.clear();
-	for(Map<StringName,GDScript::MemberInfo>::Element *E=script->member_indices.front();E;E=E->next()) {
+	for (Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
 
-		member_indices_cache[E->key()]=E->get().index;
+		member_indices_cache[E->key()] = E->get().index;
 	}
 
 #endif
 }
 
 GDInstance::GDInstance() {
-	owner=NULL;
-	base_ref=false;
+	owner = NULL;
+	base_ref = false;
 }
 
 GDInstance::~GDInstance() {
 	if (script.is_valid() && owner) {
 #ifndef NO_THREADS
-	GDScriptLanguage::singleton->lock->lock();
+		GDScriptLanguage::singleton->lock->lock();
 #endif
 
-	script->instances.erase(owner);
+		script->instances.erase(owner);
 #ifndef NO_THREADS
-	GDScriptLanguage::singleton->lock->unlock();
+		GDScriptLanguage::singleton->lock->unlock();
 #endif
-
 	}
 }
 
@@ -1477,8 +1390,7 @@ GDInstance::~GDInstance() {
 /************* SCRIPT LANGUAGE **************/
 /************* SCRIPT LANGUAGE **************/
 
-GDScriptLanguage *GDScriptLanguage::singleton=NULL;
-
+GDScriptLanguage *GDScriptLanguage::singleton = NULL;
 
 String GDScriptLanguage::get_name() const {
 
@@ -1487,63 +1399,60 @@ String GDScriptLanguage::get_name() const {
 
 /* LANGUAGE FUNCTIONS */
 
-void GDScriptLanguage::_add_global(const StringName& p_name,const Variant& p_value) {
-
+void GDScriptLanguage::_add_global(const StringName &p_name, const Variant &p_value) {
 
 	if (globals.has(p_name)) {
 		//overwrite existing
-		global_array[globals[p_name]]=p_value;
+		global_array[globals[p_name]] = p_value;
 		return;
 	}
-	globals[p_name]=global_array.size();
+	globals[p_name] = global_array.size();
 	global_array.push_back(p_value);
-	_global_array=global_array.ptr();
+	_global_array = global_array.ptr();
 }
 
-void GDScriptLanguage::add_global_constant(const StringName& p_variable,const Variant& p_value) {
+void GDScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {
 
-	_add_global(p_variable,p_value);
+	_add_global(p_variable, p_value);
 }
 
-
 void GDScriptLanguage::init() {
 
-
 	//populate global constants
-	int gcc=GlobalConstants::get_global_constant_count();
-	for(int i=0;i<gcc;i++) {
+	int gcc = GlobalConstants::get_global_constant_count();
+	for (int i = 0; i < gcc; i++) {
 
-		_add_global(StaticCString::create(GlobalConstants::get_global_constant_name(i)),GlobalConstants::get_global_constant_value(i));
+		_add_global(StaticCString::create(GlobalConstants::get_global_constant_name(i)), GlobalConstants::get_global_constant_value(i));
 	}
 
-	_add_global(StaticCString::create("PI"),Math_PI);
-	_add_global(StaticCString::create("INF"),Math_INF);
-	_add_global(StaticCString::create("NAN"),Math_NAN);
+	_add_global(StaticCString::create("PI"), Math_PI);
+	_add_global(StaticCString::create("INF"), Math_INF);
+	_add_global(StaticCString::create("NAN"), Math_NAN);
 
 	//populate native classes
 
 	List<StringName> class_list;
 	ClassDB::get_class_list(&class_list);
-	for(List<StringName>::Element *E=class_list.front();E;E=E->next()) {
+	for (List<StringName>::Element *E = class_list.front(); E; E = E->next()) {
 
 		StringName n = E->get();
 		String s = String(n);
 		if (s.begins_with("_"))
-			n=s.substr(1,s.length());
+			n = s.substr(1, s.length());
 
 		if (globals.has(n))
 			continue;
-		Ref<GDNativeClass> nc = memnew( GDNativeClass(E->get()) );
-		_add_global(n,nc);
+		Ref<GDNativeClass> nc = memnew(GDNativeClass(E->get()));
+		_add_global(n, nc);
 	}
 
 	//populate singletons
 
 	List<GlobalConfig::Singleton> singletons;
 	GlobalConfig::get_singleton()->get_singletons(&singletons);
-	for(List<GlobalConfig::Singleton>::Element *E=singletons.front();E;E=E->next()) {
+	for (List<GlobalConfig::Singleton>::Element *E = singletons.front(); E; E = E->next()) {
 
-		_add_global(E->get().name,E->get().ptr);
+		_add_global(E->get().name, E->get().ptr);
 	}
 }
 
@@ -1555,14 +1464,12 @@ String GDScriptLanguage::get_extension() const {
 
 	return "gd";
 }
-Error GDScriptLanguage::execute_file(const String& p_path)  {
+Error GDScriptLanguage::execute_file(const String &p_path) {
 
 	// ??
 	return OK;
 }
-void GDScriptLanguage::finish()  {
-
-
+void GDScriptLanguage::finish() {
 }
 
 void GDScriptLanguage::profiling_start() {
@@ -1572,27 +1479,26 @@ void GDScriptLanguage::profiling_start() {
 		lock->lock();
 	}
 
-	SelfList<GDFunction> *elem=function_list.first();
-	while(elem) {
-		elem->self()->profile.call_count=0;
-		elem->self()->profile.self_time=0;
-		elem->self()->profile.total_time=0;
-		elem->self()->profile.frame_call_count=0;
-		elem->self()->profile.frame_self_time=0;
-		elem->self()->profile.frame_total_time=0;
-		elem->self()->profile.last_frame_call_count=0;
-		elem->self()->profile.last_frame_self_time=0;
-		elem->self()->profile.last_frame_total_time=0;
-		elem=elem->next();
+	SelfList<GDFunction> *elem = function_list.first();
+	while (elem) {
+		elem->self()->profile.call_count = 0;
+		elem->self()->profile.self_time = 0;
+		elem->self()->profile.total_time = 0;
+		elem->self()->profile.frame_call_count = 0;
+		elem->self()->profile.frame_self_time = 0;
+		elem->self()->profile.frame_total_time = 0;
+		elem->self()->profile.last_frame_call_count = 0;
+		elem->self()->profile.last_frame_self_time = 0;
+		elem->self()->profile.last_frame_total_time = 0;
+		elem = elem->next();
 	}
 
-	profiling=true;
+	profiling = true;
 	if (lock) {
 		lock->unlock();
 	}
 
 #endif
-
 }
 
 void GDScriptLanguage::profiling_stop() {
@@ -1602,7 +1508,7 @@ void GDScriptLanguage::profiling_stop() {
 		lock->lock();
 	}
 
-	profiling=false;
+	profiling = false;
 	if (lock) {
 		lock->unlock();
 	}
@@ -1610,95 +1516,83 @@ void GDScriptLanguage::profiling_stop() {
 #endif
 }
 
-int GDScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr,int p_info_max) {
+int GDScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) {
 
-	int current=0;
+	int current = 0;
 #ifdef DEBUG_ENABLED
 	if (lock) {
 		lock->lock();
 	}
 
-
-	SelfList<GDFunction> *elem=function_list.first();
-	while(elem) {
-		if (current>=p_info_max)
+	SelfList<GDFunction> *elem = function_list.first();
+	while (elem) {
+		if (current >= p_info_max)
 			break;
-		p_info_arr[current].call_count=elem->self()->profile.call_count;
-		p_info_arr[current].self_time=elem->self()->profile.self_time;
-		p_info_arr[current].total_time=elem->self()->profile.total_time;
-		p_info_arr[current].signature=elem->self()->profile.signature;
-		elem=elem->next();
+		p_info_arr[current].call_count = elem->self()->profile.call_count;
+		p_info_arr[current].self_time = elem->self()->profile.self_time;
+		p_info_arr[current].total_time = elem->self()->profile.total_time;
+		p_info_arr[current].signature = elem->self()->profile.signature;
+		elem = elem->next();
 		current++;
 	}
 
-
-
 	if (lock) {
 		lock->unlock();
 	}
 
-
 #endif
 
 	return current;
-
-
 }
 
-int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr,int p_info_max) {
+int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) {
 
-	int current=0;
+	int current = 0;
 
 #ifdef DEBUG_ENABLED
 	if (lock) {
 		lock->lock();
 	}
 
-
-	SelfList<GDFunction> *elem=function_list.first();
-	while(elem) {
-		if (current>=p_info_max)
+	SelfList<GDFunction> *elem = function_list.first();
+	while (elem) {
+		if (current >= p_info_max)
 			break;
-		if (elem->self()->profile.last_frame_call_count>0) {
-			p_info_arr[current].call_count=elem->self()->profile.last_frame_call_count;
-			p_info_arr[current].self_time=elem->self()->profile.last_frame_self_time;
-			p_info_arr[current].total_time=elem->self()->profile.last_frame_total_time;
-			p_info_arr[current].signature=elem->self()->profile.signature;
+		if (elem->self()->profile.last_frame_call_count > 0) {
+			p_info_arr[current].call_count = elem->self()->profile.last_frame_call_count;
+			p_info_arr[current].self_time = elem->self()->profile.last_frame_self_time;
+			p_info_arr[current].total_time = elem->self()->profile.last_frame_total_time;
+			p_info_arr[current].signature = elem->self()->profile.signature;
 			//print_line(String(elem->self()->profile.signature)+": "+itos(elem->self()->profile.last_frame_call_count));
 			current++;
 		}
-		elem=elem->next();
-
+		elem = elem->next();
 	}
 
-
 	if (lock) {
 		lock->unlock();
 	}
 
-
 #endif
 
 	return current;
-
 }
 
-
 struct GDScriptDepSort {
 
 	//must support sorting so inheritance works properly (parent must be reloaded first)
-	bool operator()(const Ref<GDScript> &A, const Ref<GDScript>& B) const {
+	bool operator()(const Ref<GDScript> &A, const Ref<GDScript> &B) const {
 
-		if (A==B)
+		if (A == B)
 			return false; //shouldn't happen but..
-		const GDScript *I=B->get_base().ptr();
-		while(I) {
-			if (I==A.ptr()) {
+		const GDScript *I = B->get_base().ptr();
+		while (I) {
+			if (I == A.ptr()) {
 				// A is a base of B
 				return true;
 			}
 
-			I=I->get_base().ptr();
+			I = I->get_base().ptr();
 		}
 
 		return false; //not a base
@@ -1707,8 +1601,6 @@ struct GDScriptDepSort {
 
 void GDScriptLanguage::reload_all_scripts() {
 
-
-
 #ifdef DEBUG_ENABLED
 	print_line("RELOAD ALL SCRIPTS");
 	if (lock) {
@@ -1717,13 +1609,13 @@ void GDScriptLanguage::reload_all_scripts() {
 
 	List<Ref<GDScript> > scripts;
 
-	SelfList<GDScript> *elem=script_list.first();
-	while(elem) {
+	SelfList<GDScript> *elem = script_list.first();
+	while (elem) {
 		if (elem->self()->get_path().is_resource_file()) {
-			print_line("FOUND: "+elem->self()->get_path());
+			print_line("FOUND: " + elem->self()->get_path());
 			scripts.push_back(Ref<GDScript>(elem->self())); //cast to gdscript to avoid being erased by accident
 		}
-		elem=elem->next();
+		elem = elem->next();
 	}
 
 	if (lock) {
@@ -1734,18 +1626,16 @@ void GDScriptLanguage::reload_all_scripts() {
 
 	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
 
-	for(List<Ref<GDScript> >::Element *E=scripts.front();E;E=E->next()) {
+	for (List<Ref<GDScript> >::Element *E = scripts.front(); E; E = E->next()) {
 
-		print_line("RELOADING: "+E->get()->get_path());
+		print_line("RELOADING: " + E->get()->get_path());
 		E->get()->load_source_code(E->get()->get_path());
 		E->get()->reload(true);
 	}
 #endif
 }
 
-
-void GDScriptLanguage::reload_tool_script(const Ref<Script>& p_script,bool p_soft_reload) {
-
+void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {
 
 #ifdef DEBUG_ENABLED
 
@@ -1755,13 +1645,13 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script>& p_script,bool p_sof
 
 	List<Ref<GDScript> > scripts;
 
-	SelfList<GDScript> *elem=script_list.first();
-	while(elem) {
+	SelfList<GDScript> *elem = script_list.first();
+	while (elem) {
 		if (elem->self()->get_path().is_resource_file()) {
 
 			scripts.push_back(Ref<GDScript>(elem->self())); //cast to gdscript to avoid being erased by accident
 		}
-		elem=elem->next();
+		elem = elem->next();
 	}
 
 	if (lock) {
@@ -1770,68 +1660,68 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script>& p_script,bool p_sof
 
 	//when someone asks you why dynamically typed languages are easier to write....
 
-	Map< Ref<GDScript>, Map<ObjectID,List<Pair<StringName,Variant> > > > to_reload;
+	Map<Ref<GDScript>, Map<ObjectID, List<Pair<StringName, Variant> > > > to_reload;
 
 	//as scripts are going to be reloaded, must proceed without locking here
 
 	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
 
-	for(List<Ref<GDScript> >::Element *E=scripts.front();E;E=E->next()) {
+	for (List<Ref<GDScript> >::Element *E = scripts.front(); E; E = E->next()) {
 
-		bool reload = E->get()==p_script || to_reload.has(E->get()->get_base());
+		bool reload = E->get() == p_script || to_reload.has(E->get()->get_base());
 
 		if (!reload)
 			continue;
 
-		to_reload.insert(E->get(),Map<ObjectID,List<Pair<StringName,Variant> > >());
+		to_reload.insert(E->get(), Map<ObjectID, List<Pair<StringName, Variant> > >());
 
 		if (!p_soft_reload) {
 
 			//save state and remove script from instances
-			Map<ObjectID,List<Pair<StringName,Variant> > >& map = to_reload[E->get()];
+			Map<ObjectID, List<Pair<StringName, Variant> > > &map = to_reload[E->get()];
 
-			while(E->get()->instances.front()) {
+			while (E->get()->instances.front()) {
 				Object *obj = E->get()->instances.front()->get();
 				//save instance info
-				List<Pair<StringName,Variant> > state;
+				List<Pair<StringName, Variant> > state;
 				if (obj->get_script_instance()) {
 
 					obj->get_script_instance()->get_property_state(state);
-					map[obj->get_instance_ID()]=state;
+					map[obj->get_instance_ID()] = state;
 					obj->set_script(RefPtr());
 				}
 			}
 
-			//same thing for placeholders
+//same thing for placeholders
 #ifdef TOOLS_ENABLED
 
-			while(E->get()->placeholders.size()) {
+			while (E->get()->placeholders.size()) {
 
 				Object *obj = E->get()->placeholders.front()->get()->get_owner();
 				//save instance info
-				List<Pair<StringName,Variant> > state;
+				List<Pair<StringName, Variant> > state;
 				if (obj->get_script_instance()) {
 
 					obj->get_script_instance()->get_property_state(state);
-					map[obj->get_instance_ID()]=state;
+					map[obj->get_instance_ID()] = state;
 					obj->set_script(RefPtr());
 				}
 			}
 #endif
 
-			for(Map<ObjectID,List<Pair<StringName,Variant> > >::Element *F=E->get()->pending_reload_state.front();F;F=F->next()) {
-				map[F->key()]=F->get(); //pending to reload, use this one instead
+			for (Map<ObjectID, List<Pair<StringName, Variant> > >::Element *F = E->get()->pending_reload_state.front(); F; F = F->next()) {
+				map[F->key()] = F->get(); //pending to reload, use this one instead
 			}
 		}
 	}
 
-	for(Map< Ref<GDScript>, Map<ObjectID,List<Pair<StringName,Variant> > > >::Element *E=to_reload.front();E;E=E->next()) {
+	for (Map<Ref<GDScript>, Map<ObjectID, List<Pair<StringName, Variant> > > >::Element *E = to_reload.front(); E; E = E->next()) {
 
 		Ref<GDScript> scr = E->key();
 		scr->reload(p_soft_reload);
 
 		//restore state if saved
-		for (Map<ObjectID,List<Pair<StringName,Variant> > >::Element *F=E->get().front();F;F=F->next()) {
+		for (Map<ObjectID, List<Pair<StringName, Variant> > >::Element *F = E->get().front(); F; F = F->next()) {
 
 			Object *obj = ObjectDB::get_instance(F->key());
 			if (!obj)
@@ -1845,13 +1735,13 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script>& p_script,bool p_sof
 			if (!obj->get_script_instance()) {
 				//failed, save reload state for next time if not saved
 				if (!scr->pending_reload_state.has(obj->get_instance_ID())) {
-					scr->pending_reload_state[obj->get_instance_ID()]=F->get();
+					scr->pending_reload_state[obj->get_instance_ID()] = F->get();
 				}
 				continue;
 			}
 
-			for (List<Pair<StringName,Variant> >::Element *G=F->get().front();G;G=G->next()) {
-				obj->get_script_instance()->set(G->get().first,G->get().second);
+			for (List<Pair<StringName, Variant> >::Element *G = F->get().front(); G; G = G->next()) {
+				obj->get_script_instance()->set(G->get().first, G->get().second);
 			}
 
 			scr->pending_reload_state.erase(obj->get_instance_ID()); //as it reloaded, remove pending state
@@ -1860,14 +1750,13 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script>& p_script,bool p_sof
 		//if instance states were saved, set them!
 	}
 
-
 #endif
 }
 
 void GDScriptLanguage::frame() {
 
 	//print_line("calls: "+itos(calls));
-	calls=0;
+	calls = 0;
 
 #ifdef DEBUG_ENABLED
 	if (profiling) {
@@ -1875,18 +1764,17 @@ void GDScriptLanguage::frame() {
 			lock->lock();
 		}
 
-		SelfList<GDFunction> *elem=function_list.first();
-		while(elem) {
-			elem->self()->profile.last_frame_call_count=elem->self()->profile.frame_call_count;
-			elem->self()->profile.last_frame_self_time=elem->self()->profile.frame_self_time;
-			elem->self()->profile.last_frame_total_time=elem->self()->profile.frame_total_time;
-			elem->self()->profile.frame_call_count=0;
-			elem->self()->profile.frame_self_time=0;
-			elem->self()->profile.frame_total_time=0;
-			elem=elem->next();
+		SelfList<GDFunction> *elem = function_list.first();
+		while (elem) {
+			elem->self()->profile.last_frame_call_count = elem->self()->profile.frame_call_count;
+			elem->self()->profile.last_frame_self_time = elem->self()->profile.frame_self_time;
+			elem->self()->profile.last_frame_total_time = elem->self()->profile.frame_total_time;
+			elem->self()->profile.frame_call_count = 0;
+			elem->self()->profile.frame_self_time = 0;
+			elem->self()->profile.frame_total_time = 0;
+			elem = elem->next();
 		}
 
-
 		if (lock) {
 			lock->unlock();
 		}
@@ -1896,9 +1784,9 @@ void GDScriptLanguage::frame() {
 }
 
 /* EDITOR FUNCTIONS */
-void GDScriptLanguage::get_reserved_words(List<String> *p_words) const  {
+void GDScriptLanguage::get_reserved_words(List<String> *p_words) const {
 
-	static const char *_reserved_words[]={
+	static const char *_reserved_words[] = {
 		// operators
 		"and",
 		"in",
@@ -1948,11 +1836,10 @@ void GDScriptLanguage::get_reserved_words(List<String> *p_words) const  {
 		"sync",
 		"master",
 		"slave",
-		0};
-
-
-	const char **w=_reserved_words;
+		0
+	};
 
+	const char **w = _reserved_words;
 
 	while (*w) {
 
@@ -1960,73 +1847,69 @@ void GDScriptLanguage::get_reserved_words(List<String> *p_words) const  {
 		w++;
 	}
 
-	for(int i=0;i<GDFunctions::FUNC_MAX;i++) {
+	for (int i = 0; i < GDFunctions::FUNC_MAX; i++) {
 		p_words->push_back(GDFunctions::get_func_name(GDFunctions::Function(i)));
 	}
-
 }
 
 GDScriptLanguage::GDScriptLanguage() {
 
-	calls=0;
+	calls = 0;
 	ERR_FAIL_COND(singleton);
-	singleton=this;
+	singleton = this;
 	strings._init = StaticCString::create("_init");
 	strings._notification = StaticCString::create("_notification");
-	strings._set= StaticCString::create("_set");
-	strings._get= StaticCString::create("_get");
-	strings._get_property_list= StaticCString::create("_get_property_list");
-	strings._script_source=StaticCString::create("script/source");
-	_debug_parse_err_line=-1;
-	_debug_parse_err_file="";
+	strings._set = StaticCString::create("_set");
+	strings._get = StaticCString::create("_get");
+	strings._get_property_list = StaticCString::create("_get_property_list");
+	strings._script_source = StaticCString::create("script/source");
+	_debug_parse_err_line = -1;
+	_debug_parse_err_file = "";
 
 #ifdef NO_THREADS
-	lock=NULL;
+	lock = NULL;
 #else
 	lock = Mutex::create();
 #endif
-	profiling=false;
-	script_frame_time=0;
+	profiling = false;
+	script_frame_time = 0;
 
-	_debug_call_stack_pos=0;
-	int dmcs=GLOBAL_DEF("debug/script/max_call_stack",1024);
+	_debug_call_stack_pos = 0;
+	int dmcs = GLOBAL_DEF("debug/script/max_call_stack", 1024);
 	if (ScriptDebugger::get_singleton()) {
 		//debugging enabled!
 
 		_debug_max_call_stack = dmcs;
-		if (_debug_max_call_stack<1024)
-			_debug_max_call_stack=1024;
-		_call_stack = memnew_arr( CallLevel, _debug_max_call_stack+1 );
+		if (_debug_max_call_stack < 1024)
+			_debug_max_call_stack = 1024;
+		_call_stack = memnew_arr(CallLevel, _debug_max_call_stack + 1);
 
 	} else {
-		_debug_max_call_stack=0;
-		_call_stack=NULL;
+		_debug_max_call_stack = 0;
+		_call_stack = NULL;
 	}
-
 }
 
-
 GDScriptLanguage::~GDScriptLanguage() {
 
-
 	if (lock) {
 		memdelete(lock);
-		lock=NULL;
+		lock = NULL;
 	}
-	if (_call_stack)  {
+	if (_call_stack) {
 		memdelete_arr(_call_stack);
 	}
-	singleton=NULL;
+	singleton = NULL;
 }
 
 /*************** RESOURCE ***************/
 
-RES ResourceFormatLoaderGDScript::load(const String &p_path, const String& p_original_path, Error *r_error) {
+RES ResourceFormatLoaderGDScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
 
 	if (r_error)
-		*r_error=ERR_FILE_CANT_OPEN;
+		*r_error = ERR_FILE_CANT_OPEN;
 
-	GDScript *script = memnew( GDScript );
+	GDScript *script = memnew(GDScript);
 
 	Ref<GDScript> scriptres(script);
 
@@ -2036,18 +1919,17 @@ RES ResourceFormatLoaderGDScript::load(const String &p_path, const String& p_ori
 		script->set_path(p_original_path);
 		Error err = script->load_byte_code(p_path);
 
+		if (err != OK) {
 
-		if (err!=OK) {
-
-			ERR_FAIL_COND_V(err!=OK, RES());
+			ERR_FAIL_COND_V(err != OK, RES());
 		}
 
 	} else {
 		Error err = script->load_source_code(p_path);
 
-		if (err!=OK) {
+		if (err != OK) {
 
-			ERR_FAIL_COND_V(err!=OK, RES());
+			ERR_FAIL_COND_V(err != OK, RES());
 		}
 
 		script->set_script_path(p_original_path); // script needs this.
@@ -2057,7 +1939,7 @@ RES ResourceFormatLoaderGDScript::load(const String &p_path, const String& p_ori
 		script->reload();
 	}
 	if (r_error)
-		*r_error=OK;
+		*r_error = OK;
 
 	return scriptres;
 }
@@ -2068,38 +1950,36 @@ void ResourceFormatLoaderGDScript::get_recognized_extensions(List<String> *p_ext
 	p_extensions->push_back("gde");
 }
 
-bool ResourceFormatLoaderGDScript::handles_type(const String& p_type) const {
+bool ResourceFormatLoaderGDScript::handles_type(const String &p_type) const {
 
-	return (p_type=="Script" || p_type=="GDScript");
+	return (p_type == "Script" || p_type == "GDScript");
 }
 
 String ResourceFormatLoaderGDScript::get_resource_type(const String &p_path) const {
 
 	String el = p_path.get_extension().to_lower();
-	if (el=="gd" || el=="gdc" || el=="gde")
+	if (el == "gd" || el == "gdc" || el == "gde")
 		return "GDScript";
 	return "";
 }
 
-
-Error ResourceFormatSaverGDScript::save(const String &p_path,const RES& p_resource,uint32_t p_flags) {
+Error ResourceFormatSaverGDScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
 
 	Ref<GDScript> sqscr = p_resource;
-	ERR_FAIL_COND_V(sqscr.is_null(),ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(sqscr.is_null(), ERR_INVALID_PARAMETER);
 
 	String source = sqscr->get_source_code();
 
 	Error err;
-	FileAccess *file = FileAccess::open(p_path,FileAccess::WRITE,&err);
-
+	FileAccess *file = FileAccess::open(p_path, FileAccess::WRITE, &err);
 
 	if (err) {
 
-		ERR_FAIL_COND_V(err,err);
+		ERR_FAIL_COND_V(err, err);
 	}
 
 	file->store_string(source);
-	if (file->get_error()!=OK && file->get_error()!=ERR_FILE_EOF) {
+	if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) {
 		memdelete(file);
 		return ERR_CANT_CREATE;
 	}
@@ -2107,20 +1987,19 @@ Error ResourceFormatSaverGDScript::save(const String &p_path,const RES& p_resour
 	memdelete(file);
 
 	if (ScriptServer::is_reload_scripts_on_save_enabled()) {
-		GDScriptLanguage::get_singleton()->reload_tool_script(p_resource,false);
+		GDScriptLanguage::get_singleton()->reload_tool_script(p_resource, false);
 	}
 
 	return OK;
 }
 
-void ResourceFormatSaverGDScript::get_recognized_extensions(const RES& p_resource,List<String> *p_extensions) const {
+void ResourceFormatSaverGDScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
 
 	if (p_resource->cast_to<GDScript>()) {
 		p_extensions->push_back("gd");
 	}
-
 }
-bool ResourceFormatSaverGDScript::recognize(const RES& p_resource) const {
+bool ResourceFormatSaverGDScript::recognize(const RES &p_resource) const {
 
-	return p_resource->cast_to<GDScript>()!=NULL;
+	return p_resource->cast_to<GDScript>() != NULL;
 }
-- 
cgit v1.2.3-70-g09d2