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
author: Rémi Verschelde <rverschelde@gmail.com> 2017-03-05 16:44:50 +0100
committer: Rémi Verschelde <rverschelde@gmail.com> 2017-03-05 16:44:50 +0100
commit: 5dbf1809c6e3e905b94b8764e99491e608122261 (patch)
tree: 5e5a5360db15d86d59ec8c6e4f7eb511388c5a9a /modules
parent: 45438e9918d421b244bfd7776a30e67dc7f2d3e3 (diff)
84 files changed, 13900 insertions, 16580 deletions
diff --git a/modules/cscript/godot_c.cpp b/modules/cscript/godot_c.cpp
index 85ee28d6d2..f754f2bb21 100644
--- a/modules/cscript/godot_c.cpp
+++ b/modules/cscript/godot_c.cpp
@@ -27,4 +27,3 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "godot_c.h"
-
diff --git a/modules/cscript/godot_c.h b/modules/cscript/godot_c.h
index 97a63a439f..e38de1e489 100644
--- a/modules/cscript/godot_c.h
+++ b/modules/cscript/godot_c.h
@@ -33,7 +33,6 @@
 extern "C" {
 #endif
 
-
 #if defined(GDAPI_BUILT_IN) || !defined(WINDOWS_ENABLED)
 #define GDAPI
 #elif defined(GDAPI_EXPORTS)
@@ -42,10 +41,8 @@ extern "C" {
 #define GDAPI __declspec(dllimport)
 #endif
 
-
 #define GODOT_API_VERSION 1
 
-
 typedef int godot_bool;
 
 #define GODOT_FALSE 0
@@ -53,7 +50,6 @@ typedef int godot_bool;
 
 ////// Image
 
-
 #define GODOT_IMAGE_FORMAT_GRAYSCALE 0
 #define GODOT_IMAGE_FORMAT_INTENSITY 1
 #define GODOT_IMAGE_FORMAT_GRAYSCALE_ALPHA 2
@@ -77,11 +73,11 @@ typedef int godot_bool;
 #define GODOT_IMAGE_FORMAT_ATC_ALPHA_EXPLICIT 20
 #define GODOT_IMAGE_FORMAT_ATC_ALPHA_INTERPOLATED 21
 
-typedef void* godot_image;
+typedef void *godot_image;
 
 godot_image GDAPI godot_image_create_empty();
-godot_image GDAPI godot_image_create(int p_width,int p_height,int p_format,int p_use_mipmaps);
-godot_image GDAPI godot_image_create_with_data(int p_width,int p_height,int p_format,int p_use_mipmaps,unsigned char* p_buffer);
+godot_image GDAPI godot_image_create(int p_width, int p_height, int p_format, int p_use_mipmaps);
+godot_image GDAPI godot_image_create_with_data(int p_width, int p_height, int p_format, int p_use_mipmaps, unsigned char *p_buffer);
 int GDAPI godot_image_get_width(godot_image p_image);
 int GDAPI godot_image_get_height(godot_image p_image);
 int GDAPI godot_image_get_format(godot_image p_image);
@@ -89,10 +85,9 @@ int GDAPI godot_image_get_mipmap_count(godot_image p_image);
 godot_image GDAPI godot_image_copy(godot_image p_image);
 void GDAPI godot_image_free(godot_image p_image);
 
-
 ////// RID
 
-typedef void* godot_rid;
+typedef void *godot_rid;
 
 godot_rid GDAPI godot_rid_create();
 godot_rid GDAPI godot_rid_copy(godot_rid p_rid);
@@ -100,37 +95,36 @@ void GDAPI godot_rid_free(godot_rid p_rid);
 
 ////// Variant (forward declared)
 
-typedef void* godot_variant;
-
+typedef void *godot_variant;
 
 ////// Dictionary
 
-typedef void* godot_dictionary;
+typedef void *godot_dictionary;
 
 godot_dictionary GDAPI godot_dictionary_create();
-void GDAPI godot_dictionary_has(godot_dictionary p_dictionary,godot_variant p_key);
-godot_variant GDAPI godot_dictionary_get(godot_dictionary p_dictionary,godot_variant p_key);
-void GDAPI godot_dictionary_insert(godot_dictionary p_dictionary,godot_variant p_key,godot_variant p_value);
-void GDAPI godot_dictionary_remove(godot_dictionary p_dictionary,godot_variant p_key);
+void GDAPI godot_dictionary_has(godot_dictionary p_dictionary, godot_variant p_key);
+godot_variant GDAPI godot_dictionary_get(godot_dictionary p_dictionary, godot_variant p_key);
+void GDAPI godot_dictionary_insert(godot_dictionary p_dictionary, godot_variant p_key, godot_variant p_value);
+void GDAPI godot_dictionary_remove(godot_dictionary p_dictionary, godot_variant p_key);
 void GDAPI godot_dictionary_clear(godot_dictionary p_dictionary);
 int GDAPI godot_dictionary_get_size(godot_dictionary p_dictionary);
-void GDAPI godot_dictionary_get_keys(godot_dictionary p_dictionary,godot_variant* p_keys);
+void GDAPI godot_dictionary_get_keys(godot_dictionary p_dictionary, godot_variant *p_keys);
 godot_dictionary GDAPI godot_dictionary_copy(godot_dictionary p_dictionary);
 void GDAPI godot_dictionary_free(godot_dictionary p_dictionary);
 
 ////// Array
 
-typedef void* godot_array;
+typedef void *godot_array;
 
 godot_array GDAPI godot_array_create();
-godot_variant GDAPI godot_array_get(godot_array p_array,int p_index);
-void GDAPI godot_array_set(godot_array p_array,int p_index,godot_variant p_value);
-void GDAPI godot_array_resize(godot_array p_array,int p_size);
-void GDAPI godot_array_insert(godot_array p_array,int p_position,godot_variant p_value);
-void GDAPI godot_array_remove(godot_array p_array,int p_position);
+godot_variant GDAPI godot_array_get(godot_array p_array, int p_index);
+void GDAPI godot_array_set(godot_array p_array, int p_index, godot_variant p_value);
+void GDAPI godot_array_resize(godot_array p_array, int p_size);
+void GDAPI godot_array_insert(godot_array p_array, int p_position, godot_variant p_value);
+void GDAPI godot_array_remove(godot_array p_array, int p_position);
 void GDAPI godot_array_clear(godot_array p_array);
 int GDAPI godot_array_get_size(godot_array p_array);
-int GDAPI godot_array_find(godot_array p_array,godot_variant p_value,int p_from_pos=-1);
+int GDAPI godot_array_find(godot_array p_array, godot_variant p_value, int p_from_pos = -1);
 godot_array GDAPI godot_array_copy(godot_array p_array);
 void GDAPI godot_array_free(godot_array p_array);
 
@@ -143,9 +137,9 @@ void GDAPI godot_array_free(godot_array p_array);
 #define INPUT_EVENT_BUTTON_WHEEL_DOWN 5
 #define INPUT_EVENT_BUTTON_WHEEL_LEFT 6
 #define INPUT_EVENT_BUTTON_WHEEL_RIGHT 7
-#define INPUT_EVENT_BUTTON_MASK_LEFT (1<<(INPUT_EVENT_BUTTON_LEFT-1))
-#define INPUT_EVENT_BUTTON_MASK_RIGHT (1<<(INPUT_EVENT_BUTTON_RIGHT-1))
-#define INPUT_EVENT_BUTTON_MASK_MIDDLE (1<<(INPUT_EVENT_BUTTON_MIDDLE-1))
+#define INPUT_EVENT_BUTTON_MASK_LEFT (1 << (INPUT_EVENT_BUTTON_LEFT - 1))
+#define INPUT_EVENT_BUTTON_MASK_RIGHT (1 << (INPUT_EVENT_BUTTON_RIGHT - 1))
+#define INPUT_EVENT_BUTTON_MASK_MIDDLE (1 << (INPUT_EVENT_BUTTON_MIDDLE - 1))
 
 #define INPUT_EVENT_TYPE_NONE 0
 #define INPUT_EVENT_TYPE_KEY 1
@@ -157,8 +151,7 @@ void GDAPI godot_array_free(godot_array p_array);
 #define INPUT_EVENT_TYPE_SCREEN_DRAG 7
 #define INPUT_EVENT_TYPE_ACTION 8
 
-typedef void* godot_input_event;
-
+typedef void *godot_input_event;
 
 godot_input_event GDAPI godot_input_event_create();
 godot_input_event GDAPI godot_input_event_copy(godot_input_event p_input_event);
@@ -201,7 +194,6 @@ int GDAPI godot_input_event_joypad_button_get_button_index(godot_input_event p_e
 godot_bool GDAPI godot_input_event_joypad_button_is_pressed(godot_input_event p_event);
 float GDAPI godot_input_event_joypad_button_get_pressure(godot_input_event p_event);
 
-
 int GDAPI godot_input_event_screen_touch_get_index(godot_input_event p_event);
 int GDAPI godot_input_event_screen_touch_get_x(godot_input_event p_event);
 int GDAPI godot_input_event_screen_touch_get_y(godot_input_event p_event);
@@ -215,49 +207,47 @@ int GDAPI godot_input_event_screen_drag_get_relative_y(godot_input_event p_event
 int GDAPI godot_input_event_screen_drag_get_speed_x(godot_input_event p_event);
 int GDAPI godot_input_event_screen_drag_get_speed_y(godot_input_event p_event);
 
-int GDAPI godot_input_event_is_action(godot_input_event p_event,char *p_action);
-int GDAPI godot_input_event_is_action_pressed(godot_input_event p_event,char *p_action);
+int GDAPI godot_input_event_is_action(godot_input_event p_event, char *p_action);
+int GDAPI godot_input_event_is_action_pressed(godot_input_event p_event, char *p_action);
 
 ////// ByteArray
 
-typedef void* godot_byte_array;
+typedef void *godot_byte_array;
 
 godot_byte_array GDAPI godot_byte_array_create();
 godot_byte_array GDAPI godot_byte_array_copy(godot_byte_array p_byte_array);
 void GDAPI godot_byte_array_free(godot_byte_array p_byte_array);
 
 int GDAPI godot_byte_array_get_size(godot_byte_array p_byte_array);
-unsigned char GDAPI godot_byte_array_get(godot_byte_array p_byte_array,int p_index);
-void GDAPI godot_byte_array_set(godot_byte_array p_byte_array,int p_index,unsigned char p_value);
-void GDAPI godot_byte_array_remove(godot_byte_array p_byte_array,int p_index);
+unsigned char GDAPI godot_byte_array_get(godot_byte_array p_byte_array, int p_index);
+void GDAPI godot_byte_array_set(godot_byte_array p_byte_array, int p_index, unsigned char p_value);
+void GDAPI godot_byte_array_remove(godot_byte_array p_byte_array, int p_index);
 void GDAPI godot_byte_array_clear(godot_byte_array p_byte_array);
 
-typedef void* godot_byte_array_lock;
+typedef void *godot_byte_array_lock;
 
 godot_byte_array_lock GDAPI godot_byte_array_get_lock(godot_byte_array p_byte_array);
 unsigned char GDAPI *godot_byte_array_lock_get_pointer(godot_byte_array_lock p_byte_array_lock);
 void GDAPI godot_byte_array_lock_free(godot_byte_array_lock p_byte_array_lock);
 
-
-godot_image GDAPI godot_image_create_with_array(int p_width,int p_height,int p_format,int p_use_mipmaps,godot_array p_array);
+godot_image GDAPI godot_image_create_with_array(int p_width, int p_height, int p_format, int p_use_mipmaps, godot_array p_array);
 godot_byte_array GDAPI godot_image_get_data(godot_image p_image);
 
-
 ////// IntArray
 
-typedef void* godot_int_array;
+typedef void *godot_int_array;
 
 godot_int_array GDAPI godot_int_array_create();
 godot_int_array GDAPI godot_int_array_copy(godot_int_array p_int_array);
 void GDAPI godot_int_array_free(godot_int_array p_int_array);
 
 int GDAPI godot_int_array_get_size(godot_int_array p_int_array);
-int GDAPI godot_int_array_get(godot_int_array p_int_array,int p_index);
-void GDAPI godot_int_array_set(godot_int_array p_int_array,int p_index,int p_value);
-void GDAPI godot_int_array_remove(godot_int_array p_int_array,int p_index);
+int GDAPI godot_int_array_get(godot_int_array p_int_array, int p_index);
+void GDAPI godot_int_array_set(godot_int_array p_int_array, int p_index, int p_value);
+void GDAPI godot_int_array_remove(godot_int_array p_int_array, int p_index);
 void GDAPI godot_int_array_clear(godot_int_array p_int_array);
 
-typedef void* godot_int_array_lock;
+typedef void *godot_int_array_lock;
 
 godot_int_array_lock GDAPI godot_int_array_get_lock(godot_int_array p_int_array);
 int GDAPI *godot_int_array_lock_get_pointer(godot_int_array_lock p_int_array_lock);
@@ -265,44 +255,41 @@ void GDAPI godot_int_array_lock_free(godot_int_array_lock p_int_array_lock);
 
 ////// RealArray
 
-typedef void* godot_real_array;
-
+typedef void *godot_real_array;
 
 godot_real_array GDAPI godot_real_array_create();
 godot_real_array GDAPI godot_real_array_copy(godot_real_array p_real_array);
 void GDAPI godot_real_array_free(godot_real_array p_real_array);
 
 int GDAPI godot_real_array_get_size(godot_real_array p_real_array);
-float GDAPI godot_real_array_get(godot_real_array p_real_array,int p_index);
-void GDAPI godot_real_array_set(godot_real_array p_real_array,int p_index,float p_value);
-void GDAPI godot_real_array_remove(godot_real_array p_real_array,int p_index);
+float GDAPI godot_real_array_get(godot_real_array p_real_array, int p_index);
+void GDAPI godot_real_array_set(godot_real_array p_real_array, int p_index, float p_value);
+void GDAPI godot_real_array_remove(godot_real_array p_real_array, int p_index);
 void GDAPI godot_real_array_clear(godot_real_array p_real_array);
 
-typedef void* godot_real_array_lock;
+typedef void *godot_real_array_lock;
 
 godot_real_array_lock GDAPI godot_real_array_get_lock(godot_real_array p_real_array);
 float GDAPI *godot_real_array_lock_get_pointer(godot_real_array_lock p_real_array_lock);
 void GDAPI godot_real_array_lock_free(godot_real_array_lock p_real_array_lock);
 
-
 ////// StringArray
 
-typedef void* godot_string_array;
-
+typedef void *godot_string_array;
 
 godot_string_array GDAPI godot_string_array_create();
 godot_string_array GDAPI godot_string_array_copy(godot_string_array p_string_array);
 void GDAPI godot_string_array_free(godot_string_array p_string_array);
 
 int GDAPI godot_string_array_get_size(godot_string_array p_string_array);
-int GDAPI godot_string_array_get(godot_string_array p_string_array,int p_index,unsigned char* p_string,int p_max_len);
-void GDAPI godot_string_array_set(godot_string_array p_string_array,int p_index,unsigned char *p_string);
-void GDAPI godot_string_array_remove(godot_string_array p_string_array,int p_index);
+int GDAPI godot_string_array_get(godot_string_array p_string_array, int p_index, unsigned char *p_string, int p_max_len);
+void GDAPI godot_string_array_set(godot_string_array p_string_array, int p_index, unsigned char *p_string);
+void GDAPI godot_string_array_remove(godot_string_array p_string_array, int p_index);
 void GDAPI godot_string_array_clear(godot_string_array p_string_array);
 
 ////// Vector2Array
 
-typedef void* godot_vector2_array;
+typedef void *godot_vector2_array;
 
 godot_vector2_array GDAPI godot_vector2_array_create();
 godot_vector2_array GDAPI godot_vector2_array_copy(godot_vector2_array p_vector2_array);
@@ -310,13 +297,12 @@ void GDAPI godot_vector2_array_free(godot_vector2_array p_vector2_array);
 
 int GDAPI godot_vector2_array_get_size(godot_vector2_array p_vector2_array);
 int GDAPI godot_vector2_array_get_stride(godot_vector2_array p_vector2_array);
-void GDAPI godot_vector2_array_get(godot_vector2_array p_vector2_array,int p_index,float* p_vector2);
-void GDAPI godot_vector2_array_set(godot_vector2_array p_vector2_array,int p_index,float *p_vector2);
-void GDAPI godot_vector2_array_remove(godot_vector2_array p_vector2_array,int p_index);
+void GDAPI godot_vector2_array_get(godot_vector2_array p_vector2_array, int p_index, float *p_vector2);
+void GDAPI godot_vector2_array_set(godot_vector2_array p_vector2_array, int p_index, float *p_vector2);
+void GDAPI godot_vector2_array_remove(godot_vector2_array p_vector2_array, int p_index);
 void GDAPI godot_vector2_array_clear(godot_vector2_array p_vector2_array);
 
-
-typedef void* godot_vector2_array_lock;
+typedef void *godot_vector2_array_lock;
 
 godot_vector2_array_lock GDAPI godot_vector2_array_get_lock(godot_vector2_array p_vector2_array);
 float GDAPI *godot_vector2_array_lock_get_pointer(godot_vector2_array_lock p_vector2_array_lock);
@@ -324,7 +310,7 @@ void GDAPI godot_vector2_array_lock_free(godot_vector2_array_lock p_vector2_arra
 
 ////// Vector3Array
 
-typedef void* godot_vector3_array;
+typedef void *godot_vector3_array;
 
 godot_vector3_array GDAPI godot_vector3_array_create();
 godot_vector3_array GDAPI godot_vector3_array_copy(godot_vector3_array p_vector3_array);
@@ -332,13 +318,12 @@ void GDAPI godot_vector3_array_free(godot_vector3_array p_vector3_array);
 
 int GDAPI godot_vector3_array_get_size(godot_vector3_array p_vector3_array);
 int GDAPI godot_vector3_array_get_stride(godot_vector3_array p_vector3_array);
-void GDAPI godot_vector3_array_get(godot_vector3_array p_vector3_array,int p_index,float* p_vector3);
-void GDAPI godot_vector3_array_set(godot_vector3_array p_vector3_array,int p_index,float *p_vector3);
-void GDAPI godot_vector3_array_remove(godot_vector3_array p_vector3_array,int p_index);
+void GDAPI godot_vector3_array_get(godot_vector3_array p_vector3_array, int p_index, float *p_vector3);
+void GDAPI godot_vector3_array_set(godot_vector3_array p_vector3_array, int p_index, float *p_vector3);
+void GDAPI godot_vector3_array_remove(godot_vector3_array p_vector3_array, int p_index);
 void GDAPI godot_vector3_array_clear(godot_vector3_array p_vector3_array);
 
-
-typedef void* godot_vector3_array_lock;
+typedef void *godot_vector3_array_lock;
 
 godot_vector3_array_lock GDAPI godot_vector3_array_get_lock(godot_vector3_array p_vector3_array);
 float GDAPI *godot_vector3_array_lock_get_pointer(godot_vector3_array_lock p_vector3_array_lock);
@@ -346,7 +331,7 @@ void GDAPI godot_vector3_array_lock_free(godot_vector3_array_lock p_vector3_arra
 
 ////// ColorArray
 
-typedef void* godot_color_array;
+typedef void *godot_color_array;
 
 godot_color_array GDAPI godot_color_array_create();
 godot_color_array GDAPI godot_color_array_copy(godot_color_array p_color_array);
@@ -354,19 +339,17 @@ void GDAPI godot_color_array_free(godot_color_array p_color_array);
 
 int GDAPI godot_color_array_get_size(godot_color_array p_color_array);
 int GDAPI godot_color_array_get_stride(godot_color_array p_color_array);
-void GDAPI godot_color_array_get(godot_color_array p_color_array,int p_index,float* p_color);
-void GDAPI godot_color_array_set(godot_color_array p_color_array,int p_index,float *p_color);
-void GDAPI godot_color_array_remove(godot_color_array p_color_array,int p_index);
+void GDAPI godot_color_array_get(godot_color_array p_color_array, int p_index, float *p_color);
+void GDAPI godot_color_array_set(godot_color_array p_color_array, int p_index, float *p_color);
+void GDAPI godot_color_array_remove(godot_color_array p_color_array, int p_index);
 void GDAPI godot_color_array_clear(godot_color_array p_color_array);
 
-
-typedef void* godot_color_array_lock;
+typedef void *godot_color_array_lock;
 
 godot_color_array_lock GDAPI godot_color_array_get_lock(godot_color_array p_color_array);
 float GDAPI *godot_color_array_lock_get_pointer(godot_color_array_lock p_color_array_lock);
 void GDAPI godot_color_array_lock_free(godot_color_array_lock p_color_array_lock);
 
-
 ////// Instance (forward declared)
 
 typedef void *godot_instance;
@@ -409,52 +392,52 @@ godot_variant *godot_variant_new();
 int GDAPI godot_variant_get_type(godot_variant p_variant);
 
 void GDAPI godot_variant_set_null(godot_variant p_variant);
-void GDAPI godot_variant_set_bool(godot_variant p_variant,godot_bool p_bool);
-void GDAPI godot_variant_set_int(godot_variant p_variant,int p_int);
-void GDAPI godot_variant_set_float(godot_variant p_variant,int p_float);
-void GDAPI godot_variant_set_string(godot_variant p_variant,char *p_string);
-void GDAPI godot_variant_set_vector2(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_set_rect2(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_set_vector3(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_set_matrix32(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_set_plane(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_set_aabb(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_set_matrix3(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_set_transform(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_set_color(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_set_image(godot_variant p_variant,godot_image *p_image);
-void GDAPI godot_variant_set_node_path(godot_variant p_variant,char *p_path);
-void GDAPI godot_variant_set_rid(godot_variant p_variant,char *p_path);
-void GDAPI godot_variant_set_instance(godot_variant p_variant,godot_instance p_instance);
-void GDAPI godot_variant_set_input_event(godot_variant p_variant,godot_input_event p_instance);
-void GDAPI godot_variant_set_dictionary(godot_variant p_variant,godot_dictionary p_dictionary);
-void GDAPI godot_variant_set_array(godot_variant p_variant,godot_array p_array);
-void GDAPI godot_variant_set_byte_array(godot_variant p_variant,godot_byte_array p_array);
-void GDAPI godot_variant_set_int_array(godot_variant p_variant,godot_byte_array p_array);
-void GDAPI godot_variant_set_string_array(godot_variant p_variant,godot_string_array p_array);
-void GDAPI godot_variant_set_vector2_array(godot_variant p_variant,godot_vector2_array p_array);
-void GDAPI godot_variant_set_vector3_array(godot_variant p_variant,godot_vector3_array p_array);
-void GDAPI godot_variant_set_color_array(godot_variant p_variant,godot_color_array p_array);
+void GDAPI godot_variant_set_bool(godot_variant p_variant, godot_bool p_bool);
+void GDAPI godot_variant_set_int(godot_variant p_variant, int p_int);
+void GDAPI godot_variant_set_float(godot_variant p_variant, int p_float);
+void GDAPI godot_variant_set_string(godot_variant p_variant, char *p_string);
+void GDAPI godot_variant_set_vector2(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_set_rect2(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_set_vector3(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_set_matrix32(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_set_plane(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_set_aabb(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_set_matrix3(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_set_transform(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_set_color(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_set_image(godot_variant p_variant, godot_image *p_image);
+void GDAPI godot_variant_set_node_path(godot_variant p_variant, char *p_path);
+void GDAPI godot_variant_set_rid(godot_variant p_variant, char *p_path);
+void GDAPI godot_variant_set_instance(godot_variant p_variant, godot_instance p_instance);
+void GDAPI godot_variant_set_input_event(godot_variant p_variant, godot_input_event p_instance);
+void GDAPI godot_variant_set_dictionary(godot_variant p_variant, godot_dictionary p_dictionary);
+void GDAPI godot_variant_set_array(godot_variant p_variant, godot_array p_array);
+void GDAPI godot_variant_set_byte_array(godot_variant p_variant, godot_byte_array p_array);
+void GDAPI godot_variant_set_int_array(godot_variant p_variant, godot_byte_array p_array);
+void GDAPI godot_variant_set_string_array(godot_variant p_variant, godot_string_array p_array);
+void GDAPI godot_variant_set_vector2_array(godot_variant p_variant, godot_vector2_array p_array);
+void GDAPI godot_variant_set_vector3_array(godot_variant p_variant, godot_vector3_array p_array);
+void GDAPI godot_variant_set_color_array(godot_variant p_variant, godot_color_array p_array);
 
 godot_bool GDAPI godot_variant_get_bool(godot_variant p_variant);
 int GDAPI godot_variant_get_int(godot_variant p_variant);
 float GDAPI godot_variant_get_float(godot_variant p_variant);
-int GDAPI godot_variant_get_string(godot_variant p_variant,char *p_string,int p_bufsize);
-void GDAPI godot_variant_get_vector2(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_get_rect2(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_get_vector3(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_get_matrix32(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_get_plane(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_get_aabb(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_get_matrix3(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_get_transform(godot_variant p_variant,float *p_elems);
-void GDAPI godot_variant_get_color(godot_variant p_variant,float *p_elems);
+int GDAPI godot_variant_get_string(godot_variant p_variant, char *p_string, int p_bufsize);
+void GDAPI godot_variant_get_vector2(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_get_rect2(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_get_vector3(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_get_matrix32(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_get_plane(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_get_aabb(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_get_matrix3(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_get_transform(godot_variant p_variant, float *p_elems);
+void GDAPI godot_variant_get_color(godot_variant p_variant, float *p_elems);
 godot_image GDAPI *godot_variant_get_image(godot_variant p_variant);
-int GDAPI godot_variant_get_node_path(godot_variant p_variant,char *p_path, int p_bufsize);
+int GDAPI godot_variant_get_node_path(godot_variant p_variant, char *p_path, int p_bufsize);
 godot_rid GDAPI godot_variant_get_rid(godot_variant p_variant);
 godot_instance GDAPI godot_variant_get_instance(godot_variant p_variant);
-void GDAPI godot_variant_get_input_event(godot_variant p_variant,godot_input_event);
-void GDAPI godot_variant_get_dictionary(godot_variant p_variant,godot_dictionary);
+void GDAPI godot_variant_get_input_event(godot_variant p_variant, godot_input_event);
+void GDAPI godot_variant_get_dictionary(godot_variant p_variant, godot_dictionary);
 godot_array GDAPI godot_variant_get_array(godot_variant p_variant);
 godot_byte_array GDAPI godot_variant_get_byte_array(godot_variant p_variant);
 godot_byte_array GDAPI godot_variant_get_int_array(godot_variant p_variant);
@@ -463,7 +446,6 @@ godot_vector2_array GDAPI godot_variant_get_vector2_array(godot_variant p_varian
 godot_vector3_array GDAPI godot_variant_get_vector3_array(godot_variant p_variant);
 godot_color_array GDAPI godot_variant_get_color_array(godot_variant p_variant);
 
-
 void GDAPI godot_variant_delete(godot_variant p_variant);
 
 ////// Class
@@ -471,17 +453,16 @@ void GDAPI godot_variant_delete(godot_variant p_variant);
 
 char GDAPI **godot_class_get_list(); //get list of classes in array to array of strings, must be freed, use godot_list_free()
 
-int GDAPI godot_class_get_base(char* p_class,char *p_base,int p_max_len);
-int GDAPI godot_class_get_name(char* p_class,char *p_base,int p_max_len);
-
-char GDAPI **godot_class_get_method_list(char* p_class); //free with godot_list_free()
-int GDAPI godot_class_method_get_argument_count(char* p_class,char *p_method);
-int GDAPI godot_class_method_get_argument_type(char* p_class,char *p_method,int p_argument);
-godot_variant GDAPI godot_class_method_get_argument_default_value(char* p_class,char *p_method,int p_argument);
+int GDAPI godot_class_get_base(char *p_class, char *p_base, int p_max_len);
+int GDAPI godot_class_get_name(char *p_class, char *p_base, int p_max_len);
 
-char GDAPI **godot_class_get_constant_list(char* p_class); //free with godot_list_free()
-int GDAPI godot_class_constant_get_value(char* p_class,char *p_constant);
+char GDAPI **godot_class_get_method_list(char *p_class); //free with godot_list_free()
+int GDAPI godot_class_method_get_argument_count(char *p_class, char *p_method);
+int GDAPI godot_class_method_get_argument_type(char *p_class, char *p_method, int p_argument);
+godot_variant GDAPI godot_class_method_get_argument_default_value(char *p_class, char *p_method, int p_argument);
 
+char GDAPI **godot_class_get_constant_list(char *p_class); //free with godot_list_free()
+int GDAPI godot_class_constant_get_value(char *p_class, char *p_constant);
 
 ////// Instance
 
@@ -491,8 +472,8 @@ typedef int godot_call_error;
 #define GODOT_CALL_ERROR_WRONG_ARGUMENTS
 #define GODOT_CALL_ERROR_INVALID_INSTANCE
 
-godot_instance GDAPI godot_instance_new(char* p_class);
-int GDAPI godot_instance_get_class(godot_instance p_instance,char* p_class,int p_max_len);
+godot_instance GDAPI godot_instance_new(char *p_class);
+int GDAPI godot_instance_get_class(godot_instance p_instance, char *p_class, int p_max_len);
 
 typedef struct {
 	char *name;
@@ -501,34 +482,32 @@ typedef struct {
 	int usage;
 } godot_property_info;
 
-godot_call_error GDAPI godot_instance_call(godot_instance p_instance, char* p_method, ...);
-godot_call_error GDAPI godot_instance_call_ret(godot_instance p_instance, godot_variant r_return, char* p_method, ...);
-godot_bool GDAPI godot_instance_set(godot_instance p_instance, char* p_prop,godot_variant p_value);
-godot_variant GDAPI godot_instance_get(godot_instance p_instance, char* p_prop);
-
+godot_call_error GDAPI godot_instance_call(godot_instance p_instance, char *p_method, ...);
+godot_call_error GDAPI godot_instance_call_ret(godot_instance p_instance, godot_variant r_return, char *p_method, ...);
+godot_bool GDAPI godot_instance_set(godot_instance p_instance, char *p_prop, godot_variant p_value);
+godot_variant GDAPI godot_instance_get(godot_instance p_instance, char *p_prop);
 
 #define GODOT_PROPERTY_HINT_NONE 0 ///< no hint provided.
-#define GODOT_PROPERTY_HINT_RANGE 1///< hint_text = "min,max,step,slider; //slider is optional"
-#define GODOT_PROPERTY_HINT_EXP_RANGE 2///< hint_text = "min,max,step", exponential edit
-#define GODOT_PROPERTY_HINT_ENUM 3///< hint_text= "val1,val2,val3,etc"
-#define GODOT_PROPERTY_HINT_EXP_EASING 4/// exponential easing funciton (Math::ease)
-#define GODOT_PROPERTY_HINT_LENGTH 5///< hint_text= "length" (as integer)
+#define GODOT_PROPERTY_HINT_RANGE 1 ///< hint_text = "min,max,step,slider; //slider is optional"
+#define GODOT_PROPERTY_HINT_EXP_RANGE 2 ///< hint_text = "min,max,step", exponential edit
+#define GODOT_PROPERTY_HINT_ENUM 3 ///< hint_text= "val1,val2,val3,etc"
+#define GODOT_PROPERTY_HINT_EXP_EASING 4 /// exponential easing funciton (Math::ease)
+#define GODOT_PROPERTY_HINT_LENGTH 5 ///< hint_text= "length" (as integer)
 #define GODOT_PROPERTY_HINT_SPRITE_FRAME 6
-#define GODOT_PROPERTY_HINT_KEY_ACCEL 7///< hint_text= "length" (as integer)
-#define GODOT_PROPERTY_HINT_FLAGS 8///< hint_text= "flag1,flag2,etc" (as bit flags)
+#define GODOT_PROPERTY_HINT_KEY_ACCEL 7 ///< hint_text= "length" (as integer)
+#define GODOT_PROPERTY_HINT_FLAGS 8 ///< hint_text= "flag1,flag2,etc" (as bit flags)
 #define GODOT_PROPERTY_HINT_ALL_FLAGS 9
 #define GODOT_PROPERTY_HINT_FILE 10 ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
 #define GODOT_PROPERTY_HINT_DIR 11 ///< a directort path must be passed
-#define GODOT_PROPERTY_HINT_GLOBAL_FILE 12///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
+#define GODOT_PROPERTY_HINT_GLOBAL_FILE 12 ///< a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
 #define GODOT_PROPERTY_HINT_GLOBAL_DIR 13 ///< a directort path must be passed
-#define GODOT_PROPERTY_HINT_RESOURCE_TYPE 14///< a resource object type
-#define GODOT_PROPERTY_HINT_MULTILINE_TEXT 15///< used for string properties that can contain multiple lines
-#define GODOT_PROPERTY_HINT_COLOR_NO_ALPHA 16///< used for ignoring alpha component when editing a color
+#define GODOT_PROPERTY_HINT_RESOURCE_TYPE 14 ///< a resource object type
+#define GODOT_PROPERTY_HINT_MULTILINE_TEXT 15 ///< used for string properties that can contain multiple lines
+#define GODOT_PROPERTY_HINT_COLOR_NO_ALPHA 16 ///< used for ignoring alpha component when editing a color
 #define GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSY 17
 #define GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS 18
 #define GODOT_PROPERTY_HINT_OBJECT_ID 19
 
-
 #define GODOT_PROPERTY_USAGE_STORAGE 1
 #define GODOT_PROPERTY_USAGE_EDITOR 2
 #define GODOT_PROPERTY_USAGE_NETWORK 4
@@ -546,51 +525,43 @@ godot_variant GDAPI godot_instance_get(godot_instance p_instance, char* p_prop);
 #define GODOT_PROPERTY_USAGE_STORE_IF_NULL 16384
 #define GODOT_PROPERTY_USAGE_ANIMATE_AS_TRIGGER 32768
 
-#define GODOT_PROPERTY_USAGE_DEFAULT GODOT_PROPERTY_USAGE_STORAGE|GODOT_PROPERTY_USAGE_EDITOR|GODOT_PROPERTY_USAGE_NETWORK
-#define GODOT_PROPERTY_USAGE_DEFAULT_INTL GODOT_PROPERTY_USAGE_STORAGE|GODOT_PROPERTY_USAGE_EDITOR|GODOT_PROPERTY_USAGE_NETWORK|GODOT_PROPERTY_USAGE_INTERNATIONALIZED
-#define GODOT_PROPERTY_USAGE_NOEDITOR GODOT_PROPERTY_USAGE_STORAGE|GODOT_PROPERTY_USAGE_NETWORK
-
+#define GODOT_PROPERTY_USAGE_DEFAULT GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK
+#define GODOT_PROPERTY_USAGE_DEFAULT_INTL GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_EDITOR | GODOT_PROPERTY_USAGE_NETWORK | GODOT_PROPERTY_USAGE_INTERNATIONALIZED
+#define GODOT_PROPERTY_USAGE_NOEDITOR GODOT_PROPERTY_USAGE_STORAGE | GODOT_PROPERTY_USAGE_NETWORK
 
 godot_property_info GDAPI **godot_instance_get_property_list(godot_instance p_instance);
-void GDAPI godot_instance_free_property_list(godot_instance p_instance,godot_property_info** p_list);
-
-
+void GDAPI godot_instance_free_property_list(godot_instance p_instance, godot_property_info **p_list);
 
 void GDAPI godot_list_free(char **p_name); //helper to free all the class list
 
-
 ////// Script API
 
-typedef void* (godot_script_instance_func)(godot_instance); //passed an instance, return a pointer to your userdata
-typedef void (godot_script_free_func)(godot_instance,void*); //passed an instance, please free your userdata
-
-void GDAPI godot_script_register(char* p_base,char* p_name,godot_script_instance_func p_instance_func,godot_script_free_func p_free_func);
-void GDAPI godot_script_unregister(char* p_name);
+typedef void *(godot_script_instance_func)(godot_instance); //passed an instance, return a pointer to your userdata
+typedef void(godot_script_free_func)(godot_instance, void *); //passed an instance, please free your userdata
 
-typedef GDAPI godot_variant (godot_script_func)(godot_instance,void*,godot_variant*,int); //instance,userdata,arguments,argument count. Return something or NULL. Arguments must not be freed.
+void GDAPI godot_script_register(char *p_base, char *p_name, godot_script_instance_func p_instance_func, godot_script_free_func p_free_func);
+void GDAPI godot_script_unregister(char *p_name);
 
+typedef GDAPI godot_variant(godot_script_func)(godot_instance, void *, godot_variant *, int); //instance,userdata,arguments,argument count. Return something or NULL. Arguments must not be freed.
 
-void GDAPI godot_script_add_function(char* p_name,char* p_function_name,godot_script_func p_func);
-void GDAPI godot_script_add_validated_function(char* p_name,char* p_function_name,godot_script_func p_func,int* p_arg_types,int p_arg_count,godot_variant* p_default_args,int p_default_arg_count);
+void GDAPI godot_script_add_function(char *p_name, char *p_function_name, godot_script_func p_func);
+void GDAPI godot_script_add_validated_function(char *p_name, char *p_function_name, godot_script_func p_func, int *p_arg_types, int p_arg_count, godot_variant *p_default_args, int p_default_arg_count);
 
-typedef void (godot_set_property_func)(godot_instance,void*,godot_variant); //instance,userdata,value. Value must not be freed.
-typedef godot_variant (godot_get_property_func)(godot_instance,void*); //instance,userdata. Return a value or NULL.
-
-void GDAPI godot_script_add_property(char* p_name,char* p_path,godot_set_property_func p_set_func,godot_get_property_func p_get_func);
-void GDAPI godot_script_add_listed_property(char* p_name,char* p_path,godot_set_property_func p_set_func,godot_get_property_func p_get_func,int p_type,int p_hint,char* p_hint_string,int p_usage);
+typedef void(godot_set_property_func)(godot_instance, void *, godot_variant); //instance,userdata,value. Value must not be freed.
+typedef godot_variant(godot_get_property_func)(godot_instance, void *); //instance,userdata. Return a value or NULL.
 
+void GDAPI godot_script_add_property(char *p_name, char *p_path, godot_set_property_func p_set_func, godot_get_property_func p_get_func);
+void GDAPI godot_script_add_listed_property(char *p_name, char *p_path, godot_set_property_func p_set_func, godot_get_property_func p_get_func, int p_type, int p_hint, char *p_hint_string, int p_usage);
 
 ////// System Functions
 
 //using these will help Godot track how much memory is in use in debug mode
 void GDAPI *godot_alloc(int p_bytes);
-void GDAPI *godot_realloc(void* p_ptr,int p_bytes);
-void GDAPI godot_free(void* p_ptr);
-
+void GDAPI *godot_realloc(void *p_ptr, int p_bytes);
+void GDAPI godot_free(void *p_ptr);
 
 #ifdef __cplusplus
 }
 #endif
 
-
 #endif // GODOT_C_H
diff --git a/modules/cscript/register_types.cpp b/modules/cscript/register_types.cpp
index d2101bbd49..2477bc51e2 100644
--- a/modules/cscript/register_types.cpp
+++ b/modules/cscript/register_types.cpp
@@ -28,10 +28,7 @@
 /*************************************************************************/
 #include "register_types.h"
 
-
 void register_cscript_types() {
-
 }
 void unregister_cscript_types() {
-
 }
diff --git a/modules/dds/register_types.cpp b/modules/dds/register_types.cpp
index 917305f543..d0eaf3f995 100644
--- a/modules/dds/register_types.cpp
+++ b/modules/dds/register_types.cpp
@@ -34,7 +34,7 @@ static ResourceFormatDDS *resource_loader_dds = NULL;
 
 void register_dds_types() {
 
-	resource_loader_dds = memnew( ResourceFormatDDS );
+	resource_loader_dds = memnew(ResourceFormatDDS);
 	ResourceLoader::add_resource_format_loader(resource_loader_dds);
 }
 
diff --git a/modules/dds/texture_loader_dds.cpp b/modules/dds/texture_loader_dds.cpp
index 600cae991e..9c976179fa 100644
--- a/modules/dds/texture_loader_dds.cpp
+++ b/modules/dds/texture_loader_dds.cpp
@@ -29,18 +29,17 @@
 #include "texture_loader_dds.h"
 #include "os/file_access.h"
 
-
 enum {
-	DDS_MAGIC=0x20534444,
-	DDSD_CAPS=0x00000001,
-	DDSD_PIXELFORMAT=0x00001000,
-	DDSD_PITCH=0x00000008,
-	DDSD_LINEARSIZE=0x00080000,
-	DDSD_MIPMAPCOUNT=0x00020000,
-	DDPF_FOURCC=0x00000004,
-	DDPF_ALPHAPIXELS=0x00000001,
-	DDPF_INDEXED=0x00000020,
-	DDPF_RGB=0x00000040,
+	DDS_MAGIC = 0x20534444,
+	DDSD_CAPS = 0x00000001,
+	DDSD_PIXELFORMAT = 0x00001000,
+	DDSD_PITCH = 0x00000008,
+	DDSD_LINEARSIZE = 0x00080000,
+	DDSD_MIPMAPCOUNT = 0x00020000,
+	DDPF_FOURCC = 0x00000004,
+	DDPF_ALPHAPIXELS = 0x00000001,
+	DDPF_INDEXED = 0x00000020,
+	DDPF_RGB = 0x00000040,
 };
 
 enum DDSFormat {
@@ -72,41 +71,39 @@ struct DDSFormatInfo {
 	Image::Format format;
 };
 
-
-static const DDSFormatInfo dds_format_info[DDS_MAX]={
-	{"DXT1",true,false,4,8,Image::FORMAT_DXT1},
-	{"DXT3",true,false,4,16,Image::FORMAT_DXT3},
-	{"DXT5",true,false,4,16,Image::FORMAT_DXT5},
-	{"ATI1",true,false,4,8,Image::FORMAT_ATI1},
-	{"ATI2",true,false,4,16,Image::FORMAT_ATI2},
-	{"BGRA8",false,false,1,4,Image::FORMAT_RGBA8},
-	{"BGR8",false,false,1,3,Image::FORMAT_RGB8},
-	{"RGBA8",false,false,1,4,Image::FORMAT_RGBA8},
-	{"RGB8",false,false,1,3,Image::FORMAT_RGB8},
-	{"BGR5A1",false,false,1,2,Image::FORMAT_RGBA8},
-	{"BGR565",false,false,1,2,Image::FORMAT_RGB8},
-	{"BGR10A2",false,false,1,4,Image::FORMAT_RGBA8},
-	{"GRAYSCALE",false,false,1,1,Image::FORMAT_L8},
-	{"GRAYSCALE_ALPHA",false,false,1,2,Image::FORMAT_LA8}
+static const DDSFormatInfo dds_format_info[DDS_MAX] = {
+	{ "DXT1", true, false, 4, 8, Image::FORMAT_DXT1 },
+	{ "DXT3", true, false, 4, 16, Image::FORMAT_DXT3 },
+	{ "DXT5", true, false, 4, 16, Image::FORMAT_DXT5 },
+	{ "ATI1", true, false, 4, 8, Image::FORMAT_ATI1 },
+	{ "ATI2", true, false, 4, 16, Image::FORMAT_ATI2 },
+	{ "BGRA8", false, false, 1, 4, Image::FORMAT_RGBA8 },
+	{ "BGR8", false, false, 1, 3, Image::FORMAT_RGB8 },
+	{ "RGBA8", false, false, 1, 4, Image::FORMAT_RGBA8 },
+	{ "RGB8", false, false, 1, 3, Image::FORMAT_RGB8 },
+	{ "BGR5A1", false, false, 1, 2, Image::FORMAT_RGBA8 },
+	{ "BGR565", false, false, 1, 2, Image::FORMAT_RGB8 },
+	{ "BGR10A2", false, false, 1, 4, Image::FORMAT_RGBA8 },
+	{ "GRAYSCALE", false, false, 1, 1, Image::FORMAT_L8 },
+	{ "GRAYSCALE_ALPHA", false, false, 1, 2, Image::FORMAT_LA8 }
 };
 
-
-RES ResourceFormatDDS::load(const String &p_path, const String& p_original_path, Error *r_error) {
+RES ResourceFormatDDS::load(const String &p_path, const String &p_original_path, Error *r_error) {
 
 	if (r_error)
-		*r_error=ERR_CANT_OPEN;
+		*r_error = ERR_CANT_OPEN;
 
 	Error err;
-	FileAccess *f = FileAccess::open(p_path,FileAccess::READ,&err);
+	FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
 	if (!f)
 		return RES();
 
 	FileAccessRef fref(f);
 	if (r_error)
-		*r_error=ERR_FILE_CORRUPT;
+		*r_error = ERR_FILE_CORRUPT;
 
-	ERR_EXPLAIN("Unable to open DDS texture file: "+p_path);
-	ERR_FAIL_COND_V(err!=OK,RES());
+	ERR_EXPLAIN("Unable to open DDS texture file: " + p_path);
+	ERR_FAIL_COND_V(err != OK, RES());
 
 	uint32_t magic = f->get_32();
 	uint32_t hsize = f->get_32();
@@ -118,18 +115,17 @@ RES ResourceFormatDDS::load(const String &p_path, const String& p_original_path,
 	uint32_t mipmaps = f->get_32();
 
 	//skip 11
-	for(int i=0;i<11;i++)
+	for (int i = 0; i < 11; i++)
 		f->get_32();
 
 	//validate
 
-	if (magic!=DDS_MAGIC || hsize!=124 || !(flags&DDSD_PIXELFORMAT) || !(flags&DDSD_CAPS)) {
+	if (magic != DDS_MAGIC || hsize != 124 || !(flags & DDSD_PIXELFORMAT) || !(flags & DDSD_CAPS)) {
 
-		ERR_EXPLAIN("Invalid or Unsupported DDS texture file: "+p_path);
+		ERR_EXPLAIN("Invalid or Unsupported DDS texture file: " + p_path);
 		ERR_FAIL_V(RES());
 	}
 
-
 	/* uint32_t format_size = */ f->get_32();
 	uint32_t format_flags = f->get_32();
 	uint32_t format_fourcc = f->get_32();
@@ -155,258 +151,249 @@ RES ResourceFormatDDS::load(const String &p_path, const String& p_original_path,
 	//printf("rmask: %x gmask: %x, bmask: %x, amask: %x\n",format_red_mask,format_green_mask,format_blue_mask,format_alpha_mask);
 
 	//must avoid this later
-	while(f->get_pos()<128)
+	while (f->get_pos() < 128)
 		f->get_8();
 
-
 	DDSFormat dds_format;
 
-	if (format_flags&DDPF_FOURCC && format_fourcc==0x31545844) { //'1TXD'
+	if (format_flags & DDPF_FOURCC && format_fourcc == 0x31545844) { //'1TXD'
 
-		dds_format=DDS_DXT1;
-	} else if (format_flags&DDPF_FOURCC && format_fourcc==0x33545844) { //'3TXD'
+		dds_format = DDS_DXT1;
+	} else if (format_flags & DDPF_FOURCC && format_fourcc == 0x33545844) { //'3TXD'
 
-		dds_format=DDS_DXT3;
+		dds_format = DDS_DXT3;
 
-	} else if (format_flags&DDPF_FOURCC && format_fourcc==0x35545844) { //'5TXD'
+	} else if (format_flags & DDPF_FOURCC && format_fourcc == 0x35545844) { //'5TXD'
 
-		dds_format=DDS_DXT5;
-	} else if (format_flags&DDPF_FOURCC && format_fourcc==0x31495441) { //'1ITA'
+		dds_format = DDS_DXT5;
+	} else if (format_flags & DDPF_FOURCC && format_fourcc == 0x31495441) { //'1ITA'
 
-		dds_format=DDS_ATI1;
-	} else if (format_flags&DDPF_FOURCC && format_fourcc==0x32495441) { //'2ITA'
+		dds_format = DDS_ATI1;
+	} else if (format_flags & DDPF_FOURCC && format_fourcc == 0x32495441) { //'2ITA'
 
-		dds_format=DDS_ATI2;
+		dds_format = DDS_ATI2;
 
-	} else if (format_flags&DDPF_RGB && format_flags&DDPF_ALPHAPIXELS && format_rgb_bits==32 && format_red_mask==0xff0000 && format_green_mask==0xff00 && format_blue_mask==0xff && format_alpha_mask==0xff000000) {
+	} else if (format_flags & DDPF_RGB && format_flags & DDPF_ALPHAPIXELS && format_rgb_bits == 32 && format_red_mask == 0xff0000 && format_green_mask == 0xff00 && format_blue_mask == 0xff && format_alpha_mask == 0xff000000) {
 
-		dds_format=DDS_BGRA8;
-	} else if (format_flags&DDPF_RGB && !(format_flags&DDPF_ALPHAPIXELS ) && format_rgb_bits==24 && format_red_mask==0xff0000 && format_green_mask==0xff00 && format_blue_mask==0xff) {
+		dds_format = DDS_BGRA8;
+	} else if (format_flags & DDPF_RGB && !(format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 24 && format_red_mask == 0xff0000 && format_green_mask == 0xff00 && format_blue_mask == 0xff) {
 
-		dds_format=DDS_BGR8;
-	} else if (format_flags&DDPF_RGB && format_flags&DDPF_ALPHAPIXELS && format_rgb_bits==32 && format_red_mask==0xff && format_green_mask==0xff00 && format_blue_mask==0xff0000 && format_alpha_mask==0xff000000) {
+		dds_format = DDS_BGR8;
+	} else if (format_flags & DDPF_RGB && format_flags & DDPF_ALPHAPIXELS && format_rgb_bits == 32 && format_red_mask == 0xff && format_green_mask == 0xff00 && format_blue_mask == 0xff0000 && format_alpha_mask == 0xff000000) {
 
-		dds_format=DDS_RGBA8;
-	} else if (format_flags&DDPF_RGB && !(format_flags&DDPF_ALPHAPIXELS ) && format_rgb_bits==24 && format_red_mask==0xff && format_green_mask==0xff00 && format_blue_mask==0xff0000) {
+		dds_format = DDS_RGBA8;
+	} else if (format_flags & DDPF_RGB && !(format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 24 && format_red_mask == 0xff && format_green_mask == 0xff00 && format_blue_mask == 0xff0000) {
 
-		dds_format=DDS_RGB8;
+		dds_format = DDS_RGB8;
 
-	} else if (format_flags&DDPF_RGB && format_flags&DDPF_ALPHAPIXELS && format_rgb_bits==16 && format_red_mask==0x00007c00 && format_green_mask==0x000003e0 && format_blue_mask==0x0000001f && format_alpha_mask==0x00008000) {
+	} else if (format_flags & DDPF_RGB && format_flags & DDPF_ALPHAPIXELS && format_rgb_bits == 16 && format_red_mask == 0x00007c00 && format_green_mask == 0x000003e0 && format_blue_mask == 0x0000001f && format_alpha_mask == 0x00008000) {
 
-		dds_format=DDS_BGR5A1;
-	} else if (format_flags&DDPF_RGB && format_flags&DDPF_ALPHAPIXELS && format_rgb_bits==32 && format_red_mask==0x3ff00000 && format_green_mask==0xffc00 && format_blue_mask==0x3ff && format_alpha_mask==0xc0000000) {
+		dds_format = DDS_BGR5A1;
+	} else if (format_flags & DDPF_RGB && format_flags & DDPF_ALPHAPIXELS && format_rgb_bits == 32 && format_red_mask == 0x3ff00000 && format_green_mask == 0xffc00 && format_blue_mask == 0x3ff && format_alpha_mask == 0xc0000000) {
 
-		dds_format=DDS_BGR10A2;
-	} else if (format_flags&DDPF_RGB && !(format_flags&DDPF_ALPHAPIXELS) && format_rgb_bits==16 && format_red_mask==0x0000f800 && format_green_mask==0x000007e0 && format_blue_mask==0x0000001f) {
+		dds_format = DDS_BGR10A2;
+	} else if (format_flags & DDPF_RGB && !(format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 16 && format_red_mask == 0x0000f800 && format_green_mask == 0x000007e0 && format_blue_mask == 0x0000001f) {
 
-		dds_format=DDS_BGR565;
-	} else if (!(format_flags&DDPF_ALPHAPIXELS) && format_rgb_bits==8 && format_red_mask==0xff && format_green_mask==0xff && format_blue_mask==0xff) {
+		dds_format = DDS_BGR565;
+	} else if (!(format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 8 && format_red_mask == 0xff && format_green_mask == 0xff && format_blue_mask == 0xff) {
 
-		dds_format=DDS_LUMINANCE;
-	} else if ((format_flags&DDPF_ALPHAPIXELS) && format_rgb_bits==16 && format_red_mask==0xff && format_green_mask==0xff && format_blue_mask==0xff && format_alpha_mask==0xff00) {
+		dds_format = DDS_LUMINANCE;
+	} else if ((format_flags & DDPF_ALPHAPIXELS) && format_rgb_bits == 16 && format_red_mask == 0xff && format_green_mask == 0xff && format_blue_mask == 0xff && format_alpha_mask == 0xff00) {
 
-		dds_format=DDS_LUMINANCE_ALPHA;
-	} else if (format_flags&DDPF_INDEXED && format_rgb_bits==8) {
+		dds_format = DDS_LUMINANCE_ALPHA;
+	} else if (format_flags & DDPF_INDEXED && format_rgb_bits == 8) {
 
-		dds_format=DDS_BGR565;
+		dds_format = DDS_BGR565;
 	} else {
 
-		printf("unrecognized fourcc %x format_flags: %x - rgbbits %i - red_mask %x green mask %x blue mask %x alpha mask %x\n",format_fourcc,format_flags,format_rgb_bits,format_red_mask,format_green_mask,format_blue_mask,format_alpha_mask);
-		ERR_EXPLAIN("Unrecognized or Unsupported color layout in DDS: "+p_path);
+		printf("unrecognized fourcc %x format_flags: %x - rgbbits %i - red_mask %x green mask %x blue mask %x alpha mask %x\n", format_fourcc, format_flags, format_rgb_bits, format_red_mask, format_green_mask, format_blue_mask, format_alpha_mask);
+		ERR_EXPLAIN("Unrecognized or Unsupported color layout in DDS: " + p_path);
 
 		ERR_FAIL_V(RES());
-
 	}
 
-	if (!(flags&DDSD_MIPMAPCOUNT))
-		mipmaps=1;
+	if (!(flags & DDSD_MIPMAPCOUNT))
+		mipmaps = 1;
 
 	//print_line("found format: "+String(dds_format_info[dds_format].name));
 
 	PoolVector<uint8_t> src_data;
 
-	const DDSFormatInfo &info=dds_format_info[dds_format];
+	const DDSFormatInfo &info = dds_format_info[dds_format];
 	uint32_t w = width;
 	uint32_t h = height;
 
-
 	if (info.compressed) {
 		//compressed bc
 
-		uint32_t size = MAX( info.divisor, w )/info.divisor * MAX( info.divisor, h )/info.divisor * info.block_size;
-		ERR_FAIL_COND_V( size!=pitch, RES() );
-		ERR_FAIL_COND_V( !(flags&DDSD_LINEARSIZE), RES() );
+		uint32_t size = MAX(info.divisor, w) / info.divisor * MAX(info.divisor, h) / info.divisor * info.block_size;
+		ERR_FAIL_COND_V(size != pitch, RES());
+		ERR_FAIL_COND_V(!(flags & DDSD_LINEARSIZE), RES());
 
-		for(uint32_t i=1;i<mipmaps;i++) {
+		for (uint32_t i = 1; i < mipmaps; i++) {
 
-			w=MAX(1,w>>1);
-			h=MAX(1,h>>1);
-			uint32_t bsize = MAX( info.divisor, w )/info.divisor * MAX( info.divisor, h )/info.divisor * info.block_size;
+			w = MAX(1, w >> 1);
+			h = MAX(1, h >> 1);
+			uint32_t bsize = MAX(info.divisor, w) / info.divisor * MAX(info.divisor, h) / info.divisor * info.block_size;
 			//printf("%i x %i - block: %i\n",w,h,bsize);
-			size+= bsize;
+			size += bsize;
 		}
 
 		src_data.resize(size);
 		PoolVector<uint8_t>::Write wb = src_data.write();
-		f->get_buffer(wb.ptr(),size);
-		wb=PoolVector<uint8_t>::Write();
+		f->get_buffer(wb.ptr(), size);
+		wb = PoolVector<uint8_t>::Write();
 
 	} else if (info.palette) {
 
 		//indexed
-		ERR_FAIL_COND_V( !(flags&DDSD_PITCH), RES());
-		ERR_FAIL_COND_V( format_rgb_bits!=8, RES() );
+		ERR_FAIL_COND_V(!(flags & DDSD_PITCH), RES());
+		ERR_FAIL_COND_V(format_rgb_bits != 8, RES());
 
-		uint32_t size = pitch*height;
-		ERR_FAIL_COND_V( size != width*height * info.block_size, RES());
+		uint32_t size = pitch * height;
+		ERR_FAIL_COND_V(size != width * height * info.block_size, RES());
 
-		uint8_t pallete[256*4];
-		f->get_buffer(pallete,256*4);
+		uint8_t pallete[256 * 4];
+		f->get_buffer(pallete, 256 * 4);
 
-		int colsize=3;
-		for(int i=0;i<256;i++) {
+		int colsize = 3;
+		for (int i = 0; i < 256; i++) {
 
-			if (pallete[i*4+3]<255)
-				colsize=4;
+			if (pallete[i * 4 + 3] < 255)
+				colsize = 4;
 		}
 
 		int w = width;
 		int h = height;
 
-		for(uint32_t i=1;i<mipmaps;i++) {
+		for (uint32_t i = 1; i < mipmaps; i++) {
 
-			w=(w+1)>>1;
-			h=(h+1)>>1;
-			size+= w*h*info.block_size;
+			w = (w + 1) >> 1;
+			h = (h + 1) >> 1;
+			size += w * h * info.block_size;
 		}
 
-		src_data.resize(size + 256*colsize );
+		src_data.resize(size + 256 * colsize);
 		PoolVector<uint8_t>::Write wb = src_data.write();
-		f->get_buffer(wb.ptr(),size);
+		f->get_buffer(wb.ptr(), size);
 
-		for(int i=0;i<256;i++) {
+		for (int i = 0; i < 256; i++) {
 
-			int dst_ofs = size+i*colsize;
-			int src_ofs = i*4;
-			wb[dst_ofs+0]=pallete[src_ofs+2];
-			wb[dst_ofs+1]=pallete[src_ofs+1];
-			wb[dst_ofs+2]=pallete[src_ofs+0];
-			if (colsize==4)
-				wb[dst_ofs+3]=pallete[src_ofs+3];
+			int dst_ofs = size + i * colsize;
+			int src_ofs = i * 4;
+			wb[dst_ofs + 0] = pallete[src_ofs + 2];
+			wb[dst_ofs + 1] = pallete[src_ofs + 1];
+			wb[dst_ofs + 2] = pallete[src_ofs + 0];
+			if (colsize == 4)
+				wb[dst_ofs + 3] = pallete[src_ofs + 3];
 		}
 
-
-		wb=PoolVector<uint8_t>::Write();
+		wb = PoolVector<uint8_t>::Write();
 	} else {
 		//uncompressed generic...
 
-		uint32_t size = width*height*info.block_size;
-
+		uint32_t size = width * height * info.block_size;
 
-		for(uint32_t i=1;i<mipmaps;i++) {
+		for (uint32_t i = 1; i < mipmaps; i++) {
 
-			w=(w+1)>>1;
-			h=(h+1)>>1;
-			size+= w*h*info.block_size;
+			w = (w + 1) >> 1;
+			h = (h + 1) >> 1;
+			size += w * h * info.block_size;
 		}
 
-		if (dds_format==DDS_BGR565)
-			size=size*3/2;
-		else if (dds_format==DDS_BGR5A1)
-			size=size*2;
+		if (dds_format == DDS_BGR565)
+			size = size * 3 / 2;
+		else if (dds_format == DDS_BGR5A1)
+			size = size * 2;
 
 		src_data.resize(size);
 		PoolVector<uint8_t>::Write wb = src_data.write();
-		f->get_buffer(wb.ptr(),size);
-
+		f->get_buffer(wb.ptr(), size);
 
-		switch(dds_format) {
+		switch (dds_format) {
 
 			case DDS_BGR5A1: {
 
 				// TO RGBA
-				int colcount = size/4;
+				int colcount = size / 4;
 
-				for(int i=colcount-1;i>=0;i--) {
+				for (int i = colcount - 1; i >= 0; i--) {
 
-					int src_ofs = i*2;
-					int dst_ofs = i*4;
+					int src_ofs = i * 2;
+					int dst_ofs = i * 4;
 
-					uint8_t a=wb[src_ofs+1]&0x80;
-					uint8_t b= wb[src_ofs]&0x1F;
-					uint8_t g= (wb[src_ofs]>>5) | ((wb[src_ofs+1]&0x3)<<3);
-					uint8_t r= (wb[src_ofs+1]>>2)&0x1F;
-					wb[dst_ofs+0]=r<<3;
-					wb[dst_ofs+1]=g<<3;
-					wb[dst_ofs+2]=b<<3;
-					wb[dst_ofs+3]=a?255:0;
+					uint8_t a = wb[src_ofs + 1] & 0x80;
+					uint8_t b = wb[src_ofs] & 0x1F;
+					uint8_t g = (wb[src_ofs] >> 5) | ((wb[src_ofs + 1] & 0x3) << 3);
+					uint8_t r = (wb[src_ofs + 1] >> 2) & 0x1F;
+					wb[dst_ofs + 0] = r << 3;
+					wb[dst_ofs + 1] = g << 3;
+					wb[dst_ofs + 2] = b << 3;
+					wb[dst_ofs + 3] = a ? 255 : 0;
 				}
 			} break;
 			case DDS_BGR565: {
 
-				int colcount = size/3;
-
-				for(int i=colcount-1;i>=0;i--) {
+				int colcount = size / 3;
 
-					int src_ofs = i*2;
-					int dst_ofs = i*3;
+				for (int i = colcount - 1; i >= 0; i--) {
 
-					uint8_t b= wb[src_ofs]&0x1F;
-					uint8_t g= (wb[src_ofs]>>5) | ((wb[src_ofs+1]&0x7)<<3);
-					uint8_t r= wb[src_ofs+1]>>3;
-					wb[dst_ofs+0]=r<<3;
-					wb[dst_ofs+1]=g<<2;
-					wb[dst_ofs+2]=b<<3;//b<<3;
+					int src_ofs = i * 2;
+					int dst_ofs = i * 3;
 
+					uint8_t b = wb[src_ofs] & 0x1F;
+					uint8_t g = (wb[src_ofs] >> 5) | ((wb[src_ofs + 1] & 0x7) << 3);
+					uint8_t r = wb[src_ofs + 1] >> 3;
+					wb[dst_ofs + 0] = r << 3;
+					wb[dst_ofs + 1] = g << 2;
+					wb[dst_ofs + 2] = b << 3; //b<<3;
 				}
 
 			} break;
 			case DDS_BGR10A2: {
 
 				// TO RGBA
-				int colcount = size/4;
-
-				for(int i=colcount-1;i>=0;i--) {
-
-					int ofs = i*4;
+				int colcount = size / 4;
 
-					uint32_t w32 = uint32_t(wb[ofs+0]) | (uint32_t(wb[ofs+1])<<8) | (uint32_t(wb[ofs+2])<<16) | (uint32_t(wb[ofs+3])<<24);
+				for (int i = colcount - 1; i >= 0; i--) {
 
-					uint8_t a= (w32&0xc0000000) >> 24;
-					uint8_t r= (w32&0x3ff00000) >> 22;
-					uint8_t g= (w32&0xffc00) >> 12;
-					uint8_t b= (w32&0x3ff) >> 2;
+					int ofs = i * 4;
 
+					uint32_t w32 = uint32_t(wb[ofs + 0]) | (uint32_t(wb[ofs + 1]) << 8) | (uint32_t(wb[ofs + 2]) << 16) | (uint32_t(wb[ofs + 3]) << 24);
 
-					wb[ofs+0]=r;
-					wb[ofs+1]=g;
-					wb[ofs+2]=b;
-					wb[ofs+3]=a==0xc0 ? 255 : a; //0xc0 should be opaque
+					uint8_t a = (w32 & 0xc0000000) >> 24;
+					uint8_t r = (w32 & 0x3ff00000) >> 22;
+					uint8_t g = (w32 & 0xffc00) >> 12;
+					uint8_t b = (w32 & 0x3ff) >> 2;
 
+					wb[ofs + 0] = r;
+					wb[ofs + 1] = g;
+					wb[ofs + 2] = b;
+					wb[ofs + 3] = a == 0xc0 ? 255 : a; //0xc0 should be opaque
 				}
 			} break;
 			case DDS_BGRA8: {
 
-				int colcount = size/4;
+				int colcount = size / 4;
 
-				for(int i=0;i<colcount;i++) {
+				for (int i = 0; i < colcount; i++) {
 
-					SWAP( wb[i*4+0],wb[i*4+2] );
+					SWAP(wb[i * 4 + 0], wb[i * 4 + 2]);
 				}
 
 			} break;
 			case DDS_BGR8: {
 
-				int colcount = size/3;
+				int colcount = size / 3;
 
-				for(int i=0;i<colcount;i++) {
+				for (int i = 0; i < colcount; i++) {
 
-					SWAP( wb[i*3+0],wb[i*3+2] );
+					SWAP(wb[i * 3 + 0], wb[i * 3 + 2]);
 				}
 			} break;
 			case DDS_RGBA8: {
 
-					/* do nothing either
+				/* do nothing either
 				int colcount = size/4;
 
 				for(int i=0;i<colcount;i++) {
@@ -446,24 +433,20 @@ RES ResourceFormatDDS::load(const String &p_path, const String& p_original_path,
 			} break;
 
 			default: {}
-
 		}
 
-		wb=PoolVector<uint8_t>::Write();
+		wb = PoolVector<uint8_t>::Write();
 	}
 
+	Image img(width, height, mipmaps - 1, info.format, src_data);
 
-	Image img(width,height,mipmaps-1,info.format,src_data);
-
-	Ref<ImageTexture> texture = memnew( ImageTexture );
+	Ref<ImageTexture> texture = memnew(ImageTexture);
 	texture->create_from_image(img);
 
 	if (r_error)
-		*r_error=OK;
-
+		*r_error = OK;
 
 	return texture;
-
 }
 
 void ResourceFormatDDS::get_recognized_extensions(List<String> *p_extensions) const {
@@ -471,14 +454,14 @@ void ResourceFormatDDS::get_recognized_extensions(List<String> *p_extensions) co
 	p_extensions->push_back("dds");
 }
 
-bool ResourceFormatDDS::handles_type(const String& p_type) const {
+bool ResourceFormatDDS::handles_type(const String &p_type) const {
 
-	return ClassDB::is_parent_class(p_type,"Texture");
+	return ClassDB::is_parent_class(p_type, "Texture");
 }
 
 String ResourceFormatDDS::get_resource_type(const String &p_path) const {
 
-	if (p_path.get_extension().to_lower()=="dds")
+	if (p_path.get_extension().to_lower() == "dds")
 		return "ImageTexture";
 	return "";
 }
diff --git a/modules/dds/texture_loader_dds.h b/modules/dds/texture_loader_dds.h
index d09af680c7..c347937cd5 100644
--- a/modules/dds/texture_loader_dds.h
+++ b/modules/dds/texture_loader_dds.h
@@ -29,15 +29,14 @@
 #ifndef TEXTURE_LOADER_DDS_H
 #define TEXTURE_LOADER_DDS_H
 
-#include "scene/resources/texture.h"
 #include "io/resource_loader.h"
+#include "scene/resources/texture.h"
 
-class ResourceFormatDDS : public ResourceFormatLoader{
+class ResourceFormatDDS : public ResourceFormatLoader {
 public:
-
-	virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual bool handles_type(const String& p_type) const;
+	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;
 
 	virtual ~ResourceFormatDDS() {}
diff --git a/modules/enet/networked_multiplayer_enet.cpp b/modules/enet/networked_multiplayer_enet.cpp
index af555b7eb6..2dfb0b4a6a 100644
--- a/modules/enet/networked_multiplayer_enet.cpp
+++ b/modules/enet/networked_multiplayer_enet.cpp
@@ -26,98 +26,96 @@
 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
-#include "os/os.h"
-#include "io/marshalls.h"
 #include "networked_multiplayer_enet.h"
+#include "io/marshalls.h"
+#include "os/os.h"
 
 void NetworkedMultiplayerENet::set_transfer_mode(TransferMode p_mode) {
 
-	transfer_mode=p_mode;
+	transfer_mode = p_mode;
 }
 
-void NetworkedMultiplayerENet::set_target_peer(int p_peer){
+void NetworkedMultiplayerENet::set_target_peer(int p_peer) {
 
-	target_peer=p_peer;
+	target_peer = p_peer;
 }
 
-int NetworkedMultiplayerENet::get_packet_peer() const{
+int NetworkedMultiplayerENet::get_packet_peer() const {
 
-	ERR_FAIL_COND_V(!active,1);
-	ERR_FAIL_COND_V(incoming_packets.size()==0,1);
+	ERR_FAIL_COND_V(!active, 1);
+	ERR_FAIL_COND_V(incoming_packets.size() == 0, 1);
 
 	return incoming_packets.front()->get().from;
-
 }
 
-Error NetworkedMultiplayerENet::create_server(int p_port, int p_max_clients, int p_in_bandwidth, int p_out_bandwidth){
+Error NetworkedMultiplayerENet::create_server(int p_port, int p_max_clients, int p_in_bandwidth, int p_out_bandwidth) {
 
-	ERR_FAIL_COND_V(active,ERR_ALREADY_IN_USE);
+	ERR_FAIL_COND_V(active, ERR_ALREADY_IN_USE);
 
 	ENetAddress address;
 	address.host = bind_ip;
 
 	address.port = p_port;
 
-	host = enet_host_create (& address /* the address to bind the server host to */,
-				     p_max_clients      /* allow up to 32 clients and/or outgoing connections */,
-				     SYSCH_MAX      /* allow up to SYSCH_MAX channels to be used */,
-				     p_in_bandwidth      /* assume any amount of incoming bandwidth */,
-				     p_out_bandwidth      /* assume any amount of outgoing bandwidth */);
+	host = enet_host_create(&address /* the address to bind the server host to */,
+			p_max_clients /* allow up to 32 clients and/or outgoing connections */,
+			SYSCH_MAX /* allow up to SYSCH_MAX channels to be used */,
+			p_in_bandwidth /* assume any amount of incoming bandwidth */,
+			p_out_bandwidth /* assume any amount of outgoing bandwidth */);
 
-	ERR_FAIL_COND_V(!host,ERR_CANT_CREATE);
+	ERR_FAIL_COND_V(!host, ERR_CANT_CREATE);
 
 	_setup_compressor();
-	active=true;
-	server=true;
-	refuse_connections=false;
-	unique_id=1;
-	connection_status=CONNECTION_CONNECTED;
+	active = true;
+	server = true;
+	refuse_connections = false;
+	unique_id = 1;
+	connection_status = CONNECTION_CONNECTED;
 	return OK;
 }
-Error NetworkedMultiplayerENet::create_client(const IP_Address& p_ip, int p_port, int p_in_bandwidth, int p_out_bandwidth){
+Error NetworkedMultiplayerENet::create_client(const IP_Address &p_ip, int p_port, int p_in_bandwidth, int p_out_bandwidth) {
 
-	ERR_FAIL_COND_V(active,ERR_ALREADY_IN_USE);
+	ERR_FAIL_COND_V(active, ERR_ALREADY_IN_USE);
 	ERR_FAIL_COND_V(!p_ip.is_ipv4(), ERR_INVALID_PARAMETER);
 
-	host = enet_host_create (NULL /* create a client host */,
-		    1 /* only allow 1 outgoing connection */,
-		    SYSCH_MAX /* allow up to SYSCH_MAX channels to be used */,
-		    p_in_bandwidth /* 56K modem with 56 Kbps downstream bandwidth */,
-		    p_out_bandwidth /* 56K modem with 14 Kbps upstream bandwidth */);
-
-	ERR_FAIL_COND_V(!host,ERR_CANT_CREATE);
+	host = enet_host_create(NULL /* create a client host */,
+			1 /* only allow 1 outgoing connection */,
+			SYSCH_MAX /* allow up to SYSCH_MAX channels to be used */,
+			p_in_bandwidth /* 56K modem with 56 Kbps downstream bandwidth */,
+			p_out_bandwidth /* 56K modem with 14 Kbps upstream bandwidth */);
 
+	ERR_FAIL_COND_V(!host, ERR_CANT_CREATE);
 
 	_setup_compressor();
 
 	ENetAddress address;
-	address.host=*((uint32_t *)p_ip.get_ipv4());
-	address.port=p_port;
+	address.host = *((uint32_t *)p_ip.get_ipv4());
+	address.port = p_port;
 
 	//enet_address_set_host (& address, "localhost");
 	//address.port = p_port;
 
-	unique_id=_gen_unique_id();
+	unique_id = _gen_unique_id();
 
 	/* Initiate the connection, allocating the enough channels */
-	ENetPeer *peer = enet_host_connect (host, & address, SYSCH_MAX, unique_id);
+	ENetPeer *peer = enet_host_connect(host, &address, SYSCH_MAX, unique_id);
 
 	if (peer == NULL) {
 		enet_host_destroy(host);
-		ERR_FAIL_COND_V(!peer,ERR_CANT_CREATE);
+		ERR_FAIL_COND_V(!peer, ERR_CANT_CREATE);
 	}
 
 	//technically safe to ignore the peer or anything else.
 
-	connection_status=CONNECTION_CONNECTING;
-	active=true;
-	server=false;
-	refuse_connections=false;
+	connection_status = CONNECTION_CONNECTING;
+	active = true;
+	server = false;
+	refuse_connections = false;
 
 	return OK;
 }
 
-void NetworkedMultiplayerENet::poll(){
+void NetworkedMultiplayerENet::poll() {
 
 	ERR_FAIL_COND(!active);
 
@@ -130,17 +128,16 @@ void NetworkedMultiplayerENet::poll(){
 		if (!host || !active) //might have been disconnected while emitting a notification
 			return;
 
-		int ret = enet_host_service (host, & event, 1);
+		int ret = enet_host_service(host, &event, 1);
 
-		if (ret<0) {
+		if (ret < 0) {
 			//error, do something?
 			break;
-		} else if (ret==0) {
+		} else if (ret == 0) {
 			break;
 		}
 
-		switch (event.type)
-		{
+		switch (event.type) {
 			case ENET_EVENT_TYPE_CONNECT: {
 				/* Store any relevant client information here. */
 
@@ -150,39 +147,39 @@ void NetworkedMultiplayerENet::poll(){
 				}
 
 				IP_Address ip;
-				ip.set_ipv4((uint8_t *)&(event.peer -> address.host));
+				ip.set_ipv4((uint8_t *)&(event.peer->address.host));
 
-				int *new_id = memnew( int );
+				int *new_id = memnew(int);
 				*new_id = event.data;
 
-				if (*new_id==0) { //data zero is sent by server (enet won't let you configure this). Server is always 1
-					*new_id=1;
+				if (*new_id == 0) { //data zero is sent by server (enet won't let you configure this). Server is always 1
+					*new_id = 1;
 				}
 
-				event.peer->data=new_id;
+				event.peer->data = new_id;
 
-				peer_map[*new_id]=event.peer;
+				peer_map[*new_id] = event.peer;
 
-				connection_status=CONNECTION_CONNECTED; //if connecting, this means it connected t something!
+				connection_status = CONNECTION_CONNECTED; //if connecting, this means it connected t something!
 
-				emit_signal("peer_connected",*new_id);
+				emit_signal("peer_connected", *new_id);
 
 				if (server) {
 					//someone connected, let it know of all the peers available
-					for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {
+					for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
 
-						if (E->key()==*new_id)
+						if (E->key() == *new_id)
 							continue;
 						//send existing peers to new peer
-						ENetPacket * packet = enet_packet_create (NULL,8,ENET_PACKET_FLAG_RELIABLE);
-						encode_uint32(SYSMSG_ADD_PEER,&packet->data[0]);
-						encode_uint32(E->key(),&packet->data[4]);
-						enet_peer_send(event.peer,SYSCH_CONFIG,packet);
+						ENetPacket *packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE);
+						encode_uint32(SYSMSG_ADD_PEER, &packet->data[0]);
+						encode_uint32(E->key(), &packet->data[4]);
+						enet_peer_send(event.peer, SYSCH_CONFIG, packet);
 						//send the new peer to existing peers
-						packet = enet_packet_create (NULL,8,ENET_PACKET_FLAG_RELIABLE);
-						encode_uint32(SYSMSG_ADD_PEER,&packet->data[0]);
-						encode_uint32(*new_id,&packet->data[4]);
-						enet_peer_send(E->get(),SYSCH_CONFIG,packet);
+						packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE);
+						encode_uint32(SYSMSG_ADD_PEER, &packet->data[0]);
+						encode_uint32(*new_id, &packet->data[4]);
+						enet_peer_send(E->get(), SYSCH_CONFIG, packet);
 					}
 				} else {
 
@@ -194,9 +191,7 @@ void NetworkedMultiplayerENet::poll(){
 
 				/* Reset the peer's client information. */
 
-				int *id = (int*)event.peer -> data;
-
-
+				int *id = (int *)event.peer->data;
 
 				if (!id) {
 					if (!server) {
@@ -206,15 +201,15 @@ void NetworkedMultiplayerENet::poll(){
 
 					if (server) {
 						//someone disconnected, let it know to everyone else
-						for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {
+						for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
 
-							if (E->key()==*id)
+							if (E->key() == *id)
 								continue;
 							//send the new peer to existing peers
-							ENetPacket* packet = enet_packet_create (NULL,8,ENET_PACKET_FLAG_RELIABLE);
-							encode_uint32(SYSMSG_REMOVE_PEER,&packet->data[0]);
-							encode_uint32(*id,&packet->data[4]);
-							enet_peer_send(E->get(),SYSCH_CONFIG,packet);
+							ENetPacket *packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE);
+							encode_uint32(SYSMSG_REMOVE_PEER, &packet->data[0]);
+							encode_uint32(*id, &packet->data[4]);
+							enet_peer_send(E->get(), SYSCH_CONFIG, packet);
 						}
 					} else if (!server) {
 						emit_signal("server_disconnected");
@@ -222,91 +217,87 @@ void NetworkedMultiplayerENet::poll(){
 						return;
 					}
 
-					emit_signal("peer_disconnected",*id);
+					emit_signal("peer_disconnected", *id);
 					peer_map.erase(*id);
-					memdelete( id );
-
+					memdelete(id);
 				}
 
-
 			} break;
 			case ENET_EVENT_TYPE_RECEIVE: {
 
-
-				if (event.channelID==SYSCH_CONFIG) {
+				if (event.channelID == SYSCH_CONFIG) {
 					//some config message
-					ERR_CONTINUE( event.packet->dataLength < 8);
+					ERR_CONTINUE(event.packet->dataLength < 8);
 
 					// Only server can send config messages
-					ERR_CONTINUE( server );
+					ERR_CONTINUE(server);
 
 					int msg = decode_uint32(&event.packet->data[0]);
 					int id = decode_uint32(&event.packet->data[4]);
 
-					switch(msg) {
+					switch (msg) {
 						case SYSMSG_ADD_PEER: {
 
-							peer_map[id]=NULL;
-							emit_signal("peer_connected",id);
+							peer_map[id] = NULL;
+							emit_signal("peer_connected", id);
 
 						} break;
 						case SYSMSG_REMOVE_PEER: {
 
 							peer_map.erase(id);
-							emit_signal("peer_disconnected",id);
+							emit_signal("peer_disconnected", id);
 						} break;
 					}
 
 					enet_packet_destroy(event.packet);
-				} else if (event.channelID < SYSCH_MAX){
+				} else if (event.channelID < SYSCH_MAX) {
 
 					Packet packet;
 					packet.packet = event.packet;
 
-					uint32_t *id = (uint32_t*)event.peer->data;
-
-					ERR_CONTINUE(event.packet->dataLength<12)
+					uint32_t *id = (uint32_t *)event.peer->data;
 
+					ERR_CONTINUE(event.packet->dataLength < 12)
 
 					uint32_t source = decode_uint32(&event.packet->data[0]);
 					int target = decode_uint32(&event.packet->data[4]);
 					uint32_t flags = decode_uint32(&event.packet->data[8]);
 
-					packet.from=source;
+					packet.from = source;
 
 					if (server) {
 						// Someone is cheating and trying to fake the source!
-						ERR_CONTINUE(source!=*id);
+						ERR_CONTINUE(source != *id);
 
-						packet.from=*id;
+						packet.from = *id;
 
-						if (target==0) {
+						if (target == 0) {
 							//re-send the everyone but sender :|
 
 							incoming_packets.push_back(packet);
 							//and make copies for sending
-							for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {
+							for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
 
-								if (uint32_t(E->key())==source) //do not resend to self
+								if (uint32_t(E->key()) == source) //do not resend to self
 									continue;
 
-								ENetPacket* packet2 = enet_packet_create (packet.packet->data,packet.packet->dataLength,flags);
+								ENetPacket *packet2 = enet_packet_create(packet.packet->data, packet.packet->dataLength, flags);
 
-								enet_peer_send(E->get(),event.channelID,packet2);
+								enet_peer_send(E->get(), event.channelID, packet2);
 							}
 
-						} else if (target<0) {
+						} else if (target < 0) {
 							//to all but one
 
 							//and make copies for sending
-							for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {
+							for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
 
-								if (uint32_t(E->key())==source || E->key()==-target) //do not resend to self, also do not send to excluded
+								if (uint32_t(E->key()) == source || E->key() == -target) //do not resend to self, also do not send to excluded
 									continue;
 
-								ENetPacket* packet2 = enet_packet_create (packet.packet->data,packet.packet->dataLength,flags);
+								ENetPacket *packet2 = enet_packet_create(packet.packet->data, packet.packet->dataLength, flags);
 
-								enet_peer_send(E->get(),event.channelID,packet2);
+								enet_peer_send(E->get(), event.channelID, packet2);
 							}
 
 							if (-target != 1) {
@@ -317,27 +308,25 @@ void NetworkedMultiplayerENet::poll(){
 								enet_packet_destroy(packet.packet);
 							}
 
-						} else if (target==1) {
+						} else if (target == 1) {
 							//to myself and only myself
 							incoming_packets.push_back(packet);
 						} else {
 							//to someone else, specifically
 							ERR_CONTINUE(!peer_map.has(target));
-							enet_peer_send(peer_map[target],event.channelID,packet.packet);
+							enet_peer_send(peer_map[target], event.channelID, packet.packet);
 						}
 					} else {
 
 						incoming_packets.push_back(packet);
 					}
 
-
 					//destroy packet later..
 				} else {
 					ERR_CONTINUE(true);
 				}
 
-
-			}break;
+			} break;
 			case ENET_EVENT_TYPE_NONE: {
 				//do nothing
 			} break;
@@ -346,7 +335,7 @@ void NetworkedMultiplayerENet::poll(){
 }
 
 bool NetworkedMultiplayerENet::is_server() const {
-	ERR_FAIL_COND_V(!active,false);
+	ERR_FAIL_COND_V(!active, false);
 
 	return server;
 }
@@ -358,115 +347,112 @@ void NetworkedMultiplayerENet::close_connection() {
 
 	_pop_current_packet();
 
-	bool peers_disconnected=false;
-	for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {
+	bool peers_disconnected = false;
+	for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
 		if (E->get()) {
-			enet_peer_disconnect_now(E->get(),unique_id);
-			peers_disconnected=true;
+			enet_peer_disconnect_now(E->get(), unique_id);
+			peers_disconnected = true;
 		}
 	}
 
 	if (peers_disconnected) {
 		enet_host_flush(host);
 		OS::get_singleton()->delay_usec(100); //wait 100ms for disconnection packets to send
-
 	}
 
 	enet_host_destroy(host);
-	active=false;
+	active = false;
 	incoming_packets.clear();
-	unique_id=1; //server is 1
-	connection_status=CONNECTION_DISCONNECTED;
+	unique_id = 1; //server is 1
+	connection_status = CONNECTION_DISCONNECTED;
 }
 
 int NetworkedMultiplayerENet::get_available_packet_count() const {
 
 	return incoming_packets.size();
 }
-Error NetworkedMultiplayerENet::get_packet(const uint8_t **r_buffer,int &r_buffer_size) const{
+Error NetworkedMultiplayerENet::get_packet(const uint8_t **r_buffer, int &r_buffer_size) const {
 
-	ERR_FAIL_COND_V(incoming_packets.size()==0,ERR_UNAVAILABLE);
+	ERR_FAIL_COND_V(incoming_packets.size() == 0, ERR_UNAVAILABLE);
 
 	_pop_current_packet();
 
 	current_packet = incoming_packets.front()->get();
 	incoming_packets.pop_front();
 
-	*r_buffer=(const uint8_t*)(&current_packet.packet->data[12]);
-	r_buffer_size=current_packet.packet->dataLength-12;
+	*r_buffer = (const uint8_t *)(&current_packet.packet->data[12]);
+	r_buffer_size = current_packet.packet->dataLength - 12;
 
 	return OK;
 }
-Error NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer,int p_buffer_size){
+Error NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer, int p_buffer_size) {
 
-	ERR_FAIL_COND_V(!active,ERR_UNCONFIGURED);
-	ERR_FAIL_COND_V(connection_status!=CONNECTION_CONNECTED,ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(!active, ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(connection_status != CONNECTION_CONNECTED, ERR_UNCONFIGURED);
 
-	int packet_flags=0;
-	int channel=SYSCH_RELIABLE;
+	int packet_flags = 0;
+	int channel = SYSCH_RELIABLE;
 
-	switch(transfer_mode) {
+	switch (transfer_mode) {
 		case TRANSFER_MODE_UNRELIABLE: {
-			packet_flags=ENET_PACKET_FLAG_UNSEQUENCED;
-			channel=SYSCH_UNRELIABLE;
+			packet_flags = ENET_PACKET_FLAG_UNSEQUENCED;
+			channel = SYSCH_UNRELIABLE;
 		} break;
 		case TRANSFER_MODE_UNRELIABLE_ORDERED: {
-			packet_flags=0;
-			channel=SYSCH_UNRELIABLE;
+			packet_flags = 0;
+			channel = SYSCH_UNRELIABLE;
 		} break;
 		case TRANSFER_MODE_RELIABLE: {
-			packet_flags=ENET_PACKET_FLAG_RELIABLE;
-			channel=SYSCH_RELIABLE;
+			packet_flags = ENET_PACKET_FLAG_RELIABLE;
+			channel = SYSCH_RELIABLE;
 		} break;
 	}
 
-	Map<int,ENetPeer*>::Element *E=NULL;
+	Map<int, ENetPeer *>::Element *E = NULL;
 
-	if (target_peer!=0) {
+	if (target_peer != 0) {
 
 		E = peer_map.find(ABS(target_peer));
 		if (!E) {
-			ERR_EXPLAIN("Invalid Target Peer: "+itos(target_peer));
+			ERR_EXPLAIN("Invalid Target Peer: " + itos(target_peer));
 			ERR_FAIL_V(ERR_INVALID_PARAMETER);
 		}
 	}
 
-	ENetPacket * packet = enet_packet_create (NULL,p_buffer_size+12,packet_flags);
-	encode_uint32(unique_id,&packet->data[0]); //source ID
-	encode_uint32(target_peer,&packet->data[4]); //dest ID
-	encode_uint32(packet_flags,&packet->data[8]); //dest ID
-	copymem(&packet->data[12],p_buffer,p_buffer_size);
+	ENetPacket *packet = enet_packet_create(NULL, p_buffer_size + 12, packet_flags);
+	encode_uint32(unique_id, &packet->data[0]); //source ID
+	encode_uint32(target_peer, &packet->data[4]); //dest ID
+	encode_uint32(packet_flags, &packet->data[8]); //dest ID
+	copymem(&packet->data[12], p_buffer, p_buffer_size);
 
 	if (server) {
 
-		if (target_peer==0) {
-			enet_host_broadcast(host,channel,packet);
-		} else if (target_peer<0) {
+		if (target_peer == 0) {
+			enet_host_broadcast(host, channel, packet);
+		} else if (target_peer < 0) {
 			//send to all but one
 			//and make copies for sending
 
-			int exclude=-target_peer;
+			int exclude = -target_peer;
 
-			for (Map<int,ENetPeer*>::Element *F=peer_map.front();F;F=F->next()) {
+			for (Map<int, ENetPeer *>::Element *F = peer_map.front(); F; F = F->next()) {
 
-				if (F->key()==exclude) // exclude packet
+				if (F->key() == exclude) // exclude packet
 					continue;
 
-				ENetPacket* packet2 = enet_packet_create (packet->data,packet->dataLength,packet_flags);
+				ENetPacket *packet2 = enet_packet_create(packet->data, packet->dataLength, packet_flags);
 
-				enet_peer_send(F->get(),channel,packet2);
+				enet_peer_send(F->get(), channel, packet2);
 			}
 
 			enet_packet_destroy(packet); //original packet no longer needed
 		} else {
-			enet_peer_send (E->get(), channel, packet);
-
+			enet_peer_send(E->get(), channel, packet);
 		}
 	} else {
 
-		ERR_FAIL_COND_V(!peer_map.has(1),ERR_BUG);
-		enet_peer_send (peer_map[1], channel, packet); //send to server for broadcast..
-
+		ERR_FAIL_COND_V(!peer_map.has(1), ERR_BUG);
+		enet_peer_send(peer_map[1], channel, packet); //send to server for broadcast..
 	}
 
 	enet_host_flush(host);
@@ -476,17 +462,16 @@ Error NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer,int p_buffer_
 
 int NetworkedMultiplayerENet::get_max_packet_size() const {
 
-	return 1<<24; //anything is good
+	return 1 << 24; //anything is good
 }
 
 void NetworkedMultiplayerENet::_pop_current_packet() const {
 
 	if (current_packet.packet) {
 		enet_packet_destroy(current_packet.packet);
-		current_packet.packet=NULL;
-		current_packet.from=0;
+		current_packet.packet = NULL;
+		current_packet.from = 0;
 	}
-
 }
 
 NetworkedMultiplayerPeer::ConnectionStatus NetworkedMultiplayerENet::get_connection_status() const {
@@ -498,24 +483,24 @@ uint32_t NetworkedMultiplayerENet::_gen_unique_id() const {
 
 	uint32_t hash = 0;
 
-	while (hash==0 || hash==1) {
+	while (hash == 0 || hash == 1) {
 
 		hash = hash_djb2_one_32(
-					(uint32_t)OS::get_singleton()->get_ticks_usec() );
+				(uint32_t)OS::get_singleton()->get_ticks_usec());
 		hash = hash_djb2_one_32(
-					(uint32_t)OS::get_singleton()->get_unix_time(), hash );
+				(uint32_t)OS::get_singleton()->get_unix_time(), hash);
 		hash = hash_djb2_one_32(
-					(uint32_t)OS::get_singleton()->get_data_dir().hash64(), hash );
+				(uint32_t)OS::get_singleton()->get_data_dir().hash64(), hash);
 		/*
 		hash = hash_djb2_one_32(
 					(uint32_t)OS::get_singleton()->get_unique_ID().hash64(), hash );
 		*/
 		hash = hash_djb2_one_32(
-					(uint32_t)((uint64_t)this), hash ); //rely on aslr heap
+				(uint32_t)((uint64_t)this), hash); //rely on aslr heap
 		hash = hash_djb2_one_32(
-					(uint32_t)((uint64_t)&hash), hash ); //rely on aslr stack
+				(uint32_t)((uint64_t)&hash), hash); //rely on aslr stack
 
-		hash=hash&0x7FFFFFFF; // make it compatible with unsigned, since negatie id is used for exclusion
+		hash = hash & 0x7FFFFFFF; // make it compatible with unsigned, since negatie id is used for exclusion
 	}
 
 	return hash;
@@ -523,13 +508,13 @@ uint32_t NetworkedMultiplayerENet::_gen_unique_id() const {
 
 int NetworkedMultiplayerENet::get_unique_id() const {
 
-	ERR_FAIL_COND_V(!active,0);
+	ERR_FAIL_COND_V(!active, 0);
 	return unique_id;
 }
 
 void NetworkedMultiplayerENet::set_refuse_new_connections(bool p_enable) {
 
-	refuse_connections=p_enable;
+	refuse_connections = p_enable;
 }
 
 bool NetworkedMultiplayerENet::is_refusing_new_connections() const {
@@ -539,79 +524,78 @@ bool NetworkedMultiplayerENet::is_refusing_new_connections() const {
 
 void NetworkedMultiplayerENet::set_compression_mode(CompressionMode p_mode) {
 
-	compression_mode=p_mode;
+	compression_mode = p_mode;
 }
 
-NetworkedMultiplayerENet::CompressionMode NetworkedMultiplayerENet::get_compression_mode() const{
+NetworkedMultiplayerENet::CompressionMode NetworkedMultiplayerENet::get_compression_mode() const {
 
 	return compression_mode;
 }
 
-size_t NetworkedMultiplayerENet::enet_compress(void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit) {
+size_t NetworkedMultiplayerENet::enet_compress(void *context, const ENetBuffer *inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 *outData, size_t outLimit) {
 
-	NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet*)(context);
+	NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet *)(context);
 
-	if (size_t(enet->src_compressor_mem.size())<inLimit) {
-		enet->src_compressor_mem.resize( inLimit );
+	if (size_t(enet->src_compressor_mem.size()) < inLimit) {
+		enet->src_compressor_mem.resize(inLimit);
 	}
 
 	int total = inLimit;
-	int ofs=0;
-	while(total) {
-		for(size_t i=0;i<inBufferCount;i++) {
-			int to_copy = MIN(total,int(inBuffers[i].dataLength));
-			copymem(&enet->src_compressor_mem[ofs],inBuffers[i].data,to_copy);
-			ofs+=to_copy;
-			total-=to_copy;
+	int ofs = 0;
+	while (total) {
+		for (size_t i = 0; i < inBufferCount; i++) {
+			int to_copy = MIN(total, int(inBuffers[i].dataLength));
+			copymem(&enet->src_compressor_mem[ofs], inBuffers[i].data, to_copy);
+			ofs += to_copy;
+			total -= to_copy;
 		}
 	}
 
 	Compression::Mode mode;
 
-	switch(enet->compression_mode) {
+	switch (enet->compression_mode) {
 		case COMPRESS_FASTLZ: {
-			mode=Compression::MODE_FASTLZ;
+			mode = Compression::MODE_FASTLZ;
 		} break;
 		case COMPRESS_ZLIB: {
-			mode=Compression::MODE_DEFLATE;
+			mode = Compression::MODE_DEFLATE;
 		} break;
 		default: { ERR_FAIL_V(0); }
 	}
 
-	int req_size = Compression::get_max_compressed_buffer_size(ofs,mode);
-	if (enet->dst_compressor_mem.size()<req_size) {
+	int req_size = Compression::get_max_compressed_buffer_size(ofs, mode);
+	if (enet->dst_compressor_mem.size() < req_size) {
 		enet->dst_compressor_mem.resize(req_size);
 	}
-	int ret=Compression::compress(enet->dst_compressor_mem.ptr(),enet->src_compressor_mem.ptr(),ofs,mode);
+	int ret = Compression::compress(enet->dst_compressor_mem.ptr(), enet->src_compressor_mem.ptr(), ofs, mode);
 
-	if (ret<0)
+	if (ret < 0)
 		return 0;
 
-
-	if (ret>int(outLimit))
+	if (ret > int(outLimit))
 		return 0; //do not bother
 
-	copymem(outData,enet->dst_compressor_mem.ptr(),ret);
+	copymem(outData, enet->dst_compressor_mem.ptr(), ret);
 
 	return ret;
 }
 
-size_t NetworkedMultiplayerENet::enet_decompress (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit){
+size_t NetworkedMultiplayerENet::enet_decompress(void *context, const enet_uint8 *inData, size_t inLimit, enet_uint8 *outData, size_t outLimit) {
 
-	NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet*)(context);
+	NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet *)(context);
 	int ret = -1;
-	switch(enet->compression_mode) {
+	switch (enet->compression_mode) {
 		case COMPRESS_FASTLZ: {
 
-			ret=Compression::decompress(outData,outLimit,inData,inLimit,Compression::MODE_FASTLZ);
+			ret = Compression::decompress(outData, outLimit, inData, inLimit, Compression::MODE_FASTLZ);
 		} break;
 		case COMPRESS_ZLIB: {
 
-			ret=Compression::decompress(outData,outLimit,inData,inLimit,Compression::MODE_DEFLATE);
+			ret = Compression::decompress(outData, outLimit, inData, inLimit, Compression::MODE_DEFLATE);
 		} break;
 		default: {}
 	}
-	if (ret<0) {
+	if (ret < 0) {
 		return 0;
 	} else {
 		return ret;
@@ -620,11 +604,11 @@ size_t NetworkedMultiplayerENet::enet_decompress (void * context, const enet_uin
 
 void NetworkedMultiplayerENet::_setup_compressor() {
 
-	switch(compression_mode) {
+	switch (compression_mode) {
 
 		case COMPRESS_NONE: {
 
-			enet_host_compress(host,NULL);
+			enet_host_compress(host, NULL);
 		} break;
 		case COMPRESS_RANGE_CODER: {
 			enet_host_compress_with_range_coder(host);
@@ -632,60 +616,58 @@ void NetworkedMultiplayerENet::_setup_compressor() {
 		case COMPRESS_FASTLZ:
 		case COMPRESS_ZLIB: {
 
-			enet_host_compress(host,&enet_compressor);
+			enet_host_compress(host, &enet_compressor);
 		} break;
 	}
 }
 
-void NetworkedMultiplayerENet::enet_compressor_destroy(void * context){
+void NetworkedMultiplayerENet::enet_compressor_destroy(void *context) {
 
 	//do none
 }
 
-
 void NetworkedMultiplayerENet::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("create_server","port","max_clients","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_server,DEFVAL(32),DEFVAL(0),DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("create_client","ip","port","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_client,DEFVAL(0),DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("close_connection"),&NetworkedMultiplayerENet::close_connection);
-	ClassDB::bind_method(D_METHOD("set_compression_mode","mode"),&NetworkedMultiplayerENet::set_compression_mode);
-	ClassDB::bind_method(D_METHOD("get_compression_mode"),&NetworkedMultiplayerENet::get_compression_mode);
-	ClassDB::bind_method(D_METHOD("set_bind_ip", "ip"),&NetworkedMultiplayerENet::set_bind_ip);
-
-	BIND_CONSTANT( COMPRESS_NONE );
-	BIND_CONSTANT( COMPRESS_RANGE_CODER );
-	BIND_CONSTANT( COMPRESS_FASTLZ );
-	BIND_CONSTANT( COMPRESS_ZLIB );
+	ClassDB::bind_method(D_METHOD("create_server", "port", "max_clients", "in_bandwidth", "out_bandwidth"), &NetworkedMultiplayerENet::create_server, DEFVAL(32), DEFVAL(0), DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("create_client", "ip", "port", "in_bandwidth", "out_bandwidth"), &NetworkedMultiplayerENet::create_client, DEFVAL(0), DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("close_connection"), &NetworkedMultiplayerENet::close_connection);
+	ClassDB::bind_method(D_METHOD("set_compression_mode", "mode"), &NetworkedMultiplayerENet::set_compression_mode);
+	ClassDB::bind_method(D_METHOD("get_compression_mode"), &NetworkedMultiplayerENet::get_compression_mode);
+	ClassDB::bind_method(D_METHOD("set_bind_ip", "ip"), &NetworkedMultiplayerENet::set_bind_ip);
+
+	BIND_CONSTANT(COMPRESS_NONE);
+	BIND_CONSTANT(COMPRESS_RANGE_CODER);
+	BIND_CONSTANT(COMPRESS_FASTLZ);
+	BIND_CONSTANT(COMPRESS_ZLIB);
 }
 
-
-NetworkedMultiplayerENet::NetworkedMultiplayerENet(){
-
-	active=false;
-	server=false;
-	refuse_connections=false;
-	unique_id=0;
-	target_peer=0;
-	current_packet.packet=NULL;
-	transfer_mode=TRANSFER_MODE_RELIABLE;
-	connection_status=CONNECTION_DISCONNECTED;
-	compression_mode=COMPRESS_NONE;
-	enet_compressor.context=this;
-	enet_compressor.compress=enet_compress;
-	enet_compressor.decompress=enet_decompress;
-	enet_compressor.destroy=enet_compressor_destroy;
-
-	bind_ip=ENET_HOST_ANY;
+NetworkedMultiplayerENet::NetworkedMultiplayerENet() {
+
+	active = false;
+	server = false;
+	refuse_connections = false;
+	unique_id = 0;
+	target_peer = 0;
+	current_packet.packet = NULL;
+	transfer_mode = TRANSFER_MODE_RELIABLE;
+	connection_status = CONNECTION_DISCONNECTED;
+	compression_mode = COMPRESS_NONE;
+	enet_compressor.context = this;
+	enet_compressor.compress = enet_compress;
+	enet_compressor.decompress = enet_decompress;
+	enet_compressor.destroy = enet_compressor_destroy;
+
+	bind_ip = ENET_HOST_ANY;
 }
 
-NetworkedMultiplayerENet::~NetworkedMultiplayerENet(){
+NetworkedMultiplayerENet::~NetworkedMultiplayerENet() {
 
 	close_connection();
 }
 
 // sets IP for ENet to bind when using create_server
 // if no IP is set, then ENet bind to ENET_HOST_ANY
-void NetworkedMultiplayerENet::set_bind_ip(const IP_Address& p_ip){
+void NetworkedMultiplayerENet::set_bind_ip(const IP_Address &p_ip) {
 	ERR_FAIL_COND(!p_ip.is_ipv4());
-	bind_ip=*(uint32_t *)p_ip.get_ipv4();
+	bind_ip = *(uint32_t *)p_ip.get_ipv4();
 }
diff --git a/modules/enet/networked_multiplayer_enet.h b/modules/enet/networked_multiplayer_enet.h
index dcf8c2429b..4e95adec10 100644
--- a/modules/enet/networked_multiplayer_enet.h
+++ b/modules/enet/networked_multiplayer_enet.h
@@ -29,13 +29,13 @@
 #ifndef NETWORKED_MULTIPLAYER_ENET_H
 #define NETWORKED_MULTIPLAYER_ENET_H
 
-#include "io/networked_multiplayer_peer.h"
 #include "enet/enet.h"
 #include "io/compression.h"
+#include "io/networked_multiplayer_peer.h"
 
 class NetworkedMultiplayerENet : public NetworkedMultiplayerPeer {
 
-	GDCLASS(NetworkedMultiplayerENet,NetworkedMultiplayerPeer)
+	GDCLASS(NetworkedMultiplayerENet, NetworkedMultiplayerPeer)
 public:
 	enum CompressionMode {
 		COMPRESS_NONE,
@@ -43,9 +43,8 @@ public:
 		COMPRESS_FASTLZ,
 		COMPRESS_ZLIB
 	};
-private:
-
 
+private:
 	enum {
 		SYSMSG_ADD_PEER,
 		SYSMSG_REMOVE_PEER
@@ -74,7 +73,7 @@ private:
 
 	ConnectionStatus connection_status;
 
-	Map<int,ENetPeer*> peer_map;
+	Map<int, ENetPeer *> peer_map;
 
 	struct Packet {
 
@@ -95,25 +94,24 @@ private:
 	Vector<uint8_t> dst_compressor_mem;
 
 	ENetCompressor enet_compressor;
-	static size_t enet_compress(void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit);
-	static size_t  enet_decompress (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit);
-	static void enet_compressor_destroy(void * context);
+	static size_t enet_compress(void *context, const ENetBuffer *inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 *outData, size_t outLimit);
+	static size_t enet_decompress(void *context, const enet_uint8 *inData, size_t inLimit, enet_uint8 *outData, size_t outLimit);
+	static void enet_compressor_destroy(void *context);
 	void _setup_compressor();
 
 	enet_uint32 bind_ip;
+
 protected:
 	static void _bind_methods();
-public:
 
+public:
 	virtual void set_transfer_mode(TransferMode p_mode);
 	virtual void set_target_peer(int p_peer);
 
-
 	virtual int get_packet_peer() const;
 
-
-	Error create_server(int p_port, int p_max_peers=32, int p_in_bandwidth=0, int p_out_bandwidth=0);
-	Error create_client(const IP_Address& p_ip, int p_port, int p_in_bandwidth=0, int p_out_bandwidth=0);
+	Error create_server(int p_port, int p_max_peers = 32, int p_in_bandwidth = 0, int p_out_bandwidth = 0);
+	Error create_client(const IP_Address &p_ip, int p_port, int p_in_bandwidth = 0, int p_out_bandwidth = 0);
 
 	void close_connection();
 
@@ -122,8 +120,8 @@ public:
 	virtual bool is_server() const;
 
 	virtual int get_available_packet_count() const;
-	virtual Error get_packet(const uint8_t **r_buffer,int &r_buffer_size) const; ///< buffer is GONE after next get_packet
-	virtual Error put_packet(const uint8_t *p_buffer,int p_buffer_size);
+	virtual Error get_packet(const uint8_t **r_buffer, int &r_buffer_size) const; ///< buffer is GONE after next get_packet
+	virtual Error put_packet(const uint8_t *p_buffer, int p_buffer_size);
 
 	virtual int get_max_packet_size() const;
 
@@ -140,10 +138,9 @@ public:
 	NetworkedMultiplayerENet();
 	~NetworkedMultiplayerENet();
 
-	void set_bind_ip(const IP_Address& p_ip);
+	void set_bind_ip(const IP_Address &p_ip);
 };
 
 VARIANT_ENUM_CAST(NetworkedMultiplayerENet::CompressionMode);
 
-
 #endif // NETWORKED_MULTIPLAYER_ENET_H
diff --git a/modules/enet/register_types.cpp b/modules/enet/register_types.cpp
index 2b4dd35d33..0dea038520 100644
--- a/modules/enet/register_types.cpp
+++ b/modules/enet/register_types.cpp
@@ -30,14 +30,14 @@
 #include "error_macros.h"
 #include "networked_multiplayer_enet.h"
 
-static bool enet_ok=false;
+static bool enet_ok = false;
 
 void register_enet_types() {
 
-	if (enet_initialize() !=0 ) {
+	if (enet_initialize() != 0) {
 		ERR_PRINT("ENet initialization failure");
 	} else {
-		enet_ok=true;
+		enet_ok = true;
 	}
 
 	ClassDB::register_class<NetworkedMultiplayerENet>();
@@ -47,5 +47,4 @@ void unregister_enet_types() {
 
 	if (enet_ok)
 		enet_deinitialize();
-
 }
diff --git a/modules/etc1/image_etc.cpp b/modules/etc1/image_etc.cpp
index 2d883bff0f..642ec027f3 100644
--- a/modules/etc1/image_etc.cpp
+++ b/modules/etc1/image_etc.cpp
@@ -28,175 +28,154 @@
 /*************************************************************************/
 #include "image_etc.h"
 #include "image.h"
-#include "rg_etc1.h"
-#include "print_string.h"
 #include "os/copymem.h"
+#include "print_string.h"
+#include "rg_etc1.h"
 static void _decompress_etc(Image *p_img) {
 
-	ERR_FAIL_COND(p_img->get_format()!=Image::FORMAT_ETC);
+	ERR_FAIL_COND(p_img->get_format() != Image::FORMAT_ETC);
 
 	int imgw = p_img->get_width();
 	int imgh = p_img->get_height();
-	PoolVector<uint8_t> src=p_img->get_data();
+	PoolVector<uint8_t> src = p_img->get_data();
 	PoolVector<uint8_t> dst;
 
 	PoolVector<uint8_t>::Read r = src.read();
 
-	int mmc=p_img->get_mipmap_count();
+	int mmc = p_img->get_mipmap_count();
 
+	for (int i = 0; i <= mmc; i++) {
 
-	for(int i=0;i<=mmc;i++) {
-
-		dst.resize(dst.size()+imgw*imgh*3);
-		const uint8_t *srcbr=&r[p_img->get_mipmap_offset(i)];
+		dst.resize(dst.size() + imgw * imgh * 3);
+		const uint8_t *srcbr = &r[p_img->get_mipmap_offset(i)];
 		PoolVector<uint8_t>::Write w = dst.write();
 
-		uint8_t *wptr = &w[dst.size()-imgw*imgh*3];
-
-		int bw=MAX(imgw/4,1);
-		int bh=MAX(imgh/4,1);
-
-		for(int y=0;y<bh;y++) {
+		uint8_t *wptr = &w[dst.size() - imgw * imgh * 3];
 
-			for(int x=0;x<bw;x++) {
+		int bw = MAX(imgw / 4, 1);
+		int bh = MAX(imgh / 4, 1);
 
-				uint8_t block[4*4*4];
+		for (int y = 0; y < bh; y++) {
 
+			for (int x = 0; x < bw; x++) {
 
-				rg_etc1::unpack_etc1_block(srcbr,(unsigned int*)block);
-				srcbr+=8;
+				uint8_t block[4 * 4 * 4];
 
-				int maxx=MIN(imgw,4);
-				int maxy=MIN(imgh,4);
+				rg_etc1::unpack_etc1_block(srcbr, (unsigned int *)block);
+				srcbr += 8;
 
-				for(int yy=0;yy<maxy;yy++) {
+				int maxx = MIN(imgw, 4);
+				int maxy = MIN(imgh, 4);
 
-					for(int xx=0;xx<maxx;xx++) {
+				for (int yy = 0; yy < maxy; yy++) {
 
-						uint32_t src_ofs = (yy*4+xx)*4;
-						uint32_t dst_ofs = ((y*4+yy)*imgw+x*4+xx)*3;
-						wptr[dst_ofs+0]=block[src_ofs+0];
-						wptr[dst_ofs+1]=block[src_ofs+1];
-						wptr[dst_ofs+2]=block[src_ofs+2];
+					for (int xx = 0; xx < maxx; xx++) {
 
+						uint32_t src_ofs = (yy * 4 + xx) * 4;
+						uint32_t dst_ofs = ((y * 4 + yy) * imgw + x * 4 + xx) * 3;
+						wptr[dst_ofs + 0] = block[src_ofs + 0];
+						wptr[dst_ofs + 1] = block[src_ofs + 1];
+						wptr[dst_ofs + 2] = block[src_ofs + 2];
 					}
 				}
-
 			}
-
 		}
 
-		imgw=MAX(1,imgw/2);
-		imgh=MAX(1,imgh/2);
+		imgw = MAX(1, imgw / 2);
+		imgh = MAX(1, imgh / 2);
 	}
 
-
-	r=PoolVector<uint8_t>::Read();
+	r = PoolVector<uint8_t>::Read();
 	//print_line("Re Creating ETC into regular image: w "+itos(p_img->get_width())+" h "+itos(p_img->get_height())+" mm "+itos(p_img->get_mipmaps()));
-	*p_img=Image(p_img->get_width(),p_img->get_height(),p_img->has_mipmaps(),Image::FORMAT_RGB8,dst);
+	*p_img = Image(p_img->get_width(), p_img->get_height(), p_img->has_mipmaps(), Image::FORMAT_RGB8, dst);
 	if (p_img->has_mipmaps())
 		p_img->generate_mipmaps();
-
-
 }
 
 static void _compress_etc(Image *p_img) {
 
 	Image img = *p_img;
 
-	int imgw=img.get_width(),imgh=img.get_height();
+	int imgw = img.get_width(), imgh = img.get_height();
 
-	ERR_FAIL_COND( nearest_power_of_2(imgw)!=imgw || nearest_power_of_2(imgh)!=imgh );
+	ERR_FAIL_COND(nearest_power_of_2(imgw) != imgw || nearest_power_of_2(imgh) != imgh);
 
-	if (img.get_format()!=Image::FORMAT_RGB8)
+	if (img.get_format() != Image::FORMAT_RGB8)
 		img.convert(Image::FORMAT_RGB8);
 
-
 	PoolVector<uint8_t> res_data;
 	PoolVector<uint8_t> dst_data;
 	PoolVector<uint8_t>::Read r = img.get_data().read();
 
-	int target_size = Image::get_image_data_size(p_img->get_width(),p_img->get_height(),Image::FORMAT_ETC,p_img->has_mipmaps()?-1:0);
-	int mmc = p_img->has_mipmaps() ? Image::get_image_required_mipmaps(p_img->get_width(),p_img->get_height(),Image::FORMAT_ETC) : 0;
+	int target_size = Image::get_image_data_size(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC, p_img->has_mipmaps() ? -1 : 0);
+	int mmc = p_img->has_mipmaps() ? Image::get_image_required_mipmaps(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC) : 0;
 
 	dst_data.resize(target_size);
-	int mc=0;
-	int ofs=0;
-	PoolVector<uint8_t>::Write w=dst_data.write();
-
+	int mc = 0;
+	int ofs = 0;
+	PoolVector<uint8_t>::Write w = dst_data.write();
 
 	rg_etc1::etc1_pack_params pp;
-	pp.m_quality=rg_etc1::cLowQuality;
-	for(int i=0;i<=mmc;i++) {
-
+	pp.m_quality = rg_etc1::cLowQuality;
+	for (int i = 0; i <= mmc; i++) {
 
-		int bw=MAX(imgw/4,1);
-		int bh=MAX(imgh/4,1);
+		int bw = MAX(imgw / 4, 1);
+		int bh = MAX(imgh / 4, 1);
 		const uint8_t *src = &r[img.get_mipmap_offset(i)];
-		int mmsize = MAX(bw,1)*MAX(bh,1)*8;
+		int mmsize = MAX(bw, 1) * MAX(bh, 1) * 8;
 
 		uint8_t *dst = &w[ofs];
-		ofs+=mmsize;
-
+		ofs += mmsize;
 
 		//print_line("bh: "+itos(bh)+" bw: "+itos(bw));
 
-		for(int y=0;y<bh;y++) {
+		for (int y = 0; y < bh; y++) {
 
-			for(int x=0;x<bw;x++) {
+			for (int x = 0; x < bw; x++) {
 
 				//print_line("x: "+itos(x)+" y: "+itos(y));
 
-				uint8_t block[4*4*4];
-				zeromem(block,4*4*4);
+				uint8_t block[4 * 4 * 4];
+				zeromem(block, 4 * 4 * 4);
 				uint8_t cblock[8];
 
-				int maxy = MIN(imgh,4);
-				int maxx = MIN(imgw,4);
-
-
-				for(int yy=0;yy<maxy;yy++) {
-
-					for(int xx=0;xx<maxx;xx++) {
+				int maxy = MIN(imgh, 4);
+				int maxx = MIN(imgw, 4);
 
+				for (int yy = 0; yy < maxy; yy++) {
 
-						uint32_t dst_ofs = (yy*4+xx)*4;
-						uint32_t src_ofs = ((y*4+yy)*imgw+x*4+xx)*3;
-						block[dst_ofs+0]=src[src_ofs+0];
-						block[dst_ofs+1]=src[src_ofs+1];
-						block[dst_ofs+2]=src[src_ofs+2];
-						block[dst_ofs+3]=255;
+					for (int xx = 0; xx < maxx; xx++) {
 
+						uint32_t dst_ofs = (yy * 4 + xx) * 4;
+						uint32_t src_ofs = ((y * 4 + yy) * imgw + x * 4 + xx) * 3;
+						block[dst_ofs + 0] = src[src_ofs + 0];
+						block[dst_ofs + 1] = src[src_ofs + 1];
+						block[dst_ofs + 2] = src[src_ofs + 2];
+						block[dst_ofs + 3] = 255;
 					}
 				}
 
-				rg_etc1::pack_etc1_block(cblock, (const unsigned int*)block, pp);
-				for(int j=0;j<8;j++) {
+				rg_etc1::pack_etc1_block(cblock, (const unsigned int *)block, pp);
+				for (int j = 0; j < 8; j++) {
 
-					dst[j]=cblock[j];
+					dst[j] = cblock[j];
 				}
 
-				dst+=8;
+				dst += 8;
 			}
-
 		}
 
-		imgw=MAX(1,imgw/2);
-		imgh=MAX(1,imgh/2);
+		imgw = MAX(1, imgw / 2);
+		imgh = MAX(1, imgh / 2);
 		mc++;
-
 	}
 
-	*p_img=Image(p_img->get_width(),p_img->get_height(),(mc-1)?true:false,Image::FORMAT_ETC,dst_data);
-
-
+	*p_img = Image(p_img->get_width(), p_img->get_height(), (mc - 1) ? true : false, Image::FORMAT_ETC, dst_data);
 }
 
 void _register_etc1_compress_func() {
 
 	rg_etc1::pack_etc1_block_init();
-	Image::_image_compress_etc_func=_compress_etc;
-	Image::_image_decompress_etc=_decompress_etc;
-
-
+	Image::_image_compress_etc_func = _compress_etc;
+	Image::_image_decompress_etc = _decompress_etc;
 }
diff --git a/modules/etc1/image_etc.h b/modules/etc1/image_etc.h
index 6ab10126f8..18461819d6 100644
--- a/modules/etc1/image_etc.h
+++ b/modules/etc1/image_etc.h
@@ -29,7 +29,6 @@
 #ifndef IMAGE_ETC1_H
 #define IMAGE_ETC1_H
 
-
 void _register_etc1_compress_func();
 
 #endif // IMAGE_ETC_H
diff --git a/modules/etc1/register_types.cpp b/modules/etc1/register_types.cpp
index d02ef83478..b3b6419d26 100644
--- a/modules/etc1/register_types.cpp
+++ b/modules/etc1/register_types.cpp
@@ -35,7 +35,7 @@ static ResourceFormatPKM *resource_loader_pkm = NULL;
 
 void register_etc1_types() {
 
-	resource_loader_pkm = memnew( ResourceFormatPKM );
+	resource_loader_pkm = memnew(ResourceFormatPKM);
 	ResourceLoader::add_resource_format_loader(resource_loader_pkm);
 
 	_register_etc1_compress_func();
diff --git a/modules/etc1/texture_loader_pkm.cpp b/modules/etc1/texture_loader_pkm.cpp
index b00e71c485..bce10e691e 100644
--- a/modules/etc1/texture_loader_pkm.cpp
+++ b/modules/etc1/texture_loader_pkm.cpp
@@ -32,38 +32,38 @@
 #include <string.h>
 
 struct ETC1Header {
-    char tag[6];			// "PKM 10"
-    uint16_t format;        // Format == number of mips (== zero)
-    uint16_t texWidth;      // Texture dimensions, multiple of 4 (big-endian)
-    uint16_t texHeight;
-    uint16_t origWidth;     // Original dimensions (big-endian)
-    uint16_t origHeight;
+	char tag[6]; // "PKM 10"
+	uint16_t format; // Format == number of mips (== zero)
+	uint16_t texWidth; // Texture dimensions, multiple of 4 (big-endian)
+	uint16_t texHeight;
+	uint16_t origWidth; // Original dimensions (big-endian)
+	uint16_t origHeight;
 };
 
-RES ResourceFormatPKM::load(const String &p_path, const String& p_original_path, Error *r_error) {
+RES ResourceFormatPKM::load(const String &p_path, const String &p_original_path, Error *r_error) {
 
 	if (r_error)
-		*r_error=ERR_CANT_OPEN;
+		*r_error = ERR_CANT_OPEN;
 
 	Error err;
-	FileAccess *f = FileAccess::open(p_path,FileAccess::READ,&err);
+	FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
 	if (!f)
 		return RES();
 
 	FileAccessRef fref(f);
 	if (r_error)
-		*r_error=ERR_FILE_CORRUPT;
+		*r_error = ERR_FILE_CORRUPT;
 
-	ERR_EXPLAIN("Unable to open PKM texture file: "+p_path);
-	ERR_FAIL_COND_V(err!=OK,RES());
+	ERR_EXPLAIN("Unable to open PKM texture file: " + p_path);
+	ERR_FAIL_COND_V(err != OK, RES());
 
 	// big endian
 	f->set_endian_swap(true);
 
 	ETC1Header h;
-	ERR_EXPLAIN("Invalid or Unsupported PKM texture file: "+p_path);
-	f->get_buffer((uint8_t *) &h.tag, sizeof(h.tag));
-	if(strncmp(h.tag, "PKM 10", sizeof(h.tag)))
+	ERR_EXPLAIN("Invalid or Unsupported PKM texture file: " + p_path);
+	f->get_buffer((uint8_t *)&h.tag, sizeof(h.tag));
+	if (strncmp(h.tag, "PKM 10", sizeof(h.tag)))
 		ERR_FAIL_V(RES());
 
 	h.format = f->get_16();
@@ -77,20 +77,20 @@ RES ResourceFormatPKM::load(const String &p_path, const String& p_original_path,
 	uint32_t size = h.texWidth * h.texHeight / 2;
 	src_data.resize(size);
 	PoolVector<uint8_t>::Write wb = src_data.write();
-	f->get_buffer(wb.ptr(),size);
-	wb=PoolVector<uint8_t>::Write();
+	f->get_buffer(wb.ptr(), size);
+	wb = PoolVector<uint8_t>::Write();
 
 	int mipmaps = h.format;
 	int width = h.origWidth;
 	int height = h.origHeight;
 
-	Image img(width,height,mipmaps,Image::FORMAT_ETC,src_data);
+	Image img(width, height, mipmaps, Image::FORMAT_ETC, src_data);
 
-	Ref<ImageTexture> texture = memnew( ImageTexture );
+	Ref<ImageTexture> texture = memnew(ImageTexture);
 	texture->create_from_image(img);
 
 	if (r_error)
-		*r_error=OK;
+		*r_error = OK;
 
 	return texture;
 }
@@ -100,14 +100,14 @@ void ResourceFormatPKM::get_recognized_extensions(List<String> *p_extensions) co
 	p_extensions->push_back("pkm");
 }
 
-bool ResourceFormatPKM::handles_type(const String& p_type) const {
+bool ResourceFormatPKM::handles_type(const String &p_type) const {
 
-	return ClassDB::is_parent_class(p_type,"Texture");
+	return ClassDB::is_parent_class(p_type, "Texture");
 }
 
 String ResourceFormatPKM::get_resource_type(const String &p_path) const {
 
-	if (p_path.get_extension().to_lower()=="pkm")
+	if (p_path.get_extension().to_lower() == "pkm")
 		return "ImageTexture";
 	return "";
 }
diff --git a/modules/etc1/texture_loader_pkm.h b/modules/etc1/texture_loader_pkm.h
index 9be7b051d3..19d15d21fc 100644
--- a/modules/etc1/texture_loader_pkm.h
+++ b/modules/etc1/texture_loader_pkm.h
@@ -29,15 +29,14 @@
 #ifndef TEXTURE_LOADER_PKM_H
 #define TEXTURE_LOADER_PKM_H
 
-#include "scene/resources/texture.h"
 #include "io/resource_loader.h"
+#include "scene/resources/texture.h"
 
-class ResourceFormatPKM : public ResourceFormatLoader{
+class ResourceFormatPKM : public ResourceFormatLoader {
 public:
-
-	virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual bool handles_type(const String& p_type) const;
+	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;
 
 	virtual ~ResourceFormatPKM() {}
diff --git a/modules/gdscript/gd_compiler.cpp b/modules/gdscript/gd_compiler.cpp
index 398c2cf82a..9591740438 100644
--- a/modules/gdscript/gd_compiler.cpp
+++ b/modules/gdscript/gd_compiler.cpp
@@ -29,53 +29,51 @@
 #include "gd_compiler.h"
 #include "gd_script.h"
 
-bool GDCompiler::_is_class_member_property(CodeGen & codegen, const StringName & p_name) {
+bool GDCompiler::_is_class_member_property(CodeGen &codegen, const StringName &p_name) {
 
 	if (!codegen.function_node || codegen.function_node->_static)
 		return false;
 
-	return _is_class_member_property(codegen.script,p_name);
+	return _is_class_member_property(codegen.script, p_name);
 }
 
-bool GDCompiler::_is_class_member_property(GDScript *owner, const StringName & p_name) {
-
+bool GDCompiler::_is_class_member_property(GDScript *owner, const StringName &p_name) {
 
 	GDScript *scr = owner;
-	GDNativeClass *nc=NULL;
-	while(scr) {
+	GDNativeClass *nc = NULL;
+	while (scr) {
 
 		if (scr->native.is_valid())
-			nc=scr->native.ptr();
-		scr=scr->_base;
+			nc = scr->native.ptr();
+		scr = scr->_base;
 	}
 
-	ERR_FAIL_COND_V(!nc,false);
+	ERR_FAIL_COND_V(!nc, false);
 
-	return ClassDB::has_property(nc->get_name(),p_name);
+	return ClassDB::has_property(nc->get_name(), p_name);
 }
 
+void GDCompiler::_set_error(const String &p_error, const GDParser::Node *p_node) {
 
-void GDCompiler::_set_error(const String& p_error,const GDParser::Node *p_node) {
-
-	if (error!="")
+	if (error != "")
 		return;
 
-	error=p_error;
+	error = p_error;
 	if (p_node) {
-		err_line=p_node->line;
-		err_column=p_node->column;
+		err_line = p_node->line;
+		err_column = p_node->column;
 	} else {
-		err_line=0;
-		err_column=0;
+		err_line = 0;
+		err_column = 0;
 	}
 }
 
-bool GDCompiler::_create_unary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level) {
+bool GDCompiler::_create_unary_operator(CodeGen &codegen, const GDParser::OperatorNode *on, Variant::Operator op, int p_stack_level) {
 
-	ERR_FAIL_COND_V(on->arguments.size()!=1,false);
+	ERR_FAIL_COND_V(on->arguments.size() != 1, false);
 
-	int src_address_a = _parse_expression(codegen,on->arguments[0],p_stack_level);
-	if (src_address_a<0)
+	int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level);
+	if (src_address_a < 0)
 		return false;
 
 	codegen.opcodes.push_back(GDFunction::OPCODE_OPERATOR); // perform operator
@@ -86,22 +84,20 @@ bool GDCompiler::_create_unary_operator(CodeGen& codegen,const GDParser::Operato
 	return true;
 }
 
-bool GDCompiler::_create_binary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level,bool p_initializer) {
-
-	ERR_FAIL_COND_V(on->arguments.size()!=2,false);
+bool GDCompiler::_create_binary_operator(CodeGen &codegen, const GDParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer) {
 
+	ERR_FAIL_COND_V(on->arguments.size() != 2, false);
 
-	int src_address_a = _parse_expression(codegen,on->arguments[0],p_stack_level,false,p_initializer);
-	if (src_address_a<0)
+	int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level, false, p_initializer);
+	if (src_address_a < 0)
 		return false;
-	if (src_address_a&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)
+	if (src_address_a & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS)
 		p_stack_level++; //uses stack for return, increase stack
 
-	int src_address_b = _parse_expression(codegen,on->arguments[1],p_stack_level,false,p_initializer);
-	if (src_address_b<0)
+	int src_address_b = _parse_expression(codegen, on->arguments[1], p_stack_level, false, p_initializer);
+	if (src_address_b < 0)
 		return false;
 
-
 	codegen.opcodes.push_back(GDFunction::OPCODE_OPERATOR); // perform operator
 	codegen.opcodes.push_back(op); //which operator
 	codegen.opcodes.push_back(src_address_a); // argument 1
@@ -109,7 +105,6 @@ bool GDCompiler::_create_binary_operator(CodeGen& codegen,const GDParser::Operat
 	return true;
 }
 
-
 /*
 int GDCompiler::_parse_subexpression(CodeGen& codegen,const GDParser::Node *p_expression) {
 
@@ -128,55 +123,52 @@ int GDCompiler::_parse_subexpression(CodeGen& codegen,const GDParser::Node *p_ex
 }
 */
 
-int GDCompiler::_parse_assign_right_expression(CodeGen& codegen,const GDParser::OperatorNode *p_expression, int p_stack_level) {
+int GDCompiler::_parse_assign_right_expression(CodeGen &codegen, const GDParser::OperatorNode *p_expression, int p_stack_level) {
 
-	Variant::Operator var_op=Variant::OP_MAX;
+	Variant::Operator var_op = Variant::OP_MAX;
 
+	switch (p_expression->op) {
 
-	switch(p_expression->op) {
-
-		case GDParser::OperatorNode::OP_ASSIGN_ADD: var_op=Variant::OP_ADD; break;
-		case GDParser::OperatorNode::OP_ASSIGN_SUB: var_op=Variant::OP_SUBSTRACT; break;
-		case GDParser::OperatorNode::OP_ASSIGN_MUL: var_op=Variant::OP_MULTIPLY; break;
-		case GDParser::OperatorNode::OP_ASSIGN_DIV: var_op=Variant::OP_DIVIDE; break;
-		case GDParser::OperatorNode::OP_ASSIGN_MOD: var_op=Variant::OP_MODULE; break;
-		case GDParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT: var_op=Variant::OP_SHIFT_LEFT; break;
-		case GDParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT: var_op=Variant::OP_SHIFT_RIGHT; break;
-		case GDParser::OperatorNode::OP_ASSIGN_BIT_AND: var_op=Variant::OP_BIT_AND; break;
-		case GDParser::OperatorNode::OP_ASSIGN_BIT_OR: var_op=Variant::OP_BIT_OR; break;
-		case GDParser::OperatorNode::OP_ASSIGN_BIT_XOR: var_op=Variant::OP_BIT_XOR; break;
+		case GDParser::OperatorNode::OP_ASSIGN_ADD: var_op = Variant::OP_ADD; break;
+		case GDParser::OperatorNode::OP_ASSIGN_SUB: var_op = Variant::OP_SUBSTRACT; break;
+		case GDParser::OperatorNode::OP_ASSIGN_MUL: var_op = Variant::OP_MULTIPLY; break;
+		case GDParser::OperatorNode::OP_ASSIGN_DIV: var_op = Variant::OP_DIVIDE; break;
+		case GDParser::OperatorNode::OP_ASSIGN_MOD: var_op = Variant::OP_MODULE; break;
+		case GDParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT: var_op = Variant::OP_SHIFT_LEFT; break;
+		case GDParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT: var_op = Variant::OP_SHIFT_RIGHT; break;
+		case GDParser::OperatorNode::OP_ASSIGN_BIT_AND: var_op = Variant::OP_BIT_AND; break;
+		case GDParser::OperatorNode::OP_ASSIGN_BIT_OR: var_op = Variant::OP_BIT_OR; break;
+		case GDParser::OperatorNode::OP_ASSIGN_BIT_XOR: var_op = Variant::OP_BIT_XOR; break;
 		case GDParser::OperatorNode::OP_INIT_ASSIGN:
 		case GDParser::OperatorNode::OP_ASSIGN: {
 
 			//none
 		} break;
-	default: {
+		default: {
 
 			ERR_FAIL_V(-1);
 		}
 	}
 
-	bool initializer = p_expression->op==GDParser::OperatorNode::OP_INIT_ASSIGN;
+	bool initializer = p_expression->op == GDParser::OperatorNode::OP_INIT_ASSIGN;
 
-	if (var_op==Variant::OP_MAX) {
+	if (var_op == Variant::OP_MAX) {
 
-		return _parse_expression(codegen,p_expression->arguments[1],p_stack_level,false,initializer);
+		return _parse_expression(codegen, p_expression->arguments[1], p_stack_level, false, initializer);
 	}
 
-	if (!_create_binary_operator(codegen,p_expression,var_op,p_stack_level,initializer))
+	if (!_create_binary_operator(codegen, p_expression, var_op, p_stack_level, initializer))
 		return -1;
 
-	int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+	int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 	codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 	codegen.alloc_stack(p_stack_level);
 	return dst_addr;
-
 }
 
-int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expression, int p_stack_level,bool p_root,bool p_initializer) {
+int GDCompiler::_parse_expression(CodeGen &codegen, const GDParser::Node *p_expression, int p_stack_level, bool p_root, bool p_initializer) {
 
-
-	switch(p_expression->type) {
+	switch (p_expression->type) {
 		//should parse variable declaration and adjust stack accordingly...
 		case GDParser::Node::TYPE_IDENTIFIER: {
 			//return identifier
@@ -185,16 +177,15 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 
 			//This could be made much simpler by just indexing "self", but done this way (with custom self-addressing modes) increases peformance a lot.
 
-			const GDParser::IdentifierNode *in = static_cast<const GDParser::IdentifierNode*>(p_expression);
+			const GDParser::IdentifierNode *in = static_cast<const GDParser::IdentifierNode *>(p_expression);
 
 			StringName identifier = in->name;
 
-
-			if (_is_class_member_property(codegen,identifier)) {
+			if (_is_class_member_property(codegen, identifier)) {
 				//get property
 				codegen.opcodes.push_back(GDFunction::OPCODE_GET_MEMBER); // perform operator
 				codegen.opcodes.push_back(codegen.get_name_map_pos(identifier)); // argument 2 (unary only takes one parameter)
-				int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+				int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 				codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 				codegen.alloc_stack(p_stack_level);
 				return dst_addr;
@@ -204,8 +195,7 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 			if (!p_initializer && codegen.stack_identifiers.has(identifier)) {
 
 				int pos = codegen.stack_identifiers[identifier];
-				return pos|(GDFunction::ADDR_TYPE_STACK_VARIABLE<<GDFunction::ADDR_BITS);
-
+				return pos | (GDFunction::ADDR_TYPE_STACK_VARIABLE << GDFunction::ADDR_BITS);
 			}
 			//TRY MEMBERS!
 			if (!codegen.function_node || !codegen.function_node->_static) {
@@ -215,7 +205,7 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 				if (codegen.script->member_indices.has(identifier)) {
 
 					int idx = codegen.script->member_indices[identifier].index;
-					return idx|(GDFunction::ADDR_TYPE_MEMBER<<GDFunction::ADDR_BITS); //argument (stack root)
+					return idx | (GDFunction::ADDR_TYPE_MEMBER << GDFunction::ADDR_BITS); //argument (stack root)
 				}
 			}
 
@@ -225,45 +215,44 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 			while (owner) {
 
 				GDScript *scr = owner;
-				GDNativeClass *nc=NULL;
-				while(scr) {
+				GDNativeClass *nc = NULL;
+				while (scr) {
 
 					if (scr->constants.has(identifier)) {
 
 						//int idx=scr->constants[identifier];
 						int idx = codegen.get_name_map_pos(identifier);
-						return idx|(GDFunction::ADDR_TYPE_CLASS_CONSTANT<<GDFunction::ADDR_BITS); //argument (stack root)
+						return idx | (GDFunction::ADDR_TYPE_CLASS_CONSTANT << GDFunction::ADDR_BITS); //argument (stack root)
 					}
 					if (scr->native.is_valid())
-						nc=scr->native.ptr();
-					scr=scr->_base;
+						nc = scr->native.ptr();
+					scr = scr->_base;
 				}
 
 				// CLASS C++ Integer Constant
 
 				if (nc) {
 
-					bool success=false;
-					int constant = ClassDB::get_integer_constant(nc->get_name(),identifier,&success);
+					bool success = false;
+					int constant = ClassDB::get_integer_constant(nc->get_name(), identifier, &success);
 					if (success) {
-						Variant key=constant;
+						Variant key = constant;
 						int idx;
 
 						if (!codegen.constant_map.has(key)) {
 
-							idx=codegen.constant_map.size();
-							codegen.constant_map[key]=idx;
+							idx = codegen.constant_map.size();
+							codegen.constant_map[key] = idx;
 
 						} else {
-							idx=codegen.constant_map[key];
+							idx = codegen.constant_map[key];
 						}
 
-						return idx|(GDFunction::ADDR_TYPE_LOCAL_CONSTANT<<GDFunction::ADDR_BITS); //make it a local constant (faster access)
+						return idx | (GDFunction::ADDR_TYPE_LOCAL_CONSTANT << GDFunction::ADDR_BITS); //make it a local constant (faster access)
 					}
-
 				}
 
-				owner=owner->_owner;
+				owner = owner->_owner;
 			}
 
 			/*
@@ -278,58 +267,55 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 			if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
 
 				int idx = GDScriptLanguage::get_singleton()->get_global_map()[identifier];
-				return idx|(GDFunction::ADDR_TYPE_GLOBAL<<GDFunction::ADDR_BITS); //argument (stack root)
+				return idx | (GDFunction::ADDR_TYPE_GLOBAL << GDFunction::ADDR_BITS); //argument (stack root)
 			}
 
 			//not found, error
 
-			_set_error("Identifier not found: "+String(identifier),p_expression);
+			_set_error("Identifier not found: " + String(identifier), p_expression);
 
 			return -1;
 
-
 		} break;
 		case GDParser::Node::TYPE_CONSTANT: {
 			//return constant
-			const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode*>(p_expression);
-
+			const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode *>(p_expression);
 
 			int idx;
 
 			if (!codegen.constant_map.has(cn->value)) {
 
-				idx=codegen.constant_map.size();
-				codegen.constant_map[cn->value]=idx;
+				idx = codegen.constant_map.size();
+				codegen.constant_map[cn->value] = idx;
 
 			} else {
-				idx=codegen.constant_map[cn->value];
+				idx = codegen.constant_map[cn->value];
 			}
 
-
-			return idx|(GDFunction::ADDR_TYPE_LOCAL_CONSTANT<<GDFunction::ADDR_BITS); //argument (stack root)
+			return idx | (GDFunction::ADDR_TYPE_LOCAL_CONSTANT << GDFunction::ADDR_BITS); //argument (stack root)
 
 		} break;
 		case GDParser::Node::TYPE_SELF: {
 			//return constant
 			if (codegen.function_node && codegen.function_node->_static) {
-				_set_error("'self' not present in static function!",p_expression);
+				_set_error("'self' not present in static function!", p_expression);
 				return -1;
 			}
-			return (GDFunction::ADDR_TYPE_SELF<<GDFunction::ADDR_BITS);
+			return (GDFunction::ADDR_TYPE_SELF << GDFunction::ADDR_BITS);
 		} break;
 		case GDParser::Node::TYPE_ARRAY: {
 
-			const GDParser::ArrayNode *an = static_cast<const GDParser::ArrayNode*>(p_expression);
+			const GDParser::ArrayNode *an = static_cast<const GDParser::ArrayNode *>(p_expression);
 			Vector<int> values;
 
-			int slevel=p_stack_level;
+			int slevel = p_stack_level;
 
-			for(int i=0;i<an->elements.size();i++) {
+			for (int i = 0; i < an->elements.size(); i++) {
 
-				int ret = _parse_expression(codegen,an->elements[i],slevel);
-				if (ret<0)
+				int ret = _parse_expression(codegen, an->elements[i], slevel);
+				if (ret < 0)
 					return ret;
-				if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+				if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 					slevel++;
 					codegen.alloc_stack(slevel);
 				}
@@ -339,10 +325,10 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 
 			codegen.opcodes.push_back(GDFunction::OPCODE_CONSTRUCT_ARRAY);
 			codegen.opcodes.push_back(values.size());
-			for(int i=0;i<values.size();i++)
+			for (int i = 0; i < values.size(); i++)
 				codegen.opcodes.push_back(values[i]);
 
-			int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+			int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 			codegen.alloc_stack(p_stack_level);
 			return dst_addr;
@@ -350,27 +336,27 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 		} break;
 		case GDParser::Node::TYPE_DICTIONARY: {
 
-			const GDParser::DictionaryNode *dn = static_cast<const GDParser::DictionaryNode*>(p_expression);
+			const GDParser::DictionaryNode *dn = static_cast<const GDParser::DictionaryNode *>(p_expression);
 			Vector<int> values;
 
-			int slevel=p_stack_level;
+			int slevel = p_stack_level;
 
-			for(int i=0;i<dn->elements.size();i++) {
+			for (int i = 0; i < dn->elements.size(); i++) {
 
-				int ret = _parse_expression(codegen,dn->elements[i].key,slevel);
-				if (ret<0)
+				int ret = _parse_expression(codegen, dn->elements[i].key, slevel);
+				if (ret < 0)
 					return ret;
-				if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+				if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 					slevel++;
 					codegen.alloc_stack(slevel);
 				}
 
 				values.push_back(ret);
 
-				ret = _parse_expression(codegen,dn->elements[i].value,slevel);
-				if (ret<0)
+				ret = _parse_expression(codegen, dn->elements[i].value, slevel);
+				if (ret < 0)
 					return ret;
-				if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+				if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 					slevel++;
 					codegen.alloc_stack(slevel);
 				}
@@ -380,10 +366,10 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 
 			codegen.opcodes.push_back(GDFunction::OPCODE_CONSTRUCT_DICTIONARY);
 			codegen.opcodes.push_back(dn->elements.size());
-			for(int i=0;i<values.size();i++)
+			for (int i = 0; i < values.size(); i++)
 				codegen.opcodes.push_back(values[i]);
 
-			int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+			int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 			codegen.alloc_stack(p_stack_level);
 			return dst_addr;
@@ -392,27 +378,24 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 		case GDParser::Node::TYPE_OPERATOR: {
 			//hell breaks loose
 
-			const GDParser::OperatorNode *on = static_cast<const GDParser::OperatorNode*>(p_expression);
-			switch(on->op) {
-
+			const GDParser::OperatorNode *on = static_cast<const GDParser::OperatorNode *>(p_expression);
+			switch (on->op) {
 
 				//call/constructor operator
 				case GDParser::OperatorNode::OP_PARENT_CALL: {
 
-
-					ERR_FAIL_COND_V(on->arguments.size()<1,-1);
+					ERR_FAIL_COND_V(on->arguments.size() < 1, -1);
 
 					const GDParser::IdentifierNode *in = (const GDParser::IdentifierNode *)on->arguments[0];
 
-
 					Vector<int> arguments;
 					int slevel = p_stack_level;
-					for(int i=1;i<on->arguments.size();i++) {
+					for (int i = 1; i < on->arguments.size(); i++) {
 
-						int ret = _parse_expression(codegen,on->arguments[i],slevel);
-						if (ret<0)
+						int ret = _parse_expression(codegen, on->arguments[i], slevel);
+						if (ret < 0)
 							return ret;
-						if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+						if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
@@ -425,27 +408,27 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 					codegen.opcodes.push_back(codegen.get_name_map_pos(in->name)); //instance
 					codegen.opcodes.push_back(arguments.size()); //argument count
 					codegen.alloc_call(arguments.size());
-					for(int i=0;i<arguments.size();i++)
+					for (int i = 0; i < arguments.size(); i++)
 						codegen.opcodes.push_back(arguments[i]); //arguments
 
 				} break;
 				case GDParser::OperatorNode::OP_CALL: {
 
-					if (on->arguments[0]->type==GDParser::Node::TYPE_TYPE) {
+					if (on->arguments[0]->type == GDParser::Node::TYPE_TYPE) {
 						//construct a basic type
-						ERR_FAIL_COND_V(on->arguments.size()<1,-1);
+						ERR_FAIL_COND_V(on->arguments.size() < 1, -1);
 
 						const GDParser::TypeNode *tn = (const GDParser::TypeNode *)on->arguments[0];
 						int vtype = tn->vtype;
 
 						Vector<int> arguments;
 						int slevel = p_stack_level;
-						for(int i=1;i<on->arguments.size();i++) {
+						for (int i = 1; i < on->arguments.size(); i++) {
 
-							int ret = _parse_expression(codegen,on->arguments[i],slevel);
-							if (ret<0)
+							int ret = _parse_expression(codegen, on->arguments[i], slevel);
+							if (ret < 0)
 								return ret;
-							if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+							if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 								slevel++;
 								codegen.alloc_stack(slevel);
 							}
@@ -457,24 +440,23 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 						codegen.opcodes.push_back(vtype); //instance
 						codegen.opcodes.push_back(arguments.size()); //argument count
 						codegen.alloc_call(arguments.size());
-						for(int i=0;i<arguments.size();i++)
+						for (int i = 0; i < arguments.size(); i++)
 							codegen.opcodes.push_back(arguments[i]); //arguments
 
-					} else if (on->arguments[0]->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
+					} else if (on->arguments[0]->type == GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
 						//built in function
 
-						ERR_FAIL_COND_V(on->arguments.size()<1,-1);
-
+						ERR_FAIL_COND_V(on->arguments.size() < 1, -1);
 
 						Vector<int> arguments;
 						int slevel = p_stack_level;
-						for(int i=1;i<on->arguments.size();i++) {
+						for (int i = 1; i < on->arguments.size(); i++) {
 
-							int ret = _parse_expression(codegen,on->arguments[i],slevel);
-							if (ret<0)
+							int ret = _parse_expression(codegen, on->arguments[i], slevel);
+							if (ret < 0)
 								return ret;
 
-							if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+							if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 								slevel++;
 								codegen.alloc_stack(slevel);
 							}
@@ -482,79 +464,74 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 							arguments.push_back(ret);
 						}
 
-
 						codegen.opcodes.push_back(GDFunction::OPCODE_CALL_BUILT_IN);
-						codegen.opcodes.push_back(static_cast<const GDParser::BuiltInFunctionNode*>(on->arguments[0])->function);
-						codegen.opcodes.push_back(on->arguments.size()-1);
-						codegen.alloc_call(on->arguments.size()-1);
-						for(int i=0;i<arguments.size();i++)
+						codegen.opcodes.push_back(static_cast<const GDParser::BuiltInFunctionNode *>(on->arguments[0])->function);
+						codegen.opcodes.push_back(on->arguments.size() - 1);
+						codegen.alloc_call(on->arguments.size() - 1);
+						for (int i = 0; i < arguments.size(); i++)
 							codegen.opcodes.push_back(arguments[i]);
 
 					} else {
 						//regular function
-						ERR_FAIL_COND_V(on->arguments.size()<2,-1);
+						ERR_FAIL_COND_V(on->arguments.size() < 2, -1);
 
 						const GDParser::Node *instance = on->arguments[0];
 
-						if (instance->type==GDParser::Node::TYPE_SELF) {
+						if (instance->type == GDParser::Node::TYPE_SELF) {
 							//room for optimization
-
 						}
 
-
 						Vector<int> arguments;
 						int slevel = p_stack_level;
 
-						for(int i=0;i<on->arguments.size();i++) {
+						for (int i = 0; i < on->arguments.size(); i++) {
 
 							int ret;
 
-							if (i==0 && on->arguments[i]->type==GDParser::Node::TYPE_SELF && codegen.function_node && codegen.function_node->_static) {
+							if (i == 0 && on->arguments[i]->type == GDParser::Node::TYPE_SELF && codegen.function_node && codegen.function_node->_static) {
 								//static call to self
-								ret=(GDFunction::ADDR_TYPE_CLASS<<GDFunction::ADDR_BITS);
-							} else if (i==1) {
+								ret = (GDFunction::ADDR_TYPE_CLASS << GDFunction::ADDR_BITS);
+							} else if (i == 1) {
 
-								if (on->arguments[i]->type!=GDParser::Node::TYPE_IDENTIFIER) {
-									_set_error("Attempt to call a non-identifier.",on);
+								if (on->arguments[i]->type != GDParser::Node::TYPE_IDENTIFIER) {
+									_set_error("Attempt to call a non-identifier.", on);
 									return -1;
 								}
-								GDParser::IdentifierNode *id = static_cast<GDParser::IdentifierNode*>(on->arguments[i]);
-								ret=codegen.get_name_map_pos(id->name);
+								GDParser::IdentifierNode *id = static_cast<GDParser::IdentifierNode *>(on->arguments[i]);
+								ret = codegen.get_name_map_pos(id->name);
 
 							} else {
 
-								ret = _parse_expression(codegen,on->arguments[i],slevel);
-								if (ret<0)
+								ret = _parse_expression(codegen, on->arguments[i], slevel);
+								if (ret < 0)
 									return ret;
-								if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+								if (ret & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 									slevel++;
 									codegen.alloc_stack(slevel);
 								}
 							}
 							arguments.push_back(ret);
-
 						}
 
-						codegen.opcodes.push_back(p_root?GDFunction::OPCODE_CALL:GDFunction::OPCODE_CALL_RETURN); // perform operator
-						codegen.opcodes.push_back(on->arguments.size()-2);
-						codegen.alloc_call(on->arguments.size()-2);
-						for(int i=0;i<arguments.size();i++)
+						codegen.opcodes.push_back(p_root ? GDFunction::OPCODE_CALL : GDFunction::OPCODE_CALL_RETURN); // perform operator
+						codegen.opcodes.push_back(on->arguments.size() - 2);
+						codegen.alloc_call(on->arguments.size() - 2);
+						for (int i = 0; i < arguments.size(); i++)
 							codegen.opcodes.push_back(arguments[i]);
 					}
 				} break;
 				case GDParser::OperatorNode::OP_YIELD: {
 
-
-					ERR_FAIL_COND_V(on->arguments.size() && on->arguments.size()!=2,-1);
+					ERR_FAIL_COND_V(on->arguments.size() && on->arguments.size() != 2, -1);
 
 					Vector<int> arguments;
 					int slevel = p_stack_level;
-					for(int i=0;i<on->arguments.size();i++) {
+					for (int i = 0; i < on->arguments.size(); i++) {
 
-						int ret = _parse_expression(codegen,on->arguments[i],slevel);
-						if (ret<0)
+						int ret = _parse_expression(codegen, on->arguments[i], slevel);
+						if (ret < 0)
 							return ret;
-						if (ret&(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)) {
+						if (ret & (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS)) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
@@ -562,8 +539,8 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 					}
 
 					//push call bytecode
-					codegen.opcodes.push_back(arguments.size()==0?GDFunction::OPCODE_YIELD:GDFunction::OPCODE_YIELD_SIGNAL); // basic type constructor
-					for(int i=0;i<arguments.size();i++)
+					codegen.opcodes.push_back(arguments.size() == 0 ? GDFunction::OPCODE_YIELD : GDFunction::OPCODE_YIELD_SIGNAL); // basic type constructor
+					for (int i = 0; i < arguments.size(); i++)
 						codegen.opcodes.push_back(arguments[i]); //arguments
 					codegen.opcodes.push_back(GDFunction::OPCODE_YIELD_RESUME);
 					//next will be where to place the result :)
@@ -574,60 +551,60 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 				case GDParser::OperatorNode::OP_INDEX:
 				case GDParser::OperatorNode::OP_INDEX_NAMED: {
 
-					ERR_FAIL_COND_V(on->arguments.size()!=2,-1);
+					ERR_FAIL_COND_V(on->arguments.size() != 2, -1);
 
 					int slevel = p_stack_level;
-					bool named=(on->op==GDParser::OperatorNode::OP_INDEX_NAMED);
+					bool named = (on->op == GDParser::OperatorNode::OP_INDEX_NAMED);
 
-					int from = _parse_expression(codegen,on->arguments[0],slevel);
-					if (from<0)
+					int from = _parse_expression(codegen, on->arguments[0], slevel);
+					if (from < 0)
 						return from;
 
 					int index;
 					if (named) {
-						if (on->arguments[0]->type==GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
+						if (on->arguments[0]->type == GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
 
-							GDParser::IdentifierNode* identifier = static_cast<GDParser::IdentifierNode*>(on->arguments[1]);
-							const Map<StringName,GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(identifier->name);
+							GDParser::IdentifierNode *identifier = static_cast<GDParser::IdentifierNode *>(on->arguments[1]);
+							const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(identifier->name);
 
 #ifdef DEBUG_ENABLED
-							if (MI && MI->get().getter==codegen.function_node->name) {
-								String n = static_cast<GDParser::IdentifierNode*>(on->arguments[1])->name;
-								_set_error("Must use '"+n+"' instead of 'self."+n+"' in getter.",on);
+							if (MI && MI->get().getter == codegen.function_node->name) {
+								String n = static_cast<GDParser::IdentifierNode *>(on->arguments[1])->name;
+								_set_error("Must use '" + n + "' instead of 'self." + n + "' in getter.", on);
 								return -1;
 							}
 #endif
 
-							if (MI && MI->get().getter=="") {
+							if (MI && MI->get().getter == "") {
 								// Faster than indexing self (as if no self. had been used)
-								return (MI->get().index)|(GDFunction::ADDR_TYPE_MEMBER<<GDFunction::ADDR_BITS);
+								return (MI->get().index) | (GDFunction::ADDR_TYPE_MEMBER << GDFunction::ADDR_BITS);
 							}
 						}
 
-						index=codegen.get_name_map_pos(static_cast<GDParser::IdentifierNode*>(on->arguments[1])->name);
+						index = codegen.get_name_map_pos(static_cast<GDParser::IdentifierNode *>(on->arguments[1])->name);
 
 					} else {
 
-						if (on->arguments[1]->type==GDParser::Node::TYPE_CONSTANT && static_cast<const GDParser::ConstantNode*>(on->arguments[1])->value.get_type()==Variant::STRING) {
+						if (on->arguments[1]->type == GDParser::Node::TYPE_CONSTANT && static_cast<const GDParser::ConstantNode *>(on->arguments[1])->value.get_type() == Variant::STRING) {
 							//also, somehow, named (speed up anyway)
-							StringName name = static_cast<const GDParser::ConstantNode*>(on->arguments[1])->value;
-							index=codegen.get_name_map_pos(name);
-							named=true;
+							StringName name = static_cast<const GDParser::ConstantNode *>(on->arguments[1])->value;
+							index = codegen.get_name_map_pos(name);
+							named = true;
 
 						} else {
 							//regular indexing
-							if (from&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+							if (from & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 								slevel++;
 								codegen.alloc_stack(slevel);
 							}
 
-							index = _parse_expression(codegen,on->arguments[1],slevel);
-							if (index<0)
+							index = _parse_expression(codegen, on->arguments[1], slevel);
+							if (index < 0)
 								return index;
 						}
 					}
 
-					codegen.opcodes.push_back(named?GDFunction::OPCODE_GET_NAMED:GDFunction::OPCODE_GET); // perform operator
+					codegen.opcodes.push_back(named ? GDFunction::OPCODE_GET_NAMED : GDFunction::OPCODE_GET); // perform operator
 					codegen.opcodes.push_back(from); // argument 1
 					codegen.opcodes.push_back(index); // argument 2 (unary only takes one parameter)
 
@@ -636,66 +613,66 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 
 					// AND operator with early out on failure
 
-					int res = _parse_expression(codegen,on->arguments[0],p_stack_level);
-					if (res<0)
+					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
+					if (res < 0)
 						return res;
 					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT);
 					codegen.opcodes.push_back(res);
-					int jump_fail_pos=codegen.opcodes.size();
+					int jump_fail_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
-					res = _parse_expression(codegen,on->arguments[1],p_stack_level);
-					if (res<0)
+					res = _parse_expression(codegen, on->arguments[1], p_stack_level);
+					if (res < 0)
 						return res;
 
 					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT);
 					codegen.opcodes.push_back(res);
-					int jump_fail_pos2=codegen.opcodes.size();
+					int jump_fail_pos2 = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
 					codegen.alloc_stack(p_stack_level); //it will be used..
 					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_TRUE);
-					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+					codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
-					codegen.opcodes.push_back(codegen.opcodes.size()+3);
-					codegen.opcodes[jump_fail_pos]=codegen.opcodes.size();
-					codegen.opcodes[jump_fail_pos2]=codegen.opcodes.size();
+					codegen.opcodes.push_back(codegen.opcodes.size() + 3);
+					codegen.opcodes[jump_fail_pos] = codegen.opcodes.size();
+					codegen.opcodes[jump_fail_pos2] = codegen.opcodes.size();
 					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_FALSE);
-					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
-					return p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS;
+					codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
+					return p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS;
 
 				} break;
 				case GDParser::OperatorNode::OP_OR: {
 
 					// OR operator with early out on success
 
-					int res = _parse_expression(codegen,on->arguments[0],p_stack_level);
-					if (res<0)
+					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
+					if (res < 0)
 						return res;
 					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF);
 					codegen.opcodes.push_back(res);
-					int jump_success_pos=codegen.opcodes.size();
+					int jump_success_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
-					res = _parse_expression(codegen,on->arguments[1],p_stack_level);
-					if (res<0)
+					res = _parse_expression(codegen, on->arguments[1], p_stack_level);
+					if (res < 0)
 						return res;
 
 					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF);
 					codegen.opcodes.push_back(res);
-					int jump_success_pos2=codegen.opcodes.size();
+					int jump_success_pos2 = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
 					codegen.alloc_stack(p_stack_level); //it will be used..
 					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_FALSE);
-					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+					codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
-					codegen.opcodes.push_back(codegen.opcodes.size()+3);
-					codegen.opcodes[jump_success_pos]=codegen.opcodes.size();
-					codegen.opcodes[jump_success_pos2]=codegen.opcodes.size();
+					codegen.opcodes.push_back(codegen.opcodes.size() + 3);
+					codegen.opcodes[jump_success_pos] = codegen.opcodes.size();
+					codegen.opcodes[jump_success_pos2] = codegen.opcodes.size();
 					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_TRUE);
-					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
-					return p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS;
+					codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
+					return p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS;
 
 				} break;
 				// ternary operators
@@ -703,70 +680,113 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 
 					// x IF a ELSE y operator with early out on failure
 
-					int res = _parse_expression(codegen,on->arguments[0],p_stack_level);
-					if (res<0)
+					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
+					if (res < 0)
 						return res;
 					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT);
 					codegen.opcodes.push_back(res);
-					int jump_fail_pos=codegen.opcodes.size();
+					int jump_fail_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
-
-					res = _parse_expression(codegen,on->arguments[1],p_stack_level);
-					if (res<0)
+					res = _parse_expression(codegen, on->arguments[1], p_stack_level);
+					if (res < 0)
 						return res;
-					
+
 					codegen.alloc_stack(p_stack_level); //it will be used..
 					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN);
-					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+					codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 					codegen.opcodes.push_back(res);
 					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
-					int jump_past_pos=codegen.opcodes.size();
+					int jump_past_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
-					
-					codegen.opcodes[jump_fail_pos]=codegen.opcodes.size();
-					res = _parse_expression(codegen,on->arguments[2],p_stack_level);
-					if (res<0)
+
+					codegen.opcodes[jump_fail_pos] = codegen.opcodes.size();
+					res = _parse_expression(codegen, on->arguments[2], p_stack_level);
+					if (res < 0)
 						return res;
-					
+
 					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN);
-					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+					codegen.opcodes.push_back(p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 					codegen.opcodes.push_back(res);
-					
-					codegen.opcodes[jump_past_pos]=codegen.opcodes.size();
-					
-					return p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS;
+
+					codegen.opcodes[jump_past_pos] = codegen.opcodes.size();
+
+					return p_stack_level | GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS;
 
 				} break;
 				//unary operators
-				case GDParser::OperatorNode::OP_NEG: { if (!_create_unary_operator(codegen,on,Variant::OP_NEGATE,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_NOT: { if (!_create_unary_operator(codegen,on,Variant::OP_NOT,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_BIT_INVERT: { if (!_create_unary_operator(codegen,on,Variant::OP_BIT_NEGATE,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_PREINC: { } break; //?
-				case GDParser::OperatorNode::OP_PREDEC: { } break;
-				case GDParser::OperatorNode::OP_INC: { } break;
-				case GDParser::OperatorNode::OP_DEC: { } break;
+				case GDParser::OperatorNode::OP_NEG: {
+					if (!_create_unary_operator(codegen, on, Variant::OP_NEGATE, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_NOT: {
+					if (!_create_unary_operator(codegen, on, Variant::OP_NOT, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_BIT_INVERT: {
+					if (!_create_unary_operator(codegen, on, Variant::OP_BIT_NEGATE, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_PREINC: {
+				} break; //?
+				case GDParser::OperatorNode::OP_PREDEC: {
+				} break;
+				case GDParser::OperatorNode::OP_INC: {
+				} break;
+				case GDParser::OperatorNode::OP_DEC: {
+				} break;
 				//binary operators (in precedence order)
-				case GDParser::OperatorNode::OP_IN: { if (!_create_binary_operator(codegen,on,Variant::OP_IN,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_EQUAL,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_NOT_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_NOT_EQUAL,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_LESS: { if (!_create_binary_operator(codegen,on,Variant::OP_LESS,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_LESS_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_LESS_EQUAL,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_GREATER: { if (!_create_binary_operator(codegen,on,Variant::OP_GREATER,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_GREATER_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_GREATER_EQUAL,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_ADD: { if (!_create_binary_operator(codegen,on,Variant::OP_ADD,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_SUB: { if (!_create_binary_operator(codegen,on,Variant::OP_SUBSTRACT,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_MUL: { if (!_create_binary_operator(codegen,on,Variant::OP_MULTIPLY,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_DIV: { if (!_create_binary_operator(codegen,on,Variant::OP_DIVIDE,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_MOD: { if (!_create_binary_operator(codegen,on,Variant::OP_MODULE,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_IN: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_IN, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_EQUAL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_EQUAL, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_NOT_EQUAL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_NOT_EQUAL, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_LESS: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_LESS, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_LESS_EQUAL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_LESS_EQUAL, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_GREATER: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_GREATER_EQUAL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER_EQUAL, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_ADD: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_ADD, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_SUB: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_SUBSTRACT, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_MUL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_MULTIPLY, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_DIV: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_DIVIDE, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_MOD: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_MODULE, p_stack_level)) return -1;
+				} break;
 				//case GDParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break;
 				//case GDParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_BIT_AND: { if (!_create_binary_operator(codegen,on,Variant::OP_BIT_AND,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_BIT_OR: { if (!_create_binary_operator(codegen,on,Variant::OP_BIT_OR,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_BIT_XOR: { if (!_create_binary_operator(codegen,on,Variant::OP_BIT_XOR,p_stack_level)) return -1;} break;
-                //shift
-				case GDParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break;
-				case GDParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_BIT_AND: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_AND, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_BIT_OR: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_OR, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_BIT_XOR: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_XOR, p_stack_level)) return -1;
+				} break;
+				//shift
+				case GDParser::OperatorNode::OP_SHIFT_LEFT: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_LEFT, p_stack_level)) return -1;
+				} break;
+				case GDParser::OperatorNode::OP_SHIFT_RIGHT: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_RIGHT, p_stack_level)) return -1;
+				} break;
 				//assignment operators
 				case GDParser::OperatorNode::OP_ASSIGN_ADD:
 				case GDParser::OperatorNode::OP_ASSIGN_SUB:
@@ -781,63 +801,57 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 				case GDParser::OperatorNode::OP_INIT_ASSIGN:
 				case GDParser::OperatorNode::OP_ASSIGN: {
 
-					ERR_FAIL_COND_V(on->arguments.size()!=2,-1);
-
-
-					if (on->arguments[0]->type==GDParser::Node::TYPE_OPERATOR && (static_cast<GDParser::OperatorNode*>(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX || static_cast<GDParser::OperatorNode*>(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX_NAMED)) {
-						//SET (chained) MODE!!
+					ERR_FAIL_COND_V(on->arguments.size() != 2, -1);
 
+					if (on->arguments[0]->type == GDParser::Node::TYPE_OPERATOR && (static_cast<GDParser::OperatorNode *>(on->arguments[0])->op == GDParser::OperatorNode::OP_INDEX || static_cast<GDParser::OperatorNode *>(on->arguments[0])->op == GDParser::OperatorNode::OP_INDEX_NAMED)) {
+//SET (chained) MODE!!
 
 #ifdef DEBUG_ENABLED
-						if (static_cast<GDParser::OperatorNode*>(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX_NAMED) {
-							const GDParser::OperatorNode* inon = static_cast<GDParser::OperatorNode*>(on->arguments[0]);
-
+						if (static_cast<GDParser::OperatorNode *>(on->arguments[0])->op == GDParser::OperatorNode::OP_INDEX_NAMED) {
+							const GDParser::OperatorNode *inon = static_cast<GDParser::OperatorNode *>(on->arguments[0]);
 
-							if (inon->arguments[0]->type==GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
+							if (inon->arguments[0]->type == GDParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
 
-								const Map<StringName,GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(static_cast<GDParser::IdentifierNode*>(inon->arguments[1])->name);
-								if (MI && MI->get().setter==codegen.function_node->name) {
-									String n = static_cast<GDParser::IdentifierNode*>(inon->arguments[1])->name;
-									_set_error("Must use '"+n+"' instead of 'self."+n+"' in setter.",inon);
+								const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(static_cast<GDParser::IdentifierNode *>(inon->arguments[1])->name);
+								if (MI && MI->get().setter == codegen.function_node->name) {
+									String n = static_cast<GDParser::IdentifierNode *>(inon->arguments[1])->name;
+									_set_error("Must use '" + n + "' instead of 'self." + n + "' in setter.", inon);
 									return -1;
 								}
 							}
 						}
 #endif
 
+						int slevel = p_stack_level;
 
-						int slevel=p_stack_level;
-
-						GDParser::OperatorNode* op = static_cast<GDParser::OperatorNode*>(on->arguments[0]);
+						GDParser::OperatorNode *op = static_cast<GDParser::OperatorNode *>(on->arguments[0]);
 
 						/* Find chain of sets */
 
 						StringName assign_property;
 
-						List<GDParser::OperatorNode*> chain;
+						List<GDParser::OperatorNode *> chain;
 
 						{
 							//create get/set chain
-							GDParser::OperatorNode* n=op;
-							while(true) {
+							GDParser::OperatorNode *n = op;
+							while (true) {
 
 								chain.push_back(n);
-								if (n->arguments[0]->type!=GDParser::Node::TYPE_OPERATOR) {
+								if (n->arguments[0]->type != GDParser::Node::TYPE_OPERATOR) {
 
 									//check for a built-in property
-									if (n->arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER) {
+									if (n->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER) {
 
-										GDParser::IdentifierNode *identifier = static_cast<GDParser::IdentifierNode*>(n->arguments[0]);
-										if (_is_class_member_property(codegen,identifier->name)) {
+										GDParser::IdentifierNode *identifier = static_cast<GDParser::IdentifierNode *>(n->arguments[0]);
+										if (_is_class_member_property(codegen, identifier->name)) {
 											assign_property = identifier->name;
-
 										}
-
 									}
 									break;
 								}
-								n = static_cast<GDParser::OperatorNode*>(n->arguments[0]);
-								if (n->op!=GDParser::OperatorNode::OP_INDEX && n->op!=GDParser::OperatorNode::OP_INDEX_NAMED)
+								n = static_cast<GDParser::OperatorNode *>(n->arguments[0]);
+								if (n->op != GDParser::OperatorNode::OP_INDEX && n->op != GDParser::OperatorNode::OP_INDEX_NAMED)
 									break;
 							}
 						}
@@ -845,23 +859,21 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 						/* Chain of gets */
 
 						//get at (potential) root stack pos, so it can be returned
-						int prev_pos = _parse_expression(codegen,chain.back()->get()->arguments[0],slevel);
-						if (prev_pos<0)
+						int prev_pos = _parse_expression(codegen, chain.back()->get()->arguments[0], slevel);
+						if (prev_pos < 0)
 							return prev_pos;
-						int retval=prev_pos;
+						int retval = prev_pos;
 
 						//print_line("retval: "+itos(retval));
 
-						if (retval&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+						if (retval & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
 
-
 						Vector<int> setchain;
 
-
-						if (assign_property!=StringName()) {
+						if (assign_property != StringName()) {
 
 							// recover and assign at the end, this allows stuff like
 							// position.x+=2.0
@@ -871,37 +883,34 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 							setchain.push_back(GDFunction::OPCODE_SET_MEMBER);
 						}
 
-						for(List<GDParser::OperatorNode*>::Element *E=chain.back();E;E=E->prev()) {
+						for (List<GDParser::OperatorNode *>::Element *E = chain.back(); E; E = E->prev()) {
 
-
-							if (E==chain.front()) //ignore first
+							if (E == chain.front()) //ignore first
 								break;
 
-							bool named = E->get()->op==GDParser::OperatorNode::OP_INDEX_NAMED;
+							bool named = E->get()->op == GDParser::OperatorNode::OP_INDEX_NAMED;
 							int key_idx;
 
 							if (named) {
 
-								key_idx = codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode*>(E->get()->arguments[1])->name);
+								key_idx = codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode *>(E->get()->arguments[1])->name);
 								//printf("named key %x\n",key_idx);
 
 							} else {
 
-								if (prev_pos&(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)) {
+								if (prev_pos & (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS)) {
 									slevel++;
 									codegen.alloc_stack(slevel);
 								}
 
 								GDParser::Node *key = E->get()->arguments[1];
-								key_idx = _parse_expression(codegen,key,slevel);
+								key_idx = _parse_expression(codegen, key, slevel);
 								//printf("expr key %x\n",key_idx);
 
-
 								//stack was raised here if retval was stack but..
-
 							}
 
-							if (key_idx<0) //error
+							if (key_idx < 0) //error
 								return key_idx;
 
 							codegen.opcodes.push_back(named ? GDFunction::OPCODE_GET_NAMED : GDFunction::OPCODE_GET);
@@ -909,134 +918,116 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 							codegen.opcodes.push_back(key_idx);
 							slevel++;
 							codegen.alloc_stack(slevel);
-							int dst_pos = (GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)|slevel;
+							int dst_pos = (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) | slevel;
 
 							codegen.opcodes.push_back(dst_pos);
 
-
 							//add in reverse order, since it will be reverted
 
-
 							setchain.push_back(dst_pos);
 							setchain.push_back(key_idx);
 							setchain.push_back(prev_pos);
 							setchain.push_back(named ? GDFunction::OPCODE_SET_NAMED : GDFunction::OPCODE_SET);
 
-							prev_pos=dst_pos;
-
+							prev_pos = dst_pos;
 						}
 
 						setchain.invert();
 
-
 						int set_index;
-						bool named=false;
+						bool named = false;
 
+						if (static_cast<const GDParser::OperatorNode *>(op)->op == GDParser::OperatorNode::OP_INDEX_NAMED) {
 
-						if (static_cast<const GDParser::OperatorNode*>(op)->op==GDParser::OperatorNode::OP_INDEX_NAMED) {
-
-
-							set_index=codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode*>(op->arguments[1])->name);
-							named=true;
+							set_index = codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode *>(op->arguments[1])->name);
+							named = true;
 						} else {
 
-							set_index = _parse_expression(codegen,op->arguments[1],slevel+1);
-							named=false;
+							set_index = _parse_expression(codegen, op->arguments[1], slevel + 1);
+							named = false;
 						}
 
-
-						if (set_index<0) //error
+						if (set_index < 0) //error
 							return set_index;
 
-						if (set_index&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+						if (set_index & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
 
-
-						int set_value = _parse_assign_right_expression(codegen,on,slevel+1);
-						if (set_value<0) //error
+						int set_value = _parse_assign_right_expression(codegen, on, slevel + 1);
+						if (set_value < 0) //error
 							return set_value;
 
-						codegen.opcodes.push_back(named?GDFunction::OPCODE_SET_NAMED:GDFunction::OPCODE_SET);
+						codegen.opcodes.push_back(named ? GDFunction::OPCODE_SET_NAMED : GDFunction::OPCODE_SET);
 						codegen.opcodes.push_back(prev_pos);
 						codegen.opcodes.push_back(set_index);
 						codegen.opcodes.push_back(set_value);
 
-						for(int i=0;i<setchain.size();i++) {
-
+						for (int i = 0; i < setchain.size(); i++) {
 
 							codegen.opcodes.push_back(setchain[i]);
 						}
 
 						return retval;
 
-
-					} else if (on->arguments[0]->type==GDParser::Node::TYPE_IDENTIFIER && _is_class_member_property(codegen,static_cast<GDParser::IdentifierNode*>(on->arguments[0])->name)) {
+					} else if (on->arguments[0]->type == GDParser::Node::TYPE_IDENTIFIER && _is_class_member_property(codegen, static_cast<GDParser::IdentifierNode *>(on->arguments[0])->name)) {
 						//assignment to member property
 
 						int slevel = p_stack_level;
 
-						int src_address = _parse_assign_right_expression(codegen,on,slevel);
-						if (src_address<0)
+						int src_address = _parse_assign_right_expression(codegen, on, slevel);
+						if (src_address < 0)
 							return -1;
 
-						StringName name = static_cast<GDParser::IdentifierNode*>(on->arguments[0])->name;
+						StringName name = static_cast<GDParser::IdentifierNode *>(on->arguments[0])->name;
 
 						codegen.opcodes.push_back(GDFunction::OPCODE_SET_MEMBER);
 						codegen.opcodes.push_back(codegen.get_name_map_pos(name));
 						codegen.opcodes.push_back(src_address);
 
-						return GDFunction::ADDR_TYPE_NIL<<GDFunction::ADDR_BITS;
+						return GDFunction::ADDR_TYPE_NIL << GDFunction::ADDR_BITS;
 					} else {
 
-
-
 						//REGULAR ASSIGNMENT MODE!!
 
 						int slevel = p_stack_level;
 
-						int dst_address_a = _parse_expression(codegen,on->arguments[0],slevel,false,on->op==GDParser::OperatorNode::OP_INIT_ASSIGN);
-						if (dst_address_a<0)
+						int dst_address_a = _parse_expression(codegen, on->arguments[0], slevel, false, on->op == GDParser::OperatorNode::OP_INIT_ASSIGN);
+						if (dst_address_a < 0)
 							return -1;
 
-						if (dst_address_a&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+						if (dst_address_a & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
 
-						int src_address_b = _parse_assign_right_expression(codegen,on,slevel);
-						if (src_address_b<0)
+						int src_address_b = _parse_assign_right_expression(codegen, on, slevel);
+						if (src_address_b < 0)
 							return -1;
 
-
-
-
 						codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN); // perform operator
 						codegen.opcodes.push_back(dst_address_a); // argument 1
 						codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
 						return dst_address_a; //if anything, returns wathever was assigned or correct stack position
-
 					}
 
-
 				} break;
 				case GDParser::OperatorNode::OP_EXTENDS: {
 
-					ERR_FAIL_COND_V(on->arguments.size()!=2,false);
-
+					ERR_FAIL_COND_V(on->arguments.size() != 2, false);
 
 					int slevel = p_stack_level;
 
-					int src_address_a = _parse_expression(codegen,on->arguments[0],slevel);
-					if (src_address_a<0)
+					int src_address_a = _parse_expression(codegen, on->arguments[0], slevel);
+					if (src_address_a < 0)
 						return -1;
 
-					if (src_address_a&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)
+					if (src_address_a & GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS)
 						slevel++; //uses stack for return, increase stack
 
-					int src_address_b = _parse_expression(codegen,on->arguments[1],slevel);
-					if (src_address_b<0)
+					int src_address_b = _parse_expression(codegen, on->arguments[1], slevel);
+					if (src_address_b < 0)
 						return -1;
 
 					codegen.opcodes.push_back(GDFunction::OPCODE_EXTENDS_TEST); // perform operator
@@ -1046,14 +1037,13 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 				} break;
 				default: {
 
-
-					ERR_EXPLAIN("Bug in bytecode compiler, unexpected operator #"+itos(on->op)+" in parse tree while parsing expression.");
+					ERR_EXPLAIN("Bug in bytecode compiler, unexpected operator #" + itos(on->op) + " in parse tree while parsing expression.");
 					ERR_FAIL_V(0); //unreachable code
 
 				} break;
 			}
 
-			int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+			int dst_addr = (p_stack_level) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 			codegen.alloc_stack(p_stack_level);
 			return dst_addr;
@@ -1064,47 +1054,43 @@ int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expre
 			ERR_EXPLAIN("Bug in bytecode compiler, unexpected node in parse tree while parsing expression.");
 			ERR_FAIL_V(-1); //unreachable code
 		} break;
-
-
 	}
 
 	ERR_FAIL_V(-1); //unreachable code
 }
 
-
-Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_block,int p_stack_level,int p_break_addr,int p_continue_addr) {
+Error GDCompiler::_parse_block(CodeGen &codegen, const GDParser::BlockNode *p_block, int p_stack_level, int p_break_addr, int p_continue_addr) {
 
 	codegen.push_stack_identifiers();
-	int new_identifiers=0;
-	codegen.current_line=p_block->line;
+	int new_identifiers = 0;
+	codegen.current_line = p_block->line;
 
-	for(int i=0;i<p_block->statements.size();i++) {
+	for (int i = 0; i < p_block->statements.size(); i++) {
 
 		const GDParser::Node *s = p_block->statements[i];
 
-
-		switch(s->type) {
+		switch (s->type) {
 			case GDParser::Node::TYPE_NEWLINE: {
 #ifdef DEBUG_ENABLED
-				const GDParser::NewLineNode *nl = static_cast<const GDParser::NewLineNode*>(s);
+				const GDParser::NewLineNode *nl = static_cast<const GDParser::NewLineNode *>(s);
 				codegen.opcodes.push_back(GDFunction::OPCODE_LINE);
 				codegen.opcodes.push_back(nl->line);
-				codegen.current_line=nl->line;
+				codegen.current_line = nl->line;
 #endif
 			} break;
 			case GDParser::Node::TYPE_CONTROL_FLOW: {
 				// try subblocks
 
-				const GDParser::ControlFlowNode *cf = static_cast<const GDParser::ControlFlowNode*>(s);
+				const GDParser::ControlFlowNode *cf = static_cast<const GDParser::ControlFlowNode *>(s);
 
-				switch(cf->cf_type) {
+				switch (cf->cf_type) {
 
 					case GDParser::ControlFlowNode::CF_MATCH: {
 						GDParser::MatchNode *match = cf->match;
-						
+
 						GDParser::IdentifierNode *id = memnew(GDParser::IdentifierNode);
 						id->name = "#match_value";
-						
+
 						// var #match_value
 						// copied because there is no _parse_statement :(
 						codegen.add_stack_identifier(id->name, p_stack_level++);
@@ -1112,25 +1098,25 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo
 						new_identifiers++;
 
 						GDParser::OperatorNode *op = memnew(GDParser::OperatorNode);
-						op->op=GDParser::OperatorNode::OP_ASSIGN;
+						op->op = GDParser::OperatorNode::OP_ASSIGN;
 						op->arguments.push_back(id);
 						op->arguments.push_back(match->val_to_match);
-						
+
 						int ret = _parse_expression(codegen, op, p_stack_level);
 						if (ret < 0) {
 							return ERR_PARSE_ERROR;
 						}
-						
+
 						// break address
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(codegen.opcodes.size() + 3);
 						int break_addr = codegen.opcodes.size();
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(0); // break addr
-						
+
 						for (int j = 0; j < match->compiled_pattern_branches.size(); j++) {
 							GDParser::MatchNode::CompiledPatternBranch branch = match->compiled_pattern_branches[j];
-							
+
 							// jump over continue
 							// jump unconditionally
 							// continue address
@@ -1139,87 +1125,81 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo
 							if (ret < 0) {
 								return ERR_PARSE_ERROR;
 							}
-							
+
 							codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF);
 							codegen.opcodes.push_back(ret);
 							codegen.opcodes.push_back(codegen.opcodes.size() + 3);
 							int continue_addr = codegen.opcodes.size();
 							codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
 							codegen.opcodes.push_back(0);
-							
-							
-							
+
 							Error err = _parse_block(codegen, branch.body, p_stack_level, p_break_addr, continue_addr);
 							if (err) {
 								return ERR_PARSE_ERROR;
 							}
-							
+
 							codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
 							codegen.opcodes.push_back(break_addr);
-							
+
 							codegen.opcodes[continue_addr + 1] = codegen.opcodes.size();
 						}
-						
+
 						codegen.opcodes[break_addr + 1] = codegen.opcodes.size();
-						
-						
+
 					} break;
-					
+
 					case GDParser::ControlFlowNode::CF_IF: {
 
 #ifdef DEBUG_ENABLED
 						codegen.opcodes.push_back(GDFunction::OPCODE_LINE);
 						codegen.opcodes.push_back(cf->line);
-						codegen.current_line=cf->line;
+						codegen.current_line = cf->line;
 #endif
-						int ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false);
-						if (ret<0)
+						int ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
+						if (ret < 0)
 							return ERR_PARSE_ERROR;
 
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT);
 						codegen.opcodes.push_back(ret);
-						int else_addr=codegen.opcodes.size();
+						int else_addr = codegen.opcodes.size();
 						codegen.opcodes.push_back(0); //temporary
 
-						Error err = _parse_block(codegen,cf->body,p_stack_level,p_break_addr,p_continue_addr);
+						Error err = _parse_block(codegen, cf->body, p_stack_level, p_break_addr, p_continue_addr);
 						if (err)
 							return err;
 
 						if (cf->body_else) {
 
 							codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
-							int end_addr=codegen.opcodes.size();
+							int end_addr = codegen.opcodes.size();
 							codegen.opcodes.push_back(0);
-							codegen.opcodes[else_addr]=codegen.opcodes.size();
+							codegen.opcodes[else_addr] = codegen.opcodes.size();
 
-							Error err = _parse_block(codegen,cf->body_else,p_stack_level,p_break_addr,p_continue_addr);
+							Error err = _parse_block(codegen, cf->body_else, p_stack_level, p_break_addr, p_continue_addr);
 							if (err)
 								return err;
 
-							codegen.opcodes[end_addr]=codegen.opcodes.size();
+							codegen.opcodes[end_addr] = codegen.opcodes.size();
 						} else {
 							//end without else
-							codegen.opcodes[else_addr]=codegen.opcodes.size();
-
+							codegen.opcodes[else_addr] = codegen.opcodes.size();
 						}
 
 					} break;
 					case GDParser::ControlFlowNode::CF_FOR: {
 
-
-
-						int slevel=p_stack_level;
-						int iter_stack_pos=slevel;
-						int iterator_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
-						int counter_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
-						int container_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+						int slevel = p_stack_level;
+						int iter_stack_pos = slevel;
+						int iterator_pos = (slevel++) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
+						int counter_pos = (slevel++) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
+						int container_pos = (slevel++) | (GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS);
 						codegen.alloc_stack(slevel);
 
-						    codegen.push_stack_identifiers();
-						      codegen.add_stack_identifier(static_cast<const GDParser::IdentifierNode*>(cf->arguments[0])->name,iter_stack_pos);
+						codegen.push_stack_identifiers();
+						codegen.add_stack_identifier(static_cast<const GDParser::IdentifierNode *>(cf->arguments[0])->name, iter_stack_pos);
 
-						int ret = _parse_expression(codegen,cf->arguments[1],slevel,false);
-						if (ret<0)
+						int ret = _parse_expression(codegen, cf->arguments[1], slevel, false);
+						if (ret < 0)
 							return ERR_COMPILATION_FAILED;
 
 						//assign container
@@ -1231,32 +1211,29 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo
 						codegen.opcodes.push_back(GDFunction::OPCODE_ITERATE_BEGIN);
 						codegen.opcodes.push_back(counter_pos);
 						codegen.opcodes.push_back(container_pos);
-						codegen.opcodes.push_back(codegen.opcodes.size()+4);
+						codegen.opcodes.push_back(codegen.opcodes.size() + 4);
 						codegen.opcodes.push_back(iterator_pos);
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); //skip code for next
-						codegen.opcodes.push_back(codegen.opcodes.size()+8);
+						codegen.opcodes.push_back(codegen.opcodes.size() + 8);
 						//break loop
-						int break_pos=codegen.opcodes.size();
+						int break_pos = codegen.opcodes.size();
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); //skip code for next
 						codegen.opcodes.push_back(0); //skip code for next
 						//next loop
-						int continue_pos=codegen.opcodes.size();
+						int continue_pos = codegen.opcodes.size();
 						codegen.opcodes.push_back(GDFunction::OPCODE_ITERATE);
 						codegen.opcodes.push_back(counter_pos);
 						codegen.opcodes.push_back(container_pos);
 						codegen.opcodes.push_back(break_pos);
 						codegen.opcodes.push_back(iterator_pos);
 
-
-						Error err = _parse_block(codegen,cf->body,slevel,break_pos,continue_pos);
+						Error err = _parse_block(codegen, cf->body, slevel, break_pos, continue_pos);
 						if (err)
 							return err;
 
-
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(continue_pos);
-						codegen.opcodes[break_pos+1]=codegen.opcodes.size();
-
+						codegen.opcodes[break_pos + 1] = codegen.opcodes.size();
 
 						codegen.pop_stack_identifiers();
 
@@ -1264,25 +1241,25 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo
 					case GDParser::ControlFlowNode::CF_WHILE: {
 
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
-						codegen.opcodes.push_back(codegen.opcodes.size()+3);
-						int break_addr=codegen.opcodes.size();
+						codegen.opcodes.push_back(codegen.opcodes.size() + 3);
+						int break_addr = codegen.opcodes.size();
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(0);
-						int continue_addr=codegen.opcodes.size();
+						int continue_addr = codegen.opcodes.size();
 
-						int ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false);
-						if (ret<0)
+						int ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
+						if (ret < 0)
 							return ERR_PARSE_ERROR;
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT);
 						codegen.opcodes.push_back(ret);
 						codegen.opcodes.push_back(break_addr);
-						Error err = _parse_block(codegen,cf->body,p_stack_level,break_addr,continue_addr);
+						Error err = _parse_block(codegen, cf->body, p_stack_level, break_addr, continue_addr);
 						if (err)
 							return err;
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(continue_addr);
 
-						codegen.opcodes[break_addr+1]=codegen.opcodes.size();
+						codegen.opcodes[break_addr + 1] = codegen.opcodes.size();
 
 					} break;
 					case GDParser::ControlFlowNode::CF_SWITCH: {
@@ -1290,9 +1267,9 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo
 					} break;
 					case GDParser::ControlFlowNode::CF_BREAK: {
 
-						if (p_break_addr<0) {
+						if (p_break_addr < 0) {
 
-							_set_error("'break'' not within loop",cf);
+							_set_error("'break'' not within loop", cf);
 							return ERR_COMPILATION_FAILED;
 						}
 						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
@@ -1301,9 +1278,9 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo
 					} break;
 					case GDParser::ControlFlowNode::CF_CONTINUE: {
 
-						if (p_continue_addr<0) {
+						if (p_continue_addr < 0) {
 
-							_set_error("'continue' not within loop",cf);
+							_set_error("'continue' not within loop", cf);
 							return ERR_COMPILATION_FAILED;
 						}
 
@@ -1317,29 +1294,28 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo
 
 						if (cf->arguments.size()) {
 
-							ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false);
-							if (ret<0)
+							ret = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
+							if (ret < 0)
 								return ERR_PARSE_ERROR;
 
 						} else {
 
-							ret=GDFunction::ADDR_TYPE_NIL << GDFunction::ADDR_BITS;
+							ret = GDFunction::ADDR_TYPE_NIL << GDFunction::ADDR_BITS;
 						}
 
 						codegen.opcodes.push_back(GDFunction::OPCODE_RETURN);
 						codegen.opcodes.push_back(ret);
 
 					} break;
-
 				}
 			} break;
 			case GDParser::Node::TYPE_ASSERT: {
 				// try subblocks
 
-				const GDParser::AssertNode *as = static_cast<const GDParser::AssertNode*>(s);
+				const GDParser::AssertNode *as = static_cast<const GDParser::AssertNode *>(s);
 
-				int ret = _parse_expression(codegen,as->condition,p_stack_level,false);
-				if (ret<0)
+				int ret = _parse_expression(codegen, as->condition, p_stack_level, false);
+				if (ret < 0)
 					return ERR_PARSE_ERROR;
 
 				codegen.opcodes.push_back(GDFunction::OPCODE_ASSERT);
@@ -1353,99 +1329,91 @@ Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_blo
 			} break;
 			case GDParser::Node::TYPE_LOCAL_VAR: {
 
+				const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode *>(s);
 
-				const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode*>(s);
-
-				if (_is_class_member_property(codegen,lv->name)) {
-					_set_error("Name for local variable '"+String(lv->name)+"' can't shadow class property of the same name.",lv);
+				if (_is_class_member_property(codegen, lv->name)) {
+					_set_error("Name for local variable '" + String(lv->name) + "' can't shadow class property of the same name.", lv);
 					return ERR_ALREADY_EXISTS;
 				}
 
-				codegen.add_stack_identifier(lv->name,p_stack_level++);
+				codegen.add_stack_identifier(lv->name, p_stack_level++);
 				codegen.alloc_stack(p_stack_level);
 				new_identifiers++;
 
 			} break;
 			default: {
 				//expression
-				int ret = _parse_expression(codegen,s,p_stack_level,true);
-				if (ret<0)
+				int ret = _parse_expression(codegen, s, p_stack_level, true);
+				if (ret < 0)
 					return ERR_PARSE_ERROR;
 			} break;
-
 		}
-
 	}
 	codegen.pop_stack_identifiers();
 	return OK;
 }
 
-
-Error GDCompiler::_parse_function(GDScript *p_script,const GDParser::ClassNode *p_class,const GDParser::FunctionNode *p_func,bool p_for_ready) {
+Error GDCompiler::_parse_function(GDScript *p_script, const GDParser::ClassNode *p_class, const GDParser::FunctionNode *p_func, bool p_for_ready) {
 
 	Vector<int> bytecode;
 	CodeGen codegen;
 
-	codegen.class_node=p_class;
-	codegen.script=p_script;
-	codegen.function_node=p_func;
-	codegen.stack_max=0;
-	codegen.current_line=0;
-	codegen.call_max=0;
-	codegen.debug_stack=ScriptDebugger::get_singleton()!=NULL;
+	codegen.class_node = p_class;
+	codegen.script = p_script;
+	codegen.function_node = p_func;
+	codegen.stack_max = 0;
+	codegen.current_line = 0;
+	codegen.call_max = 0;
+	codegen.debug_stack = ScriptDebugger::get_singleton() != NULL;
 	Vector<StringName> argnames;
 
-	int stack_level=0;
+	int stack_level = 0;
 
 	if (p_func) {
-		for(int i=0;i<p_func->arguments.size();i++) {
-			if (_is_class_member_property(p_script,p_func->arguments[i])) {
-				_set_error("Name for argument '"+String(p_func->arguments[i])+"' can't shadow class property of the same name.",p_func);
+		for (int i = 0; i < p_func->arguments.size(); i++) {
+			if (_is_class_member_property(p_script, p_func->arguments[i])) {
+				_set_error("Name for argument '" + String(p_func->arguments[i]) + "' can't shadow class property of the same name.", p_func);
 				return ERR_ALREADY_EXISTS;
 			}
-			codegen.add_stack_identifier(p_func->arguments[i],i);
+			codegen.add_stack_identifier(p_func->arguments[i], i);
 #ifdef TOOLS_ENABLED
 			argnames.push_back(p_func->arguments[i]);
 #endif
 		}
-		stack_level=p_func->arguments.size();
+		stack_level = p_func->arguments.size();
 	}
 
 	codegen.alloc_stack(stack_level);
 
 	/* Parse initializer -if applies- */
 
-	bool is_initializer=!p_for_ready && !p_func;
+	bool is_initializer = !p_for_ready && !p_func;
 
-	if (is_initializer || (p_func && String(p_func->name)=="_init")) {
+	if (is_initializer || (p_func && String(p_func->name) == "_init")) {
 		//parse initializer for class members
-		if (!p_func && p_class->extends_used && p_script->native.is_null()){
+		if (!p_func && p_class->extends_used && p_script->native.is_null()) {
 
 			//call implicit parent constructor
 			codegen.opcodes.push_back(GDFunction::OPCODE_CALL_SELF_BASE);
 			codegen.opcodes.push_back(codegen.get_name_map_pos("_init"));
 			codegen.opcodes.push_back(0);
-			codegen.opcodes.push_back((GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)|0);
-
+			codegen.opcodes.push_back((GDFunction::ADDR_TYPE_STACK << GDFunction::ADDR_BITS) | 0);
 		}
-		Error err = _parse_block(codegen,p_class->initializer,stack_level);
+		Error err = _parse_block(codegen, p_class->initializer, stack_level);
 		if (err)
 			return err;
-		is_initializer=true;
-
+		is_initializer = true;
 	}
 
-	if (p_for_ready || (p_func && String(p_func->name)=="_ready")) {
+	if (p_for_ready || (p_func && String(p_func->name) == "_ready")) {
 		//parse initializer for class members
 		if (p_class->ready->statements.size()) {
-			Error err = _parse_block(codegen,p_class->ready,stack_level);
+			Error err = _parse_block(codegen, p_class->ready, stack_level);
 			if (err)
 				return err;
 		}
-
 	}
 
-
 	/* Parse default argument code -if applies- */
 
 	Vector<int> defarg_addr;
@@ -1457,196 +1425,185 @@ Error GDCompiler::_parse_function(GDScript *p_script,const GDParser::ClassNode *
 
 			codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_TO_DEF_ARGUMENT);
 			defarg_addr.push_back(codegen.opcodes.size());
-			for(int i=0;i<p_func->default_values.size();i++) {
+			for (int i = 0; i < p_func->default_values.size(); i++) {
 
-				_parse_expression(codegen,p_func->default_values[i],stack_level,true);
+				_parse_expression(codegen, p_func->default_values[i], stack_level, true);
 				defarg_addr.push_back(codegen.opcodes.size());
 			}
 
-
 			defarg_addr.invert();
 		}
 
-
-
-		Error err = _parse_block(codegen,p_func->body,stack_level);
+		Error err = _parse_block(codegen, p_func->body, stack_level);
 		if (err)
 			return err;
 
-		func_name=p_func->name;
+		func_name = p_func->name;
 	} else {
 		if (p_for_ready)
-			func_name="_ready";
+			func_name = "_ready";
 		else
-			func_name="_init";
+			func_name = "_init";
 	}
 
 	codegen.opcodes.push_back(GDFunction::OPCODE_END);
 
-	GDFunction *gdfunc=NULL;
+	GDFunction *gdfunc = NULL;
 
 	/*
 	if (String(p_func->name)=="") { //initializer func
 		gdfunc = &p_script->initializer;
 	*/
 	//} else { //regular func
-		p_script->member_functions[func_name]=memnew(GDFunction);
-		gdfunc = p_script->member_functions[func_name];
+	p_script->member_functions[func_name] = memnew(GDFunction);
+	gdfunc = p_script->member_functions[func_name];
 	//}
 
 	if (p_func) {
-		gdfunc->_static=p_func->_static;
-		gdfunc->rpc_mode=p_func->rpc_mode;
+		gdfunc->_static = p_func->_static;
+		gdfunc->rpc_mode = p_func->rpc_mode;
 	}
 
 #ifdef TOOLS_ENABLED
-	gdfunc->arg_names=argnames;
+	gdfunc->arg_names = argnames;
 #endif
 	//constants
 	if (codegen.constant_map.size()) {
-		gdfunc->_constant_count=codegen.constant_map.size();
+		gdfunc->_constant_count = codegen.constant_map.size();
 		gdfunc->constants.resize(codegen.constant_map.size());
-		gdfunc->_constants_ptr=&gdfunc->constants[0];
-		const Variant *K=NULL;
-		while((K=codegen.constant_map.next(K))) {
+		gdfunc->_constants_ptr = &gdfunc->constants[0];
+		const Variant *K = NULL;
+		while ((K = codegen.constant_map.next(K))) {
 			int idx = codegen.constant_map[*K];
-			gdfunc->constants[idx]=*K;
+			gdfunc->constants[idx] = *K;
 		}
 	} else {
 
-		gdfunc->_constants_ptr=NULL;
-		gdfunc->_constant_count=0;
+		gdfunc->_constants_ptr = NULL;
+		gdfunc->_constant_count = 0;
 	}
 	//global names
 	if (codegen.name_map.size()) {
 
 		gdfunc->global_names.resize(codegen.name_map.size());
 		gdfunc->_global_names_ptr = &gdfunc->global_names[0];
-		for(Map<StringName,int>::Element *E=codegen.name_map.front();E;E=E->next()) {
+		for (Map<StringName, int>::Element *E = codegen.name_map.front(); E; E = E->next()) {
 
-			gdfunc->global_names[E->get()]=E->key();
+			gdfunc->global_names[E->get()] = E->key();
 		}
-		gdfunc->_global_names_count=gdfunc->global_names.size();
+		gdfunc->_global_names_count = gdfunc->global_names.size();
 
 	} else {
 		gdfunc->_global_names_ptr = NULL;
-		gdfunc->_global_names_count =0;
+		gdfunc->_global_names_count = 0;
 	}
 
-
 	if (codegen.opcodes.size()) {
 
-		gdfunc->code=codegen.opcodes;
-		gdfunc->_code_ptr=&gdfunc->code[0];
-		gdfunc->_code_size=codegen.opcodes.size();
+		gdfunc->code = codegen.opcodes;
+		gdfunc->_code_ptr = &gdfunc->code[0];
+		gdfunc->_code_size = codegen.opcodes.size();
 
 	} else {
 
-		gdfunc->_code_ptr=NULL;
-		gdfunc->_code_size=0;
+		gdfunc->_code_ptr = NULL;
+		gdfunc->_code_size = 0;
 	}
 
 	if (defarg_addr.size()) {
 
-		gdfunc->default_arguments=defarg_addr;
-		gdfunc->_default_arg_count=defarg_addr.size()-1;
-		gdfunc->_default_arg_ptr=&gdfunc->default_arguments[0];
+		gdfunc->default_arguments = defarg_addr;
+		gdfunc->_default_arg_count = defarg_addr.size() - 1;
+		gdfunc->_default_arg_ptr = &gdfunc->default_arguments[0];
 	} else {
-		gdfunc->_default_arg_count=0;
-		gdfunc->_default_arg_ptr=NULL;
+		gdfunc->_default_arg_count = 0;
+		gdfunc->_default_arg_ptr = NULL;
 	}
 
-	gdfunc->_argument_count=p_func ? p_func->arguments.size() : 0;
-	gdfunc->_stack_size=codegen.stack_max;
-	gdfunc->_call_size=codegen.call_max;
-	gdfunc->name=func_name;
+	gdfunc->_argument_count = p_func ? p_func->arguments.size() : 0;
+	gdfunc->_stack_size = codegen.stack_max;
+	gdfunc->_call_size = codegen.call_max;
+	gdfunc->name = func_name;
 #ifdef DEBUG_ENABLED
-	if (ScriptDebugger::get_singleton()){
+	if (ScriptDebugger::get_singleton()) {
 		String signature;
 		//path
-		if (p_script->get_path()!=String())
-			signature+=p_script->get_path();
+		if (p_script->get_path() != String())
+			signature += p_script->get_path();
 		//loc
 		if (p_func) {
-			signature+="::"+itos(p_func->body->line);
+			signature += "::" + itos(p_func->body->line);
 		} else {
-			signature+="::0";
+			signature += "::0";
 		}
 
 		//funciton and class
 
 		if (p_class->name) {
-			signature+="::"+String(p_class->name)+"."+String(func_name);
+			signature += "::" + String(p_class->name) + "." + String(func_name);
 		} else {
-			signature+="::"+String(func_name);
+			signature += "::" + String(func_name);
 		}
 
-
-
-		gdfunc->profile.signature=signature;
+		gdfunc->profile.signature = signature;
 	}
 #endif
-	gdfunc->_script=p_script;
-	gdfunc->source=source;
+	gdfunc->_script = p_script;
+	gdfunc->source = source;
 
 #ifdef DEBUG_ENABLED
 
 	{
-		gdfunc->func_cname=(String(source)+" - "+String(func_name)).utf8();
-		gdfunc->_func_cname=gdfunc->func_cname.get_data();
-
+		gdfunc->func_cname = (String(source) + " - " + String(func_name)).utf8();
+		gdfunc->_func_cname = gdfunc->func_cname.get_data();
 	}
 
 #endif
 	if (p_func) {
-		gdfunc->_initial_line=p_func->line;
+		gdfunc->_initial_line = p_func->line;
 #ifdef TOOLS_ENABLED
 
-		p_script->member_lines[func_name]=p_func->line;
+		p_script->member_lines[func_name] = p_func->line;
 #endif
 	} else {
-		gdfunc->_initial_line=0;
+		gdfunc->_initial_line = 0;
 	}
 
 	if (codegen.debug_stack)
-		gdfunc->stack_debug=codegen.stack_debug;
+		gdfunc->stack_debug = codegen.stack_debug;
 
 	if (is_initializer)
-		p_script->initializer=gdfunc;
-
+		p_script->initializer = gdfunc;
 
 	return OK;
 }
 
-
-
 Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDParser::ClassNode *p_class, bool p_keep_state) {
 
-	Map<StringName,Ref<GDScript> > old_subclasses;
+	Map<StringName, Ref<GDScript> > old_subclasses;
 
 	if (p_keep_state) {
-		old_subclasses=p_script->subclasses;
+		old_subclasses = p_script->subclasses;
 	}
 
-	p_script->native=Ref<GDNativeClass>();
-	p_script->base=Ref<GDScript>();
-	p_script->_base=NULL;
+	p_script->native = Ref<GDNativeClass>();
+	p_script->base = Ref<GDScript>();
+	p_script->_base = NULL;
 	p_script->members.clear();
 	p_script->constants.clear();
-	for (Map<StringName,GDFunction*>::Element *E=p_script->member_functions.front();E;E=E->next()) {
+	for (Map<StringName, GDFunction *>::Element *E = p_script->member_functions.front(); E; E = E->next()) {
 		memdelete(E->get());
 	}
 	p_script->member_functions.clear();
 	p_script->member_indices.clear();
 	p_script->member_info.clear();
 	p_script->_signals.clear();
-	p_script->initializer=NULL;
+	p_script->initializer = NULL;
 
 	p_script->subclasses.clear();
-	p_script->_owner=p_owner;
-	p_script->tool=p_class->tool;
-	p_script->name=p_class->name;
-
+	p_script->_owner = p_owner;
+	p_script->tool = p_class->tool;
+	p_script->name = p_class->name;
 
 	Ref<GDNativeClass> native;
 
@@ -1656,8 +1613,7 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa
 
 		Ref<GDScript> script;
 
-
-		if (path!="") {
+		if (path != "") {
 			//path (and optionally subclasses)
 
 			if (path.is_rel_path()) {
@@ -1667,47 +1623,46 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa
 				if (p_owner) {
 					GDScript *current_class = p_owner;
 					while (current_class != NULL) {
-						base=current_class->get_path();
-						if (base=="")
+						base = current_class->get_path();
+						if (base == "")
 							current_class = current_class->_owner;
 						else
 							break;
 					}
-				}
-				else {
+				} else {
 					base = p_script->get_path();
 				}
 
-				if (base=="" || base.is_rel_path()) {
-					_set_error("Could not resolve relative path for parent class: "+path,p_class);
+				if (base == "" || base.is_rel_path()) {
+					_set_error("Could not resolve relative path for parent class: " + path, p_class);
 					return ERR_FILE_NOT_FOUND;
 				}
-				path=base.get_base_dir().plus_file(path).simplify_path();
+				path = base.get_base_dir().plus_file(path).simplify_path();
 			}
 			script = ResourceLoader::load(path);
 			if (script.is_null()) {
-				_set_error("Could not load base class: "+path,p_class);
+				_set_error("Could not load base class: " + path, p_class);
 				return ERR_FILE_NOT_FOUND;
 			}
 			if (!script->valid) {
 
-				_set_error("Script not fully loaded (cyclic preload?): "+path,p_class);
+				_set_error("Script not fully loaded (cyclic preload?): " + path, p_class);
 				return ERR_BUSY;
 			}
 			//print_line("EXTENDS PATH: "+path+" script is "+itos(script.is_valid())+" indices is "+itos(script->member_indices.size())+" valid? "+itos(script->valid));
 
 			if (p_class->extends_class.size()) {
 
-				for(int i=0;i<p_class->extends_class.size();i++) {
+				for (int i = 0; i < p_class->extends_class.size(); i++) {
 
 					String sub = p_class->extends_class[i];
 					if (script->subclasses.has(sub)) {
 
 						Ref<Script> subclass = script->subclasses[sub]; //avoid reference from dissapearing
-						script=subclass;
+						script = subclass;
 					} else {
 
-						_set_error("Could not find subclass: "+sub,p_class);
+						_set_error("Could not find subclass: " + sub, p_class);
 						return ERR_FILE_NOT_FOUND;
 					}
 				}
@@ -1715,54 +1670,52 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa
 
 		} else {
 
-			ERR_FAIL_COND_V(p_class->extends_class.size()==0,ERR_BUG);
+			ERR_FAIL_COND_V(p_class->extends_class.size() == 0, ERR_BUG);
 			//look around for the subclasses
 
-			String base=p_class->extends_class[0];
+			String base = p_class->extends_class[0];
 			GDScript *p = p_owner;
 			Ref<GDScript> base_class;
 
-			while(p) {
+			while (p) {
 
 				if (p->subclasses.has(base)) {
 
-					base_class=p->subclasses[base];
+					base_class = p->subclasses[base];
 					break;
 				}
-				p=p->_owner;
+				p = p->_owner;
 			}
 
 			if (base_class.is_valid()) {
 
-				for(int i=1;i<p_class->extends_class.size();i++) {
+				for (int i = 1; i < p_class->extends_class.size(); i++) {
 
-					String subclass=p_class->extends_class[i];
+					String subclass = p_class->extends_class[i];
 
 					if (base_class->subclasses.has(subclass)) {
 
-						base_class=base_class->subclasses[subclass];
+						base_class = base_class->subclasses[subclass];
 					} else {
 
-						_set_error("Could not find subclass: "+subclass,p_class);
+						_set_error("Could not find subclass: " + subclass, p_class);
 						return ERR_FILE_NOT_FOUND;
 					}
 				}
 
-				script=base_class;
-
+				script = base_class;
 
 			} else {
 
-				if (p_class->extends_class.size()>1) {
+				if (p_class->extends_class.size() > 1) {
 
-					_set_error("Invalid inheritance (unknown class+subclasses)",p_class);
+					_set_error("Invalid inheritance (unknown class+subclasses)", p_class);
 					return ERR_FILE_NOT_FOUND;
-
 				}
 				//if not found, try engine classes
 				if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) {
 
-					_set_error("Unknown class: '"+base+"'",p_class);
+					_set_error("Unknown class: '" + base + "'", p_class);
 					return ERR_FILE_NOT_FOUND;
 				}
 
@@ -1770,66 +1723,62 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa
 				native = GDScriptLanguage::get_singleton()->get_global_array()[base_idx];
 				if (!native.is_valid()) {
 
-					_set_error("Global not a class: '"+base+"'",p_class);
+					_set_error("Global not a class: '" + base + "'", p_class);
 
 					return ERR_FILE_NOT_FOUND;
 				}
 			}
-
-
 		}
 
 		if (script.is_valid()) {
 
-			p_script->base=script;
-			p_script->_base=p_script->base.ptr();
-			p_script->member_indices=script->member_indices;
+			p_script->base = script;
+			p_script->_base = p_script->base.ptr();
+			p_script->member_indices = script->member_indices;
 
 		} else if (native.is_valid()) {
 
-			p_script->native=native;
+			p_script->native = native;
 		} else {
 
-			_set_error("Could not determine inheritance",p_class);
+			_set_error("Could not determine inheritance", p_class);
 			return ERR_FILE_NOT_FOUND;
 		}
 
-
-	}else {
+	} else {
 		// without extends, implicitly extend Reference
 		int native_idx = GDScriptLanguage::get_singleton()->get_global_map()["Reference"];
 		native = GDScriptLanguage::get_singleton()->get_global_array()[native_idx];
 		ERR_FAIL_COND_V(native.is_null(), ERR_BUG);
-		p_script->native=native;
+		p_script->native = native;
 	}
 
 	//print_line("Script: "+p_script->get_path()+" indices: "+itos(p_script->member_indices.size()));
 
-
-	for(int i=0;i<p_class->variables.size();i++) {
+	for (int i = 0; i < p_class->variables.size(); i++) {
 
 		StringName name = p_class->variables[i].identifier;
 		if (p_script->member_indices.has(name)) {
-			_set_error("Member '"+name+"' already exists (in current or parent class)",p_class);
+			_set_error("Member '" + name + "' already exists (in current or parent class)", p_class);
 			return ERR_ALREADY_EXISTS;
 		}
-		if (_is_class_member_property(p_script,name)) {
-			_set_error("Member '"+name+"' already exists as a class property.",p_class);
+		if (_is_class_member_property(p_script, name)) {
+			_set_error("Member '" + name + "' already exists as a class property.", p_class);
 			return ERR_ALREADY_EXISTS;
 		}
 
-		if (p_class->variables[i]._export.type!=Variant::NIL) {
+		if (p_class->variables[i]._export.type != Variant::NIL) {
 
-			p_script->member_info[name]=p_class->variables[i]._export;
+			p_script->member_info[name] = p_class->variables[i]._export;
 #ifdef TOOLS_ENABLED
-			if (p_class->variables[i].default_value.get_type()!=Variant::NIL) {
+			if (p_class->variables[i].default_value.get_type() != Variant::NIL) {
 
-				p_script->member_default_values[name]=p_class->variables[i].default_value;
+				p_script->member_default_values[name] = p_class->variables[i].default_value;
 			}
 #endif
 		} else {
 
-			p_script->member_info[name]=PropertyInfo(Variant::NIL,name,PROPERTY_HINT_NONE,"",PROPERTY_USAGE_SCRIPT_VARIABLE);
+			p_script->member_info[name] = PropertyInfo(Variant::NIL, name, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_SCRIPT_VARIABLE);
 		}
 
 		//int new_idx = p_script->member_indices.size();
@@ -1837,176 +1786,168 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa
 		minfo.index = p_script->member_indices.size();
 		minfo.setter = p_class->variables[i].setter;
 		minfo.getter = p_class->variables[i].getter;
-		minfo.rpc_mode=p_class->variables[i].rpc_mode;
+		minfo.rpc_mode = p_class->variables[i].rpc_mode;
 
-		p_script->member_indices[name]=minfo;
+		p_script->member_indices[name] = minfo;
 		p_script->members.insert(name);
 
 #ifdef TOOLS_ENABLED
 
-		p_script->member_lines[name]=p_class->variables[i].line;
+		p_script->member_lines[name] = p_class->variables[i].line;
 #endif
-
-
 	}
 
-	for(int i=0;i<p_class->constant_expressions.size();i++) {
+	for (int i = 0; i < p_class->constant_expressions.size(); i++) {
 
 		StringName name = p_class->constant_expressions[i].identifier;
-		ERR_CONTINUE( p_class->constant_expressions[i].expression->type!=GDParser::Node::TYPE_CONSTANT );
+		ERR_CONTINUE(p_class->constant_expressions[i].expression->type != GDParser::Node::TYPE_CONSTANT);
 
-		if (_is_class_member_property(p_script,name)) {
-			_set_error("Member '"+name+"' already exists as a class property.",p_class);
+		if (_is_class_member_property(p_script, name)) {
+			_set_error("Member '" + name + "' already exists as a class property.", p_class);
 			return ERR_ALREADY_EXISTS;
 		}
 
-		GDParser::ConstantNode *constant = static_cast<GDParser::ConstantNode*>(p_class->constant_expressions[i].expression);
+		GDParser::ConstantNode *constant = static_cast<GDParser::ConstantNode *>(p_class->constant_expressions[i].expression);
 
-		p_script->constants.insert(name,constant->value);
-		//p_script->constants[constant->value].make_const();
+		p_script->constants.insert(name, constant->value);
+//p_script->constants[constant->value].make_const();
 #ifdef TOOLS_ENABLED
 
-		p_script->member_lines[name]=p_class->constant_expressions[i].expression->line;
+		p_script->member_lines[name] = p_class->constant_expressions[i].expression->line;
 #endif
-
 	}
 
-	for(int i=0;i<p_class->_signals.size();i++) {
+	for (int i = 0; i < p_class->_signals.size(); i++) {
 
 		StringName name = p_class->_signals[i].name;
 
 		GDScript *c = p_script;
 
-		while(c) {
+		while (c) {
 
 			if (c->_signals.has(name)) {
-				_set_error("Signal '"+name+"' redefined (in current or parent class)",p_class);
+				_set_error("Signal '" + name + "' redefined (in current or parent class)", p_class);
 				return ERR_ALREADY_EXISTS;
 			}
 
 			if (c->base.is_valid()) {
-				c=c->base.ptr();
+				c = c->base.ptr();
 			} else {
-				c=NULL;
+				c = NULL;
 			}
 		}
 
 		if (native.is_valid()) {
-			if (ClassDB::has_signal(native->get_name(),name)) {
-				_set_error("Signal '"+name+"' redefined (original in native class '"+String(native->get_name())+"')",p_class);
+			if (ClassDB::has_signal(native->get_name(), name)) {
+				_set_error("Signal '" + name + "' redefined (original in native class '" + String(native->get_name()) + "')", p_class);
 				return ERR_ALREADY_EXISTS;
 			}
 		}
 
-		p_script->_signals[name]=p_class->_signals[i].arguments;
+		p_script->_signals[name] = p_class->_signals[i].arguments;
 	}
 	//parse sub-classes
 
-	for(int i=0;i<p_class->subclasses.size();i++) {
+	for (int i = 0; i < p_class->subclasses.size(); i++) {
 		StringName name = p_class->subclasses[i]->name;
 
 		Ref<GDScript> subclass;
 
 		if (old_subclasses.has(name)) {
-			subclass=old_subclasses[name];
+			subclass = old_subclasses[name];
 		} else {
 			subclass.instance();
 		}
 
-		Error err = _parse_class(subclass.ptr(),p_script,p_class->subclasses[i],p_keep_state);
+		Error err = _parse_class(subclass.ptr(), p_script, p_class->subclasses[i], p_keep_state);
 		if (err)
 			return err;
 
 #ifdef TOOLS_ENABLED
 
-		p_script->member_lines[name]=p_class->subclasses[i]->line;
+		p_script->member_lines[name] = p_class->subclasses[i]->line;
 #endif
 
-		p_script->constants.insert(name,subclass); //once parsed, goes to the list of constants
-		p_script->subclasses.insert(name,subclass);
-
+		p_script->constants.insert(name, subclass); //once parsed, goes to the list of constants
+		p_script->subclasses.insert(name, subclass);
 	}
 
-
 	//parse methods
 
-	bool has_initializer=false;
-	bool has_ready=false;
+	bool has_initializer = false;
+	bool has_ready = false;
 
-	for(int i=0;i<p_class->functions.size();i++) {
+	for (int i = 0; i < p_class->functions.size(); i++) {
 
-		if (!has_initializer && p_class->functions[i]->name=="_init")
-			has_initializer=true;
-		if (!has_ready && p_class->functions[i]->name=="_ready")
-			has_ready=true;
-		Error err = _parse_function(p_script,p_class,p_class->functions[i]);
+		if (!has_initializer && p_class->functions[i]->name == "_init")
+			has_initializer = true;
+		if (!has_ready && p_class->functions[i]->name == "_ready")
+			has_ready = true;
+		Error err = _parse_function(p_script, p_class, p_class->functions[i]);
 		if (err)
 			return err;
 	}
 
 	//parse static methods
 
-	for(int i=0;i<p_class->static_functions.size();i++) {
+	for (int i = 0; i < p_class->static_functions.size(); i++) {
 
-		Error err = _parse_function(p_script,p_class,p_class->static_functions[i]);
+		Error err = _parse_function(p_script, p_class, p_class->static_functions[i]);
 		if (err)
 			return err;
 	}
 
-
 	if (!has_initializer) {
 		//create a constructor
-		Error err = _parse_function(p_script,p_class,NULL);
+		Error err = _parse_function(p_script, p_class, NULL);
 		if (err)
 			return err;
 	}
 
 	if (!has_ready && p_class->ready->statements.size()) {
 		//create a constructor
-		Error err = _parse_function(p_script,p_class,NULL,true);
+		Error err = _parse_function(p_script, p_class, NULL, true);
 		if (err)
 			return err;
 	}
 
 #ifdef DEBUG_ENABLED
 	//validate setters/getters if debug is enabled
-	for(int i=0;i<p_class->variables.size();i++) {
+	for (int i = 0; i < p_class->variables.size(); i++) {
 
 		if (p_class->variables[i].setter) {
-			const Map<StringName,GDFunction*>::Element *E=p_script->get_member_functions().find(p_class->variables[i].setter);
+			const Map<StringName, GDFunction *>::Element *E = p_script->get_member_functions().find(p_class->variables[i].setter);
 			if (!E) {
-				_set_error("Setter function '"+String(p_class->variables[i].setter)+"' not found in class.",NULL);
-				err_line=p_class->variables[i].line;
-				err_column=0;
+				_set_error("Setter function '" + String(p_class->variables[i].setter) + "' not found in class.", NULL);
+				err_line = p_class->variables[i].line;
+				err_column = 0;
 				return ERR_PARSE_ERROR;
 			}
 
 			if (E->get()->is_static()) {
 
-				_set_error("Setter function '"+String(p_class->variables[i].setter)+"' is static.",NULL);
-				err_line=p_class->variables[i].line;
-				err_column=0;
+				_set_error("Setter function '" + String(p_class->variables[i].setter) + "' is static.", NULL);
+				err_line = p_class->variables[i].line;
+				err_column = 0;
 				return ERR_PARSE_ERROR;
 			}
-
 		}
 		if (p_class->variables[i].getter) {
-			const Map<StringName,GDFunction*>::Element *E=p_script->get_member_functions().find(p_class->variables[i].getter);
+			const Map<StringName, GDFunction *>::Element *E = p_script->get_member_functions().find(p_class->variables[i].getter);
 			if (!E) {
-				_set_error("Getter function '"+String(p_class->variables[i].getter)+"' not found in class.",NULL);
-				err_line=p_class->variables[i].line;
-				err_column=0;
+				_set_error("Getter function '" + String(p_class->variables[i].getter) + "' not found in class.", NULL);
+				err_line = p_class->variables[i].line;
+				err_column = 0;
 				return ERR_PARSE_ERROR;
 			}
 
 			if (E->get()->is_static()) {
 
-				_set_error("Getter function '"+String(p_class->variables[i].getter)+"' is static.",NULL);
-				err_line=p_class->variables[i].line;
-				err_column=0;
+				_set_error("Getter function '" + String(p_class->variables[i].getter) + "' is static.", NULL);
+				err_line = p_class->variables[i].line;
+				err_column = 0;
 				return ERR_PARSE_ERROR;
 			}
-
 		}
 	}
 
@@ -2014,96 +1955,88 @@ Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDPa
 
 	if (p_keep_state) {
 
-		print_line("RELOAD KEEP "+p_script->path);
-		for (Set<Object*>::Element *E=p_script->instances.front();E;) {
+		print_line("RELOAD KEEP " + p_script->path);
+		for (Set<Object *>::Element *E = p_script->instances.front(); E;) {
 
-			Set<Object*>::Element *N = E->next();
+			Set<Object *>::Element *N = E->next();
 
 			ScriptInstance *si = E->get()->get_script_instance();
 			if (si->is_placeholder()) {
 #ifdef TOOLS_ENABLED
-				PlaceHolderScriptInstance *psi = static_cast<PlaceHolderScriptInstance*>(si);
+				PlaceHolderScriptInstance *psi = static_cast<PlaceHolderScriptInstance *>(si);
 
 				if (p_script->is_tool()) {
 					//re-create as an instance
 					p_script->placeholders.erase(psi); //remove placeholder
 
-					GDInstance* instance = memnew( GDInstance );
-					instance->base_ref=E->get()->cast_to<Reference>();
+					GDInstance *instance = memnew(GDInstance);
+					instance->base_ref = E->get()->cast_to<Reference>();
 					instance->members.resize(p_script->member_indices.size());
-					instance->script=Ref<GDScript>(p_script);
-					instance->owner=E->get();
+					instance->script = Ref<GDScript>(p_script);
+					instance->owner = E->get();
 
 					//needed for hot reloading
-					for(Map<StringName,GDScript::MemberInfo>::Element *E=p_script->member_indices.front();E;E=E->next()) {
-						instance->member_indices_cache[E->key()]=E->get().index;
+					for (Map<StringName, GDScript::MemberInfo>::Element *E = p_script->member_indices.front(); E; E = E->next()) {
+						instance->member_indices_cache[E->key()] = E->get().index;
 					}
 					instance->owner->set_script_instance(instance);
 
-
 					/* STEP 2, INITIALIZE AND CONSRTUCT */
 
 					Variant::CallError ce;
-					p_script->initializer->call(instance,NULL,0,ce);
+					p_script->initializer->call(instance, NULL, 0, ce);
 
-					if (ce.error!=Variant::CallError::CALL_OK) {
+					if (ce.error != Variant::CallError::CALL_OK) {
 						//well, tough luck, not goinna do anything here
 					}
 				}
 #endif
 			} else {
 
-				GDInstance *gi = static_cast<GDInstance*>(si);
+				GDInstance *gi = static_cast<GDInstance *>(si);
 				gi->reload_members();
 			}
 
-			E=N;
-
+			E = N;
 		}
-
-
 	}
 #endif
 
-	p_script->valid=true;
+	p_script->valid = true;
 	return OK;
 }
 
-Error GDCompiler::compile(const GDParser *p_parser,GDScript *p_script,bool p_keep_state) {
+Error GDCompiler::compile(const GDParser *p_parser, GDScript *p_script, bool p_keep_state) {
 
-	err_line=-1;
-	err_column=-1;
-	error="";
-	parser=p_parser;
-	const GDParser::Node* root = parser->get_parse_tree();
-	ERR_FAIL_COND_V(root->type!=GDParser::Node::TYPE_CLASS,ERR_INVALID_DATA);
+	err_line = -1;
+	err_column = -1;
+	error = "";
+	parser = p_parser;
+	const GDParser::Node *root = parser->get_parse_tree();
+	ERR_FAIL_COND_V(root->type != GDParser::Node::TYPE_CLASS, ERR_INVALID_DATA);
 
-	source=p_script->get_path();
+	source = p_script->get_path();
 
-	Error err = _parse_class(p_script,NULL,static_cast<const GDParser::ClassNode*>(root),p_keep_state);
+	Error err = _parse_class(p_script, NULL, static_cast<const GDParser::ClassNode *>(root), p_keep_state);
 
 	if (err)
 		return err;
 
 	return OK;
-
 }
 
 String GDCompiler::get_error() const {
 
 	return error;
 }
-int GDCompiler::get_error_line() const{
+int GDCompiler::get_error_line() const {
 
 	return err_line;
 }
-int GDCompiler::get_error_column() const{
+int GDCompiler::get_error_column() const {
 
 	return err_column;
 }
 
-GDCompiler::GDCompiler()
-{
+GDCompiler::GDCompiler() {
 }
-
-
diff --git a/modules/gdscript/gd_compiler.h b/modules/gdscript/gd_compiler.h
index eb6079e8e0..c84bd97246 100644
--- a/modules/gdscript/gd_compiler.h
+++ b/modules/gdscript/gd_compiler.h
@@ -32,7 +32,6 @@
 #include "gd_parser.h"
 #include "gd_script.h"
 
-
 class GDCompiler {
 
 	const GDParser *parser;
@@ -43,83 +42,86 @@ class GDCompiler {
 		const GDParser::FunctionNode *function_node;
 		bool debug_stack;
 
-	        List< Map<StringName,int> > stack_id_stack;
-			Map<StringName,int> stack_identifiers;
-
-	        List<GDFunction::StackDebug> stack_debug;
-	        List< Map<StringName,int> > block_identifier_stack;
-	        Map<StringName,int> block_identifiers;
-
-	        void add_stack_identifier(const StringName& p_id,int p_stackpos) {
-	            stack_identifiers[p_id]=p_stackpos;
-	            if (debug_stack) {
-	                block_identifiers[p_id]=p_stackpos;
-	                GDFunction::StackDebug sd;
-	                sd.added=true;
-	                sd.line=current_line;
-	                sd.identifier=p_id;
-	                sd.pos=p_stackpos;
-	                stack_debug.push_back(sd);
-	            }
-	        }
-
-	        void push_stack_identifiers() {
-	            stack_id_stack.push_back( stack_identifiers );
-	            if (debug_stack) {
-
-	                block_identifier_stack.push_back(block_identifiers);
-	                block_identifiers.clear();
-	            }
-	        }
-
-	        void pop_stack_identifiers() {
-	            stack_identifiers = stack_id_stack.back()->get();
-	            stack_id_stack.pop_back();
-
-	            if (debug_stack) {
-	                for (Map<StringName,int>::Element *E=block_identifiers.front();E;E=E->next()) {
-
-	                    GDFunction::StackDebug sd;
-	                    sd.added=false;
-	                    sd.identifier=E->key();
-	                    sd.line=current_line;
-	                    sd.pos=E->get();
-	                    stack_debug.push_back(sd);
-	                }
-	                block_identifiers=block_identifier_stack.back()->get();
-	                block_identifier_stack.pop_back();
-	            }
-	        }
+		List<Map<StringName, int> > stack_id_stack;
+		Map<StringName, int> stack_identifiers;
+
+		List<GDFunction::StackDebug> stack_debug;
+		List<Map<StringName, int> > block_identifier_stack;
+		Map<StringName, int> block_identifiers;
+
+		void add_stack_identifier(const StringName &p_id, int p_stackpos) {
+			stack_identifiers[p_id] = p_stackpos;
+			if (debug_stack) {
+				block_identifiers[p_id] = p_stackpos;
+				GDFunction::StackDebug sd;
+				sd.added = true;
+				sd.line = current_line;
+				sd.identifier = p_id;
+				sd.pos = p_stackpos;
+				stack_debug.push_back(sd);
+			}
+		}
 
+		void push_stack_identifiers() {
+			stack_id_stack.push_back(stack_identifiers);
+			if (debug_stack) {
+
+				block_identifier_stack.push_back(block_identifiers);
+				block_identifiers.clear();
+			}
+		}
+
+		void pop_stack_identifiers() {
+			stack_identifiers = stack_id_stack.back()->get();
+			stack_id_stack.pop_back();
+
+			if (debug_stack) {
+				for (Map<StringName, int>::Element *E = block_identifiers.front(); E; E = E->next()) {
+
+					GDFunction::StackDebug sd;
+					sd.added = false;
+					sd.identifier = E->key();
+					sd.line = current_line;
+					sd.pos = E->get();
+					stack_debug.push_back(sd);
+				}
+				block_identifiers = block_identifier_stack.back()->get();
+				block_identifier_stack.pop_back();
+			}
+		}
 
 		//int get_identifier_pos(const StringName& p_dentifier) const;
-		HashMap<Variant,int,VariantHasher,VariantComparator> constant_map;
-		Map<StringName,int> name_map;
+		HashMap<Variant, int, VariantHasher, VariantComparator> constant_map;
+		Map<StringName, int> name_map;
 
-		int get_name_map_pos(const StringName& p_identifier) {
+		int get_name_map_pos(const StringName &p_identifier) {
 			int ret;
 			if (!name_map.has(p_identifier)) {
-				ret=name_map.size();
-				name_map[p_identifier]=ret;
+				ret = name_map.size();
+				name_map[p_identifier] = ret;
 			} else {
-				ret=name_map[p_identifier];
+				ret = name_map[p_identifier];
 			}
 			return ret;
 		}
 
-		int get_constant_pos(const Variant& p_constant) {
+		int get_constant_pos(const Variant &p_constant) {
 			if (constant_map.has(p_constant))
 				return constant_map[p_constant];
 			int pos = constant_map.size();
-			constant_map[p_constant]=pos;
+			constant_map[p_constant] = pos;
 			return pos;
 		}
 
 		Vector<int> opcodes;
-		void alloc_stack(int p_level) { if (p_level >= stack_max) stack_max=p_level+1; }
-		void alloc_call(int p_params) { if (p_params >= call_max) call_max=p_params; }
+		void alloc_stack(int p_level) {
+			if (p_level >= stack_max) stack_max = p_level + 1;
+		}
+		void alloc_call(int p_params) {
+			if (p_params >= call_max) call_max = p_params;
+		}
 
-        	int current_line;
+		int current_line;
 		int stack_max;
 		int call_max;
 	};
@@ -135,28 +137,27 @@ class GDCompiler {
 	Ref<GDScript> _parse_class(GDParser::ClassNode *p_class);
 #endif
 
-	bool _is_class_member_property(CodeGen & codegen, const StringName & p_name);
-	bool _is_class_member_property(GDScript *owner, const StringName & p_name);
+	bool _is_class_member_property(CodeGen &codegen, const StringName &p_name);
+	bool _is_class_member_property(GDScript *owner, const StringName &p_name);
 
-	void _set_error(const String& p_error,const GDParser::Node *p_node);
+	void _set_error(const String &p_error, const GDParser::Node *p_node);
 
-	bool _create_unary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level);
-	bool _create_binary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level,bool p_initializer=false);
+	bool _create_unary_operator(CodeGen &codegen, const GDParser::OperatorNode *on, Variant::Operator op, int p_stack_level);
+	bool _create_binary_operator(CodeGen &codegen, const GDParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer = false);
 
 	//int _parse_subexpression(CodeGen& codegen,const GDParser::BlockNode *p_block,const GDParser::Node *p_expression);
-	int _parse_assign_right_expression(CodeGen& codegen,const GDParser::OperatorNode *p_expression, int p_stack_level);
-	int _parse_expression(CodeGen& codegen,const GDParser::Node *p_expression, int p_stack_level,bool p_root=false,bool p_initializer=false);
-	Error _parse_block(CodeGen& codegen,const GDParser::BlockNode *p_block,int p_stack_level=0,int p_break_addr=-1,int p_continue_addr=-1);
-	Error _parse_function(GDScript *p_script,const GDParser::ClassNode *p_class,const GDParser::FunctionNode *p_func,bool p_for_ready=false);
-	Error _parse_class(GDScript *p_script,GDScript *p_owner,const GDParser::ClassNode *p_class,bool p_keep_state);
+	int _parse_assign_right_expression(CodeGen &codegen, const GDParser::OperatorNode *p_expression, int p_stack_level);
+	int _parse_expression(CodeGen &codegen, const GDParser::Node *p_expression, int p_stack_level, bool p_root = false, bool p_initializer = false);
+	Error _parse_block(CodeGen &codegen, const GDParser::BlockNode *p_block, int p_stack_level = 0, int p_break_addr = -1, int p_continue_addr = -1);
+	Error _parse_function(GDScript *p_script, const GDParser::ClassNode *p_class, const GDParser::FunctionNode *p_func, bool p_for_ready = false);
+	Error _parse_class(GDScript *p_script, GDScript *p_owner, const GDParser::ClassNode *p_class, bool p_keep_state);
 	int err_line;
 	int err_column;
 	StringName source;
 	String error;
 
 public:
-
-	Error compile(const GDParser *p_parser, GDScript *p_script, bool p_keep_state=false);
+	Error compile(const GDParser *p_parser, GDScript *p_script, bool p_keep_state = false);
 
 	String get_error() const;
 	int get_error_line() const;
@@ -165,5 +166,4 @@ public:
 	GDCompiler();
 };
 
-
 #endif // COMPILER_H
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;
 }
 
diff --git a/modules/gdscript/gd_function.cpp b/modules/gdscript/gd_function.cpp
index 519fb1cd8c..aaf97001e9 100644
--- a/modules/gdscript/gd_function.cpp
+++ b/modules/gdscript/gd_function.cpp
@@ -28,21 +28,21 @@
 /*************************************************************************/
 #include "gd_function.h"
 
+#include "gd_functions.h"
 #include "gd_script.h"
 #include "os/os.h"
-#include "gd_functions.h"
 
-Variant *GDFunction::_get_variant(int p_address,GDInstance *p_instance,GDScript *p_script,Variant &self, Variant *p_stack,String& r_error) const{
+Variant *GDFunction::_get_variant(int p_address, GDInstance *p_instance, GDScript *p_script, Variant &self, Variant *p_stack, String &r_error) const {
 
-	int address = p_address&ADDR_MASK;
+	int address = p_address & ADDR_MASK;
 
 	//sequential table (jump table generated by compiler)
-	switch((p_address&ADDR_TYPE_MASK)>>ADDR_BITS) {
+	switch ((p_address & ADDR_TYPE_MASK) >> ADDR_BITS) {
 
 		case ADDR_TYPE_SELF: {
 
 			if (!p_instance) {
-				r_error="Cannot access self without instance.";
+				r_error = "Cannot access self without instance.";
 				return NULL;
 			}
 			return &self;
@@ -54,7 +54,7 @@ Variant *GDFunction::_get_variant(int p_address,GDInstance *p_instance,GDScript
 		case ADDR_TYPE_MEMBER: {
 			//member indexing is O(1)
 			if (!p_instance) {
-				r_error="Cannot access member without instance.";
+				r_error = "Cannot access member without instance.";
 				return NULL;
 			}
 			return &p_instance->members[address];
@@ -62,41 +62,38 @@ Variant *GDFunction::_get_variant(int p_address,GDInstance *p_instance,GDScript
 		case ADDR_TYPE_CLASS_CONSTANT: {
 
 			//todo change to index!
-			GDScript *o=p_script;
-			ERR_FAIL_INDEX_V(address,_global_names_count,NULL);
+			GDScript *o = p_script;
+			ERR_FAIL_INDEX_V(address, _global_names_count, NULL);
 			const StringName *sn = &_global_names_ptr[address];
 
-			while(o) {
-				GDScript *s=o;
-				while(s) {
+			while (o) {
+				GDScript *s = o;
+				while (s) {
 
-					Map<StringName,Variant>::Element *E=s->constants.find(*sn);
+					Map<StringName, Variant>::Element *E = s->constants.find(*sn);
 					if (E) {
 						return &E->get();
 					}
-					s=s->_base;
+					s = s->_base;
 				}
-				o=o->_owner;
+				o = o->_owner;
 			}
 
-
 			ERR_EXPLAIN("GDCompiler bug..");
 			ERR_FAIL_V(NULL);
 		} break;
 		case ADDR_TYPE_LOCAL_CONSTANT: {
-			ERR_FAIL_INDEX_V(address,_constant_count,NULL);
+			ERR_FAIL_INDEX_V(address, _constant_count, NULL);
 			return &_constants_ptr[address];
 		} break;
 		case ADDR_TYPE_STACK:
 		case ADDR_TYPE_STACK_VARIABLE: {
-			ERR_FAIL_INDEX_V(address,_stack_size,NULL);
+			ERR_FAIL_INDEX_V(address, _stack_size, NULL);
 			return &p_stack[address];
 		} break;
 		case ADDR_TYPE_GLOBAL: {
 
-
-			ERR_FAIL_INDEX_V(address,GDScriptLanguage::get_singleton()->get_global_array_size(),NULL);
-
+			ERR_FAIL_INDEX_V(address, GDScriptLanguage::get_singleton()->get_global_array_size(), NULL);
 
 			return &GDScriptLanguage::get_singleton()->get_global_array()[address];
 		} break;
@@ -110,37 +107,33 @@ Variant *GDFunction::_get_variant(int p_address,GDInstance *p_instance,GDScript
 	return NULL;
 }
 
-
-String GDFunction::_get_call_error(const Variant::CallError& p_err, const String& p_where,const Variant**argptrs) const {
-
-
+String GDFunction::_get_call_error(const Variant::CallError &p_err, const String &p_where, const Variant **argptrs) const {
 
 	String err_text;
 
-	if (p_err.error==Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
-		int errorarg=p_err.argument;
-		err_text="Invalid type in "+p_where+". Cannot convert argument "+itos(errorarg+1)+" from "+Variant::get_type_name(argptrs[errorarg]->get_type())+" to "+Variant::get_type_name(p_err.expected)+".";
-	} else if (p_err.error==Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
-		err_text="Invalid call to "+p_where+". Expected "+itos(p_err.argument)+" arguments.";
-	} else if (p_err.error==Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
-		err_text="Invalid call to "+p_where+". Expected "+itos(p_err.argument)+" arguments.";
-	} else if (p_err.error==Variant::CallError::CALL_ERROR_INVALID_METHOD) {
-		err_text="Invalid call. Nonexistent "+p_where+".";
-	} else if (p_err.error==Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
-		err_text="Attempt to call "+p_where+" on a null instance.";
+	if (p_err.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
+		int errorarg = p_err.argument;
+		err_text = "Invalid type in " + p_where + ". Cannot convert argument " + itos(errorarg + 1) + " from " + Variant::get_type_name(argptrs[errorarg]->get_type()) + " to " + Variant::get_type_name(p_err.expected) + ".";
+	} else if (p_err.error == Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
+		err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.argument) + " arguments.";
+	} else if (p_err.error == Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
+		err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.argument) + " arguments.";
+	} else if (p_err.error == Variant::CallError::CALL_ERROR_INVALID_METHOD) {
+		err_text = "Invalid call. Nonexistent " + p_where + ".";
+	} else if (p_err.error == Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
+		err_text = "Attempt to call " + p_where + " on a null instance.";
 	} else {
-		err_text="Bug, call error: #"+itos(p_err.error);
+		err_text = "Bug, call error: #" + itos(p_err.error);
 	}
 
 	return err_text;
-
 }
 
-static String _get_var_type(const Variant* p_type) {
+static String _get_var_type(const Variant *p_type) {
 
 	String basestr;
 
-	if (p_type->get_type()==Variant::OBJECT) {
+	if (p_type->get_type() == Variant::OBJECT) {
 		Object *bobj = *p_type;
 		if (!bobj) {
 			basestr = "null instance";
@@ -148,15 +141,15 @@ static String _get_var_type(const Variant* p_type) {
 #ifdef DEBUG_ENABLED
 			if (ObjectDB::instance_validate(bobj)) {
 				if (bobj->get_script_instance())
-					basestr= bobj->get_class()+" ("+bobj->get_script_instance()->get_script()->get_path().get_file()+")";
+					basestr = bobj->get_class() + " (" + bobj->get_script_instance()->get_script()->get_path().get_file() + ")";
 				else
 					basestr = bobj->get_class();
 			} else {
-				basestr="previously freed instance";
+				basestr = "previously freed instance";
 			}
 
 #else
-			basestr="Object";
+			basestr = "Object";
 #endif
 		}
 
@@ -165,114 +158,108 @@ static String _get_var_type(const Variant* p_type) {
 	}
 
 	return basestr;
-
 }
 
-Variant GDFunction::call(GDInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError& r_err, CallState *p_state) {
-
+Variant GDFunction::call(GDInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError &r_err, CallState *p_state) {
 
 	if (!_code_ptr) {
 
 		return Variant();
 	}
 
-	r_err.error=Variant::CallError::CALL_OK;
+	r_err.error = Variant::CallError::CALL_OK;
 
 	Variant self;
 	Variant retvalue;
 	Variant *stack = NULL;
 	Variant **call_args;
-	int defarg=0;
+	int defarg = 0;
 
 #ifdef DEBUG_ENABLED
 
-	//GDScriptLanguage::get_singleton()->calls++;
+//GDScriptLanguage::get_singleton()->calls++;
 
 #endif
 
-	uint32_t alloca_size=0;
+	uint32_t alloca_size = 0;
 	GDScript *_class;
-	int ip=0;
-	int line=_initial_line;
-
-
+	int ip = 0;
+	int line = _initial_line;
 
 	if (p_state) {
 		//use existing (supplied) state (yielded)
-		stack=(Variant*)p_state->stack.ptr();
-		call_args=(Variant**)stack + sizeof(Variant)*p_state->stack_size;
-		line=p_state->line;
-		ip=p_state->ip;
-		alloca_size=p_state->stack.size();
-		_class=p_state->_class;
-		p_instance=p_state->instance;
-		defarg=p_state->defarg;
-		self=p_state->self;
+		stack = (Variant *)p_state->stack.ptr();
+		call_args = (Variant **)stack + sizeof(Variant) * p_state->stack_size;
+		line = p_state->line;
+		ip = p_state->ip;
+		alloca_size = p_state->stack.size();
+		_class = p_state->_class;
+		p_instance = p_state->instance;
+		defarg = p_state->defarg;
+		self = p_state->self;
 		//stack[p_state->result_pos]=p_state->result; //assign stack with result
 
 	} else {
 
-		if (p_argcount!=_argument_count) {
-
-			if (p_argcount>_argument_count) {
+		if (p_argcount != _argument_count) {
 
-				r_err.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
-				r_err.argument=_argument_count;
+			if (p_argcount > _argument_count) {
 
+				r_err.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+				r_err.argument = _argument_count;
 
 				return Variant();
 			} else if (p_argcount < _argument_count - _default_arg_count) {
 
-				r_err.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
-				r_err.argument=_argument_count - _default_arg_count;
+				r_err.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+				r_err.argument = _argument_count - _default_arg_count;
 				return Variant();
 			} else {
 
-				defarg=_argument_count-p_argcount;
+				defarg = _argument_count - p_argcount;
 			}
 		}
 
-		alloca_size = sizeof(Variant*)*_call_size + sizeof(Variant)*_stack_size;
+		alloca_size = sizeof(Variant *) * _call_size + sizeof(Variant) * _stack_size;
 
 		if (alloca_size) {
 
-			uint8_t *aptr = (uint8_t*)alloca(alloca_size);
+			uint8_t *aptr = (uint8_t *)alloca(alloca_size);
 
 			if (_stack_size) {
 
-				stack=(Variant*)aptr;
-				for(int i=0;i<p_argcount;i++)
-					memnew_placement(&stack[i],Variant(*p_args[i]));
-				for(int i=p_argcount;i<_stack_size;i++)
-					memnew_placement(&stack[i],Variant);
+				stack = (Variant *)aptr;
+				for (int i = 0; i < p_argcount; i++)
+					memnew_placement(&stack[i], Variant(*p_args[i]));
+				for (int i = p_argcount; i < _stack_size; i++)
+					memnew_placement(&stack[i], Variant);
 			} else {
-				stack=NULL;
+				stack = NULL;
 			}
 
 			if (_call_size) {
 
-				call_args = (Variant**)&aptr[sizeof(Variant)*_stack_size];
+				call_args = (Variant **)&aptr[sizeof(Variant) * _stack_size];
 			} else {
 
-				call_args=NULL;
+				call_args = NULL;
 			}
 
-
 		} else {
-			stack=NULL;
-			call_args=NULL;
+			stack = NULL;
+			call_args = NULL;
 		}
 
 		if (p_instance) {
-			if (p_instance->base_ref && static_cast<Reference*>(p_instance->owner)->is_referenced()) {
+			if (p_instance->base_ref && static_cast<Reference *>(p_instance->owner)->is_referenced()) {
 
-				self=REF(static_cast<Reference*>(p_instance->owner));
+				self = REF(static_cast<Reference *>(p_instance->owner));
 			} else {
-				self=p_instance->owner;
+				self = p_instance->owner;
 			}
-			_class=p_instance->script.ptr();
+			_class = p_instance->script.ptr();
 		} else {
-			_class=_script;
+			_class = _script;
 		}
 	}
 
@@ -281,537 +268,519 @@ Variant GDFunction::call(GDInstance *p_instance, const Variant **p_args, int p_a
 #ifdef DEBUG_ENABLED
 
 	if (ScriptDebugger::get_singleton())
-		GDScriptLanguage::get_singleton()->enter_function(p_instance,this,stack,&ip,&line);
-
-#define CHECK_SPACE(m_space)\
-	ERR_BREAK((ip+m_space)>_code_size)
+		GDScriptLanguage::get_singleton()->enter_function(p_instance, this, stack, &ip, &line);
 
-#define GET_VARIANT_PTR(m_v,m_code_ofs) \
-	Variant *m_v; \
-	m_v = _get_variant(_code_ptr[ip+m_code_ofs],p_instance,_class,self,stack,err_text);\
-	if (!m_v)\
-	break;
+#define CHECK_SPACE(m_space) \
+	ERR_BREAK((ip + m_space) > _code_size)
 
+#define GET_VARIANT_PTR(m_v, m_code_ofs)                                                       \
+	Variant *m_v;                                                                              \
+	m_v = _get_variant(_code_ptr[ip + m_code_ofs], p_instance, _class, self, stack, err_text); \
+	if (!m_v)                                                                                  \
+		break;
 
 #else
 #define CHECK_SPACE(m_space)
-#define GET_VARIANT_PTR(m_v,m_code_ofs) \
-	Variant *m_v; \
-	m_v = _get_variant(_code_ptr[ip+m_code_ofs],p_instance,_class,self,stack,err_text);
+#define GET_VARIANT_PTR(m_v, m_code_ofs) \
+	Variant *m_v;                        \
+	m_v = _get_variant(_code_ptr[ip + m_code_ofs], p_instance, _class, self, stack, err_text);
 
 #endif
 
-
 #ifdef DEBUG_ENABLED
 
 	uint64_t function_start_time;
 	uint64_t function_call_time;
 
 	if (GDScriptLanguage::get_singleton()->profiling) {
-		function_start_time=OS::get_singleton()->get_ticks_usec();
-		function_call_time=0;
+		function_start_time = OS::get_singleton()->get_ticks_usec();
+		function_call_time = 0;
 		profile.call_count++;
 		profile.frame_call_count++;
 	}
 #endif
-	bool exit_ok=false;
+	bool exit_ok = false;
 
-	while(ip<_code_size) {
+	while (ip < _code_size) {
 
-
-		int last_opcode=_code_ptr[ip];
-		switch(_code_ptr[ip]) {
+		int last_opcode = _code_ptr[ip];
+		switch (_code_ptr[ip]) {
 
 			case OPCODE_OPERATOR: {
 
 				CHECK_SPACE(5);
 
 				bool valid;
-				Variant::Operator op = (Variant::Operator)_code_ptr[ip+1];
-				ERR_BREAK(op>=Variant::OP_MAX);
+				Variant::Operator op = (Variant::Operator)_code_ptr[ip + 1];
+				ERR_BREAK(op >= Variant::OP_MAX);
 
-				GET_VARIANT_PTR(a,2);
-				GET_VARIANT_PTR(b,3);
-				GET_VARIANT_PTR(dst,4);
+				GET_VARIANT_PTR(a, 2);
+				GET_VARIANT_PTR(b, 3);
+				GET_VARIANT_PTR(dst, 4);
 
 #ifdef DEBUG_ENABLED
 				Variant ret;
-				Variant::evaluate(op,*a,*b,ret,valid);
+				Variant::evaluate(op, *a, *b, ret, valid);
 #else
-				Variant::evaluate(op,*a,*b,*dst,valid);
+				Variant::evaluate(op, *a, *b, *dst, valid);
 #endif
 
 				if (!valid) {
 #ifdef DEBUG_ENABLED
 
-					if (ret.get_type()==Variant::STRING) {
+					if (ret.get_type() == Variant::STRING) {
 						//return a string when invalid with the error
-						err_text=ret;
-						err_text += " in operator '"+Variant::get_operator_name(op)+"'.";
+						err_text = ret;
+						err_text += " in operator '" + Variant::get_operator_name(op) + "'.";
 					} else {
-						err_text="Invalid operands '"+Variant::get_type_name(a->get_type())+"' and '"+Variant::get_type_name(b->get_type())+"' in operator '"+Variant::get_operator_name(op)+"'.";
+						err_text = "Invalid operands '" + Variant::get_type_name(a->get_type()) + "' and '" + Variant::get_type_name(b->get_type()) + "' in operator '" + Variant::get_operator_name(op) + "'.";
 					}
 #endif
 					break;
-
 				}
 #ifdef DEBUG_ENABLED
-				*dst=ret;
+				*dst = ret;
 #endif
 
-				ip+=5;
+				ip += 5;
 				continue;
 			}
 			case OPCODE_EXTENDS_TEST: {
 
 				CHECK_SPACE(4);
 
-				GET_VARIANT_PTR(a,1);
-				GET_VARIANT_PTR(b,2);
-				GET_VARIANT_PTR(dst,3);
+				GET_VARIANT_PTR(a, 1);
+				GET_VARIANT_PTR(b, 2);
+				GET_VARIANT_PTR(dst, 3);
 
 #ifdef DEBUG_ENABLED
 
-				if (a->get_type()!=Variant::OBJECT || a->operator Object*()==NULL) {
+				if (a->get_type() != Variant::OBJECT || a->operator Object *() == NULL) {
 
-					err_text="Left operand of 'extends' is not an instance of anything.";
+					err_text = "Left operand of 'extends' is not an instance of anything.";
 					break;
-
 				}
-				if (b->get_type()!=Variant::OBJECT || b->operator Object*()==NULL) {
+				if (b->get_type() != Variant::OBJECT || b->operator Object *() == NULL) {
 
-					err_text="Right operand of 'extends' is not a class.";
+					err_text = "Right operand of 'extends' is not a class.";
 					break;
-
 				}
 #endif
 
-
 				Object *obj_A = *a;
 				Object *obj_B = *b;
 
-
 				GDScript *scr_B = obj_B->cast_to<GDScript>();
 
-				bool extends_ok=false;
+				bool extends_ok = false;
 
 				if (scr_B) {
 					//if B is a script, the only valid condition is that A has an instance which inherits from the script
 					//in other situation, this shoul return false.
 
-					if (obj_A->get_script_instance() && obj_A->get_script_instance()->get_language()==GDScriptLanguage::get_singleton()) {
+					if (obj_A->get_script_instance() && obj_A->get_script_instance()->get_language() == GDScriptLanguage::get_singleton()) {
 
-						GDScript *cmp = static_cast<GDScript*>(obj_A->get_script_instance()->get_script().ptr());
+						GDScript *cmp = static_cast<GDScript *>(obj_A->get_script_instance()->get_script().ptr());
 						//bool found=false;
-						while(cmp) {
+						while (cmp) {
 
-							if (cmp==scr_B) {
+							if (cmp == scr_B) {
 								//inherits from script, all ok
-								extends_ok=true;
+								extends_ok = true;
 								break;
-
 							}
 
-							cmp=cmp->_base;
+							cmp = cmp->_base;
 						}
-
 					}
 
-
 				} else {
 
-					GDNativeClass *nc= obj_B->cast_to<GDNativeClass>();
+					GDNativeClass *nc = obj_B->cast_to<GDNativeClass>();
 
 					if (!nc) {
 
-						err_text="Right operand of 'extends' is not a class (type: '"+obj_B->get_class()+"').";
+						err_text = "Right operand of 'extends' is not a class (type: '" + obj_B->get_class() + "').";
 						break;
 					}
 
-					extends_ok=ClassDB::is_parent_class(obj_A->get_class_name(),nc->get_name());
+					extends_ok = ClassDB::is_parent_class(obj_A->get_class_name(), nc->get_name());
 				}
 
-				*dst=extends_ok;
-				ip+=4;
+				*dst = extends_ok;
+				ip += 4;
 				continue;
 			}
 			case OPCODE_SET: {
 
 				CHECK_SPACE(3);
 
-				GET_VARIANT_PTR(dst,1);
-				GET_VARIANT_PTR(index,2);
-				GET_VARIANT_PTR(value,3);
+				GET_VARIANT_PTR(dst, 1);
+				GET_VARIANT_PTR(index, 2);
+				GET_VARIANT_PTR(value, 3);
 
 				bool valid;
-				dst->set(*index,*value,&valid);
+				dst->set(*index, *value, &valid);
 
 				if (!valid) {
 					String v = index->operator String();
-					if (v!="") {
-						v="'"+v+"'";
+					if (v != "") {
+						v = "'" + v + "'";
 					} else {
-						v="of type '"+_get_var_type(index)+"'";
+						v = "of type '" + _get_var_type(index) + "'";
 					}
-					err_text="Invalid set index "+v+" (on base: '"+_get_var_type(dst)+"').";
+					err_text = "Invalid set index " + v + " (on base: '" + _get_var_type(dst) + "').";
 					break;
 				}
 
-				ip+=4;
+				ip += 4;
 				continue;
 			}
 			case OPCODE_GET: {
 
 				CHECK_SPACE(3);
 
-				GET_VARIANT_PTR(src,1);
-				GET_VARIANT_PTR(index,2);
-				GET_VARIANT_PTR(dst,3);
+				GET_VARIANT_PTR(src, 1);
+				GET_VARIANT_PTR(index, 2);
+				GET_VARIANT_PTR(dst, 3);
 
 				bool valid;
 #ifdef DEBUG_ENABLED
 				//allow better error message in cases where src and dst are the same stack position
-				Variant ret = src->get(*index,&valid);
+				Variant ret = src->get(*index, &valid);
 #else
-				*dst = src->get(*index,&valid);
+				*dst = src->get(*index, &valid);
 
 #endif
 				if (!valid) {
 					String v = index->operator String();
-					if (v!="") {
-						v="'"+v+"'";
+					if (v != "") {
+						v = "'" + v + "'";
 					} else {
-						v="of type '"+_get_var_type(index)+"'";
+						v = "of type '" + _get_var_type(index) + "'";
 					}
-					err_text="Invalid get index "+v+" (on base: '"+_get_var_type(src)+"').";
+					err_text = "Invalid get index " + v + " (on base: '" + _get_var_type(src) + "').";
 					break;
 				}
 #ifdef DEBUG_ENABLED
-				*dst=ret;
+				*dst = ret;
 #endif
-				ip+=4;
+				ip += 4;
 				continue;
 			}
 			case OPCODE_SET_NAMED: {
 
 				CHECK_SPACE(3);
 
-				GET_VARIANT_PTR(dst,1);
-				GET_VARIANT_PTR(value,3);
+				GET_VARIANT_PTR(dst, 1);
+				GET_VARIANT_PTR(value, 3);
 
-				int indexname = _code_ptr[ip+2];
+				int indexname = _code_ptr[ip + 2];
 
-				ERR_BREAK(indexname<0 || indexname>=_global_names_count);
+				ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
 				const StringName *index = &_global_names_ptr[indexname];
 
 				bool valid;
-				dst->set_named(*index,*value,&valid);
+				dst->set_named(*index, *value, &valid);
 
 				if (!valid) {
 					String err_type;
-					err_text="Invalid set index '"+String(*index)+"' (on base: '"+_get_var_type(dst)+"').";
+					err_text = "Invalid set index '" + String(*index) + "' (on base: '" + _get_var_type(dst) + "').";
 					break;
 				}
 
-				ip+=4;
+				ip += 4;
 				continue;
 			}
 			case OPCODE_GET_NAMED: {
 
-
 				CHECK_SPACE(4);
 
-				GET_VARIANT_PTR(src,1);
-				GET_VARIANT_PTR(dst,3);
+				GET_VARIANT_PTR(src, 1);
+				GET_VARIANT_PTR(dst, 3);
 
-				int indexname = _code_ptr[ip+2];
+				int indexname = _code_ptr[ip + 2];
 
-				ERR_BREAK(indexname<0 || indexname>=_global_names_count);
+				ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
 				const StringName *index = &_global_names_ptr[indexname];
 
 				bool valid;
 #ifdef DEBUG_ENABLED
 				//allow better error message in cases where src and dst are the same stack position
-				Variant ret = src->get_named(*index,&valid);
+				Variant ret = src->get_named(*index, &valid);
 
 #else
-				*dst = src->get_named(*index,&valid);
+				*dst = src->get_named(*index, &valid);
 #endif
 
 				if (!valid) {
 					if (src->has_method(*index)) {
-						err_text="Invalid get index '"+index->operator String()+"' (on base: '"+_get_var_type(src)+"'). Did you mean '."+index->operator String()+"()' ?";
+						err_text = "Invalid get index '" + index->operator String() + "' (on base: '" + _get_var_type(src) + "'). Did you mean '." + index->operator String() + "()' ?";
 					} else {
-						err_text="Invalid get index '"+index->operator String()+"' (on base: '"+_get_var_type(src)+"').";
+						err_text = "Invalid get index '" + index->operator String() + "' (on base: '" + _get_var_type(src) + "').";
 					}
 					break;
 				}
 #ifdef DEBUG_ENABLED
-				*dst=ret;
+				*dst = ret;
 #endif
-				ip+=4;
+				ip += 4;
 				continue;
 			}
 			case OPCODE_SET_MEMBER: {
 
 				CHECK_SPACE(3);
-				int indexname = _code_ptr[ip+1];
-				ERR_BREAK(indexname<0 || indexname>=_global_names_count);
+				int indexname = _code_ptr[ip + 1];
+				ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
 				const StringName *index = &_global_names_ptr[indexname];
-				GET_VARIANT_PTR(src,2);
+				GET_VARIANT_PTR(src, 2);
 
 				bool valid;
-				bool ok = ClassDB::set_property(p_instance->owner,*index,*src,&valid);
+				bool ok = ClassDB::set_property(p_instance->owner, *index, *src, &valid);
 #ifdef DEBUG_ENABLED
 				if (!ok) {
-					err_text="Internal error setting property: "+String(*index);
+					err_text = "Internal error setting property: " + String(*index);
 					break;
 				} else if (!valid) {
-					err_text="Error setting property '"+String(*index)+"' with value of type "+Variant::get_type_name(src->get_type())+".";
+					err_text = "Error setting property '" + String(*index) + "' with value of type " + Variant::get_type_name(src->get_type()) + ".";
 					break;
-
 				}
 #endif
-				ip+=3;
+				ip += 3;
 				continue;
 			}
 			case OPCODE_GET_MEMBER: {
 
 				CHECK_SPACE(3);
-				int indexname = _code_ptr[ip+1];
-				ERR_BREAK(indexname<0 || indexname>=_global_names_count);
+				int indexname = _code_ptr[ip + 1];
+				ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
 				const StringName *index = &_global_names_ptr[indexname];
-				GET_VARIANT_PTR(dst,2);
-				bool ok = ClassDB::get_property(p_instance->owner,*index,*dst);
+				GET_VARIANT_PTR(dst, 2);
+				bool ok = ClassDB::get_property(p_instance->owner, *index, *dst);
 
 #ifdef DEBUG_ENABLED
 				if (!ok) {
-					err_text="Internal error getting property: "+String(*index);
+					err_text = "Internal error getting property: " + String(*index);
 					break;
 				}
 #endif
-				ip+=3;
+				ip += 3;
 				continue;
 			}
 			case OPCODE_ASSIGN: {
 
 				CHECK_SPACE(3);
-				GET_VARIANT_PTR(dst,1);
-				GET_VARIANT_PTR(src,2);
+				GET_VARIANT_PTR(dst, 1);
+				GET_VARIANT_PTR(src, 2);
 
 				*dst = *src;
 
-				ip+=3;
+				ip += 3;
 				continue;
 			}
 			case OPCODE_ASSIGN_TRUE: {
 
 				CHECK_SPACE(2);
-				GET_VARIANT_PTR(dst,1);
+				GET_VARIANT_PTR(dst, 1);
 
 				*dst = true;
 
-				ip+=2;
+				ip += 2;
 				continue;
 			}
 			case OPCODE_ASSIGN_FALSE: {
 
 				CHECK_SPACE(2);
-				GET_VARIANT_PTR(dst,1);
+				GET_VARIANT_PTR(dst, 1);
 
 				*dst = false;
 
-				ip+=2;
+				ip += 2;
 				continue;
 			}
 			case OPCODE_CONSTRUCT: {
 
 				CHECK_SPACE(2);
-				Variant::Type t=Variant::Type(_code_ptr[ip+1]);
-				int argc=_code_ptr[ip+2];
-				CHECK_SPACE(argc+2);
+				Variant::Type t = Variant::Type(_code_ptr[ip + 1]);
+				int argc = _code_ptr[ip + 2];
+				CHECK_SPACE(argc + 2);
 				Variant **argptrs = call_args;
-				for(int i=0;i<argc;i++) {
-					GET_VARIANT_PTR(v,3+i);
-					argptrs[i]=v;
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, 3 + i);
+					argptrs[i] = v;
 				}
 
-				GET_VARIANT_PTR(dst,3+argc);
+				GET_VARIANT_PTR(dst, 3 + argc);
 				Variant::CallError err;
-				*dst = Variant::construct(t,(const Variant**)argptrs,argc,err);
+				*dst = Variant::construct(t, (const Variant **)argptrs, argc, err);
 
-				if (err.error!=Variant::CallError::CALL_OK) {
+				if (err.error != Variant::CallError::CALL_OK) {
 
-					err_text=_get_call_error(err,"'"+Variant::get_type_name(t)+"' constructor",(const Variant**)argptrs);
+					err_text = _get_call_error(err, "'" + Variant::get_type_name(t) + "' constructor", (const Variant **)argptrs);
 					break;
 				}
 
-				ip+=4+argc;
+				ip += 4 + argc;
 				//construct a basic type
 				continue;
 			}
 			case OPCODE_CONSTRUCT_ARRAY: {
 
 				CHECK_SPACE(1);
-				int argc=_code_ptr[ip+1];
+				int argc = _code_ptr[ip + 1];
 				Array array; //arrays are always shared
 				array.resize(argc);
-				CHECK_SPACE(argc+2);
-
-				for(int i=0;i<argc;i++) {
-					GET_VARIANT_PTR(v,2+i);
-					array[i]=*v;
+				CHECK_SPACE(argc + 2);
 
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, 2 + i);
+					array[i] = *v;
 				}
 
-				GET_VARIANT_PTR(dst,2+argc);
+				GET_VARIANT_PTR(dst, 2 + argc);
 
-				*dst=array;
+				*dst = array;
 
-				ip+=3+argc;
+				ip += 3 + argc;
 				continue;
 			}
 			case OPCODE_CONSTRUCT_DICTIONARY: {
 
 				CHECK_SPACE(1);
-				int argc=_code_ptr[ip+1];
+				int argc = _code_ptr[ip + 1];
 				Dictionary dict; //arrays are always shared
 
-				CHECK_SPACE(argc*2+2);
+				CHECK_SPACE(argc * 2 + 2);
 
-				for(int i=0;i<argc;i++) {
-
-					GET_VARIANT_PTR(k,2+i*2+0);
-					GET_VARIANT_PTR(v,2+i*2+1);
-					dict[*k]=*v;
+				for (int i = 0; i < argc; i++) {
 
+					GET_VARIANT_PTR(k, 2 + i * 2 + 0);
+					GET_VARIANT_PTR(v, 2 + i * 2 + 1);
+					dict[*k] = *v;
 				}
 
-				GET_VARIANT_PTR(dst,2+argc*2);
+				GET_VARIANT_PTR(dst, 2 + argc * 2);
 
-				*dst=dict;
+				*dst = dict;
 
-				ip+=3+argc*2;
+				ip += 3 + argc * 2;
 				continue;
 			}
 			case OPCODE_CALL_RETURN:
 			case OPCODE_CALL: {
 
-
 				CHECK_SPACE(4);
-				bool call_ret = _code_ptr[ip]==OPCODE_CALL_RETURN;
+				bool call_ret = _code_ptr[ip] == OPCODE_CALL_RETURN;
 
-				int argc=_code_ptr[ip+1];
-				GET_VARIANT_PTR(base,2);
-				int nameg=_code_ptr[ip+3];
+				int argc = _code_ptr[ip + 1];
+				GET_VARIANT_PTR(base, 2);
+				int nameg = _code_ptr[ip + 3];
 
-				ERR_BREAK(nameg<0 || nameg>=_global_names_count);
+				ERR_BREAK(nameg < 0 || nameg >= _global_names_count);
 				const StringName *methodname = &_global_names_ptr[nameg];
 
-				ERR_BREAK(argc<0);
-				ip+=4;
-				CHECK_SPACE(argc+1);
+				ERR_BREAK(argc < 0);
+				ip += 4;
+				CHECK_SPACE(argc + 1);
 				Variant **argptrs = call_args;
 
-				for(int i=0;i<argc;i++) {
-					GET_VARIANT_PTR(v,i);
-					argptrs[i]=v;
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, i);
+					argptrs[i] = v;
 				}
 
 #ifdef DEBUG_ENABLED
 				uint64_t call_time;
 
 				if (GDScriptLanguage::get_singleton()->profiling) {
-					call_time=OS::get_singleton()->get_ticks_usec();
+					call_time = OS::get_singleton()->get_ticks_usec();
 				}
 
 #endif
 				Variant::CallError err;
 				if (call_ret) {
 
-					GET_VARIANT_PTR(ret,argc);
-					base->call_ptr(*methodname,(const Variant**)argptrs,argc,ret,err);
+					GET_VARIANT_PTR(ret, argc);
+					base->call_ptr(*methodname, (const Variant **)argptrs, argc, ret, err);
 				} else {
 
-					base->call_ptr(*methodname,(const Variant**)argptrs,argc,NULL,err);
+					base->call_ptr(*methodname, (const Variant **)argptrs, argc, NULL, err);
 				}
 #ifdef DEBUG_ENABLED
 				if (GDScriptLanguage::get_singleton()->profiling) {
-					function_call_time+=OS::get_singleton()->get_ticks_usec() - call_time;
+					function_call_time += OS::get_singleton()->get_ticks_usec() - call_time;
 				}
 #endif
 
-				if (err.error!=Variant::CallError::CALL_OK) {
-
+				if (err.error != Variant::CallError::CALL_OK) {
 
 					String methodstr = *methodname;
 					String basestr = _get_var_type(base);
 
-					if (methodstr=="call") {
-						if (argc>=1) {
-							methodstr=String(*argptrs[0])+" (via call)";
-							if (err.error==Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
-								err.argument-=1;
+					if (methodstr == "call") {
+						if (argc >= 1) {
+							methodstr = String(*argptrs[0]) + " (via call)";
+							if (err.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
+								err.argument -= 1;
 							}
 						}
-					} else if (methodstr=="free") {
+					} else if (methodstr == "free") {
 
-						if (err.error==Variant::CallError::CALL_ERROR_INVALID_METHOD) {
+						if (err.error == Variant::CallError::CALL_ERROR_INVALID_METHOD) {
 
 							if (base->is_ref()) {
-								err_text="Attempted to free a reference.";
+								err_text = "Attempted to free a reference.";
 								break;
-							} else if (base->get_type()==Variant::OBJECT) {
+							} else if (base->get_type() == Variant::OBJECT) {
 
-								err_text="Attempted to free a locked object (calling or emitting).";
+								err_text = "Attempted to free a locked object (calling or emitting).";
 								break;
 							}
 						}
 					}
-					err_text=_get_call_error(err,"function '"+methodstr+"' in base '"+basestr+"'",(const Variant**)argptrs);
+					err_text = _get_call_error(err, "function '" + methodstr + "' in base '" + basestr + "'", (const Variant **)argptrs);
 					break;
 				}
 
 				//_call_func(NULL,base,*methodname,ip,argc,p_instance,stack);
-				ip+=argc+1;
+				ip += argc + 1;
 				continue;
 			}
 			case OPCODE_CALL_BUILT_IN: {
 
 				CHECK_SPACE(4);
 
-				GDFunctions::Function func = GDFunctions::Function(_code_ptr[ip+1]);
-				int argc=_code_ptr[ip+2];
-				ERR_BREAK(argc<0);
+				GDFunctions::Function func = GDFunctions::Function(_code_ptr[ip + 1]);
+				int argc = _code_ptr[ip + 2];
+				ERR_BREAK(argc < 0);
 
-				ip+=3;
-				CHECK_SPACE(argc+1);
+				ip += 3;
+				CHECK_SPACE(argc + 1);
 				Variant **argptrs = call_args;
 
-				for(int i=0;i<argc;i++) {
-					GET_VARIANT_PTR(v,i);
-					argptrs[i]=v;
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, i);
+					argptrs[i] = v;
 				}
 
-				GET_VARIANT_PTR(dst,argc);
+				GET_VARIANT_PTR(dst, argc);
 
 				Variant::CallError err;
 
-				GDFunctions::call(func,(const Variant**)argptrs,argc,*dst,err);
-
-				if (err.error!=Variant::CallError::CALL_OK) {
+				GDFunctions::call(func, (const Variant **)argptrs, argc, *dst, err);
 
+				if (err.error != Variant::CallError::CALL_OK) {
 
 					String methodstr = GDFunctions::get_func_name(func);
-					if (dst->get_type()==Variant::STRING) {
+					if (dst->get_type() == Variant::STRING) {
 						//call provided error string
-						err_text="Error calling built-in function '"+methodstr+"': "+String(*dst);
+						err_text = "Error calling built-in function '" + methodstr + "': " + String(*dst);
 					} else {
-						err_text=_get_call_error(err,"built-in function '"+methodstr+"'",(const Variant**)argptrs);
+						err_text = _get_call_error(err, "built-in function '" + methodstr + "'", (const Variant **)argptrs);
 					}
 					break;
 				}
-				ip+=argc+1;
+				ip += argc + 1;
 				continue;
 			}
 			case OPCODE_CALL_SELF: {
@@ -821,37 +790,36 @@ Variant GDFunction::call(GDInstance *p_instance, const Variant **p_args, int p_a
 			case OPCODE_CALL_SELF_BASE: {
 
 				CHECK_SPACE(2);
-				int self_fun = _code_ptr[ip+1];
+				int self_fun = _code_ptr[ip + 1];
 #ifdef DEBUG_ENABLED
 
-				if (self_fun<0 || self_fun>=_global_names_count) {
+				if (self_fun < 0 || self_fun >= _global_names_count) {
 
-					err_text="compiler bug, function name not found";
+					err_text = "compiler bug, function name not found";
 					break;
 				}
 #endif
 				const StringName *methodname = &_global_names_ptr[self_fun];
 
-				int argc=_code_ptr[ip+2];
+				int argc = _code_ptr[ip + 2];
 
-				CHECK_SPACE(2+argc+1);
+				CHECK_SPACE(2 + argc + 1);
 
 				Variant **argptrs = call_args;
 
-				for(int i=0;i<argc;i++) {
-					GET_VARIANT_PTR(v,i+3);
-					argptrs[i]=v;
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, i + 3);
+					argptrs[i] = v;
 				}
 
-				GET_VARIANT_PTR(dst,argc+3);
+				GET_VARIANT_PTR(dst, argc + 3);
 
 				const GDScript *gds = _script;
 
-
-				const Map<StringName,GDFunction*>::Element *E=NULL;
+				const Map<StringName, GDFunction *>::Element *E = NULL;
 				while (gds->base.ptr()) {
-					gds=gds->base.ptr();
-					E=gds->member_functions.find(*methodname);
+					gds = gds->base.ptr();
+					E = gds->member_functions.find(*methodname);
 					if (E)
 						break;
 				}
@@ -860,344 +828,332 @@ Variant GDFunction::call(GDInstance *p_instance, const Variant **p_args, int p_a
 
 				if (E) {
 
-					*dst=E->get()->call(p_instance,(const Variant**)argptrs,argc,err);
+					*dst = E->get()->call(p_instance, (const Variant **)argptrs, argc, err);
 				} else if (gds->native.ptr()) {
 
-					if (*methodname!=GDScriptLanguage::get_singleton()->strings._init) {
+					if (*methodname != GDScriptLanguage::get_singleton()->strings._init) {
 
-						MethodBind *mb = ClassDB::get_method(gds->native->get_name(),*methodname);
+						MethodBind *mb = ClassDB::get_method(gds->native->get_name(), *methodname);
 						if (!mb) {
-							err.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+							err.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 						} else {
-							*dst=mb->call(p_instance->owner,(const Variant**)argptrs,argc,err);
+							*dst = mb->call(p_instance->owner, (const Variant **)argptrs, argc, err);
 						}
 					} else {
-						err.error=Variant::CallError::CALL_OK;
+						err.error = Variant::CallError::CALL_OK;
 					}
 				} else {
 
-					if (*methodname!=GDScriptLanguage::get_singleton()->strings._init) {
-						err.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					if (*methodname != GDScriptLanguage::get_singleton()->strings._init) {
+						err.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 					} else {
-						err.error=Variant::CallError::CALL_OK;
+						err.error = Variant::CallError::CALL_OK;
 					}
 				}
 
-
-				if (err.error!=Variant::CallError::CALL_OK) {
-
+				if (err.error != Variant::CallError::CALL_OK) {
 
 					String methodstr = *methodname;
-					err_text=_get_call_error(err,"function '"+methodstr+"'",(const Variant**)argptrs);
+					err_text = _get_call_error(err, "function '" + methodstr + "'", (const Variant **)argptrs);
 
 					break;
 				}
 
-				ip+=4+argc;
+				ip += 4 + argc;
 				continue;
 			}
 			case OPCODE_YIELD:
 			case OPCODE_YIELD_SIGNAL: {
 
-				int ipofs=1;
-				if (_code_ptr[ip]==OPCODE_YIELD_SIGNAL) {
+				int ipofs = 1;
+				if (_code_ptr[ip] == OPCODE_YIELD_SIGNAL) {
 					CHECK_SPACE(4);
-					ipofs+=2;
+					ipofs += 2;
 				} else {
 					CHECK_SPACE(2);
-
 				}
 
-				Ref<GDFunctionState> gdfs = memnew( GDFunctionState );
-				gdfs->function=this;
+				Ref<GDFunctionState> gdfs = memnew(GDFunctionState);
+				gdfs->function = this;
 
 				gdfs->state.stack.resize(alloca_size);
 				//copy variant stack
-				for(int i=0;i<_stack_size;i++) {
-					memnew_placement(&gdfs->state.stack[sizeof(Variant)*i],Variant(stack[i]));
+				for (int i = 0; i < _stack_size; i++) {
+					memnew_placement(&gdfs->state.stack[sizeof(Variant) * i], Variant(stack[i]));
 				}
-				gdfs->state.stack_size=_stack_size;
-				gdfs->state.self=self;
-				gdfs->state.alloca_size=alloca_size;
-				gdfs->state._class=_class;
-				gdfs->state.ip=ip+ipofs;
-				gdfs->state.line=line;
-				gdfs->state.instance_id=(p_instance && p_instance->get_owner())?p_instance->get_owner()->get_instance_ID():0;
-				gdfs->state.script_id=_class->get_instance_ID();
+				gdfs->state.stack_size = _stack_size;
+				gdfs->state.self = self;
+				gdfs->state.alloca_size = alloca_size;
+				gdfs->state._class = _class;
+				gdfs->state.ip = ip + ipofs;
+				gdfs->state.line = line;
+				gdfs->state.instance_id = (p_instance && p_instance->get_owner()) ? p_instance->get_owner()->get_instance_ID() : 0;
+				gdfs->state.script_id = _class->get_instance_ID();
 				//gdfs->state.result_pos=ip+ipofs-1;
-				gdfs->state.defarg=defarg;
-				gdfs->state.instance=p_instance;
-				gdfs->function=this;
+				gdfs->state.defarg = defarg;
+				gdfs->state.instance = p_instance;
+				gdfs->function = this;
 
-				retvalue=gdfs;
+				retvalue = gdfs;
 
-				if (_code_ptr[ip]==OPCODE_YIELD_SIGNAL) {
-					GET_VARIANT_PTR(argobj,1);
-					GET_VARIANT_PTR(argname,2);
+				if (_code_ptr[ip] == OPCODE_YIELD_SIGNAL) {
+					GET_VARIANT_PTR(argobj, 1);
+					GET_VARIANT_PTR(argname, 2);
 					//do the oneshot connect
 
-					if (argobj->get_type()!=Variant::OBJECT) {
-						err_text="First argument of yield() not of type object.";
+					if (argobj->get_type() != Variant::OBJECT) {
+						err_text = "First argument of yield() not of type object.";
 						break;
 					}
-					if (argname->get_type()!=Variant::STRING) {
-						err_text="Second argument of yield() not a string (for signal name).";
+					if (argname->get_type() != Variant::STRING) {
+						err_text = "Second argument of yield() not a string (for signal name).";
 						break;
 					}
-					Object *obj=argobj->operator Object *();
+					Object *obj = argobj->operator Object *();
 					String signal = argname->operator String();
 #ifdef DEBUG_ENABLED
 
 					if (!obj) {
-						err_text="First argument of yield() is null.";
+						err_text = "First argument of yield() is null.";
 						break;
 					}
 					if (ScriptDebugger::get_singleton()) {
 						if (!ObjectDB::instance_validate(obj)) {
-							err_text="First argument of yield() is a previously freed instance.";
+							err_text = "First argument of yield() is a previously freed instance.";
 							break;
 						}
 					}
-					if (signal.length()==0) {
+					if (signal.length() == 0) {
 
-						err_text="Second argument of yield() is an empty string (for signal name).";
+						err_text = "Second argument of yield() is an empty string (for signal name).";
 						break;
 					}
 
 #endif
-					Error err = obj->connect(signal,gdfs.ptr(),"_signal_callback",varray(gdfs),Object::CONNECT_ONESHOT);
-					if (err!=OK) {
-						err_text="Error connecting to signal: "+signal+" during yield().";
+					Error err = obj->connect(signal, gdfs.ptr(), "_signal_callback", varray(gdfs), Object::CONNECT_ONESHOT);
+					if (err != OK) {
+						err_text = "Error connecting to signal: " + signal + " during yield().";
 						break;
 					}
-
-
 				}
 
-				exit_ok=true;
+				exit_ok = true;
 				break;
 			}
 			case OPCODE_YIELD_RESUME: {
 
 				CHECK_SPACE(2);
 				if (!p_state) {
-					err_text=("Invalid Resume (bug?)");
+					err_text = ("Invalid Resume (bug?)");
 					break;
 				}
-				GET_VARIANT_PTR(result,1);
-				*result=p_state->result;
-				ip+=2;
+				GET_VARIANT_PTR(result, 1);
+				*result = p_state->result;
+				ip += 2;
 				continue;
 			}
 			case OPCODE_JUMP: {
 
 				CHECK_SPACE(2);
-				int to = _code_ptr[ip+1];
+				int to = _code_ptr[ip + 1];
 
-				ERR_BREAK(to<0 || to>_code_size);
-				ip=to;
+				ERR_BREAK(to < 0 || to > _code_size);
+				ip = to;
 				continue;
 			}
 			case OPCODE_JUMP_IF: {
 
 				CHECK_SPACE(3);
 
-				GET_VARIANT_PTR(test,1);
+				GET_VARIANT_PTR(test, 1);
 
 				bool valid;
 				bool result = test->booleanize(valid);
 #ifdef DEBUG_ENABLED
 				if (!valid) {
 
-					err_text="cannot evaluate conditional expression of type: "+Variant::get_type_name(test->get_type());
+					err_text = "cannot evaluate conditional expression of type: " + Variant::get_type_name(test->get_type());
 					break;
 				}
 #endif
 				if (result) {
-					int to = _code_ptr[ip+2];
-					ERR_BREAK(to<0 || to>_code_size);
-					ip=to;
+					int to = _code_ptr[ip + 2];
+					ERR_BREAK(to < 0 || to > _code_size);
+					ip = to;
 					continue;
 				}
-				ip+=3;
+				ip += 3;
 				continue;
 			}
 			case OPCODE_JUMP_IF_NOT: {
 
 				CHECK_SPACE(3);
 
-				GET_VARIANT_PTR(test,1);
+				GET_VARIANT_PTR(test, 1);
 
 				bool valid;
 				bool result = test->booleanize(valid);
 #ifdef DEBUG_ENABLED
 				if (!valid) {
 
-					err_text="cannot evaluate conditional expression of type: "+Variant::get_type_name(test->get_type());
+					err_text = "cannot evaluate conditional expression of type: " + Variant::get_type_name(test->get_type());
 					break;
 				}
 #endif
 				if (!result) {
-					int to = _code_ptr[ip+2];
-					ERR_BREAK(to<0 || to>_code_size);
-					ip=to;
+					int to = _code_ptr[ip + 2];
+					ERR_BREAK(to < 0 || to > _code_size);
+					ip = to;
 					continue;
 				}
-				ip+=3;
+				ip += 3;
 				continue;
 			}
 			case OPCODE_JUMP_TO_DEF_ARGUMENT: {
 
 				CHECK_SPACE(2);
-				ip=_default_arg_ptr[defarg];
+				ip = _default_arg_ptr[defarg];
 				continue;
 			}
 			case OPCODE_RETURN: {
 
 				CHECK_SPACE(2);
-				GET_VARIANT_PTR(r,1);
-				retvalue=*r;
-				exit_ok=true;
+				GET_VARIANT_PTR(r, 1);
+				retvalue = *r;
+				exit_ok = true;
 				break;
 			}
 			case OPCODE_ITERATE_BEGIN: {
 
 				CHECK_SPACE(8); //space for this an regular iterate
 
-				GET_VARIANT_PTR(counter,1);
-				GET_VARIANT_PTR(container,2);
+				GET_VARIANT_PTR(counter, 1);
+				GET_VARIANT_PTR(container, 2);
 
 				bool valid;
-				if (!container->iter_init(*counter,valid)) {
+				if (!container->iter_init(*counter, valid)) {
 					if (!valid) {
-						err_text="Unable to iterate on object of type  "+Variant::get_type_name(container->get_type())+"'.";
+						err_text = "Unable to iterate on object of type  " + Variant::get_type_name(container->get_type()) + "'.";
 						break;
 					}
-					int jumpto=_code_ptr[ip+3];
-					ERR_BREAK(jumpto<0 || jumpto>_code_size);
-					ip=jumpto;
+					int jumpto = _code_ptr[ip + 3];
+					ERR_BREAK(jumpto < 0 || jumpto > _code_size);
+					ip = jumpto;
 					continue;
 				}
-				GET_VARIANT_PTR(iterator,4);
+				GET_VARIANT_PTR(iterator, 4);
 
-
-				*iterator=container->iter_get(*counter,valid);
+				*iterator = container->iter_get(*counter, valid);
 				if (!valid) {
-					err_text="Unable to obtain iterator object of type  "+Variant::get_type_name(container->get_type())+"'.";
+					err_text = "Unable to obtain iterator object of type  " + Variant::get_type_name(container->get_type()) + "'.";
 					break;
 				}
 
-
-				ip+=5; //skip regular iterate which is always next
+				ip += 5; //skip regular iterate which is always next
 				continue;
 			}
 			case OPCODE_ITERATE: {
 
 				CHECK_SPACE(4);
 
-				GET_VARIANT_PTR(counter,1);
-				GET_VARIANT_PTR(container,2);
+				GET_VARIANT_PTR(counter, 1);
+				GET_VARIANT_PTR(container, 2);
 
 				bool valid;
-				if (!container->iter_next(*counter,valid)) {
+				if (!container->iter_next(*counter, valid)) {
 					if (!valid) {
-						err_text="Unable to iterate on object of type  "+Variant::get_type_name(container->get_type())+"' (type changed since first iteration?).";
+						err_text = "Unable to iterate on object of type  " + Variant::get_type_name(container->get_type()) + "' (type changed since first iteration?).";
 						break;
 					}
-					int jumpto=_code_ptr[ip+3];
-					ERR_BREAK(jumpto<0 || jumpto>_code_size);
-					ip=jumpto;
+					int jumpto = _code_ptr[ip + 3];
+					ERR_BREAK(jumpto < 0 || jumpto > _code_size);
+					ip = jumpto;
 					continue;
 				}
-				GET_VARIANT_PTR(iterator,4);
+				GET_VARIANT_PTR(iterator, 4);
 
-				*iterator=container->iter_get(*counter,valid);
+				*iterator = container->iter_get(*counter, valid);
 				if (!valid) {
-					err_text="Unable to obtain iterator object of type  "+Variant::get_type_name(container->get_type())+"' (but was obtained on first iteration?).";
+					err_text = "Unable to obtain iterator object of type  " + Variant::get_type_name(container->get_type()) + "' (but was obtained on first iteration?).";
 					break;
 				}
 
-				ip+=5; //loop again
+				ip += 5; //loop again
 				continue;
 			}
 			case OPCODE_ASSERT: {
 				CHECK_SPACE(2);
-				GET_VARIANT_PTR(test,1);
+				GET_VARIANT_PTR(test, 1);
 
 #ifdef DEBUG_ENABLED
 				bool valid;
 				bool result = test->booleanize(valid);
 
-
 				if (!valid) {
 
-					err_text="cannot evaluate conditional expression of type: "+Variant::get_type_name(test->get_type());
+					err_text = "cannot evaluate conditional expression of type: " + Variant::get_type_name(test->get_type());
 					break;
 				}
 
-
 				if (!result) {
 
-					err_text="Assertion failed.";
+					err_text = "Assertion failed.";
 					break;
 				}
 
 #endif
 
-				ip+=2;
+				ip += 2;
 				continue;
 			}
 			case OPCODE_BREAKPOINT: {
 #ifdef DEBUG_ENABLED
 				if (ScriptDebugger::get_singleton()) {
-					GDScriptLanguage::get_singleton()->debug_break("Breakpoint Statement",true);
+					GDScriptLanguage::get_singleton()->debug_break("Breakpoint Statement", true);
 				}
 #endif
-				ip+=1;
+				ip += 1;
 				continue;
 			}
 			case OPCODE_LINE: {
 				CHECK_SPACE(2);
 
-				line=_code_ptr[ip+1];
-				ip+=2;
+				line = _code_ptr[ip + 1];
+				ip += 2;
 
 				if (ScriptDebugger::get_singleton()) {
 					// line
-					bool do_break=false;
+					bool do_break = false;
 
-					if (ScriptDebugger::get_singleton()->get_lines_left()>0) {
+					if (ScriptDebugger::get_singleton()->get_lines_left() > 0) {
 
-						if (ScriptDebugger::get_singleton()->get_depth()<=0)
-							ScriptDebugger::get_singleton()->set_lines_left( ScriptDebugger::get_singleton()->get_lines_left() -1 );
-						if (ScriptDebugger::get_singleton()->get_lines_left()<=0)
-							do_break=true;
+						if (ScriptDebugger::get_singleton()->get_depth() <= 0)
+							ScriptDebugger::get_singleton()->set_lines_left(ScriptDebugger::get_singleton()->get_lines_left() - 1);
+						if (ScriptDebugger::get_singleton()->get_lines_left() <= 0)
+							do_break = true;
 					}
 
-					if (ScriptDebugger::get_singleton()->is_breakpoint(line,source))
-						do_break=true;
+					if (ScriptDebugger::get_singleton()->is_breakpoint(line, source))
+						do_break = true;
 
 					if (do_break) {
-						GDScriptLanguage::get_singleton()->debug_break("Breakpoint",true);
+						GDScriptLanguage::get_singleton()->debug_break("Breakpoint", true);
 					}
 
 					ScriptDebugger::get_singleton()->line_poll();
-
 				}
 				continue;
 			}
 			case OPCODE_END: {
 
-				exit_ok=true;
+				exit_ok = true;
 				break;
-
 			}
 			default: {
 
-				err_text="Illegal opcode "+itos(_code_ptr[ip])+" at address "+itos(ip);
+				err_text = "Illegal opcode " + itos(_code_ptr[ip]) + " at address " + itos(ip);
 				break;
 			}
-
 		}
 
 		if (exit_ok)
@@ -1206,73 +1162,69 @@ Variant GDFunction::call(GDInstance *p_instance, const Variant **p_args, int p_a
 		// function, file, line, error, explanation
 		String err_file;
 		if (p_instance)
-			err_file=p_instance->script->path;
+			err_file = p_instance->script->path;
 		else if (_class)
-			err_file=_class->path;
-		if (err_file=="")
-			err_file="<built-in>";
+			err_file = _class->path;
+		if (err_file == "")
+			err_file = "<built-in>";
 		String err_func = name;
-		if (p_instance && p_instance->script->name!="")
-			err_func=p_instance->script->name+"."+err_func;
-		int err_line=line;
-		if (err_text=="") {
-			err_text="Internal Script Error! - opcode #"+itos(last_opcode)+" (report please).";
+		if (p_instance && p_instance->script->name != "")
+			err_func = p_instance->script->name + "." + err_func;
+		int err_line = line;
+		if (err_text == "") {
+			err_text = "Internal Script Error! - opcode #" + itos(last_opcode) + " (report please).";
 		}
 
-		if (!GDScriptLanguage::get_singleton()->debug_break(err_text,false)) {
+		if (!GDScriptLanguage::get_singleton()->debug_break(err_text, false)) {
 			// debugger break did not happen
 
-			_err_print_error(err_func.utf8().get_data(),err_file.utf8().get_data(),err_line,err_text.utf8().get_data(),ERR_HANDLER_SCRIPT);
+			_err_print_error(err_func.utf8().get_data(), err_file.utf8().get_data(), err_line, err_text.utf8().get_data(), ERR_HANDLER_SCRIPT);
 		}
 
-
 		break;
 	}
 
 #ifdef DEBUG_ENABLED
 	if (GDScriptLanguage::get_singleton()->profiling) {
 		uint64_t time_taken = OS::get_singleton()->get_ticks_usec() - function_start_time;
-		profile.total_time+=time_taken;
-		profile.self_time+=time_taken-function_call_time;
-		profile.frame_total_time+=time_taken;
-		profile.frame_self_time+=time_taken-function_call_time;
-		GDScriptLanguage::get_singleton()->script_frame_time+=time_taken-function_call_time;
-
+		profile.total_time += time_taken;
+		profile.self_time += time_taken - function_call_time;
+		profile.frame_total_time += time_taken;
+		profile.frame_self_time += time_taken - function_call_time;
+		GDScriptLanguage::get_singleton()->script_frame_time += time_taken - function_call_time;
 	}
 
 #endif
 	if (ScriptDebugger::get_singleton())
 		GDScriptLanguage::get_singleton()->exit_function();
 
-
 	if (_stack_size) {
 		//free stack
-		for(int i=0;i<_stack_size;i++)
+		for (int i = 0; i < _stack_size; i++)
 			stack[i].~Variant();
 	}
 
 	return retvalue;
-
 }
 
-const int* GDFunction::get_code() const {
+const int *GDFunction::get_code() const {
 
 	return _code_ptr;
 }
-int GDFunction::get_code_size() const{
+int GDFunction::get_code_size() const {
 
 	return _code_size;
 }
 
 Variant GDFunction::get_constant(int p_idx) const {
 
-	ERR_FAIL_INDEX_V(p_idx,constants.size(),"<errconst>");
+	ERR_FAIL_INDEX_V(p_idx, constants.size(), "<errconst>");
 	return constants[p_idx];
 }
 
 StringName GDFunction::get_global_name(int p_idx) const {
 
-	ERR_FAIL_INDEX_V(p_idx,global_names.size(),"<errgname>");
+	ERR_FAIL_INDEX_V(p_idx, global_names.size(), "<errgname>");
 	return global_names[p_idx];
 }
 
@@ -1280,13 +1232,12 @@ int GDFunction::get_default_argument_count() const {
 
 	return default_arguments.size();
 }
-int GDFunction::get_default_argument_addr(int p_arg) const{
+int GDFunction::get_default_argument_addr(int p_arg) const {
 
-	ERR_FAIL_INDEX_V(p_arg,default_arguments.size(),-1);
+	ERR_FAIL_INDEX_V(p_arg, default_arguments.size(), -1);
 	return default_arguments[p_arg];
 }
 
-
 StringName GDFunction::get_name() const {
 
 	return name;
@@ -1311,66 +1262,60 @@ struct _GDFKCS {
 
 	bool operator<(const _GDFKCS &p_r) const {
 
-		return order<p_r.order;
+		return order < p_r.order;
 	}
 };
 
-void GDFunction::debug_get_stack_member_state(int p_line,List<Pair<StringName,int> > *r_stackvars) const {
+void GDFunction::debug_get_stack_member_state(int p_line, List<Pair<StringName, int> > *r_stackvars) const {
 
+	int oc = 0;
+	Map<StringName, _GDFKC> sdmap;
+	for (const List<StackDebug>::Element *E = stack_debug.front(); E; E = E->next()) {
 
-	int oc=0;
-	Map<StringName,_GDFKC> sdmap;
-	for( const List<StackDebug>::Element *E=stack_debug.front();E;E=E->next()) {
-
-		const StackDebug &sd=E->get();
-		if (sd.line>p_line)
+		const StackDebug &sd = E->get();
+		if (sd.line > p_line)
 			break;
 
 		if (sd.added) {
 
 			if (!sdmap.has(sd.identifier)) {
 				_GDFKC d;
-				d.order=oc++;
+				d.order = oc++;
 				d.pos.push_back(sd.pos);
-				sdmap[sd.identifier]=d;
+				sdmap[sd.identifier] = d;
 
 			} else {
 				sdmap[sd.identifier].pos.push_back(sd.pos);
 			}
 		} else {
 
-
 			ERR_CONTINUE(!sdmap.has(sd.identifier));
 
 			sdmap[sd.identifier].pos.pop_back();
 			if (sdmap[sd.identifier].pos.empty())
 				sdmap.erase(sd.identifier);
 		}
-
 	}
 
-
 	List<_GDFKCS> stackpositions;
-	for(Map<StringName,_GDFKC>::Element *E=sdmap.front();E;E=E->next() ) {
+	for (Map<StringName, _GDFKC>::Element *E = sdmap.front(); E; E = E->next()) {
 
 		_GDFKCS spp;
-		spp.id=E->key();
-		spp.order=E->get().order;
-		spp.pos=E->get().pos.back()->get();
+		spp.id = E->key();
+		spp.order = E->get().order;
+		spp.pos = E->get().pos.back()->get();
 		stackpositions.push_back(spp);
 	}
 
 	stackpositions.sort();
 
-	for(List<_GDFKCS>::Element *E=stackpositions.front();E;E=E->next()) {
+	for (List<_GDFKCS>::Element *E = stackpositions.front(); E; E = E->next()) {
 
-		Pair<StringName,int> p;
-		p.first=E->get().id;
-		p.second=E->get().pos;
+		Pair<StringName, int> p;
+		p.first = E->get().id;
+		p.second = E->get().pos;
 		r_stackvars->push_back(p);
 	}
-
-
 }
 
 #if 0
@@ -1389,14 +1334,15 @@ void GDFunction::clear() {
 
 }
 #endif
-GDFunction::GDFunction() : function_list(this) {
+GDFunction::GDFunction()
+	: function_list(this) {
 
-	_stack_size=0;
-	_call_size=0;
-	rpc_mode=ScriptInstance::RPC_MODE_DISABLED;
-	name="<anonymous>";
+	_stack_size = 0;
+	_call_size = 0;
+	rpc_mode = ScriptInstance::RPC_MODE_DISABLED;
+	name = "<anonymous>";
 #ifdef DEBUG_ENABLED
-	_func_cname=NULL;
+	_func_cname = NULL;
 
 	if (GDScriptLanguage::get_singleton()->lock) {
 		GDScriptLanguage::get_singleton()->lock->lock();
@@ -1407,20 +1353,20 @@ GDFunction::GDFunction() : function_list(this) {
 		GDScriptLanguage::get_singleton()->lock->unlock();
 	}
 
-	profile.call_count=0;
-	profile.self_time=0;
-	profile.total_time=0;
-	profile.frame_call_count=0;
-	profile.frame_self_time=0;
-	profile.frame_total_time=0;
-	profile.last_frame_call_count=0;
-	profile.last_frame_self_time=0;
-	profile.last_frame_total_time=0;
+	profile.call_count = 0;
+	profile.self_time = 0;
+	profile.total_time = 0;
+	profile.frame_call_count = 0;
+	profile.frame_self_time = 0;
+	profile.frame_total_time = 0;
+	profile.last_frame_call_count = 0;
+	profile.last_frame_self_time = 0;
+	profile.last_frame_total_time = 0;
 
 #endif
 }
 
-GDFunction::~GDFunction()  {
+GDFunction::~GDFunction() {
 #ifdef DEBUG_ENABLED
 	if (GDScriptLanguage::get_singleton()->lock) {
 		GDScriptLanguage::get_singleton()->lock->lock();
@@ -1435,8 +1381,7 @@ GDFunction::~GDFunction()  {
 
 /////////////////////
 
-
-Variant GDFunctionState::_signal_callback(const Variant** p_args, int p_argcount, Variant::CallError& r_error) {
+Variant GDFunctionState::_signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
 
 #ifdef DEBUG_ENABLED
 	if (state.instance_id && !ObjectDB::get_instance(state.instance_id)) {
@@ -1451,51 +1396,50 @@ Variant GDFunctionState::_signal_callback(const Variant** p_args, int p_argcount
 #endif
 
 	Variant arg;
-	r_error.error=Variant::CallError::CALL_OK;
+	r_error.error = Variant::CallError::CALL_OK;
 
-	ERR_FAIL_COND_V(!function,Variant());
+	ERR_FAIL_COND_V(!function, Variant());
 
-	if (p_argcount==0) {
-		r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.argument=1;
+	if (p_argcount == 0) {
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+		r_error.argument = 1;
 		return Variant();
-	} else if (p_argcount==1) {
+	} else if (p_argcount == 1) {
 		//noooneee
-	} else if (p_argcount==2) {
-		arg=*p_args[0];
+	} else if (p_argcount == 2) {
+		arg = *p_args[0];
 	} else {
 		Array extra_args;
-		for(int i=0;i<p_argcount-1;i++) {
+		for (int i = 0; i < p_argcount - 1; i++) {
 			extra_args.push_back(*p_args[i]);
 		}
-		arg=extra_args;
+		arg = extra_args;
 	}
 
-	Ref<GDFunctionState> self = *p_args[p_argcount-1];
+	Ref<GDFunctionState> self = *p_args[p_argcount - 1];
 
 	if (self.is_null()) {
-		r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-		r_error.argument=p_argcount-1;
-		r_error.expected=Variant::OBJECT;
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+		r_error.argument = p_argcount - 1;
+		r_error.expected = Variant::OBJECT;
 		return Variant();
 	}
 
-	state.result=arg;
-	Variant ret = function->call(NULL,NULL,0,r_error,&state);
-	function=NULL; //cleaned up;
-	state.result=Variant();
+	state.result = arg;
+	Variant ret = function->call(NULL, NULL, 0, r_error, &state);
+	function = NULL; //cleaned up;
+	state.result = Variant();
 	return ret;
 }
 
-
 bool GDFunctionState::is_valid() const {
 
-	return function!=NULL;
+	return function != NULL;
 }
 
-Variant GDFunctionState::resume(const Variant& p_arg) {
+Variant GDFunctionState::resume(const Variant &p_arg) {
 
-	ERR_FAIL_COND_V(!function,Variant());
+	ERR_FAIL_COND_V(!function, Variant());
 #ifdef DEBUG_ENABLED
 	if (state.instance_id && !ObjectDB::get_instance(state.instance_id)) {
 		ERR_EXPLAIN("Resumed after yield, but class instance is gone");
@@ -1508,36 +1452,33 @@ Variant GDFunctionState::resume(const Variant& p_arg) {
 	}
 #endif
 
-	state.result=p_arg;
+	state.result = p_arg;
 	Variant::CallError err;
-	Variant ret = function->call(NULL,NULL,0,err,&state);
-	function=NULL; //cleaned up;
-	state.result=Variant();
+	Variant ret = function->call(NULL, NULL, 0, err, &state);
+	function = NULL; //cleaned up;
+	state.result = Variant();
 	return ret;
 }
 
-
 void GDFunctionState::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("resume:Variant","arg"),&GDFunctionState::resume,DEFVAL(Variant()));
-	ClassDB::bind_method(D_METHOD("is_valid"),&GDFunctionState::is_valid);
-	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT,"_signal_callback",&GDFunctionState::_signal_callback,MethodInfo("_signal_callback"));
-
+	ClassDB::bind_method(D_METHOD("resume:Variant", "arg"), &GDFunctionState::resume, DEFVAL(Variant()));
+	ClassDB::bind_method(D_METHOD("is_valid"), &GDFunctionState::is_valid);
+	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &GDFunctionState::_signal_callback, MethodInfo("_signal_callback"));
 }
 
 GDFunctionState::GDFunctionState() {
 
-	function=NULL;
+	function = NULL;
 }
 
 GDFunctionState::~GDFunctionState() {
 
-	if (function!=NULL) {
+	if (function != NULL) {
 		//never called, deinitialize stack
-		for(int i=0;i<state.stack_size;i++) {
-			Variant *v=(Variant*)&state.stack[sizeof(Variant)*i];
+		for (int i = 0; i < state.stack_size; i++) {
+			Variant *v = (Variant *)&state.stack[sizeof(Variant) * i];
 			v->~Variant();
 		}
 	}
 }
-
diff --git a/modules/gdscript/gd_function.h b/modules/gdscript/gd_function.h
index aff6341601..321b3b6cfa 100644
--- a/modules/gdscript/gd_function.h
+++ b/modules/gdscript/gd_function.h
@@ -29,21 +29,19 @@
 #ifndef GD_FUNCTION_H
 #define GD_FUNCTION_H
 
-#include "self_list.h"
 #include "os/thread.h"
 #include "pair.h"
-#include "variant.h"
-#include "string_db.h"
 #include "reference.h"
 #include "script_language.h"
+#include "self_list.h"
+#include "string_db.h"
+#include "variant.h"
 
 class GDInstance;
 class GDScript;
 
-
 class GDFunction {
 public:
-
 	enum Opcode {
 		OPCODE_OPERATOR,
 		OPCODE_EXTENDS_TEST,
@@ -81,18 +79,18 @@ public:
 	};
 
 	enum Address {
-		ADDR_BITS=24,
-		ADDR_MASK=((1<<ADDR_BITS)-1),
-		ADDR_TYPE_MASK=~ADDR_MASK,
-		ADDR_TYPE_SELF=0,
-		ADDR_TYPE_CLASS=1,
-		ADDR_TYPE_MEMBER=2,
-		ADDR_TYPE_CLASS_CONSTANT=3,
-		ADDR_TYPE_LOCAL_CONSTANT=4,
-		ADDR_TYPE_STACK=5,
-		ADDR_TYPE_STACK_VARIABLE=6,
-		ADDR_TYPE_GLOBAL=7,
-		ADDR_TYPE_NIL=8
+		ADDR_BITS = 24,
+		ADDR_MASK = ((1 << ADDR_BITS) - 1),
+		ADDR_TYPE_MASK = ~ADDR_MASK,
+		ADDR_TYPE_SELF = 0,
+		ADDR_TYPE_CLASS = 1,
+		ADDR_TYPE_MEMBER = 2,
+		ADDR_TYPE_CLASS_CONSTANT = 3,
+		ADDR_TYPE_LOCAL_CONSTANT = 4,
+		ADDR_TYPE_STACK = 5,
+		ADDR_TYPE_STACK_VARIABLE = 6,
+		ADDR_TYPE_GLOBAL = 7,
+		ADDR_TYPE_NIL = 8
 	};
 
 	enum RPCMode {
@@ -103,16 +101,16 @@ public:
 		RPC_SYNC_SLAVE
 	};
 
-    struct StackDebug {
+	struct StackDebug {
 
-	int line;
-	int pos;
-	bool added;
-	StringName identifier;
-    };
+		int line;
+		int pos;
+		bool added;
+		StringName identifier;
+	};
 
 private:
-friend class GDCompiler;
+	friend class GDCompiler;
 
 	StringName source;
 
@@ -146,15 +144,15 @@ friend class GDCompiler;
 
 	List<StackDebug> stack_debug;
 
-	_FORCE_INLINE_ Variant *_get_variant(int p_address,GDInstance *p_instance,GDScript *p_script,Variant &self,Variant *p_stack,String& r_error) const;
-	_FORCE_INLINE_ String _get_call_error(const Variant::CallError& p_err, const String& p_where,const Variant**argptrs) const;
+	_FORCE_INLINE_ Variant *_get_variant(int p_address, GDInstance *p_instance, GDScript *p_script, Variant &self, Variant *p_stack, String &r_error) const;
+	_FORCE_INLINE_ String _get_call_error(const Variant::CallError &p_err, const String &p_where, const Variant **argptrs) const;
 
-friend class GDScriptLanguage;
+	friend class GDScriptLanguage;
 
 	SelfList<GDFunction> function_list;
 #ifdef DEBUG_ENABLED
 	CharString func_cname;
-	const char*_func_cname;
+	const char *_func_cname;
 
 	struct Profile {
 		StringName signature;
@@ -172,9 +170,6 @@ friend class GDScriptLanguage;
 #endif
 
 public:
-
-
-
 	struct CallState {
 
 		ObjectID instance_id; //by debug only
@@ -190,12 +185,11 @@ public:
 		int line;
 		int defarg;
 		Variant result;
-
 	};
 
 	_FORCE_INLINE_ bool is_static() const { return _static; }
 
-	const int* get_code() const; //used for debug
+	const int *get_code() const; //used for debug
 	int get_code_size() const;
 	Variant get_constant(int p_idx) const;
 	StringName get_global_name(int p_idx) const;
@@ -206,48 +200,46 @@ public:
 	GDScript *get_script() const { return _script; }
 	StringName get_source() const { return source; }
 
-	void debug_get_stack_member_state(int p_line,List<Pair<StringName,int> > *r_stackvars) const;
+	void debug_get_stack_member_state(int p_line, List<Pair<StringName, int> > *r_stackvars) const;
 
-	_FORCE_INLINE_ bool is_empty() const { return _code_size==0; }
+	_FORCE_INLINE_ bool is_empty() const { return _code_size == 0; }
 
 	int get_argument_count() const { return _argument_count; }
 	StringName get_argument_name(int p_idx) const {
 #ifdef TOOLS_ENABLED
-		ERR_FAIL_INDEX_V(p_idx,arg_names.size(),StringName());
+		ERR_FAIL_INDEX_V(p_idx, arg_names.size(), StringName());
 		return arg_names[p_idx];
 #endif
 		return StringName();
-
 	}
 	Variant get_default_argument(int p_idx) const {
-		ERR_FAIL_INDEX_V(p_idx,default_arguments.size(),Variant());
+		ERR_FAIL_INDEX_V(p_idx, default_arguments.size(), Variant());
 		return default_arguments[p_idx];
 	}
 
-	Variant call(GDInstance *p_instance,const Variant **p_args, int p_argcount,Variant::CallError& r_err,CallState *p_state=NULL);
+	Variant call(GDInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError &r_err, CallState *p_state = NULL);
 
 	_FORCE_INLINE_ ScriptInstance::RPCMode get_rpc_mode() const { return rpc_mode; }
 	GDFunction();
 	~GDFunction();
 };
 
-
 class GDFunctionState : public Reference {
 
-	GDCLASS(GDFunctionState,Reference);
-friend class GDFunction;
+	GDCLASS(GDFunctionState, Reference);
+	friend class GDFunction;
 	GDFunction *function;
 	GDFunction::CallState state;
-	Variant _signal_callback(const Variant** p_args, int p_argcount, Variant::CallError& r_error);
+	Variant _signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+
 protected:
 	static void _bind_methods();
-public:
 
+public:
 	bool is_valid() const;
-	Variant resume(const Variant& p_arg=Variant());
+	Variant resume(const Variant &p_arg = Variant());
 	GDFunctionState();
 	~GDFunctionState();
 };
 
-
 #endif // GD_FUNCTION_H
diff --git a/modules/gdscript/gd_functions.cpp b/modules/gdscript/gd_functions.cpp
index d0fc241734..fa92f0a194 100644
--- a/modules/gdscript/gd_functions.cpp
+++ b/modules/gdscript/gd_functions.cpp
@@ -27,21 +27,21 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "gd_functions.h"
-#include "math_funcs.h"
 #include "class_db.h"
-#include "reference.h"
-#include "gd_script.h"
 #include "func_ref.h"
+#include "gd_script.h"
+#include "io/json.h"
+#include "io/marshalls.h"
+#include "math_funcs.h"
 #include "os/os.h"
+#include "reference.h"
 #include "variant_parser.h"
-#include "io/marshalls.h"
-#include "io/json.h"
 
 const char *GDFunctions::get_func_name(Function p_func) {
 
-	ERR_FAIL_INDEX_V(p_func,FUNC_MAX,"");
+	ERR_FAIL_INDEX_V(p_func, FUNC_MAX, "");
 
-	static const char *_names[FUNC_MAX]={
+	static const char *_names[FUNC_MAX] = {
 		"sin",
 		"cos",
 		"tan",
@@ -115,35 +115,34 @@ const char *GDFunctions::get_func_name(Function p_func) {
 	};
 
 	return _names[p_func];
-
 }
 
-void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Variant &r_ret,Variant::CallError &r_error) {
+void GDFunctions::call(Function p_func, const Variant **p_args, int p_arg_count, Variant &r_ret, Variant::CallError &r_error) {
 
-	r_error.error=Variant::CallError::CALL_OK;
+	r_error.error = Variant::CallError::CALL_OK;
 #ifdef DEBUG_ENABLED
 
-#define VALIDATE_ARG_COUNT(m_count) \
-	if (p_arg_count<m_count) {\
-		r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;\
-		r_error.argument=m_count;\
-		r_ret=Variant();\
-		return;\
-	}\
-	if (p_arg_count>m_count) {\
-		r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;\
-		r_error.argument=m_count;\
-		r_ret=Variant();\
-		return;\
+#define VALIDATE_ARG_COUNT(m_count)                                        \
+	if (p_arg_count < m_count) {                                           \
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;  \
+		r_error.argument = m_count;                                        \
+		r_ret = Variant();                                                 \
+		return;                                                            \
+	}                                                                      \
+	if (p_arg_count > m_count) {                                           \
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS; \
+		r_error.argument = m_count;                                        \
+		r_ret = Variant();                                                 \
+		return;                                                            \
 	}
 
-#define VALIDATE_ARG_NUM(m_arg) \
-	if (!p_args[m_arg]->is_num()) {\
-		r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;\
-		r_error.argument=m_arg;\
-		r_error.expected=Variant::REAL;\
-		r_ret=Variant();\
-		return;\
+#define VALIDATE_ARG_NUM(m_arg)                                          \
+	if (!p_args[m_arg]->is_num()) {                                      \
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; \
+		r_error.argument = m_arg;                                        \
+		r_error.expected = Variant::REAL;                                \
+		r_ret = Variant();                                               \
+		return;                                                          \
 	}
 
 #else
@@ -154,245 +153,245 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 
 	//using a switch, so the compiler generates a jumptable
 
-	switch(p_func) {
+	switch (p_func) {
 
 		case MATH_SIN: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::sin((double)*p_args[0]);
+			r_ret = Math::sin((double)*p_args[0]);
 		} break;
 		case MATH_COS: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::cos((double)*p_args[0]);
+			r_ret = Math::cos((double)*p_args[0]);
 		} break;
 		case MATH_TAN: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::tan((double)*p_args[0]);
+			r_ret = Math::tan((double)*p_args[0]);
 		} break;
 		case MATH_SINH: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::sinh((double)*p_args[0]);
+			r_ret = Math::sinh((double)*p_args[0]);
 		} break;
 		case MATH_COSH: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::cosh((double)*p_args[0]);
+			r_ret = Math::cosh((double)*p_args[0]);
 		} break;
 		case MATH_TANH: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::tanh((double)*p_args[0]);
+			r_ret = Math::tanh((double)*p_args[0]);
 		} break;
 		case MATH_ASIN: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::asin((double)*p_args[0]);
+			r_ret = Math::asin((double)*p_args[0]);
 		} break;
 		case MATH_ACOS: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::acos((double)*p_args[0]);
+			r_ret = Math::acos((double)*p_args[0]);
 		} break;
 		case MATH_ATAN: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::atan((double)*p_args[0]);
+			r_ret = Math::atan((double)*p_args[0]);
 		} break;
 		case MATH_ATAN2: {
 			VALIDATE_ARG_COUNT(2);
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			r_ret=Math::atan2((double)*p_args[0],(double)*p_args[1]);
+			r_ret = Math::atan2((double)*p_args[0], (double)*p_args[1]);
 		} break;
 		case MATH_SQRT: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::sqrt((double)*p_args[0]);
+			r_ret = Math::sqrt((double)*p_args[0]);
 		} break;
 		case MATH_FMOD: {
 			VALIDATE_ARG_COUNT(2);
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			r_ret=Math::fmod((double)*p_args[0],(double)*p_args[1]);
+			r_ret = Math::fmod((double)*p_args[0], (double)*p_args[1]);
 		} break;
 		case MATH_FPOSMOD: {
 			VALIDATE_ARG_COUNT(2);
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			r_ret=Math::fposmod((double)*p_args[0],(double)*p_args[1]);
+			r_ret = Math::fposmod((double)*p_args[0], (double)*p_args[1]);
 		} break;
 		case MATH_FLOOR: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::floor((double)*p_args[0]);
-		  } break;
+			r_ret = Math::floor((double)*p_args[0]);
+		} break;
 		case MATH_CEIL: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::ceil((double)*p_args[0]);
+			r_ret = Math::ceil((double)*p_args[0]);
 		} break;
 		case MATH_ROUND: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::round((double)*p_args[0]);
+			r_ret = Math::round((double)*p_args[0]);
 		} break;
 		case MATH_ABS: {
 			VALIDATE_ARG_COUNT(1);
-			if (p_args[0]->get_type()==Variant::INT) {
+			if (p_args[0]->get_type() == Variant::INT) {
 
 				int64_t i = *p_args[0];
-				r_ret=ABS(i);
-			} else if (p_args[0]->get_type()==Variant::REAL) {
+				r_ret = ABS(i);
+			} else if (p_args[0]->get_type() == Variant::REAL) {
 
 				double r = *p_args[0];
-				r_ret=Math::abs(r);
+				r_ret = Math::abs(r);
 			} else {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::REAL;
-				r_ret=Variant();
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::REAL;
+				r_ret = Variant();
 			}
 		} break;
 		case MATH_SIGN: {
-				VALIDATE_ARG_COUNT(1);
-				if (p_args[0]->get_type()==Variant::INT) {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() == Variant::INT) {
 
-					int64_t i = *p_args[0];
-					r_ret= i < 0 ? -1 : ( i > 0 ? +1 : 0);
-				} else if (p_args[0]->get_type()==Variant::REAL) {
+				int64_t i = *p_args[0];
+				r_ret = i < 0 ? -1 : (i > 0 ? +1 : 0);
+			} else if (p_args[0]->get_type() == Variant::REAL) {
 
-					real_t r = *p_args[0];
-					r_ret= r < 0.0 ? -1.0 : ( r > 0.0 ? +1.0 : 0.0);
-				} else {
+				real_t r = *p_args[0];
+				r_ret = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
+			} else {
 
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-					r_error.argument=0;
-					r_error.expected=Variant::REAL;
-					r_ret=Variant();
-				}
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::REAL;
+				r_ret = Variant();
+			}
 		} break;
 		case MATH_POW: {
 			VALIDATE_ARG_COUNT(2);
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			r_ret=Math::pow((double)*p_args[0],(double)*p_args[1]);
+			r_ret = Math::pow((double)*p_args[0], (double)*p_args[1]);
 		} break;
 		case MATH_LOG: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::log((double)*p_args[0]);
+			r_ret = Math::log((double)*p_args[0]);
 		} break;
 		case MATH_EXP: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::exp((double)*p_args[0]);
+			r_ret = Math::exp((double)*p_args[0]);
 		} break;
 		case MATH_ISNAN: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::is_nan((double)*p_args[0]);
+			r_ret = Math::is_nan((double)*p_args[0]);
 		} break;
 		case MATH_ISINF: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::is_inf((double)*p_args[0]);
+			r_ret = Math::is_inf((double)*p_args[0]);
 		} break;
 		case MATH_EASE: {
 			VALIDATE_ARG_COUNT(2);
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			r_ret=Math::ease((double)*p_args[0],(double)*p_args[1]);
+			r_ret = Math::ease((double)*p_args[0], (double)*p_args[1]);
 		} break;
 		case MATH_DECIMALS: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::step_decimals((double)*p_args[0]);
+			r_ret = Math::step_decimals((double)*p_args[0]);
 		} break;
 		case MATH_STEPIFY: {
 			VALIDATE_ARG_COUNT(2);
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			r_ret=Math::stepify((double)*p_args[0],(double)*p_args[1]);
+			r_ret = Math::stepify((double)*p_args[0], (double)*p_args[1]);
 		} break;
 		case MATH_LERP: {
 			VALIDATE_ARG_COUNT(3);
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
-			r_ret=Math::lerp((double)*p_args[0],(double)*p_args[1],(double)*p_args[2]);
+			r_ret = Math::lerp((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
 		} break;
 		case MATH_DECTIME: {
 			VALIDATE_ARG_COUNT(3);
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
-			r_ret=Math::dectime((double)*p_args[0],(double)*p_args[1],(double)*p_args[2]);
+			r_ret = Math::dectime((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
 		} break;
 		case MATH_RANDOMIZE: {
 			Math::randomize();
-			r_ret=Variant();
+			r_ret = Variant();
 		} break;
 		case MATH_RAND: {
-			r_ret=Math::rand();
+			r_ret = Math::rand();
 		} break;
 		case MATH_RANDF: {
-			r_ret=Math::randf();
+			r_ret = Math::randf();
 		} break;
 		case MATH_RANDOM: {
 			VALIDATE_ARG_COUNT(2);
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			r_ret=Math::random((double)*p_args[0],(double)*p_args[1]);
+			r_ret = Math::random((double)*p_args[0], (double)*p_args[1]);
 		} break;
 		case MATH_SEED: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			uint64_t seed=*p_args[0];
+			uint64_t seed = *p_args[0];
 			Math::seed(seed);
-			r_ret=Variant();
+			r_ret = Variant();
 		} break;
 		case MATH_RANDSEED: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			uint64_t seed=*p_args[0];
+			uint64_t seed = *p_args[0];
 			int ret = Math::rand_from_seed(&seed);
 			Array reta;
 			reta.push_back(ret);
 			reta.push_back(seed);
-			r_ret=reta;
+			r_ret = reta;
 
 		} break;
 		case MATH_DEG2RAD: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::deg2rad((double)*p_args[0]);
+			r_ret = Math::deg2rad((double)*p_args[0]);
 		} break;
 		case MATH_RAD2DEG: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::rad2deg((double)*p_args[0]);
+			r_ret = Math::rad2deg((double)*p_args[0]);
 		} break;
 		case MATH_LINEAR2DB: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::linear2db((double)*p_args[0]);
+			r_ret = Math::linear2db((double)*p_args[0]);
 		} break;
 		case MATH_DB2LINEAR: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			r_ret=Math::db2linear((double)*p_args[0]);
+			r_ret = Math::db2linear((double)*p_args[0]);
 		} break;
 		case LOGIC_MAX: {
 			VALIDATE_ARG_COUNT(2);
-			if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {
+			if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT) {
 
 				int64_t a = *p_args[0];
 				int64_t b = *p_args[1];
-				r_ret=MAX(a,b);
+				r_ret = MAX(a, b);
 			} else {
 				VALIDATE_ARG_NUM(0);
 				VALIDATE_ARG_NUM(1);
@@ -400,17 +399,17 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 				real_t a = *p_args[0];
 				real_t b = *p_args[1];
 
-				r_ret=MAX(a,b);
+				r_ret = MAX(a, b);
 			}
 
 		} break;
 		case LOGIC_MIN: {
 			VALIDATE_ARG_COUNT(2);
-			if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT) {
+			if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT) {
 
 				int64_t a = *p_args[0];
 				int64_t b = *p_args[1];
-				r_ret=MIN(a,b);
+				r_ret = MIN(a, b);
 			} else {
 				VALIDATE_ARG_NUM(0);
 				VALIDATE_ARG_NUM(1);
@@ -418,17 +417,17 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 				real_t a = *p_args[0];
 				real_t b = *p_args[1];
 
-				r_ret=MIN(a,b);
+				r_ret = MIN(a, b);
 			}
 		} break;
 		case LOGIC_CLAMP: {
 			VALIDATE_ARG_COUNT(3);
-			if (p_args[0]->get_type()==Variant::INT && p_args[1]->get_type()==Variant::INT && p_args[2]->get_type()==Variant::INT) {
+			if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT && p_args[2]->get_type() == Variant::INT) {
 
 				int64_t a = *p_args[0];
 				int64_t b = *p_args[1];
 				int64_t c = *p_args[2];
-				r_ret=CLAMP(a,b,c);
+				r_ret = CLAMP(a, b, c);
 			} else {
 				VALIDATE_ARG_NUM(0);
 				VALIDATE_ARG_NUM(1);
@@ -438,7 +437,7 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 				real_t b = *p_args[1];
 				real_t c = *p_args[2];
 
-				r_ret=CLAMP(a,b,c);
+				r_ret = CLAMP(a, b, c);
 			}
 		} break;
 		case LOGIC_NEAREST_PO2: {
@@ -449,87 +448,80 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 		} break;
 		case OBJ_WEAKREF: {
 			VALIDATE_ARG_COUNT(1);
-			if (p_args[0]->get_type()!=Variant::OBJECT) {
+			if (p_args[0]->get_type() != Variant::OBJECT) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::OBJECT;
-				r_ret=Variant();
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = Variant();
 				return;
-
 			}
 
 			if (p_args[0]->is_ref()) {
 
 				REF r = *p_args[0];
 				if (!r.is_valid()) {
-					r_ret=Variant();
+					r_ret = Variant();
 					return;
 				}
 
-				Ref<WeakRef> wref = memnew( WeakRef );
+				Ref<WeakRef> wref = memnew(WeakRef);
 				wref->set_ref(r);
-				r_ret=wref;
+				r_ret = wref;
 			} else {
 				Object *obj = *p_args[0];
 				if (!obj) {
-					r_ret=Variant();
+					r_ret = Variant();
 					return;
 				}
-				Ref<WeakRef> wref = memnew( WeakRef );
+				Ref<WeakRef> wref = memnew(WeakRef);
 				wref->set_obj(obj);
-				r_ret=wref;
+				r_ret = wref;
 			}
 
-
-
-
 		} break;
 		case FUNC_FUNCREF: {
 			VALIDATE_ARG_COUNT(2);
-			if (p_args[0]->get_type()!=Variant::OBJECT) {
+			if (p_args[0]->get_type() != Variant::OBJECT) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::OBJECT;
-				r_ret=Variant();				
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = Variant();
 				return;
-
 			}
-			if (p_args[1]->get_type()!=Variant::STRING && p_args[1]->get_type()!=Variant::NODE_PATH) {
+			if (p_args[1]->get_type() != Variant::STRING && p_args[1]->get_type() != Variant::NODE_PATH) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=1;
-				r_error.expected=Variant::STRING;
-				r_ret=Variant();
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 1;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
 				return;
-
 			}
 
-			Ref<FuncRef> fr = memnew( FuncRef);
+			Ref<FuncRef> fr = memnew(FuncRef);
 
 			fr->set_instance(*p_args[0]);
 			fr->set_function(*p_args[1]);
 
-			r_ret=fr;
+			r_ret = fr;
 
 		} break;
 		case TYPE_CONVERT: {
 			VALIDATE_ARG_COUNT(2);
 			VALIDATE_ARG_NUM(1);
-			int type=*p_args[1];
-			if (type<0 || type>=Variant::VARIANT_MAX) {
+			int type = *p_args[1];
+			if (type < 0 || type >= Variant::VARIANT_MAX) {
 
-				r_ret=RTR("Invalid type argument to convert(), use TYPE_* constants.");
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::INT;
+				r_ret = RTR("Invalid type argument to convert(), use TYPE_* constants.");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::INT;
 				return;
 
 			} else {
 
-
-				r_ret=Variant::construct(Variant::Type(type),p_args,1,r_error);
+				r_ret = Variant::construct(Variant::Type(type), p_args, 1, r_error);
 			}
 		} break;
 		case TYPE_OF: {
@@ -547,125 +539,122 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 		case TEXT_CHAR: {
 			VALIDATE_ARG_COUNT(1);
 			VALIDATE_ARG_NUM(0);
-			CharType result[2] = {*p_args[0], 0};
-			r_ret=String(result);
+			CharType result[2] = { *p_args[0], 0 };
+			r_ret = String(result);
 		} break;
 		case TEXT_STR: {
 
 			String str;
-			for(int i=0;i<p_arg_count;i++) {
+			for (int i = 0; i < p_arg_count; i++) {
 
 				String os = p_args[i]->operator String();
 
-				if (i==0)
-					str=os;
+				if (i == 0)
+					str = os;
 				else
-					str+=os;
+					str += os;
 			}
 
-			r_ret=str;
+			r_ret = str;
 
 		} break;
 		case TEXT_PRINT: {
 
 			String str;
-			for(int i=0;i<p_arg_count;i++) {
+			for (int i = 0; i < p_arg_count; i++) {
 
-				str+=p_args[i]->operator String();
+				str += p_args[i]->operator String();
 			}
 
 			//str+="\n";
 			print_line(str);
-			r_ret=Variant();
-
+			r_ret = Variant();
 
 		} break;
 		case TEXT_PRINT_TABBED: {
 
 			String str;
-			for(int i=0;i<p_arg_count;i++) {
+			for (int i = 0; i < p_arg_count; i++) {
 
 				if (i)
-					str+="\t";
-				str+=p_args[i]->operator String();
+					str += "\t";
+				str += p_args[i]->operator String();
 			}
 
 			//str+="\n";
 			print_line(str);
-			r_ret=Variant();
-
+			r_ret = Variant();
 
 		} break;
 		case TEXT_PRINT_SPACED: {
 
 			String str;
-			for(int i=0;i<p_arg_count;i++) {
+			for (int i = 0; i < p_arg_count; i++) {
 
 				if (i)
-					str+=" ";
-				str+=p_args[i]->operator String();
+					str += " ";
+				str += p_args[i]->operator String();
 			}
 
 			//str+="\n";
 			print_line(str);
-			r_ret=Variant();
-
+			r_ret = Variant();
 
 		} break;
 
 		case TEXT_PRINTERR: {
 
 			String str;
-			for(int i=0;i<p_arg_count;i++) {
+			for (int i = 0; i < p_arg_count; i++) {
 
-				str+=p_args[i]->operator String();
+				str += p_args[i]->operator String();
 			}
 
 			//str+="\n";
-			OS::get_singleton()->printerr("%s\n",str.utf8().get_data());
-			r_ret=Variant();
+			OS::get_singleton()->printerr("%s\n", str.utf8().get_data());
+			r_ret = Variant();
 
 		} break;
 		case TEXT_PRINTRAW: {
 			String str;
-			for(int i=0;i<p_arg_count;i++) {
+			for (int i = 0; i < p_arg_count; i++) {
 
-				str+=p_args[i]->operator String();
+				str += p_args[i]->operator String();
 			}
 
 			//str+="\n";
-			OS::get_singleton()->print("%s",str.utf8().get_data());
-			r_ret=Variant();
+			OS::get_singleton()->print("%s", str.utf8().get_data());
+			r_ret = Variant();
 
 		} break;
 		case VAR_TO_STR: {
 			VALIDATE_ARG_COUNT(1);
 			String vars;
-			VariantWriter::write_to_string(*p_args[0],vars);
-			r_ret=vars;
+			VariantWriter::write_to_string(*p_args[0], vars);
+			r_ret = vars;
 		} break;
 		case STR_TO_VAR: {
 			VALIDATE_ARG_COUNT(1);
-			if (p_args[0]->get_type()!=Variant::STRING) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::STRING;
-				r_ret=Variant();
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
 				return;
 			}
 
 			VariantParser::StreamString ss;
-			ss.s=*p_args[0];
+			ss.s = *p_args[0];
 
 			String errs;
 			int line;
-			Error err = VariantParser::parse(&ss,r_ret,errs,line);
+			Error err = VariantParser::parse(&ss, r_ret, errs, line);
 
-			if (err!=OK) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::STRING;
-				r_ret="Parse error at line "+itos(line)+": "+errs;
+			if (err != OK) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = "Parse error at line " + itos(line) + ": " + errs;
 				return;
 			}
 
@@ -675,106 +664,104 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 
 			PoolByteArray barr;
 			int len;
-			Error err = encode_variant(*p_args[0],NULL,len);
+			Error err = encode_variant(*p_args[0], NULL, len);
 			if (err) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::NIL;
-				r_ret="Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::NIL;
+				r_ret = "Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
 				return;
 			}
 
 			barr.resize(len);
 			{
 				PoolByteArray::Write w = barr.write();
-				encode_variant(*p_args[0],w.ptr(),len);
-
+				encode_variant(*p_args[0], w.ptr(), len);
 			}
-			r_ret=barr;
+			r_ret = barr;
 		} break;
 		case BYTES_TO_VAR: {
 			VALIDATE_ARG_COUNT(1);
-			if (p_args[0]->get_type()!=Variant::POOL_BYTE_ARRAY) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::POOL_BYTE_ARRAY;
-				r_ret=Variant();
+			if (p_args[0]->get_type() != Variant::POOL_BYTE_ARRAY) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::POOL_BYTE_ARRAY;
+				r_ret = Variant();
 				return;
 			}
 
-			PoolByteArray varr=*p_args[0];
+			PoolByteArray varr = *p_args[0];
 			Variant ret;
 			{
-				PoolByteArray::Read r=varr.read();
-				Error err = decode_variant(ret,r.ptr(),varr.size(),NULL);
-				if (err!=OK) {
-					r_ret=RTR("Not enough bytes for decoding bytes, or invalid format.");
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-					r_error.argument=0;
-					r_error.expected=Variant::POOL_BYTE_ARRAY;
+				PoolByteArray::Read r = varr.read();
+				Error err = decode_variant(ret, r.ptr(), varr.size(), NULL);
+				if (err != OK) {
+					r_ret = RTR("Not enough bytes for decoding bytes, or invalid format.");
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 0;
+					r_error.expected = Variant::POOL_BYTE_ARRAY;
 					return;
 				}
-
 			}
 
-			r_ret=ret;
+			r_ret = ret;
 
 		} break;
 		case GEN_RANGE: {
 
-			switch(p_arg_count) {
+			switch (p_arg_count) {
 
 				case 0: {
 
-					r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
-					r_error.argument=1;
-					r_ret=Variant();
+					r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+					r_error.argument = 1;
+					r_ret = Variant();
 
 				} break;
 				case 1: {
 
 					VALIDATE_ARG_NUM(0);
-					int count=*p_args[0];
+					int count = *p_args[0];
 					Array arr;
-					if (count<=0) {
-						r_ret=arr;
+					if (count <= 0) {
+						r_ret = arr;
 						return;
 					}
 					Error err = arr.resize(count);
-					if (err!=OK) {
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-						r_ret=Variant();
+					if (err != OK) {
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_ret = Variant();
 						return;
 					}
 
-					for(int i=0;i<count;i++) {
-						arr[i]=i;
+					for (int i = 0; i < count; i++) {
+						arr[i] = i;
 					}
 
-					r_ret=arr;
+					r_ret = arr;
 				} break;
 				case 2: {
 
 					VALIDATE_ARG_NUM(0);
 					VALIDATE_ARG_NUM(1);
 
-					int from=*p_args[0];
-					int to=*p_args[1];
+					int from = *p_args[0];
+					int to = *p_args[1];
 
 					Array arr;
-					if (from>=to) {
-						r_ret=arr;
+					if (from >= to) {
+						r_ret = arr;
 						return;
 					}
-					Error err = arr.resize(to-from);
-					if (err!=OK) {
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-						r_ret=Variant();
+					Error err = arr.resize(to - from);
+					if (err != OK) {
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_ret = Variant();
 						return;
 					}
-					for(int i=from;i<to;i++)
-						arr[i-from]=i;
-					r_ret=arr;
+					for (int i = from; i < to; i++)
+						arr[i - from] = i;
+					r_ret = arr;
 				} break;
 				case 3: {
 
@@ -782,65 +769,64 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 					VALIDATE_ARG_NUM(1);
 					VALIDATE_ARG_NUM(2);
 
-					int from=*p_args[0];
-					int to=*p_args[1];
-					int incr=*p_args[2];
-					if (incr==0) {
+					int from = *p_args[0];
+					int to = *p_args[1];
+					int incr = *p_args[2];
+					if (incr == 0) {
 
-						r_ret=RTR("step argument is zero!");
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_ret = RTR("step argument is zero!");
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 						return;
 					}
 
 					Array arr;
-					if (from>=to && incr>0) {
-						r_ret=arr;
+					if (from >= to && incr > 0) {
+						r_ret = arr;
 						return;
 					}
-					if (from<=to && incr<0) {
-						r_ret=arr;
+					if (from <= to && incr < 0) {
+						r_ret = arr;
 						return;
 					}
 
 					//calculate how many
-					int count=0;
-					if (incr>0) {
+					int count = 0;
+					if (incr > 0) {
 
-						count=((to-from-1)/incr)+1;
+						count = ((to - from - 1) / incr) + 1;
 					} else {
 
-						count=((from-to-1)/-incr)+1;
+						count = ((from - to - 1) / -incr) + 1;
 					}
 
-
 					Error err = arr.resize(count);
 
-					if (err!=OK) {
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-						r_ret=Variant();
+					if (err != OK) {
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_ret = Variant();
 						return;
 					}
 
-					if (incr>0) {
-						int idx=0;
-						for(int i=from;i<to;i+=incr) {
-							arr[idx++]=i;
+					if (incr > 0) {
+						int idx = 0;
+						for (int i = from; i < to; i += incr) {
+							arr[idx++] = i;
 						}
 					} else {
 
-						int idx=0;
-						for(int i=from;i>to;i+=incr) {
-							arr[idx++]=i;
+						int idx = 0;
+						for (int i = from; i > to; i += incr) {
+							arr[idx++] = i;
 						}
 					}
 
-					r_ret=arr;
+					r_ret = arr;
 				} break;
 				default: {
 
-					r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
-					r_error.argument=3;
-					r_ret=Variant();
+					r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+					r_error.argument = 3;
+					r_ret = Variant();
 
 				} break;
 			}
@@ -848,13 +834,13 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 		} break;
 		case RESOURCE_LOAD: {
 			VALIDATE_ARG_COUNT(1);
-			if (p_args[0]->get_type()!=Variant::STRING) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::STRING;
-				r_ret=Variant();
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
 			} else {
-				r_ret=ResourceLoader::load(*p_args[0]);
+				r_ret = ResourceLoader::load(*p_args[0]);
 			}
 
 		} break;
@@ -862,91 +848,85 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 
 			VALIDATE_ARG_COUNT(1);
 
-			if (p_args[0]->get_type()==Variant::NIL) {
-				r_ret=Variant();
-			} else if (p_args[0]->get_type()!=Variant::OBJECT) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_ret=Variant();
+			if (p_args[0]->get_type() == Variant::NIL) {
+				r_ret = Variant();
+			} else if (p_args[0]->get_type() != Variant::OBJECT) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_ret = Variant();
 			} else {
 
 				Object *obj = *p_args[0];
 				if (!obj) {
-					r_ret=Variant();
+					r_ret = Variant();
 
-				} else if (!obj->get_script_instance() || obj->get_script_instance()->get_language()!=GDScriptLanguage::get_singleton()) {
+				} else if (!obj->get_script_instance() || obj->get_script_instance()->get_language() != GDScriptLanguage::get_singleton()) {
 
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-					r_error.argument=0;
-					r_error.expected=Variant::DICTIONARY;
-					r_ret=RTR("Not a script with an instance");
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 0;
+					r_error.expected = Variant::DICTIONARY;
+					r_ret = RTR("Not a script with an instance");
 					return;
 				} else {
 
-					GDInstance *ins = static_cast<GDInstance*>(obj->get_script_instance());
+					GDInstance *ins = static_cast<GDInstance *>(obj->get_script_instance());
 					Ref<GDScript> base = ins->get_script();
 					if (base.is_null()) {
 
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-						r_error.argument=0;
-						r_error.expected=Variant::DICTIONARY;
-						r_ret=RTR("Not based on a script");
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+						r_error.argument = 0;
+						r_error.expected = Variant::DICTIONARY;
+						r_ret = RTR("Not based on a script");
 						return;
-
 					}
 
-
 					GDScript *p = base.ptr();
 					Vector<StringName> sname;
 
-					while(p->_owner) {
+					while (p->_owner) {
 
 						sname.push_back(p->name);
-						p=p->_owner;
+						p = p->_owner;
 					}
 					sname.invert();
 
-
 					if (!p->path.is_resource_file()) {
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-						r_error.argument=0;
-						r_error.expected=Variant::DICTIONARY;
-						r_ret=Variant();
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+						r_error.argument = 0;
+						r_error.expected = Variant::DICTIONARY;
+						r_ret = Variant();
 
-
-						r_ret=RTR("Not based on a resource file");
+						r_ret = RTR("Not based on a resource file");
 
 						return;
 					}
 
-					NodePath cp(sname,Vector<StringName>(),false);
+					NodePath cp(sname, Vector<StringName>(), false);
 
 					Dictionary d;
-					d["@subpath"]=cp;
-					d["@path"]=p->path;
-
+					d["@subpath"] = cp;
+					d["@path"] = p->path;
 
 					p = base.ptr();
 
-					while(p) {
+					while (p) {
 
-						for(Set<StringName>::Element *E=p->members.front();E;E=E->next()) {
+						for (Set<StringName>::Element *E = p->members.front(); E; E = E->next()) {
 
 							Variant value;
-							if (ins->get(E->get(),value)) {
+							if (ins->get(E->get(), value)) {
 
 								String k = E->get();
 								if (!d.has(k)) {
-									d[k]=value;
+									d[k] = value;
 								}
 							}
 						}
 
-						p=p->_base;
+						p = p->_base;
 					}
 
-					r_ret=d;
-
+					r_ret = d;
 				}
 			}
 
@@ -955,12 +935,12 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 
 			VALIDATE_ARG_COUNT(1);
 
-			if (p_args[0]->get_type()!=Variant::DICTIONARY) {
+			if (p_args[0]->get_type() != Variant::DICTIONARY) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::DICTIONARY;
-				r_ret=Variant();
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::DICTIONARY;
+				r_ret = Variant();
 
 				return;
 			}
@@ -969,10 +949,10 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 
 			if (!d.has("@path")) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::OBJECT;
-				r_ret=RTR("Invalid instance dictionary format (missing @path)");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = RTR("Invalid instance dictionary format (missing @path)");
 
 				return;
 			}
@@ -980,10 +960,10 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 			Ref<Script> scr = ResourceLoader::load(d["@path"]);
 			if (!scr.is_valid()) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::OBJECT;
-				r_ret=RTR("Invalid instance dictionary format (can't load script at @path)");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = RTR("Invalid instance dictionary format (can't load script at @path)");
 				return;
 			}
 
@@ -991,40 +971,40 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 
 			if (!gdscr.is_valid()) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::OBJECT;
-				r_ret=Variant();
-				r_ret=RTR("Invalid instance dictionary format (invalid script at @path)");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = Variant();
+				r_ret = RTR("Invalid instance dictionary format (invalid script at @path)");
 				return;
 			}
 
 			NodePath sub;
 			if (d.has("@subpath")) {
-				sub=d["@subpath"];
+				sub = d["@subpath"];
 			}
 
-			for(int i=0;i<sub.get_name_count();i++) {
+			for (int i = 0; i < sub.get_name_count(); i++) {
 
-				gdscr = gdscr->subclasses[ sub.get_name(i)];
+				gdscr = gdscr->subclasses[sub.get_name(i)];
 				if (!gdscr.is_valid()) {
 
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-					r_error.argument=0;
-					r_error.expected=Variant::OBJECT;
-					r_ret=Variant();
-					r_ret=RTR("Invalid instance dictionary (invalid subclasses)");
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 0;
+					r_error.expected = Variant::OBJECT;
+					r_ret = Variant();
+					r_ret = RTR("Invalid instance dictionary (invalid subclasses)");
 					return;
 				}
 			}
 
-			r_ret = gdscr->_new(NULL,0,r_error);
+			r_ret = gdscr->_new(NULL, 0, r_error);
 
-			GDInstance *ins = static_cast<GDInstance*>(static_cast<Object*>(r_ret)->get_script_instance());
+			GDInstance *ins = static_cast<GDInstance *>(static_cast<Object *>(r_ret)->get_script_instance());
 			Ref<GDScript> gd_ref = ins->get_script();
 
-			for(Map<StringName,GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
-				if(d.has(E->key())) {
+			for (Map<StringName, GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
+				if (d.has(E->key())) {
 					ins->members[E->get().index] = d[E->key()];
 				}
 			}
@@ -1034,23 +1014,23 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 
 			VALIDATE_ARG_COUNT(1);
 
-			if (p_args[0]->get_type()!=Variant::STRING) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::STRING;
-				r_ret=Variant();
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
 				return;
 			}
 
 			String errs;
 			int errl;
 
-			Error err = JSON::parse(*p_args[0],r_ret,errs,errl);
+			Error err = JSON::parse(*p_args[0], r_ret, errs, errl);
 
-			if (err!=OK) {
-				r_ret=itos(errl)+":"+errs;
+			if (err != OK) {
+				r_ret = itos(errl) + ":" + errs;
 			} else {
-				r_ret="";
+				r_ret = "";
 			}
 
 		} break;
@@ -1058,21 +1038,21 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 
 			VALIDATE_ARG_COUNT(1);
 
-			if (p_args[0]->get_type()!=Variant::STRING) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::STRING;
-				r_ret=Variant();
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
 				return;
 			}
 
 			String errs;
 			int errl;
 
-			Error err = JSON::parse(*p_args[0],r_ret,errs,errl);
+			Error err = JSON::parse(*p_args[0], r_ret, errs, errl);
 
-			if (err!=OK) {
-				r_ret=Variant();
+			if (err != OK) {
+				r_ret = Variant();
 			}
 
 		} break;
@@ -1084,22 +1064,22 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 		case HASH: {
 
 			VALIDATE_ARG_COUNT(1);
-			r_ret=p_args[0]->hash();
+			r_ret = p_args[0]->hash();
 
 		} break;
 		case COLOR8: {
 
-			if (p_arg_count<3) {
-				r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
-				r_error.argument=3;
-				r_ret=Variant();
+			if (p_arg_count < 3) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+				r_error.argument = 3;
+				r_ret = Variant();
 
 				return;
 			}
-			if (p_arg_count>4) {
-				r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
-				r_error.argument=4;
-				r_ret=Variant();
+			if (p_arg_count > 4) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+				r_error.argument = 4;
+				r_ret = Variant();
 
 				return;
 			}
@@ -1108,78 +1088,76 @@ void GDFunctions::call(Function p_func,const Variant **p_args,int p_arg_count,Va
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
 
-			Color color((float)*p_args[0]/255.0f,(float)*p_args[1]/255.0f,(float)*p_args[2]/255.0f);
+			Color color((float)*p_args[0] / 255.0f, (float)*p_args[1] / 255.0f, (float)*p_args[2] / 255.0f);
 
-			if (p_arg_count==4) {
+			if (p_arg_count == 4) {
 				VALIDATE_ARG_NUM(3);
-				color.a=(float)*p_args[3]/255.0f;
+				color.a = (float)*p_args[3] / 255.0f;
 			}
 
-			r_ret=color;
+			r_ret = color;
 
 		} break;
 		case COLORN: {
 
-			if (p_arg_count<1) {
-				r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
-				r_error.argument=1;
-				r_ret=Variant();
+			if (p_arg_count < 1) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+				r_error.argument = 1;
+				r_ret = Variant();
 				return;
 			}
 
-			if (p_arg_count>2) {
-				r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
-				r_error.argument=2;
-				r_ret=Variant();
+			if (p_arg_count > 2) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+				r_error.argument = 2;
+				r_ret = Variant();
 				return;
 			}
-			
-			if (p_args[0]->get_type()!=Variant::STRING) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_ret=Variant();
+
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_ret = Variant();
 			} else {
 				Color color = Color::named(*p_args[0]);
-				if (p_arg_count==2) {
+				if (p_arg_count == 2) {
 					VALIDATE_ARG_NUM(1);
-					color.a=*p_args[1];
+					color.a = *p_args[1];
 				}
-				r_ret=color;
+				r_ret = color;
 			}
 
 		} break;
 
 		case PRINT_STACK: {
 
-			ScriptLanguage* script = GDScriptLanguage::get_singleton();
-			for (int i=0; i < script->debug_get_stack_level_count(); i++) {
+			ScriptLanguage *script = GDScriptLanguage::get_singleton();
+			for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
 
-				print_line("Frame "+itos(i)+" - "+script->debug_get_stack_level_source(i)+":"+itos(script->debug_get_stack_level_line(i))+" in function '"+script->debug_get_stack_level_function(i)+"'");
+				print_line("Frame " + itos(i) + " - " + script->debug_get_stack_level_source(i) + ":" + itos(script->debug_get_stack_level_line(i)) + " in function '" + script->debug_get_stack_level_function(i) + "'");
 			};
 		} break;
 
 		case INSTANCE_FROM_ID: {
 
 			VALIDATE_ARG_COUNT(1);
-			if (p_args[0]->get_type()!=Variant::INT && p_args[0]->get_type()!=Variant::REAL) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::INT;
-				r_ret=Variant();
+			if (p_args[0]->get_type() != Variant::INT && p_args[0]->get_type() != Variant::REAL) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::INT;
+				r_ret = Variant();
 				break;
 			}
 
-			uint32_t id=*p_args[0];
-			r_ret=ObjectDB::get_instance(id);
+			uint32_t id = *p_args[0];
+			r_ret = ObjectDB::get_instance(id);
 
 		} break;
 		case FUNC_MAX: {
 
 			ERR_FAIL();
 		} break;
-
 	}
-
 }
 
 bool GDFunctions::is_deterministic(Function p_func) {
@@ -1187,7 +1165,7 @@ bool GDFunctions::is_deterministic(Function p_func) {
 	//man i couldn't have chosen a worse function name,
 	//way too controversial..
 
-	switch(p_func) {
+	switch (p_func) {
 
 		case MATH_SIN:
 		case MATH_COS:
@@ -1231,16 +1209,13 @@ bool GDFunctions::is_deterministic(Function p_func) {
 		case TEXT_CHAR:
 		case TEXT_STR:
 		case COLOR8:
-// enable for debug only, otherwise not desirable - case GEN_RANGE:
+			// enable for debug only, otherwise not desirable - case GEN_RANGE:
 			return true;
 		default:
 			return false;
-
 	}
 
 	return false;
-
-
 }
 
 MethodInfo GDFunctions::get_info(Function p_func) {
@@ -1248,401 +1223,401 @@ MethodInfo GDFunctions::get_info(Function p_func) {
 #ifdef TOOLS_ENABLED
 	//using a switch, so the compiler generates a jumptable
 
-	switch(p_func) {
+	switch (p_func) {
 
 		case MATH_SIN: {
-			MethodInfo mi("sin",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("sin", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 
 		} break;
 		case MATH_COS: {
-			MethodInfo mi("cos",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("cos", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_TAN: {
-			MethodInfo mi("tan",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("tan", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_SINH: {
-			MethodInfo mi("sinh",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("sinh", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_COSH: {
-			MethodInfo mi("cosh",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("cosh", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_TANH: {
-			MethodInfo mi("tanh",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("tanh", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_ASIN: {
-			MethodInfo mi("asin",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("asin", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_ACOS: {
-			MethodInfo mi("acos",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("acos", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_ATAN: {
-			MethodInfo mi("atan",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("atan", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_ATAN2: {
-			MethodInfo mi("atan2",PropertyInfo(Variant::REAL,"x"),PropertyInfo(Variant::REAL,"y"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("atan2", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_SQRT: {
-			MethodInfo mi("sqrt",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("sqrt", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_FMOD: {
-			MethodInfo mi("fmod",PropertyInfo(Variant::REAL,"x"),PropertyInfo(Variant::REAL,"y"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("fmod", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_FPOSMOD: {
-			MethodInfo mi("fposmod",PropertyInfo(Variant::REAL,"x"),PropertyInfo(Variant::REAL,"y"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("fposmod", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_FLOOR: {
-			MethodInfo mi("floor",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("floor", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
-		  } break;
+		} break;
 		case MATH_CEIL: {
-			MethodInfo mi("ceil",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("ceil", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_ROUND: {
-			MethodInfo mi("round",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("round", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_ABS: {
-			MethodInfo mi("abs",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("abs", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_SIGN: {
-			MethodInfo mi("sign",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("sign", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_POW: {
-			MethodInfo mi("pow",PropertyInfo(Variant::REAL,"x"),PropertyInfo(Variant::REAL,"y"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("pow", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_LOG: {
-			MethodInfo mi("log",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("log", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_EXP: {
-			MethodInfo mi("exp",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("exp", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_ISNAN: {
-			MethodInfo mi("is_nan",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("is_nan", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_ISINF: {
-			MethodInfo mi("is_inf",PropertyInfo(Variant::REAL,"s"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("is_inf", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_EASE: {
-			MethodInfo mi("ease",PropertyInfo(Variant::REAL,"s"),PropertyInfo(Variant::REAL,"curve"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("ease", PropertyInfo(Variant::REAL, "s"), PropertyInfo(Variant::REAL, "curve"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_DECIMALS: {
-			MethodInfo mi("decimals",PropertyInfo(Variant::REAL,"step"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("decimals", PropertyInfo(Variant::REAL, "step"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_STEPIFY: {
-			MethodInfo mi("stepify",PropertyInfo(Variant::REAL,"s"),PropertyInfo(Variant::REAL,"step"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("stepify", PropertyInfo(Variant::REAL, "s"), PropertyInfo(Variant::REAL, "step"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_LERP: {
-			MethodInfo mi("lerp",PropertyInfo(Variant::REAL,"from"),PropertyInfo(Variant::REAL,"to"), PropertyInfo(Variant::REAL,"weight"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("lerp", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"), PropertyInfo(Variant::REAL, "weight"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_DECTIME: {
-			MethodInfo mi("dectime",PropertyInfo(Variant::REAL,"value"),PropertyInfo(Variant::REAL,"amount"),PropertyInfo(Variant::REAL,"step"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("dectime", PropertyInfo(Variant::REAL, "value"), PropertyInfo(Variant::REAL, "amount"), PropertyInfo(Variant::REAL, "step"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_RANDOMIZE: {
 			MethodInfo mi("randomize");
-			mi.return_val.type=Variant::NIL;
+			mi.return_val.type = Variant::NIL;
 			return mi;
 		} break;
 		case MATH_RAND: {
 			MethodInfo mi("randi");
-			mi.return_val.type=Variant::INT;
+			mi.return_val.type = Variant::INT;
 			return mi;
 		} break;
 		case MATH_RANDF: {
 			MethodInfo mi("randf");
-			mi.return_val.type=Variant::REAL;
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_RANDOM: {
-			MethodInfo mi("rand_range",PropertyInfo(Variant::REAL,"from"),PropertyInfo(Variant::REAL,"to"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("rand_range", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_SEED: {
-			MethodInfo mi("seed",PropertyInfo(Variant::INT,"seed"));
-			mi.return_val.type=Variant::NIL;
+			MethodInfo mi("seed", PropertyInfo(Variant::INT, "seed"));
+			mi.return_val.type = Variant::NIL;
 			return mi;
 		} break;
 		case MATH_RANDSEED: {
-			MethodInfo mi("rand_seed",PropertyInfo(Variant::INT,"seed"));
-			mi.return_val.type=Variant::ARRAY;
+			MethodInfo mi("rand_seed", PropertyInfo(Variant::INT, "seed"));
+			mi.return_val.type = Variant::ARRAY;
 			return mi;
 		} break;
 		case MATH_DEG2RAD: {
-			MethodInfo mi("deg2rad",PropertyInfo(Variant::REAL,"deg"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("deg2rad", PropertyInfo(Variant::REAL, "deg"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_RAD2DEG: {
-			MethodInfo mi("rad2deg",PropertyInfo(Variant::REAL,"rad"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("rad2deg", PropertyInfo(Variant::REAL, "rad"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_LINEAR2DB: {
-			MethodInfo mi("linear2db",PropertyInfo(Variant::REAL,"nrg"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("linear2db", PropertyInfo(Variant::REAL, "nrg"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case MATH_DB2LINEAR: {
-			MethodInfo mi("db2linear",PropertyInfo(Variant::REAL,"db"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("db2linear", PropertyInfo(Variant::REAL, "db"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case LOGIC_MAX: {
-			MethodInfo mi("max",PropertyInfo(Variant::REAL,"a"),PropertyInfo(Variant::REAL,"b"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("max", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 
 		} break;
 		case LOGIC_MIN: {
-			MethodInfo mi("min",PropertyInfo(Variant::REAL,"a"),PropertyInfo(Variant::REAL,"b"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("min", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case LOGIC_CLAMP: {
-			MethodInfo mi("clamp",PropertyInfo(Variant::REAL,"val"),PropertyInfo(Variant::REAL,"min"),PropertyInfo(Variant::REAL,"max"));
-			mi.return_val.type=Variant::REAL;
+			MethodInfo mi("clamp", PropertyInfo(Variant::REAL, "val"), PropertyInfo(Variant::REAL, "min"), PropertyInfo(Variant::REAL, "max"));
+			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
 		case LOGIC_NEAREST_PO2: {
-			MethodInfo mi("nearest_po2",PropertyInfo(Variant::INT,"val"));
-			mi.return_val.type=Variant::INT;
+			MethodInfo mi("nearest_po2", PropertyInfo(Variant::INT, "val"));
+			mi.return_val.type = Variant::INT;
 			return mi;
 		} break;
 		case OBJ_WEAKREF: {
 
-			MethodInfo mi("weakref",PropertyInfo(Variant::OBJECT,"obj"));
-			mi.return_val.type=Variant::OBJECT;
-			mi.return_val.name="WeakRef";
+			MethodInfo mi("weakref", PropertyInfo(Variant::OBJECT, "obj"));
+			mi.return_val.type = Variant::OBJECT;
+			mi.return_val.name = "WeakRef";
 
 			return mi;
 
 		} break;
 		case FUNC_FUNCREF: {
 
-			MethodInfo mi("funcref",PropertyInfo(Variant::OBJECT,"instance"),PropertyInfo(Variant::STRING,"funcname"));
-			mi.return_val.type=Variant::OBJECT;
-			mi.return_val.name="FuncRef";
+			MethodInfo mi("funcref", PropertyInfo(Variant::OBJECT, "instance"), PropertyInfo(Variant::STRING, "funcname"));
+			mi.return_val.type = Variant::OBJECT;
+			mi.return_val.name = "FuncRef";
 			return mi;
 
 		} break;
 		case TYPE_CONVERT: {
 
-			MethodInfo mi("convert",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::INT,"type"));
-			mi.return_val.type=Variant::OBJECT;
+			MethodInfo mi("convert", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::INT, "type"));
+			mi.return_val.type = Variant::OBJECT;
 			return mi;
 		} break;
 		case TYPE_OF: {
 
-			MethodInfo mi("typeof",PropertyInfo(Variant::NIL,"what"));
-			mi.return_val.type=Variant::INT;
+			MethodInfo mi("typeof", PropertyInfo(Variant::NIL, "what"));
+			mi.return_val.type = Variant::INT;
 			return mi;
 
 		} break;
 		case TYPE_EXISTS: {
 
-			MethodInfo mi("type_exists",PropertyInfo(Variant::STRING,"type"));
-			mi.return_val.type=Variant::BOOL;
+			MethodInfo mi("type_exists", PropertyInfo(Variant::STRING, "type"));
+			mi.return_val.type = Variant::BOOL;
 			return mi;
 
 		} break;
 		case TEXT_CHAR: {
 
-			MethodInfo mi("char",PropertyInfo(Variant::INT,"ascii"));
-			mi.return_val.type=Variant::STRING;
+			MethodInfo mi("char", PropertyInfo(Variant::INT, "ascii"));
+			mi.return_val.type = Variant::STRING;
 			return mi;
 
 		} break;
 		case TEXT_STR: {
 
-			MethodInfo mi("str",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
-			mi.return_val.type=Variant::STRING;
+			MethodInfo mi("str", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
+			mi.return_val.type = Variant::STRING;
 			return mi;
 
 		} break;
 		case TEXT_PRINT: {
 
-			MethodInfo mi("print",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
-			mi.return_val.type=Variant::NIL;
+			MethodInfo mi("print", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
+			mi.return_val.type = Variant::NIL;
 			return mi;
 
 		} break;
 		case TEXT_PRINT_TABBED: {
 
-			MethodInfo mi("printt",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
-			mi.return_val.type=Variant::NIL;
+			MethodInfo mi("printt", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
+			mi.return_val.type = Variant::NIL;
 			return mi;
 
 		} break;
 		case TEXT_PRINT_SPACED: {
 
-			MethodInfo mi("prints",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
-			mi.return_val.type=Variant::NIL;
+			MethodInfo mi("prints", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
+			mi.return_val.type = Variant::NIL;
 			return mi;
 
 		} break;
 		case TEXT_PRINTERR: {
 
-			MethodInfo mi("printerr",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
-			mi.return_val.type=Variant::NIL;
+			MethodInfo mi("printerr", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
+			mi.return_val.type = Variant::NIL;
 			return mi;
 
 		} break;
 		case TEXT_PRINTRAW: {
 
-			MethodInfo mi("printraw",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
-			mi.return_val.type=Variant::NIL;
+			MethodInfo mi("printraw", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
+			mi.return_val.type = Variant::NIL;
 			return mi;
 
 		} break;
 		case VAR_TO_STR: {
-			MethodInfo mi("var2str",PropertyInfo(Variant::NIL,"var"));
-			mi.return_val.type=Variant::STRING;
+			MethodInfo mi("var2str", PropertyInfo(Variant::NIL, "var"));
+			mi.return_val.type = Variant::STRING;
 			return mi;
 
 		} break;
 		case STR_TO_VAR: {
 
-			MethodInfo mi("str2var:Variant",PropertyInfo(Variant::STRING,"string"));
-			mi.return_val.type=Variant::NIL;
+			MethodInfo mi("str2var:Variant", PropertyInfo(Variant::STRING, "string"));
+			mi.return_val.type = Variant::NIL;
 			return mi;
 		} break;
 		case VAR_TO_BYTES: {
-			MethodInfo mi("var2bytes",PropertyInfo(Variant::NIL,"var"));
-			mi.return_val.type=Variant::POOL_BYTE_ARRAY;
+			MethodInfo mi("var2bytes", PropertyInfo(Variant::NIL, "var"));
+			mi.return_val.type = Variant::POOL_BYTE_ARRAY;
 			return mi;
 
 		} break;
 		case BYTES_TO_VAR: {
 
-			MethodInfo mi("bytes2var:Variant",PropertyInfo(Variant::POOL_BYTE_ARRAY,"bytes"));
-			mi.return_val.type=Variant::NIL;
+			MethodInfo mi("bytes2var:Variant", PropertyInfo(Variant::POOL_BYTE_ARRAY, "bytes"));
+			mi.return_val.type = Variant::NIL;
 			return mi;
 		} break;
 		case GEN_RANGE: {
 
-			MethodInfo mi("range",PropertyInfo(Variant::NIL,"..."));
-			mi.return_val.type=Variant::ARRAY;
+			MethodInfo mi("range", PropertyInfo(Variant::NIL, "..."));
+			mi.return_val.type = Variant::ARRAY;
 			return mi;
 		} break;
 		case RESOURCE_LOAD: {
 
-			MethodInfo mi("load",PropertyInfo(Variant::STRING,"path"));
-			mi.return_val.type=Variant::OBJECT;
-			mi.return_val.name="Resource";
+			MethodInfo mi("load", PropertyInfo(Variant::STRING, "path"));
+			mi.return_val.type = Variant::OBJECT;
+			mi.return_val.name = "Resource";
 			return mi;
 		} break;
 		case INST2DICT: {
 
-			MethodInfo mi("inst2dict",PropertyInfo(Variant::OBJECT,"inst"));
-			mi.return_val.type=Variant::DICTIONARY;
+			MethodInfo mi("inst2dict", PropertyInfo(Variant::OBJECT, "inst"));
+			mi.return_val.type = Variant::DICTIONARY;
 			return mi;
 		} break;
 		case DICT2INST: {
 
-			MethodInfo mi("dict2inst",PropertyInfo(Variant::DICTIONARY,"dict"));
-			mi.return_val.type=Variant::OBJECT;
+			MethodInfo mi("dict2inst", PropertyInfo(Variant::DICTIONARY, "dict"));
+			mi.return_val.type = Variant::OBJECT;
 			return mi;
 		} break;
 		case VALIDATE_JSON: {
 
-			MethodInfo mi("validate_json:Variant",PropertyInfo(Variant::STRING,"json"));
-			mi.return_val.type=Variant::STRING;
+			MethodInfo mi("validate_json:Variant", PropertyInfo(Variant::STRING, "json"));
+			mi.return_val.type = Variant::STRING;
 			return mi;
 		} break;
 		case PARSE_JSON: {
 
-			MethodInfo mi("parse_json:Variant",PropertyInfo(Variant::STRING,"json"));
-			mi.return_val.type=Variant::NIL;
+			MethodInfo mi("parse_json:Variant", PropertyInfo(Variant::STRING, "json"));
+			mi.return_val.type = Variant::NIL;
 			return mi;
 		} break;
 		case TO_JSON: {
 
-			MethodInfo mi("to_json",PropertyInfo(Variant::NIL,"var:Variant"));
-			mi.return_val.type=Variant::STRING;
+			MethodInfo mi("to_json", PropertyInfo(Variant::NIL, "var:Variant"));
+			mi.return_val.type = Variant::STRING;
 			return mi;
 		} break;
 		case HASH: {
 
-			MethodInfo mi("hash",PropertyInfo(Variant::NIL,"var:Variant"));
-			mi.return_val.type=Variant::INT;
+			MethodInfo mi("hash", PropertyInfo(Variant::NIL, "var:Variant"));
+			mi.return_val.type = Variant::INT;
 			return mi;
 		} break;
 		case COLOR8: {
 
-			MethodInfo mi("Color8",PropertyInfo(Variant::INT,"r8"),PropertyInfo(Variant::INT,"g8"),PropertyInfo(Variant::INT,"b8"),PropertyInfo(Variant::INT,"a8"));
-			mi.return_val.type=Variant::COLOR;
+			MethodInfo mi("Color8", PropertyInfo(Variant::INT, "r8"), PropertyInfo(Variant::INT, "g8"), PropertyInfo(Variant::INT, "b8"), PropertyInfo(Variant::INT, "a8"));
+			mi.return_val.type = Variant::COLOR;
 			return mi;
 		} break;
 		case COLORN: {
 
-			MethodInfo mi("ColorN",PropertyInfo(Variant::STRING,"name"),PropertyInfo(Variant::REAL,"alpha"));
-			mi.return_val.type=Variant::COLOR;
+			MethodInfo mi("ColorN", PropertyInfo(Variant::STRING, "name"), PropertyInfo(Variant::REAL, "alpha"));
+			mi.return_val.type = Variant::COLOR;
 			return mi;
 		} break;
 
 		case PRINT_STACK: {
 			MethodInfo mi("print_stack");
-			mi.return_val.type=Variant::NIL;
+			mi.return_val.type = Variant::NIL;
 			return mi;
 		} break;
 
 		case INSTANCE_FROM_ID: {
-			MethodInfo mi("instance_from_id",PropertyInfo(Variant::INT,"instance_id"));
-			mi.return_val.type=Variant::OBJECT;
+			MethodInfo mi("instance_from_id", PropertyInfo(Variant::INT, "instance_id"));
+			mi.return_val.type = Variant::OBJECT;
 			return mi;
 		} break;
 
@@ -1650,7 +1625,6 @@ MethodInfo GDFunctions::get_info(Function p_func) {
 
 			ERR_FAIL_V(MethodInfo());
 		} break;
-
 	}
 #endif
 
diff --git a/modules/gdscript/gd_functions.h b/modules/gdscript/gd_functions.h
index 6e30b4dbb5..cde1a9210d 100644
--- a/modules/gdscript/gd_functions.h
+++ b/modules/gdscript/gd_functions.h
@@ -33,7 +33,6 @@
 
 class GDFunctions {
 public:
-
 	enum Function {
 		MATH_SIN,
 		MATH_COS,
@@ -110,10 +109,9 @@ public:
 	};
 
 	static const char *get_func_name(Function p_func);
-	static void call(Function p_func,const Variant **p_args,int p_arg_count,Variant &r_ret,Variant::CallError &r_error);
+	static void call(Function p_func, const Variant **p_args, int p_arg_count, Variant &r_ret, Variant::CallError &r_error);
 	static bool is_deterministic(Function p_func);
 	static MethodInfo get_info(Function p_func);
-
 };
 
 #endif // GD_FUNCTIONS_H
diff --git a/modules/gdscript/gd_parser.cpp b/modules/gdscript/gd_parser.cpp
index 5147ccd63f..86b97e27a9 100644
--- a/modules/gdscript/gd_parser.cpp
+++ b/modules/gdscript/gd_parser.cpp
@@ -27,74 +27,72 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "gd_parser.h"
-#include "print_string.h"
+#include "gd_script.h"
 #include "io/resource_loader.h"
 #include "os/file_access.h"
+#include "print_string.h"
 #include "script_language.h"
-#include "gd_script.h"
 
-template<class T>
-T* GDParser::alloc_node() {
+template <class T>
+T *GDParser::alloc_node() {
 
-	T *t = memnew( T);
+	T *t = memnew(T);
 
-	t->next=list;
-	list=t;
+	t->next = list;
+	list = t;
 
 	if (!head)
-		head=t;
+		head = t;
 
-	t->line=tokenizer->get_token_line();
-	t->column=tokenizer->get_token_column();
+	t->line = tokenizer->get_token_line();
+	t->column = tokenizer->get_token_column();
 	return t;
-
 }
 
 bool GDParser::_end_statement() {
 
-	if (tokenizer->get_token()==GDTokenizer::TK_SEMICOLON) {
+	if (tokenizer->get_token() == GDTokenizer::TK_SEMICOLON) {
 		tokenizer->advance();
 		return true; //handle next
-	} else if (tokenizer->get_token()==GDTokenizer::TK_NEWLINE || tokenizer->get_token()==GDTokenizer::TK_EOF) {
+	} else if (tokenizer->get_token() == GDTokenizer::TK_NEWLINE || tokenizer->get_token() == GDTokenizer::TK_EOF) {
 		return true; //will be handled properly
 	}
 
 	return false;
 }
 
-bool GDParser::_enter_indent_block(BlockNode* p_block) {
-
+bool GDParser::_enter_indent_block(BlockNode *p_block) {
 
-	if (tokenizer->get_token()!=GDTokenizer::TK_COLON) {
+	if (tokenizer->get_token() != GDTokenizer::TK_COLON) {
 		// report location at the previous token (on the previous line)
 		int error_line = tokenizer->get_token_line(-1);
 		int error_column = tokenizer->get_token_column(-1);
-		_set_error("':' expected at end of line.",error_line,error_column);
+		_set_error("':' expected at end of line.", error_line, error_column);
 		return false;
 	}
 	tokenizer->advance();
 
-	if (tokenizer->get_token()!=GDTokenizer::TK_NEWLINE) {
+	if (tokenizer->get_token() != GDTokenizer::TK_NEWLINE) {
 
 		// be more python-like
 		int current = tab_level.back()->get();
-		tab_level.push_back(current+1);
+		tab_level.push_back(current + 1);
 		return true;
 		//_set_error("newline expected after ':'.");
 		//return false;
 	}
 
-	while(true) {
+	while (true) {
 
-		if (tokenizer->get_token()!=GDTokenizer::TK_NEWLINE) {
+		if (tokenizer->get_token() != GDTokenizer::TK_NEWLINE) {
 
 			return false; //wtf
-		} else if (tokenizer->get_token(1)!=GDTokenizer::TK_NEWLINE) {
+		} else if (tokenizer->get_token(1) != GDTokenizer::TK_NEWLINE) {
 
 			int indent = tokenizer->get_token_line_indent();
 			int current = tab_level.back()->get();
-			if (indent<=current) {
-				print_line("current: "+itos(current)+" indent: "+itos(indent));
+			if (indent <= current) {
+				print_line("current: " + itos(current) + " indent: " + itos(indent));
 				print_line("less than current");
 				return false;
 			}
@@ -106,52 +104,51 @@ bool GDParser::_enter_indent_block(BlockNode* p_block) {
 		} else if (p_block) {
 
 			NewLineNode *nl = alloc_node<NewLineNode>();
-			nl->line=tokenizer->get_token_line();
+			nl->line = tokenizer->get_token_line();
 			p_block->statements.push_back(nl);
-
 		}
 
 		tokenizer->advance(); // go to next newline
 	}
 }
 
-bool GDParser::_parse_arguments(Node* p_parent,Vector<Node*>& p_args,bool p_static,bool p_can_codecomplete) {
+bool GDParser::_parse_arguments(Node *p_parent, Vector<Node *> &p_args, bool p_static, bool p_can_codecomplete) {
 
-	if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) {
+	if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE) {
 		tokenizer->advance();
 	} else {
 
-		parenthesis ++;
-		int argidx=0;
+		parenthesis++;
+		int argidx = 0;
 
-		while(true) {
+		while (true) {
 
-			if (tokenizer->get_token()==GDTokenizer::TK_CURSOR) {
+			if (tokenizer->get_token() == GDTokenizer::TK_CURSOR) {
 				_make_completable_call(argidx);
-				completion_node=p_parent;
-			} else if (tokenizer->get_token()==GDTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type()==Variant::STRING && tokenizer->get_token(1)==GDTokenizer::TK_CURSOR) {
+				completion_node = p_parent;
+			} else if (tokenizer->get_token() == GDTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING && tokenizer->get_token(1) == GDTokenizer::TK_CURSOR) {
 				//completing a string argument..
-				completion_cursor=tokenizer->get_token_constant();
+				completion_cursor = tokenizer->get_token_constant();
 
 				_make_completable_call(argidx);
-				completion_node=p_parent;
+				completion_node = p_parent;
 				tokenizer->advance(1);
 				return false;
 			}
 
-			Node*arg  = _parse_expression(p_parent,p_static);
+			Node *arg = _parse_expression(p_parent, p_static);
 			if (!arg)
 				return false;
 
 			p_args.push_back(arg);
 
-			if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) {
+			if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE) {
 				tokenizer->advance();
 				break;
 
-			} else if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+			} else if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 
-				if (tokenizer->get_token(1)==GDTokenizer::TK_PARENTHESIS_CLOSE) {
+				if (tokenizer->get_token(1) == GDTokenizer::TK_PARENTHESIS_CLOSE) {
 
 					_set_error("Expression expected");
 					return false;
@@ -164,57 +161,52 @@ bool GDParser::_parse_arguments(Node* p_parent,Vector<Node*>& p_args,bool p_stat
 				_set_error("Expected ',' or ')'");
 				return false;
 			}
-
 		}
-		parenthesis --;
+		parenthesis--;
 	}
 
 	return true;
-
 }
 
-
 void GDParser::_make_completable_call(int p_arg) {
 
-	completion_cursor=StringName();
-	completion_type=COMPLETION_CALL_ARGUMENTS;
-	completion_class=current_class;
-	completion_function=current_function;
-	completion_line=tokenizer->get_token_line();
-	completion_argument=p_arg;
-	completion_block=current_block;
-	completion_found=true;
+	completion_cursor = StringName();
+	completion_type = COMPLETION_CALL_ARGUMENTS;
+	completion_class = current_class;
+	completion_function = current_function;
+	completion_line = tokenizer->get_token_line();
+	completion_argument = p_arg;
+	completion_block = current_block;
+	completion_found = true;
 	tokenizer->advance();
-
 }
 
+bool GDParser::_get_completable_identifier(CompletionType p_type, StringName &identifier) {
 
-bool GDParser::_get_completable_identifier(CompletionType p_type,StringName& identifier) {
-
-	identifier=StringName();
-	if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER) {
-		identifier=tokenizer->get_token_identifier();
+	identifier = StringName();
+	if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER) {
+		identifier = tokenizer->get_token_identifier();
 		tokenizer->advance();
 	}
-	if (tokenizer->get_token()==GDTokenizer::TK_CURSOR) {
-
-		completion_cursor=identifier;
-		completion_type=p_type;
-		completion_class=current_class;
-		completion_function=current_function;
-		completion_line=tokenizer->get_token_line();
-		completion_block=current_block;
-		completion_found=true;
-		completion_ident_is_call=false;
+	if (tokenizer->get_token() == GDTokenizer::TK_CURSOR) {
+
+		completion_cursor = identifier;
+		completion_type = p_type;
+		completion_class = current_class;
+		completion_function = current_function;
+		completion_line = tokenizer->get_token_line();
+		completion_block = current_block;
+		completion_found = true;
+		completion_ident_is_call = false;
 		tokenizer->advance();
 
-		if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER) {
-			identifier=identifier.operator String() + tokenizer->get_token_identifier().operator String();
+		if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER) {
+			identifier = identifier.operator String() + tokenizer->get_token_identifier().operator String();
 			tokenizer->advance();
 		}
 
-		if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_OPEN) {
-			completion_ident_is_call=true;
+		if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_OPEN) {
+			completion_ident_is_call = true;
 		}
 		return true;
 	}
@@ -222,132 +214,129 @@ bool GDParser::_get_completable_identifier(CompletionType p_type,StringName& ide
 	return false;
 }
 
-
-GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_allow_assign,bool p_parsing_constant) {
+GDParser::Node *GDParser::_parse_expression(Node *p_parent, bool p_static, bool p_allow_assign, bool p_parsing_constant) {
 
 	//Vector<Node*> expressions;
 	//Vector<OperatorNode::Operator> operators;
 
 	Vector<Expression> expression;
 
-	Node *expr=NULL;
+	Node *expr = NULL;
 
 	int op_line = tokenizer->get_token_line(); // when operators are created at the bottom, the line might have been changed (\n found)
 
-	while(true) {
-
+	while (true) {
 
 		/*****************/
 		/* Parse Operand */
 		/*****************/
 
-		if (parenthesis>0) {
+		if (parenthesis > 0) {
 			//remove empty space (only allowed if inside parenthesis
-			while(tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+			while (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 				tokenizer->advance();
 			}
 		}
 
-		if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_OPEN) {
+		if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_OPEN) {
 			//subexpression ()
 			tokenizer->advance();
 			parenthesis++;
-			Node* subexpr = _parse_expression(p_parent,p_static,p_allow_assign,p_parsing_constant);
+			Node *subexpr = _parse_expression(p_parent, p_static, p_allow_assign, p_parsing_constant);
 			parenthesis--;
 			if (!subexpr)
 				return NULL;
 
-			if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+			if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 
 				_set_error("Expected ')' in expression");
 				return NULL;
 			}
 
 			tokenizer->advance();
-			expr=subexpr;
-		} else if (tokenizer->get_token()==GDTokenizer::TK_DOLLAR) {
+			expr = subexpr;
+		} else if (tokenizer->get_token() == GDTokenizer::TK_DOLLAR) {
 			tokenizer->advance();
 
 			String path;
 
-			bool need_identifier=true;
-			bool done=false;
+			bool need_identifier = true;
+			bool done = false;
 
-			while(!done) {
+			while (!done) {
 
-				switch(tokenizer->get_token()) {
+				switch (tokenizer->get_token()) {
 					case GDTokenizer::TK_CURSOR: {
-						completion_cursor=StringName();
-						completion_type=COMPLETION_GET_NODE;
-						completion_class=current_class;
-						completion_function=current_function;
-						completion_line=tokenizer->get_token_line();
-						completion_cursor=path;
-						completion_argument=0;
-						completion_block=current_block;
-						completion_found=true;
+						completion_cursor = StringName();
+						completion_type = COMPLETION_GET_NODE;
+						completion_class = current_class;
+						completion_function = current_function;
+						completion_line = tokenizer->get_token_line();
+						completion_cursor = path;
+						completion_argument = 0;
+						completion_block = current_block;
+						completion_found = true;
 						tokenizer->advance();
 					} break;
 					case GDTokenizer::TK_CONSTANT: {
 
 						if (!need_identifier) {
-							done=true;
+							done = true;
 							break;
 						}
 
-						if (tokenizer->get_token_constant().get_type()!=Variant::STRING) {
+						if (tokenizer->get_token_constant().get_type() != Variant::STRING) {
 							_set_error("Expected string constant or identifier after '$' or '/'.");
 							return NULL;
 						}
 
-						path+=String(tokenizer->get_token_constant());
+						path += String(tokenizer->get_token_constant());
 						tokenizer->advance();
-						need_identifier=false;
+						need_identifier = false;
 
 					} break;
 					case GDTokenizer::TK_IDENTIFIER: {
 						if (!need_identifier) {
-							done=true;
+							done = true;
 							break;
 						}
 
-						path+=String(tokenizer->get_token_identifier());
+						path += String(tokenizer->get_token_identifier());
 						tokenizer->advance();
-						need_identifier=false;
+						need_identifier = false;
 
 					} break;
 					case GDTokenizer::TK_OP_DIV: {
 
 						if (need_identifier) {
-							done=true;
+							done = true;
 							break;
 						}
 
-						path+="/";
+						path += "/";
 						tokenizer->advance();
-						need_identifier=true;
+						need_identifier = true;
 
 					} break;
 					default: {
-						done=true;
+						done = true;
 						break;
 					}
 				}
 			}
 
-			if (path=="") {
+			if (path == "") {
 				_set_error("Path expected after $.");
 				return NULL;
-
 			}
 
 			OperatorNode *op = alloc_node<OperatorNode>();
-			op->op=OperatorNode::OP_CALL;
+			op->op = OperatorNode::OP_CALL;
 
 			op->arguments.push_back(alloc_node<SelfNode>());
 
 			IdentifierNode *funcname = alloc_node<IdentifierNode>();
-			funcname->name="get_node";
+			funcname->name = "get_node";
 
 			op->arguments.push_back(funcname);
 
@@ -355,47 +344,45 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 			nodepath->value = NodePath(StringName(path));
 			op->arguments.push_back(nodepath);
 
-			expr=op;
+			expr = op;
 
-		} else if (tokenizer->get_token()==GDTokenizer::TK_CURSOR) {
+		} else if (tokenizer->get_token() == GDTokenizer::TK_CURSOR) {
 			tokenizer->advance();
 			continue; //no point in cursor in the middle of expression
 
-		} else if (tokenizer->get_token()==GDTokenizer::TK_CONSTANT) {
+		} else if (tokenizer->get_token() == GDTokenizer::TK_CONSTANT) {
 
 			//constant defined by tokenizer
 			ConstantNode *constant = alloc_node<ConstantNode>();
-			constant->value=tokenizer->get_token_constant();
+			constant->value = tokenizer->get_token_constant();
 			tokenizer->advance();
-			expr=constant;
-		} else if (tokenizer->get_token()==GDTokenizer::TK_CONST_PI) {
+			expr = constant;
+		} else if (tokenizer->get_token() == GDTokenizer::TK_CONST_PI) {
 
 			//constant defined by tokenizer
 			ConstantNode *constant = alloc_node<ConstantNode>();
-			constant->value=Math_PI;
+			constant->value = Math_PI;
 			tokenizer->advance();
-			expr=constant;
-		}
-		else if (tokenizer->get_token() == GDTokenizer::TK_CONST_INF) {
+			expr = constant;
+		} else if (tokenizer->get_token() == GDTokenizer::TK_CONST_INF) {
 
 			//constant defined by tokenizer
 			ConstantNode *constant = alloc_node<ConstantNode>();
 			constant->value = Math_INF;
 			tokenizer->advance();
 			expr = constant;
-		}
-		else if (tokenizer->get_token() == GDTokenizer::TK_CONST_NAN) {
+		} else if (tokenizer->get_token() == GDTokenizer::TK_CONST_NAN) {
 
 			//constant defined by tokenizer
 			ConstantNode *constant = alloc_node<ConstantNode>();
 			constant->value = Math_NAN;
 			tokenizer->advance();
 			expr = constant;
-		} else if (tokenizer->get_token()==GDTokenizer::TK_PR_PRELOAD) {
+		} else if (tokenizer->get_token() == GDTokenizer::TK_PR_PRELOAD) {
 
 			//constant defined by tokenizer
 			tokenizer->advance();
-			if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) {
+			if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_OPEN) {
 				_set_error("Expected '(' after 'preload'");
 				return NULL;
 			}
@@ -409,18 +396,18 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 			Node *subexpr = _parse_and_reduce_expression(p_parent, p_static);
 			if (subexpr) {
 				if (subexpr->type == Node::TYPE_CONSTANT) {
-					cn = static_cast<ConstantNode*>(subexpr);
+					cn = static_cast<ConstantNode *>(subexpr);
 					found_constant = true;
 				}
 				if (subexpr->type == Node::TYPE_IDENTIFIER) {
-					IdentifierNode *in = static_cast<IdentifierNode*>(subexpr);
+					IdentifierNode *in = static_cast<IdentifierNode *>(subexpr);
 					Vector<ClassNode::Constant> ce = current_class->constant_expressions;
 
 					// Try to find the constant expression by the identifier
-					for(int i=0; i < ce.size(); ++i){
-						if(ce[i].identifier == in->name) {
-							if(ce[i].expression->type == Node::TYPE_CONSTANT) {
-								cn = static_cast<ConstantNode*>(ce[i].expression);
+					for (int i = 0; i < ce.size(); ++i) {
+						if (ce[i].identifier == in->name) {
+							if (ce[i].expression->type == Node::TYPE_CONSTANT) {
+								cn = static_cast<ConstantNode *>(ce[i].expression);
 								found_constant = true;
 							}
 						}
@@ -429,7 +416,7 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 
 				if (found_constant && cn->value.get_type() == Variant::STRING) {
 					valid = true;
-					path = (String) cn->value;
+					path = (String)cn->value;
 				}
 			}
 
@@ -438,17 +425,15 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 				return NULL;
 			}
 
-			if (!path.is_abs_path() && base_path!="")
-				path=base_path+"/"+path;
-			path = path.replace("///","//").simplify_path();
-			if (path==self_path) {
+			if (!path.is_abs_path() && base_path != "")
+				path = base_path + "/" + path;
+			path = path.replace("///", "//").simplify_path();
+			if (path == self_path) {
 
 				_set_error("Can't preload itself (use 'get_script()').");
 				return NULL;
-
 			}
 
-
 			Ref<Resource> res;
 			if (!validating) {
 
@@ -459,33 +444,33 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 					res = ResourceLoader::load(path);
 				}
 				if (!res.is_valid()) {
-					_set_error("Can't preload resource at path: "+path);
+					_set_error("Can't preload resource at path: " + path);
 					return NULL;
 				}
 			} else {
 
 				if (!FileAccess::exists(path)) {
-					_set_error("Can't preload resource at path: "+path);
+					_set_error("Can't preload resource at path: " + path);
 					return NULL;
 				}
 			}
 
-			if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+			if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 				_set_error("Expected ')' after 'preload' path");
 				return NULL;
 			}
 
 			ConstantNode *constant = alloc_node<ConstantNode>();
-			constant->value=res;
+			constant->value = res;
 			tokenizer->advance();
 
-			expr=constant;
-		} else if (tokenizer->get_token()==GDTokenizer::TK_PR_YIELD) {
+			expr = constant;
+		} else if (tokenizer->get_token() == GDTokenizer::TK_PR_YIELD) {
 
 			//constant defined by tokenizer
 
 			tokenizer->advance();
-			if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) {
+			if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_OPEN) {
 				_set_error("Expected '(' after 'yield'");
 				return NULL;
 			}
@@ -493,65 +478,63 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 			tokenizer->advance();
 
 			OperatorNode *yield = alloc_node<OperatorNode>();
-			yield->op=OperatorNode::OP_YIELD;
+			yield->op = OperatorNode::OP_YIELD;
 
-			while (tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+			while (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 				tokenizer->advance();
 			}
 
-			if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) {
-				expr=yield;
+			if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE) {
+				expr = yield;
 				tokenizer->advance();
 			} else {
 
-				parenthesis ++;
+				parenthesis++;
 
-				Node *object = _parse_and_reduce_expression(p_parent,p_static);
+				Node *object = _parse_and_reduce_expression(p_parent, p_static);
 				if (!object)
 					return NULL;
 				yield->arguments.push_back(object);
 
-				if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) {
+				if (tokenizer->get_token() != GDTokenizer::TK_COMMA) {
 					_set_error("Expected ',' after first argument of 'yield'");
 					return NULL;
 				}
 
 				tokenizer->advance();
 
-				if (tokenizer->get_token()==GDTokenizer::TK_CURSOR) {
-
-
-					completion_cursor=StringName();
-					completion_node=object;
-					completion_type=COMPLETION_YIELD;
-					completion_class=current_class;
-					completion_function=current_function;
-					completion_line=tokenizer->get_token_line();
-					completion_argument=0;
-					completion_block=current_block;
-					completion_found=true;
+				if (tokenizer->get_token() == GDTokenizer::TK_CURSOR) {
+
+					completion_cursor = StringName();
+					completion_node = object;
+					completion_type = COMPLETION_YIELD;
+					completion_class = current_class;
+					completion_function = current_function;
+					completion_line = tokenizer->get_token_line();
+					completion_argument = 0;
+					completion_block = current_block;
+					completion_found = true;
 					tokenizer->advance();
 				}
 
-				Node *signal = _parse_and_reduce_expression(p_parent,p_static);
+				Node *signal = _parse_and_reduce_expression(p_parent, p_static);
 				if (!signal)
 					return NULL;
 				yield->arguments.push_back(signal);
 
-				if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+				if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 					_set_error("Expected ')' after second argument of 'yield'");
 					return NULL;
 				}
 
-				parenthesis --;
+				parenthesis--;
 
 				tokenizer->advance();
 
-				expr=yield;
+				expr = yield;
 			}
 
-
-		} else if (tokenizer->get_token()==GDTokenizer::TK_SELF) {
+		} else if (tokenizer->get_token() == GDTokenizer::TK_SELF) {
 
 			if (p_static) {
 				_set_error("'self'' not allowed in static function or constant expression");
@@ -560,51 +543,50 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 			//constant defined by tokenizer
 			SelfNode *self = alloc_node<SelfNode>();
 			tokenizer->advance();
-			expr=self;
-		} else if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token(1)==GDTokenizer::TK_PERIOD) {
+			expr = self;
+		} else if (tokenizer->get_token() == GDTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token(1) == GDTokenizer::TK_PERIOD) {
 
 			Variant::Type bi_type = tokenizer->get_token_type();
 			tokenizer->advance(2);
 
 			StringName identifier;
 
-			if (_get_completable_identifier(COMPLETION_BUILT_IN_TYPE_CONSTANT,identifier)) {
+			if (_get_completable_identifier(COMPLETION_BUILT_IN_TYPE_CONSTANT, identifier)) {
 
-				completion_built_in_constant=bi_type;
+				completion_built_in_constant = bi_type;
 			}
 
-			if (identifier==StringName()) {
+			if (identifier == StringName()) {
 
 				_set_error("Built-in type constant expected after '.'");
 				return NULL;
 			}
-			if (!Variant::has_numeric_constant(bi_type,identifier)) {
+			if (!Variant::has_numeric_constant(bi_type, identifier)) {
 
-				_set_error("Static constant  '"+identifier.operator String()+"' not present in built-in type "+Variant::get_type_name(bi_type)+".");
+				_set_error("Static constant  '" + identifier.operator String() + "' not present in built-in type " + Variant::get_type_name(bi_type) + ".");
 				return NULL;
 			}
 
 			ConstantNode *cn = alloc_node<ConstantNode>();
-			cn->value=Variant::get_numeric_constant_value(bi_type,identifier);
-			expr=cn;
+			cn->value = Variant::get_numeric_constant_value(bi_type, identifier);
+			expr = cn;
 
-
-		} else if (tokenizer->get_token(1)==GDTokenizer::TK_PARENTHESIS_OPEN && (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE || tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER || tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_FUNC)) {
+		} else if (tokenizer->get_token(1) == GDTokenizer::TK_PARENTHESIS_OPEN && (tokenizer->get_token() == GDTokenizer::TK_BUILT_IN_TYPE || tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER || tokenizer->get_token() == GDTokenizer::TK_BUILT_IN_FUNC)) {
 			//function or constructor
 
 			OperatorNode *op = alloc_node<OperatorNode>();
-			op->op=OperatorNode::OP_CALL;
+			op->op = OperatorNode::OP_CALL;
 
-			if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE) {
+			if (tokenizer->get_token() == GDTokenizer::TK_BUILT_IN_TYPE) {
 
 				TypeNode *tn = alloc_node<TypeNode>();
-				tn->vtype=tokenizer->get_token_type();
+				tn->vtype = tokenizer->get_token_type();
 				op->arguments.push_back(tn);
 				tokenizer->advance(2);
-			} else if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_FUNC) {
+			} else if (tokenizer->get_token() == GDTokenizer::TK_BUILT_IN_FUNC) {
 
 				BuiltInFunctionNode *bn = alloc_node<BuiltInFunctionNode>();
-				bn->function=tokenizer->get_token_built_in_func();
+				bn->function = tokenizer->get_token_built_in_func();
 				op->arguments.push_back(bn);
 				tokenizer->advance(2);
 			} else {
@@ -613,43 +595,40 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 				op->arguments.push_back(self);
 
 				StringName identifier;
-				if (_get_completable_identifier(COMPLETION_FUNCTION,identifier)) {
-
+				if (_get_completable_identifier(COMPLETION_FUNCTION, identifier)) {
 				}
 
-				IdentifierNode* id = alloc_node<IdentifierNode>();
-				id->name=identifier;
+				IdentifierNode *id = alloc_node<IdentifierNode>();
+				id->name = identifier;
 				op->arguments.push_back(id);
 				tokenizer->advance(1);
 			}
 
-			if (tokenizer->get_token()==GDTokenizer::TK_CURSOR) {
+			if (tokenizer->get_token() == GDTokenizer::TK_CURSOR) {
 				_make_completable_call(0);
-				completion_node=op;
-
+				completion_node = op;
 			}
-			if (!_parse_arguments(op,op->arguments,p_static,true))
+			if (!_parse_arguments(op, op->arguments, p_static, true))
 				return NULL;
 
-			expr=op;
+			expr = op;
 
-		} else if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER) {
+		} else if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER) {
 			//identifier (reference)
 
-			const ClassNode* cln = current_class;
-			bool             bfn = false;
-			StringName       identifier;
-			if (_get_completable_identifier(COMPLETION_IDENTIFIER,identifier)) {
-
+			const ClassNode *cln = current_class;
+			bool bfn = false;
+			StringName identifier;
+			if (_get_completable_identifier(COMPLETION_IDENTIFIER, identifier)) {
 			}
 
 			if (p_parsing_constant) {
-				for( int i=0; i<cln->constant_expressions.size(); ++i ) {
+				for (int i = 0; i < cln->constant_expressions.size(); ++i) {
 
-					if( cln->constant_expressions[i].identifier == identifier ) {
+					if (cln->constant_expressions[i].identifier == identifier) {
 
 						expr = cln->constant_expressions[i].expression;
-						bfn  = true;
+						bfn = true;
 						break;
 					}
 				}
@@ -657,37 +636,36 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 				if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
 					//check from constants
 					ConstantNode *constant = alloc_node<ConstantNode>();
-					constant->value = GDScriptLanguage::get_singleton()->get_global_array()[ GDScriptLanguage::get_singleton()->get_global_map()[identifier] ];
-					expr=constant;
+					constant->value = GDScriptLanguage::get_singleton()->get_global_array()[GDScriptLanguage::get_singleton()->get_global_map()[identifier]];
+					expr = constant;
 					bfn = true;
 				}
 			}
 
-			if ( !bfn ) {
+			if (!bfn) {
 				IdentifierNode *id = alloc_node<IdentifierNode>();
 				id->name = identifier;
 				expr = id;
 			}
 
-		} else if (tokenizer->get_token()==GDTokenizer::TK_OP_ADD || tokenizer->get_token()==GDTokenizer::TK_OP_SUB || tokenizer->get_token()==GDTokenizer::TK_OP_NOT || tokenizer->get_token()==GDTokenizer::TK_OP_BIT_INVERT) {
+		} else if (tokenizer->get_token() == GDTokenizer::TK_OP_ADD || tokenizer->get_token() == GDTokenizer::TK_OP_SUB || tokenizer->get_token() == GDTokenizer::TK_OP_NOT || tokenizer->get_token() == GDTokenizer::TK_OP_BIT_INVERT) {
 
 			//single prefix operators like !expr +expr -expr ++expr --expr
 			alloc_node<OperatorNode>();
 			Expression e;
-			e.is_op=true;
+			e.is_op = true;
 
-			switch(tokenizer->get_token()) {
-				case GDTokenizer::TK_OP_ADD: e.op=OperatorNode::OP_POS; break;
-				case GDTokenizer::TK_OP_SUB: e.op=OperatorNode::OP_NEG; break;
-				case GDTokenizer::TK_OP_NOT: e.op=OperatorNode::OP_NOT; break;
-				case GDTokenizer::TK_OP_BIT_INVERT: e.op=OperatorNode::OP_BIT_INVERT; break;
+			switch (tokenizer->get_token()) {
+				case GDTokenizer::TK_OP_ADD: e.op = OperatorNode::OP_POS; break;
+				case GDTokenizer::TK_OP_SUB: e.op = OperatorNode::OP_NEG; break;
+				case GDTokenizer::TK_OP_NOT: e.op = OperatorNode::OP_NOT; break;
+				case GDTokenizer::TK_OP_BIT_INVERT: e.op = OperatorNode::OP_BIT_INVERT; break;
 				default: {}
 			}
 
-
 			tokenizer->advance();
 
-			if (e.op!=OperatorNode::OP_NOT && tokenizer->get_token()==GDTokenizer::TK_OP_NOT) {
+			if (e.op != OperatorNode::OP_NOT && tokenizer->get_token() == GDTokenizer::TK_OP_NOT) {
 				_set_error("Misplaced 'not'.");
 				return NULL;
 			}
@@ -702,33 +680,33 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 			op->arguments.push_back(subexpr);
 			expr=op;*/
 
-		} else if (tokenizer->get_token()==GDTokenizer::TK_BRACKET_OPEN) {
+		} else if (tokenizer->get_token() == GDTokenizer::TK_BRACKET_OPEN) {
 			// array
 			tokenizer->advance();
 
 			ArrayNode *arr = alloc_node<ArrayNode>();
-			bool expecting_comma=false;
+			bool expecting_comma = false;
 
-			while(true) {
+			while (true) {
 
-				if (tokenizer->get_token()==GDTokenizer::TK_EOF) {
+				if (tokenizer->get_token() == GDTokenizer::TK_EOF) {
 
 					_set_error("Unterminated array");
 					return NULL;
 
-				} else if (tokenizer->get_token()==GDTokenizer::TK_BRACKET_CLOSE) {
+				} else if (tokenizer->get_token() == GDTokenizer::TK_BRACKET_CLOSE) {
 					tokenizer->advance();
 					break;
-				} else if (tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+				} else if (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 
 					tokenizer->advance(); //ignore newline
-				} else if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+				} else if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 					if (!expecting_comma) {
 						_set_error("expression or ']' expected");
 						return NULL;
 					}
 
-					expecting_comma=false;
+					expecting_comma = false;
 					tokenizer->advance(); //ignore newline
 				} else {
 					//parse expression
@@ -736,16 +714,16 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 						_set_error("',' or ']' expected");
 						return NULL;
 					}
-					Node *n = _parse_expression(arr,p_static,p_allow_assign,p_parsing_constant);
+					Node *n = _parse_expression(arr, p_static, p_allow_assign, p_parsing_constant);
 					if (!n)
 						return NULL;
 					arr->elements.push_back(n);
-					expecting_comma=true;
+					expecting_comma = true;
 				}
 			}
 
-			expr=arr;
-		} else if (tokenizer->get_token()==GDTokenizer::TK_CURLY_BRACKET_OPEN) {
+			expr = arr;
+		} else if (tokenizer->get_token() == GDTokenizer::TK_CURLY_BRACKET_OPEN) {
 			// array
 			tokenizer->advance();
 
@@ -760,105 +738,105 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 
 			};
 
-			Node *key=NULL;
+			Node *key = NULL;
 			Set<Variant> keys;
 
-			DictExpect expecting=DICT_EXPECT_KEY;
+			DictExpect expecting = DICT_EXPECT_KEY;
 
-			while(true) {
+			while (true) {
 
-				if (tokenizer->get_token()==GDTokenizer::TK_EOF) {
+				if (tokenizer->get_token() == GDTokenizer::TK_EOF) {
 
 					_set_error("Unterminated dictionary");
 					return NULL;
 
-				} else if (tokenizer->get_token()==GDTokenizer::TK_CURLY_BRACKET_CLOSE) {
+				} else if (tokenizer->get_token() == GDTokenizer::TK_CURLY_BRACKET_CLOSE) {
 
-					if (expecting==DICT_EXPECT_COLON) {
+					if (expecting == DICT_EXPECT_COLON) {
 						_set_error("':' expected");
 						return NULL;
 					}
-					if (expecting==DICT_EXPECT_VALUE) {
+					if (expecting == DICT_EXPECT_VALUE) {
 						_set_error("value expected");
 						return NULL;
 					}
 					tokenizer->advance();
 					break;
-				} else if (tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+				} else if (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 
 					tokenizer->advance(); //ignore newline
-				} else if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+				} else if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 
-					if (expecting==DICT_EXPECT_KEY) {
+					if (expecting == DICT_EXPECT_KEY) {
 						_set_error("key or '}' expected");
 						return NULL;
 					}
-					if (expecting==DICT_EXPECT_VALUE) {
+					if (expecting == DICT_EXPECT_VALUE) {
 						_set_error("value expected");
 						return NULL;
 					}
-					if (expecting==DICT_EXPECT_COLON) {
+					if (expecting == DICT_EXPECT_COLON) {
 						_set_error("':' expected");
 						return NULL;
 					}
 
-					expecting=DICT_EXPECT_KEY;
+					expecting = DICT_EXPECT_KEY;
 					tokenizer->advance(); //ignore newline
 
-				} else if (tokenizer->get_token()==GDTokenizer::TK_COLON) {
+				} else if (tokenizer->get_token() == GDTokenizer::TK_COLON) {
 
-					if (expecting==DICT_EXPECT_KEY) {
+					if (expecting == DICT_EXPECT_KEY) {
 						_set_error("key or '}' expected");
 						return NULL;
 					}
-					if (expecting==DICT_EXPECT_VALUE) {
+					if (expecting == DICT_EXPECT_VALUE) {
 						_set_error("value expected");
 						return NULL;
 					}
-					if (expecting==DICT_EXPECT_COMMA) {
+					if (expecting == DICT_EXPECT_COMMA) {
 						_set_error("',' or '}' expected");
 						return NULL;
 					}
 
-					expecting=DICT_EXPECT_VALUE;
+					expecting = DICT_EXPECT_VALUE;
 					tokenizer->advance(); //ignore newline
 				} else {
 
-					if (expecting==DICT_EXPECT_COMMA) {
+					if (expecting == DICT_EXPECT_COMMA) {
 						_set_error("',' or '}' expected");
 						return NULL;
 					}
-					if (expecting==DICT_EXPECT_COLON) {
+					if (expecting == DICT_EXPECT_COLON) {
 						_set_error("':' expected");
 						return NULL;
 					}
 
-					if (expecting==DICT_EXPECT_KEY) {
+					if (expecting == DICT_EXPECT_KEY) {
 
-						if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token(1)==GDTokenizer::TK_OP_ASSIGN) {
+						if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER && tokenizer->get_token(1) == GDTokenizer::TK_OP_ASSIGN) {
 							//lua style identifier, easier to write
 							ConstantNode *cn = alloc_node<ConstantNode>();
 							cn->value = tokenizer->get_token_identifier();
 							key = cn;
 							tokenizer->advance(2);
-							expecting=DICT_EXPECT_VALUE;
+							expecting = DICT_EXPECT_VALUE;
 						} else {
 							//python/js style more flexible
-							key = _parse_expression(dict,p_static,p_allow_assign,p_parsing_constant);
+							key = _parse_expression(dict, p_static, p_allow_assign, p_parsing_constant);
 							if (!key)
 								return NULL;
-							expecting=DICT_EXPECT_COLON;
+							expecting = DICT_EXPECT_COLON;
 						}
 					}
 
-					if (expecting==DICT_EXPECT_VALUE) {
-						Node *value = _parse_expression(dict,p_static,p_allow_assign,p_parsing_constant);
+					if (expecting == DICT_EXPECT_VALUE) {
+						Node *value = _parse_expression(dict, p_static, p_allow_assign, p_parsing_constant);
 						if (!value)
 							return NULL;
-						expecting=DICT_EXPECT_COMMA;
+						expecting = DICT_EXPECT_COMMA;
 
 						if (key->type == GDParser::Node::TYPE_CONSTANT) {
-							Variant const& keyName = static_cast<const GDParser::ConstantNode*>(key)->value;
+							Variant const &keyName = static_cast<const GDParser::ConstantNode *>(key)->value;
 
 							if (keys.has(keyName)) {
 								_set_error("Duplicate key found in Dictionary literal");
@@ -868,43 +846,40 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 						}
 
 						DictionaryNode::Pair pair;
-						pair.key=key;
-						pair.value=value;
+						pair.key = key;
+						pair.value = value;
 						dict->elements.push_back(pair);
-						key=NULL;
-
+						key = NULL;
 					}
-
 				}
 			}
 
-			expr=dict;
+			expr = dict;
 
-		} else if (tokenizer->get_token()==GDTokenizer::TK_PERIOD && (tokenizer->get_token(1)==GDTokenizer::TK_IDENTIFIER || tokenizer->get_token(1)==GDTokenizer::TK_CURSOR) && tokenizer->get_token(2)==GDTokenizer::TK_PARENTHESIS_OPEN) {
+		} else if (tokenizer->get_token() == GDTokenizer::TK_PERIOD && (tokenizer->get_token(1) == GDTokenizer::TK_IDENTIFIER || tokenizer->get_token(1) == GDTokenizer::TK_CURSOR) && tokenizer->get_token(2) == GDTokenizer::TK_PARENTHESIS_OPEN) {
 			// parent call
 
 			tokenizer->advance(); //goto identifier
 			OperatorNode *op = alloc_node<OperatorNode>();
-			op->op=OperatorNode::OP_PARENT_CALL;
-
+			op->op = OperatorNode::OP_PARENT_CALL;
 
 			/*SelfNode *self = alloc_node<SelfNode>();
 			op->arguments.push_back(self);
 			forbidden for now */
 			StringName identifier;
-			if (_get_completable_identifier(COMPLETION_PARENT_FUNCTION,identifier)) {
+			if (_get_completable_identifier(COMPLETION_PARENT_FUNCTION, identifier)) {
 				//indexing stuff
 			}
 
 			IdentifierNode *id = alloc_node<IdentifierNode>();
-			id->name=identifier;
+			id->name = identifier;
 			op->arguments.push_back(id);
 
 			tokenizer->advance(1);
-			if (!_parse_arguments(op,op->arguments,p_static))
+			if (!_parse_arguments(op, op->arguments, p_static))
 				return NULL;
 
-			expr=op;
+			expr = op;
 
 		} else {
 
@@ -912,113 +887,106 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 
 			//print_line("found bug?");
 
-			_set_error("Error parsing expression, misplaced: "+String(tokenizer->get_token_name(tokenizer->get_token())));
-			return NULL;		//nothing
+			_set_error("Error parsing expression, misplaced: " + String(tokenizer->get_token_name(tokenizer->get_token())));
+			return NULL; //nothing
 		}
 
 		if (!expr) {
 			ERR_EXPLAIN("GDParser bug, couldn't figure out what expression is..");
-			ERR_FAIL_COND_V(!expr,NULL);
+			ERR_FAIL_COND_V(!expr, NULL);
 		}
 
-
 		/******************/
 		/* Parse Indexing */
 		/******************/
 
-
 		while (true) {
 
 			//expressions can be indexed any number of times
 
-			if (tokenizer->get_token()==GDTokenizer::TK_PERIOD) {
+			if (tokenizer->get_token() == GDTokenizer::TK_PERIOD) {
 
 				//indexing using "."
 
-				if (tokenizer->get_token(1)!=GDTokenizer::TK_CURSOR && tokenizer->get_token(1)!=GDTokenizer::TK_IDENTIFIER && tokenizer->get_token(1)!=GDTokenizer::TK_BUILT_IN_FUNC ) {
+				if (tokenizer->get_token(1) != GDTokenizer::TK_CURSOR && tokenizer->get_token(1) != GDTokenizer::TK_IDENTIFIER && tokenizer->get_token(1) != GDTokenizer::TK_BUILT_IN_FUNC) {
 					_set_error("Expected identifier as member");
 					return NULL;
-				} else if (tokenizer->get_token(2)==GDTokenizer::TK_PARENTHESIS_OPEN) {
+				} else if (tokenizer->get_token(2) == GDTokenizer::TK_PARENTHESIS_OPEN) {
 					//call!!
-					OperatorNode * op = alloc_node<OperatorNode>();
-					op->op=OperatorNode::OP_CALL;
+					OperatorNode *op = alloc_node<OperatorNode>();
+					op->op = OperatorNode::OP_CALL;
 
 					tokenizer->advance();
 
-					IdentifierNode * id = alloc_node<IdentifierNode>();
-					if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_FUNC ) {
+					IdentifierNode *id = alloc_node<IdentifierNode>();
+					if (tokenizer->get_token() == GDTokenizer::TK_BUILT_IN_FUNC) {
 						//small hack so built in funcs don't obfuscate methods
 
-						id->name=GDFunctions::get_func_name(tokenizer->get_token_built_in_func());
+						id->name = GDFunctions::get_func_name(tokenizer->get_token_built_in_func());
 						tokenizer->advance();
 
 					} else {
 						StringName identifier;
-						if (_get_completable_identifier(COMPLETION_METHOD,identifier)) {
-							completion_node=op;
+						if (_get_completable_identifier(COMPLETION_METHOD, identifier)) {
+							completion_node = op;
 							//indexing stuff
 						}
 
-						id->name=identifier;
+						id->name = identifier;
 					}
 
 					op->arguments.push_back(expr); // call what
 					op->arguments.push_back(id); // call func
 					//get arguments
 					tokenizer->advance(1);
-					if (tokenizer->get_token()==GDTokenizer::TK_CURSOR) {
+					if (tokenizer->get_token() == GDTokenizer::TK_CURSOR) {
 						_make_completable_call(0);
-						completion_node=op;
-
+						completion_node = op;
 					}
-					if (!_parse_arguments(op,op->arguments,p_static,true))
+					if (!_parse_arguments(op, op->arguments, p_static, true))
 						return NULL;
-					expr=op;
+					expr = op;
 
 				} else {
 					//simple indexing!
 
-
-					OperatorNode * op = alloc_node<OperatorNode>();
-					op->op=OperatorNode::OP_INDEX_NAMED;
+					OperatorNode *op = alloc_node<OperatorNode>();
+					op->op = OperatorNode::OP_INDEX_NAMED;
 					tokenizer->advance();
 
-
 					StringName identifier;
-					if (_get_completable_identifier(COMPLETION_INDEX,identifier)) {
+					if (_get_completable_identifier(COMPLETION_INDEX, identifier)) {
 
-						if (identifier==StringName()) {
-							identifier="@temp"; //so it parses allright
+						if (identifier == StringName()) {
+							identifier = "@temp"; //so it parses allright
 						}
-						completion_node=op;
+						completion_node = op;
 
 						//indexing stuff
 					}
 
-					IdentifierNode * id = alloc_node<IdentifierNode>();
-					id->name=identifier;
+					IdentifierNode *id = alloc_node<IdentifierNode>();
+					id->name = identifier;
 
 					op->arguments.push_back(expr);
 					op->arguments.push_back(id);
 
-					expr=op;
-
-
+					expr = op;
 				}
 
-			} else if (tokenizer->get_token()==GDTokenizer::TK_BRACKET_OPEN) {
+			} else if (tokenizer->get_token() == GDTokenizer::TK_BRACKET_OPEN) {
 				//indexing using "[]"
-				OperatorNode * op = alloc_node<OperatorNode>();
-				op->op=OperatorNode::OP_INDEX;
+				OperatorNode *op = alloc_node<OperatorNode>();
+				op->op = OperatorNode::OP_INDEX;
 
 				tokenizer->advance(1);
 
-				Node *subexpr = _parse_expression(op,p_static,p_allow_assign,p_parsing_constant);
+				Node *subexpr = _parse_expression(op, p_static, p_allow_assign, p_parsing_constant);
 				if (!subexpr) {
 					return NULL;
 				}
 
-				if (tokenizer->get_token()!=GDTokenizer::TK_BRACKET_CLOSE) {
+				if (tokenizer->get_token() != GDTokenizer::TK_BRACKET_CLOSE) {
 					_set_error("Expected ']'");
 					return NULL;
 				}
@@ -1026,7 +994,7 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 				op->arguments.push_back(expr);
 				op->arguments.push_back(subexpr);
 				tokenizer->advance(1);
-				expr=op;
+				expr = op;
 
 			} else
 				break;
@@ -1036,88 +1004,91 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 		/* Parse Operator */
 		/******************/
 
-		if (parenthesis>0) {
+		if (parenthesis > 0) {
 			//remove empty space (only allowed if inside parenthesis
-			while(tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+			while (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 				tokenizer->advance();
 			}
 		}
 
 		Expression e;
-		e.is_op=false;
-		e.node=expr;
+		e.is_op = false;
+		e.node = expr;
 		expression.push_back(e);
 
 		// determine which operator is next
 
 		OperatorNode::Operator op;
-		bool valid=true;
+		bool valid = true;
 
 //assign, if allowed is only alowed on the first operator
-#define _VALIDATE_ASSIGN if (!p_allow_assign) { _set_error("Unexpected assign."); return NULL; } p_allow_assign=false;
-		switch(tokenizer->get_token()) { //see operator
-
-			case GDTokenizer::TK_OP_IN: op=OperatorNode::OP_IN; break;
-			case GDTokenizer::TK_OP_EQUAL: op=OperatorNode::OP_EQUAL ; break;
-			case GDTokenizer::TK_OP_NOT_EQUAL: op=OperatorNode::OP_NOT_EQUAL ; break;
-			case GDTokenizer::TK_OP_LESS: op=OperatorNode::OP_LESS ; break;
-			case GDTokenizer::TK_OP_LESS_EQUAL: op=OperatorNode::OP_LESS_EQUAL ; break;
-			case GDTokenizer::TK_OP_GREATER: op=OperatorNode::OP_GREATER ; break;
-			case GDTokenizer::TK_OP_GREATER_EQUAL: op=OperatorNode::OP_GREATER_EQUAL ; break;
-			case GDTokenizer::TK_OP_AND: op=OperatorNode::OP_AND ; break;
-			case GDTokenizer::TK_OP_OR: op=OperatorNode::OP_OR ; break;
-			case GDTokenizer::TK_OP_ADD: op=OperatorNode::OP_ADD ; break;
-			case GDTokenizer::TK_OP_SUB: op=OperatorNode::OP_SUB ; break;
-			case GDTokenizer::TK_OP_MUL: op=OperatorNode::OP_MUL ; break;
-			case GDTokenizer::TK_OP_DIV: op=OperatorNode::OP_DIV ; break;
-			case GDTokenizer::TK_OP_MOD: op=OperatorNode::OP_MOD ; break;
+#define _VALIDATE_ASSIGN                  \
+	if (!p_allow_assign) {                \
+		_set_error("Unexpected assign."); \
+		return NULL;                      \
+	}                                     \
+	p_allow_assign = false;
+		switch (tokenizer->get_token()) { //see operator
+
+			case GDTokenizer::TK_OP_IN: op = OperatorNode::OP_IN; break;
+			case GDTokenizer::TK_OP_EQUAL: op = OperatorNode::OP_EQUAL; break;
+			case GDTokenizer::TK_OP_NOT_EQUAL: op = OperatorNode::OP_NOT_EQUAL; break;
+			case GDTokenizer::TK_OP_LESS: op = OperatorNode::OP_LESS; break;
+			case GDTokenizer::TK_OP_LESS_EQUAL: op = OperatorNode::OP_LESS_EQUAL; break;
+			case GDTokenizer::TK_OP_GREATER: op = OperatorNode::OP_GREATER; break;
+			case GDTokenizer::TK_OP_GREATER_EQUAL: op = OperatorNode::OP_GREATER_EQUAL; break;
+			case GDTokenizer::TK_OP_AND: op = OperatorNode::OP_AND; break;
+			case GDTokenizer::TK_OP_OR: op = OperatorNode::OP_OR; break;
+			case GDTokenizer::TK_OP_ADD: op = OperatorNode::OP_ADD; break;
+			case GDTokenizer::TK_OP_SUB: op = OperatorNode::OP_SUB; break;
+			case GDTokenizer::TK_OP_MUL: op = OperatorNode::OP_MUL; break;
+			case GDTokenizer::TK_OP_DIV: op = OperatorNode::OP_DIV; break;
+			case GDTokenizer::TK_OP_MOD:
+				op = OperatorNode::OP_MOD;
+				break;
 			//case GDTokenizer::TK_OP_NEG: op=OperatorNode::OP_NEG ; break;
-			case GDTokenizer::TK_OP_SHIFT_LEFT: op=OperatorNode::OP_SHIFT_LEFT ; break;
-			case GDTokenizer::TK_OP_SHIFT_RIGHT: op=OperatorNode::OP_SHIFT_RIGHT ; break;
-			case GDTokenizer::TK_OP_ASSIGN: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN ; break;
-			case GDTokenizer::TK_OP_ASSIGN_ADD: _VALIDATE_ASSIGN  op=OperatorNode::OP_ASSIGN_ADD ; break;
-			case GDTokenizer::TK_OP_ASSIGN_SUB: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN_SUB ; break;
-			case GDTokenizer::TK_OP_ASSIGN_MUL: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN_MUL ; break;
-			case GDTokenizer::TK_OP_ASSIGN_DIV: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN_DIV ; break;
-			case GDTokenizer::TK_OP_ASSIGN_MOD: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN_MOD ; break;
-			case GDTokenizer::TK_OP_ASSIGN_SHIFT_LEFT: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN_SHIFT_LEFT; break;
-			case GDTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN_SHIFT_RIGHT; break;
-			case GDTokenizer::TK_OP_ASSIGN_BIT_AND: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN_BIT_AND ; break;
-			case GDTokenizer::TK_OP_ASSIGN_BIT_OR: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN_BIT_OR ; break;
-			case GDTokenizer::TK_OP_ASSIGN_BIT_XOR: _VALIDATE_ASSIGN op=OperatorNode::OP_ASSIGN_BIT_XOR ; break;
-			case GDTokenizer::TK_OP_BIT_AND: op=OperatorNode::OP_BIT_AND ; break;
-			case GDTokenizer::TK_OP_BIT_OR: op=OperatorNode::OP_BIT_OR ; break;
-			case GDTokenizer::TK_OP_BIT_XOR: op=OperatorNode::OP_BIT_XOR ; break;
-			case GDTokenizer::TK_PR_EXTENDS: op=OperatorNode::OP_EXTENDS; break;
-			case GDTokenizer::TK_CF_IF: op=OperatorNode::OP_TERNARY_IF; break;
-			case GDTokenizer::TK_CF_ELSE: op=OperatorNode::OP_TERNARY_ELSE; break;
-			default: valid=false; break;
+			case GDTokenizer::TK_OP_SHIFT_LEFT: op = OperatorNode::OP_SHIFT_LEFT; break;
+			case GDTokenizer::TK_OP_SHIFT_RIGHT: op = OperatorNode::OP_SHIFT_RIGHT; break;
+			case GDTokenizer::TK_OP_ASSIGN: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN; break;
+			case GDTokenizer::TK_OP_ASSIGN_ADD: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_ADD; break;
+			case GDTokenizer::TK_OP_ASSIGN_SUB: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SUB; break;
+			case GDTokenizer::TK_OP_ASSIGN_MUL: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_MUL; break;
+			case GDTokenizer::TK_OP_ASSIGN_DIV: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_DIV; break;
+			case GDTokenizer::TK_OP_ASSIGN_MOD: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_MOD; break;
+			case GDTokenizer::TK_OP_ASSIGN_SHIFT_LEFT: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SHIFT_LEFT; break;
+			case GDTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SHIFT_RIGHT; break;
+			case GDTokenizer::TK_OP_ASSIGN_BIT_AND: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_AND; break;
+			case GDTokenizer::TK_OP_ASSIGN_BIT_OR: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_OR; break;
+			case GDTokenizer::TK_OP_ASSIGN_BIT_XOR: _VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_XOR; break;
+			case GDTokenizer::TK_OP_BIT_AND: op = OperatorNode::OP_BIT_AND; break;
+			case GDTokenizer::TK_OP_BIT_OR: op = OperatorNode::OP_BIT_OR; break;
+			case GDTokenizer::TK_OP_BIT_XOR: op = OperatorNode::OP_BIT_XOR; break;
+			case GDTokenizer::TK_PR_EXTENDS: op = OperatorNode::OP_EXTENDS; break;
+			case GDTokenizer::TK_CF_IF: op = OperatorNode::OP_TERNARY_IF; break;
+			case GDTokenizer::TK_CF_ELSE: op = OperatorNode::OP_TERNARY_ELSE; break;
+			default: valid = false; break;
 		}
 
 		if (valid) {
-			e.is_op=true;
-			e.op=op;
+			e.is_op = true;
+			e.op = op;
 			expression.push_back(e);
 			tokenizer->advance();
 		} else {
 			break;
 		}
-
 	}
 
 	/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
 
+	while (expression.size() > 1) {
 
-	while(expression.size()>1) {
-
-		int next_op=-1;
-		int min_priority=0xFFFFF;
-		bool is_unary=false;
-		bool is_ternary=false;
-
-		for(int i=0;i<expression.size();i++) {
-
+		int next_op = -1;
+		int min_priority = 0xFFFFF;
+		bool is_unary = false;
+		bool is_ternary = false;
 
+		for (int i = 0; i < expression.size(); i++) {
 
 			if (!expression[i].is_op) {
 
@@ -1126,102 +1097,115 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 
 			int priority;
 
-			bool unary=false;
-			bool ternary=false;
-			bool error=false;
+			bool unary = false;
+			bool ternary = false;
+			bool error = false;
 
-			switch(expression[i].op) {
+			switch (expression[i].op) {
 
-				case OperatorNode::OP_EXTENDS: priority=-1; break; //before anything
+				case OperatorNode::OP_EXTENDS:
+					priority = -1;
+					break; //before anything
 
-				case OperatorNode::OP_BIT_INVERT: priority=0; unary=true; break;
-				case OperatorNode::OP_NEG: priority=1; unary=true; break;
-				case OperatorNode::OP_POS: priority=1; unary=true; break;
+				case OperatorNode::OP_BIT_INVERT:
+					priority = 0;
+					unary = true;
+					break;
+				case OperatorNode::OP_NEG:
+					priority = 1;
+					unary = true;
+					break;
+				case OperatorNode::OP_POS:
+					priority = 1;
+					unary = true;
+					break;
 
-				case OperatorNode::OP_MUL: priority=2; break;
-				case OperatorNode::OP_DIV: priority=2; break;
-				case OperatorNode::OP_MOD: priority=2; break;
+				case OperatorNode::OP_MUL: priority = 2; break;
+				case OperatorNode::OP_DIV: priority = 2; break;
+				case OperatorNode::OP_MOD: priority = 2; break;
 
-				case OperatorNode::OP_ADD: priority=3; break;
-				case OperatorNode::OP_SUB: priority=3; break;
+				case OperatorNode::OP_ADD: priority = 3; break;
+				case OperatorNode::OP_SUB: priority = 3; break;
 
-				case OperatorNode::OP_SHIFT_LEFT: priority=4; break;
-				case OperatorNode::OP_SHIFT_RIGHT: priority=4; break;
+				case OperatorNode::OP_SHIFT_LEFT: priority = 4; break;
+				case OperatorNode::OP_SHIFT_RIGHT: priority = 4; break;
 
-				case OperatorNode::OP_BIT_AND: priority=5; break;
-				case OperatorNode::OP_BIT_XOR: priority=6; break;
-				case OperatorNode::OP_BIT_OR: priority=7; break;
+				case OperatorNode::OP_BIT_AND: priority = 5; break;
+				case OperatorNode::OP_BIT_XOR: priority = 6; break;
+				case OperatorNode::OP_BIT_OR: priority = 7; break;
 
-				case OperatorNode::OP_LESS: priority=8; break;
-				case OperatorNode::OP_LESS_EQUAL: priority=8; break;
-				case OperatorNode::OP_GREATER: priority=8; break;
-				case OperatorNode::OP_GREATER_EQUAL: priority=8; break;
+				case OperatorNode::OP_LESS: priority = 8; break;
+				case OperatorNode::OP_LESS_EQUAL: priority = 8; break;
+				case OperatorNode::OP_GREATER: priority = 8; break;
+				case OperatorNode::OP_GREATER_EQUAL: priority = 8; break;
 
-				case OperatorNode::OP_EQUAL: priority=8; break;
-				case OperatorNode::OP_NOT_EQUAL: priority=8; break;
+				case OperatorNode::OP_EQUAL: priority = 8; break;
+				case OperatorNode::OP_NOT_EQUAL: priority = 8; break;
 
-				
-				case OperatorNode::OP_IN: priority=10; break;
-				
-				case OperatorNode::OP_NOT: priority=11; unary=true; break;
-				case OperatorNode::OP_AND: priority=12; break;
-				case OperatorNode::OP_OR: priority=13; break;
-				
-				case OperatorNode::OP_TERNARY_IF: priority=14; ternary=true; break;
-				case OperatorNode::OP_TERNARY_ELSE: priority=14; error=true; break; // Errors out when found without IF (since IF would consume it)
+				case OperatorNode::OP_IN: priority = 10; break;
 
-				case OperatorNode::OP_ASSIGN: priority=15; break;
-				case OperatorNode::OP_ASSIGN_ADD: priority=15; break;
-				case OperatorNode::OP_ASSIGN_SUB: priority=15; break;
-				case OperatorNode::OP_ASSIGN_MUL: priority=15; break;
-				case OperatorNode::OP_ASSIGN_DIV: priority=15; break;
-				case OperatorNode::OP_ASSIGN_MOD: priority=15; break;
-				case OperatorNode::OP_ASSIGN_SHIFT_LEFT: priority=15; break;
-				case OperatorNode::OP_ASSIGN_SHIFT_RIGHT: priority=15; break;
-				case OperatorNode::OP_ASSIGN_BIT_AND: priority=15; break;
-				case OperatorNode::OP_ASSIGN_BIT_OR: priority=15; break;
-				case OperatorNode::OP_ASSIGN_BIT_XOR: priority=15; break;
+				case OperatorNode::OP_NOT:
+					priority = 11;
+					unary = true;
+					break;
+				case OperatorNode::OP_AND: priority = 12; break;
+				case OperatorNode::OP_OR: priority = 13; break;
 
+				case OperatorNode::OP_TERNARY_IF:
+					priority = 14;
+					ternary = true;
+					break;
+				case OperatorNode::OP_TERNARY_ELSE:
+					priority = 14;
+					error = true;
+					break; // Errors out when found without IF (since IF would consume it)
+
+				case OperatorNode::OP_ASSIGN: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_ADD: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_SUB: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_MUL: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_DIV: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_MOD: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_SHIFT_LEFT: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_SHIFT_RIGHT: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_BIT_AND: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_BIT_OR: priority = 15; break;
+				case OperatorNode::OP_ASSIGN_BIT_XOR: priority = 15; break;
 
 				default: {
-					_set_error("GDParser bug, invalid operator in expression: "+itos(expression[i].op));
+					_set_error("GDParser bug, invalid operator in expression: " + itos(expression[i].op));
 					return NULL;
 				}
-
 			}
 
-			if (priority<min_priority) {
-				if(error) {
+			if (priority < min_priority) {
+				if (error) {
 					_set_error("Unexpected operator");
 					return NULL;
 				}
 				// < is used for left to right (default)
 				// <= is used for right to left
-				next_op=i;
-				min_priority=priority;
-				is_unary=unary;
-				is_ternary=ternary;
+				next_op = i;
+				min_priority = priority;
+				is_unary = unary;
+				is_ternary = ternary;
 			}
-
 		}
 
-
-		if (next_op==-1) {
-
+		if (next_op == -1) {
 
 			_set_error("Yet another parser bug....");
-			ERR_FAIL_COND_V(next_op==-1,NULL);
+			ERR_FAIL_COND_V(next_op == -1, NULL);
 		}
 
-
 		// OK! create operator..
 		if (is_unary) {
 
-			int expr_pos=next_op;
-			while(expression[expr_pos].is_op) {
+			int expr_pos = next_op;
+			while (expression[expr_pos].is_op) {
 
 				expr_pos++;
-				if (expr_pos==expression.size()) {
+				if (expr_pos == expression.size()) {
 					//can happen..
 					_set_error("Unexpected end of expression..");
 					return NULL;
@@ -1229,44 +1213,43 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 			}
 
 			//consecutively do unary opeators
-			for(int i=expr_pos-1;i>=next_op;i--) {
+			for (int i = expr_pos - 1; i >= next_op; i--) {
 
 				OperatorNode *op = alloc_node<OperatorNode>();
-				op->op=expression[i].op;
-				op->arguments.push_back(expression[i+1].node);
-				op->line=op_line; //line might have been changed from a \n
-				expression[i].is_op=false;
-				expression[i].node=op;
-				expression.remove(i+1);
+				op->op = expression[i].op;
+				op->arguments.push_back(expression[i + 1].node);
+				op->line = op_line; //line might have been changed from a \n
+				expression[i].is_op = false;
+				expression[i].node = op;
+				expression.remove(i + 1);
 			}
 
-
-		} else if(is_ternary) {
-			if (next_op <1 || next_op>=(expression.size()-1)) {
+		} else if (is_ternary) {
+			if (next_op < 1 || next_op >= (expression.size() - 1)) {
 				_set_error("Parser bug..");
 				ERR_FAIL_V(NULL);
 			}
-			
-			if(next_op>=(expression.size()-2) || expression[next_op+2].op != OperatorNode::OP_TERNARY_ELSE) {
+
+			if (next_op >= (expression.size() - 2) || expression[next_op + 2].op != OperatorNode::OP_TERNARY_ELSE) {
 				_set_error("Expected else after ternary if.");
 				ERR_FAIL_V(NULL);
 			}
-			if(next_op>=(expression.size()-3)) {
+			if (next_op >= (expression.size() - 3)) {
 				_set_error("Expected value after ternary else.");
 				ERR_FAIL_V(NULL);
 			}
 
 			OperatorNode *op = alloc_node<OperatorNode>();
-			op->op=expression[next_op].op;
-			op->line=op_line; //line might have been changed from a \n
+			op->op = expression[next_op].op;
+			op->line = op_line; //line might have been changed from a \n
 
-			if (expression[next_op-1].is_op) {
+			if (expression[next_op - 1].is_op) {
 
 				_set_error("Parser bug..");
 				ERR_FAIL_V(NULL);
 			}
 
-			if (expression[next_op+1].is_op) {
+			if (expression[next_op + 1].is_op) {
 				// this is not invalid and can really appear
 				// but it becomes invalid anyway because no binary op
 				// can be followed by an unary op in a valid combination,
@@ -1276,7 +1259,7 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 				return NULL;
 			}
 
-			if (expression[next_op+3].is_op) {
+			if (expression[next_op + 3].is_op) {
 				// this is not invalid and can really appear
 				// but it becomes invalid anyway because no binary op
 				// can be followed by an unary op in a valid combination,
@@ -1286,35 +1269,34 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 				return NULL;
 			}
 
-
-			op->arguments.push_back(expression[next_op+1].node); //next expression goes as first
-			op->arguments.push_back(expression[next_op-1].node); //left expression goes as when-true
-			op->arguments.push_back(expression[next_op+3].node); //expression after next goes as when-false
+			op->arguments.push_back(expression[next_op + 1].node); //next expression goes as first
+			op->arguments.push_back(expression[next_op - 1].node); //left expression goes as when-true
+			op->arguments.push_back(expression[next_op + 3].node); //expression after next goes as when-false
 
 			//replace all 3 nodes by this operator and make it an expression
-			expression[next_op-1].node=op;
+			expression[next_op - 1].node = op;
 			expression.remove(next_op);
 			expression.remove(next_op);
 			expression.remove(next_op);
 			expression.remove(next_op);
 		} else {
 
-			if (next_op <1 || next_op>=(expression.size()-1)) {
+			if (next_op < 1 || next_op >= (expression.size() - 1)) {
 				_set_error("Parser bug..");
 				ERR_FAIL_V(NULL);
 			}
 
 			OperatorNode *op = alloc_node<OperatorNode>();
-			op->op=expression[next_op].op;
-			op->line=op_line; //line might have been changed from a \n
+			op->op = expression[next_op].op;
+			op->line = op_line; //line might have been changed from a \n
 
-			if (expression[next_op-1].is_op) {
+			if (expression[next_op - 1].is_op) {
 
 				_set_error("Parser bug..");
 				ERR_FAIL_V(NULL);
 			}
 
-			if (expression[next_op+1].is_op) {
+			if (expression[next_op + 1].is_op) {
 				// this is not invalid and can really appear
 				// but it becomes invalid anyway because no binary op
 				// can be followed by an unary op in a valid combination,
@@ -1324,26 +1306,22 @@ GDParser::Node* GDParser::_parse_expression(Node *p_parent,bool p_static,bool p_
 				return NULL;
 			}
 
-
-			op->arguments.push_back(expression[next_op-1].node); //expression goes as left
-			op->arguments.push_back(expression[next_op+1].node); //next expression goes as right
+			op->arguments.push_back(expression[next_op - 1].node); //expression goes as left
+			op->arguments.push_back(expression[next_op + 1].node); //next expression goes as right
 
 			//replace all 3 nodes by this operator and make it an expression
-			expression[next_op-1].node=op;
+			expression[next_op - 1].node = op;
 			expression.remove(next_op);
 			expression.remove(next_op);
 		}
-
 	}
 
 	return expression[0].node;
-
 }
 
+GDParser::Node *GDParser::_reduce_expression(Node *p_node, bool p_to_const) {
 
-GDParser::Node* GDParser::_reduce_expression(Node *p_node,bool p_to_const) {
-
-	switch(p_node->type) {
+	switch (p_node->type) {
 
 		case Node::TYPE_BUILT_IN_FUNCTION: {
 			//many may probably be optimizable
@@ -1351,14 +1329,14 @@ GDParser::Node* GDParser::_reduce_expression(Node *p_node,bool p_to_const) {
 		} break;
 		case Node::TYPE_ARRAY: {
 
-			ArrayNode *an = static_cast<ArrayNode*>(p_node);
-			bool all_constants=true;
+			ArrayNode *an = static_cast<ArrayNode *>(p_node);
+			bool all_constants = true;
 
-			for(int i=0;i<an->elements.size();i++) {
+			for (int i = 0; i < an->elements.size(); i++) {
 
-				an->elements[i]=_reduce_expression(an->elements[i],p_to_const);
-				if (an->elements[i]->type!=Node::TYPE_CONSTANT)
-					all_constants=false;
+				an->elements[i] = _reduce_expression(an->elements[i], p_to_const);
+				if (an->elements[i]->type != Node::TYPE_CONSTANT)
+					all_constants = false;
 			}
 
 			if (all_constants && p_to_const) {
@@ -1368,12 +1346,11 @@ GDParser::Node* GDParser::_reduce_expression(Node *p_node,bool p_to_const) {
 				Array arr;
 				//print_line("mk array "+itos(!p_to_const));
 				arr.resize(an->elements.size());
-				for(int i=0;i<an->elements.size();i++) {
-					ConstantNode *acn = static_cast<ConstantNode*>(an->elements[i]);
-					arr[i]=acn->value;
-
+				for (int i = 0; i < an->elements.size(); i++) {
+					ConstantNode *acn = static_cast<ConstantNode *>(an->elements[i]);
+					arr[i] = acn->value;
 				}
-				cn->value=arr;
+				cn->value = arr;
 				return cn;
 			}
 
@@ -1382,18 +1359,17 @@ GDParser::Node* GDParser::_reduce_expression(Node *p_node,bool p_to_const) {
 		} break;
 		case Node::TYPE_DICTIONARY: {
 
-			DictionaryNode *dn = static_cast<DictionaryNode*>(p_node);
-			bool all_constants=true;
-
-			for(int i=0;i<dn->elements.size();i++) {
+			DictionaryNode *dn = static_cast<DictionaryNode *>(p_node);
+			bool all_constants = true;
 
-				dn->elements[i].key=_reduce_expression(dn->elements[i].key,p_to_const);
-				if (dn->elements[i].key->type!=Node::TYPE_CONSTANT)
-					all_constants=false;
-				dn->elements[i].value=_reduce_expression(dn->elements[i].value,p_to_const);
-				if (dn->elements[i].value->type!=Node::TYPE_CONSTANT)
-					all_constants=false;
+			for (int i = 0; i < dn->elements.size(); i++) {
 
+				dn->elements[i].key = _reduce_expression(dn->elements[i].key, p_to_const);
+				if (dn->elements[i].key->type != Node::TYPE_CONSTANT)
+					all_constants = false;
+				dn->elements[i].value = _reduce_expression(dn->elements[i].value, p_to_const);
+				if (dn->elements[i].value->type != Node::TYPE_CONSTANT)
+					all_constants = false;
 			}
 
 			if (all_constants && p_to_const) {
@@ -1401,157 +1377,143 @@ GDParser::Node* GDParser::_reduce_expression(Node *p_node,bool p_to_const) {
 
 				ConstantNode *cn = alloc_node<ConstantNode>();
 				Dictionary dict;
-				for(int i=0;i<dn->elements.size();i++) {
-					ConstantNode *key_c = static_cast<ConstantNode*>(dn->elements[i].key);
-					ConstantNode *value_c = static_cast<ConstantNode*>(dn->elements[i].value);
-
-					dict[key_c->value]=value_c->value;
+				for (int i = 0; i < dn->elements.size(); i++) {
+					ConstantNode *key_c = static_cast<ConstantNode *>(dn->elements[i].key);
+					ConstantNode *value_c = static_cast<ConstantNode *>(dn->elements[i].value);
 
+					dict[key_c->value] = value_c->value;
 				}
-				cn->value=dict;
+				cn->value = dict;
 				return cn;
 			}
 
 			return dn;
 
-
 		} break;
 		case Node::TYPE_OPERATOR: {
 
-			OperatorNode *op=static_cast<OperatorNode*>(p_node);
+			OperatorNode *op = static_cast<OperatorNode *>(p_node);
 
-			bool all_constants=true;
-			int last_not_constant=-1;
+			bool all_constants = true;
+			int last_not_constant = -1;
 
-			for(int i=0;i<op->arguments.size();i++) {
+			for (int i = 0; i < op->arguments.size(); i++) {
 
-				op->arguments[i]=_reduce_expression(op->arguments[i],p_to_const);
-				if (op->arguments[i]->type!=Node::TYPE_CONSTANT) {
-					all_constants=false;
-					last_not_constant=i;
+				op->arguments[i] = _reduce_expression(op->arguments[i], p_to_const);
+				if (op->arguments[i]->type != Node::TYPE_CONSTANT) {
+					all_constants = false;
+					last_not_constant = i;
 				}
 			}
 
-			if (op->op==OperatorNode::OP_EXTENDS) {
+			if (op->op == OperatorNode::OP_EXTENDS) {
 				//nothing much
 				return op;
-
-			} if (op->op==OperatorNode::OP_PARENT_CALL) {
+			}
+			if (op->op == OperatorNode::OP_PARENT_CALL) {
 				//nothing much
 				return op;
 
-			} else if (op->op==OperatorNode::OP_CALL) {
+			} else if (op->op == OperatorNode::OP_CALL) {
 				//can reduce base type constructors
-				if ((op->arguments[0]->type==Node::TYPE_TYPE || (op->arguments[0]->type==Node::TYPE_BUILT_IN_FUNCTION && GDFunctions::is_deterministic( static_cast<BuiltInFunctionNode*>(op->arguments[0])->function))) && last_not_constant==0) {
+				if ((op->arguments[0]->type == Node::TYPE_TYPE || (op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && GDFunctions::is_deterministic(static_cast<BuiltInFunctionNode *>(op->arguments[0])->function))) && last_not_constant == 0) {
 
 					//native type constructor or intrinsic function
-					const Variant **vptr=NULL;
-					Vector<Variant*> ptrs;
-					if (op->arguments.size()>1) {
-
-						ptrs.resize(op->arguments.size()-1);
-						for(int i=0;i<ptrs.size();i++) {
+					const Variant **vptr = NULL;
+					Vector<Variant *> ptrs;
+					if (op->arguments.size() > 1) {
 
+						ptrs.resize(op->arguments.size() - 1);
+						for (int i = 0; i < ptrs.size(); i++) {
 
-							ConstantNode *cn = static_cast<ConstantNode*>(op->arguments[i+1]);
-							ptrs[i]=&cn->value;
+							ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[i + 1]);
+							ptrs[i] = &cn->value;
 						}
 
-						vptr=(const Variant**)&ptrs[0];
-
-
+						vptr = (const Variant **)&ptrs[0];
 					}
 
 					Variant::CallError ce;
 					Variant v;
 
-					if (op->arguments[0]->type==Node::TYPE_TYPE) {
-						TypeNode *tn = static_cast<TypeNode*>(op->arguments[0]);
-						v = Variant::construct(tn->vtype,vptr,ptrs.size(),ce);
+					if (op->arguments[0]->type == Node::TYPE_TYPE) {
+						TypeNode *tn = static_cast<TypeNode *>(op->arguments[0]);
+						v = Variant::construct(tn->vtype, vptr, ptrs.size(), ce);
 
 					} else {
-						GDFunctions::Function func = static_cast<BuiltInFunctionNode*>(op->arguments[0])->function;
-						GDFunctions::call(func,vptr,ptrs.size(),v,ce);
+						GDFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
+						GDFunctions::call(func, vptr, ptrs.size(), v, ce);
 					}
 
-
-					if (ce.error!=Variant::CallError::CALL_OK) {
+					if (ce.error != Variant::CallError::CALL_OK) {
 
 						String errwhere;
-						if (op->arguments[0]->type==Node::TYPE_TYPE) {
-							TypeNode *tn = static_cast<TypeNode*>(op->arguments[0]);
-							errwhere="'"+Variant::get_type_name(tn->vtype)+"'' constructor";
+						if (op->arguments[0]->type == Node::TYPE_TYPE) {
+							TypeNode *tn = static_cast<TypeNode *>(op->arguments[0]);
+							errwhere = "'" + Variant::get_type_name(tn->vtype) + "'' constructor";
 
 						} else {
-							GDFunctions::Function func = static_cast<BuiltInFunctionNode*>(op->arguments[0])->function;
-							errwhere=String("'")+GDFunctions::get_func_name(func)+"'' intrinsic function";
-
+							GDFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
+							errwhere = String("'") + GDFunctions::get_func_name(func) + "'' intrinsic function";
 						}
 
-						switch(ce.error) {
+						switch (ce.error) {
 
 							case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT: {
 
-								_set_error("Invalid argument (#"+itos(ce.argument+1)+") for "+errwhere+".");
+								_set_error("Invalid argument (#" + itos(ce.argument + 1) + ") for " + errwhere + ".");
 
 							} break;
 							case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS: {
 
-								_set_error("Too many arguments for "+errwhere+".");
+								_set_error("Too many arguments for " + errwhere + ".");
 							} break;
 							case Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS: {
 
-								_set_error("Too few arguments for "+errwhere+".");
+								_set_error("Too few arguments for " + errwhere + ".");
 							} break;
 							default: {
-								_set_error("Invalid arguments for "+errwhere+".");
+								_set_error("Invalid arguments for " + errwhere + ".");
 
 							} break;
 						}
 
-						error_line=op->line;
+						error_line = op->line;
 
 						return p_node;
 					}
 
 					ConstantNode *cn = alloc_node<ConstantNode>();
-					cn->value=v;
+					cn->value = v;
 					return cn;
 
-				} else if (op->arguments[0]->type==Node::TYPE_BUILT_IN_FUNCTION && last_not_constant==0) {
-
-
-
-
-
+				} else if (op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && last_not_constant == 0) {
 				}
 
 				return op; //don't reduce yet
 
-			} else if (op->op==OperatorNode::OP_YIELD) {
+			} else if (op->op == OperatorNode::OP_YIELD) {
 				return op;
 
-			} else if (op->op==OperatorNode::OP_INDEX) {
+			} else if (op->op == OperatorNode::OP_INDEX) {
 				//can reduce indices into constant arrays or dictionaries
 
 				if (all_constants) {
 
-					ConstantNode *ca = static_cast<ConstantNode*>(op->arguments[0]);
-					ConstantNode *cb = static_cast<ConstantNode*>(op->arguments[1]);
-
-
+					ConstantNode *ca = static_cast<ConstantNode *>(op->arguments[0]);
+					ConstantNode *cb = static_cast<ConstantNode *>(op->arguments[1]);
 
 					bool valid;
 
-					Variant v = ca->value.get(cb->value,&valid);
+					Variant v = ca->value.get(cb->value, &valid);
 					if (!valid) {
 						_set_error("invalid index in constant expression");
-						error_line=op->line;
+						error_line = op->line;
 						return op;
 					}
 
 					ConstantNode *cn = alloc_node<ConstantNode>();
-					cn->value=v;
+					cn->value = v;
 					return cn;
 
 				} /*else if (op->arguments[0]->type==Node::TYPE_CONSTANT && op->arguments[1]->type==Node::TYPE_IDENTIFIER) {
@@ -1573,32 +1535,31 @@ GDParser::Node* GDParser::_reduce_expression(Node *p_node,bool p_to_const) {
 
 				return op;
 
-			} else if (op->op==OperatorNode::OP_INDEX_NAMED) {
+			} else if (op->op == OperatorNode::OP_INDEX_NAMED) {
 
-				if (op->arguments[0]->type==Node::TYPE_CONSTANT && op->arguments[1]->type==Node::TYPE_IDENTIFIER) {
+				if (op->arguments[0]->type == Node::TYPE_CONSTANT && op->arguments[1]->type == Node::TYPE_IDENTIFIER) {
 
-					ConstantNode *ca = static_cast<ConstantNode*>(op->arguments[0]);
-					IdentifierNode *ib = static_cast<IdentifierNode*>(op->arguments[1]);
+					ConstantNode *ca = static_cast<ConstantNode *>(op->arguments[0]);
+					IdentifierNode *ib = static_cast<IdentifierNode *>(op->arguments[1]);
 
 					bool valid;
-					Variant v = ca->value.get_named(ib->name,&valid);
+					Variant v = ca->value.get_named(ib->name, &valid);
 					if (!valid) {
-						_set_error("invalid index '"+String(ib->name)+"' in constant expression");
-						error_line=op->line;
+						_set_error("invalid index '" + String(ib->name) + "' in constant expression");
+						error_line = op->line;
 						return op;
 					}
 
 					ConstantNode *cn = alloc_node<ConstantNode>();
-					cn->value=v;
+					cn->value = v;
 					return cn;
 				}
 
 				return op;
-
 			}
 
 			//validate assignment (don't assign to cosntant expression
-			switch(op->op) {
+			switch (op->op) {
 
 				case OperatorNode::OP_ASSIGN:
 				case OperatorNode::OP_ASSIGN_ADD:
@@ -1612,17 +1573,17 @@ GDParser::Node* GDParser::_reduce_expression(Node *p_node,bool p_to_const) {
 				case OperatorNode::OP_ASSIGN_BIT_OR:
 				case OperatorNode::OP_ASSIGN_BIT_XOR: {
 
-					if (op->arguments[0]->type==Node::TYPE_CONSTANT) {
-						_set_error("Can't assign to constant",tokenizer->get_token_line()-1);
-						error_line=op->line;
+					if (op->arguments[0]->type == Node::TYPE_CONSTANT) {
+						_set_error("Can't assign to constant", tokenizer->get_token_line() - 1);
+						error_line = op->line;
 						return op;
 					}
 
-					if (op->arguments[0]->type==Node::TYPE_OPERATOR) {
-						OperatorNode *on = static_cast<OperatorNode*>(op->arguments[0]);
+					if (op->arguments[0]->type == Node::TYPE_OPERATOR) {
+						OperatorNode *on = static_cast<OperatorNode *>(op->arguments[0]);
 						if (on->op != OperatorNode::OP_INDEX && on->op != OperatorNode::OP_INDEX_NAMED) {
-							_set_error("Can't assign to an expression",tokenizer->get_token_line()-1);
-							error_line=op->line;
+							_set_error("Can't assign to an expression", tokenizer->get_token_line() - 1);
+							error_line = op->line;
 							return op;
 						}
 					}
@@ -1633,59 +1594,105 @@ GDParser::Node* GDParser::_reduce_expression(Node *p_node,bool p_to_const) {
 			//now se if all are constants
 			if (!all_constants)
 				return op; //nothing to reduce from here on
-#define _REDUCE_UNARY(m_vop)\
-	bool valid=false;\
-	Variant res;\
-	Variant::evaluate(m_vop,static_cast<ConstantNode*>(op->arguments[0])->value,Variant(),res,valid);\
-	if (!valid) {\
-		_set_error("Invalid operand for unary operator");\
-		error_line=op->line;\
-		return p_node;\
-	}\
-	ConstantNode *cn = alloc_node<ConstantNode>();\
-	cn->value=res;\
+#define _REDUCE_UNARY(m_vop)                                                                               \
+	bool valid = false;                                                                                    \
+	Variant res;                                                                                           \
+	Variant::evaluate(m_vop, static_cast<ConstantNode *>(op->arguments[0])->value, Variant(), res, valid); \
+	if (!valid) {                                                                                          \
+		_set_error("Invalid operand for unary operator");                                                  \
+		error_line = op->line;                                                                             \
+		return p_node;                                                                                     \
+	}                                                                                                      \
+	ConstantNode *cn = alloc_node<ConstantNode>();                                                         \
+	cn->value = res;                                                                                       \
 	return cn;
 
-#define _REDUCE_BINARY(m_vop)\
-	bool valid=false;\
-	Variant res;\
-	Variant::evaluate(m_vop,static_cast<ConstantNode*>(op->arguments[0])->value,static_cast<ConstantNode*>(op->arguments[1])->value,res,valid);\
-	if (!valid) {\
-		_set_error("Invalid operands for operator");\
-		error_line=op->line;\
-		return p_node;\
-	}\
-	ConstantNode *cn = alloc_node<ConstantNode>();\
-	cn->value=res;\
+#define _REDUCE_BINARY(m_vop)                                                                                                                         \
+	bool valid = false;                                                                                                                               \
+	Variant res;                                                                                                                                      \
+	Variant::evaluate(m_vop, static_cast<ConstantNode *>(op->arguments[0])->value, static_cast<ConstantNode *>(op->arguments[1])->value, res, valid); \
+	if (!valid) {                                                                                                                                     \
+		_set_error("Invalid operands for operator");                                                                                                  \
+		error_line = op->line;                                                                                                                        \
+		return p_node;                                                                                                                                \
+	}                                                                                                                                                 \
+	ConstantNode *cn = alloc_node<ConstantNode>();                                                                                                    \
+	cn->value = res;                                                                                                                                  \
 	return cn;
 
-			switch(op->op) {
+			switch (op->op) {
 
 				//unary operators
-				case OperatorNode::OP_NEG: { _REDUCE_UNARY(Variant::OP_NEGATE); } break;
-				case OperatorNode::OP_POS: { _REDUCE_UNARY(Variant::OP_POSITIVE); } break;
-				case OperatorNode::OP_NOT: { _REDUCE_UNARY(Variant::OP_NOT); } break;
-				case OperatorNode::OP_BIT_INVERT: { _REDUCE_UNARY(Variant::OP_BIT_NEGATE); } break;
+				case OperatorNode::OP_NEG: {
+					_REDUCE_UNARY(Variant::OP_NEGATE);
+				} break;
+				case OperatorNode::OP_POS: {
+					_REDUCE_UNARY(Variant::OP_POSITIVE);
+				} break;
+				case OperatorNode::OP_NOT: {
+					_REDUCE_UNARY(Variant::OP_NOT);
+				} break;
+				case OperatorNode::OP_BIT_INVERT: {
+					_REDUCE_UNARY(Variant::OP_BIT_NEGATE);
+				} break;
 				//binary operators (in precedence order)
-				case OperatorNode::OP_IN: { _REDUCE_BINARY(Variant::OP_IN); } break;
-				case OperatorNode::OP_EQUAL: { _REDUCE_BINARY(Variant::OP_EQUAL); } break;
-				case OperatorNode::OP_NOT_EQUAL: { _REDUCE_BINARY(Variant::OP_NOT_EQUAL); } break;
-				case OperatorNode::OP_LESS: { _REDUCE_BINARY(Variant::OP_LESS); } break;
-				case OperatorNode::OP_LESS_EQUAL: {  _REDUCE_BINARY(Variant::OP_LESS_EQUAL); } break;
-				case OperatorNode::OP_GREATER: { _REDUCE_BINARY(Variant::OP_GREATER); } break;
-				case OperatorNode::OP_GREATER_EQUAL: { _REDUCE_BINARY(Variant::OP_GREATER_EQUAL); } break;
-				case OperatorNode::OP_AND: { _REDUCE_BINARY(Variant::OP_AND); } break;
-				case OperatorNode::OP_OR: { _REDUCE_BINARY(Variant::OP_OR); } break;
-				case OperatorNode::OP_ADD: { _REDUCE_BINARY(Variant::OP_ADD); } break;
-				case OperatorNode::OP_SUB: { _REDUCE_BINARY(Variant::OP_SUBSTRACT); } break;
-				case OperatorNode::OP_MUL: { _REDUCE_BINARY(Variant::OP_MULTIPLY); } break;
-				case OperatorNode::OP_DIV: { _REDUCE_BINARY(Variant::OP_DIVIDE); } break;
-				case OperatorNode::OP_MOD: { _REDUCE_BINARY(Variant::OP_MODULE); } break;
-				case OperatorNode::OP_SHIFT_LEFT: { _REDUCE_BINARY(Variant::OP_SHIFT_LEFT); } break;
-				case OperatorNode::OP_SHIFT_RIGHT: { _REDUCE_BINARY(Variant::OP_SHIFT_RIGHT); } break;
-				case OperatorNode::OP_BIT_AND: { _REDUCE_BINARY(Variant::OP_BIT_AND); } break;
-				case OperatorNode::OP_BIT_OR: { _REDUCE_BINARY(Variant::OP_BIT_OR); } break;
-				case OperatorNode::OP_BIT_XOR: { _REDUCE_BINARY(Variant::OP_BIT_XOR); } break;
+				case OperatorNode::OP_IN: {
+					_REDUCE_BINARY(Variant::OP_IN);
+				} break;
+				case OperatorNode::OP_EQUAL: {
+					_REDUCE_BINARY(Variant::OP_EQUAL);
+				} break;
+				case OperatorNode::OP_NOT_EQUAL: {
+					_REDUCE_BINARY(Variant::OP_NOT_EQUAL);
+				} break;
+				case OperatorNode::OP_LESS: {
+					_REDUCE_BINARY(Variant::OP_LESS);
+				} break;
+				case OperatorNode::OP_LESS_EQUAL: {
+					_REDUCE_BINARY(Variant::OP_LESS_EQUAL);
+				} break;
+				case OperatorNode::OP_GREATER: {
+					_REDUCE_BINARY(Variant::OP_GREATER);
+				} break;
+				case OperatorNode::OP_GREATER_EQUAL: {
+					_REDUCE_BINARY(Variant::OP_GREATER_EQUAL);
+				} break;
+				case OperatorNode::OP_AND: {
+					_REDUCE_BINARY(Variant::OP_AND);
+				} break;
+				case OperatorNode::OP_OR: {
+					_REDUCE_BINARY(Variant::OP_OR);
+				} break;
+				case OperatorNode::OP_ADD: {
+					_REDUCE_BINARY(Variant::OP_ADD);
+				} break;
+				case OperatorNode::OP_SUB: {
+					_REDUCE_BINARY(Variant::OP_SUBSTRACT);
+				} break;
+				case OperatorNode::OP_MUL: {
+					_REDUCE_BINARY(Variant::OP_MULTIPLY);
+				} break;
+				case OperatorNode::OP_DIV: {
+					_REDUCE_BINARY(Variant::OP_DIVIDE);
+				} break;
+				case OperatorNode::OP_MOD: {
+					_REDUCE_BINARY(Variant::OP_MODULE);
+				} break;
+				case OperatorNode::OP_SHIFT_LEFT: {
+					_REDUCE_BINARY(Variant::OP_SHIFT_LEFT);
+				} break;
+				case OperatorNode::OP_SHIFT_RIGHT: {
+					_REDUCE_BINARY(Variant::OP_SHIFT_RIGHT);
+				} break;
+				case OperatorNode::OP_BIT_AND: {
+					_REDUCE_BINARY(Variant::OP_BIT_AND);
+				} break;
+				case OperatorNode::OP_BIT_OR: {
+					_REDUCE_BINARY(Variant::OP_BIT_OR);
+				} break;
+				case OperatorNode::OP_BIT_XOR: {
+					_REDUCE_BINARY(Variant::OP_BIT_XOR);
+				} break;
 				default: { ERR_FAIL_V(op); }
 			}
 
@@ -1694,16 +1701,15 @@ GDParser::Node* GDParser::_reduce_expression(Node *p_node,bool p_to_const) {
 		default: {
 			return p_node;
 		} break;
-
 	}
 }
 
-GDParser::Node* GDParser::_parse_and_reduce_expression(Node *p_parent,bool p_static,bool p_reduce_const,bool p_allow_assign) {
+GDParser::Node *GDParser::_parse_and_reduce_expression(Node *p_parent, bool p_static, bool p_reduce_const, bool p_allow_assign) {
 
-	Node* expr=_parse_expression(p_parent,p_static,p_allow_assign,p_reduce_const);
+	Node *expr = _parse_expression(p_parent, p_static, p_allow_assign, p_reduce_const);
 	if (!expr || error_set)
 		return NULL;
-	expr = _reduce_expression(expr,p_reduce_const);
+	expr = _reduce_expression(expr, p_reduce_const);
 	if (!expr || error_set)
 		return NULL;
 	return expr;
@@ -1715,43 +1721,42 @@ bool GDParser::_recover_from_completion() {
 		return false; //can't recover if no completion
 	}
 	//skip stuff until newline
-	while(tokenizer->get_token()!=GDTokenizer::TK_NEWLINE && tokenizer->get_token()!=GDTokenizer::TK_EOF && tokenizer->get_token()!=GDTokenizer::TK_ERROR) {
+	while (tokenizer->get_token() != GDTokenizer::TK_NEWLINE && tokenizer->get_token() != GDTokenizer::TK_EOF && tokenizer->get_token() != GDTokenizer::TK_ERROR) {
 		tokenizer->advance();
 	}
-	completion_found=false;
-	error_set=false;
-	if(tokenizer->get_token() == GDTokenizer::TK_ERROR){
+	completion_found = false;
+	error_set = false;
+	if (tokenizer->get_token() == GDTokenizer::TK_ERROR) {
 		error_set = true;
 	}
 
 	return true;
 }
 
-GDParser::PatternNode *GDParser::_parse_pattern(bool p_static)
-{
-	
+GDParser::PatternNode *GDParser::_parse_pattern(bool p_static) {
+
 	PatternNode *pattern = alloc_node<PatternNode>();
-	
+
 	GDTokenizer::Token token = tokenizer->get_token();
 	if (error_set)
 		return NULL;
-	
+
 	if (token == GDTokenizer::TK_EOF) {
 		return NULL;
 	}
-	
+
 	switch (token) {
 		// array
 		case GDTokenizer::TK_BRACKET_OPEN: {
 			tokenizer->advance();
 			pattern->pt_type = GDParser::PatternNode::PT_ARRAY;
 			while (true) {
-				
+
 				if (tokenizer->get_token() == GDTokenizer::TK_BRACKET_CLOSE) {
 					tokenizer->advance();
 					break;
 				}
-				
+
 				if (tokenizer->get_token() == GDTokenizer::TK_PERIOD && tokenizer->get_token(1) == GDTokenizer::TK_PERIOD) {
 					// match everything
 					tokenizer->advance(2);
@@ -1769,14 +1774,14 @@ GDParser::PatternNode *GDParser::_parse_pattern(bool p_static)
 						return NULL;
 					}
 				}
-				
+
 				PatternNode *sub_pattern = _parse_pattern(p_static);
 				if (!sub_pattern) {
 					return NULL;
 				}
-				
+
 				pattern->array.push_back(sub_pattern);
-				
+
 				if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 					tokenizer->advance();
 					continue;
@@ -1801,12 +1806,12 @@ GDParser::PatternNode *GDParser::_parse_pattern(bool p_static)
 			tokenizer->advance();
 			pattern->pt_type = GDParser::PatternNode::PT_DICTIONARY;
 			while (true) {
-				
+
 				if (tokenizer->get_token() == GDTokenizer::TK_CURLY_BRACKET_CLOSE) {
 					tokenizer->advance();
 					break;
 				}
-				
+
 				if (tokenizer->get_token() == GDTokenizer::TK_PERIOD && tokenizer->get_token(1) == GDTokenizer::TK_PERIOD) {
 					// match everything
 					tokenizer->advance(2);
@@ -1824,33 +1829,32 @@ GDParser::PatternNode *GDParser::_parse_pattern(bool p_static)
 						return NULL;
 					}
 				}
-				
+
 				Node *key = _parse_and_reduce_expression(pattern, p_static);
 				if (!key) {
 					_set_error("Not a valid key in pattern");
 					return NULL;
 				}
-				
+
 				if (key->type != GDParser::Node::TYPE_CONSTANT) {
 					_set_error("Not a constant expression as key");
 					return NULL;
 				}
-				
+
 				if (tokenizer->get_token() == GDTokenizer::TK_COLON) {
 					tokenizer->advance();
-					
+
 					PatternNode *value = _parse_pattern(p_static);
 					if (!value) {
 						_set_error("Expected pattern in dictionary value");
 						return NULL;
 					}
-					
-					pattern->dictionary.insert(static_cast<ConstantNode*>(key), value);
+
+					pattern->dictionary.insert(static_cast<ConstantNode *>(key), value);
 				} else {
-					pattern->dictionary.insert(static_cast<ConstantNode*>(key), NULL);
+					pattern->dictionary.insert(static_cast<ConstantNode *>(key), NULL);
 				}
-				
-				
+
 				if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 					tokenizer->advance();
 					continue;
@@ -1873,47 +1877,47 @@ GDParser::PatternNode *GDParser::_parse_pattern(bool p_static)
 			if (error_set) {
 				return NULL;
 			}
-			
+
 			if (value->type != Node::TYPE_IDENTIFIER && value->type != Node::TYPE_CONSTANT) {
 				_set_error("Only constant expressions or variables allowed in a pattern");
 				return NULL;
 			}
-			
+
 			pattern->pt_type = PatternNode::PT_CONSTANT;
 			pattern->constant = value;
 		} break;
 	}
-	
+
 	return pattern;
 }
 
-void GDParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode*> &p_branches, bool p_static)
-{
+void GDParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode *> &p_branches, bool p_static) {
 	int indent_level = tab_level.back()->get();
-	
+
 	while (true) {
-		
-		while (tokenizer->get_token() == GDTokenizer::TK_NEWLINE && _parse_newline());
-		
+
+		while (tokenizer->get_token() == GDTokenizer::TK_NEWLINE && _parse_newline())
+			;
+
 		// GDTokenizer::Token token = tokenizer->get_token();
 		if (error_set)
 			return;
-		
+
 		if (indent_level > tab_level.back()->get()) {
 			return; // go back a level
 		}
-		
-		if (pending_newline!=-1) {
-			pending_newline=-1;
+
+		if (pending_newline != -1) {
+			pending_newline = -1;
 		}
-		
+
 		PatternBranchNode *branch = alloc_node<PatternBranchNode>();
-		
+
 		branch->patterns.push_back(_parse_pattern(p_static));
 		if (!branch->patterns[0]) {
 			return;
 		}
-		
+
 		while (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 			tokenizer->advance();
 			branch->patterns.push_back(_parse_pattern(p_static));
@@ -1921,263 +1925,249 @@ void GDParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode
 				return;
 			}
 		}
-		
-		if(!_enter_indent_block()) {
+
+		if (!_enter_indent_block()) {
 			_set_error("Expected block in pattern branch");
 			return;
 		}
-		
+
 		branch->body = alloc_node<BlockNode>();
 		branch->body->parent_block = p_block;
 		p_block->sub_blocks.push_back(branch->body);
 		current_block = branch->body;
-		
+
 		_parse_block(branch->body, p_static);
-		
+
 		current_block = p_block;
-		
+
 		p_branches.push_back(branch);
 	}
 }
 
-
-void GDParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_match, Node *&p_resulting_node, Map<StringName, Node*> &p_bindings)
-{
+void GDParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_match, Node *&p_resulting_node, Map<StringName, Node *> &p_bindings) {
 	switch (p_pattern->pt_type) {
 		case PatternNode::PT_CONSTANT: {
-			
+
 			// typecheck
 			BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
 			typeof_node->function = GDFunctions::TYPE_OF;
-			
+
 			OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
 			typeof_match_value->op = OperatorNode::OP_CALL;
 			typeof_match_value->arguments.push_back(typeof_node);
 			typeof_match_value->arguments.push_back(p_node_to_match);
-			
+
 			OperatorNode *typeof_pattern_value = alloc_node<OperatorNode>();
 			typeof_pattern_value->op = OperatorNode::OP_CALL;
 			typeof_pattern_value->arguments.push_back(typeof_node);
 			typeof_pattern_value->arguments.push_back(p_pattern->constant);
-			
+
 			OperatorNode *type_comp = alloc_node<OperatorNode>();
 			type_comp->op = OperatorNode::OP_EQUAL;
 			type_comp->arguments.push_back(typeof_match_value);
 			type_comp->arguments.push_back(typeof_pattern_value);
-			
-			
+
 			// comare the actual values
 			OperatorNode *value_comp = alloc_node<OperatorNode>();
 			value_comp->op = OperatorNode::OP_EQUAL;
 			value_comp->arguments.push_back(p_pattern->constant);
 			value_comp->arguments.push_back(p_node_to_match);
-			
-			
+
 			OperatorNode *comparison = alloc_node<OperatorNode>();
 			comparison->op = OperatorNode::OP_AND;
 			comparison->arguments.push_back(type_comp);
 			comparison->arguments.push_back(value_comp);
-			
+
 			p_resulting_node = comparison;
-			
+
 		} break;
 		case PatternNode::PT_BIND: {
 			p_bindings[p_pattern->bind] = p_node_to_match;
-			
+
 			// a bind always matches
 			ConstantNode *true_value = alloc_node<ConstantNode>();
 			true_value->value = Variant(true);
 			p_resulting_node = true_value;
 		} break;
 		case PatternNode::PT_ARRAY: {
-			
+
 			bool open_ended = false;
-	
+
 			if (p_pattern->array.size() > 0) {
 				if (p_pattern->array[p_pattern->array.size() - 1]->pt_type == PatternNode::PT_IGNORE_REST) {
 					open_ended = true;
 				}
 			}
-			
+
 			// typeof(value_to_match) == TYPE_ARRAY && value_to_match.size() >= length
 			// typeof(value_to_match) == TYPE_ARRAY && value_to_match.size() == length
-			
+
 			{
 				// typecheck
 				BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
 				typeof_node->function = GDFunctions::TYPE_OF;
-				
+
 				OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
 				typeof_match_value->op = OperatorNode::OP_CALL;
 				typeof_match_value->arguments.push_back(typeof_node);
 				typeof_match_value->arguments.push_back(p_node_to_match);
-				
+
 				IdentifierNode *typeof_array = alloc_node<IdentifierNode>();
 				typeof_array->name = "TYPE_ARRAY";
-				
+
 				OperatorNode *type_comp = alloc_node<OperatorNode>();
 				type_comp->op = OperatorNode::OP_EQUAL;
 				type_comp->arguments.push_back(typeof_match_value);
 				type_comp->arguments.push_back(typeof_array);
-				
-				
+
 				// size
 				ConstantNode *length = alloc_node<ConstantNode>();
 				length->value = Variant(open_ended ? p_pattern->array.size() - 1 : p_pattern->array.size());
-				
+
 				OperatorNode *call = alloc_node<OperatorNode>();
 				call->op = OperatorNode::OP_CALL;
 				call->arguments.push_back(p_node_to_match);
-				
+
 				IdentifierNode *size = alloc_node<IdentifierNode>();
 				size->name = "size";
 				call->arguments.push_back(size);
-				
+
 				OperatorNode *length_comparison = alloc_node<OperatorNode>();
 				length_comparison->op = open_ended ? OperatorNode::OP_GREATER_EQUAL : OperatorNode::OP_EQUAL;
 				length_comparison->arguments.push_back(call);
 				length_comparison->arguments.push_back(length);
-				
+
 				OperatorNode *type_and_length_comparison = alloc_node<OperatorNode>();
 				type_and_length_comparison->op = OperatorNode::OP_AND;
 				type_and_length_comparison->arguments.push_back(type_comp);
 				type_and_length_comparison->arguments.push_back(length_comparison);
-				
+
 				p_resulting_node = type_and_length_comparison;
 			}
-			
-			
-			
+
 			for (int i = 0; i < p_pattern->array.size(); i++) {
 				PatternNode *pattern = p_pattern->array[i];
-				
+
 				Node *condition = NULL;
-				
+
 				ConstantNode *index = alloc_node<ConstantNode>();
 				index->value = Variant(i);
-				
+
 				OperatorNode *indexed_value = alloc_node<OperatorNode>();
 				indexed_value->op = OperatorNode::OP_INDEX;
 				indexed_value->arguments.push_back(p_node_to_match);
 				indexed_value->arguments.push_back(index);
-				
+
 				_generate_pattern(pattern, indexed_value, condition, p_bindings);
-				
+
 				// concatenate all the patterns with &&
 				OperatorNode *and_node = alloc_node<OperatorNode>();
 				and_node->op = OperatorNode::OP_AND;
 				and_node->arguments.push_back(p_resulting_node);
 				and_node->arguments.push_back(condition);
-				
+
 				p_resulting_node = and_node;
 			}
-			
-			
+
 		} break;
 		case PatternNode::PT_DICTIONARY: {
-			
+
 			bool open_ended = false;
-			
+
 			if (p_pattern->array.size() > 0) {
 				open_ended = true;
 			}
-			
+
 			// typeof(value_to_match) == TYPE_DICTIONARY && value_to_match.size() >= length
 			// typeof(value_to_match) == TYPE_DICTIONARY && value_to_match.size() == length
-			
-			
+
 			{
 				// typecheck
 				BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
 				typeof_node->function = GDFunctions::TYPE_OF;
-				
+
 				OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
 				typeof_match_value->op = OperatorNode::OP_CALL;
 				typeof_match_value->arguments.push_back(typeof_node);
 				typeof_match_value->arguments.push_back(p_node_to_match);
-				
+
 				IdentifierNode *typeof_dictionary = alloc_node<IdentifierNode>();
 				typeof_dictionary->name = "TYPE_DICTIONARY";
-				
+
 				OperatorNode *type_comp = alloc_node<OperatorNode>();
 				type_comp->op = OperatorNode::OP_EQUAL;
 				type_comp->arguments.push_back(typeof_match_value);
 				type_comp->arguments.push_back(typeof_dictionary);
-				
+
 				// size
 				ConstantNode *length = alloc_node<ConstantNode>();
 				length->value = Variant(open_ended ? p_pattern->dictionary.size() - 1 : p_pattern->dictionary.size());
-				
+
 				OperatorNode *call = alloc_node<OperatorNode>();
 				call->op = OperatorNode::OP_CALL;
 				call->arguments.push_back(p_node_to_match);
-				
+
 				IdentifierNode *size = alloc_node<IdentifierNode>();
 				size->name = "size";
 				call->arguments.push_back(size);
-				
+
 				OperatorNode *length_comparison = alloc_node<OperatorNode>();
 				length_comparison->op = open_ended ? OperatorNode::OP_GREATER_EQUAL : OperatorNode::OP_EQUAL;
 				length_comparison->arguments.push_back(call);
 				length_comparison->arguments.push_back(length);
-				
+
 				OperatorNode *type_and_length_comparison = alloc_node<OperatorNode>();
 				type_and_length_comparison->op = OperatorNode::OP_AND;
 				type_and_length_comparison->arguments.push_back(type_comp);
 				type_and_length_comparison->arguments.push_back(length_comparison);
-				
+
 				p_resulting_node = type_and_length_comparison;
 			}
-			
-			
-			
-			for (Map<ConstantNode*, PatternNode*>::Element *e = p_pattern->dictionary.front(); e; e = e->next()) {
-				
+
+			for (Map<ConstantNode *, PatternNode *>::Element *e = p_pattern->dictionary.front(); e; e = e->next()) {
+
 				Node *condition = NULL;
-				
+
 				// chech for has, then for pattern
-				
+
 				IdentifierNode *has = alloc_node<IdentifierNode>();
 				has->name = "has";
-				
+
 				OperatorNode *has_call = alloc_node<OperatorNode>();
 				has_call->op = OperatorNode::OP_CALL;
 				has_call->arguments.push_back(p_node_to_match);
 				has_call->arguments.push_back(has);
 				has_call->arguments.push_back(e->key());
-					
-				
+
 				if (e->value()) {
-					
+
 					OperatorNode *indexed_value = alloc_node<OperatorNode>();
 					indexed_value->op = OperatorNode::OP_INDEX;
 					indexed_value->arguments.push_back(p_node_to_match);
 					indexed_value->arguments.push_back(e->key());
-					
+
 					_generate_pattern(e->value(), indexed_value, condition, p_bindings);
-					
+
 					OperatorNode *has_and_pattern = alloc_node<OperatorNode>();
 					has_and_pattern->op = OperatorNode::OP_AND;
 					has_and_pattern->arguments.push_back(has_call);
 					has_and_pattern->arguments.push_back(condition);
-					
+
 					condition = has_and_pattern;
 
 				} else {
 					condition = has_call;
 				}
-				
-				
-				
+
 				// concatenate all the patterns with &&
 				OperatorNode *and_node = alloc_node<OperatorNode>();
 				and_node->op = OperatorNode::OP_AND;
 				and_node->arguments.push_back(p_resulting_node);
 				and_node->arguments.push_back(condition);
-				
+
 				p_resulting_node = and_node;
 			}
-			
+
 		} break;
 		case PatternNode::PT_IGNORE_REST:
 		case PatternNode::PT_WILDCARD: {
@@ -2187,119 +2177,110 @@ void GDParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_match,
 			p_resulting_node = true_value;
 		} break;
 		default: {
-			
+
 		} break;
 	}
 }
 
-void GDParser::_transform_match_statment(BlockNode *p_block, MatchNode *p_match_statement)
-{
+void GDParser::_transform_match_statment(BlockNode *p_block, MatchNode *p_match_statement) {
 	IdentifierNode *id = alloc_node<IdentifierNode>();
 	id->name = "#match_value";
-	
+
 	for (int i = 0; i < p_match_statement->branches.size(); i++) {
-		
+
 		PatternBranchNode *branch = p_match_statement->branches[i];
-		
+
 		MatchNode::CompiledPatternBranch compiled_branch;
 		compiled_branch.compiled_pattern = NULL;
-		
-		Map<StringName, Node*> binding;
-		
+
+		Map<StringName, Node *> binding;
+
 		for (int j = 0; j < branch->patterns.size(); j++) {
 			PatternNode *pattern = branch->patterns[j];
-			
-			Map<StringName, Node*> bindings;
+
+			Map<StringName, Node *> bindings;
 			Node *resulting_node;
 			_generate_pattern(pattern, id, resulting_node, bindings);
-			
+
 			if (!binding.empty() && !bindings.empty()) {
 				_set_error("Multipatterns can't contain bindings");
 				return;
 			} else {
 				binding = bindings;
 			}
-			
+
 			if (compiled_branch.compiled_pattern) {
 				OperatorNode *or_node = alloc_node<OperatorNode>();
 				or_node->op = OperatorNode::OP_OR;
 				or_node->arguments.push_back(compiled_branch.compiled_pattern);
 				or_node->arguments.push_back(resulting_node);
-				
+
 				compiled_branch.compiled_pattern = or_node;
 			} else {
 				// single pattern | first one
 				compiled_branch.compiled_pattern = resulting_node;
 			}
-			
 		}
-		
-		
+
 		// prepare the body ...hehe
-		for (Map<StringName, Node*>::Element *e = binding.front(); e; e = e->next()) {
+		for (Map<StringName, Node *>::Element *e = binding.front(); e; e = e->next()) {
 			LocalVarNode *local_var = alloc_node<LocalVarNode>();
 			local_var->name = e->key();
 			local_var->assign = e->value();
 
-			
 			IdentifierNode *id = alloc_node<IdentifierNode>();
 			id->name = local_var->name;
 
 			OperatorNode *op = alloc_node<OperatorNode>();
-			op->op=OperatorNode::OP_ASSIGN;
+			op->op = OperatorNode::OP_ASSIGN;
 			op->arguments.push_back(id);
 			op->arguments.push_back(local_var->assign);
-			
+
 			branch->body->statements.push_front(op);
 			branch->body->statements.push_front(local_var);
 		}
-		
+
 		compiled_branch.body = branch->body;
-		
-		
+
 		p_match_statement->compiled_pattern_branches.push_back(compiled_branch);
 	}
-	
 }
 
-void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
+void GDParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 	int indent_level = tab_level.back()->get();
 
-
 #ifdef DEBUG_ENABLED
 
 	NewLineNode *nl = alloc_node<NewLineNode>();
 
-	nl->line=tokenizer->get_token_line();
+	nl->line = tokenizer->get_token_line();
 	p_block->statements.push_back(nl);
 #endif
 
-	while(true) {
+	while (true) {
 
 		GDTokenizer::Token token = tokenizer->get_token();
 		if (error_set)
 			return;
 
-		if (indent_level>tab_level.back()->get()) {
-			p_block->end_line=tokenizer->get_token_line();
+		if (indent_level > tab_level.back()->get()) {
+			p_block->end_line = tokenizer->get_token_line();
 			return; //go back a level
 		}
 
-		if (pending_newline!=-1) {
+		if (pending_newline != -1) {
 
 			NewLineNode *nl = alloc_node<NewLineNode>();
-			nl->line=pending_newline;
+			nl->line = pending_newline;
 			p_block->statements.push_back(nl);
-			pending_newline=-1;
-
+			pending_newline = -1;
 		}
 
-		switch(token) {
-
+		switch (token) {
 
 			case GDTokenizer::TK_EOF:
-				p_block->end_line=tokenizer->get_token_line();
+				p_block->end_line = tokenizer->get_token_line();
 			case GDTokenizer::TK_ERROR: {
 				return; //go back
 
@@ -2310,26 +2291,25 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 
 				if (!_parse_newline()) {
 					if (!error_set) {
-						p_block->end_line=tokenizer->get_token_line();
-						pending_newline=p_block->end_line;
-
+						p_block->end_line = tokenizer->get_token_line();
+						pending_newline = p_block->end_line;
 					}
 					return;
 				}
 
 				NewLineNode *nl = alloc_node<NewLineNode>();
-				nl->line=tokenizer->get_token_line();
+				nl->line = tokenizer->get_token_line();
 				p_block->statements.push_back(nl);
 
 			} break;
 			case GDTokenizer::TK_CF_PASS: {
-				if (tokenizer->get_token(1)!=GDTokenizer::TK_SEMICOLON && tokenizer->get_token(1)!=GDTokenizer::TK_NEWLINE && tokenizer->get_token(1)!=GDTokenizer::TK_EOF) {
+				if (tokenizer->get_token(1) != GDTokenizer::TK_SEMICOLON && tokenizer->get_token(1) != GDTokenizer::TK_NEWLINE && tokenizer->get_token(1) != GDTokenizer::TK_EOF) {
 
 					_set_error("Expected ';' or <NewLine>.");
 					return;
 				}
 				tokenizer->advance();
-				if(tokenizer->get_token()==GDTokenizer::TK_SEMICOLON) {
+				if (tokenizer->get_token() == GDTokenizer::TK_SEMICOLON) {
 					// Ignore semicolon after 'pass'
 					tokenizer->advance();
 				}
@@ -2338,26 +2318,26 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 				//variale declaration and (eventual) initialization
 
 				tokenizer->advance();
-				if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+				if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 
 					_set_error("Expected identifier for local variable name.");
 					return;
 				}
 				StringName n = tokenizer->get_token_identifier();
 				tokenizer->advance();
-				if (current_function){
-					for (int i=0;i<current_function->arguments.size();i++){
-						if (n == current_function->arguments[i]){
-							_set_error("Variable '"+String(n)+"' already defined in the scope (at line: "+itos(current_function->line)+").");
+				if (current_function) {
+					for (int i = 0; i < current_function->arguments.size(); i++) {
+						if (n == current_function->arguments[i]) {
+							_set_error("Variable '" + String(n) + "' already defined in the scope (at line: " + itos(current_function->line) + ").");
 							return;
 						}
 					}
 				}
 				BlockNode *check_block = p_block;
-				while (check_block){
-					for (int i=0;i<check_block->variables.size();i++){
-						if (n == check_block->variables[i]){
-							_set_error("Variable '"+String(n)+"' already defined in the scope (at line: "+itos(check_block->variable_lines[i])+").");
+				while (check_block) {
+					for (int i = 0; i < check_block->variables.size(); i++) {
+						if (n == check_block->variables[i]) {
+							_set_error("Variable '" + String(n) + "' already defined in the scope (at line: " + itos(check_block->variable_lines[i]) + ").");
 							return;
 						}
 					}
@@ -2367,20 +2347,19 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 				p_block->variables.push_back(n); //line?
 				p_block->variable_lines.push_back(tokenizer->get_token_line());
 
-
 				//must know when the local variable is declared
 				LocalVarNode *lv = alloc_node<LocalVarNode>();
-				lv->name=n;
+				lv->name = n;
 				p_block->statements.push_back(lv);
 
-				Node *assigned=NULL;
+				Node *assigned = NULL;
 
-				if (tokenizer->get_token()==GDTokenizer::TK_OP_ASSIGN) {
+				if (tokenizer->get_token() == GDTokenizer::TK_OP_ASSIGN) {
 
 					tokenizer->advance();
-					Node *subexpr=NULL;
+					Node *subexpr = NULL;
 
-					subexpr = _parse_and_reduce_expression(p_block,p_static);
+					subexpr = _parse_and_reduce_expression(p_block, p_static);
 					if (!subexpr) {
 						if (_recover_from_completion()) {
 							break;
@@ -2388,23 +2367,19 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 						return;
 					}
 
-
-
-					lv->assign=subexpr;
-					assigned=subexpr;
+					lv->assign = subexpr;
+					assigned = subexpr;
 				} else {
 
 					ConstantNode *c = alloc_node<ConstantNode>();
-					c->value=Variant();
+					c->value = Variant();
 					assigned = c;
-
 				}
 				IdentifierNode *id = alloc_node<IdentifierNode>();
-				id->name=n;
-
+				id->name = n;
 
 				OperatorNode *op = alloc_node<OperatorNode>();
-				op->op=OperatorNode::OP_ASSIGN;
+				op->op = OperatorNode::OP_ASSIGN;
 				op->arguments.push_back(id);
 				op->arguments.push_back(assigned);
 				p_block->statements.push_back(op);
@@ -2418,8 +2393,8 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 			case GDTokenizer::TK_CF_IF: {
 
 				tokenizer->advance();
-				
-				Node *condition = _parse_and_reduce_expression(p_block,p_static);
+
+				Node *condition = _parse_and_reduce_expression(p_block, p_static);
 				if (!condition) {
 					if (_recover_from_completion()) {
 						break;
@@ -2429,39 +2404,39 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 
 				ControlFlowNode *cf_if = alloc_node<ControlFlowNode>();
 
-				cf_if->cf_type=ControlFlowNode::CF_IF;
+				cf_if->cf_type = ControlFlowNode::CF_IF;
 				cf_if->arguments.push_back(condition);
 
 				cf_if->body = alloc_node<BlockNode>();
-				cf_if->body->parent_block=p_block;
+				cf_if->body->parent_block = p_block;
 				p_block->sub_blocks.push_back(cf_if->body);
 
 				if (!_enter_indent_block(cf_if->body)) {
 					_set_error("Expected intended block after 'if'");
-					p_block->end_line=tokenizer->get_token_line();
+					p_block->end_line = tokenizer->get_token_line();
 					return;
 				}
 
-				current_block=cf_if->body;
-				_parse_block(cf_if->body,p_static);
-				current_block=p_block;
+				current_block = cf_if->body;
+				_parse_block(cf_if->body, p_static);
+				current_block = p_block;
 
 				if (error_set)
 					return;
 				p_block->statements.push_back(cf_if);
 
-				while(true) {
+				while (true) {
 
-					while(tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+					while (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 						tokenizer->advance();
 					}
 
 					if (tab_level.back()->get() < indent_level) { //not at current indent level
-						p_block->end_line=tokenizer->get_token_line();
+						p_block->end_line = tokenizer->get_token_line();
 						return;
 					}
 
-					if (tokenizer->get_token()==GDTokenizer::TK_CF_ELIF) {
+					if (tokenizer->get_token() == GDTokenizer::TK_CF_ELIF) {
 
 						if (tab_level.back()->get() > indent_level) {
 
@@ -2471,15 +2446,15 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 
 						tokenizer->advance();
 
-						cf_if->body_else=alloc_node<BlockNode>();
-						cf_if->body_else->parent_block=p_block;
+						cf_if->body_else = alloc_node<BlockNode>();
+						cf_if->body_else->parent_block = p_block;
 						p_block->sub_blocks.push_back(cf_if->body_else);
 
 						ControlFlowNode *cf_else = alloc_node<ControlFlowNode>();
-						cf_else->cf_type=ControlFlowNode::CF_IF;
+						cf_else->cf_type = ControlFlowNode::CF_IF;
 
 						//condition
-						Node *condition = _parse_and_reduce_expression(p_block,p_static);
+						Node *condition = _parse_and_reduce_expression(p_block, p_static);
 						if (!condition) {
 							if (_recover_from_completion()) {
 								break;
@@ -2487,66 +2462,60 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 							return;
 						}
 						cf_else->arguments.push_back(condition);
-						cf_else->cf_type=ControlFlowNode::CF_IF;
+						cf_else->cf_type = ControlFlowNode::CF_IF;
 
 						cf_if->body_else->statements.push_back(cf_else);
-						cf_if=cf_else;
-						cf_if->body=alloc_node<BlockNode>();
-						cf_if->body->parent_block=p_block;
+						cf_if = cf_else;
+						cf_if->body = alloc_node<BlockNode>();
+						cf_if->body->parent_block = p_block;
 						p_block->sub_blocks.push_back(cf_if->body);
 
-
 						if (!_enter_indent_block(cf_if->body)) {
 							_set_error("Expected indented block after 'elif'");
-							p_block->end_line=tokenizer->get_token_line();
+							p_block->end_line = tokenizer->get_token_line();
 							return;
 						}
 
-						current_block=cf_else->body;
-						_parse_block(cf_else->body,p_static);
-						current_block=p_block;
+						current_block = cf_else->body;
+						_parse_block(cf_else->body, p_static);
+						current_block = p_block;
 						if (error_set)
 							return;
 
-
-					} else if (tokenizer->get_token()==GDTokenizer::TK_CF_ELSE) {
+					} else if (tokenizer->get_token() == GDTokenizer::TK_CF_ELSE) {
 
 						if (tab_level.back()->get() > indent_level) {
 							_set_error("Invalid indent");
 							return;
 						}
 
-
 						tokenizer->advance();
-						cf_if->body_else=alloc_node<BlockNode>();
-						cf_if->body_else->parent_block=p_block;
+						cf_if->body_else = alloc_node<BlockNode>();
+						cf_if->body_else->parent_block = p_block;
 						p_block->sub_blocks.push_back(cf_if->body_else);
 
 						if (!_enter_indent_block(cf_if->body_else)) {
 							_set_error("Expected indented block after 'else'");
-							p_block->end_line=tokenizer->get_token_line();
+							p_block->end_line = tokenizer->get_token_line();
 							return;
 						}
-						current_block=cf_if->body_else;
-						_parse_block(cf_if->body_else,p_static);
-						current_block=p_block;
+						current_block = cf_if->body_else;
+						_parse_block(cf_if->body_else, p_static);
+						current_block = p_block;
 						if (error_set)
 							return;
 
-
 						break; //after else, exit
 
 					} else
 						break;
-
 				}
 
-
 			} break;
 			case GDTokenizer::TK_CF_WHILE: {
 
 				tokenizer->advance();
-				Node *condition = _parse_and_reduce_expression(p_block,p_static);
+				Node *condition = _parse_and_reduce_expression(p_block, p_static);
 				if (!condition) {
 					if (_recover_from_completion()) {
 						break;
@@ -2556,22 +2525,22 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 
 				ControlFlowNode *cf_while = alloc_node<ControlFlowNode>();
 
-				cf_while->cf_type=ControlFlowNode::CF_WHILE;
+				cf_while->cf_type = ControlFlowNode::CF_WHILE;
 				cf_while->arguments.push_back(condition);
 
 				cf_while->body = alloc_node<BlockNode>();
-				cf_while->body->parent_block=p_block;
+				cf_while->body->parent_block = p_block;
 				p_block->sub_blocks.push_back(cf_while->body);
 
 				if (!_enter_indent_block(cf_while->body)) {
 					_set_error("Expected indented block after 'while'");
-					p_block->end_line=tokenizer->get_token_line();
+					p_block->end_line = tokenizer->get_token_line();
 					return;
 				}
 
-				current_block=cf_while->body;
-				_parse_block(cf_while->body,p_static);
-				current_block=p_block;
+				current_block = cf_while->body;
+				_parse_block(cf_while->body, p_static);
+				current_block = p_block;
 				if (error_set)
 					return;
 				p_block->statements.push_back(cf_while);
@@ -2580,24 +2549,24 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 
 				tokenizer->advance();
 
-				if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+				if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 
 					_set_error("identifier expected after 'for'");
 				}
 
 				IdentifierNode *id = alloc_node<IdentifierNode>();
-				id->name=tokenizer->get_token_identifier();
+				id->name = tokenizer->get_token_identifier();
 
 				tokenizer->advance();
 
-				if (tokenizer->get_token()!=GDTokenizer::TK_OP_IN) {
+				if (tokenizer->get_token() != GDTokenizer::TK_OP_IN) {
 					_set_error("'in' expected after identifier");
 					return;
 				}
 
 				tokenizer->advance();
 
-				Node *container = _parse_and_reduce_expression(p_block,p_static);
+				Node *container = _parse_and_reduce_expression(p_block, p_static);
 				if (!container) {
 					if (_recover_from_completion()) {
 						break;
@@ -2605,91 +2574,90 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 					return;
 				}
 
-				if (container->type==Node::TYPE_OPERATOR) {
+				if (container->type == Node::TYPE_OPERATOR) {
 
-					OperatorNode* op = static_cast<OperatorNode*>(container);
-					if (op->op==OperatorNode::OP_CALL && op->arguments[0]->type==Node::TYPE_BUILT_IN_FUNCTION && static_cast<BuiltInFunctionNode*>(op->arguments[0])->function==GDFunctions::GEN_RANGE) {
+					OperatorNode *op = static_cast<OperatorNode *>(container);
+					if (op->op == OperatorNode::OP_CALL && op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && static_cast<BuiltInFunctionNode *>(op->arguments[0])->function == GDFunctions::GEN_RANGE) {
 						//iterating a range, so see if range() can be optimized without allocating memory, by replacing it by vectors (which can work as iterable too!)
 
-						Vector<Node*> args;
+						Vector<Node *> args;
 						Vector<double> constants;
 
-						bool constant=false;
+						bool constant = false;
 
-						for(int i=1;i<op->arguments.size();i++) {
+						for (int i = 1; i < op->arguments.size(); i++) {
 							args.push_back(op->arguments[i]);
-							if (constant && op->arguments[i]->type==Node::TYPE_CONSTANT) {
-								ConstantNode *c = static_cast<ConstantNode*>(op->arguments[i]);
-								if (c->value.get_type()==Variant::REAL || c->value.get_type()==Variant::INT) {
+							if (constant && op->arguments[i]->type == Node::TYPE_CONSTANT) {
+								ConstantNode *c = static_cast<ConstantNode *>(op->arguments[i]);
+								if (c->value.get_type() == Variant::REAL || c->value.get_type() == Variant::INT) {
 									constants.push_back(c->value);
-									constant=true;
+									constant = true;
 								}
 							} else {
-								constant=false;
+								constant = false;
 							}
 						}
 
-						if (args.size()>0 && args.size()<4) {
+						if (args.size() > 0 && args.size() < 4) {
 
 							if (constant) {
 
 								ConstantNode *cn = alloc_node<ConstantNode>();
-								switch(args.size()) {
-									case 1: cn->value=constants[0]; break;
-									case 2: cn->value=Vector2(constants[0],constants[1]); break;
-									case 3: cn->value=Vector3(constants[0],constants[1],constants[2]); break;
+								switch (args.size()) {
+									case 1: cn->value = constants[0]; break;
+									case 2: cn->value = Vector2(constants[0], constants[1]); break;
+									case 3: cn->value = Vector3(constants[0], constants[1], constants[2]); break;
 								}
-								container=cn;
+								container = cn;
 							} else {
 								OperatorNode *on = alloc_node<OperatorNode>();
-								on->op=OperatorNode::OP_CALL;
+								on->op = OperatorNode::OP_CALL;
 
 								TypeNode *tn = alloc_node<TypeNode>();
 								on->arguments.push_back(tn);
 
-								switch(args.size()) {
-									case 1: tn->vtype=Variant::REAL; break;
-									case 2: tn->vtype=Variant::VECTOR2; break;
-									case 3: tn->vtype=Variant::VECTOR3; break;
+								switch (args.size()) {
+									case 1: tn->vtype = Variant::REAL; break;
+									case 2: tn->vtype = Variant::VECTOR2; break;
+									case 3: tn->vtype = Variant::VECTOR3; break;
 								}
 
-								for(int i=0;i<args.size();i++) {
+								for (int i = 0; i < args.size(); i++) {
 									on->arguments.push_back(args[i]);
 								}
 
-								container=on;
+								container = on;
 							}
 						}
 					}
-
 				}
 
 				ControlFlowNode *cf_for = alloc_node<ControlFlowNode>();
 
-				cf_for->cf_type=ControlFlowNode::CF_FOR;
+				cf_for->cf_type = ControlFlowNode::CF_FOR;
 				cf_for->arguments.push_back(id);
 				cf_for->arguments.push_back(container);
 
 				cf_for->body = alloc_node<BlockNode>();
-				cf_for->body->parent_block=p_block;
+				cf_for->body->parent_block = p_block;
 				p_block->sub_blocks.push_back(cf_for->body);
 
 				if (!_enter_indent_block(cf_for->body)) {
 					_set_error("Expected indented block after 'for'");
-					p_block->end_line=tokenizer->get_token_line();
+					p_block->end_line = tokenizer->get_token_line();
 					return;
 				}
 
-				current_block=cf_for->body;
+				current_block = cf_for->body;
 
 				// this is for checking variable for redefining
 				// inside this _parse_block
 				cf_for->body->variables.push_back(id->name);
 				cf_for->body->variable_lines.push_back(id->line);
-				_parse_block(cf_for->body,p_static);
+				_parse_block(cf_for->body, p_static);
 				cf_for->body->variables.remove(0);
 				cf_for->body->variable_lines.remove(0);
-				current_block=p_block;
+				current_block = p_block;
 
 				if (error_set)
 					return;
@@ -2699,7 +2667,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 
 				tokenizer->advance();
 				ControlFlowNode *cf_continue = alloc_node<ControlFlowNode>();
-				cf_continue->cf_type=ControlFlowNode::CF_CONTINUE;
+				cf_continue->cf_type = ControlFlowNode::CF_CONTINUE;
 				p_block->statements.push_back(cf_continue);
 				if (!_end_statement()) {
 					_set_error("Expected end of statement (continue)");
@@ -2710,7 +2678,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 
 				tokenizer->advance();
 				ControlFlowNode *cf_break = alloc_node<ControlFlowNode>();
-				cf_break->cf_type=ControlFlowNode::CF_BREAK;
+				cf_break->cf_type = ControlFlowNode::CF_BREAK;
 				p_block->statements.push_back(cf_break);
 				if (!_end_statement()) {
 					_set_error("Expected end of statement (break)");
@@ -2721,11 +2689,9 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 
 				tokenizer->advance();
 				ControlFlowNode *cf_return = alloc_node<ControlFlowNode>();
-				cf_return->cf_type=ControlFlowNode::CF_RETURN;
+				cf_return->cf_type = ControlFlowNode::CF_RETURN;
 
-
-
-				if (tokenizer->get_token()==GDTokenizer::TK_SEMICOLON || tokenizer->get_token()==GDTokenizer::TK_NEWLINE || tokenizer->get_token()==GDTokenizer::TK_EOF) {
+				if (tokenizer->get_token() == GDTokenizer::TK_SEMICOLON || tokenizer->get_token() == GDTokenizer::TK_NEWLINE || tokenizer->get_token() == GDTokenizer::TK_EOF) {
 					//expect end of statement
 					p_block->statements.push_back(cf_return);
 					if (!_end_statement()) {
@@ -2733,7 +2699,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 					}
 				} else {
 					//expect expression
-					Node *retexpr = _parse_and_reduce_expression(p_block,p_static);
+					Node *retexpr = _parse_and_reduce_expression(p_block, p_static);
 					if (!retexpr) {
 						if (_recover_from_completion()) {
 							break;
@@ -2748,52 +2714,51 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 					}
 				}
 
-
 			} break;
 			case GDTokenizer::TK_CF_MATCH: {
-				
+
 				tokenizer->advance();
-				
+
 				MatchNode *match_node = alloc_node<MatchNode>();
-				
+
 				Node *val_to_match = _parse_and_reduce_expression(p_block, p_static);
-				
+
 				if (!val_to_match) {
 					if (_recover_from_completion()) {
 						break;
 					}
 					return;
 				}
-				
+
 				match_node->val_to_match = val_to_match;
-				
+
 				if (!_enter_indent_block()) {
 					_set_error("Expected indented pattern matching block after 'match'");
 					return;
 				}
-				
+
 				BlockNode *compiled_branches = alloc_node<BlockNode>();
 				compiled_branches->parent_block = p_block;
 				compiled_branches->parent_class = p_block->parent_class;
-				
+
 				p_block->sub_blocks.push_back(compiled_branches);
-				
+
 				_parse_pattern_block(compiled_branches, match_node->branches, p_static);
-				
+
 				_transform_match_statment(compiled_branches, match_node);
-				
+
 				ControlFlowNode *match_cf_node = alloc_node<ControlFlowNode>();
 				match_cf_node->cf_type = ControlFlowNode::CF_MATCH;
 				match_cf_node->match = match_node;
-				
+
 				p_block->statements.push_back(match_cf_node);
-				
+
 				_end_statement();
 			} break;
 			case GDTokenizer::TK_PR_ASSERT: {
 
 				tokenizer->advance();
-				Node *condition = _parse_and_reduce_expression(p_block,p_static);
+				Node *condition = _parse_and_reduce_expression(p_block, p_static);
 				if (!condition) {
 					if (_recover_from_completion()) {
 						break;
@@ -2801,7 +2766,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 					return;
 				}
 				AssertNode *an = alloc_node<AssertNode>();
-				an->condition=condition;
+				an->condition = condition;
 				p_block->statements.push_back(an);
 
 				if (!_end_statement()) {
@@ -2822,7 +2787,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 			} break;
 			default: {
 
-				Node *expression = _parse_and_reduce_expression(p_block,p_static,false,true);
+				Node *expression = _parse_and_reduce_expression(p_block, p_static, false, true);
 				if (!expression) {
 					if (_recover_from_completion()) {
 						break;
@@ -2836,7 +2801,7 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 				}
 
 			} break;
-			/*
+				/*
 			case GDTokenizer::TK_CF_LOCAL: {
 
 				if (tokenizer->get_token(1)!=GDTokenizer::TK_SEMICOLON && tokenizer->get_token(1)!=GDTokenizer::TK_NEWLINE ) {
@@ -2846,37 +2811,35 @@ void GDParser::_parse_block(BlockNode *p_block,bool p_static) {
 				tokenizer->advance();
 			} break;
 			*/
-
 		}
 	}
-
 }
 
 bool GDParser::_parse_newline() {
 
-	if (tokenizer->get_token(1)!=GDTokenizer::TK_EOF && tokenizer->get_token(1)!=GDTokenizer::TK_NEWLINE) {
+	if (tokenizer->get_token(1) != GDTokenizer::TK_EOF && tokenizer->get_token(1) != GDTokenizer::TK_NEWLINE) {
 
 		int indent = tokenizer->get_token_line_indent();
 		int current_indent = tab_level.back()->get();
 
-		if (indent>current_indent) {
+		if (indent > current_indent) {
 			_set_error("Unexpected indent.");
 			return false;
 		}
 
-		if (indent<current_indent) {
+		if (indent < current_indent) {
 
-			while(indent<current_indent) {
+			while (indent < current_indent) {
 
 				//exit block
-				if (tab_level.size()==1) {
+				if (tab_level.size() == 1) {
 					_set_error("Invalid indent. BUG?");
 					return false;
 				}
 
 				tab_level.pop_back();
 
-				if (tab_level.back()->get()<indent) {
+				if (tab_level.back()->get() < indent) {
 
 					_set_error("Unindent does not match any outer indentation level.");
 					return false;
@@ -2891,13 +2854,10 @@ bool GDParser::_parse_newline() {
 
 	tokenizer->advance();
 	return true;
-
 }
 
-
 void GDParser::_parse_extends(ClassNode *p_class) {
 
-
 	if (p_class->extends_used) {
 
 		_set_error("'extends' already used for this class.");
@@ -2910,73 +2870,70 @@ void GDParser::_parse_extends(ClassNode *p_class) {
 		return;
 	}
 
-	p_class->extends_used=true;
+	p_class->extends_used = true;
 
 	tokenizer->advance();
 
-	if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token_type()==Variant::OBJECT) {
+	if (tokenizer->get_token() == GDTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token_type() == Variant::OBJECT) {
 		p_class->extends_class.push_back(Variant::get_type_name(Variant::OBJECT));
 		tokenizer->advance();
 		return;
 	}
 
 	// see if inheritance happens from a file
-	if (tokenizer->get_token()==GDTokenizer::TK_CONSTANT) {
+	if (tokenizer->get_token() == GDTokenizer::TK_CONSTANT) {
 
 		Variant constant = tokenizer->get_token_constant();
-		if (constant.get_type()!=Variant::STRING) {
+		if (constant.get_type() != Variant::STRING) {
 
 			_set_error("'extends' constant must be a string.");
 			return;
 		}
 
-		p_class->extends_file=constant;
+		p_class->extends_file = constant;
 		tokenizer->advance();
 
-		if (tokenizer->get_token()!=GDTokenizer::TK_PERIOD) {
+		if (tokenizer->get_token() != GDTokenizer::TK_PERIOD) {
 			return;
 		} else
 			tokenizer->advance();
-
 	}
 
-	while(true) {
-		if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+	while (true) {
+		if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 
 			_set_error("Invalid 'extends' syntax, expected string constant (path) and/or identifier (parent class).");
 			return;
 		}
 
-		StringName identifier=tokenizer->get_token_identifier();
+		StringName identifier = tokenizer->get_token_identifier();
 		p_class->extends_class.push_back(identifier);
 
 		tokenizer->advance(1);
-		if (tokenizer->get_token()!=GDTokenizer::TK_PERIOD)
+		if (tokenizer->get_token() != GDTokenizer::TK_PERIOD)
 			return;
 	}
-
 }
 
 void GDParser::_parse_class(ClassNode *p_class) {
 
 	int indent_level = tab_level.back()->get();
 
-	while(true) {
+	while (true) {
 
 		GDTokenizer::Token token = tokenizer->get_token();
 		if (error_set)
 			return;
 
-
-		if (indent_level>tab_level.back()->get()) {
-			p_class->end_line=tokenizer->get_token_line();
+		if (indent_level > tab_level.back()->get()) {
+			p_class->end_line = tokenizer->get_token_line();
 			return; //go back a level
 		}
 
-		switch(token) {
+		switch (token) {
 
 			case GDTokenizer::TK_EOF:
-				p_class->end_line=tokenizer->get_token_line();
+				p_class->end_line = tokenizer->get_token_line();
 			case GDTokenizer::TK_ERROR: {
 				return; //go back
 				//end of file!
@@ -2984,7 +2941,7 @@ void GDParser::_parse_class(ClassNode *p_class) {
 			case GDTokenizer::TK_NEWLINE: {
 				if (!_parse_newline()) {
 					if (!error_set) {
-						p_class->end_line=tokenizer->get_token_line();
+						p_class->end_line = tokenizer->get_token_line();
 					}
 					return;
 				}
@@ -3008,7 +2965,7 @@ void GDParser::_parse_class(ClassNode *p_class) {
 					return;
 				}
 
-				p_class->tool=true;
+				p_class->tool = true;
 				tokenizer->advance();
 
 			} break;
@@ -3018,7 +2975,7 @@ void GDParser::_parse_class(ClassNode *p_class) {
 				StringName name;
 				StringName extends;
 
-				if (tokenizer->get_token(1)!=GDTokenizer::TK_IDENTIFIER) {
+				if (tokenizer->get_token(1) != GDTokenizer::TK_IDENTIFIER) {
 
 					_set_error("'class' syntax: 'class <Name>:' or 'class <Name> extends <BaseClass>:'");
 					return;
@@ -3028,16 +2985,15 @@ void GDParser::_parse_class(ClassNode *p_class) {
 
 				ClassNode *newclass = alloc_node<ClassNode>();
 				newclass->initializer = alloc_node<BlockNode>();
-				newclass->initializer->parent_class=newclass;
+				newclass->initializer->parent_class = newclass;
 				newclass->ready = alloc_node<BlockNode>();
-				newclass->ready->parent_class=newclass;
-				newclass->name=name;
-				newclass->owner=p_class;
+				newclass->ready->parent_class = newclass;
+				newclass->name = name;
+				newclass->owner = p_class;
 
 				p_class->subclasses.push_back(newclass);
 
-
-				if (tokenizer->get_token()==GDTokenizer::TK_PR_EXTENDS) {
+				if (tokenizer->get_token() == GDTokenizer::TK_PR_EXTENDS) {
 
 					_parse_extends(newclass);
 					if (error_set)
@@ -3049,9 +3005,9 @@ void GDParser::_parse_class(ClassNode *p_class) {
 					_set_error("Indented block expected.");
 					return;
 				}
-				current_class=newclass;
+				current_class = newclass;
 				_parse_class(newclass);
-				current_class=p_class;
+				current_class = p_class;
 
 			} break;
 			/* this is for functions....
@@ -3062,7 +3018,7 @@ void GDParser::_parse_class(ClassNode *p_class) {
 			*/
 			case GDTokenizer::TK_PR_STATIC: {
 				tokenizer->advance();
-				if (tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) {
+				if (tokenizer->get_token() != GDTokenizer::TK_PR_FUNCTION) {
 
 					_set_error("Expected 'func'.");
 					return;
@@ -3071,42 +3027,38 @@ void GDParser::_parse_class(ClassNode *p_class) {
 			}; //fallthrough to function
 			case GDTokenizer::TK_PR_FUNCTION: {
 
-				bool _static=false;
-				pending_newline=-1;
+				bool _static = false;
+				pending_newline = -1;
 
-				if (tokenizer->get_token(-1)==GDTokenizer::TK_PR_STATIC) {
+				if (tokenizer->get_token(-1) == GDTokenizer::TK_PR_STATIC) {
 
-					_static=true;
+					_static = true;
 				}
 
-
 				tokenizer->advance();
 				StringName name;
 
-				if (_get_completable_identifier(COMPLETION_VIRTUAL_FUNC,name)) {
-
+				if (_get_completable_identifier(COMPLETION_VIRTUAL_FUNC, name)) {
 				}
 
-
-				if (name==StringName()) {
+				if (name == StringName()) {
 
 					_set_error("Expected identifier after 'func' (syntax: 'func <identifier>([arguments]):' ).");
 					return;
 				}
 
-				for(int i=0;i<p_class->functions.size();i++) {
-					if (p_class->functions[i]->name==name) {
-						_set_error("Function '"+String(name)+"' already exists in this class (at line: "+itos(p_class->functions[i]->line)+").");
+				for (int i = 0; i < p_class->functions.size(); i++) {
+					if (p_class->functions[i]->name == name) {
+						_set_error("Function '" + String(name) + "' already exists in this class (at line: " + itos(p_class->functions[i]->line) + ").");
 					}
 				}
-				for(int i=0;i<p_class->static_functions.size();i++) {
-					if (p_class->static_functions[i]->name==name) {
-						_set_error("Function '"+String(name)+"' already exists in this class (at line: "+itos(p_class->static_functions[i]->line)+").");
+				for (int i = 0; i < p_class->static_functions.size(); i++) {
+					if (p_class->static_functions[i]->name == name) {
+						_set_error("Function '" + String(name) + "' already exists in this class (at line: " + itos(p_class->static_functions[i]->line) + ").");
 					}
 				}
 
-
-				if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) {
+				if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_OPEN) {
 
 					_set_error("Expected '(' after identifier (syntax: 'func <identifier>([arguments]):' ).");
 					return;
@@ -3115,39 +3067,37 @@ void GDParser::_parse_class(ClassNode *p_class) {
 				tokenizer->advance();
 
 				Vector<StringName> arguments;
-				Vector<Node*> default_values;
+				Vector<Node *> default_values;
 
 				int fnline = tokenizer->get_token_line();
 
-
-				if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+				if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 					//has arguments
-					bool defaulting=false;
-					while(true) {
+					bool defaulting = false;
+					while (true) {
 
-						if (tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+						if (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 							tokenizer->advance();
 							continue;
 						}
 
-						if (tokenizer->get_token()==GDTokenizer::TK_PR_VAR) {
+						if (tokenizer->get_token() == GDTokenizer::TK_PR_VAR) {
 
 							tokenizer->advance(); //var before the identifier is allowed
 						}
 
-
-						if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+						if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 
 							_set_error("Expected identifier for argument.");
 							return;
 						}
 
-						StringName argname=tokenizer->get_token_identifier();
+						StringName argname = tokenizer->get_token_identifier();
 						arguments.push_back(argname);
 
 						tokenizer->advance();
 
-						if (defaulting && tokenizer->get_token()!=GDTokenizer::TK_OP_ASSIGN) {
+						if (defaulting && tokenizer->get_token() != GDTokenizer::TK_OP_ASSIGN) {
 
 							_set_error("Default parameter expected.");
 							return;
@@ -3155,21 +3105,20 @@ void GDParser::_parse_class(ClassNode *p_class) {
 
 						//tokenizer->advance();
 
-
-						if (tokenizer->get_token()==GDTokenizer::TK_OP_ASSIGN) {
-							defaulting=true;
+						if (tokenizer->get_token() == GDTokenizer::TK_OP_ASSIGN) {
+							defaulting = true;
 							tokenizer->advance(1);
-							Node *defval=NULL;
+							Node *defval = NULL;
 
-							defval=_parse_and_reduce_expression(p_class,_static);
+							defval = _parse_and_reduce_expression(p_class, _static);
 							if (!defval || error_set)
 								return;
 
 							OperatorNode *on = alloc_node<OperatorNode>();
-							on->op=OperatorNode::OP_ASSIGN;
+							on->op = OperatorNode::OP_ASSIGN;
 
 							IdentifierNode *in = alloc_node<IdentifierNode>();
-							in->name=argname;
+							in->name = argname;
 
 							on->arguments.push_back(in);
 							on->arguments.push_back(defval);
@@ -3182,14 +3131,14 @@ void GDParser::_parse_class(ClassNode *p_class) {
 							default_values.push_back(on);
 						}
 
-						while (tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+						while (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 							tokenizer->advance();
 						}
 
-						if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+						if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 							tokenizer->advance();
 							continue;
-						} else if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+						} else if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 
 							_set_error("Expected ',' or ')'.");
 							return;
@@ -3197,68 +3146,63 @@ void GDParser::_parse_class(ClassNode *p_class) {
 
 						break;
 					}
-
-
 				}
 
 				tokenizer->advance();
 
 				BlockNode *block = alloc_node<BlockNode>();
-				block->parent_class=p_class;
+				block->parent_class = p_class;
 
-				if (name=="_init") {
+				if (name == "_init") {
 
 					if (p_class->extends_used) {
 
 						OperatorNode *cparent = alloc_node<OperatorNode>();
-						cparent->op=OperatorNode::OP_PARENT_CALL;
+						cparent->op = OperatorNode::OP_PARENT_CALL;
 						block->statements.push_back(cparent);
 
 						IdentifierNode *id = alloc_node<IdentifierNode>();
-						id->name="_init";
+						id->name = "_init";
 						cparent->arguments.push_back(id);
 
-						if (tokenizer->get_token()==GDTokenizer::TK_PERIOD) {
+						if (tokenizer->get_token() == GDTokenizer::TK_PERIOD) {
 							tokenizer->advance();
-							if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_OPEN) {
+							if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_OPEN) {
 								_set_error("expected '(' for parent constructor arguments.");
 							}
 							tokenizer->advance();
 
-							if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+							if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 								//has arguments
-								parenthesis ++;
-								while(true) {
+								parenthesis++;
+								while (true) {
 
-									Node *arg = _parse_and_reduce_expression(p_class,_static);
+									Node *arg = _parse_and_reduce_expression(p_class, _static);
 									cparent->arguments.push_back(arg);
 
-									if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+									if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 										tokenizer->advance();
 										continue;
-									} else if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+									} else if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 
 										_set_error("Expected ',' or ')'.");
 										return;
 									}
 
 									break;
-
 								}
-								parenthesis --;
+								parenthesis--;
 							}
 
 							tokenizer->advance();
 						}
 					} else {
 
-
-						if (tokenizer->get_token()==GDTokenizer::TK_PERIOD) {
+						if (tokenizer->get_token() == GDTokenizer::TK_PERIOD) {
 
 							_set_error("Parent constructor call found for a class without inheritance.");
 							return;
 						}
-
 					}
 				}
 
@@ -3269,34 +3213,32 @@ void GDParser::_parse_class(ClassNode *p_class) {
 				}
 
 				FunctionNode *function = alloc_node<FunctionNode>();
-				function->name=name;
-				function->arguments=arguments;
-				function->default_values=default_values;
-				function->_static=_static;
-				function->line=fnline;
-
-				function->rpc_mode=rpc_mode;
-				rpc_mode=ScriptInstance::RPC_MODE_DISABLED;
+				function->name = name;
+				function->arguments = arguments;
+				function->default_values = default_values;
+				function->_static = _static;
+				function->line = fnline;
 
+				function->rpc_mode = rpc_mode;
+				rpc_mode = ScriptInstance::RPC_MODE_DISABLED;
 
 				if (_static)
 					p_class->static_functions.push_back(function);
 				else
 					p_class->functions.push_back(function);
 
-
-				current_function=function;
-				function->body=block;
-				current_block=block;
-				_parse_block(block,_static);
-				current_block=NULL;
+				current_function = function;
+				function->body = block;
+				current_block = block;
+				_parse_block(block, _static);
+				current_block = NULL;
 
 				//arguments
 			} break;
 			case GDTokenizer::TK_PR_SIGNAL: {
 				tokenizer->advance();
 
-				if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+				if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 					_set_error("Expected identifier after 'signal'.");
 					return;
 				}
@@ -3305,22 +3247,20 @@ void GDParser::_parse_class(ClassNode *p_class) {
 				sig.name = tokenizer->get_token_identifier();
 				tokenizer->advance();
 
-
-				if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_OPEN) {
+				if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_OPEN) {
 					tokenizer->advance();
-					while(true) {
-						if (tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+					while (true) {
+						if (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 							tokenizer->advance();
 							continue;
 						}
 
-
-						if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) {
+						if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE) {
 							tokenizer->advance();
 							break;
 						}
 
-						if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+						if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 							_set_error("Expected identifier in signal argument.");
 							return;
 						}
@@ -3328,13 +3268,13 @@ void GDParser::_parse_class(ClassNode *p_class) {
 						sig.arguments.push_back(tokenizer->get_token_identifier());
 						tokenizer->advance();
 
-						while (tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
+						while (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
 							tokenizer->advance();
 						}
 
-						if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+						if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 							tokenizer->advance();
-						} else if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+						} else if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 							_set_error("Expected ',' or ')' after signal parameter identifier.");
 							return;
 						}
@@ -3352,33 +3292,33 @@ void GDParser::_parse_class(ClassNode *p_class) {
 
 				tokenizer->advance();
 
-				if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_OPEN) {
+				if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_OPEN) {
 
 					tokenizer->advance();
-					if (tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE) {
+					if (tokenizer->get_token() == GDTokenizer::TK_BUILT_IN_TYPE) {
 
 						Variant::Type type = tokenizer->get_token_type();
-						if (type==Variant::NIL) {
+						if (type == Variant::NIL) {
 							_set_error("Can't export null type.");
 							return;
 						}
-						current_export.type=type;
-						current_export.usage|=PROPERTY_USAGE_SCRIPT_VARIABLE;
+						current_export.type = type;
+						current_export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
 						tokenizer->advance();
-						
-						String hint_prefix ="";
-						
-						if(type == Variant::ARRAY && tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+
+						String hint_prefix = "";
+
+						if (type == Variant::ARRAY && tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 							tokenizer->advance();
 
-							while(tokenizer->get_token()==GDTokenizer::TK_BUILT_IN_TYPE) {
+							while (tokenizer->get_token() == GDTokenizer::TK_BUILT_IN_TYPE) {
 								type = tokenizer->get_token_type();
-								
+
 								tokenizer->advance();
 
-								if(type == Variant::ARRAY) {
-									hint_prefix += itos(Variant::ARRAY)+":";
-									if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+								if (type == Variant::ARRAY) {
+									hint_prefix += itos(Variant::ARRAY) + ":";
+									if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 										tokenizer->advance();
 									}
 								} else {
@@ -3387,56 +3327,54 @@ void GDParser::_parse_class(ClassNode *p_class) {
 								}
 							}
 						}
-						
-						if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+
+						if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 							// hint expected next!
 							tokenizer->advance();
 
-							switch(type) {
-
+							switch (type) {
 
 								case Variant::INT: {
 
-									if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier()=="FLAGS") {
+									if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FLAGS") {
 
 										//current_export.hint=PROPERTY_HINT_ALL_FLAGS;
 										tokenizer->advance();
 
-										if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE) {
 											break;
 										}
-										if (tokenizer->get_token()!=GDTokenizer::TK_COMMA)
-										{
+										if (tokenizer->get_token() != GDTokenizer::TK_COMMA) {
 											_set_error("Expected ')' or ',' in bit flags hint.");
 											return;
 										}
 
-										current_export.hint=PROPERTY_HINT_FLAGS;
+										current_export.hint = PROPERTY_HINT_FLAGS;
 										tokenizer->advance();
 
 										bool first = true;
-										while(true) {
+										while (true) {
 
-											if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type()!=Variant::STRING) {
-												current_export=PropertyInfo();
+											if (tokenizer->get_token() != GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
+												current_export = PropertyInfo();
 												_set_error("Expected a string constant in named bit flags hint.");
 												return;
 											}
 
 											String c = tokenizer->get_token_constant();
 											if (!first)
-												current_export.hint_string+=",";
+												current_export.hint_string += ",";
 											else
-												first=false;
+												first = false;
 
-											current_export.hint_string+=c.xml_escape();
+											current_export.hint_string += c.xml_escape();
 
 											tokenizer->advance();
-											if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE)
+											if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE)
 												break;
 
-											if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) {
-												current_export=PropertyInfo();
+											if (tokenizer->get_token() != GDTokenizer::TK_COMMA) {
+												current_export = PropertyInfo();
 												_set_error("Expected ')' or ',' in named bit flags hint.");
 												return;
 											}
@@ -3446,39 +3384,38 @@ void GDParser::_parse_class(ClassNode *p_class) {
 										break;
 									}
 
-									if (tokenizer->get_token()==GDTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type()==Variant::STRING) {
+									if (tokenizer->get_token() == GDTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
 										//enumeration
-										current_export.hint=PROPERTY_HINT_ENUM;
-										bool first=true;
-										while(true) {
+										current_export.hint = PROPERTY_HINT_ENUM;
+										bool first = true;
+										while (true) {
 
-											if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type()!=Variant::STRING) {
+											if (tokenizer->get_token() != GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
 
-												current_export=PropertyInfo();
+												current_export = PropertyInfo();
 												_set_error("Expected a string constant in enumeration hint.");
 												return;
 											}
 
 											String c = tokenizer->get_token_constant();
 											if (!first)
-												current_export.hint_string+=",";
+												current_export.hint_string += ",";
 											else
-												first=false;
+												first = false;
 
-											current_export.hint_string+=c.xml_escape();
+											current_export.hint_string += c.xml_escape();
 
 											tokenizer->advance();
-											if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE)
+											if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE)
 												break;
 
-											if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) {
-												current_export=PropertyInfo();
+											if (tokenizer->get_token() != GDTokenizer::TK_COMMA) {
+												current_export = PropertyInfo();
 												_set_error("Expected ')' or ',' in enumeration hint.");
 												return;
 											}
 
 											tokenizer->advance();
-
 										}
 
 										break;
@@ -3487,10 +3424,10 @@ void GDParser::_parse_class(ClassNode *p_class) {
 								}; //fallthrough to use the same
 								case Variant::REAL: {
 
-									if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier()=="EASE") {
-										current_export.hint=PROPERTY_HINT_EXP_EASING;
+									if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EASE") {
+										current_export.hint = PROPERTY_HINT_EXP_EASING;
 										tokenizer->advance();
-										if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected ')' in hint.");
 											return;
 										}
@@ -3498,146 +3435,143 @@ void GDParser::_parse_class(ClassNode *p_class) {
 									}
 
 									// range
-									if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier()=="EXP") {
+									if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EXP") {
 
-										current_export.hint=PROPERTY_HINT_EXP_RANGE;
+										current_export.hint = PROPERTY_HINT_EXP_RANGE;
 										tokenizer->advance();
 
-										if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE)
+										if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE)
 											break;
-										else if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) {
+										else if (tokenizer->get_token() != GDTokenizer::TK_COMMA) {
 											_set_error("Expected ')' or ',' in exponential range hint.");
 											return;
 										}
 										tokenizer->advance();
-									}
-									else
-										current_export.hint=PROPERTY_HINT_RANGE;
+									} else
+										current_export.hint = PROPERTY_HINT_RANGE;
 
-									float sign=1.0;
+									float sign = 1.0;
 
-									if (tokenizer->get_token()==GDTokenizer::TK_OP_SUB) {
-										sign=-1;
+									if (tokenizer->get_token() == GDTokenizer::TK_OP_SUB) {
+										sign = -1;
 										tokenizer->advance();
 									}
-									if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
+									if (tokenizer->get_token() != GDTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
 
-										current_export=PropertyInfo();
+										current_export = PropertyInfo();
 										_set_error("Expected a range in numeric hint.");
 										return;
-
 									}
 
-									current_export.hint_string=rtos(sign*double(tokenizer->get_token_constant()));
+									current_export.hint_string = rtos(sign * double(tokenizer->get_token_constant()));
 									tokenizer->advance();
 
-									if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE) {
-										current_export.hint_string="0,"+current_export.hint_string;
+									if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE) {
+										current_export.hint_string = "0," + current_export.hint_string;
 										break;
 									}
 
-									if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) {
+									if (tokenizer->get_token() != GDTokenizer::TK_COMMA) {
 
-										current_export=PropertyInfo();
+										current_export = PropertyInfo();
 										_set_error("Expected ',' or ')' in numeric range hint.");
 										return;
 									}
 
 									tokenizer->advance();
 
-									sign=1.0;
-									if (tokenizer->get_token()==GDTokenizer::TK_OP_SUB) {
-										sign=-1;
+									sign = 1.0;
+									if (tokenizer->get_token() == GDTokenizer::TK_OP_SUB) {
+										sign = -1;
 										tokenizer->advance();
 									}
 
-									if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
+									if (tokenizer->get_token() != GDTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
 
-										current_export=PropertyInfo();
+										current_export = PropertyInfo();
 										_set_error("Expected a number as upper bound in numeric range hint.");
 										return;
 									}
 
-									current_export.hint_string+=","+rtos(sign*double(tokenizer->get_token_constant()));
+									current_export.hint_string += "," + rtos(sign * double(tokenizer->get_token_constant()));
 									tokenizer->advance();
 
-									if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE)
+									if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE)
 										break;
 
-									if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) {
+									if (tokenizer->get_token() != GDTokenizer::TK_COMMA) {
 
-										current_export=PropertyInfo();
+										current_export = PropertyInfo();
 										_set_error("Expected ',' or ')' in numeric range hint.");
 										return;
 									}
 
 									tokenizer->advance();
-									sign=1.0;
-									if (tokenizer->get_token()==GDTokenizer::TK_OP_SUB) {
-										sign=-1;
+									sign = 1.0;
+									if (tokenizer->get_token() == GDTokenizer::TK_OP_SUB) {
+										sign = -1;
 										tokenizer->advance();
 									}
 
-									if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
+									if (tokenizer->get_token() != GDTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
 
-										current_export=PropertyInfo();
+										current_export = PropertyInfo();
 										_set_error("Expected a number as step in numeric range hint.");
 										return;
 									}
 
-									current_export.hint_string+=","+rtos(sign*double(tokenizer->get_token_constant()));
+									current_export.hint_string += "," + rtos(sign * double(tokenizer->get_token_constant()));
 									tokenizer->advance();
 
 								} break;
 								case Variant::STRING: {
 
-									if (tokenizer->get_token()==GDTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type()==Variant::STRING) {
+									if (tokenizer->get_token() == GDTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
 										//enumeration
-										current_export.hint=PROPERTY_HINT_ENUM;
-										bool first=true;
-										while(true) {
+										current_export.hint = PROPERTY_HINT_ENUM;
+										bool first = true;
+										while (true) {
 
-											if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type()!=Variant::STRING) {
+											if (tokenizer->get_token() != GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
 
-												current_export=PropertyInfo();
+												current_export = PropertyInfo();
 												_set_error("Expected a string constant in enumeration hint.");
 												return;
 											}
 
 											String c = tokenizer->get_token_constant();
 											if (!first)
-												current_export.hint_string+=",";
+												current_export.hint_string += ",";
 											else
-												first=false;
+												first = false;
 
-											current_export.hint_string+=c.xml_escape();
+											current_export.hint_string += c.xml_escape();
 											tokenizer->advance();
-											if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE)
+											if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE)
 												break;
 
-											if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) {
-												current_export=PropertyInfo();
+											if (tokenizer->get_token() != GDTokenizer::TK_COMMA) {
+												current_export = PropertyInfo();
 												_set_error("Expected ')' or ',' in enumeration hint.");
 												return;
 											}
 											tokenizer->advance();
-
 										}
 
 										break;
 									}
 
-									if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier()=="DIR") {
+									if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "DIR") {
 
 										tokenizer->advance();
 
-										if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE)
-											current_export.hint=PROPERTY_HINT_DIR;
-										else if (tokenizer->get_token()==GDTokenizer::TK_COMMA ) {
+										if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE)
+											current_export.hint = PROPERTY_HINT_DIR;
+										else if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 
 											tokenizer->advance();
 
-											if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER || !(tokenizer->get_token_identifier()=="GLOBAL")) {
+											if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER || !(tokenizer->get_token_identifier() == "GLOBAL")) {
 												_set_error("Expected 'GLOBAL' after comma in directory hint.");
 												return;
 											}
@@ -3645,42 +3579,41 @@ void GDParser::_parse_class(ClassNode *p_class) {
 												_set_error("Global filesystem hints may only be used in tool scripts.");
 												return;
 											}
-											current_export.hint=PROPERTY_HINT_GLOBAL_DIR;
+											current_export.hint = PROPERTY_HINT_GLOBAL_DIR;
 											tokenizer->advance();
 
-											if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+											if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 												_set_error("Expected ')' in hint.");
 												return;
 											}
-										}
-										else {
+										} else {
 											_set_error("Expected ')' or ',' in hint.");
 											return;
 										}
 										break;
 									}
 
-									if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier()=="FILE") {
+									if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FILE") {
 
-										current_export.hint=PROPERTY_HINT_FILE;
+										current_export.hint = PROPERTY_HINT_FILE;
 										tokenizer->advance();
 
-										if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+										if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 
 											tokenizer->advance();
 
-											if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier()=="GLOBAL") {
+											if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "GLOBAL") {
 
 												if (!p_class->tool) {
 													_set_error("Global filesystem hints may only be used in tool scripts.");
 													return;
 												}
-												current_export.hint=PROPERTY_HINT_GLOBAL_FILE;
+												current_export.hint = PROPERTY_HINT_GLOBAL_FILE;
 												tokenizer->advance();
 
-												if (tokenizer->get_token()==GDTokenizer::TK_PARENTHESIS_CLOSE)
+												if (tokenizer->get_token() == GDTokenizer::TK_PARENTHESIS_CLOSE)
 													break;
-												else if (tokenizer->get_token()==GDTokenizer::TK_COMMA)
+												else if (tokenizer->get_token() == GDTokenizer::TK_COMMA)
 													tokenizer->advance();
 												else {
 													_set_error("Expected ')' or ',' in hint.");
@@ -3688,31 +3621,30 @@ void GDParser::_parse_class(ClassNode *p_class) {
 												}
 											}
 
-											if (tokenizer->get_token()!=GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type()!=Variant::STRING) {
+											if (tokenizer->get_token() != GDTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
 
-												if (current_export.hint==PROPERTY_HINT_GLOBAL_FILE)
+												if (current_export.hint == PROPERTY_HINT_GLOBAL_FILE)
 													_set_error("Expected string constant with filter");
 												else
 													_set_error("Expected 'GLOBAL' or string constant with filter");
 												return;
 											}
-											current_export.hint_string=tokenizer->get_token_constant();
+											current_export.hint_string = tokenizer->get_token_constant();
 											tokenizer->advance();
-
 										}
 
-										if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected ')' in hint.");
 											return;
 										}
 										break;
 									}
 
-									if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier()=="MULTILINE") {
+									if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "MULTILINE") {
 
-										current_export.hint=PROPERTY_HINT_MULTILINE_TEXT;
+										current_export.hint = PROPERTY_HINT_MULTILINE_TEXT;
 										tokenizer->advance();
-										if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected ')' in hint.");
 											return;
 										}
@@ -3721,20 +3653,20 @@ void GDParser::_parse_class(ClassNode *p_class) {
 								} break;
 								case Variant::COLOR: {
 
-									if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER ) {
+									if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 
-										current_export=PropertyInfo();
+										current_export = PropertyInfo();
 										_set_error("Color type hint expects RGB or RGBA as hints");
 										return;
 									}
 
 									String identifier = tokenizer->get_token_identifier();
-									if (identifier=="RGB") {
-										current_export.hint=PROPERTY_HINT_COLOR_NO_ALPHA;
-									} else if (identifier=="RGBA") {
+									if (identifier == "RGB") {
+										current_export.hint = PROPERTY_HINT_COLOR_NO_ALPHA;
+									} else if (identifier == "RGBA") {
 										//none
 									} else {
-										current_export=PropertyInfo();
+										current_export = PropertyInfo();
 										_set_error("Color type hint expects RGB or RGBA as hints");
 										return;
 									}
@@ -3743,54 +3675,51 @@ void GDParser::_parse_class(ClassNode *p_class) {
 								} break;
 								default: {
 
-									current_export=PropertyInfo();
-									_set_error("Type '"+Variant::get_type_name(type)+"' can't take hints.");
+									current_export = PropertyInfo();
+									_set_error("Type '" + Variant::get_type_name(type) + "' can't take hints.");
 									return;
 								} break;
 							}
-							
 						}
-						if(current_export.type == Variant::ARRAY && !hint_prefix.empty()) {
-							if(current_export.hint) {
-								hint_prefix += "/"+itos(current_export.hint);
+						if (current_export.type == Variant::ARRAY && !hint_prefix.empty()) {
+							if (current_export.hint) {
+								hint_prefix += "/" + itos(current_export.hint);
 							}
-							current_export.hint_string=hint_prefix+":"+current_export.hint_string;
-							current_export.hint=PROPERTY_HINT_NONE;
+							current_export.hint_string = hint_prefix + ":" + current_export.hint_string;
+							current_export.hint = PROPERTY_HINT_NONE;
 						}
 
-					} else if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER) {
+					} else if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER) {
 
 						String identifier = tokenizer->get_token_identifier();
-						if (!ClassDB::is_parent_class(identifier,"Resource")) {
+						if (!ClassDB::is_parent_class(identifier, "Resource")) {
 
-							current_export=PropertyInfo();
+							current_export = PropertyInfo();
 							_set_error("Export hint not a type or resource.");
 						}
 
-						current_export.type=Variant::OBJECT;
-						current_export.hint=PROPERTY_HINT_RESOURCE_TYPE;
-						current_export.usage|=PROPERTY_USAGE_SCRIPT_VARIABLE;
+						current_export.type = Variant::OBJECT;
+						current_export.hint = PROPERTY_HINT_RESOURCE_TYPE;
+						current_export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
 
-						current_export.hint_string=identifier;
+						current_export.hint_string = identifier;
 
 						tokenizer->advance();
 					}
 
-					if (tokenizer->get_token()!=GDTokenizer::TK_PARENTHESIS_CLOSE) {
+					if (tokenizer->get_token() != GDTokenizer::TK_PARENTHESIS_CLOSE) {
 
-						current_export=PropertyInfo();
+						current_export = PropertyInfo();
 						_set_error("Expected ')' or ',' after export hint.");
 						return;
-
 					}
 
 					tokenizer->advance();
-
 				}
 
-				if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_ONREADY && tokenizer->get_token()!=GDTokenizer::TK_PR_REMOTE && tokenizer->get_token()!=GDTokenizer::TK_PR_MASTER && tokenizer->get_token()!=GDTokenizer::TK_PR_SLAVE && tokenizer->get_token()!=GDTokenizer::TK_PR_SYNC) {
+				if (tokenizer->get_token() != GDTokenizer::TK_PR_VAR && tokenizer->get_token() != GDTokenizer::TK_PR_ONREADY && tokenizer->get_token() != GDTokenizer::TK_PR_REMOTE && tokenizer->get_token() != GDTokenizer::TK_PR_MASTER && tokenizer->get_token() != GDTokenizer::TK_PR_SLAVE && tokenizer->get_token() != GDTokenizer::TK_PR_SYNC) {
 
-					current_export=PropertyInfo();
+					current_export = PropertyInfo();
 					_set_error("Expected 'var', 'onready', 'remote', 'master', 'slave' or 'sync'.");
 					return;
 				}
@@ -3801,7 +3730,7 @@ void GDParser::_parse_class(ClassNode *p_class) {
 
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
-				if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) {
+				if (tokenizer->get_token() != GDTokenizer::TK_PR_VAR) {
 					_set_error("Expected 'var'.");
 					return;
 				}
@@ -3812,19 +3741,19 @@ void GDParser::_parse_class(ClassNode *p_class) {
 
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
-				if (current_export.type)  {
-					if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) {
+				if (current_export.type) {
+					if (tokenizer->get_token() != GDTokenizer::TK_PR_VAR) {
 						_set_error("Expected 'var'.");
 						return;
 					}
 
 				} else {
-					if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) {
+					if (tokenizer->get_token() != GDTokenizer::TK_PR_VAR && tokenizer->get_token() != GDTokenizer::TK_PR_FUNCTION) {
 						_set_error("Expected 'var' or 'func'.");
 						return;
 					}
 				}
-				rpc_mode=ScriptInstance::RPC_MODE_REMOTE;
+				rpc_mode = ScriptInstance::RPC_MODE_REMOTE;
 
 				continue;
 			} break;
@@ -3832,47 +3761,47 @@ void GDParser::_parse_class(ClassNode *p_class) {
 
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
-				if (current_export.type)  {
-					if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) {
+				if (current_export.type) {
+					if (tokenizer->get_token() != GDTokenizer::TK_PR_VAR) {
 						_set_error("Expected 'var'.");
 						return;
 					}
 
 				} else {
-					if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) {
+					if (tokenizer->get_token() != GDTokenizer::TK_PR_VAR && tokenizer->get_token() != GDTokenizer::TK_PR_FUNCTION) {
 						_set_error("Expected 'var' or 'func'.");
 						return;
 					}
 				}
 
-				rpc_mode=ScriptInstance::RPC_MODE_MASTER;
+				rpc_mode = ScriptInstance::RPC_MODE_MASTER;
 				continue;
 			} break;
 			case GDTokenizer::TK_PR_SLAVE: {
 
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
-				if (current_export.type)  {
-					if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR) {
+				if (current_export.type) {
+					if (tokenizer->get_token() != GDTokenizer::TK_PR_VAR) {
 						_set_error("Expected 'var'.");
 						return;
 					}
 
 				} else {
-					if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) {
+					if (tokenizer->get_token() != GDTokenizer::TK_PR_VAR && tokenizer->get_token() != GDTokenizer::TK_PR_FUNCTION) {
 						_set_error("Expected 'var' or 'func'.");
 						return;
 					}
 				}
 
-				rpc_mode=ScriptInstance::RPC_MODE_SLAVE;
+				rpc_mode = ScriptInstance::RPC_MODE_SLAVE;
 				continue;
 			} break;
 			case GDTokenizer::TK_PR_SYNC: {
 
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
-				if (tokenizer->get_token()!=GDTokenizer::TK_PR_VAR && tokenizer->get_token()!=GDTokenizer::TK_PR_FUNCTION) {
+				if (tokenizer->get_token() != GDTokenizer::TK_PR_VAR && tokenizer->get_token() != GDTokenizer::TK_PR_FUNCTION) {
 					if (current_export.type)
 						_set_error("Expected 'var'.");
 					else
@@ -3880,48 +3809,48 @@ void GDParser::_parse_class(ClassNode *p_class) {
 					return;
 				}
 
-				rpc_mode=ScriptInstance::RPC_MODE_SYNC;
+				rpc_mode = ScriptInstance::RPC_MODE_SYNC;
 				continue;
 			} break;
 			case GDTokenizer::TK_PR_VAR: {
 				//variale declaration and (eventual) initialization
 
 				ClassNode::Member member;
-				bool autoexport = tokenizer->get_token(-1)==GDTokenizer::TK_PR_EXPORT;
-				if (current_export.type!=Variant::NIL) {
-					member._export=current_export;
-					current_export=PropertyInfo();
+				bool autoexport = tokenizer->get_token(-1) == GDTokenizer::TK_PR_EXPORT;
+				if (current_export.type != Variant::NIL) {
+					member._export = current_export;
+					current_export = PropertyInfo();
 				}
 
-				bool onready = tokenizer->get_token(-1)==GDTokenizer::TK_PR_ONREADY;
+				bool onready = tokenizer->get_token(-1) == GDTokenizer::TK_PR_ONREADY;
 
 				tokenizer->advance();
-				if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+				if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 
 					_set_error("Expected identifier for member variable name.");
 					return;
 				}
 
-				member.identifier=tokenizer->get_token_identifier();
-				member.expression=NULL;
-				member._export.name=member.identifier;
-				member.line=tokenizer->get_token_line();
-				member.rpc_mode=rpc_mode;
+				member.identifier = tokenizer->get_token_identifier();
+				member.expression = NULL;
+				member._export.name = member.identifier;
+				member.line = tokenizer->get_token_line();
+				member.rpc_mode = rpc_mode;
 
 				tokenizer->advance();
 
-				rpc_mode=ScriptInstance::RPC_MODE_DISABLED;
+				rpc_mode = ScriptInstance::RPC_MODE_DISABLED;
 
-				if (tokenizer->get_token()==GDTokenizer::TK_OP_ASSIGN) {
+				if (tokenizer->get_token() == GDTokenizer::TK_OP_ASSIGN) {
 
 #ifdef DEBUG_ENABLED
 					int line = tokenizer->get_token_line();
 #endif
 					tokenizer->advance();
 
-					Node *subexpr=NULL;
+					Node *subexpr = NULL;
 
-					subexpr = _parse_and_reduce_expression(p_class,false,autoexport);
+					subexpr = _parse_and_reduce_expression(p_class, false, autoexport);
 					if (!subexpr) {
 						if (_recover_from_completion()) {
 							break;
@@ -3930,24 +3859,23 @@ void GDParser::_parse_class(ClassNode *p_class) {
 					}
 
 					//discourage common error
-					if (!onready && subexpr->type==Node::TYPE_OPERATOR) {
+					if (!onready && subexpr->type == Node::TYPE_OPERATOR) {
 
-						OperatorNode *op=static_cast<OperatorNode*>(subexpr);
-						if (op->op==OperatorNode::OP_CALL && op->arguments[0]->type==Node::TYPE_SELF && op->arguments[1]->type==Node::TYPE_IDENTIFIER) {
-							IdentifierNode *id=static_cast<IdentifierNode*>(op->arguments[1]);
-							if (id->name=="get_node") {
+						OperatorNode *op = static_cast<OperatorNode *>(subexpr);
+						if (op->op == OperatorNode::OP_CALL && op->arguments[0]->type == Node::TYPE_SELF && op->arguments[1]->type == Node::TYPE_IDENTIFIER) {
+							IdentifierNode *id = static_cast<IdentifierNode *>(op->arguments[1]);
+							if (id->name == "get_node") {
 
-								_set_error("Use 'onready var "+String(member.identifier)+" = get_node(..)' instead");
+								_set_error("Use 'onready var " + String(member.identifier) + " = get_node(..)' instead");
 								return;
-
 							}
 						}
 					}
 
-					member.expression=subexpr;
+					member.expression = subexpr;
 
 					if (autoexport) {
-						if (1)/*(subexpr->type==Node::TYPE_ARRAY) {
+						if (1) /*(subexpr->type==Node::TYPE_ARRAY) {
 
 							member._export.type=Variant::ARRAY;
 
@@ -3957,54 +3885,53 @@ void GDParser::_parse_class(ClassNode *p_class) {
 
 						} else*/ {
 
-							if (subexpr->type!=Node::TYPE_CONSTANT) {
+							if (subexpr->type != Node::TYPE_CONSTANT) {
 
 								_set_error("Type-less export needs a constant expression assigned to infer type.");
 								return;
 							}
 
-							ConstantNode *cn = static_cast<ConstantNode*>(subexpr);
-							if (cn->value.get_type()==Variant::NIL) {
+							ConstantNode *cn = static_cast<ConstantNode *>(subexpr);
+							if (cn->value.get_type() == Variant::NIL) {
 
 								_set_error("Can't accept a null constant expression for infering export type.");
 								return;
 							}
-							member._export.type=cn->value.get_type();
-							member._export.usage|=PROPERTY_USAGE_SCRIPT_VARIABLE;
-							if (cn->value.get_type()==Variant::OBJECT) {
+							member._export.type = cn->value.get_type();
+							member._export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
+							if (cn->value.get_type() == Variant::OBJECT) {
 								Object *obj = cn->value;
 								Resource *res = obj->cast_to<Resource>();
-								if(res==NULL) {
+								if (res == NULL) {
 									_set_error("Exported constant not a type or resource.");
 									return;
 								}
-								member._export.hint=PROPERTY_HINT_RESOURCE_TYPE;
-								member._export.hint_string=res->get_class();
+								member._export.hint = PROPERTY_HINT_RESOURCE_TYPE;
+								member._export.hint_string = res->get_class();
 							}
 						}
 					}
 #ifdef TOOLS_ENABLED
-					if (subexpr->type==Node::TYPE_CONSTANT && member._export.type!=Variant::NIL) {
+					if (subexpr->type == Node::TYPE_CONSTANT && member._export.type != Variant::NIL) {
 
-						ConstantNode *cn = static_cast<ConstantNode*>(subexpr);
-						if (cn->value.get_type()!=Variant::NIL) {
-							member.default_value=cn->value;
+						ConstantNode *cn = static_cast<ConstantNode *>(subexpr);
+						if (cn->value.get_type() != Variant::NIL) {
+							member.default_value = cn->value;
 						}
 					}
 #endif
 
 					IdentifierNode *id = alloc_node<IdentifierNode>();
-					id->name=member.identifier;
+					id->name = member.identifier;
 
 					OperatorNode *op = alloc_node<OperatorNode>();
-					op->op=OperatorNode::OP_INIT_ASSIGN;
+					op->op = OperatorNode::OP_INIT_ASSIGN;
 					op->arguments.push_back(id);
 					op->arguments.push_back(subexpr);
 
-
 #ifdef DEBUG_ENABLED
 					NewLineNode *nl = alloc_node<NewLineNode>();
-					nl->line=line;
+					nl->line = line;
 					if (onready)
 						p_class->ready->statements.push_back(nl);
 					else
@@ -4015,8 +3942,6 @@ void GDParser::_parse_class(ClassNode *p_class) {
 					else
 						p_class->initializer->statements.push_back(op);
 
-
-
 				} else {
 
 					if (autoexport) {
@@ -4024,36 +3949,33 @@ void GDParser::_parse_class(ClassNode *p_class) {
 						_set_error("Type-less export needs a constant expression assigned to infer type.");
 						return;
 					}
-
 				}
 
-				if (tokenizer->get_token()==GDTokenizer::TK_PR_SETGET) {
-
+				if (tokenizer->get_token() == GDTokenizer::TK_PR_SETGET) {
 
 					tokenizer->advance();
 
-					if (tokenizer->get_token()!=GDTokenizer::TK_COMMA) {
+					if (tokenizer->get_token() != GDTokenizer::TK_COMMA) {
 						//just comma means using only getter
-						if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+						if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 							_set_error("Expected identifier for setter function after 'notify'.");
 						}
 
-						member.setter=tokenizer->get_token_identifier();
+						member.setter = tokenizer->get_token_identifier();
 
 						tokenizer->advance();
 					}
 
-					if (tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+					if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 						//there is a getter
 						tokenizer->advance();
 
-						if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+						if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 							_set_error("Expected identifier for getter function after ','.");
 						}
 
-						member.getter=tokenizer->get_token_identifier();
+						member.getter = tokenizer->get_token_identifier();
 						tokenizer->advance();
-
 					}
 				}
 
@@ -4070,25 +3992,25 @@ void GDParser::_parse_class(ClassNode *p_class) {
 				ClassNode::Constant constant;
 
 				tokenizer->advance();
-				if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
+				if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
 
 					_set_error("Expected name (identifier) for constant.");
 					return;
 				}
 
-				constant.identifier=tokenizer->get_token_identifier();
+				constant.identifier = tokenizer->get_token_identifier();
 				tokenizer->advance();
 
-				if (tokenizer->get_token()!=GDTokenizer::TK_OP_ASSIGN) {
+				if (tokenizer->get_token() != GDTokenizer::TK_OP_ASSIGN) {
 					_set_error("Constant expects assignment.");
 					return;
 				}
 
 				tokenizer->advance();
 
-				Node *subexpr=NULL;
+				Node *subexpr = NULL;
 
-				subexpr = _parse_and_reduce_expression(p_class,true,true);
+				subexpr = _parse_and_reduce_expression(p_class, true, true);
 				if (!subexpr) {
 					if (_recover_from_completion()) {
 						break;
@@ -4096,10 +4018,10 @@ void GDParser::_parse_class(ClassNode *p_class) {
 					return;
 				}
 
-				if (subexpr->type!=Node::TYPE_CONSTANT) {
+				if (subexpr->type != Node::TYPE_CONSTANT) {
 					_set_error("Expected constant expression");
 				}
-				constant.expression=subexpr;
+				constant.expression = subexpr;
 
 				p_class->constant_expressions.push_back(constant);
 
@@ -4117,46 +4039,46 @@ void GDParser::_parse_class(ClassNode *p_class) {
 				Dictionary enum_dict;
 
 				tokenizer->advance();
-				if (tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER) {
-					enum_name=tokenizer->get_token_identifier();
+				if (tokenizer->get_token() == GDTokenizer::TK_IDENTIFIER) {
+					enum_name = tokenizer->get_token_identifier();
 					tokenizer->advance();
 				}
-				if (tokenizer->get_token()!=GDTokenizer::TK_CURLY_BRACKET_OPEN) {
+				if (tokenizer->get_token() != GDTokenizer::TK_CURLY_BRACKET_OPEN) {
 					_set_error("Expected '{' in enum declaration");
 					return;
 				}
 				tokenizer->advance();
-				
-				while(true) {
-					if(tokenizer->get_token()==GDTokenizer::TK_NEWLINE) {
-						
+
+				while (true) {
+					if (tokenizer->get_token() == GDTokenizer::TK_NEWLINE) {
+
 						tokenizer->advance(); // Ignore newlines
-					} else if (tokenizer->get_token()==GDTokenizer::TK_CURLY_BRACKET_CLOSE) {
-						
+					} else if (tokenizer->get_token() == GDTokenizer::TK_CURLY_BRACKET_CLOSE) {
+
 						tokenizer->advance();
 						break; // End of enum
-					} else if (tokenizer->get_token()!=GDTokenizer::TK_IDENTIFIER) {
-						
-						if(tokenizer->get_token()==GDTokenizer::TK_EOF) {
+					} else if (tokenizer->get_token() != GDTokenizer::TK_IDENTIFIER) {
+
+						if (tokenizer->get_token() == GDTokenizer::TK_EOF) {
 							_set_error("Unexpected end of file.");
 						} else {
 							_set_error(String("Unexpected ") + GDTokenizer::get_token_name(tokenizer->get_token()) + ", expected identifier");
 						}
-						
+
 						return;
 					} else { // tokenizer->get_token()==GDTokenizer::TK_IDENTIFIER
 						ClassNode::Constant constant;
-						
-						constant.identifier=tokenizer->get_token_identifier();
-						
+
+						constant.identifier = tokenizer->get_token_identifier();
+
 						tokenizer->advance();
-						
-						if (tokenizer->get_token()==GDTokenizer::TK_OP_ASSIGN) {
+
+						if (tokenizer->get_token() == GDTokenizer::TK_OP_ASSIGN) {
 							tokenizer->advance();
 
-							Node *subexpr=NULL;
+							Node *subexpr = NULL;
 
-							subexpr = _parse_and_reduce_expression(p_class,true,true);
+							subexpr = _parse_and_reduce_expression(p_class, true, true);
 							if (!subexpr) {
 								if (_recover_from_completion()) {
 									break;
@@ -4164,19 +4086,19 @@ void GDParser::_parse_class(ClassNode *p_class) {
 								return;
 							}
 
-							if (subexpr->type!=Node::TYPE_CONSTANT) {
+							if (subexpr->type != Node::TYPE_CONSTANT) {
 								_set_error("Expected constant expression");
 							}
-							
-							const ConstantNode *subexpr_const = static_cast<const ConstantNode*>(subexpr);
-							
-							if(subexpr_const->value.get_type() != Variant::INT) {
+
+							const ConstantNode *subexpr_const = static_cast<const ConstantNode *>(subexpr);
+
+							if (subexpr_const->value.get_type() != Variant::INT) {
 								_set_error("Expected an int value for enum");
 							}
-							
+
 							last_assign = subexpr_const->value;
-							
-							constant.expression=subexpr;
+
+							constant.expression = subexpr;
 
 						} else {
 							last_assign = last_assign + 1;
@@ -4184,27 +4106,26 @@ void GDParser::_parse_class(ClassNode *p_class) {
 							cn->value = last_assign;
 							constant.expression = cn;
 						}
-						
-						if(tokenizer->get_token()==GDTokenizer::TK_COMMA) {
+
+						if (tokenizer->get_token() == GDTokenizer::TK_COMMA) {
 							tokenizer->advance();
 						}
 
-						if(enum_name != "") {
-							const ConstantNode *cn = static_cast<const ConstantNode*>(constant.expression);
+						if (enum_name != "") {
+							const ConstantNode *cn = static_cast<const ConstantNode *>(constant.expression);
 							enum_dict[constant.identifier] = cn->value;
 						}
 
 						p_class->constant_expressions.push_back(constant);
 					}
-					
 				}
-				
-				if(enum_name != "") {
+
+				if (enum_name != "") {
 					ClassNode::Constant enum_constant;
-					enum_constant.identifier=enum_name;
+					enum_constant.identifier = enum_name;
 					ConstantNode *cn = alloc_node<ConstantNode>();
 					cn->value = enum_dict;
-					enum_constant.expression=cn;
+					enum_constant.expression = cn;
 					p_class->constant_expressions.push_back(enum_constant);
 				}
 
@@ -4213,46 +4134,37 @@ void GDParser::_parse_class(ClassNode *p_class) {
 					return;
 				}
 
-
-				
-
 			} break;
-			
+
 			case GDTokenizer::TK_CONSTANT: {
-				if(tokenizer->get_token_constant().get_type() == Variant::STRING) {
+				if (tokenizer->get_token_constant().get_type() == Variant::STRING) {
 					tokenizer->advance();
 					// Ignore
 				} else {
-					_set_error(String()+"Unexpected constant of type: "+Variant::get_type_name(tokenizer->get_token_constant().get_type()));
+					_set_error(String() + "Unexpected constant of type: " + Variant::get_type_name(tokenizer->get_token_constant().get_type()));
 					return;
 				}
 			} break;
 
 			default: {
 
-				_set_error(String()+"Unexpected token: "+tokenizer->get_token_name(tokenizer->get_token())+":"+tokenizer->get_token_identifier());
+				_set_error(String() + "Unexpected token: " + tokenizer->get_token_name(tokenizer->get_token()) + ":" + tokenizer->get_token_identifier());
 				return;
 
 			} break;
-
 		}
-
 	}
-
-
 }
 
-
-void GDParser::_set_error(const String& p_error, int p_line, int p_column) {
-
+void GDParser::_set_error(const String &p_error, int p_line, int p_column) {
 
 	if (error_set)
 		return; //allow no further errors
 
-	error=p_error;
-	error_line=p_line<0?tokenizer->get_token_line():p_line;
-	error_column=p_column<0?tokenizer->get_token_column():p_column;
-	error_set=true;
+	error = p_error;
+	error_line = p_line < 0 ? tokenizer->get_token_line() : p_line;
+	error_column = p_column < 0 ? tokenizer->get_token_column() : p_column;
+	error_set = true;
 }
 
 String GDParser::get_error() const {
@@ -4269,27 +4181,25 @@ int GDParser::get_error_column() const {
 	return error_column;
 }
 
+Error GDParser::_parse(const String &p_base_path) {
 
-Error GDParser::_parse(const String& p_base_path) {
-
-
-	base_path=p_base_path;
+	base_path = p_base_path;
 
 	clear();
 
 	//assume class
 	ClassNode *main_class = alloc_node<ClassNode>();
 	main_class->initializer = alloc_node<BlockNode>();
-	main_class->initializer->parent_class=main_class;
+	main_class->initializer->parent_class = main_class;
 	main_class->ready = alloc_node<BlockNode>();
-	main_class->ready->parent_class=main_class;
-	current_class=main_class;
+	main_class->ready->parent_class = main_class;
+	current_class = main_class;
 
 	_parse_class(main_class);
 
-	if (tokenizer->get_token()==GDTokenizer::TK_ERROR) {
-		error_set=false;
-		_set_error("Parse Error: "+tokenizer->get_token_error());
+	if (tokenizer->get_token() == GDTokenizer::TK_ERROR) {
+		error_set = false;
+		_set_error("Parse Error: " + tokenizer->get_token_error());
 	}
 
 	if (error_set) {
@@ -4299,60 +4209,59 @@ Error GDParser::_parse(const String& p_base_path) {
 	return OK;
 }
 
-Error GDParser::parse_bytecode(const Vector<uint8_t> &p_bytecode,const String& p_base_path, const String &p_self_path) {
-
-	for_completion=false;
-	validating=false;
-	completion_type=COMPLETION_NONE;
-	completion_node=NULL;
-	completion_class=NULL;
-	completion_function=NULL;
-	completion_block=NULL;
-	completion_found=false;
-	current_block=NULL;
-	current_class=NULL;
-	current_function=NULL;
-
-	self_path=p_self_path;
-	GDTokenizerBuffer *tb = memnew( GDTokenizerBuffer );
+Error GDParser::parse_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_base_path, const String &p_self_path) {
+
+	for_completion = false;
+	validating = false;
+	completion_type = COMPLETION_NONE;
+	completion_node = NULL;
+	completion_class = NULL;
+	completion_function = NULL;
+	completion_block = NULL;
+	completion_found = false;
+	current_block = NULL;
+	current_class = NULL;
+	current_function = NULL;
+
+	self_path = p_self_path;
+	GDTokenizerBuffer *tb = memnew(GDTokenizerBuffer);
 	tb->set_code_buffer(p_bytecode);
-	tokenizer=tb;
+	tokenizer = tb;
 	Error ret = _parse(p_base_path);
 	memdelete(tb);
-	tokenizer=NULL;
+	tokenizer = NULL;
 	return ret;
 }
 
+Error GDParser::parse(const String &p_code, const String &p_base_path, bool p_just_validate, const String &p_self_path, bool p_for_completion) {
 
-Error GDParser::parse(const String& p_code, const String& p_base_path, bool p_just_validate, const String &p_self_path,bool p_for_completion) {
-
-	completion_type=COMPLETION_NONE;
-	completion_node=NULL;
-	completion_class=NULL;
-	completion_function=NULL;
-	completion_block=NULL;
-	completion_found=false;
-	current_block=NULL;
-	current_class=NULL;
+	completion_type = COMPLETION_NONE;
+	completion_node = NULL;
+	completion_class = NULL;
+	completion_function = NULL;
+	completion_block = NULL;
+	completion_found = false;
+	current_block = NULL;
+	current_class = NULL;
 
-	current_function=NULL;
+	current_function = NULL;
 
-	self_path=p_self_path;
-	GDTokenizerText *tt = memnew( GDTokenizerText );
+	self_path = p_self_path;
+	GDTokenizerText *tt = memnew(GDTokenizerText);
 	tt->set_code(p_code);
 
-	validating=p_just_validate;
-	for_completion=p_for_completion;
-	tokenizer=tt;
+	validating = p_just_validate;
+	for_completion = p_for_completion;
+	tokenizer = tt;
 	Error ret = _parse(p_base_path);
 	memdelete(tt);
-	tokenizer=NULL;
+	tokenizer = NULL;
 	return ret;
 }
 
 bool GDParser::is_tool_script() const {
 
-	return (head && head->type==Node::TYPE_CLASS && static_cast<const ClassNode*>(head)->tool);
+	return (head && head->type == Node::TYPE_CLASS && static_cast<const ClassNode *>(head)->tool);
 }
 
 const GDParser::Node *GDParser::get_parse_tree() const {
@@ -4362,44 +4271,42 @@ const GDParser::Node *GDParser::get_parse_tree() const {
 
 void GDParser::clear() {
 
-	while(list) {
+	while (list) {
 
-		Node *l=list;
-		list=list->next;
+		Node *l = list;
+		list = list->next;
 		memdelete(l);
 	}
 
-	head=NULL;
-	list=NULL;
+	head = NULL;
+	list = NULL;
 
-	completion_type=COMPLETION_NONE;
-	completion_node=NULL;
-	completion_class=NULL;
-	completion_function=NULL;
-	completion_block=NULL;
-	current_block=NULL;
-	current_class=NULL;
+	completion_type = COMPLETION_NONE;
+	completion_node = NULL;
+	completion_class = NULL;
+	completion_function = NULL;
+	completion_block = NULL;
+	current_block = NULL;
+	current_class = NULL;
 
-	completion_found=false;
-	rpc_mode=ScriptInstance::RPC_MODE_DISABLED;
+	completion_found = false;
+	rpc_mode = ScriptInstance::RPC_MODE_DISABLED;
 
-	current_function=NULL;
+	current_function = NULL;
 
-	validating=false;
-	for_completion=false;
-	error_set=false;
+	validating = false;
+	for_completion = false;
+	error_set = false;
 	tab_level.clear();
 	tab_level.push_back(0);
-	error_line=0;
-	error_column=0;
-	pending_newline=-1;
-	parenthesis=0;
-	current_export.type=Variant::NIL;
-	error="";
-
+	error_line = 0;
+	error_column = 0;
+	pending_newline = -1;
+	parenthesis = 0;
+	current_export.type = Variant::NIL;
+	error = "";
 }
 
-
 GDParser::CompletionType GDParser::get_completion_type() {
 
 	return completion_type;
@@ -4415,12 +4322,12 @@ int GDParser::get_completion_line() {
 	return completion_line;
 }
 
-Variant::Type GDParser::get_completion_built_in_constant(){
+Variant::Type GDParser::get_completion_built_in_constant() {
 
 	return completion_built_in_constant;
 }
 
-GDParser::Node *GDParser::get_completion_node(){
+GDParser::Node *GDParser::get_completion_node() {
 
 	return completion_node;
 }
@@ -4430,12 +4337,12 @@ GDParser::BlockNode *GDParser::get_completion_block() {
 	return completion_block;
 }
 
-GDParser::ClassNode *GDParser::get_completion_class(){
+GDParser::ClassNode *GDParser::get_completion_class() {
 
 	return completion_class;
 }
 
-GDParser::FunctionNode *GDParser::get_completion_function(){
+GDParser::FunctionNode *GDParser::get_completion_function() {
 
 	return completion_function;
 }
@@ -4452,12 +4359,11 @@ int GDParser::get_completion_identifier_is_function() {
 
 GDParser::GDParser() {
 
-	head=NULL;
-	list=NULL;
-	tokenizer=NULL;
-	pending_newline=-1;
+	head = NULL;
+	list = NULL;
+	tokenizer = NULL;
+	pending_newline = -1;
 	clear();
-
 }
 
 GDParser::~GDParser() {
diff --git a/modules/gdscript/gd_parser.h b/modules/gdscript/gd_parser.h
index 7968bf85df..8d2c136818 100644
--- a/modules/gdscript/gd_parser.h
+++ b/modules/gdscript/gd_parser.h
@@ -29,15 +29,14 @@
 #ifndef GD_PARSER_H
 #define GD_PARSER_H
 
-#include "gd_tokenizer.h"
 #include "gd_functions.h"
+#include "gd_tokenizer.h"
 #include "map.h"
 #include "object.h"
 #include "script_language.h"
 
 class GDParser {
 public:
-
 	struct Node {
 
 		enum Type {
@@ -59,7 +58,7 @@ public:
 			TYPE_NEWLINE,
 		};
 
-		Node * next;
+		Node *next;
 		int line;
 		int column;
 		Type type;
@@ -78,7 +77,6 @@ public:
 		StringName extends_file;
 		Vector<StringName> extends_class;
 
-
 		struct Member {
 			PropertyInfo _export;
 #ifdef TOOLS_ENABLED
@@ -101,11 +99,11 @@ public:
 			Vector<StringName> arguments;
 		};
 
-		Vector<ClassNode*> subclasses;
+		Vector<ClassNode *> subclasses;
 		Vector<Member> variables;
 		Vector<Constant> constant_expressions;
-		Vector<FunctionNode*> functions;
-		Vector<FunctionNode*> static_functions;
+		Vector<FunctionNode *> functions;
+		Vector<FunctionNode *> static_functions;
 		Vector<Signal> _signals;
 		BlockNode *initializer;
 		BlockNode *ready;
@@ -113,74 +111,88 @@ public:
 		//Vector<Node*> initializers;
 		int end_line;
 
-		ClassNode() { tool=false; type=TYPE_CLASS; extends_used=false; end_line=-1; owner=NULL;}
+		ClassNode() {
+			tool = false;
+			type = TYPE_CLASS;
+			extends_used = false;
+			end_line = -1;
+			owner = NULL;
+		}
 	};
 
-
-
 	struct FunctionNode : public Node {
 
 		bool _static;
 		ScriptInstance::RPCMode rpc_mode;
 		StringName name;
 		Vector<StringName> arguments;
-		Vector<Node*> default_values;
+		Vector<Node *> default_values;
 		BlockNode *body;
 
-		FunctionNode() { type=TYPE_FUNCTION; _static=false; rpc_mode=ScriptInstance::RPC_MODE_DISABLED; }
-
+		FunctionNode() {
+			type = TYPE_FUNCTION;
+			_static = false;
+			rpc_mode = ScriptInstance::RPC_MODE_DISABLED;
+		}
 	};
 
 	struct BlockNode : public Node {
 
 		ClassNode *parent_class;
 		BlockNode *parent_block;
-		Map<StringName,int> locals;
-		List<Node*> statements;
+		Map<StringName, int> locals;
+		List<Node *> statements;
 		Vector<StringName> variables;
 		Vector<int> variable_lines;
 
 		//the following is useful for code completion
-		List<BlockNode*> sub_blocks;
+		List<BlockNode *> sub_blocks;
 		int end_line;
-		BlockNode() { type=TYPE_BLOCK; end_line=-1; parent_block=NULL; parent_class=NULL; }
+		BlockNode() {
+			type = TYPE_BLOCK;
+			end_line = -1;
+			parent_block = NULL;
+			parent_class = NULL;
+		}
 	};
 
 	struct TypeNode : public Node {
 
 		Variant::Type vtype;
-		TypeNode() { type=TYPE_TYPE;  }
+		TypeNode() { type = TYPE_TYPE; }
 	};
 	struct BuiltInFunctionNode : public Node {
 		GDFunctions::Function function;
-		BuiltInFunctionNode() { type=TYPE_BUILT_IN_FUNCTION;  }
+		BuiltInFunctionNode() { type = TYPE_BUILT_IN_FUNCTION; }
 	};
 
 	struct IdentifierNode : public Node {
 
 		StringName name;
-		IdentifierNode() { type=TYPE_IDENTIFIER;  }
+		IdentifierNode() { type = TYPE_IDENTIFIER; }
 	};
 
 	struct LocalVarNode : public Node {
 
 		StringName name;
 		Node *assign;
-		LocalVarNode() { type=TYPE_LOCAL_VAR;  assign=NULL;}
+		LocalVarNode() {
+			type = TYPE_LOCAL_VAR;
+			assign = NULL;
+		}
 	};
 
 	struct ConstantNode : public Node {
 		Variant value;
-		ConstantNode() { type=TYPE_CONSTANT; }
+		ConstantNode() { type = TYPE_CONSTANT; }
 	};
 
 	struct ArrayNode : public Node {
 
-		Vector<Node*> elements;
-		ArrayNode() { type=TYPE_ARRAY; }
+		Vector<Node *> elements;
+		ArrayNode() { type = TYPE_ARRAY; }
 	};
 
-
 	struct DictionaryNode : public Node {
 
 		struct Pair {
@@ -190,11 +202,11 @@ public:
 		};
 
 		Vector<Pair> elements;
-		DictionaryNode() { type=TYPE_DICTIONARY; }
+		DictionaryNode() { type = TYPE_DICTIONARY; }
 	};
 
 	struct SelfNode : public Node {
-		SelfNode() { type=TYPE_SELF; }
+		SelfNode() { type = TYPE_SELF; }
 	};
 
 	struct OperatorNode : public Node {
@@ -255,13 +267,12 @@ public:
 
 		Operator op;
 
-		Vector<Node*> arguments;
-		OperatorNode() { type=TYPE_OPERATOR; }
+		Vector<Node *> arguments;
+		OperatorNode() { type = TYPE_OPERATOR; }
 	};
-	
-	
+
 	struct PatternNode : public Node {
-		
+
 		enum PatternType {
 			PT_CONSTANT,
 			PT_BIND,
@@ -270,30 +281,29 @@ public:
 			PT_IGNORE_REST,
 			PT_WILDCARD
 		};
-		
+
 		PatternType pt_type;
-		
+
 		Node *constant;
 		StringName bind;
-		Map<ConstantNode*, PatternNode*> dictionary;
-		Vector<PatternNode*> array;
-		
+		Map<ConstantNode *, PatternNode *> dictionary;
+		Vector<PatternNode *> array;
 	};
-	
+
 	struct PatternBranchNode : public Node {
-		Vector<PatternNode*> patterns;
+		Vector<PatternNode *> patterns;
 		BlockNode *body;
 	};
-	
+
 	struct MatchNode : public Node {
 		Node *val_to_match;
-		Vector<PatternBranchNode*> branches;
-		
+		Vector<PatternBranchNode *> branches;
+
 		struct CompiledPatternBranch {
 			Node *compiled_pattern;
 			BlockNode *body;
 		};
-		
+
 		Vector<CompiledPatternBranch> compiled_pattern_branches;
 	};
 
@@ -310,30 +320,34 @@ public:
 		};
 
 		CFType cf_type;
-		Vector<Node*> arguments;
+		Vector<Node *> arguments;
 		BlockNode *body;
 		BlockNode *body_else;
-		
+
 		MatchNode *match;
 
 		ControlFlowNode *_else; //used for if
-		ControlFlowNode() { type=TYPE_CONTROL_FLOW; cf_type=CF_IF; body=NULL; body_else=NULL;}
+		ControlFlowNode() {
+			type = TYPE_CONTROL_FLOW;
+			cf_type = CF_IF;
+			body = NULL;
+			body_else = NULL;
+		}
 	};
 
 	struct AssertNode : public Node {
-		Node* condition;
-		AssertNode() { type=TYPE_ASSERT; }
+		Node *condition;
+		AssertNode() { type = TYPE_ASSERT; }
 	};
 
 	struct BreakpointNode : public Node {
-		BreakpointNode() { type=TYPE_BREAKPOINT; }
+		BreakpointNode() { type = TYPE_BREAKPOINT; }
 	};
 
 	struct NewLineNode : public Node {
-		NewLineNode() { type=TYPE_NEWLINE; }
+		NewLineNode() { type = TYPE_NEWLINE; }
 	};
 
-
 	struct Expression {
 
 		bool is_op;
@@ -343,8 +357,7 @@ public:
 		};
 	};
 
-
-/*
+	/*
 	struct OperatorNode : public Node {
 
 		DataType return_cache;
@@ -428,18 +441,13 @@ public:
 		COMPLETION_YIELD,
 	};
 
-
-
 private:
-
-
 	GDTokenizer *tokenizer;
 
-
 	Node *head;
 	Node *list;
-	template<class T>
-	T* alloc_node();
+	template <class T>
+	T *alloc_node();
 
 	bool validating;
 	bool for_completion;
@@ -456,12 +464,11 @@ private:
 	String base_path;
 	String self_path;
 
-
 	ClassNode *current_class;
 	FunctionNode *current_function;
 	BlockNode *current_block;
 
-	bool _get_completable_identifier(CompletionType p_type,StringName& identifier);
+	bool _get_completable_identifier(CompletionType p_type, StringName &identifier);
 	void _make_completable_call(int p_arg);
 
 	CompletionType completion_type;
@@ -481,41 +488,34 @@ private:
 
 	ScriptInstance::RPCMode rpc_mode;
 
-
-	void _set_error(const String& p_error, int p_line=-1, int p_column=-1);
+	void _set_error(const String &p_error, int p_line = -1, int p_column = -1);
 	bool _recover_from_completion();
 
-
-	bool _parse_arguments(Node* p_parent, Vector<Node*>& p_args, bool p_static, bool p_can_codecomplete=false);
-	bool _enter_indent_block(BlockNode *p_block=NULL);
+	bool _parse_arguments(Node *p_parent, Vector<Node *> &p_args, bool p_static, bool p_can_codecomplete = false);
+	bool _enter_indent_block(BlockNode *p_block = NULL);
 	bool _parse_newline();
-	Node* _parse_expression(Node *p_parent, bool p_static, bool p_allow_assign=false, bool p_parsing_constant=false);
-	Node* _reduce_expression(Node *p_node,bool p_to_const=false);
-	Node* _parse_and_reduce_expression(Node *p_parent,bool p_static,bool p_reduce_const=false,bool p_allow_assign=false);
+	Node *_parse_expression(Node *p_parent, bool p_static, bool p_allow_assign = false, bool p_parsing_constant = false);
+	Node *_reduce_expression(Node *p_node, bool p_to_const = false);
+	Node *_parse_and_reduce_expression(Node *p_parent, bool p_static, bool p_reduce_const = false, bool p_allow_assign = false);
 
-	
-	
-	
 	PatternNode *_parse_pattern(bool p_static);
-	void _parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode*> &p_branches, bool p_static);
+	void _parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode *> &p_branches, bool p_static);
 	void _transform_match_statment(BlockNode *p_block, MatchNode *p_match_statement);
-	void _generate_pattern(PatternNode *p_pattern, Node *p_node_to_match, Node *&p_resulting_node, Map<StringName, Node*> &p_bindings);
-	
-	
-	void _parse_block(BlockNode *p_block,bool p_static);
+	void _generate_pattern(PatternNode *p_pattern, Node *p_node_to_match, Node *&p_resulting_node, Map<StringName, Node *> &p_bindings);
+
+	void _parse_block(BlockNode *p_block, bool p_static);
 	void _parse_extends(ClassNode *p_class);
 	void _parse_class(ClassNode *p_class);
 	bool _end_statement();
 
-	Error _parse(const String& p_base_path);
+	Error _parse(const String &p_base_path);
 
 public:
-
 	String get_error() const;
 	int get_error_line() const;
 	int get_error_column() const;
-	Error parse(const String& p_code, const String& p_base_path="", bool p_just_validate=false,const String& p_self_path="",bool p_for_completion=false);
-	Error parse_bytecode(const Vector<uint8_t> &p_bytecode,const String& p_base_path="",const String& p_self_path="");
+	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 parse_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_base_path = "", const String &p_self_path = "");
 
 	bool is_tool_script() const;
 	const Node *get_parse_tree() const;
diff --git a/modules/gdscript/gd_script.cpp b/modules/gdscript/gd_script.cpp
index 4e72bc39a4..e1cc75acfc 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;
 }
diff --git a/modules/gdscript/gd_script.h b/modules/gdscript/gd_script.h
index 4d3baa5bc0..d64cc9798d 100644
--- a/modules/gdscript/gd_script.h
+++ b/modules/gdscript/gd_script.h
@@ -29,50 +29,45 @@
 #ifndef GD_SCRIPT_H
 #define GD_SCRIPT_H
 
-#include "script_language.h"
+#include "gd_function.h"
 #include "io/resource_loader.h"
 #include "io/resource_saver.h"
-#include "gd_function.h"
+#include "script_language.h"
 class GDNativeClass : public Reference {
 
-	GDCLASS(GDNativeClass,Reference);
+	GDCLASS(GDNativeClass, Reference);
 
 	StringName name;
-protected:
 
-	bool _get(const StringName& p_name,Variant &r_ret) const;
+protected:
+	bool _get(const StringName &p_name, Variant &r_ret) const;
 	static void _bind_methods();
 
 public:
-
-	_FORCE_INLINE_ const StringName& get_name() const { return name; }
+	_FORCE_INLINE_ const StringName &get_name() const { return name; }
 	Variant _new();
 	Object *instance();
-	GDNativeClass(const StringName& p_name);
+	GDNativeClass(const StringName &p_name);
 };
 
-
 class GDScript : public Script {
 
-
-	GDCLASS(GDScript,Script);
+	GDCLASS(GDScript, Script);
 	bool tool;
 	bool valid;
 
-
 	struct MemberInfo {
 		int index;
 		StringName setter;
 		StringName getter;
 		ScriptInstance::RPCMode rpc_mode;
-
 	};
 
-friend class GDInstance;
-friend class GDFunction;
-friend class GDCompiler;
-friend class GDFunctions;
-friend class GDScriptLanguage;
+	friend class GDInstance;
+	friend class GDFunction;
+	friend class GDCompiler;
+	friend class GDFunctions;
+	friend class GDScriptLanguage;
 
 	Variant _static_ref; //used for static call
 	Ref<GDNativeClass> native;
@@ -81,130 +76,125 @@ friend class GDScriptLanguage;
 	GDScript *_owner; //for subclasses
 
 	Set<StringName> members; //members are just indices to the instanced script.
-	Map<StringName,Variant> constants;
-	Map<StringName,GDFunction*> member_functions;
-	Map<StringName,MemberInfo> member_indices; //members are just indices to the instanced script.
-	Map<StringName,Ref<GDScript> > subclasses;
-	Map<StringName,Vector<StringName> > _signals;
-
+	Map<StringName, Variant> constants;
+	Map<StringName, GDFunction *> member_functions;
+	Map<StringName, MemberInfo> member_indices; //members are just indices to the instanced script.
+	Map<StringName, Ref<GDScript> > subclasses;
+	Map<StringName, Vector<StringName> > _signals;
 
 #ifdef TOOLS_ENABLED
 
-	Map<StringName,int> member_lines;
+	Map<StringName, int> member_lines;
 
-	Map<StringName,Variant> member_default_values;
+	Map<StringName, Variant> member_default_values;
 
 	List<PropertyInfo> members_cache;
-	Map<StringName,Variant> member_default_values_cache;
+	Map<StringName, Variant> member_default_values_cache;
 	Ref<GDScript> base_cache;
 	Set<ObjectID> inheriters_cache;
 	bool source_changed_cache;
-	void _update_exports_values(Map<StringName,Variant>& values, List<PropertyInfo> &propnames);
+	void _update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames);
 
 #endif
-	Map<StringName,PropertyInfo> member_info;
+	Map<StringName, PropertyInfo> member_info;
 
 	GDFunction *initializer; //direct pointer to _init , faster to locate
 
 	int subclass_count;
-	Set<Object*> instances;
+	Set<Object *> instances;
 	//exported members
 	String source;
 	String path;
 	String name;
 	SelfList<GDScript> script_list;
 
+	GDInstance *_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_isref, Variant::CallError &r_error);
 
-	GDInstance* _create_instance(const Variant** p_args,int p_argcount,Object *p_owner,bool p_isref,Variant::CallError &r_error);
-
-	void _set_subclass_path(Ref<GDScript>& p_sc,const String& p_path);
+	void _set_subclass_path(Ref<GDScript> &p_sc, const String &p_path);
 
 #ifdef TOOLS_ENABLED
-	Set<PlaceHolderScriptInstance*> placeholders;
+	Set<PlaceHolderScriptInstance *> placeholders;
 	//void _update_placeholder(PlaceHolderScriptInstance *p_placeholder);
 	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder);
 #endif
 
 #ifdef DEBUG_ENABLED
 
-	Map<ObjectID,List<Pair<StringName,Variant> > > pending_reload_state;
+	Map<ObjectID, List<Pair<StringName, Variant> > > pending_reload_state;
 
 #endif
 
 	bool _update_exports();
 
 protected:
-	bool _get(const StringName& p_name,Variant &r_ret) const;
-	bool _set(const StringName& p_name, const Variant& p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	bool _set(const StringName &p_name, const Variant &p_value);
 	void _get_property_list(List<PropertyInfo> *p_properties) const;
 
-	Variant call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error);
+	Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error);
 	//void call_multilevel(const StringName& p_method,const Variant** p_args,int p_argcount);
 
 	static void _bind_methods();
-public:
 
+public:
 	bool is_valid() const { return valid; }
 
-	const Map<StringName,Ref<GDScript> >& get_subclasses() const { return subclasses; }
-	const Map<StringName,Variant >& get_constants() const { return constants; }
-	const Set<StringName>& get_members() const { return members; }
-	const Map<StringName,GDFunction*>& get_member_functions() const { return member_functions; }
-	const Ref<GDNativeClass>& get_native() const { return native; }
+	const Map<StringName, Ref<GDScript> > &get_subclasses() const { return subclasses; }
+	const Map<StringName, Variant> &get_constants() const { return constants; }
+	const Set<StringName> &get_members() const { return members; }
+	const Map<StringName, GDFunction *> &get_member_functions() const { return member_functions; }
+	const Ref<GDNativeClass> &get_native() const { return native; }
 
-	virtual bool has_script_signal(const StringName& p_signal) const;
+	virtual bool has_script_signal(const StringName &p_signal) const;
 	virtual void get_script_signal_list(List<MethodInfo> *r_signals) const;
 
-
 	bool is_tool() const { return tool; }
 	Ref<GDScript> get_base() const;
 
-	const Map<StringName,MemberInfo>& debug_get_member_indices() const { return member_indices; }
-	const Map<StringName,GDFunction*>& debug_get_member_functions() const; //this is debug only
+	const Map<StringName, MemberInfo> &debug_get_member_indices() const { return member_indices; }
+	const Map<StringName, GDFunction *> &debug_get_member_functions() const; //this is debug only
 	StringName debug_get_member_by_index(int p_idx) const;
 
-	Variant _new(const Variant** p_args,int p_argcount,Variant::CallError& r_error);
+	Variant _new(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
 	virtual bool can_instance() const;
 
 	virtual Ref<Script> get_base_script() const;
 
 	virtual StringName get_instance_base_type() const; // this may not work in all scripts, will return empty if so
-	virtual ScriptInstance* instance_create(Object *p_this);
+	virtual ScriptInstance *instance_create(Object *p_this);
 	virtual bool instance_has(const Object *p_this) const;
 
 	virtual bool has_source_code() const;
 	virtual String get_source_code() const;
-	virtual void set_source_code(const String& p_code);
+	virtual void set_source_code(const String &p_code);
 	virtual void update_exports();
 
-	virtual Error reload(bool p_keep_state=false);
+	virtual Error reload(bool p_keep_state = false);
 
 	virtual String get_node_type() const;
-	void set_script_path(const String& p_path) { path=p_path; } //because subclasses need a path too...
-	Error load_source_code(const String& p_path);
-	Error load_byte_code(const String& p_path);
+	void set_script_path(const String &p_path) { path = p_path; } //because subclasses need a path too...
+	Error load_source_code(const String &p_path);
+	Error load_byte_code(const String &p_path);
 
 	Vector<uint8_t> get_as_byte_code() const;
 
-	bool get_property_default_value(const StringName& p_property,Variant& r_value) const;
+	bool get_property_default_value(const StringName &p_property, Variant &r_value) const;
 
 	virtual void get_script_method_list(List<MethodInfo> *p_list) const;
-	virtual bool has_method(const StringName& p_method) const;
-	virtual MethodInfo get_method_info(const StringName& p_method) const;
+	virtual bool has_method(const StringName &p_method) const;
+	virtual MethodInfo get_method_info(const StringName &p_method) const;
 
 	virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
 
-
 	virtual ScriptLanguage *get_language() const;
 
-	virtual int get_member_line(const StringName& p_member) const {
+	virtual int get_member_line(const StringName &p_member) const {
 #ifdef TOOLS_ENABLED
 		if (member_lines.has(p_member))
 			return member_lines[p_member];
 		else
 #endif
 			return -1;
-
 	}
 
 	GDScript();
@@ -212,37 +202,34 @@ public:
 };
 
 class GDInstance : public ScriptInstance {
-friend class GDScript;
-friend class GDFunction;
-friend class GDFunctions;
-friend class GDCompiler;
+	friend class GDScript;
+	friend class GDFunction;
+	friend class GDFunctions;
+	friend class GDCompiler;
 
 	Object *owner;
 	Ref<GDScript> script;
 #ifdef DEBUG_ENABLED
-	Map<StringName,int> member_indices_cache; //used only for hot script reloading
+	Map<StringName, int> member_indices_cache; //used only for hot script reloading
 #endif
 	Vector<Variant> members;
 	bool base_ref;
 
-
-	void _ml_call_reversed(GDScript *sptr,const StringName& p_method,const Variant** p_args,int p_argcount);
+	void _ml_call_reversed(GDScript *sptr, const StringName &p_method, const Variant **p_args, int p_argcount);
 
 public:
+	_FORCE_INLINE_ Object *get_owner() { return owner; }
 
-	_FORCE_INLINE_ Object* get_owner() { return owner; }
-
-	virtual bool set(const StringName& p_name, const Variant& p_value);
-	virtual bool get(const StringName& p_name, Variant &r_ret) const;
+	virtual bool set(const StringName &p_name, const Variant &p_value);
+	virtual bool get(const StringName &p_name, Variant &r_ret) const;
 	virtual void get_property_list(List<PropertyInfo> *p_properties) const;
-	virtual Variant::Type get_property_type(const StringName& p_name,bool *r_is_valid=NULL) const;
-
+	virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = NULL) const;
 
 	virtual void get_method_list(List<MethodInfo> *p_list) const;
-	virtual bool has_method(const StringName& p_method) const;
-	virtual Variant call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error);
-	virtual void call_multilevel(const StringName& p_method,const Variant** p_args,int p_argcount);
-	virtual void call_multilevel_reversed(const StringName& p_method,const Variant** p_args,int p_argcount);
+	virtual bool has_method(const StringName &p_method) const;
+	virtual Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+	virtual void call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount);
+	virtual void call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount);
 
 	Variant debug_get_member_by_index(int p_idx) const { return members[p_idx]; }
 
@@ -252,27 +239,24 @@ public:
 
 	virtual ScriptLanguage *get_language();
 
-	void set_path(const String& p_path);
+	void set_path(const String &p_path);
 
 	void reload_members();
 
-	virtual RPCMode get_rpc_mode(const StringName& p_method) const;
-	virtual RPCMode get_rset_mode(const StringName& p_variable) const;
-
+	virtual RPCMode get_rpc_mode(const StringName &p_method) const;
+	virtual RPCMode get_rset_mode(const StringName &p_variable) const;
 
 	GDInstance();
 	~GDInstance();
-
 };
 
 class GDScriptLanguage : public ScriptLanguage {
 
 	static GDScriptLanguage *singleton;
 
-	Variant* _global_array;
+	Variant *_global_array;
 	Vector<Variant> global_array;
-	Map<StringName,int> globals;
-
+	Map<StringName, int> globals;
 
 	struct CallLevel {
 
@@ -281,10 +265,8 @@ class GDScriptLanguage : public ScriptLanguage {
 		GDInstance *instance;
 		int *ip;
 		int *line;
-
 	};
 
-
 	int _debug_parse_err_line;
 	String _debug_parse_err_file;
 	String _debug_error;
@@ -292,65 +274,61 @@ class GDScriptLanguage : public ScriptLanguage {
 	int _debug_max_call_stack;
 	CallLevel *_call_stack;
 
-	void _add_global(const StringName& p_name,const Variant& p_value);
+	void _add_global(const StringName &p_name, const Variant &p_value);
 
-friend class GDInstance;
+	friend class GDInstance;
 
 	Mutex *lock;
 
-
-
-
-friend class GDScript;
+	friend class GDScript;
 
 	SelfList<GDScript>::List script_list;
-friend class GDFunction;
+	friend class GDFunction;
 
 	SelfList<GDFunction>::List function_list;
 	bool profiling;
 	uint64_t script_frame_time;
-public:
-
 
+public:
 	int calls;
 
-	bool debug_break(const String& p_error,bool p_allow_continue=true);
-	bool debug_break_parse(const String& p_file, int p_line,const String& p_error);
+	bool debug_break(const String &p_error, bool p_allow_continue = true);
+	bool debug_break_parse(const String &p_file, int p_line, const String &p_error);
 
-	_FORCE_INLINE_ void enter_function(GDInstance *p_instance,GDFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) {
+	_FORCE_INLINE_ void enter_function(GDInstance *p_instance, GDFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) {
 
-		if (Thread::get_main_ID()!=Thread::get_caller_ID())
+		if (Thread::get_main_ID() != Thread::get_caller_ID())
 			return; //no support for other threads than main for now
 
-		if (ScriptDebugger::get_singleton()->get_lines_left()>0 && ScriptDebugger::get_singleton()->get_depth()>=0)
-			ScriptDebugger::get_singleton()->set_depth( ScriptDebugger::get_singleton()->get_depth() +1 );
+		if (ScriptDebugger::get_singleton()->get_lines_left() > 0 && ScriptDebugger::get_singleton()->get_depth() >= 0)
+			ScriptDebugger::get_singleton()->set_depth(ScriptDebugger::get_singleton()->get_depth() + 1);
 
 		if (_debug_call_stack_pos >= _debug_max_call_stack) {
 			//stack overflow
-			_debug_error="Stack Overflow (Stack Size: "+itos(_debug_max_call_stack)+")";
+			_debug_error = "Stack Overflow (Stack Size: " + itos(_debug_max_call_stack) + ")";
 			ScriptDebugger::get_singleton()->debug(this);
 			return;
 		}
 
-		_call_stack[_debug_call_stack_pos].stack=p_stack;
-		_call_stack[_debug_call_stack_pos].instance=p_instance;
-		_call_stack[_debug_call_stack_pos].function=p_function;
-		_call_stack[_debug_call_stack_pos].ip=p_ip;
-		_call_stack[_debug_call_stack_pos].line=p_line;
+		_call_stack[_debug_call_stack_pos].stack = p_stack;
+		_call_stack[_debug_call_stack_pos].instance = p_instance;
+		_call_stack[_debug_call_stack_pos].function = p_function;
+		_call_stack[_debug_call_stack_pos].ip = p_ip;
+		_call_stack[_debug_call_stack_pos].line = p_line;
 		_debug_call_stack_pos++;
 	}
 
 	_FORCE_INLINE_ void exit_function() {
 
-		if (Thread::get_main_ID()!=Thread::get_caller_ID())
+		if (Thread::get_main_ID() != Thread::get_caller_ID())
 			return; //no support for other threads than main for now
 
-		if (ScriptDebugger::get_singleton()->get_lines_left()>0 && ScriptDebugger::get_singleton()->get_depth()>=0)
-			ScriptDebugger::get_singleton()->set_depth( ScriptDebugger::get_singleton()->get_depth() -1 );
+		if (ScriptDebugger::get_singleton()->get_lines_left() > 0 && ScriptDebugger::get_singleton()->get_depth() >= 0)
+			ScriptDebugger::get_singleton()->set_depth(ScriptDebugger::get_singleton()->get_depth() - 1);
 
-		if (_debug_call_stack_pos==0) {
+		if (_debug_call_stack_pos == 0) {
 
-			_debug_error="Stack Underflow (Engine Bug)";
+			_debug_error = "Stack Underflow (Engine Bug)";
 			ScriptDebugger::get_singleton()->debug(this);
 			return;
 		}
@@ -358,16 +336,15 @@ public:
 		_debug_call_stack_pos--;
 	}
 
-
 	virtual Vector<StackInfo> debug_get_current_stack_info() {
-		if (Thread::get_main_ID()!=Thread::get_caller_ID())
+		if (Thread::get_main_ID() != Thread::get_caller_ID())
 			return Vector<StackInfo>();
 
 		Vector<StackInfo> csi;
 		csi.resize(_debug_call_stack_pos);
-		for(int i=0;i<_debug_call_stack_pos;i++) {
-			csi[_debug_call_stack_pos-i-1].line=_call_stack[i].line?*_call_stack[i].line:0;
-			csi[_debug_call_stack_pos-i-1].script=Ref<GDScript>(_call_stack[i].function->get_script());
+		for (int i = 0; i < _debug_call_stack_pos; i++) {
+			csi[_debug_call_stack_pos - i - 1].line = _call_stack[i].line ? *_call_stack[i].line : 0;
+			csi[_debug_call_stack_pos - i - 1].script = Ref<GDScript>(_call_stack[i].function->get_script());
 		}
 		return csi;
 	}
@@ -383,10 +360,9 @@ public:
 
 	} strings;
 
-
 	_FORCE_INLINE_ int get_global_array_size() const { return global_array.size(); }
-	_FORCE_INLINE_ Variant* get_global_array() { return _global_array; }
-	_FORCE_INLINE_ const Map<StringName,int>& get_global_map() { return globals; }
+	_FORCE_INLINE_ Variant *get_global_array() { return _global_array; }
+	_FORCE_INLINE_ const Map<StringName, int> &get_global_map() { return globals; }
 
 	_FORCE_INLINE_ static GDScriptLanguage *get_singleton() { return singleton; }
 
@@ -396,26 +372,25 @@ public:
 	virtual void init();
 	virtual String get_type() const;
 	virtual String get_extension() const;
-	virtual Error execute_file(const String& p_path) ;
+	virtual Error execute_file(const String &p_path);
 	virtual void finish();
 
 	/* EDITOR FUNCTIONS */
 	virtual void get_reserved_words(List<String> *p_words) const;
 	virtual void get_comment_delimiters(List<String> *p_delimiters) const;
 	virtual void get_string_delimiters(List<String> *p_delimiters) const;
-	virtual Ref<Script> get_template(const String& p_class_name, const String& p_base_class_name) const;
-	virtual bool 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=NULL) const;
+	virtual Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const;
+	virtual bool 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 = NULL) const;
 	virtual Script *create_script() const;
 	virtual bool has_named_classes() const;
-	virtual int find_function(const String& p_function,const String& p_code) const;
-	virtual String make_function(const String& p_class,const String& p_name,const PoolStringArray& p_args) const;
-	virtual Error complete_code(const String& p_code, const String& p_base_path, Object*p_owner,List<String>* r_options,String& r_call_hint);
+	virtual int find_function(const String &p_function, const String &p_code) const;
+	virtual String make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const;
+	virtual Error complete_code(const String &p_code, const String &p_base_path, Object *p_owner, List<String> *r_options, String &r_call_hint);
 #ifdef TOOLS_ENABLED
-	virtual Error lookup_code(const String& p_code, const String& p_symbol, const String& p_base_path, Object*p_owner, LookupResult& r_result);
+	virtual Error lookup_code(const String &p_code, const String &p_symbol, const String &p_base_path, Object *p_owner, LookupResult &r_result);
 #endif
-	virtual void auto_indent_code(String& p_code,int p_from_line,int p_to_line) const;
-	virtual void add_global_constant(const StringName& p_variable,const Variant& p_value);
-
+	virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const;
+	virtual void add_global_constant(const StringName &p_variable, const Variant &p_value);
 
 	/* DEBUGGER FUNCTIONS */
 
@@ -424,24 +399,24 @@ public:
 	virtual int debug_get_stack_level_line(int p_level) const;
 	virtual String debug_get_stack_level_function(int p_level) const;
 	virtual String debug_get_stack_level_source(int p_level) const;
-	virtual void debug_get_stack_level_locals(int p_level,List<String> *p_locals, List<Variant> *p_values, int p_max_subitems=-1,int p_max_depth=-1);
-	virtual void debug_get_stack_level_members(int p_level,List<String> *p_members, List<Variant> *p_values, int p_max_subitems=-1,int p_max_depth=-1);
-	virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems=-1,int p_max_depth=-1);
-	virtual String debug_parse_stack_level_expression(int p_level,const String& p_expression,int p_max_subitems=-1,int p_max_depth=-1);
+	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
+	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
+	virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
+	virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems = -1, int p_max_depth = -1);
 
 	virtual void reload_all_scripts();
-	virtual void reload_tool_script(const Ref<Script>& p_script,bool p_soft_reload);
+	virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload);
 
 	virtual void frame();
 
 	virtual void get_public_functions(List<MethodInfo> *p_functions) const;
-	virtual void get_public_constants(List<Pair<String,Variant> > *p_constants) const;
+	virtual void get_public_constants(List<Pair<String, Variant> > *p_constants) const;
 
 	virtual void profiling_start();
 	virtual void profiling_stop();
 
-	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr,int p_info_max);
-	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr,int p_info_max);
+	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max);
+	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max);
 
 	/* LOADER FUNCTIONS */
 
@@ -451,24 +426,19 @@ public:
 	~GDScriptLanguage();
 };
 
-
 class ResourceFormatLoaderGDScript : public ResourceFormatLoader {
 public:
-
-	virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual bool handles_type(const String& p_type) const;
+	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;
-
 };
 
 class ResourceFormatSaverGDScript : public ResourceFormatSaver {
 public:
-
-	virtual Error save(const String &p_path,const RES& p_resource,uint32_t p_flags=0);
-	virtual void get_recognized_extensions(const RES& p_resource,List<String> *p_extensions) const;
-	virtual bool recognize(const RES& p_resource) const;
-
+	virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
+	virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const;
+	virtual bool recognize(const RES &p_resource) const;
 };
 
 #endif // GD_SCRIPT_H
diff --git a/modules/gdscript/gd_tokenizer.cpp b/modules/gdscript/gd_tokenizer.cpp
index 54b9624e8e..981924191f 100644
--- a/modules/gdscript/gd_tokenizer.cpp
+++ b/modules/gdscript/gd_tokenizer.cpp
@@ -27,212 +27,205 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "gd_tokenizer.h"
-#include "print_string.h"
 #include "gd_functions.h"
 #include "io/marshalls.h"
 #include "map.h"
+#include "print_string.h"
 
-const char* GDTokenizer::token_names[TK_MAX]={
-"Empty",
-"Identifier",
-"Constant",
-"Self",
-"Built-In Type",
-"Built-In Func",
-"In",
-"'=='",
-"'!='",
-"'<'",
-"'<='",
-"'>'",
-"'>='",
-"'and'",
-"'or'",
-"'not'",
-"'+'",
-"'-'",
-"'*'",
-"'/'",
-"'%'",
-"'<<'",
-"'>>'",
-"'='",
-"'+='",
-"'-='",
-"'*='",
-"'/='",
-"'%='",
-"'<<='",
-"'>>='",
-"'&='",
-"'|='",
-"'^='",
-"'&'",
-"'|'",
-"'^'",
-"'~'",
-//"Plus Plus",
-//"Minus Minus",
-"if",
-"elif",
-"else",
-"for",
-"do",
-"while",
-"switch (reserved)",
-"case (reserved)",
-"break",
-"continue",
-"pass",
-"return",
-"match",
-"func",
-"class",
-"extends",
-"onready",
-"tool",
-"static",
-"export",
-"setget",
-"const",
-"var",
-"enum",
-"preload",
-"assert",
-"yield",
-"signal",
-"breakpoint",
-"rpc",
-"sync",
-"master",
-"slave",
-"'['",
-"']'",
-"'{'",
-"'}'",
-"'('",
-"')'",
-"','",
-"';'",
-"'.'",
-"'?'",
-"':'",
-"'\\n'",
-"PI",
-"_",
-"INF",
-"NAN",
-"Error",
-"EOF",
-"Cursor"};
+const char *GDTokenizer::token_names[TK_MAX] = {
+	"Empty",
+	"Identifier",
+	"Constant",
+	"Self",
+	"Built-In Type",
+	"Built-In Func",
+	"In",
+	"'=='",
+	"'!='",
+	"'<'",
+	"'<='",
+	"'>'",
+	"'>='",
+	"'and'",
+	"'or'",
+	"'not'",
+	"'+'",
+	"'-'",
+	"'*'",
+	"'/'",
+	"'%'",
+	"'<<'",
+	"'>>'",
+	"'='",
+	"'+='",
+	"'-='",
+	"'*='",
+	"'/='",
+	"'%='",
+	"'<<='",
+	"'>>='",
+	"'&='",
+	"'|='",
+	"'^='",
+	"'&'",
+	"'|'",
+	"'^'",
+	"'~'",
+	//"Plus Plus",
+	//"Minus Minus",
+	"if",
+	"elif",
+	"else",
+	"for",
+	"do",
+	"while",
+	"switch (reserved)",
+	"case (reserved)",
+	"break",
+	"continue",
+	"pass",
+	"return",
+	"match",
+	"func",
+	"class",
+	"extends",
+	"onready",
+	"tool",
+	"static",
+	"export",
+	"setget",
+	"const",
+	"var",
+	"enum",
+	"preload",
+	"assert",
+	"yield",
+	"signal",
+	"breakpoint",
+	"rpc",
+	"sync",
+	"master",
+	"slave",
+	"'['",
+	"']'",
+	"'{'",
+	"'}'",
+	"'('",
+	"')'",
+	"','",
+	"';'",
+	"'.'",
+	"'?'",
+	"':'",
+	"'\\n'",
+	"PI",
+	"_",
+	"INF",
+	"NAN",
+	"Error",
+	"EOF",
+	"Cursor"
+};
 
 const char *GDTokenizer::get_token_name(Token p_token) {
 
-	ERR_FAIL_INDEX_V(p_token,TK_MAX,"<error>");
+	ERR_FAIL_INDEX_V(p_token, TK_MAX, "<error>");
 	return token_names[p_token];
 }
 
 static bool _is_text_char(CharType c) {
 
-	return (c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9') || c=='_';
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
 }
 
 static bool _is_number(CharType c) {
 
-	return (c>='0' && c<='9');
+	return (c >= '0' && c <= '9');
 }
 
 static bool _is_hex(CharType c) {
 
-	return (c>='0' && c<='9') || (c>='a' && c<='f') || (c>='A' && c<='F');
+	return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
 }
 
-void GDTokenizerText::_make_token(Token p_type)  {
+void GDTokenizerText::_make_token(Token p_type) {
 
-	TokenData &tk=tk_rb[tk_rb_pos];
+	TokenData &tk = tk_rb[tk_rb_pos];
 
-	tk.type=p_type;
-	tk.line=line;
-	tk.col=column;
+	tk.type = p_type;
+	tk.line = line;
+	tk.col = column;
 
-	tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE;
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
 }
-void GDTokenizerText::_make_identifier(const StringName& p_identifier)  {
+void GDTokenizerText::_make_identifier(const StringName &p_identifier) {
 
-	TokenData &tk=tk_rb[tk_rb_pos];
+	TokenData &tk = tk_rb[tk_rb_pos];
 
-	tk.type=TK_IDENTIFIER;
-	tk.identifier=p_identifier;
-	tk.line=line;
-	tk.col=column;
-
-	tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE;
+	tk.type = TK_IDENTIFIER;
+	tk.identifier = p_identifier;
+	tk.line = line;
+	tk.col = column;
 
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
 }
 
-void GDTokenizerText::_make_built_in_func(GDFunctions::Function p_func)  {
-
-	TokenData &tk=tk_rb[tk_rb_pos];
+void GDTokenizerText::_make_built_in_func(GDFunctions::Function p_func) {
 
-	tk.type=TK_BUILT_IN_FUNC;
-	tk.func=p_func;
-	tk.line=line;
-	tk.col=column;
+	TokenData &tk = tk_rb[tk_rb_pos];
 
-	tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE;
+	tk.type = TK_BUILT_IN_FUNC;
+	tk.func = p_func;
+	tk.line = line;
+	tk.col = column;
 
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
 }
-void GDTokenizerText::_make_constant(const Variant& p_constant)  {
+void GDTokenizerText::_make_constant(const Variant &p_constant) {
 
-	TokenData &tk=tk_rb[tk_rb_pos];
+	TokenData &tk = tk_rb[tk_rb_pos];
 
-	tk.type=TK_CONSTANT;
-	tk.constant=p_constant;
-	tk.line=line;
-	tk.col=column;
-
-	tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE;
+	tk.type = TK_CONSTANT;
+	tk.constant = p_constant;
+	tk.line = line;
+	tk.col = column;
 
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
 }
 
-void GDTokenizerText::_make_type(const Variant::Type& p_type) {
-
-
-	TokenData &tk=tk_rb[tk_rb_pos];
+void GDTokenizerText::_make_type(const Variant::Type &p_type) {
 
-	tk.type=TK_BUILT_IN_TYPE;
-	tk.vtype=p_type;
-	tk.line=line;
-	tk.col=column;
+	TokenData &tk = tk_rb[tk_rb_pos];
 
-	tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE;
+	tk.type = TK_BUILT_IN_TYPE;
+	tk.vtype = p_type;
+	tk.line = line;
+	tk.col = column;
 
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
 }
 
+void GDTokenizerText::_make_error(const String &p_error) {
 
-void GDTokenizerText::_make_error(const String& p_error) {
-
-	error_flag=true;
-	last_error=p_error;
-
-	TokenData &tk=tk_rb[tk_rb_pos];
-	tk.type=TK_ERROR;
-	tk.constant=p_error;
-	tk.line=line;
-	tk.col=column;
-	tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE;
+	error_flag = true;
+	last_error = p_error;
 
+	TokenData &tk = tk_rb[tk_rb_pos];
+	tk.type = TK_ERROR;
+	tk.constant = p_error;
+	tk.line = line;
+	tk.col = column;
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
 }
 
-
 void GDTokenizerText::_make_newline(int p_spaces) {
 
-	TokenData &tk=tk_rb[tk_rb_pos];
-	tk.type=TK_NEWLINE;
-	tk.constant=p_spaces;
-	tk.line=line;
-	tk.col=column;
-	tk_rb_pos=(tk_rb_pos+1)%TK_RB_SIZE;
+	TokenData &tk = tk_rb[tk_rb_pos];
+	tk.type = TK_NEWLINE;
+	tk.constant = p_spaces;
+	tk.line = line;
+	tk.col = column;
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
 }
 
 void GDTokenizerText::_advance() {
@@ -243,29 +236,32 @@ void GDTokenizerText::_advance() {
 		return;
 	}
 
-	if (code_pos>=len) {
+	if (code_pos >= len) {
 		_make_token(TK_EOF);
 		return;
 	}
-#define GETCHAR(m_ofs) ((m_ofs+code_pos)>=len?0:_code[m_ofs+code_pos])
-#define INCPOS(m_amount) { code_pos+=m_amount; column+=m_amount; }
+#define GETCHAR(m_ofs) ((m_ofs + code_pos) >= len ? 0 : _code[m_ofs + code_pos])
+#define INCPOS(m_amount)      \
+	{                         \
+		code_pos += m_amount; \
+		column += m_amount;   \
+	}
 	while (true) {
 
+		bool is_node_path = false;
+		StringMode string_mode = STRING_DOUBLE_QUOTE;
 
-		bool is_node_path  = false;
-		StringMode string_mode=STRING_DOUBLE_QUOTE;
-
-		switch(GETCHAR(0)) {
+		switch (GETCHAR(0)) {
 			case 0:
 				_make_token(TK_EOF);
 				break;
 			case '\\':
 				INCPOS(1);
-				if (GETCHAR(0)=='\r') {
+				if (GETCHAR(0) == '\r') {
 					INCPOS(1);
 				}
 
-				if (GETCHAR(0)!='\n') {
+				if (GETCHAR(0) != '\n') {
 					_make_error("Expected newline after '\\'.");
 					return;
 				}
@@ -273,7 +269,7 @@ void GDTokenizerText::_advance() {
 				INCPOS(1);
 				line++;
 
-				while(GETCHAR(0)==' ' || GETCHAR(0)=='\t') {
+				while (GETCHAR(0) == ' ' || GETCHAR(0) == '\t') {
 					INCPOS(1);
 				}
 
@@ -286,9 +282,9 @@ void GDTokenizerText::_advance() {
 			case '\n': {
 				line++;
 				INCPOS(1);
-				column=1;
-				int i=0;
-				while(GETCHAR(i)==' ' || GETCHAR(i)=='\t') {
+				column = 1;
+				int i = 0;
+				while (GETCHAR(i) == ' ' || GETCHAR(i) == '\t') {
 					i++;
 				}
 
@@ -298,19 +294,19 @@ void GDTokenizerText::_advance() {
 #if 1 //py style tokenizer
 			case '#': { // line comment skip
 
-				while(GETCHAR(0)!='\n') {
+				while (GETCHAR(0) != '\n') {
 					code_pos++;
-					if (GETCHAR(0)==0) { //end of file
+					if (GETCHAR(0) == 0) { //end of file
 						//_make_error("Unterminated Comment");
 						_make_token(TK_EOF);
 						return;
 					}
 				}
 				INCPOS(1);
-				column=1;
+				column = 1;
 				line++;
-				int i=0;
-				while(GETCHAR(i)==' ' || GETCHAR(i)=='\t') {
+				int i = 0;
+				while (GETCHAR(i) == ' ' || GETCHAR(i) == '\t') {
 					i++;
 				}
 				_make_newline(i);
@@ -320,7 +316,7 @@ void GDTokenizerText::_advance() {
 #endif
 			case '/': {
 
-				switch(GETCHAR(1)) {
+				switch (GETCHAR(1)) {
 #if 0 // c style tokenizer
 					case '*': { // block comment
 						int pos = code_pos+2;
@@ -376,11 +372,10 @@ void GDTokenizerText::_advance() {
 					} break;
 					default:
 						_make_token(TK_OP_DIV);
-
 				}
 			} break;
 			case '=': {
-				if (GETCHAR(1)=='=') {
+				if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_EQUAL);
 					INCPOS(1);
 
@@ -389,12 +384,12 @@ void GDTokenizerText::_advance() {
 
 			} break;
 			case '<': {
-				if (GETCHAR(1)=='=') {
+				if (GETCHAR(1) == '=') {
 
 					_make_token(TK_OP_LESS_EQUAL);
 					INCPOS(1);
-				} else if (GETCHAR(1)=='<') {
-					if (GETCHAR(2)=='=') {
+				} else if (GETCHAR(1) == '<') {
+					if (GETCHAR(2) == '=') {
 						_make_token(TK_OP_ASSIGN_SHIFT_LEFT);
 						INCPOS(1);
 					} else {
@@ -406,11 +401,11 @@ void GDTokenizerText::_advance() {
 
 			} break;
 			case '>': {
-				if (GETCHAR(1)=='=') {
+				if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_GREATER_EQUAL);
 					INCPOS(1);
-				} else if (GETCHAR(1)=='>') {
-					if (GETCHAR(2)=='=') {
+				} else if (GETCHAR(1) == '>') {
+					if (GETCHAR(2) == '=') {
 						_make_token(TK_OP_ASSIGN_SHIFT_RIGHT);
 						INCPOS(1);
 
@@ -424,7 +419,7 @@ void GDTokenizerText::_advance() {
 
 			} break;
 			case '!': {
-				if (GETCHAR(1)=='=') {
+				if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_NOT_EQUAL);
 					INCPOS(1);
 				} else {
@@ -468,7 +463,7 @@ void GDTokenizerText::_advance() {
 				_make_token(TK_DOLLAR); //for the get_node() shortener
 				break;
 			case '^': {
-				if (GETCHAR(1)=='=') {
+				if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_ASSIGN_BIT_XOR);
 					INCPOS(1);
 				} else {
@@ -480,11 +475,11 @@ void GDTokenizerText::_advance() {
 				_make_token(TK_OP_BIT_INVERT);
 				break;
 			case '&': {
-				if (GETCHAR(1)=='&') {
+				if (GETCHAR(1) == '&') {
 
 					_make_token(TK_OP_AND);
 					INCPOS(1);
-				} else if (GETCHAR(1)=='=') {
+				} else if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_ASSIGN_BIT_AND);
 					INCPOS(1);
 				} else {
@@ -492,11 +487,11 @@ void GDTokenizerText::_advance() {
 				}
 			} break;
 			case '|': {
-				if (GETCHAR(1)=='|') {
+				if (GETCHAR(1) == '|') {
 
 					_make_token(TK_OP_OR);
 					INCPOS(1);
-				} else if (GETCHAR(1)=='=') {
+				} else if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_ASSIGN_BIT_OR);
 					INCPOS(1);
 				} else {
@@ -505,7 +500,7 @@ void GDTokenizerText::_advance() {
 			} break;
 			case '*': {
 
-				if (GETCHAR(1)=='=') {
+				if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_ASSIGN_MUL);
 					INCPOS(1);
 				} else {
@@ -514,10 +509,10 @@ void GDTokenizerText::_advance() {
 			} break;
 			case '+': {
 
-				if (GETCHAR(1)=='=') {
+				if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_ASSIGN_ADD);
 					INCPOS(1);
-				/*
+					/*
 				}  else if (GETCHAR(1)=='+') {
 					_make_token(TK_OP_PLUS_PLUS);
 					INCPOS(1);
@@ -529,10 +524,10 @@ void GDTokenizerText::_advance() {
 			} break;
 			case '-': {
 
-				if (GETCHAR(1)=='=') {
+				if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_ASSIGN_SUB);
 					INCPOS(1);
-				/*
+					/*
 				}  else if (GETCHAR(1)=='-') {
 					_make_token(TK_OP_MINUS_MINUS);
 					INCPOS(1);
@@ -543,7 +538,7 @@ void GDTokenizerText::_advance() {
 			} break;
 			case '%': {
 
-				if (GETCHAR(1)=='=') {
+				if (GETCHAR(1) == '=') {
 					_make_token(TK_OP_ASSIGN_MOD);
 					INCPOS(1);
 				} else {
@@ -551,106 +546,103 @@ void GDTokenizerText::_advance() {
 				}
 			} break;
 			case '@':
-				if( CharType(GETCHAR(1))!='"' && CharType(GETCHAR(1))!='\'' ) {
+				if (CharType(GETCHAR(1)) != '"' && CharType(GETCHAR(1)) != '\'') {
 					_make_error("Unexpected '@'");
 					return;
 				}
 				INCPOS(1);
-				is_node_path=true;
+				is_node_path = true;
 
 			case '\'':
 			case '"': {
 
-				if (GETCHAR(0)=='\'')
-					string_mode=STRING_SINGLE_QUOTE;
-
-
-				int i=1;
-				if (string_mode==STRING_DOUBLE_QUOTE && GETCHAR(i)=='"' && GETCHAR(i+1)=='"') {
-					i+=2;
-					string_mode=STRING_MULTILINE;
+				if (GETCHAR(0) == '\'')
+					string_mode = STRING_SINGLE_QUOTE;
 
+				int i = 1;
+				if (string_mode == STRING_DOUBLE_QUOTE && GETCHAR(i) == '"' && GETCHAR(i + 1) == '"') {
+					i += 2;
+					string_mode = STRING_MULTILINE;
 				}
 
-
 				String str;
-				while(true) {
-					if (CharType(GETCHAR(i))==0) {
+				while (true) {
+					if (CharType(GETCHAR(i)) == 0) {
 
 						_make_error("Unterminated String");
 						return;
-					} else if( string_mode==STRING_DOUBLE_QUOTE && CharType(GETCHAR(i))=='"' ) {
+					} else if (string_mode == STRING_DOUBLE_QUOTE && CharType(GETCHAR(i)) == '"') {
 						break;
-					} else if( string_mode==STRING_SINGLE_QUOTE && CharType(GETCHAR(i))=='\'' ) {
+					} else if (string_mode == STRING_SINGLE_QUOTE && CharType(GETCHAR(i)) == '\'') {
 						break;
-					} else if( string_mode==STRING_MULTILINE && CharType(GETCHAR(i))=='\"' &&  CharType(GETCHAR(i+1))=='\"' && CharType(GETCHAR(i+2))=='\"') {
-						i+=2;
+					} else if (string_mode == STRING_MULTILINE && CharType(GETCHAR(i)) == '\"' && CharType(GETCHAR(i + 1)) == '\"' && CharType(GETCHAR(i + 2)) == '\"') {
+						i += 2;
 						break;
-					} else if( string_mode!=STRING_MULTILINE && CharType(GETCHAR(i))=='\n') {
+					} else if (string_mode != STRING_MULTILINE && CharType(GETCHAR(i)) == '\n') {
 						_make_error("Unexpected EOL at String.");
 						return;
-					} else if( CharType(GETCHAR(i))==0xFFFF) {
+					} else if (CharType(GETCHAR(i)) == 0xFFFF) {
 						//string ends here, next will be TK
 						i--;
 						break;
-					} else if (CharType(GETCHAR(i))=='\\') {
+					} else if (CharType(GETCHAR(i)) == '\\') {
 						//escaped characters...
 						i++;
 						CharType next = GETCHAR(i);
-						if (next==0) {
+						if (next == 0) {
 							_make_error("Unterminated String");
 							return;
 						}
-						CharType res=0;
-
-						switch(next) {
-
-							case 'a': res=7; break;
-							case 'b': res=8; break;
-							case 't': res=9; break;
-							case 'n': res=10; break;
-							case 'v': res=11; break;
-							case 'f': res=12; break;
-							case 'r': res=13; break;
-							case '\'': res='\''; break;
-							case '\"': res='\"'; break;
-							case '\\': res='\\'; break;
-							case '/': res='/'; break; //wtf
+						CharType res = 0;
+
+						switch (next) {
+
+							case 'a': res = 7; break;
+							case 'b': res = 8; break;
+							case 't': res = 9; break;
+							case 'n': res = 10; break;
+							case 'v': res = 11; break;
+							case 'f': res = 12; break;
+							case 'r': res = 13; break;
+							case '\'': res = '\''; break;
+							case '\"': res = '\"'; break;
+							case '\\': res = '\\'; break;
+							case '/':
+								res = '/';
+								break; //wtf
 
 							case 'u': {
 								//hexnumbarh - oct is deprecated
-								i+=1;
-								for(int j=0;j<4;j++) {
-									CharType c = GETCHAR(i+j);
-									if (c==0) {
+								i += 1;
+								for (int j = 0; j < 4; j++) {
+									CharType c = GETCHAR(i + j);
+									if (c == 0) {
 										_make_error("Unterminated String");
 										return;
 									}
-									if (!((c>='0' && c<='9') || (c>='a' && c<='f') || (c>='A' && c<='F'))) {
+									if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
 
 										_make_error("Malformed hex constant in string");
 										return;
 									}
 									CharType v;
-									if (c>='0' && c<='9') {
-										v=c-'0';
-									} else if (c>='a' && c<='f') {
-										v=c-'a';
-										v+=10;
-									} else if (c>='A' && c<='F') {
-										v=c-'A';
-										v+=10;
+									if (c >= '0' && c <= '9') {
+										v = c - '0';
+									} else if (c >= 'a' && c <= 'f') {
+										v = c - 'a';
+										v += 10;
+									} else if (c >= 'A' && c <= 'F') {
+										v = c - 'A';
+										v += 10;
 									} else {
 										ERR_PRINT("BUG");
-										v=0;
+										v = 0;
 									}
 
-									res<<=4;
-									res|=v;
-
-
+									res <<= 4;
+									res |= v;
 								}
-								i+=3;
+								i += 3;
 
 							} break;
 							default: {
@@ -660,15 +652,15 @@ void GDTokenizerText::_advance() {
 							} break;
 						}
 
-						str+=res;
+						str += res;
 
 					} else {
-						if (CharType(GETCHAR(i))=='\n') {
+						if (CharType(GETCHAR(i)) == '\n') {
 							line++;
-							column=1;
+							column = 1;
 						}
 
-						str+=CharType(GETCHAR(i));
+						str += CharType(GETCHAR(i));
 					}
 					i++;
 				}
@@ -686,54 +678,54 @@ void GDTokenizerText::_advance() {
 			} break;
 			default: {
 
-				if (_is_number(GETCHAR(0)) || (GETCHAR(0)=='.' && _is_number(GETCHAR(1)))) {
+				if (_is_number(GETCHAR(0)) || (GETCHAR(0) == '.' && _is_number(GETCHAR(1)))) {
 					// parse number
-					bool period_found=false;
-					bool exponent_found=false;
-					bool hexa_found=false;
-					bool sign_found=false;
+					bool period_found = false;
+					bool exponent_found = false;
+					bool hexa_found = false;
+					bool sign_found = false;
 
 					String str;
-					int i=0;
+					int i = 0;
 
-					while(true) {
-						if (GETCHAR(i)=='.') {
+					while (true) {
+						if (GETCHAR(i) == '.') {
 							if (period_found || exponent_found) {
 								_make_error("Invalid numeric constant at '.'");
 								return;
 							}
-							period_found=true;
-						} else if (GETCHAR(i)=='x') {
-							if (hexa_found || str.length()!=1 || !( (i==1 && str[0]=='0') || (i==2 && str[1]=='0' && str[0]=='-') ) ) {
+							period_found = true;
+						} else if (GETCHAR(i) == 'x') {
+							if (hexa_found || str.length() != 1 || !((i == 1 && str[0] == '0') || (i == 2 && str[1] == '0' && str[0] == '-'))) {
 								_make_error("Invalid numeric constant at 'x'");
 								return;
 							}
-							hexa_found=true;
-						} else if (!hexa_found && GETCHAR(i)=='e') {
+							hexa_found = true;
+						} else if (!hexa_found && GETCHAR(i) == 'e') {
 							if (hexa_found || exponent_found) {
 								_make_error("Invalid numeric constant at 'e'");
 								return;
 							}
-							exponent_found=true;
+							exponent_found = true;
 						} else if (_is_number(GETCHAR(i))) {
 							//all ok
 						} else if (hexa_found && _is_hex(GETCHAR(i))) {
 
-						} else if ((GETCHAR(i)=='-' || GETCHAR(i)=='+') && exponent_found) {
+						} else if ((GETCHAR(i) == '-' || GETCHAR(i) == '+') && exponent_found) {
 							if (sign_found) {
 								_make_error("Invalid numeric constant at '-'");
 								return;
 							}
-							sign_found=true;
+							sign_found = true;
 						} else
 							break;
 
-						str+=CharType(GETCHAR(i));
+						str += CharType(GETCHAR(i));
 						i++;
 					}
 
-					if (!( _is_number(str[str.length()-1]) || (hexa_found && _is_hex(str[str.length()-1])))) {
-						_make_error("Invalid numeric constant: "+str);
+					if (!(_is_number(str[str.length() - 1]) || (hexa_found && _is_hex(str[str.length() - 1])))) {
+						_make_error("Invalid numeric constant: " + str);
 						return;
 					}
 
@@ -748,13 +740,12 @@ void GDTokenizerText::_advance() {
 					} else {
 						int64_t val = str.to_int64();
 						_make_constant(val);
-
 					}
 
 					return;
 				}
 
-				if (GETCHAR(0)=='.') {
+				if (GETCHAR(0) == '.') {
 					//parse period
 					_make_token(TK_PERIOD);
 					break;
@@ -763,74 +754,76 @@ void GDTokenizerText::_advance() {
 				if (_is_text_char(GETCHAR(0))) {
 					// parse identifier
 					String str;
-					str+=CharType(GETCHAR(0));
+					str += CharType(GETCHAR(0));
 
-					int i=1;
-					while(_is_text_char(GETCHAR(i))) {
-						str+=CharType(GETCHAR(i));
+					int i = 1;
+					while (_is_text_char(GETCHAR(i))) {
+						str += CharType(GETCHAR(i));
 						i++;
 					}
 
-					bool identifier=false;
+					bool identifier = false;
 
-					if (str=="null") {
+					if (str == "null") {
 						_make_constant(Variant());
 
-					} else if (str=="true") {
+					} else if (str == "true") {
 						_make_constant(true);
 
-					} else if (str=="false") {
+					} else if (str == "false") {
 						_make_constant(false);
 					} else {
 
-						bool found=false;
+						bool found = false;
 
-						struct _bit { Variant::Type type; const char *text;};
+						struct _bit {
+							Variant::Type type;
+							const char *text;
+						};
 						//built in types
 
-						static const  _bit type_list[]={
+						static const _bit type_list[] = {
 							//types
-							{Variant::BOOL,"bool"},
-							{Variant::INT,"int"},
-							{Variant::REAL,"float"},
-							{Variant::STRING,"String"},
-							{Variant::VECTOR2,"Vector2"},
-							{Variant::RECT2,"Rect2"},
-							{Variant::TRANSFORM2D,"Transform2D"},
-							{Variant::VECTOR3,"Vector3"},
-							{Variant::RECT3,"Rect3"},
-							{Variant::PLANE,"Plane"},
-							{Variant::QUAT,"Quat"},
-							{Variant::BASIS,"Basis"},
-							{Variant::TRANSFORM,"Transform"},
-							{Variant::COLOR,"Color"},
-							{Variant::IMAGE,"Image"},
-							{Variant::_RID,"RID"},
-							{Variant::OBJECT,"Object"},
-							{Variant::INPUT_EVENT,"InputEvent"},
-							{Variant::NODE_PATH,"NodePath"},
-							{Variant::DICTIONARY,"Dictionary"},
-							{Variant::ARRAY,"Array"},
-							{Variant::POOL_BYTE_ARRAY,"PoolByteArray"},
-							{Variant::POOL_INT_ARRAY,"PoolIntArray"},
-							{Variant::POOL_REAL_ARRAY,"PoolFloatArray"},
-							{Variant::POOL_STRING_ARRAY,"PoolStringArray"},
-							{Variant::POOL_VECTOR2_ARRAY,"PoolVector2Array"},
-							{Variant::POOL_VECTOR3_ARRAY,"PoolVector3Array"},
-							{Variant::POOL_COLOR_ARRAY,"PoolColorArray"},
-							{Variant::VARIANT_MAX,NULL},
+							{ Variant::BOOL, "bool" },
+							{ Variant::INT, "int" },
+							{ Variant::REAL, "float" },
+							{ Variant::STRING, "String" },
+							{ Variant::VECTOR2, "Vector2" },
+							{ Variant::RECT2, "Rect2" },
+							{ Variant::TRANSFORM2D, "Transform2D" },
+							{ Variant::VECTOR3, "Vector3" },
+							{ Variant::RECT3, "Rect3" },
+							{ Variant::PLANE, "Plane" },
+							{ Variant::QUAT, "Quat" },
+							{ Variant::BASIS, "Basis" },
+							{ Variant::TRANSFORM, "Transform" },
+							{ Variant::COLOR, "Color" },
+							{ Variant::IMAGE, "Image" },
+							{ Variant::_RID, "RID" },
+							{ Variant::OBJECT, "Object" },
+							{ Variant::INPUT_EVENT, "InputEvent" },
+							{ Variant::NODE_PATH, "NodePath" },
+							{ Variant::DICTIONARY, "Dictionary" },
+							{ Variant::ARRAY, "Array" },
+							{ Variant::POOL_BYTE_ARRAY, "PoolByteArray" },
+							{ Variant::POOL_INT_ARRAY, "PoolIntArray" },
+							{ Variant::POOL_REAL_ARRAY, "PoolFloatArray" },
+							{ Variant::POOL_STRING_ARRAY, "PoolStringArray" },
+							{ Variant::POOL_VECTOR2_ARRAY, "PoolVector2Array" },
+							{ Variant::POOL_VECTOR3_ARRAY, "PoolVector3Array" },
+							{ Variant::POOL_COLOR_ARRAY, "PoolColorArray" },
+							{ Variant::VARIANT_MAX, NULL },
 						};
 
 						{
 
+							int idx = 0;
 
-							int idx=0;
-
-							while(type_list[idx].text) {
+							while (type_list[idx].text) {
 
-								if (str==type_list[idx].text) {
+								if (str == type_list[idx].text) {
 									_make_type(type_list[idx].type);
-									found=true;
+									found = true;
 									break;
 								}
 								idx++;
@@ -841,12 +834,12 @@ void GDTokenizerText::_advance() {
 
 							//built in func?
 
-							for(int i=0;i<GDFunctions::FUNC_MAX;i++) {
+							for (int i = 0; i < GDFunctions::FUNC_MAX; i++) {
 
-								if (str==GDFunctions::get_func_name(GDFunctions::Function(i))) {
+								if (str == GDFunctions::get_func_name(GDFunctions::Function(i))) {
 
 									_make_built_in_func(GDFunctions::Function(i));
-									found=true;
+									found = true;
 									break;
 								}
 							}
@@ -856,66 +849,68 @@ void GDTokenizerText::_advance() {
 
 						if (!found) {
 
+							struct _kws {
+								Token token;
+								const char *text;
+							};
 
-							struct _kws { Token token; const char *text;};
-
-							static const  _kws keyword_list[]={
+							static const _kws keyword_list[] = {
 								//ops
-								{TK_OP_IN,"in"},
-								{TK_OP_NOT,"not"},
-								{TK_OP_OR,"or"},
-								{TK_OP_AND,"and"},
+								{ TK_OP_IN, "in" },
+								{ TK_OP_NOT, "not" },
+								{ TK_OP_OR, "or" },
+								{ TK_OP_AND, "and" },
 								//func
-								{TK_PR_FUNCTION,"func"},
-								{TK_PR_CLASS,"class"},
-								{TK_PR_EXTENDS,"extends"},
-								{TK_PR_ONREADY,"onready"},
-								{TK_PR_TOOL,"tool"},
-								{TK_PR_STATIC,"static"},
-								{TK_PR_EXPORT,"export"},
-								{TK_PR_SETGET,"setget"},
-								{TK_PR_VAR,"var"},
-								{TK_PR_PRELOAD,"preload"},
-								{TK_PR_ASSERT,"assert"},
-								{TK_PR_YIELD,"yield"},
-								{TK_PR_SIGNAL,"signal"},
-								{TK_PR_BREAKPOINT,"breakpoint"},
-								{TK_PR_REMOTE,"remote"},
-								{TK_PR_MASTER,"master"},
-								{TK_PR_SLAVE,"slave"},
-								{TK_PR_SYNC,"sync"},
-								{TK_PR_CONST,"const"},
-								{TK_PR_ENUM,"enum"},
+								{ TK_PR_FUNCTION, "func" },
+								{ TK_PR_CLASS, "class" },
+								{ TK_PR_EXTENDS, "extends" },
+								{ TK_PR_ONREADY, "onready" },
+								{ TK_PR_TOOL, "tool" },
+								{ TK_PR_STATIC, "static" },
+								{ TK_PR_EXPORT, "export" },
+								{ TK_PR_SETGET, "setget" },
+								{ TK_PR_VAR, "var" },
+								{ TK_PR_PRELOAD, "preload" },
+								{ TK_PR_ASSERT, "assert" },
+								{ TK_PR_YIELD, "yield" },
+								{ TK_PR_SIGNAL, "signal" },
+								{ TK_PR_BREAKPOINT, "breakpoint" },
+								{ TK_PR_REMOTE, "remote" },
+								{ TK_PR_MASTER, "master" },
+								{ TK_PR_SLAVE, "slave" },
+								{ TK_PR_SYNC, "sync" },
+								{ TK_PR_CONST, "const" },
+								{ TK_PR_ENUM, "enum" },
 								//controlflow
-								{TK_CF_IF,"if"},
-								{TK_CF_ELIF,"elif"},
-								{TK_CF_ELSE,"else"},
-								{TK_CF_FOR,"for"},
-								{TK_CF_WHILE,"while"},
-								{TK_CF_DO,"do"},
-								{TK_CF_SWITCH,"switch"},
-								{TK_CF_CASE,"case"},
-								{TK_CF_BREAK,"break"},
-								{TK_CF_CONTINUE,"continue"},
-								{TK_CF_RETURN,"return"},
-								{TK_CF_MATCH, "match"},
-								{TK_CF_PASS,"pass"},
-								{TK_SELF,"self"},
-								{TK_CONST_PI,"PI"},
-								{TK_WILDCARD,"_"},
-								{TK_CONST_INF,"INF"},
-								{TK_CONST_NAN,"NAN"},
-								{TK_ERROR,NULL}
+								{ TK_CF_IF, "if" },
+								{ TK_CF_ELIF, "elif" },
+								{ TK_CF_ELSE, "else" },
+								{ TK_CF_FOR, "for" },
+								{ TK_CF_WHILE, "while" },
+								{ TK_CF_DO, "do" },
+								{ TK_CF_SWITCH, "switch" },
+								{ TK_CF_CASE, "case" },
+								{ TK_CF_BREAK, "break" },
+								{ TK_CF_CONTINUE, "continue" },
+								{ TK_CF_RETURN, "return" },
+								{ TK_CF_MATCH, "match" },
+								{ TK_CF_PASS, "pass" },
+								{ TK_SELF, "self" },
+								{ TK_CONST_PI, "PI" },
+								{ TK_WILDCARD, "_" },
+								{ TK_CONST_INF, "INF" },
+								{ TK_CONST_NAN, "NAN" },
+								{ TK_ERROR, NULL }
 							};
 
-							int idx=0;
-							found=false;
+							int idx = 0;
+							found = false;
 
-							while(keyword_list[idx].text) {
+							while (keyword_list[idx].text) {
 
-								if (str==keyword_list[idx].text) {
+								if (str == keyword_list[idx].text) {
 									_make_token(keyword_list[idx].token);
-									found=true;
+									found = true;
 									break;
 								}
 								idx++;
@@ -923,10 +918,9 @@ void GDTokenizerText::_advance() {
 						}
 
 						if (!found)
-							identifier=true;
+							identifier = true;
 					}
 
-
 					if (identifier) {
 						_make_identifier(str);
 					}
@@ -943,381 +937,358 @@ void GDTokenizerText::_advance() {
 		INCPOS(1);
 		break;
 	}
-
 }
 
-void GDTokenizerText::set_code(const String& p_code) {
+void GDTokenizerText::set_code(const String &p_code) {
 
-	code=p_code;
+	code = p_code;
 	len = p_code.length();
 	if (len) {
-		_code=&code[0];
+		_code = &code[0];
 	} else {
-		_code=NULL;
+		_code = NULL;
 	}
-	code_pos=0;
-	line=1; //it is stand-ar-ized that lines begin in 1 in code..
-	column=1; //the same holds for columns
-	tk_rb_pos=0;
-	error_flag=false;
-	last_error="";
-	for(int i=0;i<MAX_LOOKAHEAD+1;i++)
+	code_pos = 0;
+	line = 1; //it is stand-ar-ized that lines begin in 1 in code..
+	column = 1; //the same holds for columns
+	tk_rb_pos = 0;
+	error_flag = false;
+	last_error = "";
+	for (int i = 0; i < MAX_LOOKAHEAD + 1; i++)
 		_advance();
 }
 
 GDTokenizerText::Token GDTokenizerText::get_token(int p_offset) const {
-	ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, TK_ERROR);
-	ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, TK_ERROR);
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, TK_ERROR);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, TK_ERROR);
 
-	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD -1)%TK_RB_SIZE;
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
 	return tk_rb[ofs].type;
 }
 
 int GDTokenizerText::get_token_line(int p_offset) const {
-	ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, -1);
-	ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, -1);
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, -1);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, -1);
 
-	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD -1)%TK_RB_SIZE;
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
 	return tk_rb[ofs].line;
 }
 
 int GDTokenizerText::get_token_column(int p_offset) const {
-	ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, -1);
-	ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, -1);
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, -1);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, -1);
 
-	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD -1)%TK_RB_SIZE;
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
 	return tk_rb[ofs].col;
 }
 
-const Variant& GDTokenizerText::get_token_constant(int p_offset) const {
-	ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, tk_rb[0].constant);
-	ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, tk_rb[0].constant);
+const Variant &GDTokenizerText::get_token_constant(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, tk_rb[0].constant);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, tk_rb[0].constant);
 
-	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD -1)%TK_RB_SIZE;
-	ERR_FAIL_COND_V(tk_rb[ofs].type!=TK_CONSTANT,tk_rb[0].constant);
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_CONSTANT, tk_rb[0].constant);
 	return tk_rb[ofs].constant;
 }
 StringName GDTokenizerText::get_token_identifier(int p_offset) const {
 
-	ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, StringName());
-	ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, StringName());
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, StringName());
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, StringName());
 
-	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD -1)%TK_RB_SIZE;
-	ERR_FAIL_COND_V(tk_rb[ofs].type!=TK_IDENTIFIER,StringName());
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_IDENTIFIER, StringName());
 	return tk_rb[ofs].identifier;
-
 }
 
 GDFunctions::Function GDTokenizerText::get_token_built_in_func(int p_offset) const {
 
-	ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, GDFunctions::FUNC_MAX);
-	ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, GDFunctions::FUNC_MAX);
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, GDFunctions::FUNC_MAX);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, GDFunctions::FUNC_MAX);
 
-	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD -1)%TK_RB_SIZE;
-	ERR_FAIL_COND_V(tk_rb[ofs].type!=TK_BUILT_IN_FUNC,GDFunctions::FUNC_MAX);
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_BUILT_IN_FUNC, GDFunctions::FUNC_MAX);
 	return tk_rb[ofs].func;
-
 }
 
 Variant::Type GDTokenizerText::get_token_type(int p_offset) const {
 
-	ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, Variant::NIL);
-	ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, Variant::NIL);
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, Variant::NIL);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, Variant::NIL);
 
-	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD -1)%TK_RB_SIZE;
-	ERR_FAIL_COND_V(tk_rb[ofs].type!=TK_BUILT_IN_TYPE,Variant::NIL);
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_BUILT_IN_TYPE, Variant::NIL);
 	return tk_rb[ofs].vtype;
-
 }
 
-
 int GDTokenizerText::get_token_line_indent(int p_offset) const {
 
-	ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, 0);
-	ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, 0);
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, 0);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, 0);
 
-	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD -1)%TK_RB_SIZE;
-	ERR_FAIL_COND_V(tk_rb[ofs].type!=TK_NEWLINE,0);
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_NEWLINE, 0);
 	return tk_rb[ofs].constant;
-
 }
 
 String GDTokenizerText::get_token_error(int p_offset) const {
 
-	ERR_FAIL_COND_V( p_offset <= -MAX_LOOKAHEAD, String());
-	ERR_FAIL_COND_V( p_offset >= MAX_LOOKAHEAD, String());
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, String());
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, String());
 
-	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD -1)%TK_RB_SIZE;
-	ERR_FAIL_COND_V(tk_rb[ofs].type!=TK_ERROR,String());
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_ERROR, String());
 	return tk_rb[ofs].constant;
 }
 
 void GDTokenizerText::advance(int p_amount) {
 
-	ERR_FAIL_COND( p_amount <=0 );
-	for(int i=0;i<p_amount;i++)
+	ERR_FAIL_COND(p_amount <= 0);
+	for (int i = 0; i < p_amount; i++)
 		_advance();
 }
 
-
-
-
-
-
-
-
-
-
-
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #define BYTECODE_VERSION 12
 
-Error GDTokenizerBuffer::set_code_buffer(const Vector<uint8_t> & p_buffer) {
-
+Error GDTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer) {
 
-	const uint8_t *buf=p_buffer.ptr();
-	int total_len=p_buffer.size();
-	ERR_FAIL_COND_V( p_buffer.size()<24 || p_buffer[0]!='G' || p_buffer[1]!='D' || p_buffer[2]!='S' || p_buffer[3]!='C',ERR_INVALID_DATA);
+	const uint8_t *buf = p_buffer.ptr();
+	int total_len = p_buffer.size();
+	ERR_FAIL_COND_V(p_buffer.size() < 24 || p_buffer[0] != 'G' || p_buffer[1] != 'D' || p_buffer[2] != 'S' || p_buffer[3] != 'C', ERR_INVALID_DATA);
 
 	int version = decode_uint32(&buf[4]);
-	if (version>BYTECODE_VERSION) {
+	if (version > BYTECODE_VERSION) {
 		ERR_EXPLAIN("Bytecode is too New! Please use a newer engine version.");
-		ERR_FAIL_COND_V(version>BYTECODE_VERSION,ERR_INVALID_DATA);
+		ERR_FAIL_COND_V(version > BYTECODE_VERSION, ERR_INVALID_DATA);
 	}
 	int identifier_count = decode_uint32(&buf[8]);
 	int constant_count = decode_uint32(&buf[12]);
 	int line_count = decode_uint32(&buf[16]);
 	int token_count = decode_uint32(&buf[20]);
 
-	const uint8_t *b=buf;
+	const uint8_t *b = buf;
 
-	b=&buf[24];
-	total_len-=24;
+	b = &buf[24];
+	total_len -= 24;
 
 	identifiers.resize(identifier_count);
-	for(int i=0;i<identifier_count;i++) {
+	for (int i = 0; i < identifier_count; i++) {
 
 		int len = decode_uint32(b);
-		ERR_FAIL_COND_V(len>total_len,ERR_INVALID_DATA);
-		b+=4;
+		ERR_FAIL_COND_V(len > total_len, ERR_INVALID_DATA);
+		b += 4;
 		Vector<uint8_t> cs;
 		cs.resize(len);
-		for(int j=0;j<len;j++) {
-			cs[j]=b[j]^0xb6;
+		for (int j = 0; j < len; j++) {
+			cs[j] = b[j] ^ 0xb6;
 		}
 
-		cs[cs.size()-1]=0;
+		cs[cs.size() - 1] = 0;
 		String s;
-		s.parse_utf8((const char*)cs.ptr());
-		b+=len;
-		total_len-=len+4;
-		identifiers[i]=s;
+		s.parse_utf8((const char *)cs.ptr());
+		b += len;
+		total_len -= len + 4;
+		identifiers[i] = s;
 	}
 
 	constants.resize(constant_count);
-	for(int i=0;i<constant_count;i++) {
+	for (int i = 0; i < constant_count; i++) {
 
 		Variant v;
 		int len;
-		Error err = decode_variant(v,b,total_len,&len);
+		Error err = decode_variant(v, b, total_len, &len);
 		if (err)
 			return err;
-		b+=len;
-		total_len-=len;
-		constants[i]=v;
-
+		b += len;
+		total_len -= len;
+		constants[i] = v;
 	}
 
-	ERR_FAIL_COND_V(line_count*8>total_len,ERR_INVALID_DATA);
+	ERR_FAIL_COND_V(line_count * 8 > total_len, ERR_INVALID_DATA);
 
-	for(int i=0;i<line_count;i++) {
+	for (int i = 0; i < line_count; i++) {
 
-		uint32_t token=decode_uint32(b);
-		b+=4;
-		uint32_t linecol=decode_uint32(b);
-		b+=4;
+		uint32_t token = decode_uint32(b);
+		b += 4;
+		uint32_t linecol = decode_uint32(b);
+		b += 4;
 
-		lines.insert(token,linecol);
-		total_len-=8;
+		lines.insert(token, linecol);
+		total_len -= 8;
 	}
 
 	tokens.resize(token_count);
 
-	for(int i=0;i<token_count;i++) {
+	for (int i = 0; i < token_count; i++) {
 
-		ERR_FAIL_COND_V( total_len < 1, ERR_INVALID_DATA);
+		ERR_FAIL_COND_V(total_len < 1, ERR_INVALID_DATA);
 
-		if ((*b)&TOKEN_BYTE_MASK) { //little endian always
-			ERR_FAIL_COND_V( total_len < 4, ERR_INVALID_DATA);
+		if ((*b) & TOKEN_BYTE_MASK) { //little endian always
+			ERR_FAIL_COND_V(total_len < 4, ERR_INVALID_DATA);
 
-			tokens[i]=decode_uint32(b)&~TOKEN_BYTE_MASK;
-			b+=4;
+			tokens[i] = decode_uint32(b) & ~TOKEN_BYTE_MASK;
+			b += 4;
 		} else {
-			tokens[i]=*b;
-			b+=1;
+			tokens[i] = *b;
+			b += 1;
 			total_len--;
 		}
 	}
 
-	token=0;
+	token = 0;
 
 	return OK;
-
 }
 
-
-Vector<uint8_t> GDTokenizerBuffer::parse_code_string(const String& p_code) {
+Vector<uint8_t> GDTokenizerBuffer::parse_code_string(const String &p_code) {
 
 	Vector<uint8_t> buf;
 
-
-	Map<StringName,int> identifier_map;
-	HashMap<Variant,int,VariantHasher,VariantComparator> constant_map;
-	Map<uint32_t,int> line_map;
+	Map<StringName, int> identifier_map;
+	HashMap<Variant, int, VariantHasher, VariantComparator> constant_map;
+	Map<uint32_t, int> line_map;
 	Vector<uint32_t> token_array;
 
 	GDTokenizerText tt;
 	tt.set_code(p_code);
-	int line=-1;
+	int line = -1;
 
-	while(true) {
+	while (true) {
 
-		if (tt.get_token_line()!=line) {
+		if (tt.get_token_line() != line) {
 
-			line=tt.get_token_line();
-			line_map[line]=token_array.size();
+			line = tt.get_token_line();
+			line_map[line] = token_array.size();
 		}
 
-		uint32_t token=tt.get_token();
-		switch(tt.get_token()) {
+		uint32_t token = tt.get_token();
+		switch (tt.get_token()) {
 
 			case TK_IDENTIFIER: {
 				StringName id = tt.get_token_identifier();
 				if (!identifier_map.has(id)) {
 					int idx = identifier_map.size();
-					identifier_map[id]=idx;
+					identifier_map[id] = idx;
 				}
-				token|=identifier_map[id]<<TOKEN_BITS;
+				token |= identifier_map[id] << TOKEN_BITS;
 			} break;
 			case TK_CONSTANT: {
 
 				Variant c = tt.get_token_constant();
 				if (!constant_map.has(c)) {
 					int idx = constant_map.size();
-					constant_map[c]=idx;
+					constant_map[c] = idx;
 				}
-				token|=constant_map[c]<<TOKEN_BITS;
+				token |= constant_map[c] << TOKEN_BITS;
 			} break;
 			case TK_BUILT_IN_TYPE: {
 
-				token|=tt.get_token_type()<<TOKEN_BITS;
+				token |= tt.get_token_type() << TOKEN_BITS;
 			} break;
 			case TK_BUILT_IN_FUNC: {
 
-				token|=tt.get_token_built_in_func()<<TOKEN_BITS;
+				token |= tt.get_token_built_in_func() << TOKEN_BITS;
 
 			} break;
 			case TK_NEWLINE: {
 
-				token|=tt.get_token_line_indent()<<TOKEN_BITS;
+				token |= tt.get_token_line_indent() << TOKEN_BITS;
 			} break;
 			case TK_ERROR: {
 
 				ERR_FAIL_V(Vector<uint8_t>());
 			} break;
 			default: {}
-
 		};
 
 		token_array.push_back(token);
 
-		if (tt.get_token()==TK_EOF)
+		if (tt.get_token() == TK_EOF)
 			break;
 		tt.advance();
-
 	}
 
 	//reverse maps
 
-	Map<int,StringName> rev_identifier_map;
-	for(Map<StringName,int>::Element *E=identifier_map.front();E;E=E->next()) {
-		rev_identifier_map[E->get()]=E->key();
+	Map<int, StringName> rev_identifier_map;
+	for (Map<StringName, int>::Element *E = identifier_map.front(); E; E = E->next()) {
+		rev_identifier_map[E->get()] = E->key();
 	}
 
-	Map<int,Variant> rev_constant_map;
-	const Variant *K =NULL;
-	while((K=constant_map.next(K))) {
-		rev_constant_map[constant_map[*K]]=*K;
+	Map<int, Variant> rev_constant_map;
+	const Variant *K = NULL;
+	while ((K = constant_map.next(K))) {
+		rev_constant_map[constant_map[*K]] = *K;
 	}
 
-	Map<int,uint32_t> rev_line_map;
-	for(Map<uint32_t,int>::Element *E=line_map.front();E;E=E->next()) {
-		rev_line_map[E->get()]=E->key();
+	Map<int, uint32_t> rev_line_map;
+	for (Map<uint32_t, int>::Element *E = line_map.front(); E; E = E->next()) {
+		rev_line_map[E->get()] = E->key();
 	}
 
 	//save header
 	buf.resize(24);
-	buf[0]='G';
-	buf[1]='D';
-	buf[2]='S';
-	buf[3]='C';
-	encode_uint32(BYTECODE_VERSION,&buf[4]);
-	encode_uint32(identifier_map.size(),&buf[8]);
-	encode_uint32(constant_map.size(),&buf[12]);
-	encode_uint32(line_map.size(),&buf[16]);
-	encode_uint32(token_array.size(),&buf[20]);
+	buf[0] = 'G';
+	buf[1] = 'D';
+	buf[2] = 'S';
+	buf[3] = 'C';
+	encode_uint32(BYTECODE_VERSION, &buf[4]);
+	encode_uint32(identifier_map.size(), &buf[8]);
+	encode_uint32(constant_map.size(), &buf[12]);
+	encode_uint32(line_map.size(), &buf[16]);
+	encode_uint32(token_array.size(), &buf[20]);
 
 	//save identifiers
 
-	for(Map<int,StringName>::Element *E=rev_identifier_map.front();E;E=E->next()) {
+	for (Map<int, StringName>::Element *E = rev_identifier_map.front(); E; E = E->next()) {
 
 		CharString cs = String(E->get()).utf8();
-		int len = cs.length()+1;
-		int extra = 4-(len%4);
-		if (extra==4)
-			extra=0;
+		int len = cs.length() + 1;
+		int extra = 4 - (len % 4);
+		if (extra == 4)
+			extra = 0;
 
 		uint8_t ibuf[4];
-		encode_uint32(len+extra,ibuf);
-		for(int i=0;i<4;i++) {
+		encode_uint32(len + extra, ibuf);
+		for (int i = 0; i < 4; i++) {
 			buf.push_back(ibuf[i]);
 		}
-		for(int i=0;i<len;i++) {
-			buf.push_back(cs[i]^0xb6);
+		for (int i = 0; i < len; i++) {
+			buf.push_back(cs[i] ^ 0xb6);
 		}
-		for(int i=0;i<extra;i++) {
-			buf.push_back(0^0xb6);
+		for (int i = 0; i < extra; i++) {
+			buf.push_back(0 ^ 0xb6);
 		}
 	}
 
-	for(Map<int,Variant>::Element *E=rev_constant_map.front();E;E=E->next()) {
+	for (Map<int, Variant>::Element *E = rev_constant_map.front(); E; E = E->next()) {
 
 		int len;
-		Error err = encode_variant(E->get(),NULL,len);
-		ERR_FAIL_COND_V(err!=OK,Vector<uint8_t>());
-		int pos=buf.size();
-		buf.resize(pos+len);
-		encode_variant(E->get(),&buf[pos],len);
+		Error err = encode_variant(E->get(), NULL, len);
+		ERR_FAIL_COND_V(err != OK, Vector<uint8_t>());
+		int pos = buf.size();
+		buf.resize(pos + len);
+		encode_variant(E->get(), &buf[pos], len);
 	}
 
-	for(Map<int,uint32_t>::Element *E=rev_line_map.front();E;E=E->next()) {
+	for (Map<int, uint32_t>::Element *E = rev_line_map.front(); E; E = E->next()) {
 
 		uint8_t ibuf[8];
-		encode_uint32(E->key(),&ibuf[0]);
-		encode_uint32(E->get(),&ibuf[4]);
-		for(int i=0;i<8;i++)
+		encode_uint32(E->key(), &ibuf[0]);
+		encode_uint32(E->get(), &ibuf[4]);
+		for (int i = 0; i < 8; i++)
 			buf.push_back(ibuf[i]);
 	}
 
-	for(int i=0;i<token_array.size();i++) {
+	for (int i = 0; i < token_array.size(); i++) {
 
 		uint32_t token = token_array[i];
 
-		if (token&~TOKEN_MASK) {
+		if (token & ~TOKEN_MASK) {
 			uint8_t buf4[4];
-			encode_uint32(token_array[i]|TOKEN_BYTE_MASK,&buf4[0]);
-			for(int j=0;j<4;j++) {
+			encode_uint32(token_array[i] | TOKEN_BYTE_MASK, &buf4[0]);
+			for (int j = 0; j < 4; j++) {
 				buf.push_back(buf4[j]);
 			}
 		} else {
@@ -1326,102 +1297,94 @@ Vector<uint8_t> GDTokenizerBuffer::parse_code_string(const String& p_code) {
 	}
 
 	return buf;
-
 }
 
 GDTokenizerBuffer::Token GDTokenizerBuffer::get_token(int p_offset) const {
 
-	int offset = token+p_offset;
+	int offset = token + p_offset;
 
-	if (offset<0 || offset>=tokens.size())
+	if (offset < 0 || offset >= tokens.size())
 		return TK_EOF;
 
-	return GDTokenizerBuffer::Token(tokens[offset]&TOKEN_MASK);
+	return GDTokenizerBuffer::Token(tokens[offset] & TOKEN_MASK);
 }
 
+StringName GDTokenizerBuffer::get_token_identifier(int p_offset) const {
 
-StringName GDTokenizerBuffer::get_token_identifier(int p_offset) const{
+	int offset = token + p_offset;
 
-	int offset = token+p_offset;
-
-	ERR_FAIL_INDEX_V(offset,tokens.size(),StringName());
-	uint32_t identifier = tokens[offset]>>TOKEN_BITS;
-	ERR_FAIL_INDEX_V(identifier,(uint32_t)identifiers.size(),StringName());
+	ERR_FAIL_INDEX_V(offset, tokens.size(), StringName());
+	uint32_t identifier = tokens[offset] >> TOKEN_BITS;
+	ERR_FAIL_INDEX_V(identifier, (uint32_t)identifiers.size(), StringName());
 
 	return identifiers[identifier];
 }
 
-GDFunctions::Function GDTokenizerBuffer::get_token_built_in_func(int p_offset) const{
+GDFunctions::Function GDTokenizerBuffer::get_token_built_in_func(int p_offset) const {
 
-	int offset = token+p_offset;
-	ERR_FAIL_INDEX_V(offset,tokens.size(),GDFunctions::FUNC_MAX);
-	return GDFunctions::Function(tokens[offset]>>TOKEN_BITS);
+	int offset = token + p_offset;
+	ERR_FAIL_INDEX_V(offset, tokens.size(), GDFunctions::FUNC_MAX);
+	return GDFunctions::Function(tokens[offset] >> TOKEN_BITS);
 }
 
-Variant::Type GDTokenizerBuffer::get_token_type(int p_offset) const{
+Variant::Type GDTokenizerBuffer::get_token_type(int p_offset) const {
 
-	int offset = token+p_offset;
-	ERR_FAIL_INDEX_V(offset,tokens.size(),Variant::NIL);
+	int offset = token + p_offset;
+	ERR_FAIL_INDEX_V(offset, tokens.size(), Variant::NIL);
 
-	return Variant::Type(tokens[offset]>>TOKEN_BITS);
+	return Variant::Type(tokens[offset] >> TOKEN_BITS);
 }
 
-int GDTokenizerBuffer::get_token_line(int p_offset) const{
+int GDTokenizerBuffer::get_token_line(int p_offset) const {
 
-	int offset = token+p_offset;
+	int offset = token + p_offset;
 	int pos = lines.find_nearest(offset);
 
-	if (pos<0)
+	if (pos < 0)
 		return -1;
-	if (pos>=lines.size())
-		pos=lines.size()-1;
+	if (pos >= lines.size())
+		pos = lines.size() - 1;
 
 	uint32_t l = lines.getv(pos);
-	return l&TOKEN_LINE_MASK;
-
+	return l & TOKEN_LINE_MASK;
 }
-int GDTokenizerBuffer::get_token_column(int p_offset) const{
+int GDTokenizerBuffer::get_token_column(int p_offset) const {
 
-	int offset = token+p_offset;
+	int offset = token + p_offset;
 	int pos = lines.find_nearest(offset);
-	if (pos<0)
+	if (pos < 0)
 		return -1;
-	if (pos>=lines.size())
-		pos=lines.size()-1;
+	if (pos >= lines.size())
+		pos = lines.size() - 1;
 
 	uint32_t l = lines.getv(pos);
-	return l>>TOKEN_LINE_BITS;
-
+	return l >> TOKEN_LINE_BITS;
 }
-int GDTokenizerBuffer::get_token_line_indent(int p_offset) const{
+int GDTokenizerBuffer::get_token_line_indent(int p_offset) const {
 
-	int offset = token+p_offset;
-	ERR_FAIL_INDEX_V(offset,tokens.size(),0);
-	return tokens[offset]>>TOKEN_BITS;
+	int offset = token + p_offset;
+	ERR_FAIL_INDEX_V(offset, tokens.size(), 0);
+	return tokens[offset] >> TOKEN_BITS;
 }
-const Variant& GDTokenizerBuffer::get_token_constant(int p_offset) const{
-
+const Variant &GDTokenizerBuffer::get_token_constant(int p_offset) const {
 
-	int offset = token+p_offset;
-	ERR_FAIL_INDEX_V(offset,tokens.size(),nil);
-	uint32_t constant = tokens[offset]>>TOKEN_BITS;
-	ERR_FAIL_INDEX_V(constant,(uint32_t)constants.size(),nil);
+	int offset = token + p_offset;
+	ERR_FAIL_INDEX_V(offset, tokens.size(), nil);
+	uint32_t constant = tokens[offset] >> TOKEN_BITS;
+	ERR_FAIL_INDEX_V(constant, (uint32_t)constants.size(), nil);
 	return constants[constant];
-
 }
-String GDTokenizerBuffer::get_token_error(int p_offset) const{
+String GDTokenizerBuffer::get_token_error(int p_offset) const {
 
 	ERR_FAIL_V(String());
 }
 
-void GDTokenizerBuffer::advance(int p_amount){
+void GDTokenizerBuffer::advance(int p_amount) {
 
-	ERR_FAIL_INDEX(p_amount+token,tokens.size());
-	token+=p_amount;
+	ERR_FAIL_INDEX(p_amount + token, tokens.size());
+	token += p_amount;
 }
-GDTokenizerBuffer::GDTokenizerBuffer(){
-
-	token=0;
+GDTokenizerBuffer::GDTokenizerBuffer() {
 
+	token = 0;
 }
-
diff --git a/modules/gdscript/gd_tokenizer.h b/modules/gdscript/gd_tokenizer.h
index 1e9eda7947..c1ed8ad92e 100644
--- a/modules/gdscript/gd_tokenizer.h
+++ b/modules/gdscript/gd_tokenizer.h
@@ -29,15 +29,14 @@
 #ifndef GD_TOKENIZER_H
 #define GD_TOKENIZER_H
 
+#include "gd_functions.h"
+#include "string_db.h"
 #include "ustring.h"
 #include "variant.h"
-#include "string_db.h"
-#include "gd_functions.h"
 #include "vmap.h"
 
 class GDTokenizer {
 public:
-
 	enum Token {
 
 		TK_EMPTY,
@@ -137,37 +136,36 @@ public:
 	};
 
 protected:
-
 	enum StringMode {
 		STRING_SINGLE_QUOTE,
 		STRING_DOUBLE_QUOTE,
 		STRING_MULTILINE
 	};
 
-	static const char* token_names[TK_MAX];
+	static const char *token_names[TK_MAX];
+
 public:
 	static const char *get_token_name(Token p_token);
 
-	virtual const Variant& get_token_constant(int p_offset=0) const=0;
-	virtual Token get_token(int p_offset=0) const=0;
-	virtual StringName get_token_identifier(int p_offset=0) const=0;
-	virtual GDFunctions::Function get_token_built_in_func(int p_offset=0) const=0;
-	virtual Variant::Type get_token_type(int p_offset=0) const=0;
-	virtual int get_token_line(int p_offset=0) const=0;
-	virtual int get_token_column(int p_offset=0) const=0;
-	virtual int get_token_line_indent(int p_offset=0) const=0;
-	virtual String get_token_error(int p_offset=0) const=0;
-	virtual void advance(int p_amount=1)=0;
+	virtual const Variant &get_token_constant(int p_offset = 0) const = 0;
+	virtual Token get_token(int p_offset = 0) const = 0;
+	virtual StringName get_token_identifier(int p_offset = 0) const = 0;
+	virtual GDFunctions::Function get_token_built_in_func(int p_offset = 0) const = 0;
+	virtual Variant::Type get_token_type(int p_offset = 0) const = 0;
+	virtual int get_token_line(int p_offset = 0) const = 0;
+	virtual int get_token_column(int p_offset = 0) const = 0;
+	virtual int get_token_line_indent(int p_offset = 0) const = 0;
+	virtual String get_token_error(int p_offset = 0) const = 0;
+	virtual void advance(int p_amount = 1) = 0;
 
 	virtual ~GDTokenizer(){};
-
 };
 
 class GDTokenizerText : public GDTokenizer {
 
 	enum {
-		MAX_LOOKAHEAD=4,
-		TK_RB_SIZE=MAX_LOOKAHEAD*2+1
+		MAX_LOOKAHEAD = 4,
+		TK_RB_SIZE = MAX_LOOKAHEAD * 2 + 1
 
 	};
 
@@ -179,17 +177,21 @@ class GDTokenizerText : public GDTokenizer {
 			Variant::Type vtype; //for type types
 			GDFunctions::Function func; //function for built in functions
 		};
-		int line,col;
-		TokenData() { type = TK_EMPTY; line=col=0; vtype=Variant::NIL; }
+		int line, col;
+		TokenData() {
+			type = TK_EMPTY;
+			line = col = 0;
+			vtype = Variant::NIL;
+		}
 	};
 
 	void _make_token(Token p_type);
-	void _make_newline(int p_spaces=0);
-	void _make_identifier(const StringName& p_identifier);
+	void _make_newline(int p_spaces = 0);
+	void _make_identifier(const StringName &p_identifier);
 	void _make_built_in_func(GDFunctions::Function p_func);
-	void _make_constant(const Variant& p_constant);
-	void _make_type(const Variant::Type& p_type);
-	void _make_error(const String& p_error);
+	void _make_constant(const Variant &p_constant);
+	void _make_type(const Variant::Type &p_type);
+	void _make_error(const String &p_error);
 
 	String code;
 	int len;
@@ -197,66 +199,58 @@ class GDTokenizerText : public GDTokenizer {
 	const CharType *_code;
 	int line;
 	int column;
-	TokenData tk_rb[TK_RB_SIZE*2+1];
+	TokenData tk_rb[TK_RB_SIZE * 2 + 1];
 	int tk_rb_pos;
 	String last_error;
 	bool error_flag;
 
 	void _advance();
-public:
 
-
-	void set_code(const String& p_code);
-	virtual Token get_token(int p_offset=0) const;
-	virtual StringName get_token_identifier(int p_offset=0) const;
-	virtual GDFunctions::Function get_token_built_in_func(int p_offset=0) const;
-	virtual Variant::Type get_token_type(int p_offset=0) const;
-	virtual int get_token_line(int p_offset=0) const;
-	virtual int get_token_column(int p_offset=0) const;
-	virtual int get_token_line_indent(int p_offset=0) const;
-	virtual const Variant& get_token_constant(int p_offset=0) const;
-	virtual String get_token_error(int p_offset=0) const;
-	virtual void advance(int p_amount=1);
+public:
+	void set_code(const String &p_code);
+	virtual Token get_token(int p_offset = 0) const;
+	virtual StringName get_token_identifier(int p_offset = 0) const;
+	virtual GDFunctions::Function get_token_built_in_func(int p_offset = 0) const;
+	virtual Variant::Type get_token_type(int p_offset = 0) const;
+	virtual int get_token_line(int p_offset = 0) const;
+	virtual int get_token_column(int p_offset = 0) const;
+	virtual int get_token_line_indent(int p_offset = 0) const;
+	virtual const Variant &get_token_constant(int p_offset = 0) const;
+	virtual String get_token_error(int p_offset = 0) const;
+	virtual void advance(int p_amount = 1);
 };
 
-
-
-
 class GDTokenizerBuffer : public GDTokenizer {
 
-
 	enum {
 
-		TOKEN_BYTE_MASK=0x80,
-		TOKEN_BITS=8,
-		TOKEN_MASK=(1<<TOKEN_BITS)-1,
-		TOKEN_LINE_BITS=24,
-		TOKEN_LINE_MASK=(1<<TOKEN_LINE_BITS)-1,
+		TOKEN_BYTE_MASK = 0x80,
+		TOKEN_BITS = 8,
+		TOKEN_MASK = (1 << TOKEN_BITS) - 1,
+		TOKEN_LINE_BITS = 24,
+		TOKEN_LINE_MASK = (1 << TOKEN_LINE_BITS) - 1,
 	};
 
-
 	Vector<StringName> identifiers;
 	Vector<Variant> constants;
-	VMap<uint32_t,uint32_t> lines;
+	VMap<uint32_t, uint32_t> lines;
 	Vector<uint32_t> tokens;
 	Variant nil;
 	int token;
 
 public:
-
-
-	Error set_code_buffer(const Vector<uint8_t> & p_buffer);
-	static Vector<uint8_t> parse_code_string(const String& p_code);
-	virtual Token get_token(int p_offset=0) const;
-	virtual StringName get_token_identifier(int p_offset=0) const;
-	virtual GDFunctions::Function get_token_built_in_func(int p_offset=0) const;
-	virtual Variant::Type get_token_type(int p_offset=0) const;
-	virtual int get_token_line(int p_offset=0) const;
-	virtual int get_token_column(int p_offset=0) const;
-	virtual int get_token_line_indent(int p_offset=0) const;
-	virtual const Variant& get_token_constant(int p_offset=0) const;
-	virtual String get_token_error(int p_offset=0) const;
-	virtual void advance(int p_amount=1);
+	Error set_code_buffer(const Vector<uint8_t> &p_buffer);
+	static Vector<uint8_t> parse_code_string(const String &p_code);
+	virtual Token get_token(int p_offset = 0) const;
+	virtual StringName get_token_identifier(int p_offset = 0) const;
+	virtual GDFunctions::Function get_token_built_in_func(int p_offset = 0) const;
+	virtual Variant::Type get_token_type(int p_offset = 0) const;
+	virtual int get_token_line(int p_offset = 0) const;
+	virtual int get_token_column(int p_offset = 0) const;
+	virtual int get_token_line_indent(int p_offset = 0) const;
+	virtual const Variant &get_token_constant(int p_offset = 0) const;
+	virtual String get_token_error(int p_offset = 0) const;
+	virtual void advance(int p_amount = 1);
 	GDTokenizerBuffer();
 };
 
diff --git a/modules/gdscript/register_types.cpp b/modules/gdscript/register_types.cpp
index d1d69c6709..5acd412f7e 100644
--- a/modules/gdscript/register_types.cpp
+++ b/modules/gdscript/register_types.cpp
@@ -29,22 +29,20 @@
 #include "register_types.h"
 
 #include "gd_script.h"
+#include "io/file_access_encrypted.h"
 #include "io/resource_loader.h"
 #include "os/file_access.h"
-#include "io/file_access_encrypted.h"
-
 
-
-GDScriptLanguage *script_language_gd=NULL;
-ResourceFormatLoaderGDScript *resource_loader_gd=NULL;
-ResourceFormatSaverGDScript *resource_saver_gd=NULL;
+GDScriptLanguage *script_language_gd = NULL;
+ResourceFormatLoaderGDScript *resource_loader_gd = NULL;
+ResourceFormatSaverGDScript *resource_saver_gd = NULL;
 #if 0
 #ifdef TOOLS_ENABLED
 
 #include "editor/editor_import_export.h"
-#include "gd_tokenizer.h"
 #include "editor/editor_node.h"
 #include "editor/editor_settings.h"
+#include "gd_tokenizer.h"
 
 class EditorExportGDScript : public EditorExportPlugin {
 
@@ -133,7 +131,6 @@ static void register_editor_plugin() {
 	EditorImportExport::get_singleton()->add_export_plugin(egd);
 }
 
-
 #endif
 #endif
 void register_gdscript_types() {
@@ -141,12 +138,12 @@ void register_gdscript_types() {
 	ClassDB::register_class<GDScript>();
 	ClassDB::register_virtual_class<GDFunctionState>();
 
-	script_language_gd=memnew( GDScriptLanguage );
+	script_language_gd = memnew(GDScriptLanguage);
 	//script_language_gd->init();
 	ScriptServer::register_language(script_language_gd);
-	resource_loader_gd=memnew( ResourceFormatLoaderGDScript );
+	resource_loader_gd = memnew(ResourceFormatLoaderGDScript);
 	ResourceLoader::add_resource_format_loader(resource_loader_gd);
-	resource_saver_gd=memnew( ResourceFormatSaverGDScript );
+	resource_saver_gd = memnew(ResourceFormatSaverGDScript);
 	ResourceSaver::add_resource_format_saver(resource_saver_gd);
 #if 0
 #ifdef TOOLS_ENABLED
@@ -154,18 +151,15 @@ void register_gdscript_types() {
 	EditorNode::add_init_callback(register_editor_plugin);
 #endif
 #endif
-
 }
 void unregister_gdscript_types() {
 
-
 	ScriptServer::unregister_language(script_language_gd);
 
 	if (script_language_gd)
-		memdelete( script_language_gd );
+		memdelete(script_language_gd);
 	if (resource_loader_gd)
-		memdelete( resource_loader_gd );
+		memdelete(resource_loader_gd);
 	if (resource_saver_gd)
-		memdelete( resource_saver_gd );
-
+		memdelete(resource_saver_gd);
 }
diff --git a/modules/gridmap/grid_map.cpp b/modules/gridmap/grid_map.cpp
index d4fb174bfe..128592fa29 100644
--- a/modules/gridmap/grid_map.cpp
+++ b/modules/gridmap/grid_map.cpp
@@ -27,36 +27,36 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "grid_map.h"
-#include "servers/visual_server.h"
-#include "scene/resources/surface_tool.h"
 #include "message_queue.h"
 #include "scene/3d/light.h"
+#include "scene/resources/surface_tool.h"
+#include "servers/visual_server.h"
 
 #include "io/marshalls.h"
-#include "scene/scene_string_names.h"
 #include "os/os.h"
 #include "scene/resources/mesh_library.h"
+#include "scene/scene_string_names.h"
 
-bool GridMap::_set(const StringName& p_name, const Variant& p_value) {
+bool GridMap::_set(const StringName &p_name, const Variant &p_value) {
 
-	String name=p_name;
+	String name = p_name;
 
-	if (name=="theme") {
+	if (name == "theme") {
 
 		set_theme(p_value);
-	} else if (name=="cell_size") {
+	} else if (name == "cell_size") {
 		set_cell_size(p_value);
-	} else if (name=="cell_octant_size") {
+	} else if (name == "cell_octant_size") {
 		set_octant_size(p_value);
-	} else if (name=="cell_center_x") {
+	} else if (name == "cell_center_x") {
 		set_center_x(p_value);
-	} else if (name=="cell_center_y") {
+	} else if (name == "cell_center_y") {
 		set_center_y(p_value);
-	} else if (name=="cell_center_z") {
+	} else if (name == "cell_center_z") {
 		set_center_z(p_value);
-	} else if (name=="cell_scale") {
+	} else if (name == "cell_scale") {
 		set_cell_scale(p_value);
-/*	} else if (name=="cells") {
+		/*	} else if (name=="cells") {
 		PoolVector<int> cells = p_value;
 		int amount=cells.size();
 		PoolVector<int>::Read r = cells.read();
@@ -73,146 +73,138 @@ bool GridMap::_set(const StringName& p_name, const Variant& p_value) {
 
 		}
 		_recreate_octant_data();*/
-	} else if (name=="data") {
+	} else if (name == "data") {
 
 		Dictionary d = p_value;
 
 		if (d.has("cells")) {
 
 			PoolVector<int> cells = d["cells"];
-			int amount=cells.size();
+			int amount = cells.size();
 			PoolVector<int>::Read r = cells.read();
-			ERR_FAIL_COND_V(amount%3,false); // not even
+			ERR_FAIL_COND_V(amount % 3, false); // not even
 			cell_map.clear();
-			for(int i=0;i<amount/3;i++) {
+			for (int i = 0; i < amount / 3; i++) {
 
 				IndexKey ik;
-				ik.key=decode_uint64((const uint8_t*)&r[i*3]);
+				ik.key = decode_uint64((const uint8_t *)&r[i * 3]);
 				Cell cell;
-				cell.cell=decode_uint32((const uint8_t*)&r[i*3+2]);
-				cell_map[ik]=cell;
-
+				cell.cell = decode_uint32((const uint8_t *)&r[i * 3 + 2]);
+				cell_map[ik] = cell;
 			}
 		}
 		_recreate_octant_data();
 
-
 	} else if (name.begins_with("areas/")) {
-		int which = name.get_slicec('/',1).to_int();
-		String what=name.get_slicec('/',2);
-		if (what=="bounds") {
-			ERR_FAIL_COND_V(area_map.has(which),false);
-			create_area(which,p_value);
+		int which = name.get_slicec('/', 1).to_int();
+		String what = name.get_slicec('/', 2);
+		if (what == "bounds") {
+			ERR_FAIL_COND_V(area_map.has(which), false);
+			create_area(which, p_value);
 			return true;
 		}
 
-		ERR_FAIL_COND_V(!area_map.has(which),false);
+		ERR_FAIL_COND_V(!area_map.has(which), false);
 
-		if (what=="name")
-			area_set_name(which,p_value);
-		else if (what=="disable_distance")
-			area_set_portal_disable_distance(which,p_value);
-		else if (what=="exterior_portal")
-			area_set_portal_disable_color(which,p_value);
+		if (what == "name")
+			area_set_name(which, p_value);
+		else if (what == "disable_distance")
+			area_set_portal_disable_distance(which, p_value);
+		else if (what == "exterior_portal")
+			area_set_portal_disable_color(which, p_value);
 		else
 			return false;
 	} else
 		return false;
 
 	return true;
-
-
 }
 
-bool GridMap::_get(const StringName& p_name,Variant &r_ret) const {
-
-	String name=p_name;
-
-	if (name=="theme") {
-		r_ret= get_theme();
-	} else if (name=="cell_size") {
-		r_ret= get_cell_size();
-	} else if (name=="cell_octant_size") {
-		r_ret= get_octant_size();
-	} else if (name=="cell_center_x") {
-		r_ret= get_center_x();
-	} else if (name=="cell_center_y") {
-		r_ret= get_center_y();
-	} else if (name=="cell_center_z") {
-		r_ret= get_center_z();
-	} else if (name=="cell_scale") {
-		r_ret= cell_scale;
-	} else if (name=="data") {
+bool GridMap::_get(const StringName &p_name, Variant &r_ret) const {
+
+	String name = p_name;
+
+	if (name == "theme") {
+		r_ret = get_theme();
+	} else if (name == "cell_size") {
+		r_ret = get_cell_size();
+	} else if (name == "cell_octant_size") {
+		r_ret = get_octant_size();
+	} else if (name == "cell_center_x") {
+		r_ret = get_center_x();
+	} else if (name == "cell_center_y") {
+		r_ret = get_center_y();
+	} else if (name == "cell_center_z") {
+		r_ret = get_center_z();
+	} else if (name == "cell_scale") {
+		r_ret = cell_scale;
+	} else if (name == "data") {
 
 		Dictionary d;
 
 		PoolVector<int> cells;
-		cells.resize(cell_map.size()*3);
+		cells.resize(cell_map.size() * 3);
 		{
 			PoolVector<int>::Write w = cells.write();
-			int i=0;
-			for (Map<IndexKey,Cell>::Element *E=cell_map.front();E;E=E->next(),i++) {
+			int i = 0;
+			for (Map<IndexKey, Cell>::Element *E = cell_map.front(); E; E = E->next(), i++) {
 
-				encode_uint64(E->key().key,(uint8_t*)&w[i*3]);
-				encode_uint32(E->get().cell,(uint8_t*)&w[i*3+2]);
+				encode_uint64(E->key().key, (uint8_t *)&w[i * 3]);
+				encode_uint32(E->get().cell, (uint8_t *)&w[i * 3 + 2]);
 			}
 		}
 
-		d["cells"]=cells;
-
+		d["cells"] = cells;
 
-
-		r_ret= d;
+		r_ret = d;
 	} else if (name.begins_with("areas/")) {
-		int which = name.get_slicec('/',1).to_int();
-		String what=name.get_slicec('/',2);
-		if (what=="bounds")
-			r_ret= area_get_bounds(which);
-		else if (what=="name")
-			r_ret= area_get_name(which);
-		else if (what=="disable_distance")
-			r_ret= area_get_portal_disable_distance(which);
-		else if (what=="exterior_portal")
-			r_ret= area_is_exterior_portal(which);
+		int which = name.get_slicec('/', 1).to_int();
+		String what = name.get_slicec('/', 2);
+		if (what == "bounds")
+			r_ret = area_get_bounds(which);
+		else if (what == "name")
+			r_ret = area_get_name(which);
+		else if (what == "disable_distance")
+			r_ret = area_get_portal_disable_distance(which);
+		else if (what == "exterior_portal")
+			r_ret = area_is_exterior_portal(which);
 		else
 			return false;
 	} else
 		return false;
 
 	return true;
-
 }
 
-void GridMap::_get_property_list( List<PropertyInfo> *p_list) const {
+void GridMap::_get_property_list(List<PropertyInfo> *p_list) const {
 
-	p_list->push_back( PropertyInfo( Variant::OBJECT, "theme", PROPERTY_HINT_RESOURCE_TYPE, "MeshLibrary"));
-	p_list->push_back( PropertyInfo( Variant::NIL, "Cell", PROPERTY_HINT_NONE,"cell_",PROPERTY_USAGE_GROUP));
-	p_list->push_back( PropertyInfo( Variant::REAL, "cell_size",PROPERTY_HINT_RANGE,"0.01,16384,0.01") );
-	p_list->push_back( PropertyInfo( Variant::INT, "cell_octant_size",PROPERTY_HINT_RANGE,"1,1024,1") );
-	p_list->push_back( PropertyInfo( Variant::BOOL, "cell_center_x") );
-	p_list->push_back( PropertyInfo( Variant::BOOL, "cell_center_y") );
-	p_list->push_back( PropertyInfo( Variant::BOOL, "cell_center_z") );
-	p_list->push_back( PropertyInfo( Variant::REAL, "cell_scale") );
+	p_list->push_back(PropertyInfo(Variant::OBJECT, "theme", PROPERTY_HINT_RESOURCE_TYPE, "MeshLibrary"));
+	p_list->push_back(PropertyInfo(Variant::NIL, "Cell", PROPERTY_HINT_NONE, "cell_", PROPERTY_USAGE_GROUP));
+	p_list->push_back(PropertyInfo(Variant::REAL, "cell_size", PROPERTY_HINT_RANGE, "0.01,16384,0.01"));
+	p_list->push_back(PropertyInfo(Variant::INT, "cell_octant_size", PROPERTY_HINT_RANGE, "1,1024,1"));
+	p_list->push_back(PropertyInfo(Variant::BOOL, "cell_center_x"));
+	p_list->push_back(PropertyInfo(Variant::BOOL, "cell_center_y"));
+	p_list->push_back(PropertyInfo(Variant::BOOL, "cell_center_z"));
+	p_list->push_back(PropertyInfo(Variant::REAL, "cell_scale"));
 
-	p_list->push_back( PropertyInfo( Variant::DICTIONARY, "data", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
+	p_list->push_back(PropertyInfo(Variant::DICTIONARY, "data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE));
 
-	for(const Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
+	for (const Map<int, Area *>::Element *E = area_map.front(); E; E = E->next()) {
 
-		String base="areas/"+itos(E->key())+"/";
-		p_list->push_back( PropertyInfo( Variant::RECT3, base+"bounds", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
-		p_list->push_back( PropertyInfo( Variant::STRING, base+"name", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
-		p_list->push_back( PropertyInfo( Variant::REAL, base+"disable_distance", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
-		p_list->push_back( PropertyInfo( Variant::COLOR, base+"disable_color", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
-		p_list->push_back( PropertyInfo( Variant::BOOL, base+"exterior_portal", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
+		String base = "areas/" + itos(E->key()) + "/";
+		p_list->push_back(PropertyInfo(Variant::RECT3, base + "bounds", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE));
+		p_list->push_back(PropertyInfo(Variant::STRING, base + "name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE));
+		p_list->push_back(PropertyInfo(Variant::REAL, base + "disable_distance", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE));
+		p_list->push_back(PropertyInfo(Variant::COLOR, base + "disable_color", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE));
+		p_list->push_back(PropertyInfo(Variant::BOOL, base + "exterior_portal", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE));
 	}
 }
 
-
-void GridMap::set_theme(const Ref<MeshLibrary>& p_theme) {
+void GridMap::set_theme(const Ref<MeshLibrary> &p_theme) {
 
 	if (!theme.is_null())
 		theme->unregister_owner(this);
-	theme=p_theme;
+	theme = p_theme;
 	if (!theme.is_null())
 		theme->register_owner(this);
 
@@ -220,35 +212,34 @@ void GridMap::set_theme(const Ref<MeshLibrary>& p_theme) {
 	_change_notify("theme");
 }
 
-Ref<MeshLibrary> GridMap::get_theme() const{
+Ref<MeshLibrary> GridMap::get_theme() const {
 
 	return theme;
 }
 
-void GridMap::set_cell_size(float p_size){
+void GridMap::set_cell_size(float p_size) {
 
-	cell_size=p_size;
+	cell_size = p_size;
 	_recreate_octant_data();
-
 }
-float GridMap::get_cell_size() const{
+float GridMap::get_cell_size() const {
 
 	return cell_size;
 }
 
-void GridMap::set_octant_size(int p_size){
+void GridMap::set_octant_size(int p_size) {
 
-	octant_size=p_size;
+	octant_size = p_size;
 	_recreate_octant_data();
 }
-int GridMap::get_octant_size() const{
+int GridMap::get_octant_size() const {
 
 	return octant_size;
 }
 
 void GridMap::set_center_x(bool p_enable) {
 
-	center_x=p_enable;
+	center_x = p_enable;
 	_recreate_octant_data();
 }
 
@@ -258,7 +249,7 @@ bool GridMap::get_center_x() const {
 
 void GridMap::set_center_y(bool p_enable) {
 
-	center_y=p_enable;
+	center_y = p_enable;
 	_recreate_octant_data();
 }
 
@@ -268,7 +259,7 @@ bool GridMap::get_center_y() const {
 
 void GridMap::set_center_z(bool p_enable) {
 
-	center_z=p_enable;
+	center_z = p_enable;
 	_recreate_octant_data();
 }
 
@@ -276,56 +267,52 @@ bool GridMap::get_center_z() const {
 	return center_z;
 }
 
+int GridMap::_find_area(const IndexKey &p_pos) const {
 
-int GridMap::_find_area(const IndexKey& p_pos) const {
-
-	for(const Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
-	//this should somehow be faster...
-		const Area& a=*E->get();
-		if (	p_pos.x>=a.from.x && p_pos.x<a.to.x &&
-			p_pos.y>=a.from.y && p_pos.y<a.to.y &&
-			p_pos.z>=a.from.z && p_pos.z<a.to.z ) {
+	for (const Map<int, Area *>::Element *E = area_map.front(); E; E = E->next()) {
+		//this should somehow be faster...
+		const Area &a = *E->get();
+		if (p_pos.x >= a.from.x && p_pos.x < a.to.x &&
+				p_pos.y >= a.from.y && p_pos.y < a.to.y &&
+				p_pos.z >= a.from.z && p_pos.z < a.to.z) {
 			return E->key();
 		}
 	}
 
 	return 0;
 }
-void GridMap::set_cell_item(int p_x,int p_y,int p_z, int p_item,int p_rot){
+void GridMap::set_cell_item(int p_x, int p_y, int p_z, int p_item, int p_rot) {
 
-	ERR_FAIL_INDEX(ABS(p_x),1<<20);
-	ERR_FAIL_INDEX(ABS(p_y),1<<20);
-	ERR_FAIL_INDEX(ABS(p_z),1<<20);
+	ERR_FAIL_INDEX(ABS(p_x), 1 << 20);
+	ERR_FAIL_INDEX(ABS(p_y), 1 << 20);
+	ERR_FAIL_INDEX(ABS(p_z), 1 << 20);
 
 	IndexKey key;
-	key.x=p_x;
-	key.y=p_y;
-	key.z=p_z;
+	key.x = p_x;
+	key.y = p_y;
+	key.z = p_z;
 
 	OctantKey ok;
-	ok.x=p_x/octant_size;
-	ok.y=p_y/octant_size;
-	ok.z=p_z/octant_size;
+	ok.x = p_x / octant_size;
+	ok.y = p_y / octant_size;
+	ok.z = p_z / octant_size;
 	ok.area = _find_area(key);
 
-
 	if (cell_map.has(key)) {
 
-		int prev_item=cell_map[key].item;
+		int prev_item = cell_map[key].item;
 
-		OctantKey octantkey=ok;
+		OctantKey octantkey = ok;
 
 		ERR_FAIL_COND(!octant_map.has(octantkey));
-		Octant& g = *octant_map[octantkey];
+		Octant &g = *octant_map[octantkey];
 		ERR_FAIL_COND(!g.items.has(prev_item));
 		ERR_FAIL_COND(!g.items[prev_item].cells.has(key));
 
-
 		g.items[prev_item].cells.erase(key);
-		if (g.items[prev_item].cells.size()==0) {
+		if (g.items[prev_item].cells.size() == 0) {
 			VS::get_singleton()->free(g.items[prev_item].multimesh_instance);
 			g.items.erase(prev_item);
-
 		}
 		if (g.items.empty()) {
 
@@ -339,136 +326,129 @@ void GridMap::set_cell_item(int p_x,int p_y,int p_z, int p_item,int p_rot){
 			octant_map.erase(octantkey);
 		} else {
 
-
-			g.dirty=true;
+			g.dirty = true;
 		}
 		cell_map.erase(key);
 
 		_queue_dirty_map();
 	}
 
-	if (p_item<0)
+	if (p_item < 0)
 		return;
 
-	OctantKey octantkey=ok;
+	OctantKey octantkey = ok;
 
 	//add later
 	if (!octant_map.has(octantkey)) {
 
-
-		Octant *g = memnew( Octant );
-		g->dirty=true;
+		Octant *g = memnew(Octant);
+		g->dirty = true;
 		g->static_body = PhysicsServer::get_singleton()->body_create(PhysicsServer::BODY_MODE_STATIC);
-		PhysicsServer::get_singleton()->body_attach_object_instance_ID(g->static_body,get_instance_ID());
+		PhysicsServer::get_singleton()->body_attach_object_instance_ID(g->static_body, get_instance_ID());
 		if (is_inside_world())
-			PhysicsServer::get_singleton()->body_set_space(g->static_body,get_world()->get_space());
+			PhysicsServer::get_singleton()->body_set_space(g->static_body, get_world()->get_space());
 
-		SceneTree *st=SceneTree::get_singleton();
+		SceneTree *st = SceneTree::get_singleton();
 
 		if (st && st->is_debugging_collisions_hint()) {
 
-			g->collision_debug=VisualServer::get_singleton()->mesh_create();
-			g->collision_debug_instance=VisualServer::get_singleton()->instance_create();
-			VisualServer::get_singleton()->instance_set_base(g->collision_debug_instance,g->collision_debug);
+			g->collision_debug = VisualServer::get_singleton()->mesh_create();
+			g->collision_debug_instance = VisualServer::get_singleton()->instance_create();
+			VisualServer::get_singleton()->instance_set_base(g->collision_debug_instance, g->collision_debug);
 			if (is_inside_world()) {
-				VisualServer::get_singleton()->instance_set_scenario(g->collision_debug_instance,get_world()->get_scenario());
-				VisualServer::get_singleton()->instance_set_transform(g->collision_debug_instance,get_global_transform());
+				VisualServer::get_singleton()->instance_set_scenario(g->collision_debug_instance, get_world()->get_scenario());
+				VisualServer::get_singleton()->instance_set_transform(g->collision_debug_instance, get_global_transform());
 			}
-
 		}
 
-		octant_map[octantkey]=g;
+		octant_map[octantkey] = g;
 	}
 
-	Octant& g = *octant_map[octantkey];
+	Octant &g = *octant_map[octantkey];
 	if (!g.items.has(p_item)) {
 
 		Octant::ItemInstances ii;
 		if (theme.is_valid() && theme->has_item(p_item)) {
-			ii.mesh=theme->get_item_mesh(p_item);
-			ii.shape=theme->get_item_shape(p_item);
-			ii.navmesh=theme->get_item_navmesh(p_item);
+			ii.mesh = theme->get_item_mesh(p_item);
+			ii.shape = theme->get_item_shape(p_item);
+			ii.navmesh = theme->get_item_navmesh(p_item);
 		}
-		ii.multimesh = Ref<MultiMesh>( memnew( MultiMesh ) );
+		ii.multimesh = Ref<MultiMesh>(memnew(MultiMesh));
 		ii.multimesh->set_color_format(MultiMesh::COLOR_NONE);
 		ii.multimesh->set_transform_format(MultiMesh::TRANSFORM_3D);
 		ii.multimesh->set_mesh(ii.mesh);
 		ii.multimesh_instance = VS::get_singleton()->instance_create();
-		VS::get_singleton()->instance_set_base(ii.multimesh_instance,ii.multimesh->get_rid());
+		VS::get_singleton()->instance_set_base(ii.multimesh_instance, ii.multimesh->get_rid());
 
-		g.items[p_item]=ii;
+		g.items[p_item] = ii;
 	}
 
 	Octant::ItemInstances &ii = g.items[p_item];
 	ii.cells.insert(key);
-	g.dirty=true;
+	g.dirty = true;
 
 	_queue_dirty_map();
 
-	cell_map[key]=Cell();
-	Cell &c=cell_map[key];
-	c.item=p_item;
-	c.rot=p_rot;
-
+	cell_map[key] = Cell();
+	Cell &c = cell_map[key];
+	c.item = p_item;
+	c.rot = p_rot;
 }
 
-int GridMap::get_cell_item(int p_x,int p_y,int p_z) const{
-
-	ERR_FAIL_INDEX_V(ABS(p_x),1<<20,INVALID_CELL_ITEM);
-	ERR_FAIL_INDEX_V(ABS(p_y),1<<20,INVALID_CELL_ITEM);
-	ERR_FAIL_INDEX_V(ABS(p_z),1<<20,INVALID_CELL_ITEM);
+int GridMap::get_cell_item(int p_x, int p_y, int p_z) const {
 
+	ERR_FAIL_INDEX_V(ABS(p_x), 1 << 20, INVALID_CELL_ITEM);
+	ERR_FAIL_INDEX_V(ABS(p_y), 1 << 20, INVALID_CELL_ITEM);
+	ERR_FAIL_INDEX_V(ABS(p_z), 1 << 20, INVALID_CELL_ITEM);
 
 	IndexKey key;
-	key.x=p_x;
-	key.y=p_y;
-	key.z=p_z;
+	key.x = p_x;
+	key.y = p_y;
+	key.z = p_z;
 
 	if (!cell_map.has(key))
 		return INVALID_CELL_ITEM;
 	return cell_map[key].item;
-
 }
 
-int GridMap::get_cell_item_orientation(int p_x,int p_y,int p_z) const{
+int GridMap::get_cell_item_orientation(int p_x, int p_y, int p_z) const {
 
-	ERR_FAIL_INDEX_V(ABS(p_x),1<<20,-1);
-	ERR_FAIL_INDEX_V(ABS(p_y),1<<20,-1);
-	ERR_FAIL_INDEX_V(ABS(p_z),1<<20,-1);
+	ERR_FAIL_INDEX_V(ABS(p_x), 1 << 20, -1);
+	ERR_FAIL_INDEX_V(ABS(p_y), 1 << 20, -1);
+	ERR_FAIL_INDEX_V(ABS(p_z), 1 << 20, -1);
 
 	IndexKey key;
-	key.x=p_x;
-	key.y=p_y;
-	key.z=p_z;
+	key.x = p_x;
+	key.y = p_y;
+	key.z = p_z;
 
 	if (!cell_map.has(key))
 		return -1;
 	return cell_map[key].rot;
-
 }
 
-void GridMap::_octant_enter_tree(const OctantKey &p_key){
+void GridMap::_octant_enter_tree(const OctantKey &p_key) {
 	ERR_FAIL_COND(!octant_map.has(p_key));
-	if(navigation){
-		Octant&g = *octant_map[p_key];
+	if (navigation) {
+		Octant &g = *octant_map[p_key];
 
-		Vector3 ofs(cell_size*0.5*int(center_x),cell_size*0.5*int(center_y),cell_size*0.5*int(center_z));
+		Vector3 ofs(cell_size * 0.5 * int(center_x), cell_size * 0.5 * int(center_y), cell_size * 0.5 * int(center_z));
 		_octant_clear_navmesh(p_key);
 
-		for(Map<int,Octant::ItemInstances>::Element *E=g.items.front();E;E=E->next()) {
-			Octant::ItemInstances &ii=E->get();
+		for (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
+			Octant::ItemInstances &ii = E->get();
 
-			for(Set<IndexKey>::Element *F=ii.cells.front();F;F=F->next()) {
+			for (Set<IndexKey>::Element *F = ii.cells.front(); F; F = F->next()) {
 
-				IndexKey ik=F->get();
-				Map<IndexKey,Cell>::Element *C=cell_map.find(ik);
+				IndexKey ik = F->get();
+				Map<IndexKey, Cell>::Element *C = cell_map.find(ik);
 				ERR_CONTINUE(!C);
 
-				Vector3 cellpos = Vector3(ik.x,ik.y,ik.z );
+				Vector3 cellpos = Vector3(ik.x, ik.y, ik.z);
 
 				Transform xform;
 
-				if (clip && ( (clip_above && cellpos[clip_axis]>clip_floor) || (!clip_above && cellpos[clip_axis]<clip_floor))) {
+				if (clip && ((clip_above && cellpos[clip_axis] > clip_floor) || (!clip_above && cellpos[clip_axis] < clip_floor))) {
 
 					xform.basis.set_zero();
 
@@ -477,16 +457,15 @@ void GridMap::_octant_enter_tree(const OctantKey &p_key){
 					xform.basis.set_orthogonal_index(C->get().rot);
 				}
 
-
-				xform.set_origin( cellpos*cell_size+ofs);
-				xform.basis.scale(Vector3(cell_scale,cell_scale,cell_scale));
+				xform.set_origin(cellpos * cell_size + ofs);
+				xform.basis.scale(Vector3(cell_scale, cell_scale, cell_scale));
 				// add the item's navmesh at given xform to GridMap's Navigation ancestor
-				if(ii.navmesh.is_valid()){
-					int nm_id = navigation->navmesh_create(ii.navmesh,xform,this);
+				if (ii.navmesh.is_valid()) {
+					int nm_id = navigation->navmesh_create(ii.navmesh, xform, this);
 					Octant::NavMesh nm;
-					nm.id=nm_id;
-					nm.xform=xform;
-					g.navmesh_ids[ik]=nm;
+					nm.id = nm_id;
+					nm.xform = xform;
+					g.navmesh_ids[ik] = nm;
 				}
 			}
 		}
@@ -496,56 +475,53 @@ void GridMap::_octant_enter_tree(const OctantKey &p_key){
 void GridMap::_octant_enter_world(const OctantKey &p_key) {
 
 	ERR_FAIL_COND(!octant_map.has(p_key));
-	Octant&g = *octant_map[p_key];
-	PhysicsServer::get_singleton()->body_set_state(g.static_body,PhysicsServer::BODY_STATE_TRANSFORM,get_global_transform());
-	PhysicsServer::get_singleton()->body_set_space(g.static_body,get_world()->get_space());
+	Octant &g = *octant_map[p_key];
+	PhysicsServer::get_singleton()->body_set_state(g.static_body, PhysicsServer::BODY_STATE_TRANSFORM, get_global_transform());
+	PhysicsServer::get_singleton()->body_set_space(g.static_body, get_world()->get_space());
 	//print_line("BODYPOS: "+get_global_transform());
 
-
 	if (g.collision_debug_instance.is_valid()) {
-		VS::get_singleton()->instance_set_scenario(g.collision_debug_instance,get_world()->get_scenario());
-		VS::get_singleton()->instance_set_transform(g.collision_debug_instance,get_global_transform());
+		VS::get_singleton()->instance_set_scenario(g.collision_debug_instance, get_world()->get_scenario());
+		VS::get_singleton()->instance_set_transform(g.collision_debug_instance, get_global_transform());
 		if (area_map.has(p_key.area)) {
-			VS::get_singleton()->instance_set_room(g.collision_debug_instance,area_map[p_key.area]->instance);
+			VS::get_singleton()->instance_set_room(g.collision_debug_instance, area_map[p_key.area]->instance);
 		}
 	}
-	for(Map<int,Octant::ItemInstances>::Element *E=g.items.front();E;E=E->next()) {
+	for (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
 
-		VS::get_singleton()->instance_set_scenario(E->get().multimesh_instance,get_world()->get_scenario());
-		VS::get_singleton()->instance_set_transform(E->get().multimesh_instance,get_global_transform());
+		VS::get_singleton()->instance_set_scenario(E->get().multimesh_instance, get_world()->get_scenario());
+		VS::get_singleton()->instance_set_transform(E->get().multimesh_instance, get_global_transform());
 		//print_line("INSTANCEPOS: "+get_global_transform());
 
 		if (area_map.has(p_key.area)) {
-			VS::get_singleton()->instance_set_room(E->get().multimesh_instance,area_map[p_key.area]->instance);
+			VS::get_singleton()->instance_set_room(E->get().multimesh_instance, area_map[p_key.area]->instance);
 		}
 	}
 }
 
-
 void GridMap::_octant_transform(const OctantKey &p_key) {
 
 	ERR_FAIL_COND(!octant_map.has(p_key));
-	Octant&g = *octant_map[p_key];
-	PhysicsServer::get_singleton()->body_set_state(g.static_body,PhysicsServer::BODY_STATE_TRANSFORM,get_global_transform());
+	Octant &g = *octant_map[p_key];
+	PhysicsServer::get_singleton()->body_set_state(g.static_body, PhysicsServer::BODY_STATE_TRANSFORM, get_global_transform());
 
 	if (g.collision_debug_instance.is_valid()) {
-		VS::get_singleton()->instance_set_transform(g.collision_debug_instance,get_global_transform());
+		VS::get_singleton()->instance_set_transform(g.collision_debug_instance, get_global_transform());
 	}
 
-	for(Map<int,Octant::ItemInstances>::Element *E=g.items.front();E;E=E->next()) {
+	for (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
 
-		VS::get_singleton()->instance_set_transform(E->get().multimesh_instance,get_global_transform());
+		VS::get_singleton()->instance_set_transform(E->get().multimesh_instance, get_global_transform());
 		//print_line("UPDATEPOS: "+get_global_transform());
 	}
-
 }
 
-void GridMap::_octant_clear_navmesh(const OctantKey &p_key){
-	Octant&g = *octant_map[p_key];
+void GridMap::_octant_clear_navmesh(const OctantKey &p_key) {
+	Octant &g = *octant_map[p_key];
 	if (navigation) {
-		for(Map<IndexKey,Octant::NavMesh>::Element *E=g.navmesh_ids.front();E;E=E->next()) {
+		for (Map<IndexKey, Octant::NavMesh>::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
 			Octant::NavMesh *nvm = &E->get();
-			if(nvm && nvm->id){
+			if (nvm && nvm->id) {
 				navigation->navmesh_remove(E->get().id);
 			}
 		}
@@ -555,7 +531,7 @@ void GridMap::_octant_clear_navmesh(const OctantKey &p_key){
 
 void GridMap::_octant_update(const OctantKey &p_key) {
 	ERR_FAIL_COND(!octant_map.has(p_key));
-	Octant&g = *octant_map[p_key];
+	Octant &g = *octant_map[p_key];
 	if (!g.dirty)
 		return;
 
@@ -576,31 +552,30 @@ void GridMap::_octant_update(const OctantKey &p_key) {
 	 * set item's multimesh's instance count to number of cells which have this item
 	 * and set said multimesh bounding box to one containing all cells which have this item
 	 */
-	for(Map<int,Octant::ItemInstances>::Element *E=g.items.front();E;E=E->next()) {
+	for (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
 
-		Octant::ItemInstances &ii=E->get();
+		Octant::ItemInstances &ii = E->get();
 
 		ii.multimesh->set_instance_count(ii.cells.size());
 
 		Rect3 aabb;
-		Rect3 mesh_aabb = ii.mesh.is_null()?Rect3():ii.mesh->get_aabb();
-
-		Vector3 ofs(cell_size*0.5*int(center_x),cell_size*0.5*int(center_y),cell_size*0.5*int(center_z));
+		Rect3 mesh_aabb = ii.mesh.is_null() ? Rect3() : ii.mesh->get_aabb();
 
+		Vector3 ofs(cell_size * 0.5 * int(center_x), cell_size * 0.5 * int(center_y), cell_size * 0.5 * int(center_z));
 
 		//print_line("OCTANT, CELLS: "+itos(ii.cells.size()));
-		int idx=0;
+		int idx = 0;
 		// foreach cell containing this item type
-		for(Set<IndexKey>::Element *F=ii.cells.front();F;F=F->next()) {
-			IndexKey ik=F->get();
-			Map<IndexKey,Cell>::Element *C=cell_map.find(ik);
+		for (Set<IndexKey>::Element *F = ii.cells.front(); F; F = F->next()) {
+			IndexKey ik = F->get();
+			Map<IndexKey, Cell>::Element *C = cell_map.find(ik);
 			ERR_CONTINUE(!C);
 
-			Vector3 cellpos = Vector3(ik.x,ik.y,ik.z );
+			Vector3 cellpos = Vector3(ik.x, ik.y, ik.z);
 
 			Transform xform;
 
-			if (clip && ( (clip_above && cellpos[clip_axis]>clip_floor) || (!clip_above && cellpos[clip_axis]<clip_floor))) {
+			if (clip && ((clip_above && cellpos[clip_axis] > clip_floor) || (!clip_above && cellpos[clip_axis] < clip_floor))) {
 
 				xform.basis.set_zero();
 
@@ -609,19 +584,17 @@ void GridMap::_octant_update(const OctantKey &p_key) {
 				xform.basis.set_orthogonal_index(C->get().rot);
 			}
 
+			xform.set_origin(cellpos * cell_size + ofs);
+			xform.basis.scale(Vector3(cell_scale, cell_scale, cell_scale));
 
-			xform.set_origin( cellpos*cell_size+ofs);
-			xform.basis.scale(Vector3(cell_scale,cell_scale,cell_scale));
-
-			ii.multimesh->set_instance_transform(idx,xform);
+			ii.multimesh->set_instance_transform(idx, xform);
 			//ii.multimesh->set_instance_transform(idx,Transform()	);
 			//ii.multimesh->set_instance_color(idx,Color(1,1,1,1));
 			//print_line("MMINST: "+xform);
 
+			if (idx == 0) {
 
-			if(idx==0) {
-
-				aabb=xform.xform(mesh_aabb);
+				aabb = xform.xform(mesh_aabb);
 			} else {
 
 				aabb.merge_with(xform.xform(mesh_aabb));
@@ -630,22 +603,22 @@ void GridMap::_octant_update(const OctantKey &p_key) {
 			// add the item's shape at given xform to octant's static_body
 			if (ii.shape.is_valid()) {
 				// add the item's shape
-				PhysicsServer::get_singleton()->body_add_shape(g.static_body,ii.shape->get_rid(),xform);
+				PhysicsServer::get_singleton()->body_add_shape(g.static_body, ii.shape->get_rid(), xform);
 				if (g.collision_debug.is_valid()) {
-					ii.shape->add_vertices_to_array(col_debug,xform);
+					ii.shape->add_vertices_to_array(col_debug, xform);
 				}
 
 				//print_line("PHIS x: "+xform);
 			}
 
 			// add the item's navmesh at given xform to GridMap's Navigation ancestor
-			if(navigation){
-				if(ii.navmesh.is_valid()){
-					int nm_id = navigation->navmesh_create(ii.navmesh,xform,this);
+			if (navigation) {
+				if (ii.navmesh.is_valid()) {
+					int nm_id = navigation->navmesh_create(ii.navmesh, xform, this);
 					Octant::NavMesh nm;
-					nm.id=nm_id;
-					nm.xform=xform;
-					g.navmesh_ids[ik]=nm;
+					nm.id = nm_id;
+					nm.xform = xform;
+					g.navmesh_ids[ik] = nm;
 				}
 			}
 
@@ -653,95 +626,84 @@ void GridMap::_octant_update(const OctantKey &p_key) {
 		}
 
 		//ii.multimesh->set_aabb(aabb);
-
-
 	}
 
 	if (col_debug.size()) {
 
-
 		Array arr;
 		arr.resize(VS::ARRAY_MAX);
-		arr[VS::ARRAY_VERTEX]=col_debug;
+		arr[VS::ARRAY_VERTEX] = col_debug;
 
-		VS::get_singleton()->mesh_add_surface_from_arrays(g.collision_debug,VS::PRIMITIVE_LINES,arr);
-		SceneTree *st=SceneTree::get_singleton();
+		VS::get_singleton()->mesh_add_surface_from_arrays(g.collision_debug, VS::PRIMITIVE_LINES, arr);
+		SceneTree *st = SceneTree::get_singleton();
 		if (st) {
-			VS::get_singleton()->mesh_surface_set_material( g.collision_debug, 0,st->get_debug_collision_material()->get_rid() );
+			VS::get_singleton()->mesh_surface_set_material(g.collision_debug, 0, st->get_debug_collision_material()->get_rid());
 		}
 	}
 
-	g.dirty=false;
-
+	g.dirty = false;
 }
 
-
 void GridMap::_octant_exit_world(const OctantKey &p_key) {
 
 	ERR_FAIL_COND(!octant_map.has(p_key));
-	Octant&g = *octant_map[p_key];
-	PhysicsServer::get_singleton()->body_set_state(g.static_body,PhysicsServer::BODY_STATE_TRANSFORM,get_global_transform());
-	PhysicsServer::get_singleton()->body_set_space(g.static_body,RID());
-
+	Octant &g = *octant_map[p_key];
+	PhysicsServer::get_singleton()->body_set_state(g.static_body, PhysicsServer::BODY_STATE_TRANSFORM, get_global_transform());
+	PhysicsServer::get_singleton()->body_set_space(g.static_body, RID());
 
 	if (g.collision_debug_instance.is_valid()) {
 
-		VS::get_singleton()->instance_set_room(g.collision_debug_instance,RID());
-		VS::get_singleton()->instance_set_scenario(g.collision_debug_instance,RID());
+		VS::get_singleton()->instance_set_room(g.collision_debug_instance, RID());
+		VS::get_singleton()->instance_set_scenario(g.collision_debug_instance, RID());
 	}
 
-	for(Map<int,Octant::ItemInstances>::Element *E=g.items.front();E;E=E->next()) {
+	for (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
 
-		VS::get_singleton()->instance_set_scenario(E->get().multimesh_instance,RID());
+		VS::get_singleton()->instance_set_scenario(E->get().multimesh_instance, RID());
 		//VS::get_singleton()->instance_set_transform(E->get().multimesh_instance,get_global_transform());
-		VS::get_singleton()->instance_set_room(E->get().multimesh_instance,RID());
+		VS::get_singleton()->instance_set_room(E->get().multimesh_instance, RID());
 	}
-
 }
 
-
 void GridMap::_notification(int p_what) {
 
-
-	switch(p_what) {
+	switch (p_what) {
 
 		case NOTIFICATION_ENTER_WORLD: {
 
 			_update_area_instances();
 
-			for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
+			for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
 				//IndexKey ik;
 				//ik.key = E->key().indexkey;
 				_octant_enter_world(E->key());
 				_octant_update(E->key());
 			}
 
-			awaiting_update=false;
-
-			last_transform=get_global_transform();
+			awaiting_update = false;
 
+			last_transform = get_global_transform();
 
 		} break;
 		case NOTIFICATION_TRANSFORM_CHANGED: {
 
 			Transform new_xform = get_global_transform();
-			if (new_xform==last_transform)
+			if (new_xform == last_transform)
 				break;
 			//update run
-			for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
+			for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
 				_octant_transform(E->key());
 			}
 
-			last_transform=new_xform;
+			last_transform = new_xform;
 
 		} break;
 		case NOTIFICATION_EXIT_WORLD: {
 
-			for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
+			for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
 				_octant_exit_world(E->key());
 			}
 
-
 			//_queue_dirty_map(MAP_DIRTY_INSTANCES|MAP_DIRTY_TRANSFORMS);
 			//_update_dirty_map_callback();
 			//_update_area_instances();
@@ -749,41 +711,39 @@ void GridMap::_notification(int p_what) {
 		} break;
 		case NOTIFICATION_ENTER_TREE: {
 
-			Spatial *c=this;
-			while(c) {
-				navigation=c->cast_to<Navigation>();
+			Spatial *c = this;
+			while (c) {
+				navigation = c->cast_to<Navigation>();
 				if (navigation) {
 					break;
 				}
 
-				c=c->get_parent()->cast_to<Spatial>();
+				c = c->get_parent()->cast_to<Spatial>();
 			}
 
-			if(navigation){
-				for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
+			if (navigation) {
+				for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
 					if (navigation) {
 						_octant_enter_tree(E->key());
 					}
 				}
 			}
 
-		   _queue_dirty_map();
+			_queue_dirty_map();
 		} break;
 		case NOTIFICATION_EXIT_TREE: {
-			for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
+			for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
 				if (navigation) {
 					_octant_clear_navmesh(E->key());
 				}
 			}
 
-			navigation=NULL;
+			navigation = NULL;
 
 		} break;
 	}
 }
 
-
-
 void GridMap::_queue_dirty_map() {
 
 	if (awaiting_update)
@@ -791,34 +751,32 @@ void GridMap::_queue_dirty_map() {
 
 	if (is_inside_world()) {
 
-		MessageQueue::get_singleton()->push_call(this,"_update_dirty_map_callback");
-		awaiting_update=true;
+		MessageQueue::get_singleton()->push_call(this, "_update_dirty_map_callback");
+		awaiting_update = true;
 	}
 }
 
 void GridMap::_recreate_octant_data() {
 
-	Map<IndexKey,Cell> cell_copy=cell_map;
+	Map<IndexKey, Cell> cell_copy = cell_map;
 	_clear_internal(true);
-	for (Map<IndexKey,Cell>::Element *E=cell_copy.front();E;E=E->next()) {
+	for (Map<IndexKey, Cell>::Element *E = cell_copy.front(); E; E = E->next()) {
 
-		set_cell_item(E->key().x,E->key().y,E->key().z,E->get().item,E->get().rot);
+		set_cell_item(E->key().x, E->key().y, E->key().z, E->get().item, E->get().rot);
 	}
-
 }
 
 void GridMap::_clear_internal(bool p_keep_areas) {
 
-	for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
+	for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
 		if (is_inside_world())
 			_octant_exit_world(E->key());
 
-		for (Map<int,Octant::ItemInstances>::Element *F=E->get()->items.front();F;F=F->next()) {
+		for (Map<int, Octant::ItemInstances>::Element *F = E->get()->items.front(); F; F = F->next()) {
 
 			VS::get_singleton()->free(F->get().multimesh_instance);
 		}
 
-
 		if (E->get()->collision_debug.is_valid())
 			VS::get_singleton()->free(E->get()->collision_debug);
 		if (E->get()->collision_debug_instance.is_valid())
@@ -826,7 +784,6 @@ void GridMap::_clear_internal(bool p_keep_areas) {
 
 		PhysicsServer::get_singleton()->free(E->get()->static_body);
 		memdelete(E->get());
-
 	}
 
 	octant_map.clear();
@@ -835,253 +792,231 @@ void GridMap::_clear_internal(bool p_keep_areas) {
 	if (p_keep_areas)
 		return;
 
-	for (Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
-
+	for (Map<int, Area *>::Element *E = area_map.front(); E; E = E->next()) {
 
 		VS::get_singleton()->free(E->get()->base_portal);
 		VS::get_singleton()->free(E->get()->instance);
-		for(int i=0;i<E->get()->portals.size();i++) {
+		for (int i = 0; i < E->get()->portals.size(); i++) {
 			VS::get_singleton()->free(E->get()->portals[i].instance);
 		}
 
 		memdelete(E->get());
 	}
-
 }
 
 void GridMap::clear() {
 
 	_clear_internal();
-
 }
 
-void GridMap::resource_changed(const RES& p_res) {
+void GridMap::resource_changed(const RES &p_res) {
 
 	_recreate_octant_data();
 }
 
-
 void GridMap::_update_dirty_map_callback() {
 
 	if (!awaiting_update)
 		return;
 
-	for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
+	for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
 		_octant_update(E->key());
 	}
 
-
-	awaiting_update=false;
-
+	awaiting_update = false;
 }
 
-
 void GridMap::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_theme","theme:MeshLibrary"),&GridMap::set_theme);
-	ClassDB::bind_method(D_METHOD("get_theme:MeshLibrary"),&GridMap::get_theme);
+	ClassDB::bind_method(D_METHOD("set_theme", "theme:MeshLibrary"), &GridMap::set_theme);
+	ClassDB::bind_method(D_METHOD("get_theme:MeshLibrary"), &GridMap::get_theme);
 
-	ClassDB::bind_method(D_METHOD("set_cell_size","size"),&GridMap::set_cell_size);
-	ClassDB::bind_method(D_METHOD("get_cell_size"),&GridMap::get_cell_size);
+	ClassDB::bind_method(D_METHOD("set_cell_size", "size"), &GridMap::set_cell_size);
+	ClassDB::bind_method(D_METHOD("get_cell_size"), &GridMap::get_cell_size);
 
-	ClassDB::bind_method(D_METHOD("set_octant_size","size"),&GridMap::set_octant_size);
-	ClassDB::bind_method(D_METHOD("get_octant_size"),&GridMap::get_octant_size);
+	ClassDB::bind_method(D_METHOD("set_octant_size", "size"), &GridMap::set_octant_size);
+	ClassDB::bind_method(D_METHOD("get_octant_size"), &GridMap::get_octant_size);
 
-	ClassDB::bind_method(D_METHOD("set_cell_item","x","y","z","item","orientation"),&GridMap::set_cell_item,DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("get_cell_item","x","y","z"),&GridMap::get_cell_item);
-	ClassDB::bind_method(D_METHOD("get_cell_item_orientation","x","y","z"),&GridMap::get_cell_item_orientation);
+	ClassDB::bind_method(D_METHOD("set_cell_item", "x", "y", "z", "item", "orientation"), &GridMap::set_cell_item, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_cell_item", "x", "y", "z"), &GridMap::get_cell_item);
+	ClassDB::bind_method(D_METHOD("get_cell_item_orientation", "x", "y", "z"), &GridMap::get_cell_item_orientation);
 
 	//ClassDB::bind_method(D_METHOD("_recreate_octants"),&GridMap::_recreate_octants);
-	ClassDB::bind_method(D_METHOD("_update_dirty_map_callback"),&GridMap::_update_dirty_map_callback);
-	ClassDB::bind_method(D_METHOD("resource_changed","resource"),&GridMap::resource_changed);
-
-	ClassDB::bind_method(D_METHOD("set_center_x","enable"),&GridMap::set_center_x);
-	ClassDB::bind_method(D_METHOD("get_center_x"),&GridMap::get_center_x);
-	ClassDB::bind_method(D_METHOD("set_center_y","enable"),&GridMap::set_center_y);
-	ClassDB::bind_method(D_METHOD("get_center_y"),&GridMap::get_center_y);
-	ClassDB::bind_method(D_METHOD("set_center_z","enable"),&GridMap::set_center_z);
-	ClassDB::bind_method(D_METHOD("get_center_z"),&GridMap::get_center_z);
-
-	ClassDB::bind_method(D_METHOD("set_clip","enabled","clipabove","floor","axis"),&GridMap::set_clip,DEFVAL(true),DEFVAL(0),DEFVAL(Vector3::AXIS_X));
-
-	ClassDB::bind_method(D_METHOD("create_area","id","area"),&GridMap::create_area);
-	ClassDB::bind_method(D_METHOD("area_get_bounds","area","bounds"),&GridMap::area_get_bounds);
-	ClassDB::bind_method(D_METHOD("area_set_exterior_portal","area","enable"),&GridMap::area_set_exterior_portal);
-	ClassDB::bind_method(D_METHOD("area_set_name","area","name"),&GridMap::area_set_name);
-	ClassDB::bind_method(D_METHOD("area_get_name","area"),&GridMap::area_get_name);
-	ClassDB::bind_method(D_METHOD("area_is_exterior_portal","area"),&GridMap::area_is_exterior_portal);
-	ClassDB::bind_method(D_METHOD("area_set_portal_disable_distance","area","distance"),&GridMap::area_set_portal_disable_distance);
-	ClassDB::bind_method(D_METHOD("area_get_portal_disable_distance","area"),&GridMap::area_get_portal_disable_distance);
-	ClassDB::bind_method(D_METHOD("area_set_portal_disable_color","area","color"),&GridMap::area_set_portal_disable_color);
-	ClassDB::bind_method(D_METHOD("area_get_portal_disable_color","area"),&GridMap::area_get_portal_disable_color);
-	ClassDB::bind_method(D_METHOD("erase_area","area"),&GridMap::erase_area);
-	ClassDB::bind_method(D_METHOD("get_unused_area_id","area"),&GridMap::get_unused_area_id);
-
-	ClassDB::bind_method(D_METHOD("clear"),&GridMap::clear);
-
-	ClassDB::bind_method(D_METHOD("get_meshes"),&GridMap::get_meshes);
-
-	BIND_CONSTANT( INVALID_CELL_ITEM );
-
+	ClassDB::bind_method(D_METHOD("_update_dirty_map_callback"), &GridMap::_update_dirty_map_callback);
+	ClassDB::bind_method(D_METHOD("resource_changed", "resource"), &GridMap::resource_changed);
+
+	ClassDB::bind_method(D_METHOD("set_center_x", "enable"), &GridMap::set_center_x);
+	ClassDB::bind_method(D_METHOD("get_center_x"), &GridMap::get_center_x);
+	ClassDB::bind_method(D_METHOD("set_center_y", "enable"), &GridMap::set_center_y);
+	ClassDB::bind_method(D_METHOD("get_center_y"), &GridMap::get_center_y);
+	ClassDB::bind_method(D_METHOD("set_center_z", "enable"), &GridMap::set_center_z);
+	ClassDB::bind_method(D_METHOD("get_center_z"), &GridMap::get_center_z);
+
+	ClassDB::bind_method(D_METHOD("set_clip", "enabled", "clipabove", "floor", "axis"), &GridMap::set_clip, DEFVAL(true), DEFVAL(0), DEFVAL(Vector3::AXIS_X));
+
+	ClassDB::bind_method(D_METHOD("create_area", "id", "area"), &GridMap::create_area);
+	ClassDB::bind_method(D_METHOD("area_get_bounds", "area", "bounds"), &GridMap::area_get_bounds);
+	ClassDB::bind_method(D_METHOD("area_set_exterior_portal", "area", "enable"), &GridMap::area_set_exterior_portal);
+	ClassDB::bind_method(D_METHOD("area_set_name", "area", "name"), &GridMap::area_set_name);
+	ClassDB::bind_method(D_METHOD("area_get_name", "area"), &GridMap::area_get_name);
+	ClassDB::bind_method(D_METHOD("area_is_exterior_portal", "area"), &GridMap::area_is_exterior_portal);
+	ClassDB::bind_method(D_METHOD("area_set_portal_disable_distance", "area", "distance"), &GridMap::area_set_portal_disable_distance);
+	ClassDB::bind_method(D_METHOD("area_get_portal_disable_distance", "area"), &GridMap::area_get_portal_disable_distance);
+	ClassDB::bind_method(D_METHOD("area_set_portal_disable_color", "area", "color"), &GridMap::area_set_portal_disable_color);
+	ClassDB::bind_method(D_METHOD("area_get_portal_disable_color", "area"), &GridMap::area_get_portal_disable_color);
+	ClassDB::bind_method(D_METHOD("erase_area", "area"), &GridMap::erase_area);
+	ClassDB::bind_method(D_METHOD("get_unused_area_id", "area"), &GridMap::get_unused_area_id);
+
+	ClassDB::bind_method(D_METHOD("clear"), &GridMap::clear);
+
+	ClassDB::bind_method(D_METHOD("get_meshes"), &GridMap::get_meshes);
+
+	BIND_CONSTANT(INVALID_CELL_ITEM);
 }
 
 void GridMap::set_clip(bool p_enabled, bool p_clip_above, int p_floor, Vector3::Axis p_axis) {
 
 	if (!p_enabled && !clip)
 		return;
-	if (clip && p_enabled && clip_floor==p_floor && p_clip_above==clip_above && p_axis==clip_axis)
+	if (clip && p_enabled && clip_floor == p_floor && p_clip_above == clip_above && p_axis == clip_axis)
 		return;
 
-	clip=p_enabled;
-	clip_floor=p_floor;
-	clip_axis=p_axis;
-	clip_above=p_clip_above;
+	clip = p_enabled;
+	clip_floor = p_floor;
+	clip_axis = p_axis;
+	clip_above = p_clip_above;
 
 	//make it all update
-	for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
-
-		Octant *g=E->get();
-		g->dirty=true;
+	for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
 
+		Octant *g = E->get();
+		g->dirty = true;
 	}
-	awaiting_update=true;
+	awaiting_update = true;
 	_update_dirty_map_callback();
 }
 
-
 void GridMap::_update_areas() {
 
 	//clear the portals
-	for(Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
+	for (Map<int, Area *>::Element *E = area_map.front(); E; E = E->next()) {
 		//this should somehow be faster...
-		Area& a=*E->get();
+		Area &a = *E->get();
 		a.portals.clear();
 		if (a.instance.is_valid()) {
 			VisualServer::get_singleton()->free(a.instance);
-			a.instance=RID();
+			a.instance = RID();
 		}
 	}
 
 	//test all areas against all areas and create portals - this sucks (slow :( )
-	for(Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
-		Area& a=*E->get();
+	for (Map<int, Area *>::Element *E = area_map.front(); E; E = E->next()) {
+		Area &a = *E->get();
 		if (a.exterior_portal) //that's pretty much all it does... yes it is
 			continue;
-		Vector3 from_a(a.from.x,a.from.y,a.from.z);
-		Vector3 to_a(a.to.x,a.to.y,a.to.z);
+		Vector3 from_a(a.from.x, a.from.y, a.from.z);
+		Vector3 to_a(a.to.x, a.to.y, a.to.z);
 
-		for(Map<int,Area*>::Element *F=area_map.front();F;F=F->next()) {
+		for (Map<int, Area *>::Element *F = area_map.front(); F; F = F->next()) {
 
-			Area& b=*F->get();
-			Vector3 from_b(b.from.x,b.from.y,b.from.z);
-			Vector3 to_b(b.to.x,b.to.y,b.to.z);
+			Area &b = *F->get();
+			Vector3 from_b(b.from.x, b.from.y, b.from.z);
+			Vector3 to_b(b.to.x, b.to.y, b.to.z);
 
 			// initially test intersection and discards
-			int axis=-1;
-			float sign=0;
-			bool valid=true;
-			Vector3 axmin,axmax;
-
+			int axis = -1;
+			float sign = 0;
+			bool valid = true;
+			Vector3 axmin, axmax;
 
-			for(int i=0;i<3;i++) {
+			for (int i = 0; i < 3; i++) {
 
-				if (from_a[i]==to_b[i]) {
+				if (from_a[i] == to_b[i]) {
 
-					if (axis!=-1) {
-						valid=false;
+					if (axis != -1) {
+						valid = false;
 						break;
 					}
 
-					axis=i;
-					sign=-1;
-				} else if (from_b[i]==to_a[i]) {
+					axis = i;
+					sign = -1;
+				} else if (from_b[i] == to_a[i]) {
 
-					if (axis!=-1) {
-						valid=false;
+					if (axis != -1) {
+						valid = false;
 						break;
 					}
-					axis=i;
-					sign=+1;
+					axis = i;
+					sign = +1;
 				}
 
-
-				if (from_a[i] > to_b[i] || to_a[i] < from_b[i] ) {
-					valid=false;
+				if (from_a[i] > to_b[i] || to_a[i] < from_b[i]) {
+					valid = false;
 					break;
 				} else {
 
-					axmin[i]= ( from_a[i] > from_b[i] ) ? from_a[i] :from_b[i];
-					axmax[i]= ( to_a[i] < to_b[i] ) ? to_a[i] :to_b[i];
-
+					axmin[i] = (from_a[i] > from_b[i]) ? from_a[i] : from_b[i];
+					axmax[i] = (to_a[i] < to_b[i]) ? to_a[i] : to_b[i];
 				}
-
-
 			}
 
-			if (axis==-1 || !valid)
+			if (axis == -1 || !valid)
 				continue;
 
 			Transform xf;
 
+			for (int i = 0; i < 3; i++) {
 
-			for(int i=0;i<3;i++) {
-
-
-
-				int ax=(axis+i)%3;
+				int ax = (axis + i) % 3;
 				Vector3 axis_vec;
-				float scale = (i==0)?sign:((axmax[ax]-axmin[ax])*cell_size);
-				axis_vec[ax]=scale;
-				xf.basis.set_axis((2+i)%3,axis_vec);
-				xf.origin[i]=axmin[i]*cell_size;
-
+				float scale = (i == 0) ? sign : ((axmax[ax] - axmin[ax]) * cell_size);
+				axis_vec[ax] = scale;
+				xf.basis.set_axis((2 + i) % 3, axis_vec);
+				xf.origin[i] = axmin[i] * cell_size;
 			}
 
-
-
 			Area::Portal portal;
-			portal.xform=xf;
+			portal.xform = xf;
 			a.portals.push_back(portal);
 		}
 	}
 
 	_update_area_instances();
-
 }
 
 void GridMap::_update_area_instances() {
 
 	Transform base_xform;
 	if (_in_tree)
-		base_xform=get_global_transform();
+		base_xform = get_global_transform();
 
-	for(Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
+	for (Map<int, Area *>::Element *E = area_map.front(); E; E = E->next()) {
 		//this should somehow be faster...
-		Area& a=*E->get();
-		if (a.instance.is_valid()!=_in_tree) {
+		Area &a = *E->get();
+		if (a.instance.is_valid() != _in_tree) {
 
 			if (!_in_tree) {
 
-				for(int i=0;i<a.portals.size();i++) {
+				for (int i = 0; i < a.portals.size(); i++) {
 
-					Area::Portal&p=a.portals[i];
+					Area::Portal &p = a.portals[i];
 					ERR_CONTINUE(!p.instance.is_valid());
 					VisualServer::get_singleton()->free(p.instance);
-					p.instance=RID();
+					p.instance = RID();
 				}
 
 				VisualServer::get_singleton()->free(a.instance);
-				a.instance=RID();
+				a.instance = RID();
 
 			} else {
 
 				//a.instance = VisualServer::get_singleton()->instance_create2(base_room,get_world()->get_scenario());
-				for(int i=0;i<a.portals.size();i++) {
+				for (int i = 0; i < a.portals.size(); i++) {
 
-					Area::Portal&p=a.portals[i];
+					Area::Portal &p = a.portals[i];
 					ERR_CONTINUE(p.instance.is_valid());
-					p.instance=VisualServer::get_singleton()->instance_create2(a.base_portal,get_world()->get_scenario());
-					VisualServer::get_singleton()->instance_set_room(p.instance,a.instance);
+					p.instance = VisualServer::get_singleton()->instance_create2(a.base_portal, get_world()->get_scenario());
+					VisualServer::get_singleton()->instance_set_room(p.instance, a.instance);
 				}
 			}
 		}
@@ -1089,62 +1024,57 @@ void GridMap::_update_area_instances() {
 		if (a.instance.is_valid()) {
 			Transform xform;
 
-			Vector3 from_a(a.from.x,a.from.y,a.from.z);
-			Vector3 to_a(a.to.x,a.to.y,a.to.z);
+			Vector3 from_a(a.from.x, a.from.y, a.from.z);
+			Vector3 to_a(a.to.x, a.to.y, a.to.z);
 
-			for(int i=0;i<3;i++) {
-				xform.origin[i]=from_a[i]*cell_size;
+			for (int i = 0; i < 3; i++) {
+				xform.origin[i] = from_a[i] * cell_size;
 				Vector3 s;
-				s[i]=(to_a[i]-from_a[i])*cell_size;
-				xform.basis.set_axis(i,s);
+				s[i] = (to_a[i] - from_a[i]) * cell_size;
+				xform.basis.set_axis(i, s);
 			}
 
+			VisualServer::get_singleton()->instance_set_transform(a.instance, base_xform * xform);
 
-			VisualServer::get_singleton()->instance_set_transform(a.instance,base_xform * xform);
-
-			for(int i=0;i<a.portals.size();i++) {
+			for (int i = 0; i < a.portals.size(); i++) {
 
-				Area::Portal&p=a.portals[i];
+				Area::Portal &p = a.portals[i];
 				ERR_CONTINUE(!p.instance.is_valid());
 
-				VisualServer::get_singleton()->instance_set_transform(p.instance,base_xform * xform);
-
+				VisualServer::get_singleton()->instance_set_transform(p.instance, base_xform * xform);
 			}
-
 		}
 	}
-
 }
 
-Error GridMap::create_area(int p_id,const Rect3& p_bounds) {
+Error GridMap::create_area(int p_id, const Rect3 &p_bounds) {
 
-	ERR_FAIL_COND_V(area_map.has(p_id),ERR_ALREADY_EXISTS);
+	ERR_FAIL_COND_V(area_map.has(p_id), ERR_ALREADY_EXISTS);
 	ERR_EXPLAIN("ID 0 is taken as global area, start from 1");
-	ERR_FAIL_COND_V(p_id==0,ERR_INVALID_PARAMETER);
-	ERR_FAIL_COND_V(p_bounds.has_no_area(),ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_id == 0, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(p_bounds.has_no_area(), ERR_INVALID_PARAMETER);
 
 	// FIRST VALIDATE AREA
-	IndexKey from,to;
-	from.x=p_bounds.pos.x;
-	from.y=p_bounds.pos.y;
-	from.z=p_bounds.pos.z;
-	to.x=p_bounds.pos.x+p_bounds.size.x;
-	to.y=p_bounds.pos.y+p_bounds.size.y;
-	to.z=p_bounds.pos.z+p_bounds.size.z;
-
-
-	for(Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
+	IndexKey from, to;
+	from.x = p_bounds.pos.x;
+	from.y = p_bounds.pos.y;
+	from.z = p_bounds.pos.z;
+	to.x = p_bounds.pos.x + p_bounds.size.x;
+	to.y = p_bounds.pos.y + p_bounds.size.y;
+	to.z = p_bounds.pos.z + p_bounds.size.z;
+
+	for (Map<int, Area *>::Element *E = area_map.front(); E; E = E->next()) {
 		//this should somehow be faster...
-		Area& a=*E->get();
+		Area &a = *E->get();
 
 		//does it interset with anything else?
 
-		if (	from.x >= a.to.x ||
-			to.x <= a.from.x ||
-			from.y >= a.to.y ||
-			to.y <= a.from.y ||
-			from.z >= a.to.z ||
-			to.z <= a.from.z ) {
+		if (from.x >= a.to.x ||
+				to.x <= a.from.x ||
+				from.y >= a.to.y ||
+				to.y <= a.from.y ||
+				from.z >= a.to.z ||
+				to.z <= a.from.z) {
 
 			// all good
 		} else {
@@ -1153,62 +1083,60 @@ Error GridMap::create_area(int p_id,const Rect3& p_bounds) {
 		}
 	}
 
-
-	Area *area = memnew( Area );
-	area->from=from;
-	area->to=to;
-	area->portal_disable_distance=0;
-	area->exterior_portal=false;
-	area->name="Area "+itos(p_id);
-	area_map[p_id]=area;
+	Area *area = memnew(Area);
+	area->from = from;
+	area->to = to;
+	area->portal_disable_distance = 0;
+	area->exterior_portal = false;
+	area->name = "Area " + itos(p_id);
+	area_map[p_id] = area;
 	_recreate_octant_data();
 	return OK;
 }
 
 Rect3 GridMap::area_get_bounds(int p_area) const {
 
-	ERR_FAIL_COND_V(!area_map.has(p_area),Rect3());
+	ERR_FAIL_COND_V(!area_map.has(p_area), Rect3());
 
 	const Area *a = area_map[p_area];
 	Rect3 aabb;
-	aabb.pos=Vector3(a->from.x,a->from.y,a->from.z);
-	aabb.size=Vector3(a->to.x,a->to.y,a->to.z)-aabb.pos;
+	aabb.pos = Vector3(a->from.x, a->from.y, a->from.z);
+	aabb.size = Vector3(a->to.x, a->to.y, a->to.z) - aabb.pos;
 
 	return aabb;
 }
 
-void GridMap::area_set_name(int p_area,const String& p_name) {
+void GridMap::area_set_name(int p_area, const String &p_name) {
 
 	ERR_FAIL_COND(!area_map.has(p_area));
 
 	Area *a = area_map[p_area];
-	a->name=p_name;
+	a->name = p_name;
 }
 
 String GridMap::area_get_name(int p_area) const {
 
-	ERR_FAIL_COND_V(!area_map.has(p_area),"");
+	ERR_FAIL_COND_V(!area_map.has(p_area), "");
 
 	const Area *a = area_map[p_area];
 	return a->name;
 }
 
-
-void GridMap::area_set_exterior_portal(int p_area,bool p_enable) {
+void GridMap::area_set_exterior_portal(int p_area, bool p_enable) {
 
 	ERR_FAIL_COND(!area_map.has(p_area));
 
 	Area *a = area_map[p_area];
-	if (a->exterior_portal==p_enable)
+	if (a->exterior_portal == p_enable)
 		return;
-	a->exterior_portal=p_enable;
+	a->exterior_portal = p_enable;
 
 	_recreate_octant_data();
 }
 
 bool GridMap::area_is_exterior_portal(int p_area) const {
 
-	ERR_FAIL_COND_V(!area_map.has(p_area),false);
+	ERR_FAIL_COND_V(!area_map.has(p_area), false);
 
 	const Area *a = area_map[p_area];
 	return a->exterior_portal;
@@ -1219,13 +1147,12 @@ void GridMap::area_set_portal_disable_distance(int p_area, float p_distance) {
 	ERR_FAIL_COND(!area_map.has(p_area));
 
 	Area *a = area_map[p_area];
-	a->portal_disable_distance=p_distance;
-
+	a->portal_disable_distance = p_distance;
 }
 
 float GridMap::area_get_portal_disable_distance(int p_area) const {
 
-	ERR_FAIL_COND_V(!area_map.has(p_area),0);
+	ERR_FAIL_COND_V(!area_map.has(p_area), 0);
 
 	const Area *a = area_map[p_area];
 	return a->portal_disable_distance;
@@ -1236,13 +1163,12 @@ void GridMap::area_set_portal_disable_color(int p_area, Color p_color) {
 	ERR_FAIL_COND(!area_map.has(p_area));
 
 	Area *a = area_map[p_area];
-	a->portal_disable_color=p_color;
-
+	a->portal_disable_color = p_color;
 }
 
 Color GridMap::area_get_portal_disable_color(int p_area) const {
 
-	ERR_FAIL_COND_V(!area_map.has(p_area),Color());
+	ERR_FAIL_COND_V(!area_map.has(p_area), Color());
 
 	const Area *a = area_map[p_area];
 	return a->portal_disable_color;
@@ -1250,34 +1176,29 @@ Color GridMap::area_get_portal_disable_color(int p_area) const {
 
 void GridMap::get_area_list(List<int> *p_areas) const {
 
-	for(const Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
+	for (const Map<int, Area *>::Element *E = area_map.front(); E; E = E->next()) {
 
 		p_areas->push_back(E->key());
 	}
-
 }
 
-
 GridMap::Area::Portal::~Portal() {
 
 	if (instance.is_valid())
 		VisualServer::get_singleton()->free(instance);
 }
 
-
 GridMap::Area::Area() {
 
-	base_portal=VisualServer::get_singleton()->portal_create();
-	Vector< Point2 > points;
-	points.push_back( Point2( 0, 1 ) );
-	points.push_back( Point2( 1, 1 ) );
-	points.push_back( Point2( 1, 0 ) );
-	points.push_back( Point2( 0, 0 ) );
-	VisualServer::get_singleton()->portal_set_shape(base_portal,points);
-
+	base_portal = VisualServer::get_singleton()->portal_create();
+	Vector<Point2> points;
+	points.push_back(Point2(0, 1));
+	points.push_back(Point2(1, 1));
+	points.push_back(Point2(1, 0));
+	points.push_back(Point2(0, 0));
+	VisualServer::get_singleton()->portal_set_shape(base_portal, points);
 }
 
-
 GridMap::Area::~Area() {
 
 	if (instance.is_valid())
@@ -1289,7 +1210,7 @@ void GridMap::erase_area(int p_area) {
 
 	ERR_FAIL_COND(!area_map.has(p_area));
 
-	Area* a=area_map[p_area];
+	Area *a = area_map[p_area];
 	memdelete(a);
 	area_map.erase(p_area);
 	_recreate_octant_data();
@@ -1300,92 +1221,79 @@ int GridMap::get_unused_area_id() const {
 	if (area_map.empty())
 		return 1;
 	else
-		return area_map.back()->key()+1;
+		return area_map.back()->key() + 1;
 }
 
 void GridMap::set_cell_scale(float p_scale) {
 
-	cell_scale=p_scale;
+	cell_scale = p_scale;
 	_queue_dirty_map();
 }
 
-float GridMap::get_cell_scale() const{
+float GridMap::get_cell_scale() const {
 
 	return cell_scale;
 }
 
-
-
-
 Array GridMap::get_meshes() {
 
 	if (theme.is_null())
 		return Array();
 
-	Vector3 ofs(cell_size*0.5*int(center_x),cell_size*0.5*int(center_y),cell_size*0.5*int(center_z));
+	Vector3 ofs(cell_size * 0.5 * int(center_x), cell_size * 0.5 * int(center_y), cell_size * 0.5 * int(center_z));
 	Array meshes;
 
-	for (Map<IndexKey,Cell>::Element *E=cell_map.front();E;E=E->next()) {
-
+	for (Map<IndexKey, Cell>::Element *E = cell_map.front(); E; E = E->next()) {
 
 		int id = E->get().item;
 		if (!theme->has_item(id))
 			continue;
-		Ref<Mesh> mesh=theme->get_item_mesh(id);
+		Ref<Mesh> mesh = theme->get_item_mesh(id);
 		if (mesh.is_null())
 			continue;
 
-		IndexKey ik=E->key();
+		IndexKey ik = E->key();
 
-		Vector3 cellpos = Vector3(ik.x,ik.y,ik.z );
+		Vector3 cellpos = Vector3(ik.x, ik.y, ik.z);
 
 		Transform xform;
 
 		xform.basis.set_orthogonal_index(E->get().rot);
 
-
-		xform.set_origin( cellpos*cell_size+ofs);
-		xform.basis.scale(Vector3(cell_scale,cell_scale,cell_scale));
+		xform.set_origin(cellpos * cell_size + ofs);
+		xform.basis.scale(Vector3(cell_scale, cell_scale, cell_scale));
 
 		meshes.push_back(xform);
 		meshes.push_back(mesh);
-
 	}
 
 	return meshes;
 }
 
-
-
-
 GridMap::GridMap() {
 
-	cell_size=2;
-	octant_size=4;
-	awaiting_update=false;
-	_in_tree=false;
-	center_x=true;
-	center_y=true;
-	center_z=true;
-
-	clip=false;
-	clip_floor=0;
-	clip_axis=Vector3::AXIS_Z;
-	clip_above=true;
-	cell_scale=1.0;
+	cell_size = 2;
+	octant_size = 4;
+	awaiting_update = false;
+	_in_tree = false;
+	center_x = true;
+	center_y = true;
+	center_z = true;
 
+	clip = false;
+	clip_floor = 0;
+	clip_axis = Vector3::AXIS_Z;
+	clip_above = true;
+	cell_scale = 1.0;
 
 	navigation = NULL;
 	set_notify_transform(true);
 }
 
-
 GridMap::~GridMap() {
 
 	if (!theme.is_null())
 		theme->unregister_owner(this);
 
 	clear();
-
 }
-
diff --git a/modules/gridmap/grid_map.h b/modules/gridmap/grid_map.h
index 5d4133383b..2a0c2b9646 100644
--- a/modules/gridmap/grid_map.h
+++ b/modules/gridmap/grid_map.h
@@ -29,26 +29,23 @@
 #ifndef GRID_MAP_H
 #define GRID_MAP_H
 
-
-#include "scene/resources/mesh_library.h"
-#include "scene/3d/spatial.h"
 #include "scene/3d/navigation.h"
+#include "scene/3d/spatial.h"
+#include "scene/resources/mesh_library.h"
 #include "scene/resources/multimesh.h"
 
 //heh heh, godotsphir!! this shares no code and the design is completely different with previous projects i've done..
 //should scale better with hardware that supports instancing
 
-
 class BakedLightInstance;
 
 class GridMap : public Spatial {
 
-
-	GDCLASS( GridMap, Spatial );
+	GDCLASS(GridMap, Spatial);
 
 	enum {
-		MAP_DIRTY_TRANSFORMS=1,
-		MAP_DIRTY_INSTANCES=2,
+		MAP_DIRTY_TRANSFORMS = 1,
+		MAP_DIRTY_INSTANCES = 2,
 	};
 
 	union IndexKey {
@@ -60,12 +57,12 @@ class GridMap : public Spatial {
 		};
 		uint64_t key;
 
-		_FORCE_INLINE_ bool operator<(const IndexKey& p_key) const {
+		_FORCE_INLINE_ bool operator<(const IndexKey &p_key) const {
 
 			return key < p_key.key;
 		}
 
-		IndexKey() { key=0; }
+		IndexKey() { key = 0; }
 	};
 
 	/**
@@ -75,12 +72,16 @@ class GridMap : public Spatial {
 
 		struct {
 			unsigned int item : 16;
-			unsigned int rot:5;
-			unsigned int layer:8;
+			unsigned int rot : 5;
+			unsigned int layer : 8;
 		};
 		uint32_t cell;
 
-		Cell() { item=0; rot=0; layer=0; }
+		Cell() {
+			item = 0;
+			rot = 0;
+			layer = 0;
+		}
 	};
 
 	/**
@@ -108,8 +109,8 @@ class GridMap : public Spatial {
 
 		bool dirty;
 		RID static_body;
-		Map<int,ItemInstances> items;
-		Map<IndexKey,NavMesh> navmesh_ids;
+		Map<int, ItemInstances> items;
+		Map<IndexKey, NavMesh> navmesh_ids;
 	};
 
 	union OctantKey {
@@ -123,13 +124,13 @@ class GridMap : public Spatial {
 
 		uint64_t key;
 
-		_FORCE_INLINE_ bool operator<(const OctantKey& p_key) const {
+		_FORCE_INLINE_ bool operator<(const OctantKey &p_key) const {
 
 			return key < p_key.key;
 		}
 
 		//OctantKey(const IndexKey& p_k, int p_item) { indexkey=p_k.key; item=p_item; }
-		OctantKey() { key=0; }
+		OctantKey() { key = 0; }
 	};
 
 	Transform last_transform;
@@ -137,7 +138,7 @@ class GridMap : public Spatial {
 	bool _in_tree;
 	float cell_size;
 	int octant_size;
-	bool center_x,center_y,center_z;
+	bool center_x, center_y, center_z;
 	float cell_scale;
 	Navigation *navigation;
 
@@ -146,7 +147,6 @@ class GridMap : public Spatial {
 	int clip_floor;
 	Vector3::Axis clip_axis;
 
-
 	/**
 	 * @brief An Area is something like a room: it has doors, and Octants can choose to belong to it.
 	 */
@@ -173,11 +173,9 @@ class GridMap : public Spatial {
 
 	Ref<MeshLibrary> theme;
 
-	Map<OctantKey,Octant*> octant_map;
-	Map<IndexKey,Cell> cell_map;
-	Map<int,Area*> area_map;
-
-
+	Map<OctantKey, Octant *> octant_map;
+	Map<IndexKey, Cell> cell_map;
+	Map<int, Area *> area_map;
 
 	void _recreate_octant_data();
 
@@ -189,11 +187,11 @@ class GridMap : public Spatial {
 		float param[VS::LIGHT_PARAM_MAX];
 	};
 
-	_FORCE_INLINE_ int _find_area(const IndexKey& p_pos) const;
+	_FORCE_INLINE_ int _find_area(const IndexKey &p_pos) const;
 
 	_FORCE_INLINE_ Vector3 _octant_get_offset(const OctantKey &p_key) const {
 
-		return Vector3(p_key.x,p_key.y,p_key.z)*cell_size*octant_size;
+		return Vector3(p_key.x, p_key.y, p_key.z) * cell_size * octant_size;
 	}
 
 	void _octant_enter_world(const OctantKey &p_key);
@@ -201,37 +199,33 @@ class GridMap : public Spatial {
 	void _octant_exit_world(const OctantKey &p_key);
 	void _octant_update(const OctantKey &p_key);
 	void _octant_transform(const OctantKey &p_key);
-	void _octant_clear_navmesh(const GridMap::OctantKey&);
+	void _octant_clear_navmesh(const GridMap::OctantKey &);
 	bool awaiting_update;
 
 	void _queue_dirty_map();
 	void _update_dirty_map_callback();
 
-	void resource_changed(const RES& p_res);
-
+	void resource_changed(const RES &p_res);
 
 	void _update_areas();
 	void _update_area_instances();
 
-	void _clear_internal(bool p_keep_areas=false);
+	void _clear_internal(bool p_keep_areas = false);
 
 protected:
-
-	bool _set(const StringName& p_name, const Variant& p_value);
-	bool _get(const StringName& p_name,Variant &r_ret) const;
-	void _get_property_list( List<PropertyInfo> *p_list) const;
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
 
 	void _notification(int p_what);
 	static void _bind_methods();
 
-
 public:
-
 	enum {
-		INVALID_CELL_ITEM=-1
+		INVALID_CELL_ITEM = -1
 	};
 
-	void set_theme(const Ref<MeshLibrary>& p_theme);
+	void set_theme(const Ref<MeshLibrary> &p_theme);
 	Ref<MeshLibrary> get_theme() const;
 
 	void set_cell_size(float p_size);
@@ -240,7 +234,6 @@ public:
 	void set_octant_size(int p_size);
 	int get_octant_size() const;
 
-
 	void set_center_x(bool p_enable);
 	bool get_center_x() const;
 	void set_center_y(bool p_enable);
@@ -248,16 +241,16 @@ public:
 	void set_center_z(bool p_enable);
 	bool get_center_z() const;
 
-	void set_cell_item(int p_x,int p_y,int p_z, int p_item,int p_orientation=0);
-	int get_cell_item(int p_x,int p_y,int p_z) const;
-	int get_cell_item_orientation(int p_x,int p_y,int p_z) const;
+	void set_cell_item(int p_x, int p_y, int p_z, int p_item, int p_orientation = 0);
+	int get_cell_item(int p_x, int p_y, int p_z) const;
+	int get_cell_item_orientation(int p_x, int p_y, int p_z) const;
 
-	void set_clip(bool p_enabled, bool p_clip_above=true, int p_floor=0, Vector3::Axis p_axis=Vector3::AXIS_X);
+	void set_clip(bool p_enabled, bool p_clip_above = true, int p_floor = 0, Vector3::Axis p_axis = Vector3::AXIS_X);
 
-	Error create_area(int p_id,const Rect3& p_area);
+	Error create_area(int p_id, const Rect3 &p_area);
 	Rect3 area_get_bounds(int p_area) const;
-	void area_set_exterior_portal(int p_area,bool p_enable);
-	void area_set_name(int p_area,const String& p_name);
+	void area_set_exterior_portal(int p_area, bool p_enable);
+	void area_set_name(int p_area, const String &p_name);
 	String area_get_name(int p_area) const;
 	bool area_is_exterior_portal(int p_area) const;
 	void area_set_portal_disable_distance(int p_area, float p_distance);
@@ -271,11 +264,8 @@ public:
 	void set_cell_scale(float p_scale);
 	float get_cell_scale() const;
 
-
-
 	Array get_meshes();
 
-
 	void clear();
 
 	GridMap();
diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp
index a5d2f84c68..a6a3a03503 100644
--- a/modules/gridmap/grid_map_editor_plugin.cpp
+++ b/modules/gridmap/grid_map_editor_plugin.cpp
@@ -27,59 +27,53 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "grid_map_editor_plugin.h"
+#include "editor/editor_settings.h"
 #include "editor/plugins/spatial_editor_plugin.h"
 #include "scene/3d/camera.h"
-#include "editor/editor_settings.h"
 
-#include "os/keyboard.h"
 #include "geometry.h"
+#include "os/keyboard.h"
 
 void GridMapEditor::_node_removed(Node *p_node) {
 
-	if(p_node==node) {
-		node=NULL;
+	if (p_node == node) {
+		node = NULL;
 		hide();
 		theme_pallete->hide();
 	}
-
 }
 
-
 void GridMapEditor::_configure() {
 
-	if(!node)
+	if (!node)
 		return;
 
 	update_grid();
-
 }
 
-void  GridMapEditor::_menu_option(int p_option) {
+void GridMapEditor::_menu_option(int p_option) {
 
-
-	switch(p_option) {
+	switch (p_option) {
 
 		case MENU_OPTION_CONFIGURE: {
 
-
 		} break;
 		case MENU_OPTION_LOCK_VIEW: {
 
-			int index=options->get_popup()->get_item_index(MENU_OPTION_LOCK_VIEW);
-			lock_view=!options->get_popup()->is_item_checked(index);
+			int index = options->get_popup()->get_item_index(MENU_OPTION_LOCK_VIEW);
+			lock_view = !options->get_popup()->is_item_checked(index);
 
-			options->get_popup()->set_item_checked(index,lock_view);
+			options->get_popup()->set_item_checked(index, lock_view);
 		} break;
 		case MENU_OPTION_CLIP_DISABLED:
 		case MENU_OPTION_CLIP_ABOVE:
 		case MENU_OPTION_CLIP_BELOW: {
 
-			clip_mode=ClipMode(p_option-MENU_OPTION_CLIP_DISABLED);
-			for(int i=0;i<3;i++) {
-
-				int index=options->get_popup()->get_item_index(MENU_OPTION_CLIP_DISABLED+i);
-				options->get_popup()->set_item_checked(index,i==clip_mode);
+			clip_mode = ClipMode(p_option - MENU_OPTION_CLIP_DISABLED);
+			for (int i = 0; i < 3; i++) {
 
+				int index = options->get_popup()->get_item_index(MENU_OPTION_CLIP_DISABLED + i);
+				options->get_popup()->set_item_checked(index, i == clip_mode);
 			}
 
 			_update_clip();
@@ -88,102 +82,100 @@ void  GridMapEditor::_menu_option(int p_option) {
 		case MENU_OPTION_Y_AXIS:
 		case MENU_OPTION_Z_AXIS: {
 
-			int new_axis = p_option-MENU_OPTION_X_AXIS;
-			for(int i=0;i<3;i++) {
-				int idx=options->get_popup()->get_item_index(MENU_OPTION_X_AXIS+i);
-				options->get_popup()->set_item_checked(idx,i==new_axis);
+			int new_axis = p_option - MENU_OPTION_X_AXIS;
+			for (int i = 0; i < 3; i++) {
+				int idx = options->get_popup()->get_item_index(MENU_OPTION_X_AXIS + i);
+				options->get_popup()->set_item_checked(idx, i == new_axis);
 			}
-			edit_axis=Vector3::Axis(new_axis);
+			edit_axis = Vector3::Axis(new_axis);
 			update_grid();
 			_update_clip();
 
 		} break;
 		case MENU_OPTION_CURSOR_ROTATE_Y: {
 			Basis r;
-			if (input_action==INPUT_DUPLICATE) {
+			if (input_action == INPUT_DUPLICATE) {
 
 				r.set_orthogonal_index(selection.duplicate_rot);
-				r.rotate(Vector3(0,1,0),-Math_PI/2.0);
-				selection.duplicate_rot=r.get_orthogonal_index();
+				r.rotate(Vector3(0, 1, 0), -Math_PI / 2.0);
+				selection.duplicate_rot = r.get_orthogonal_index();
 				_update_duplicate_indicator();
 				break;
 			}
 			r.set_orthogonal_index(cursor_rot);
-			r.rotate(Vector3(0,1,0),-Math_PI/2.0);
-			cursor_rot=r.get_orthogonal_index();
+			r.rotate(Vector3(0, 1, 0), -Math_PI / 2.0);
+			cursor_rot = r.get_orthogonal_index();
 			_update_cursor_transform();
 		} break;
 		case MENU_OPTION_CURSOR_ROTATE_X: {
 			Basis r;
-			if (input_action==INPUT_DUPLICATE) {
+			if (input_action == INPUT_DUPLICATE) {
 
 				r.set_orthogonal_index(selection.duplicate_rot);
-				r.rotate(Vector3(1,0,0),-Math_PI/2.0);
-				selection.duplicate_rot=r.get_orthogonal_index();
+				r.rotate(Vector3(1, 0, 0), -Math_PI / 2.0);
+				selection.duplicate_rot = r.get_orthogonal_index();
 				_update_duplicate_indicator();
 				break;
 			}
 
 			r.set_orthogonal_index(cursor_rot);
-			r.rotate(Vector3(1,0,0),-Math_PI/2.0);
-			cursor_rot=r.get_orthogonal_index();
+			r.rotate(Vector3(1, 0, 0), -Math_PI / 2.0);
+			cursor_rot = r.get_orthogonal_index();
 			_update_cursor_transform();
 		} break;
 		case MENU_OPTION_CURSOR_ROTATE_Z: {
 			Basis r;
-			if (input_action==INPUT_DUPLICATE) {
+			if (input_action == INPUT_DUPLICATE) {
 
 				r.set_orthogonal_index(selection.duplicate_rot);
-				r.rotate(Vector3(0,0,1),-Math_PI/2.0);
-				selection.duplicate_rot=r.get_orthogonal_index();
+				r.rotate(Vector3(0, 0, 1), -Math_PI / 2.0);
+				selection.duplicate_rot = r.get_orthogonal_index();
 				_update_duplicate_indicator();
 				break;
 			}
 
 			r.set_orthogonal_index(cursor_rot);
-			r.rotate(Vector3(0,0,1),-Math_PI/2.0);
-			cursor_rot=r.get_orthogonal_index();
+			r.rotate(Vector3(0, 0, 1), -Math_PI / 2.0);
+			cursor_rot = r.get_orthogonal_index();
 			_update_cursor_transform();
 		} break;
 		case MENU_OPTION_CURSOR_BACK_ROTATE_Y: {
 			Basis r;
 			r.set_orthogonal_index(cursor_rot);
-			r.rotate(Vector3(0,1,0),Math_PI/2.0);
-			cursor_rot=r.get_orthogonal_index();
+			r.rotate(Vector3(0, 1, 0), Math_PI / 2.0);
+			cursor_rot = r.get_orthogonal_index();
 			_update_cursor_transform();
 		} break;
 		case MENU_OPTION_CURSOR_BACK_ROTATE_X: {
 			Basis r;
 			r.set_orthogonal_index(cursor_rot);
-			r.rotate(Vector3(1,0,0),Math_PI/2.0);
-			cursor_rot=r.get_orthogonal_index();
+			r.rotate(Vector3(1, 0, 0), Math_PI / 2.0);
+			cursor_rot = r.get_orthogonal_index();
 			_update_cursor_transform();
 		} break;
 		case MENU_OPTION_CURSOR_BACK_ROTATE_Z: {
 			Basis r;
 			r.set_orthogonal_index(cursor_rot);
-			r.rotate(Vector3(0,0,1),Math_PI/2.0);
-			cursor_rot=r.get_orthogonal_index();
+			r.rotate(Vector3(0, 0, 1), Math_PI / 2.0);
+			cursor_rot = r.get_orthogonal_index();
 			_update_cursor_transform();
 		} break;
 		case MENU_OPTION_CURSOR_CLEAR_ROTATION: {
 
-			if (input_action==INPUT_DUPLICATE) {
-
+			if (input_action == INPUT_DUPLICATE) {
 
-				selection.duplicate_rot=0;
+				selection.duplicate_rot = 0;
 				_update_duplicate_indicator();
 				break;
 			}
 
-			cursor_rot=0;
+			cursor_rot = 0;
 			_update_cursor_transform();
 		} break;
 
-
 		case MENU_OPTION_DUPLICATE_SELECTS: {
 			int idx = options->get_popup()->get_item_index(MENU_OPTION_DUPLICATE_SELECTS);
-			options->get_popup()->set_item_checked( idx, !options->get_popup()->is_item_checked( idx ) );
+			options->get_popup()->set_item_checked(idx, !options->get_popup()->is_item_checked(idx));
 		} break;
 		case MENU_OPTION_SELECTION_MAKE_AREA:
 		case MENU_OPTION_SELECTION_MAKE_EXTERIOR_CONNECTOR: {
@@ -191,37 +183,34 @@ void  GridMapEditor::_menu_option(int p_option) {
 			if (!selection.active)
 				break;
 			int area = node->get_unused_area_id();
-			Error err = node->create_area(area,Rect3(selection.begin,selection.end-selection.begin+Vector3(1,1,1)));
-			if (err!=OK) {
-
-
+			Error err = node->create_area(area, Rect3(selection.begin, selection.end - selection.begin + Vector3(1, 1, 1)));
+			if (err != OK) {
 			}
-			if (p_option==MENU_OPTION_SELECTION_MAKE_EXTERIOR_CONNECTOR) {
+			if (p_option == MENU_OPTION_SELECTION_MAKE_EXTERIOR_CONNECTOR) {
 
-				node->area_set_exterior_portal(area,true);
+				node->area_set_exterior_portal(area, true);
 			}
 			_update_areas_display();
 			update_areas();
 
-
 		} break;
 		case MENU_OPTION_REMOVE_AREA: {
-			if (selected_area<1)
+			if (selected_area < 1)
 				return;
 			node->erase_area(selected_area);
 			_update_areas_display();
 			update_areas();
 		} break;
 		case MENU_OPTION_SELECTION_DUPLICATE:
-			if (!(selection.active && input_action==INPUT_NONE))
+			if (!(selection.active && input_action == INPUT_NONE))
 				return;
-			if (last_mouseover==Vector3(-1,-1,-1)) //nono mouseovering anythin
+			if (last_mouseover == Vector3(-1, -1, -1)) //nono mouseovering anythin
 				break;
 
-			input_action=INPUT_DUPLICATE;
-			selection.click=last_mouseover;
-			selection.current=last_mouseover;
-			selection.duplicate_rot=0;
+			input_action = INPUT_DUPLICATE;
+			selection.click = last_mouseover;
+			selection.current = last_mouseover;
+			selection.duplicate_rot = 0;
 			_update_duplicate_indicator();
 			break;
 		case MENU_OPTION_SELECTION_CLEAR: {
@@ -230,28 +219,24 @@ void  GridMapEditor::_menu_option(int p_option) {
 
 			_delete_selection();
 
-
 		} break;
 		case MENU_OPTION_GRIDMAP_SETTINGS: {
 			settings_dialog->popup_centered(settings_vbc->get_combined_minimum_size() + Size2(50, 50));
 		} break;
-
 	}
 }
 
 void GridMapEditor::_update_cursor_transform() {
 
-	cursor_transform=Transform();
-	cursor_transform.origin=cursor_origin;
+	cursor_transform = Transform();
+	cursor_transform.origin = cursor_origin;
 	cursor_transform.basis.set_orthogonal_index(cursor_rot);
 	cursor_transform = node->get_transform() * cursor_transform;
 
-
 	if (cursor_instance.is_valid()) {
-		VisualServer::get_singleton()->instance_set_transform(cursor_instance,cursor_transform);
-		VisualServer::get_singleton()->instance_set_visible(cursor_instance,cursor_visible);
+		VisualServer::get_singleton()->instance_set_transform(cursor_instance, cursor_transform);
+		VisualServer::get_singleton()->instance_set_visible(cursor_instance, cursor_visible);
 	}
-
 }
 
 void GridMapEditor::_update_selection_transform() {
@@ -260,93 +245,87 @@ void GridMapEditor::_update_selection_transform() {
 
 		Transform xf;
 		xf.basis.set_zero();
-		VisualServer::get_singleton()->instance_set_transform(selection_instance,xf);
+		VisualServer::get_singleton()->instance_set_transform(selection_instance, xf);
 		return;
 	}
 
 	Transform xf;
-	xf.scale(Vector3(1,1,1)*(Vector3(1,1,1)+(selection.end-selection.begin))*node->get_cell_size());
-	xf.origin=selection.begin*node->get_cell_size();
-
-	VisualServer::get_singleton()->instance_set_transform(selection_instance,node->get_global_transform() * xf);
+	xf.scale(Vector3(1, 1, 1) * (Vector3(1, 1, 1) + (selection.end - selection.begin)) * node->get_cell_size());
+	xf.origin = selection.begin * node->get_cell_size();
 
+	VisualServer::get_singleton()->instance_set_transform(selection_instance, node->get_global_transform() * xf);
 }
 
 void GridMapEditor::_validate_selection() {
 
 	if (!selection.active)
 		return;
-	selection.begin=selection.click;
-	selection.end=selection.current;
-
-	if (selection.begin.x>selection.end.x)
-		SWAP(selection.begin.x,selection.end.x);
-	if (selection.begin.y>selection.end.y)
-		SWAP(selection.begin.y,selection.end.y);
-	if (selection.begin.z>selection.end.z)
-		SWAP(selection.begin.z,selection.end.z);
+	selection.begin = selection.click;
+	selection.end = selection.current;
 
+	if (selection.begin.x > selection.end.x)
+		SWAP(selection.begin.x, selection.end.x);
+	if (selection.begin.y > selection.end.y)
+		SWAP(selection.begin.y, selection.end.y);
+	if (selection.begin.z > selection.end.z)
+		SWAP(selection.begin.z, selection.end.z);
 
 	_update_selection_transform();
 }
 
-bool GridMapEditor::do_input_action(Camera* p_camera,const Point2& p_point,bool p_click) {
+bool GridMapEditor::do_input_action(Camera *p_camera, const Point2 &p_point, bool p_click) {
 
 	if (!spatial_editor)
 		return false;
 
-
-	if (selected_pallete<0 && input_action!=INPUT_COPY && input_action!=INPUT_SELECT && input_action!=INPUT_DUPLICATE)
+	if (selected_pallete < 0 && input_action != INPUT_COPY && input_action != INPUT_SELECT && input_action != INPUT_DUPLICATE)
 		return false;
 	Ref<MeshLibrary> theme = node->get_theme();
 	if (theme.is_null())
 		return false;
-	if (input_action!=INPUT_COPY && input_action!=INPUT_SELECT && input_action!=INPUT_DUPLICATE && !theme->has_item(selected_pallete))
+	if (input_action != INPUT_COPY && input_action != INPUT_SELECT && input_action != INPUT_DUPLICATE && !theme->has_item(selected_pallete))
 		return false;
 
 	Camera *camera = p_camera;
 	Vector3 from = camera->project_ray_origin(p_point);
 	Vector3 normal = camera->project_ray_normal(p_point);
 	Transform local_xform = node->get_global_transform().affine_inverse();
-	Vector<Plane> planes=camera->get_frustum();
-	from=local_xform.xform(from);
-	normal=local_xform.basis.xform(normal).normalized();
-
+	Vector<Plane> planes = camera->get_frustum();
+	from = local_xform.xform(from);
+	normal = local_xform.basis.xform(normal).normalized();
 
 	Plane p;
-	p.normal[edit_axis]=1.0;
-	p.d=edit_floor[edit_axis]*node->get_cell_size();
+	p.normal[edit_axis] = 1.0;
+	p.d = edit_floor[edit_axis] * node->get_cell_size();
 
 	Vector3 inters;
 	if (!p.intersects_segment(from, from + normal * settings_pick_distance->get_value(), &inters))
 		return false;
 
-
 	//make sure the intersection is inside the frustum planes, to avoid
 	//painting on invisible regions
-	for(int i=0;i<planes.size();i++) {
+	for (int i = 0; i < planes.size(); i++) {
 
 		Plane fp = local_xform.xform(planes[i]);
 		if (fp.is_point_over(inters))
 			return false;
 	}
 
-
 	int cell[3];
-	float cell_size[3]={node->get_cell_size(),node->get_cell_size(),node->get_cell_size()};
+	float cell_size[3] = { node->get_cell_size(), node->get_cell_size(), node->get_cell_size() };
 
-	last_mouseover=Vector3(-1,-1,-1);
+	last_mouseover = Vector3(-1, -1, -1);
 
-	for(int i=0;i<3;i++) {
+	for (int i = 0; i < 3; i++) {
 
-		if (i==edit_axis)
-			cell[i]=edit_floor[i];
+		if (i == edit_axis)
+			cell[i] = edit_floor[i];
 		else {
 
-			cell[i]=inters[i]/node->get_cell_size();
-			if (inters[i]<0)
-				cell[i]-=1; //compensate negative
-			grid_ofs[i]=cell[i]*cell_size[i];
+			cell[i] = inters[i] / node->get_cell_size();
+			if (inters[i] < 0)
+				cell[i] -= 1; //compensate negative
+			grid_ofs[i] = cell[i] * cell_size[i];
 		}
 
 		/*if (cell[i]<0 || cell[i]>=grid_size[i]) {
@@ -357,68 +336,65 @@ bool GridMapEditor::do_input_action(Camera* p_camera,const Point2& p_point,bool
 		}*/
 	}
 
-	last_mouseover=Vector3(cell[0],cell[1],cell[2]);
-	VS::get_singleton()->instance_set_transform(grid_instance[edit_axis],Transform(Basis(),grid_ofs));
-
+	last_mouseover = Vector3(cell[0], cell[1], cell[2]);
+	VS::get_singleton()->instance_set_transform(grid_instance[edit_axis], Transform(Basis(), grid_ofs));
 
 	if (cursor_instance.is_valid()) {
 
-		cursor_origin=(Vector3(cell[0],cell[1],cell[2])+Vector3(0.5*node->get_center_x(),0.5*node->get_center_y(),0.5*node->get_center_z()))*node->get_cell_size();
-		cursor_visible=true;
+		cursor_origin = (Vector3(cell[0], cell[1], cell[2]) + Vector3(0.5 * node->get_center_x(), 0.5 * node->get_center_y(), 0.5 * node->get_center_z())) * node->get_cell_size();
+		cursor_visible = true;
 
 		_update_cursor_transform();
-
 	}
 
-	if (input_action==INPUT_DUPLICATE) {
+	if (input_action == INPUT_DUPLICATE) {
 
-		selection.current=Vector3(cell[0],cell[1],cell[2]);
+		selection.current = Vector3(cell[0], cell[1], cell[2]);
 		_update_duplicate_indicator();
 
-	} else if (input_action==INPUT_SELECT) {
+	} else if (input_action == INPUT_SELECT) {
 
-		selection.current=Vector3(cell[0],cell[1],cell[2]);
+		selection.current = Vector3(cell[0], cell[1], cell[2]);
 		if (p_click)
-			selection.click=selection.current;
-		selection.active=true;
+			selection.click = selection.current;
+		selection.active = true;
 		_validate_selection();
 
 		return true;
-	} else if (input_action==INPUT_COPY) {
+	} else if (input_action == INPUT_COPY) {
 
-		int item=node->get_cell_item(cell[0],cell[1],cell[2]);
-		if (item>=0) {
-			selected_pallete=item;
+		int item = node->get_cell_item(cell[0], cell[1], cell[2]);
+		if (item >= 0) {
+			selected_pallete = item;
 			theme_pallete->set_current(item);
 			update_pallete();
 			_update_cursor_instance();
 		}
 		return true;
-	} if (input_action==INPUT_PAINT) {
+	}
+	if (input_action == INPUT_PAINT) {
 		SetItem si;
-		si.pos=Vector3(cell[0],cell[1],cell[2]);
-		si.new_value=selected_pallete;
-		si.new_orientation=cursor_rot;
-		si.old_value=node->get_cell_item(cell[0],cell[1],cell[2]);
-		si.old_orientation=node->get_cell_item_orientation(cell[0],cell[1],cell[2]);
+		si.pos = Vector3(cell[0], cell[1], cell[2]);
+		si.new_value = selected_pallete;
+		si.new_orientation = cursor_rot;
+		si.old_value = node->get_cell_item(cell[0], cell[1], cell[2]);
+		si.old_orientation = node->get_cell_item_orientation(cell[0], cell[1], cell[2]);
 		set_items.push_back(si);
-		node->set_cell_item(cell[0],cell[1],cell[2],selected_pallete,cursor_rot);
+		node->set_cell_item(cell[0], cell[1], cell[2], selected_pallete, cursor_rot);
 		return true;
-	} else if (input_action==INPUT_ERASE) {
+	} else if (input_action == INPUT_ERASE) {
 		SetItem si;
-		si.pos=Vector3(cell[0],cell[1],cell[2]);
-		si.new_value=-1;
-		si.new_orientation=0;
-		si.old_value=node->get_cell_item(cell[0],cell[1],cell[2]);
-		si.old_orientation=node->get_cell_item_orientation(cell[0],cell[1],cell[2]);
+		si.pos = Vector3(cell[0], cell[1], cell[2]);
+		si.new_value = -1;
+		si.new_orientation = 0;
+		si.old_value = node->get_cell_item(cell[0], cell[1], cell[2]);
+		si.old_orientation = node->get_cell_item_orientation(cell[0], cell[1], cell[2]);
 		set_items.push_back(si);
-		node->set_cell_item(cell[0],cell[1],cell[2],-1);
+		node->set_cell_item(cell[0], cell[1], cell[2], -1);
 		return true;
 	}
 
-
 	return false;
-
 }
 
 void GridMapEditor::_delete_selection() {
@@ -427,269 +403,253 @@ void GridMapEditor::_delete_selection() {
 		return;
 
 	undo_redo->create_action("GridMap Delete Selection");
-	for(int i=selection.begin.x;i<=selection.end.x;i++) {
+	for (int i = selection.begin.x; i <= selection.end.x; i++) {
 
-		for(int j=selection.begin.y;j<=selection.end.y;j++) {
+		for (int j = selection.begin.y; j <= selection.end.y; j++) {
 
-			for(int k=selection.begin.z;k<=selection.end.z;k++) {
+			for (int k = selection.begin.z; k <= selection.end.z; k++) {
 
-				undo_redo->add_do_method(node,"set_cell_item",i,j,k,GridMap::INVALID_CELL_ITEM);
-				undo_redo->add_undo_method(node,"set_cell_item",i,j,k,node->get_cell_item(i,j,k),node->get_cell_item_orientation(i,j,k));
+				undo_redo->add_do_method(node, "set_cell_item", i, j, k, GridMap::INVALID_CELL_ITEM);
+				undo_redo->add_undo_method(node, "set_cell_item", i, j, k, node->get_cell_item(i, j, k), node->get_cell_item_orientation(i, j, k));
 			}
-
 		}
 	}
 	undo_redo->commit_action();
 
-	selection.active=false;
+	selection.active = false;
 	_validate_selection();
-
 }
 
 void GridMapEditor::_update_duplicate_indicator() {
 
-	if (!selection.active || input_action!=INPUT_DUPLICATE) {
+	if (!selection.active || input_action != INPUT_DUPLICATE) {
 
 		Transform xf;
 		xf.basis.set_zero();
-		VisualServer::get_singleton()->instance_set_transform(duplicate_instance,xf);
+		VisualServer::get_singleton()->instance_set_transform(duplicate_instance, xf);
 		return;
 	}
 
 	Transform xf;
-	xf.scale(Vector3(1,1,1)*(Vector3(1,1,1)+(selection.end-selection.begin))*node->get_cell_size());
-	xf.origin=(selection.begin+(selection.current-selection.click))*node->get_cell_size();
+	xf.scale(Vector3(1, 1, 1) * (Vector3(1, 1, 1) + (selection.end - selection.begin)) * node->get_cell_size());
+	xf.origin = (selection.begin + (selection.current - selection.click)) * node->get_cell_size();
 	Basis rot;
 	rot.set_orthogonal_index(selection.duplicate_rot);
 	xf.basis = rot * xf.basis;
 
-	VisualServer::get_singleton()->instance_set_transform(duplicate_instance,node->get_global_transform() * xf);
-
-
+	VisualServer::get_singleton()->instance_set_transform(duplicate_instance, node->get_global_transform() * xf);
 }
 
-struct __Item { Vector3 pos; int rot; int item	; };
+struct __Item {
+	Vector3 pos;
+	int rot;
+	int item;
+};
 void GridMapEditor::_duplicate_paste() {
 
 	if (!selection.active)
 		return;
 
 	int idx = options->get_popup()->get_item_index(MENU_OPTION_DUPLICATE_SELECTS);
-	bool reselect = options->get_popup()->is_item_checked( idx );
+	bool reselect = options->get_popup()->is_item_checked(idx);
 
-
-
-	List< __Item > items;
+	List<__Item> items;
 
 	Basis rot;
 	rot.set_orthogonal_index(selection.duplicate_rot);
 
-	for(int i=selection.begin.x;i<=selection.end.x;i++) {
+	for (int i = selection.begin.x; i <= selection.end.x; i++) {
 
-		for(int j=selection.begin.y;j<=selection.end.y;j++) {
+		for (int j = selection.begin.y; j <= selection.end.y; j++) {
 
-			for(int k=selection.begin.z;k<=selection.end.z;k++) {
+			for (int k = selection.begin.z; k <= selection.end.z; k++) {
 
-				int itm = node->get_cell_item(i,j,k);
-				if (itm==GridMap::INVALID_CELL_ITEM)
+				int itm = node->get_cell_item(i, j, k);
+				if (itm == GridMap::INVALID_CELL_ITEM)
 					continue;
-				int orientation = node->get_cell_item_orientation(i,j,k);
+				int orientation = node->get_cell_item_orientation(i, j, k);
 				__Item item;
-				Vector3 rel=Vector3(i,j,k)-selection.begin;
+				Vector3 rel = Vector3(i, j, k) - selection.begin;
 				rel = rot.xform(rel);
 
 				Basis orm;
 				orm.set_orthogonal_index(orientation);
 				orm = rot * orm;
 
-				item.pos=selection.begin+rel;
-				item.item=itm;
-				item.rot=orm.get_orthogonal_index();
+				item.pos = selection.begin + rel;
+				item.item = itm;
+				item.rot = orm.get_orthogonal_index();
 				items.push_back(item);
 			}
-
 		}
 	}
 
-	Vector3 ofs=selection.current-selection.click;
+	Vector3 ofs = selection.current - selection.click;
 	if (items.size()) {
 		undo_redo->create_action("GridMap Duplicate Selection");
-		for(List< __Item >::Element *E=items.front();E;E=E->next()) {
-			__Item &it=E->get();
-			Vector3 pos = it.pos+ofs;
-
-			undo_redo->add_do_method(node,"set_cell_item",pos.x,pos.y,pos.z,it.item,it.rot);
-			undo_redo->add_undo_method(node,"set_cell_item",pos.x,pos.y,pos.z,node->get_cell_item(pos.x,pos.y,pos.z),node->get_cell_item_orientation(pos.x,pos.y,pos.z));
+		for (List<__Item>::Element *E = items.front(); E; E = E->next()) {
+			__Item &it = E->get();
+			Vector3 pos = it.pos + ofs;
 
+			undo_redo->add_do_method(node, "set_cell_item", pos.x, pos.y, pos.z, it.item, it.rot);
+			undo_redo->add_undo_method(node, "set_cell_item", pos.x, pos.y, pos.z, node->get_cell_item(pos.x, pos.y, pos.z), node->get_cell_item_orientation(pos.x, pos.y, pos.z));
 		}
 		undo_redo->commit_action();
 	}
 
-
 	if (reselect) {
 
-		selection.begin+=ofs;
-		selection.end+=ofs;
-		selection.click=selection.begin;
-		selection.current=selection.end;
+		selection.begin += ofs;
+		selection.end += ofs;
+		selection.click = selection.begin;
+		selection.current = selection.end;
 		_validate_selection();
 	}
-
 }
 
-bool GridMapEditor::forward_spatial_input_event(Camera* p_camera,const InputEvent& p_event) {
+bool GridMapEditor::forward_spatial_input_event(Camera *p_camera, const InputEvent &p_event) {
 	if (!node) {
 		return false;
 	}
 
-	if (edit_mode->get_selected()==0) { // regular click
+	if (edit_mode->get_selected() == 0) { // regular click
 		switch (p_event.type) {
 			case InputEvent::MOUSE_BUTTON: {
 
-				if (p_event.mouse_button.button_index==BUTTON_WHEEL_UP && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) {
+				if (p_event.mouse_button.button_index == BUTTON_WHEEL_UP && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) {
 					if (p_event.mouse_button.pressed)
-						floor->set_value( floor->get_value() +1);
+						floor->set_value(floor->get_value() + 1);
 
 					return true; //eaten
-				} else if (p_event.mouse_button.button_index==BUTTON_WHEEL_DOWN && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) {
+				} else if (p_event.mouse_button.button_index == BUTTON_WHEEL_DOWN && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) {
 					if (p_event.mouse_button.pressed)
-						floor->set_value( floor->get_value() -1);
+						floor->set_value(floor->get_value() - 1);
 					return true;
 				}
 
 				if (p_event.mouse_button.pressed) {
 
-					if (p_event.mouse_button.button_index==BUTTON_LEFT) {
+					if (p_event.mouse_button.button_index == BUTTON_LEFT) {
 
-						if (input_action==INPUT_DUPLICATE) {
+						if (input_action == INPUT_DUPLICATE) {
 
 							//paste
 							_duplicate_paste();
-							input_action=INPUT_NONE;
+							input_action = INPUT_NONE;
 							_update_duplicate_indicator();
 						} else if (p_event.mouse_button.mod.shift) {
-							input_action=INPUT_SELECT;
+							input_action = INPUT_SELECT;
 						} else if (p_event.mouse_button.mod.command)
-							input_action=INPUT_COPY;
+							input_action = INPUT_COPY;
 						else {
-							input_action=INPUT_PAINT;
+							input_action = INPUT_PAINT;
 							set_items.clear();
 						}
-					} else if (p_event.mouse_button.button_index==BUTTON_RIGHT)
-						if (input_action==INPUT_DUPLICATE) {
+					} else if (p_event.mouse_button.button_index == BUTTON_RIGHT)
+						if (input_action == INPUT_DUPLICATE) {
 
-							input_action=INPUT_NONE;
+							input_action = INPUT_NONE;
 							_update_duplicate_indicator();
 						} else {
-							input_action=INPUT_ERASE;
+							input_action = INPUT_ERASE;
 							set_items.clear();
 						}
 					else
 						return false;
 
-					return do_input_action(p_camera,Point2(p_event.mouse_button.x,p_event.mouse_button.y),true);
+					return do_input_action(p_camera, Point2(p_event.mouse_button.x, p_event.mouse_button.y), true);
 				} else {
 
-
 					if (
-						(p_event.mouse_button.button_index==BUTTON_RIGHT && input_action==INPUT_ERASE) ||
-						(p_event.mouse_button.button_index==BUTTON_LEFT && input_action==INPUT_PAINT) ) {
+							(p_event.mouse_button.button_index == BUTTON_RIGHT && input_action == INPUT_ERASE) ||
+							(p_event.mouse_button.button_index == BUTTON_LEFT && input_action == INPUT_PAINT)) {
 
 						if (set_items.size()) {
 							undo_redo->create_action("GridMap Paint");
-							for(List<SetItem>::Element *E=set_items.front();E;E=E->next()) {
+							for (List<SetItem>::Element *E = set_items.front(); E; E = E->next()) {
 
-								const SetItem &si=E->get();
-								undo_redo->add_do_method(node,"set_cell_item",si.pos.x,si.pos.y,si.pos.z,si.new_value,si.new_orientation);
+								const SetItem &si = E->get();
+								undo_redo->add_do_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.new_value, si.new_orientation);
 							}
-							for(List<SetItem>::Element *E=set_items.back();E;E=E->prev()) {
+							for (List<SetItem>::Element *E = set_items.back(); E; E = E->prev()) {
 
-								const SetItem &si=E->get();
-								undo_redo->add_undo_method(node,"set_cell_item",si.pos.x,si.pos.y,si.pos.z,si.old_value,si.old_orientation);
+								const SetItem &si = E->get();
+								undo_redo->add_undo_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.old_value, si.old_orientation);
 							}
 
-
 							undo_redo->commit_action();
 						}
 						set_items.clear();
-						input_action=INPUT_NONE;
+						input_action = INPUT_NONE;
 						return true;
-
 					}
 
-
-
-					if (p_event.mouse_button.button_index==BUTTON_LEFT && input_action!=INPUT_NONE) {
+					if (p_event.mouse_button.button_index == BUTTON_LEFT && input_action != INPUT_NONE) {
 
 						set_items.clear();
-						input_action=INPUT_NONE;
+						input_action = INPUT_NONE;
 						return true;
 					}
-					if (p_event.mouse_button.button_index==BUTTON_RIGHT && (input_action==INPUT_ERASE || input_action==INPUT_DUPLICATE)) {
-						input_action=INPUT_NONE;
+					if (p_event.mouse_button.button_index == BUTTON_RIGHT && (input_action == INPUT_ERASE || input_action == INPUT_DUPLICATE)) {
+						input_action = INPUT_NONE;
 						return true;
 					}
 				}
 			} break;
 			case InputEvent::MOUSE_MOTION: {
 
-				return do_input_action(p_camera,Point2(p_event.mouse_motion.x,p_event.mouse_motion.y),false);
+				return do_input_action(p_camera, Point2(p_event.mouse_motion.x, p_event.mouse_motion.y), false);
 			} break;
 		}
 
-	} else if (edit_mode->get_selected()==1) {
+	} else if (edit_mode->get_selected() == 1) {
 		//area mode, select an area
 
 		switch (p_event.type) {
 			case InputEvent::MOUSE_BUTTON: {
 
-				if (p_event.mouse_button.button_index==BUTTON_LEFT && p_event.mouse_button.pressed) {
+				if (p_event.mouse_button.button_index == BUTTON_LEFT && p_event.mouse_button.pressed) {
 
-					Point2 point = Point2(p_event.mouse_motion.x,p_event.mouse_motion.y);
+					Point2 point = Point2(p_event.mouse_motion.x, p_event.mouse_motion.y);
 
 					Camera *camera = p_camera;
 					Vector3 from = camera->project_ray_origin(point);
 					Vector3 normal = camera->project_ray_normal(point);
 					Transform local_xform = node->get_global_transform().affine_inverse();
-					from=local_xform.xform(from);
-					normal=local_xform.basis.xform(normal).normalized();
+					from = local_xform.xform(from);
+					normal = local_xform.basis.xform(normal).normalized();
 
 					List<int> areas;
 					node->get_area_list(&areas);
 
-					float min_d=1e10;
-					int min_area=-1;
+					float min_d = 1e10;
+					int min_area = -1;
 
-
-					for(List<int>::Element *E=areas.front();E;E=E->next()) {
+					for (List<int>::Element *E = areas.front(); E; E = E->next()) {
 
 						int area = E->get();
 						Rect3 aabb = node->area_get_bounds(area);
-						aabb.pos*=node->get_cell_size();
-						aabb.size*=node->get_cell_size();
-
+						aabb.pos *= node->get_cell_size();
+						aabb.size *= node->get_cell_size();
 
-						Vector3 rclip,rnormal;
-						if (!aabb.intersects_segment(from,from+normal*10000,&rclip,&rnormal))
+						Vector3 rclip, rnormal;
+						if (!aabb.intersects_segment(from, from + normal * 10000, &rclip, &rnormal))
 							continue;
 
 						float d = normal.dot(rclip);
-						if (d<min_d) {
-							min_d=d;
-							min_area=area;
+						if (d < min_d) {
+							min_d = d;
+							min_area = area;
 						}
 					}
 
-					selected_area=min_area;
+					selected_area = min_area;
 					update_areas();
-
 				}
 			} break;
 		}
-
 	}
 
-
 	return false;
 }
 
@@ -697,12 +657,11 @@ struct _CGMEItemSort {
 
 	String name;
 	int id;
-	_FORCE_INLINE_ bool operator<(const _CGMEItemSort& r_it) const { return name < r_it.name; }
-
+	_FORCE_INLINE_ bool operator<(const _CGMEItemSort &r_it) const { return name < r_it.name; }
 };
 
 void GridMapEditor::_set_display_mode(int p_mode) {
-	if (display_mode==p_mode) {
+	if (display_mode == p_mode) {
 		return;
 	}
 
@@ -714,32 +673,32 @@ void GridMapEditor::_set_display_mode(int p_mode) {
 		mode_thumbnail->set_pressed(true);
 	}
 
-	display_mode=p_mode;
+	display_mode = p_mode;
 
 	update_pallete();
 }
 
-void GridMapEditor::update_pallete()  {
+void GridMapEditor::update_pallete() {
 	int selected = theme_pallete->get_current();
 
 	theme_pallete->clear();
 	if (display_mode == DISPLAY_THUMBNAIL) {
 		theme_pallete->set_max_columns(0);
 		theme_pallete->set_icon_mode(ItemList::ICON_MODE_TOP);
-	} else if (display_mode == DISPLAY_LIST){
+	} else if (display_mode == DISPLAY_LIST) {
 		theme_pallete->set_max_columns(1);
 		theme_pallete->set_icon_mode(ItemList::ICON_MODE_LEFT);
 	}
 
-	float min_size = EDITOR_DEF("editors/grid_map/preview_size",64);
+	float min_size = EDITOR_DEF("editors/grid_map/preview_size", 64);
 	theme_pallete->set_fixed_icon_size(Size2(min_size, min_size));
-	theme_pallete->set_fixed_column_width(min_size*3/2);
+	theme_pallete->set_fixed_column_width(min_size * 3 / 2);
 	theme_pallete->set_max_text_lines(2);
 
 	Ref<MeshLibrary> theme = node->get_theme();
 
 	if (theme.is_null()) {
-		last_theme=NULL;
+		last_theme = NULL;
 		return;
 	}
 
@@ -747,65 +706,63 @@ void GridMapEditor::update_pallete()  {
 	ids = theme->get_item_list();
 
 	List<_CGMEItemSort> il;
-	for(int i=0;i<ids.size();i++) {
+	for (int i = 0; i < ids.size(); i++) {
 
 		_CGMEItemSort is;
-		is.id=ids[i];
-		is.name=theme->get_item_name(ids[i]);
+		is.id = ids[i];
+		is.name = theme->get_item_name(ids[i]);
 		il.push_back(is);
 	}
 	il.sort();
 
 	int item = 0;
 
-	for(List<_CGMEItemSort>::Element *E=il.front();E;E=E->next()) {
+	for (List<_CGMEItemSort>::Element *E = il.front(); E; E = E->next()) {
 		int id = E->get().id;
 
 		theme_pallete->add_item("");
 
-		String name=theme->get_item_name(id);
+		String name = theme->get_item_name(id);
 		Ref<Texture> preview = theme->get_item_preview(id);
 
 		if (!preview.is_null()) {
 			theme_pallete->set_item_icon(item, preview);
 			theme_pallete->set_item_tooltip(item, name);
 		}
-		if (name!="") {
-			theme_pallete->set_item_text(item,name);
+		if (name != "") {
+			theme_pallete->set_item_text(item, name);
 		}
 		theme_pallete->set_item_metadata(item, id);
 
 		item++;
 	}
 
-	if (selected!=-1) {
+	if (selected != -1) {
 		theme_pallete->select(selected);
 	}
 
-	last_theme=theme.operator->();
+	last_theme = theme.operator->();
 }
 
-
 void GridMapEditor::_area_renamed() {
 
-	TreeItem * it = area_list->get_selected();
+	TreeItem *it = area_list->get_selected();
 	int area = it->get_metadata(0);
-	if (area<1)
+	if (area < 1)
 		return;
-	node->area_set_name(area,it->get_text(0));
+	node->area_set_name(area, it->get_text(0));
 }
 
-
 void GridMapEditor::_area_selected() {
 
-	TreeItem * it = area_list->get_selected();
+	TreeItem *it = area_list->get_selected();
 	int area = it->get_metadata(0);
-	if (area<1)
+	if (area < 1)
 		return;
-	selected_area=area;
+	selected_area = area;
 }
 
-void GridMapEditor::update_areas()  {
+void GridMapEditor::update_areas() {
 
 	area_list->clear();
 
@@ -814,246 +771,221 @@ void GridMapEditor::update_areas()  {
 
 	TreeItem *root = area_list->create_item(NULL);
 	area_list->set_hide_root(true);
-	TreeItem *selected=NULL;
-
+	TreeItem *selected = NULL;
 
-	for (List<int>::Element *E=areas.front();E;E=E->next()) {
+	for (List<int>::Element *E = areas.front(); E; E = E->next()) {
 
 		int area = E->get();
 		TreeItem *ti = area_list->create_item(root);
-		String name=node->area_get_name(area);
+		String name = node->area_get_name(area);
 
-		ti->set_metadata(0,area);
-		ti->set_text(0,name);
-		ti->set_editable(0,true);
-		if (area==selected_area)
-			selected=ti;
+		ti->set_metadata(0, area);
+		ti->set_text(0, name);
+		ti->set_editable(0, true);
+		if (area == selected_area)
+			selected = ti;
 	}
 
-
 	if (selected)
 		selected->select(0);
-
 }
 
 void GridMapEditor::edit(GridMap *p_gridmap) {
 
-	node=p_gridmap;
+	node = p_gridmap;
 	VS *vs = VS::get_singleton();
 
-	last_mouseover=Vector3(-1,-1,-1);
-	input_action=INPUT_NONE;
-	selection.active=false;
+	last_mouseover = Vector3(-1, -1, -1);
+	input_action = INPUT_NONE;
+	selection.active = false;
 	_update_selection_transform();
 	_update_duplicate_indicator();
 
-	spatial_editor  = editor->get_editor_plugin_screen()->cast_to<SpatialEditorPlugin>();
+	spatial_editor = editor->get_editor_plugin_screen()->cast_to<SpatialEditorPlugin>();
 
 	if (!node) {
 		set_process(false);
-		for(int i=0;i<3;i++) {
-			VisualServer::get_singleton()->instance_set_visible(grid_instance[i],false);
-
+		for (int i = 0; i < 3; i++) {
+			VisualServer::get_singleton()->instance_set_visible(grid_instance[i], false);
 		}
 
-		VisualServer::get_singleton()->instance_set_visible(cursor_instance,false);
+		VisualServer::get_singleton()->instance_set_visible(cursor_instance, false);
 
 		_clear_areas();
 
 		return;
 	}
 
-
 	update_pallete();
 	update_areas();
 
 	set_process(true);
 
 	Vector3 edited_floor = p_gridmap->get_meta("_editor_floor_");
-	clip_mode=p_gridmap->has_meta("_editor_clip_")?ClipMode(p_gridmap->get_meta("_editor_clip_").operator int()):CLIP_DISABLED;
-
-
-
-	for(int i=0;i<3;i++) {
-		if (vs->mesh_get_surface_count(grid[i])>0)
-			vs->mesh_remove_surface(grid[i],0);
-		edit_floor[i]=edited_floor[i];
+	clip_mode = p_gridmap->has_meta("_editor_clip_") ? ClipMode(p_gridmap->get_meta("_editor_clip_").operator int()) : CLIP_DISABLED;
 
+	for (int i = 0; i < 3; i++) {
+		if (vs->mesh_get_surface_count(grid[i]) > 0)
+			vs->mesh_remove_surface(grid[i], 0);
+		edit_floor[i] = edited_floor[i];
 	}
 
 	{
 
 		//update grids
 		indicator_mat.instance();
-		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED,true);
-		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR,true);
-		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR,true);
-		indicator_mat->set_albedo(Color(0.8,0.5,0.1));
-
+		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true);
+		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
+		indicator_mat->set_flag(FixedSpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
+		indicator_mat->set_albedo(Color(0.8, 0.5, 0.1));
 
 		Vector<Vector3> grid_points[3];
 		Vector<Color> grid_colors[3];
 
-		float cell_size[3]={p_gridmap->get_cell_size(),p_gridmap->get_cell_size(),p_gridmap->get_cell_size()};
+		float cell_size[3] = { p_gridmap->get_cell_size(), p_gridmap->get_cell_size(), p_gridmap->get_cell_size() };
 
-		for(int i=0;i<3;i++) {
+		for (int i = 0; i < 3; i++) {
 
 			Vector3 axis;
-			axis[i]=1;
+			axis[i] = 1;
 			Vector3 axis_n1;
-			axis_n1[(i+1)%3]=cell_size[(i+1)%3];
+			axis_n1[(i + 1) % 3] = cell_size[(i + 1) % 3];
 			Vector3 axis_n2;
-			axis_n2[(i+2)%3]=cell_size[(i+2)%3];
+			axis_n2[(i + 2) % 3] = cell_size[(i + 2) % 3];
 
-			for(int j=-GRID_CURSOR_SIZE;j<=GRID_CURSOR_SIZE;j++) {
+			for (int j = -GRID_CURSOR_SIZE; j <= GRID_CURSOR_SIZE; j++) {
 
-				for(int k=-GRID_CURSOR_SIZE;k<=GRID_CURSOR_SIZE;k++) {
+				for (int k = -GRID_CURSOR_SIZE; k <= GRID_CURSOR_SIZE; k++) {
 
-					Vector3 p = axis_n1*j + axis_n2 *k;
-					float trans = Math::pow(MAX(0,1.0-(Vector2(j,k).length()/GRID_CURSOR_SIZE)),2);
+					Vector3 p = axis_n1 * j + axis_n2 * k;
+					float trans = Math::pow(MAX(0, 1.0 - (Vector2(j, k).length() / GRID_CURSOR_SIZE)), 2);
 
-					Vector3 pj = axis_n1*(j+1) + axis_n2 *k;
-					float transj = Math::pow(MAX(0,1.0-(Vector2(j+1,k).length()/GRID_CURSOR_SIZE)),2);
+					Vector3 pj = axis_n1 * (j + 1) + axis_n2 * k;
+					float transj = Math::pow(MAX(0, 1.0 - (Vector2(j + 1, k).length() / GRID_CURSOR_SIZE)), 2);
 
-					Vector3 pk = axis_n1*j + axis_n2 *(k+1);
-					float transk = Math::pow(MAX(0,1.0-(Vector2(j,k+1).length()/GRID_CURSOR_SIZE)),2);
+					Vector3 pk = axis_n1 * j + axis_n2 * (k + 1);
+					float transk = Math::pow(MAX(0, 1.0 - (Vector2(j, k + 1).length() / GRID_CURSOR_SIZE)), 2);
 
 					grid_points[i].push_back(p);
 					grid_points[i].push_back(pk);
-					grid_colors[i].push_back(Color(1,1,1,trans));
-					grid_colors[i].push_back(Color(1,1,1,transk));
+					grid_colors[i].push_back(Color(1, 1, 1, trans));
+					grid_colors[i].push_back(Color(1, 1, 1, transk));
 
 					grid_points[i].push_back(p);
 					grid_points[i].push_back(pj);
-					grid_colors[i].push_back(Color(1,1,1,trans));
-					grid_colors[i].push_back(Color(1,1,1,transj));
+					grid_colors[i].push_back(Color(1, 1, 1, trans));
+					grid_colors[i].push_back(Color(1, 1, 1, transj));
 				}
-
 			}
 
 			Array d;
 			d.resize(VS::ARRAY_MAX);
-			d[VS::ARRAY_VERTEX]=grid_points[i];
-			d[VS::ARRAY_COLOR]=grid_colors[i];
-			VisualServer::get_singleton()->mesh_add_surface_from_arrays(grid[i],VisualServer::PRIMITIVE_LINES,d);
-			VisualServer::get_singleton()->mesh_surface_set_material(grid[i],0,indicator_mat->get_rid());
-
-
+			d[VS::ARRAY_VERTEX] = grid_points[i];
+			d[VS::ARRAY_COLOR] = grid_colors[i];
+			VisualServer::get_singleton()->mesh_add_surface_from_arrays(grid[i], VisualServer::PRIMITIVE_LINES, d);
+			VisualServer::get_singleton()->mesh_surface_set_material(grid[i], 0, indicator_mat->get_rid());
 		}
-
 	}
 
 	update_grid();
 	_update_clip();
 	_update_areas_display();
-
-
 }
 
 void GridMapEditor::_update_clip() {
 
-
-	node->set_meta("_editor_clip_",clip_mode);
-	if (clip_mode==CLIP_DISABLED)
+	node->set_meta("_editor_clip_", clip_mode);
+	if (clip_mode == CLIP_DISABLED)
 		node->set_clip(false);
 	else
-		node->set_clip(true,clip_mode==CLIP_ABOVE,edit_floor[edit_axis],edit_axis);
+		node->set_clip(true, clip_mode == CLIP_ABOVE, edit_floor[edit_axis], edit_axis);
 }
 
-
 void GridMapEditor::update_grid() {
 
-	grid_xform.origin.x-=1; //force update in hackish way.. what do i care
+	grid_xform.origin.x -= 1; //force update in hackish way.. what do i care
 
 	//VS *vs = VS::get_singleton();
 
-	grid_ofs[edit_axis]=edit_floor[edit_axis]*node->get_cell_size();
-
-	edit_grid_xform.origin=grid_ofs;
-	edit_grid_xform.basis=Basis();
+	grid_ofs[edit_axis] = edit_floor[edit_axis] * node->get_cell_size();
 
+	edit_grid_xform.origin = grid_ofs;
+	edit_grid_xform.basis = Basis();
 
-	for(int i=0;i<3;i++) {
-		VisualServer::get_singleton()->instance_set_visible(grid_instance[i],i==edit_axis);
-
+	for (int i = 0; i < 3; i++) {
+		VisualServer::get_singleton()->instance_set_visible(grid_instance[i], i == edit_axis);
 	}
 
-	updating=true;
+	updating = true;
 	floor->set_value(edit_floor[edit_axis]);
-	updating=false;
-
+	updating = false;
 }
 
-
-
 void GridMapEditor::_notification(int p_what) {
 
-	if (p_what==NOTIFICATION_ENTER_TREE) {
+	if (p_what == NOTIFICATION_ENTER_TREE) {
 
-		theme_pallete->connect("item_selected", this,"_item_selected_cbk");
-		edit_mode->connect("item_selected", this,"_edit_mode_changed");
-		area_list->connect("item_edited", this,"_area_renamed");
-		area_list->connect("item_selected", this,"_area_selected");
-		for(int i=0;i<3;i++) {
+		theme_pallete->connect("item_selected", this, "_item_selected_cbk");
+		edit_mode->connect("item_selected", this, "_edit_mode_changed");
+		area_list->connect("item_edited", this, "_area_renamed");
+		area_list->connect("item_selected", this, "_area_selected");
+		for (int i = 0; i < 3; i++) {
 
-			grid[i]=VS::get_singleton()->mesh_create();
-			grid_instance[i]=VS::get_singleton()->instance_create2(grid[i],get_tree()->get_root()->get_world()->get_scenario());
+			grid[i] = VS::get_singleton()->mesh_create();
+			grid_instance[i] = VS::get_singleton()->instance_create2(grid[i], get_tree()->get_root()->get_world()->get_scenario());
 		}
 
-		selection_instance = VisualServer::get_singleton()->instance_create2(selection_mesh,get_tree()->get_root()->get_world()->get_scenario());
-		duplicate_instance = VisualServer::get_singleton()->instance_create2(duplicate_mesh,get_tree()->get_root()->get_world()->get_scenario());
+		selection_instance = VisualServer::get_singleton()->instance_create2(selection_mesh, get_tree()->get_root()->get_world()->get_scenario());
+		duplicate_instance = VisualServer::get_singleton()->instance_create2(duplicate_mesh, get_tree()->get_root()->get_world()->get_scenario());
 
 		_update_selection_transform();
 		_update_duplicate_indicator();
 
-	} else if (p_what==NOTIFICATION_EXIT_TREE) {
+	} else if (p_what == NOTIFICATION_EXIT_TREE) {
 
-		for(int i=0;i<3;i++) {
+		for (int i = 0; i < 3; i++) {
 
 			VS::get_singleton()->free(grid_instance[i]);
 			VS::get_singleton()->free(grid[i]);
-			grid_instance[i]=RID();
-			grid[i]=RID();
+			grid_instance[i] = RID();
+			grid[i] = RID();
 		}
 
 		VisualServer::get_singleton()->free(selection_instance);
 		VisualServer::get_singleton()->free(duplicate_instance);
-		selection_instance=RID();
-		duplicate_instance=RID();
+		selection_instance = RID();
+		duplicate_instance = RID();
 
-	} else if (p_what==NOTIFICATION_PROCESS) {
+	} else if (p_what == NOTIFICATION_PROCESS) {
 
 		Transform xf = node->get_global_transform();
 
-		if (xf!=grid_xform) {
-			for(int i=0;i<3;i++) {
-
+		if (xf != grid_xform) {
+			for (int i = 0; i < 3; i++) {
 
-				VS::get_singleton()->instance_set_transform(grid_instance[i],xf * edit_grid_xform);
+				VS::get_singleton()->instance_set_transform(grid_instance[i], xf * edit_grid_xform);
 			}
-			grid_xform=xf;
+			grid_xform = xf;
 		}
 		Ref<MeshLibrary> cgmt = node->get_theme();
-		if (cgmt.operator->()!=last_theme)
+		if (cgmt.operator->() != last_theme)
 			update_pallete();
 
 		if (lock_view) {
 
-			EditorNode*editor = get_tree()->get_root()->get_child(0)->cast_to<EditorNode>();
+			EditorNode *editor = get_tree()->get_root()->get_child(0)->cast_to<EditorNode>();
 
 			Plane p;
-			p.normal[edit_axis]=1.0;
-			p.d=edit_floor[edit_axis]*node->get_cell_size();
+			p.normal[edit_axis] = 1.0;
+			p.d = edit_floor[edit_axis] * node->get_cell_size();
 			p = node->get_transform().xform(p); // plane to snap
 
 			SpatialEditorPlugin *sep = editor->get_editor_plugin_screen()->cast_to<SpatialEditorPlugin>();
 			if (sep)
 				sep->snap_cursor_to_plane(p);
-				//editor->get_editor_plugin_screen()->call("snap_cursor_to_plane",p);
-
+			//editor->get_editor_plugin_screen()->call("snap_cursor_to_plane",p);
 		}
 	}
-
 }
 
 void GridMapEditor::_update_cursor_instance() {
@@ -1063,32 +995,30 @@ void GridMapEditor::_update_cursor_instance() {
 
 	if (cursor_instance.is_valid())
 		VisualServer::get_singleton()->free(cursor_instance);
-	cursor_instance=RID();
+	cursor_instance = RID();
 
-	if (selected_pallete>=0) {
+	if (selected_pallete >= 0) {
 
 		if (node && !node->get_theme().is_null()) {
 			Ref<Mesh> mesh = node->get_theme()->get_item_mesh(selected_pallete);
 			if (!mesh.is_null() && mesh->get_rid().is_valid()) {
 
-				cursor_instance=VisualServer::get_singleton()->instance_create2(mesh->get_rid(),get_tree()->get_root()->get_world()->get_scenario());
-				VisualServer::get_singleton()->instance_set_transform(cursor_instance,cursor_transform);
+				cursor_instance = VisualServer::get_singleton()->instance_create2(mesh->get_rid(), get_tree()->get_root()->get_world()->get_scenario());
+				VisualServer::get_singleton()->instance_set_transform(cursor_instance, cursor_transform);
 			}
 		}
 	}
-
 }
 
 void GridMapEditor::_item_selected_cbk(int idx) {
-	selected_pallete=theme_pallete->get_item_metadata(idx);
+	selected_pallete = theme_pallete->get_item_metadata(idx);
 
 	_update_cursor_instance();
-
 }
 
 void GridMapEditor::_clear_areas() {
 
-	for(int i=0;i<areas.size();i++) {
+	for (int i = 0; i < areas.size(); i++) {
 
 		VisualServer::get_singleton()->free(areas[i].instance);
 		VisualServer::get_singleton()->free(areas[i].mesh);
@@ -1154,7 +1084,7 @@ void GridMapEditor::_update_areas_display() {
 
 void GridMapEditor::_edit_mode_changed(int p_what) {
 
-	if (p_what==0) {
+	if (p_what == 0) {
 
 		theme_pallete->show();
 		area_list->hide();
@@ -1162,89 +1092,82 @@ void GridMapEditor::_edit_mode_changed(int p_what) {
 
 		theme_pallete->hide();
 		area_list->show();
-
 	}
 }
 
 void GridMapEditor::_floor_changed(float p_value) {
 
-
 	if (updating)
 		return;
 
-	edit_floor[edit_axis]=p_value;
-	node->set_meta("_editor_floor_",Vector3(edit_floor[0],edit_floor[1],edit_floor[2]));
+	edit_floor[edit_axis] = p_value;
+	node->set_meta("_editor_floor_", Vector3(edit_floor[0], edit_floor[1], edit_floor[2]));
 	update_grid();
 	_update_clip();
-
 }
 
 void GridMapEditor::_bind_methods() {
 
-	ClassDB::bind_method("_menu_option",&GridMapEditor::_menu_option);
-	ClassDB::bind_method("_configure",&GridMapEditor::_configure);
-	ClassDB::bind_method("_item_selected_cbk",&GridMapEditor::_item_selected_cbk);
-	ClassDB::bind_method("_edit_mode_changed",&GridMapEditor::_edit_mode_changed);
-	ClassDB::bind_method("_area_renamed",&GridMapEditor::_area_renamed);
-	ClassDB::bind_method("_area_selected",&GridMapEditor::_area_selected);
-	ClassDB::bind_method("_floor_changed",&GridMapEditor::_floor_changed);
+	ClassDB::bind_method("_menu_option", &GridMapEditor::_menu_option);
+	ClassDB::bind_method("_configure", &GridMapEditor::_configure);
+	ClassDB::bind_method("_item_selected_cbk", &GridMapEditor::_item_selected_cbk);
+	ClassDB::bind_method("_edit_mode_changed", &GridMapEditor::_edit_mode_changed);
+	ClassDB::bind_method("_area_renamed", &GridMapEditor::_area_renamed);
+	ClassDB::bind_method("_area_selected", &GridMapEditor::_area_selected);
+	ClassDB::bind_method("_floor_changed", &GridMapEditor::_floor_changed);
 
-	ClassDB::bind_method(D_METHOD("_set_display_mode","mode"), &GridMapEditor::_set_display_mode);
+	ClassDB::bind_method(D_METHOD("_set_display_mode", "mode"), &GridMapEditor::_set_display_mode);
 }
 
-
-
 GridMapEditor::GridMapEditor(EditorNode *p_editor) {
 
+	input_action = INPUT_NONE;
+	editor = p_editor;
+	undo_redo = p_editor->get_undo_redo();
 
-	input_action=INPUT_NONE;
-	editor=p_editor;
-	undo_redo=p_editor->get_undo_redo();
-
-	int mw = EDITOR_DEF("editors/grid_map/palette_min_width",230);
-	Control *ec = memnew( Control);
-	ec->set_custom_minimum_size(Size2(mw,0));
+	int mw = EDITOR_DEF("editors/grid_map/palette_min_width", 230);
+	Control *ec = memnew(Control);
+	ec->set_custom_minimum_size(Size2(mw, 0));
 	add_child(ec);
 
-
-	spatial_editor_hb = memnew( HBoxContainer );
+	spatial_editor_hb = memnew(HBoxContainer);
 	SpatialEditor::get_singleton()->add_control_to_menu_panel(spatial_editor_hb);
-	options = memnew( MenuButton );
+	options = memnew(MenuButton);
 	spatial_editor_hb->add_child(options);
 	spatial_editor_hb->hide();
 
 	options->set_text("Grid");
-	options->get_popup()->add_check_item("Snap View",MENU_OPTION_LOCK_VIEW);
+	options->get_popup()->add_check_item("Snap View", MENU_OPTION_LOCK_VIEW);
 	options->get_popup()->add_separator();
-	options->get_popup()->add_item("Prev Level ("+keycode_get_string(KEY_MASK_CMD)+"Down Wheel)",MENU_OPTION_PREV_LEVEL);
-	options->get_popup()->add_item("Next Level ("+keycode_get_string(KEY_MASK_CMD)+"Up Wheel)",MENU_OPTION_NEXT_LEVEL);
+	options->get_popup()->add_item("Prev Level (" + keycode_get_string(KEY_MASK_CMD) + "Down Wheel)", MENU_OPTION_PREV_LEVEL);
+	options->get_popup()->add_item("Next Level (" + keycode_get_string(KEY_MASK_CMD) + "Up Wheel)", MENU_OPTION_NEXT_LEVEL);
 	options->get_popup()->add_separator();
-	options->get_popup()->add_check_item("Clip Disabled",MENU_OPTION_CLIP_DISABLED);
-	options->get_popup()->set_item_checked( options->get_popup()->get_item_index(MENU_OPTION_CLIP_DISABLED), true );
-	options->get_popup()->add_check_item("Clip Above",MENU_OPTION_CLIP_ABOVE);
-	options->get_popup()->add_check_item("Clip Below",MENU_OPTION_CLIP_BELOW);
+	options->get_popup()->add_check_item("Clip Disabled", MENU_OPTION_CLIP_DISABLED);
+	options->get_popup()->set_item_checked(options->get_popup()->get_item_index(MENU_OPTION_CLIP_DISABLED), true);
+	options->get_popup()->add_check_item("Clip Above", MENU_OPTION_CLIP_ABOVE);
+	options->get_popup()->add_check_item("Clip Below", MENU_OPTION_CLIP_BELOW);
 	options->get_popup()->add_separator();
-	options->get_popup()->add_check_item("Edit X Axis",MENU_OPTION_X_AXIS,KEY_Z);
-	options->get_popup()->add_check_item("Edit Y Axis",MENU_OPTION_Y_AXIS,KEY_X);
-	options->get_popup()->add_check_item("Edit Z Axis",MENU_OPTION_Z_AXIS,KEY_C);
-	options->get_popup()->set_item_checked( options->get_popup()->get_item_index(MENU_OPTION_Y_AXIS), true );
+	options->get_popup()->add_check_item("Edit X Axis", MENU_OPTION_X_AXIS, KEY_Z);
+	options->get_popup()->add_check_item("Edit Y Axis", MENU_OPTION_Y_AXIS, KEY_X);
+	options->get_popup()->add_check_item("Edit Z Axis", MENU_OPTION_Z_AXIS, KEY_C);
+	options->get_popup()->set_item_checked(options->get_popup()->get_item_index(MENU_OPTION_Y_AXIS), true);
 	options->get_popup()->add_separator();
-	options->get_popup()->add_item("Cursor Rotate X",MENU_OPTION_CURSOR_ROTATE_X,KEY_A);
-	options->get_popup()->add_item("Cursor Rotate Y",MENU_OPTION_CURSOR_ROTATE_Y,KEY_S);
-	options->get_popup()->add_item("Cursor Rotate Z",MENU_OPTION_CURSOR_ROTATE_Z,KEY_D);
-	options->get_popup()->add_item("Cursor Back Rotate X",MENU_OPTION_CURSOR_BACK_ROTATE_X,KEY_MASK_SHIFT+KEY_A);
-	options->get_popup()->add_item("Cursor Back Rotate Y",MENU_OPTION_CURSOR_BACK_ROTATE_Y,KEY_MASK_SHIFT+KEY_S);
-	options->get_popup()->add_item("Cursor Back Rotate Z",MENU_OPTION_CURSOR_BACK_ROTATE_Z,KEY_MASK_SHIFT+KEY_D);
-	options->get_popup()->add_item("Cursor Clear Rotation",MENU_OPTION_CURSOR_CLEAR_ROTATION,KEY_W);
+	options->get_popup()->add_item("Cursor Rotate X", MENU_OPTION_CURSOR_ROTATE_X, KEY_A);
+	options->get_popup()->add_item("Cursor Rotate Y", MENU_OPTION_CURSOR_ROTATE_Y, KEY_S);
+	options->get_popup()->add_item("Cursor Rotate Z", MENU_OPTION_CURSOR_ROTATE_Z, KEY_D);
+	options->get_popup()->add_item("Cursor Back Rotate X", MENU_OPTION_CURSOR_BACK_ROTATE_X, KEY_MASK_SHIFT + KEY_A);
+	options->get_popup()->add_item("Cursor Back Rotate Y", MENU_OPTION_CURSOR_BACK_ROTATE_Y, KEY_MASK_SHIFT + KEY_S);
+	options->get_popup()->add_item("Cursor Back Rotate Z", MENU_OPTION_CURSOR_BACK_ROTATE_Z, KEY_MASK_SHIFT + KEY_D);
+	options->get_popup()->add_item("Cursor Clear Rotation", MENU_OPTION_CURSOR_CLEAR_ROTATION, KEY_W);
 	options->get_popup()->add_separator();
-	options->get_popup()->add_check_item("Duplicate Selects",MENU_OPTION_DUPLICATE_SELECTS);
+	options->get_popup()->add_check_item("Duplicate Selects", MENU_OPTION_DUPLICATE_SELECTS);
 	options->get_popup()->add_separator();
-	options->get_popup()->add_item("Create Area",MENU_OPTION_SELECTION_MAKE_AREA,KEY_CONTROL+KEY_C);
-	options->get_popup()->add_item("Create Exterior Connector",MENU_OPTION_SELECTION_MAKE_EXTERIOR_CONNECTOR);
-	options->get_popup()->add_item("Erase Area",MENU_OPTION_REMOVE_AREA);
+	options->get_popup()->add_item("Create Area", MENU_OPTION_SELECTION_MAKE_AREA, KEY_CONTROL + KEY_C);
+	options->get_popup()->add_item("Create Exterior Connector", MENU_OPTION_SELECTION_MAKE_EXTERIOR_CONNECTOR);
+	options->get_popup()->add_item("Erase Area", MENU_OPTION_REMOVE_AREA);
 	options->get_popup()->add_separator();
-	options->get_popup()->add_item("Selection -> Duplicate",MENU_OPTION_SELECTION_DUPLICATE,KEY_MASK_SHIFT+KEY_INSERT);
-	options->get_popup()->add_item("Selection -> Clear",MENU_OPTION_SELECTION_CLEAR,KEY_MASK_SHIFT+KEY_DELETE);
+	options->get_popup()->add_item("Selection -> Duplicate", MENU_OPTION_SELECTION_DUPLICATE, KEY_MASK_SHIFT + KEY_INSERT);
+	options->get_popup()->add_item("Selection -> Clear", MENU_OPTION_SELECTION_CLEAR, KEY_MASK_SHIFT + KEY_DELETE);
 	//options->get_popup()->add_separator();
 	//options->get_popup()->add_item("Configure",MENU_OPTION_CONFIGURE);
 
@@ -1265,46 +1188,46 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
 	settings_pick_distance->set_value(EDITOR_DEF("editors/grid_map/pick_distance", 5000.0));
 	settings_vbc->add_margin_child("Pick Distance:", settings_pick_distance);
 
-	clip_mode=CLIP_DISABLED;
-	options->get_popup()->connect("id_pressed", this,"_menu_option");
+	clip_mode = CLIP_DISABLED;
+	options->get_popup()->connect("id_pressed", this, "_menu_option");
 
-	HBoxContainer *hb = memnew( HBoxContainer );
+	HBoxContainer *hb = memnew(HBoxContainer);
 	add_child(hb);
 	hb->set_h_size_flags(SIZE_EXPAND_FILL);
 
 	edit_mode = memnew(OptionButton);
 	edit_mode->set_area_as_parent_rect();
-	edit_mode->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,24);
-	edit_mode->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,14);
+	edit_mode->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_BEGIN, 24);
+	edit_mode->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 14);
 	edit_mode->add_item("Tiles");
 	edit_mode->add_item("Areas");
 	hb->add_child(edit_mode);
 	edit_mode->set_h_size_flags(SIZE_EXPAND_FILL);
 
-	mode_thumbnail = memnew( ToolButton );
+	mode_thumbnail = memnew(ToolButton);
 	mode_thumbnail->set_toggle_mode(true);
 	mode_thumbnail->set_pressed(true);
-	mode_thumbnail->set_icon(p_editor->get_gui_base()->get_icon("FileThumbnail","EditorIcons"));
+	mode_thumbnail->set_icon(p_editor->get_gui_base()->get_icon("FileThumbnail", "EditorIcons"));
 	hb->add_child(mode_thumbnail);
 	mode_thumbnail->connect("pressed", this, "_set_display_mode", varray(DISPLAY_THUMBNAIL));
 
-	mode_list = memnew( ToolButton );
+	mode_list = memnew(ToolButton);
 	mode_list->set_toggle_mode(true);
 	mode_list->set_pressed(false);
 	mode_list->set_icon(p_editor->get_gui_base()->get_icon("FileList", "EditorIcons"));
 	hb->add_child(mode_list);
 	mode_list->connect("pressed", this, "_set_display_mode", varray(DISPLAY_LIST));
 
-	EDITOR_DEF("editors/grid_map/preview_size",64);
+	EDITOR_DEF("editors/grid_map/preview_size", 64);
 
 	display_mode = DISPLAY_THUMBNAIL;
-	selected_area=-1;
+	selected_area = -1;
 
-	theme_pallete = memnew( ItemList );
+	theme_pallete = memnew(ItemList);
 	add_child(theme_pallete);
 	theme_pallete->set_v_size_flags(SIZE_EXPAND_FILL);
 
-	area_list = memnew( Tree );
+	area_list = memnew(Tree);
 	add_child(area_list);
 	area_list->set_v_size_flags(SIZE_EXPAND_FILL);
 	area_list->hide();
@@ -1314,26 +1237,25 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
 	fl->set_text("   Floor: ");
 	spatial_editor_hb->add_child(fl);
 
-	floor = memnew( SpinBox );
+	floor = memnew(SpinBox);
 	floor->set_min(-32767);
 	floor->set_max(32767);
 	floor->set_step(1);
-	floor->get_line_edit()->add_constant_override("minimum_spaces",16);
+	floor->get_line_edit()->add_constant_override("minimum_spaces", 16);
 
 	spatial_editor_hb->add_child(floor);
-	floor->connect("value_changed",this,"_floor_changed");
-
+	floor->connect("value_changed", this, "_floor_changed");
 
-	edit_axis=Vector3::AXIS_Y;
-	edit_floor[0]=-1;
-	edit_floor[1]=-1;
-	edit_floor[2]=-1;
+	edit_axis = Vector3::AXIS_Y;
+	edit_floor[0] = -1;
+	edit_floor[1] = -1;
+	edit_floor[2] = -1;
 
-	cursor_visible=false;
-	selected_pallete=-1;
-	lock_view=false;
-	cursor_rot=0;
-	last_mouseover=Vector3(-1,-1,-1);
+	cursor_visible = false;
+	selected_pallete = -1;
+	lock_view = false;
+	cursor_rot = 0;
+	last_mouseover = Vector3(-1, -1, -1);
 
 	selection_mesh = VisualServer::get_singleton()->mesh_create();
 	duplicate_mesh = VisualServer::get_singleton()->mesh_create();
@@ -1341,45 +1263,43 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
 	{
 		//selection mesh create
 
-
 		PoolVector<Vector3> lines;
 		PoolVector<Vector3> triangles;
 
-		for (int i=0;i<6;i++) {
-
+		for (int i = 0; i < 6; i++) {
 
 			Vector3 face_points[4];
 
-			for (int j=0;j<4;j++) {
+			for (int j = 0; j < 4; j++) {
 
 				float v[3];
-				v[0]=1.0;
-				v[1]=1-2*((j>>1)&1);
-				v[2]=v[1]*(1-2*(j&1));
+				v[0] = 1.0;
+				v[1] = 1 - 2 * ((j >> 1) & 1);
+				v[2] = v[1] * (1 - 2 * (j & 1));
 
-				for (int k=0;k<3;k++) {
+				for (int k = 0; k < 3; k++) {
 
-					if (i<3)
-						face_points[j][(i+k)%3]=v[k]*(i>=3?-1:1);
+					if (i < 3)
+						face_points[j][(i + k) % 3] = v[k] * (i >= 3 ? -1 : 1);
 					else
-						face_points[3-j][(i+k)%3]=v[k]*(i>=3?-1:1);
+						face_points[3 - j][(i + k) % 3] = v[k] * (i >= 3 ? -1 : 1);
 				}
 			}
 
-			triangles.push_back(face_points[0]*0.5+Vector3(0.5,0.5,0.5));
-			triangles.push_back(face_points[1]*0.5+Vector3(0.5,0.5,0.5));
-			triangles.push_back(face_points[2]*0.5+Vector3(0.5,0.5,0.5));
+			triangles.push_back(face_points[0] * 0.5 + Vector3(0.5, 0.5, 0.5));
+			triangles.push_back(face_points[1] * 0.5 + Vector3(0.5, 0.5, 0.5));
+			triangles.push_back(face_points[2] * 0.5 + Vector3(0.5, 0.5, 0.5));
 
-			triangles.push_back(face_points[2]*0.5+Vector3(0.5,0.5,0.5));
-			triangles.push_back(face_points[3]*0.5+Vector3(0.5,0.5,0.5));
-			triangles.push_back(face_points[0]*0.5+Vector3(0.5,0.5,0.5));
+			triangles.push_back(face_points[2] * 0.5 + Vector3(0.5, 0.5, 0.5));
+			triangles.push_back(face_points[3] * 0.5 + Vector3(0.5, 0.5, 0.5));
+			triangles.push_back(face_points[0] * 0.5 + Vector3(0.5, 0.5, 0.5));
 		}
 
-		for(int i=0;i<12;i++) {
+		for (int i = 0; i < 12; i++) {
 
-			Rect3 base(Vector3(0,0,0),Vector3(1,1,1));
-			Vector3 a,b;
-			base.get_edge(i,a,b);
+			Rect3 base(Vector3(0, 0, 0), Vector3(1, 1, 1));
+			Vector3 a, b;
+			base.get_edge(i, a, b);
 			lines.push_back(a);
 			lines.push_back(b);
 		}
@@ -1388,49 +1308,42 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
 		d.resize(VS::ARRAY_MAX);
 
 		inner_mat.instance();
-		inner_mat->set_albedo(Color(0.7,0.7,1.0,0.3));
-		inner_mat->set_flag(FixedSpatialMaterial::FLAG_ONTOP,true);
-		inner_mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED,true);
-		inner_mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT,true);
+		inner_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.3));
+		inner_mat->set_flag(FixedSpatialMaterial::FLAG_ONTOP, true);
+		inner_mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true);
+		inner_mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true);
 
-
-		d[VS::ARRAY_VERTEX]=triangles;
-		VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_mesh,VS::PRIMITIVE_TRIANGLES,d);
-		VisualServer::get_singleton()->mesh_surface_set_material(selection_mesh,0,inner_mat->get_rid());
+		d[VS::ARRAY_VERTEX] = triangles;
+		VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_mesh, VS::PRIMITIVE_TRIANGLES, d);
+		VisualServer::get_singleton()->mesh_surface_set_material(selection_mesh, 0, inner_mat->get_rid());
 
 		outer_mat.instance();
-		outer_mat->set_albedo(Color(0.7,0.7,1.0,0.3));
-		outer_mat->set_flag(FixedSpatialMaterial::FLAG_ONTOP,true);
-		outer_mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED,true);
+		outer_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.3));
+		outer_mat->set_flag(FixedSpatialMaterial::FLAG_ONTOP, true);
+		outer_mat->set_flag(FixedSpatialMaterial::FLAG_UNSHADED, true);
 		outer_mat->set_line_width(3.0);
-		outer_mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT,true);
-
-
-		d[VS::ARRAY_VERTEX]=lines;
-		VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_mesh,VS::PRIMITIVE_LINES,d);
-		VisualServer::get_singleton()->mesh_surface_set_material(selection_mesh,1,outer_mat->get_rid());
+		outer_mat->set_feature(FixedSpatialMaterial::FEATURE_TRANSPARENT, true);
 
-		d[VS::ARRAY_VERTEX]=triangles;
-		VisualServer::get_singleton()->mesh_add_surface_from_arrays(duplicate_mesh,VS::PRIMITIVE_TRIANGLES,d);
-		VisualServer::get_singleton()->mesh_surface_set_material(duplicate_mesh,0,inner_mat->get_rid());
+		d[VS::ARRAY_VERTEX] = lines;
+		VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_mesh, VS::PRIMITIVE_LINES, d);
+		VisualServer::get_singleton()->mesh_surface_set_material(selection_mesh, 1, outer_mat->get_rid());
 
-		d[VS::ARRAY_VERTEX]=lines;
-		VisualServer::get_singleton()->mesh_add_surface_from_arrays(duplicate_mesh,VS::PRIMITIVE_LINES,d);
-		VisualServer::get_singleton()->mesh_surface_set_material(duplicate_mesh,1,outer_mat->get_rid());
+		d[VS::ARRAY_VERTEX] = triangles;
+		VisualServer::get_singleton()->mesh_add_surface_from_arrays(duplicate_mesh, VS::PRIMITIVE_TRIANGLES, d);
+		VisualServer::get_singleton()->mesh_surface_set_material(duplicate_mesh, 0, inner_mat->get_rid());
 
+		d[VS::ARRAY_VERTEX] = lines;
+		VisualServer::get_singleton()->mesh_add_surface_from_arrays(duplicate_mesh, VS::PRIMITIVE_LINES, d);
+		VisualServer::get_singleton()->mesh_surface_set_material(duplicate_mesh, 1, outer_mat->get_rid());
 	}
 
-	selection.active=false;
-	updating=false;
-
+	selection.active = false;
+	updating = false;
 }
 
-
-
-
 GridMapEditor::~GridMapEditor() {
 
-	for(int i=0;i<3;i++) {
+	for (int i = 0; i < 3; i++) {
 
 		if (grid[i].is_valid())
 			VisualServer::get_singleton()->free(grid[i]);
@@ -1440,12 +1353,10 @@ GridMapEditor::~GridMapEditor() {
 			VisualServer::get_singleton()->free(cursor_instance);
 	}
 
-
 	VisualServer::get_singleton()->free(selection_mesh);
 	if (selection_instance.is_valid())
 		VisualServer::get_singleton()->free(selection_instance);
 
-
 	VisualServer::get_singleton()->free(duplicate_mesh);
 	if (duplicate_instance.is_valid())
 		VisualServer::get_singleton()->free(duplicate_instance);
@@ -1455,8 +1366,7 @@ GridMapEditor::~GridMapEditor() {
 
 void GridMapEditorPlugin::edit(Object *p_object) {
 
-
-	gridmap_editor->edit(p_object?p_object->cast_to<GridMap>():NULL);
+	gridmap_editor->edit(p_object ? p_object->cast_to<GridMap>() : NULL);
 }
 
 bool GridMapEditorPlugin::handles(Object *p_object) const {
@@ -1477,26 +1387,18 @@ void GridMapEditorPlugin::make_visible(bool p_visible) {
 		gridmap_editor->edit(NULL);
 		gridmap_editor->set_process(false);
 	}
-
 }
 
-
 GridMapEditorPlugin::GridMapEditorPlugin(EditorNode *p_node) {
 
-	editor=p_node;
-	gridmap_editor = memnew( GridMapEditor(editor) );
+	editor = p_node;
+	gridmap_editor = memnew(GridMapEditor(editor));
 
 	SpatialEditor::get_singleton()->get_palette_split()->add_child(gridmap_editor);
-	SpatialEditor::get_singleton()->get_palette_split()->move_child(gridmap_editor,0);
+	SpatialEditor::get_singleton()->get_palette_split()->move_child(gridmap_editor, 0);
 
 	gridmap_editor->hide();
-
-
-
 }
 
-
-GridMapEditorPlugin::~GridMapEditorPlugin()
-{
+GridMapEditorPlugin::~GridMapEditorPlugin() {
 }
-
diff --git a/modules/gridmap/grid_map_editor_plugin.h b/modules/gridmap/grid_map_editor_plugin.h
index 07ac34cd4e..27a063ee41 100644
--- a/modules/gridmap/grid_map_editor_plugin.h
+++ b/modules/gridmap/grid_map_editor_plugin.h
@@ -29,10 +29,10 @@
 #ifndef GRID_MAP_EDITOR_PLUGIN_H
 #define GRID_MAP_EDITOR_PLUGIN_H
 
-#include "editor/editor_plugin.h"
 #include "editor/editor_node.h"
-#include "grid_map.h"
+#include "editor/editor_plugin.h"
 #include "editor/pane_drag.h"
+#include "grid_map.h"
 /**
 	@author Juan Linietsky <reduzio@gmail.com>
 */
@@ -40,11 +40,11 @@
 class SpatialEditorPlugin;
 
 class GridMapEditor : public VBoxContainer {
-	GDCLASS(GridMapEditor, VBoxContainer );
+	GDCLASS(GridMapEditor, VBoxContainer);
 
 	enum {
 
-		GRID_CURSOR_SIZE=50
+		GRID_CURSOR_SIZE = 50
 	};
 
 	enum InputAction {
@@ -65,14 +65,14 @@ class GridMapEditor : public VBoxContainer {
 	};
 
 	enum DisplayMode {
-	    DISPLAY_THUMBNAIL,
-	    DISPLAY_LIST
+		DISPLAY_THUMBNAIL,
+		DISPLAY_LIST
 	};
 
 	UndoRedo *undo_redo;
 	InputAction input_action;
 	Panel *panel;
-	MenuButton * options;
+	MenuButton *options;
 	SpinBox *floor;
 	OptionButton *edit_mode;
 	ToolButton *mode_thumbnail;
@@ -94,7 +94,7 @@ class GridMapEditor : public VBoxContainer {
 	List<SetItem> set_items;
 
 	GridMap *node;
-	MeshLibrary* last_theme;
+	MeshLibrary *last_theme;
 	ClipMode clip_mode;
 
 	bool lock_view;
@@ -118,10 +118,8 @@ class GridMapEditor : public VBoxContainer {
 
 	bool updating;
 
-
 	struct Selection {
 
-
 		Vector3 click;
 		Vector3 current;
 		Vector3 begin;
@@ -141,7 +139,6 @@ class GridMapEditor : public VBoxContainer {
 	int selected_area;
 	int cursor_rot;
 
-
 	enum Menu {
 
 		MENU_OPTION_CONFIGURE,
@@ -173,7 +170,6 @@ class GridMapEditor : public VBoxContainer {
 
 	SpatialEditorPlugin *spatial_editor;
 
-
 	struct AreaDisplay {
 
 		RID mesh;
@@ -212,20 +208,18 @@ class GridMapEditor : public VBoxContainer {
 	void update_areas();
 
 	EditorNode *editor;
-	bool do_input_action(Camera* p_camera,const Point2& p_point,bool p_click);
+	bool do_input_action(Camera *p_camera, const Point2 &p_point, bool p_click);
 
-friend class GridMapEditorPlugin;
+	friend class GridMapEditorPlugin;
 	Panel *theme_panel;
 
 protected:
 	void _notification(int p_what);
 	void _node_removed(Node *p_node);
 	static void _bind_methods();
-public:
-
-	bool forward_spatial_input_event(Camera* p_camera,const InputEvent& p_event);
-
 
+public:
+	bool forward_spatial_input_event(Camera *p_camera, const InputEvent &p_event);
 
 	void edit(GridMap *p_gridmap);
 	GridMapEditor() {}
@@ -235,14 +229,13 @@ public:
 
 class GridMapEditorPlugin : public EditorPlugin {
 
-	GDCLASS( GridMapEditorPlugin, EditorPlugin );
+	GDCLASS(GridMapEditorPlugin, EditorPlugin);
 
 	GridMapEditor *gridmap_editor;
 	EditorNode *editor;
 
 public:
-
-	virtual bool forward_spatial_input_event(Camera* p_camera,const InputEvent& p_event) { return gridmap_editor->forward_spatial_input_event(p_camera,p_event); }
+	virtual bool forward_spatial_input_event(Camera *p_camera, const InputEvent &p_event) { return gridmap_editor->forward_spatial_input_event(p_camera, p_event); }
 	virtual String get_name() const { return "GridMap"; }
 	bool has_main_screen() const { return false; }
 	virtual void edit(Object *p_node);
@@ -251,7 +244,6 @@ public:
 
 	GridMapEditorPlugin(EditorNode *p_node);
 	~GridMapEditorPlugin();
-
 };
 
 #endif // CUBE_GRID_MAP_EDITOR_PLUGIN_H
diff --git a/modules/gridmap/register_types.cpp b/modules/gridmap/register_types.cpp
index 9cd70a0f9b..4035caea78 100644
--- a/modules/gridmap/register_types.cpp
+++ b/modules/gridmap/register_types.cpp
@@ -43,9 +43,5 @@ void register_gridmap_types() {
 #endif
 }
 
-
-
 void unregister_gridmap_types() {
-
-
 }
diff --git a/modules/jpg/image_loader_jpegd.cpp b/modules/jpg/image_loader_jpegd.cpp
index 1152d42e1b..ca928c4fe6 100644
--- a/modules/jpg/image_loader_jpegd.cpp
+++ b/modules/jpg/image_loader_jpegd.cpp
@@ -28,16 +28,15 @@
 /*************************************************************************/
 #include "image_loader_jpegd.h"
 
-#include "print_string.h"
 #include "os/os.h"
+#include "print_string.h"
 
 #include <jpgd.h>
 #include <string.h>
 
+Error jpeg_load_image_from_buffer(Image *p_image, const uint8_t *p_buffer, int p_buffer_len) {
 
-Error jpeg_load_image_from_buffer(Image *p_image,const uint8_t* p_buffer, int p_buffer_len) {
-
-	jpgd::jpeg_decoder_mem_stream mem_stream(p_buffer,p_buffer_len);
+	jpgd::jpeg_decoder_mem_stream mem_stream(p_buffer, p_buffer_len);
 
 	jpgd::jpeg_decoder decoder(&mem_stream);
 
@@ -48,8 +47,8 @@ Error jpeg_load_image_from_buffer(Image *p_image,const uint8_t* p_buffer, int p_
 	const int image_width = decoder.get_width();
 	const int image_height = decoder.get_height();
 	int comps = decoder.get_num_components();
-	if (comps==3)
-		comps=4; //weird
+	if (comps == 3)
+		comps = 4; //weird
 
 	if (decoder.begin_decoding() != jpgd::JPGD_SUCCESS)
 		return ERR_FILE_CORRUPT;
@@ -62,42 +61,34 @@ Error jpeg_load_image_from_buffer(Image *p_image,const uint8_t* p_buffer, int p_
 
 	PoolVector<uint8_t>::Write dw = data.write();
 
-	jpgd::uint8 *pImage_data = (jpgd::uint8*)dw.ptr();
+	jpgd::uint8 *pImage_data = (jpgd::uint8 *)dw.ptr();
 
-	for (int y = 0; y < image_height; y++)
-	{
-		const jpgd::uint8* pScan_line;
+	for (int y = 0; y < image_height; y++) {
+		const jpgd::uint8 *pScan_line;
 		jpgd::uint scan_line_len;
-		if (decoder.decode((const void**)&pScan_line, &scan_line_len) != jpgd::JPGD_SUCCESS)
-		{
+		if (decoder.decode((const void **)&pScan_line, &scan_line_len) != jpgd::JPGD_SUCCESS) {
 			return ERR_FILE_CORRUPT;
 		}
 
 		jpgd::uint8 *pDst = pImage_data + y * dst_bpl;
 		memcpy(pDst, pScan_line, dst_bpl);
-
-
 	}
 
-
 	//all good
 
 	Image::Format fmt;
-	if (comps==1)
-		fmt=Image::FORMAT_L8;
+	if (comps == 1)
+		fmt = Image::FORMAT_L8;
 	else
-		fmt=Image::FORMAT_RGBA8;
+		fmt = Image::FORMAT_RGBA8;
 
 	dw = PoolVector<uint8_t>::Write();
-	p_image->create(image_width,image_height,0,fmt,data);
+	p_image->create(image_width, image_height, 0, fmt, data);
 
 	return OK;
-
 }
 
-
-Error ImageLoaderJPG::load_image(Image *p_image,FileAccess *f) {
-
+Error ImageLoaderJPG::load_image(Image *p_image, FileAccess *f) {
 
 	PoolVector<uint8_t> src_image;
 	int src_image_len = f->get_len();
@@ -106,30 +97,27 @@ Error ImageLoaderJPG::load_image(Image *p_image,FileAccess *f) {
 
 	PoolVector<uint8_t>::Write w = src_image.write();
 
-	f->get_buffer(&w[0],src_image_len);
+	f->get_buffer(&w[0], src_image_len);
 
 	f->close();
 
-
-	Error err = jpeg_load_image_from_buffer(p_image,w.ptr(),src_image_len);
+	Error err = jpeg_load_image_from_buffer(p_image, w.ptr(), src_image_len);
 
 	w = PoolVector<uint8_t>::Write();
 
 	return err;
-
 }
 
 void ImageLoaderJPG::get_recognized_extensions(List<String> *p_extensions) const {
-	
+
 	p_extensions->push_back("jpg");
 	p_extensions->push_back("jpeg");
 }
 
-
-static Image _jpegd_mem_loader_func(const uint8_t* p_png,int p_size) {
+static Image _jpegd_mem_loader_func(const uint8_t *p_png, int p_size) {
 
 	Image img;
-	Error err = jpeg_load_image_from_buffer(&img,p_png,p_size);
+	Error err = jpeg_load_image_from_buffer(&img, p_png, p_size);
 	if (err)
 		ERR_PRINT("Couldn't initialize ImageLoaderJPG with the given resource.");
 
@@ -138,7 +126,5 @@ static Image _jpegd_mem_loader_func(const uint8_t* p_png,int p_size) {
 
 ImageLoaderJPG::ImageLoaderJPG() {
 
-	Image::_jpg_mem_loader_func=_jpegd_mem_loader_func;
+	Image::_jpg_mem_loader_func = _jpegd_mem_loader_func;
 }
-
-
diff --git a/modules/jpg/image_loader_jpegd.h b/modules/jpg/image_loader_jpegd.h
index aeb219aa5d..0803cfba1e 100644
--- a/modules/jpg/image_loader_jpegd.h
+++ b/modules/jpg/image_loader_jpegd.h
@@ -36,14 +36,10 @@
 */
 class ImageLoaderJPG : public ImageFormatLoader {
 
-
 public:
-
-	virtual Error load_image(Image *p_image,FileAccess *f);
-	virtual void get_recognized_extensions(List<String> *p_extensions) const;	
+	virtual Error load_image(Image *p_image, FileAccess *f);
+	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	ImageLoaderJPG();
 };
 
-
-
 #endif
diff --git a/modules/jpg/register_types.cpp b/modules/jpg/register_types.cpp
index bcd467f5fc..ce0330643a 100644
--- a/modules/jpg/register_types.cpp
+++ b/modules/jpg/register_types.cpp
@@ -34,11 +34,11 @@ static ImageLoaderJPG *image_loader_jpg = NULL;
 
 void register_jpg_types() {
 
-	image_loader_jpg = memnew( ImageLoaderJPG );
+	image_loader_jpg = memnew(ImageLoaderJPG);
 	ImageLoader::add_image_format_loader(image_loader_jpg);
 }
 
 void unregister_jpg_types() {
 
-	memdelete( image_loader_jpg );
+	memdelete(image_loader_jpg);
 }
diff --git a/modules/openssl/stream_peer_openssl.cpp b/modules/openssl/stream_peer_openssl.cpp
index 43a1f610d8..3b25b8a50e 100644
--- a/modules/openssl/stream_peer_openssl.cpp
+++ b/modules/openssl/stream_peer_openssl.cpp
@@ -29,12 +29,11 @@
 #include "stream_peer_openssl.h"
 //hostname matching code from curl
 
-
 //#include <openssl/applink.c> // To prevent crashing (see the OpenSSL FAQ)
 
 bool StreamPeerOpenSSL::_match_host_name(const char *name, const char *hostname) {
 
-	return Tool_Curl_cert_hostcheck(name,hostname)==CURL_HOST_MATCH;
+	return Tool_Curl_cert_hostcheck(name, hostname) == CURL_HOST_MATCH;
 	//print_line("MATCH: "+String(name)+" vs "+String(hostname));
 	//return true;
 }
@@ -47,36 +46,32 @@ Error StreamPeerOpenSSL::_match_common_name(const char *hostname, const X509 *se
 	char *common_name_str = NULL;
 
 	// Find the position of the CN field in the Subject field of the certificate
-	common_name_loc = X509_NAME_get_index_by_NID(X509_get_subject_name((X509 *) server_cert), NID_commonName, -1);
+	common_name_loc = X509_NAME_get_index_by_NID(X509_get_subject_name((X509 *)server_cert), NID_commonName, -1);
 
-	ERR_FAIL_COND_V(common_name_loc < 0, ERR_INVALID_PARAMETER );
+	ERR_FAIL_COND_V(common_name_loc < 0, ERR_INVALID_PARAMETER);
 
 	// Extract the CN field
-	common_name_entry = X509_NAME_get_entry(X509_get_subject_name((X509 *) server_cert), common_name_loc);
+	common_name_entry = X509_NAME_get_entry(X509_get_subject_name((X509 *)server_cert), common_name_loc);
 
-	ERR_FAIL_COND_V(common_name_entry == NULL, ERR_INVALID_PARAMETER );
+	ERR_FAIL_COND_V(common_name_entry == NULL, ERR_INVALID_PARAMETER);
 
 	// Convert the CN field to a C string
 	common_name_asn1 = X509_NAME_ENTRY_get_data(common_name_entry);
 
-	ERR_FAIL_COND_V(common_name_asn1 == NULL, ERR_INVALID_PARAMETER );
+	ERR_FAIL_COND_V(common_name_asn1 == NULL, ERR_INVALID_PARAMETER);
 
-	common_name_str = (char *) ASN1_STRING_data(common_name_asn1);
+	common_name_str = (char *)ASN1_STRING_data(common_name_asn1);
 
 	// Make sure there isn't an embedded NUL character in the CN
 	bool malformed_certificate = (size_t)ASN1_STRING_length(common_name_asn1) != strlen(common_name_str);
 
-	ERR_FAIL_COND_V(malformed_certificate, ERR_INVALID_PARAMETER );
-
+	ERR_FAIL_COND_V(malformed_certificate, ERR_INVALID_PARAMETER);
 
 	// Compare expected hostname with the CN
 
-
-	return _match_host_name(common_name_str,hostname)?OK:FAILED;
-
+	return _match_host_name(common_name_str, hostname) ? OK : FAILED;
 }
 
-
 /**
 * Tries to find a match for hostname in the certificate's Subject Alternative Name extension.
 *
@@ -90,26 +85,25 @@ Error StreamPeerOpenSSL::_match_subject_alternative_name(const char *hostname, c
 	STACK_OF(GENERAL_NAME) *san_names = NULL;
 
 	// Try to extract the names within the SAN extension from the certificate
-	san_names = (STACK_OF(GENERAL_NAME) *)X509_get_ext_d2i((X509 *) server_cert, NID_subject_alt_name, NULL, NULL);
+	san_names = (STACK_OF(GENERAL_NAME) *)X509_get_ext_d2i((X509 *)server_cert, NID_subject_alt_name, NULL, NULL);
 	if (san_names == NULL) {
 		return ERR_FILE_NOT_FOUND;
 	}
 	san_names_nb = sk_GENERAL_NAME_num(san_names);
 
 	// Check each name within the extension
-	for (i=0; i<san_names_nb; i++) {
+	for (i = 0; i < san_names_nb; i++) {
 		const GENERAL_NAME *current_name = sk_GENERAL_NAME_value(san_names, i);
 
 		if (current_name->type == GEN_DNS) {
 			// Current name is a DNS name, let's check it
-			char *dns_name = (char *) ASN1_STRING_data(current_name->d.dNSName);
+			char *dns_name = (char *)ASN1_STRING_data(current_name->d.dNSName);
 
 			// Make sure there isn't an embedded NUL character in the DNS name
 			if ((size_t)ASN1_STRING_length(current_name->d.dNSName) != strlen(dns_name)) {
 				result = ERR_INVALID_PARAMETER;
 				break;
-			}
-			else { // Compare expected hostname with the DNS name
+			} else { // Compare expected hostname with the DNS name
 				if (_match_host_name(dns_name, hostname)) {
 					result = OK;
 					break;
@@ -131,19 +125,19 @@ int StreamPeerOpenSSL::_cert_verify_callback(X509_STORE_CTX *x509_ctx, void *arg
 
 	bool base_cert_valid = X509_verify_cert(x509_ctx);
 	if (!base_cert_valid) {
-		print_line("Cause: "+String(X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509_ctx))));
+		print_line("Cause: " + String(X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509_ctx))));
 		ERR_print_errors_fp(stdout);
 	}
 	X509 *server_cert = X509_STORE_CTX_get_current_cert(x509_ctx);
 
-	ERR_FAIL_COND_V(!server_cert,0);
+	ERR_FAIL_COND_V(!server_cert, 0);
 
 	char cert_str[256];
-	X509_NAME_oneline(X509_get_subject_name (server_cert),
-			  cert_str, sizeof (cert_str));
+	X509_NAME_oneline(X509_get_subject_name(server_cert),
+			cert_str, sizeof(cert_str));
 
-	print_line("CERT STR: "+String(cert_str));
-	print_line("VALID: "+itos(base_cert_valid));
+	print_line("CERT STR: " + String(cert_str));
+	print_line("VALID: " + itos(base_cert_valid));
 
 	if (!base_cert_valid)
 		return 0;
@@ -152,27 +146,24 @@ int StreamPeerOpenSSL::_cert_verify_callback(X509_STORE_CTX *x509_ctx, void *arg
 
 	if (ssl->validate_hostname) {
 
-		Error err = _match_subject_alternative_name(ssl->hostname.utf8().get_data(),server_cert);
+		Error err = _match_subject_alternative_name(ssl->hostname.utf8().get_data(), server_cert);
 
-		if (err==ERR_FILE_NOT_FOUND) {
+		if (err == ERR_FILE_NOT_FOUND) {
 
-			err = _match_common_name(ssl->hostname.utf8().get_data(),server_cert);
+			err = _match_common_name(ssl->hostname.utf8().get_data(), server_cert);
 		}
 
-		if (err!=OK) {
+		if (err != OK) {
 
-			ssl->status=STATUS_ERROR_HOSTNAME_MISMATCH;
+			ssl->status = STATUS_ERROR_HOSTNAME_MISMATCH;
 			return 0;
 		}
 	}
 
 	return 1;
-
 }
 
-
-
-int StreamPeerOpenSSL::_bio_create( BIO *b ) {
+int StreamPeerOpenSSL::_bio_create(BIO *b) {
 	b->init = 1;
 	b->num = 0;
 	b->ptr = NULL;
@@ -180,31 +171,29 @@ int StreamPeerOpenSSL::_bio_create( BIO *b ) {
 	return 1;
 }
 
-int StreamPeerOpenSSL::_bio_destroy( BIO *b )
-{
-	if ( b == NULL )
+int StreamPeerOpenSSL::_bio_destroy(BIO *b) {
+	if (b == NULL)
 		return 0;
 
-	b->ptr = NULL;		/* sb_tls_remove() will free it */
+	b->ptr = NULL; /* sb_tls_remove() will free it */
 	b->init = 0;
 	b->flags = 0;
 	return 1;
 }
 
-int StreamPeerOpenSSL::_bio_read( BIO *b, char *buf, int len ) {
+int StreamPeerOpenSSL::_bio_read(BIO *b, char *buf, int len) {
 
-
-	if ( buf == NULL || len <= 0 ) return 0;
+	if (buf == NULL || len <= 0) return 0;
 
 	StreamPeerOpenSSL *sp = (StreamPeerOpenSSL *)b->ptr;
 
-	ERR_FAIL_COND_V( sp == NULL, 0);
+	ERR_FAIL_COND_V(sp == NULL, 0);
 
-	BIO_clear_retry_flags( b );
+	BIO_clear_retry_flags(b);
 	if (sp->use_blocking) {
 
-		Error err = sp->base->get_data((uint8_t*)buf,len);
-		if (err!=OK) {
+		Error err = sp->base->get_data((uint8_t *)buf, len);
+		if (err != OK) {
 			return -1;
 		}
 
@@ -212,12 +201,12 @@ int StreamPeerOpenSSL::_bio_read( BIO *b, char *buf, int len ) {
 	} else {
 
 		int got;
-		Error err = sp->base->get_partial_data((uint8_t*)buf,len,got);
-		if (err!=OK) {
+		Error err = sp->base->get_partial_data((uint8_t *)buf, len, got);
+		if (err != OK) {
 			return -1;
 		}
-		if (got==0) {
-			BIO_set_retry_read( b );
+		if (got == 0) {
+			BIO_set_retry_read(b);
 		}
 		return got;
 	}
@@ -226,19 +215,19 @@ int StreamPeerOpenSSL::_bio_read( BIO *b, char *buf, int len ) {
 	return 0;
 }
 
-int StreamPeerOpenSSL::_bio_write( BIO *b, const char *buf, int len ) {
+int StreamPeerOpenSSL::_bio_write(BIO *b, const char *buf, int len) {
 
-	if ( buf == NULL || len <= 0 ) return 0;
+	if (buf == NULL || len <= 0) return 0;
 
 	StreamPeerOpenSSL *sp = (StreamPeerOpenSSL *)b->ptr;
 
-	ERR_FAIL_COND_V( sp == NULL, 0);
+	ERR_FAIL_COND_V(sp == NULL, 0);
 
-	BIO_clear_retry_flags( b );
+	BIO_clear_retry_flags(b);
 	if (sp->use_blocking) {
 
-		Error err = sp->base->put_data((const uint8_t*)buf,len);
-		if (err!=OK) {
+		Error err = sp->base->put_data((const uint8_t *)buf, len);
+		if (err != OK) {
 			return -1;
 		}
 
@@ -246,43 +235,39 @@ int StreamPeerOpenSSL::_bio_write( BIO *b, const char *buf, int len ) {
 	} else {
 
 		int sent;
-		Error err = sp->base->put_partial_data((const uint8_t*)buf,len,sent);
-		if (err!=OK) {
+		Error err = sp->base->put_partial_data((const uint8_t *)buf, len, sent);
+		if (err != OK) {
 			return -1;
 		}
-		if (sent==0) {
-			BIO_set_retry_write( b );
+		if (sent == 0) {
+			BIO_set_retry_write(b);
 		}
 		return sent;
-
 	}
 
 	//unreachable
 	return 0;
 }
 
-long StreamPeerOpenSSL::_bio_ctrl( BIO *b, int cmd, long num, void *ptr )
-{
-	if ( cmd == BIO_CTRL_FLUSH ) {
+long StreamPeerOpenSSL::_bio_ctrl(BIO *b, int cmd, long num, void *ptr) {
+	if (cmd == BIO_CTRL_FLUSH) {
 		/* The OpenSSL library needs this */
 		return 1;
 	}
 	return 0;
 }
 
-int StreamPeerOpenSSL::_bio_gets( BIO *b, char *buf, int len )
-{
+int StreamPeerOpenSSL::_bio_gets(BIO *b, char *buf, int len) {
 	return -1;
 }
 
-int StreamPeerOpenSSL::_bio_puts( BIO *b, const char *str )
-{
-	return _bio_write( b, str, strlen( str ) );
+int StreamPeerOpenSSL::_bio_puts(BIO *b, const char *str) {
+	return _bio_write(b, str, strlen(str));
 }
 
 BIO_METHOD StreamPeerOpenSSL::_bio_method = {
 	/* it's a source/sink BIO */
-	( 100 | 0x400 ),
+	(100 | 0x400),
 	"streampeer glue",
 	_bio_write,
 	_bio_read,
@@ -293,35 +278,29 @@ BIO_METHOD StreamPeerOpenSSL::_bio_method = {
 	_bio_destroy
 };
 
-Error StreamPeerOpenSSL::connect_to_stream(Ref<StreamPeer> p_base, bool p_validate_certs, const String& p_for_hostname) {
+Error StreamPeerOpenSSL::connect_to_stream(Ref<StreamPeer> p_base, bool p_validate_certs, const String &p_for_hostname) {
 
 	if (connected)
 		disconnect_from_stream();
 
-
-	hostname=p_for_hostname;
-	status=STATUS_DISCONNECTED;
+	hostname = p_for_hostname;
+	status = STATUS_DISCONNECTED;
 
 	// Set up a SSL_CTX object, which will tell our BIO object how to do its work
 	ctx = SSL_CTX_new(SSLv23_client_method());
-	base=p_base;
-	validate_certs=p_validate_certs;
-	validate_hostname=p_for_hostname!="";
-
-
-
+	base = p_base;
+	validate_certs = p_validate_certs;
+	validate_hostname = p_for_hostname != "";
 
 	if (p_validate_certs) {
 
-
 		if (certs.size()) {
 			//yay for undocumented OpenSSL functions
 
 			X509_STORE *store = SSL_CTX_get_cert_store(ctx);
-			for(int i=0;i<certs.size();i++) {
-
-				X509_STORE_add_cert(store,certs[i]);
+			for (int i = 0; i < certs.size(); i++) {
 
+				X509_STORE_add_cert(store, certs[i]);
 			}
 #if 0
 			const unsigned char *in=(const unsigned char *)certs.ptr();
@@ -343,7 +322,6 @@ Error StreamPeerOpenSSL::connect_to_stream(Ref<StreamPeer> p_base, bool p_valida
 		//int res = SSL_CTX_load_verify_locations(ctx,"/etc/ssl/certs/ca-certificates.crt",NULL);
 		//print_line("verify locations res: "+itos(res));
 
-
 		/* Ask OpenSSL to verify the server certificate.  Note that this
 		 * does NOT include verifying that the hostname is correct.
 		 * So, by itself, this means anyone with any legitimate
@@ -366,183 +344,176 @@ Error StreamPeerOpenSSL::connect_to_stream(Ref<StreamPeer> p_base, bool p_valida
 		 * OpenSSL's built-in routine which would have been called if
 		 * we hadn't set the callback.  Therefore, we're just
 		 * "wrapping" OpenSSL's routine, not replacing it. */
-		SSL_CTX_set_cert_verify_callback (ctx, _cert_verify_callback,this);
+		SSL_CTX_set_cert_verify_callback(ctx, _cert_verify_callback, this);
 
 		//Let the verify_callback catch the verify_depth error so that we get an appropriate error in the logfile. (??)
-		SSL_CTX_set_verify_depth(ctx,max_cert_chain_depth + 1);
-
+		SSL_CTX_set_verify_depth(ctx, max_cert_chain_depth + 1);
 	}
 
-
-
-
-
-	ssl = SSL_new( ctx );
-	bio = BIO_new( &_bio_method );
+	ssl = SSL_new(ctx);
+	bio = BIO_new(&_bio_method);
 	bio->ptr = this;
-	SSL_set_bio( ssl, bio, bio );
+	SSL_set_bio(ssl, bio, bio);
 
-	if (p_for_hostname!=String()) {
-		SSL_set_tlsext_host_name(ssl,p_for_hostname.utf8().get_data());
+	if (p_for_hostname != String()) {
+		SSL_set_tlsext_host_name(ssl, p_for_hostname.utf8().get_data());
 	}
 
-	use_blocking=true; // let handshake use blocking
+	use_blocking = true; // let handshake use blocking
 	// Set the SSL to automatically retry on failure.
 	SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
 
 	// Same as before, try to connect.
-	int result = SSL_connect( ssl );
+	int result = SSL_connect(ssl);
 
-	print_line("CONNECTION RESULT: "+itos(result));
-	if (result<1) {
+	print_line("CONNECTION RESULT: " + itos(result));
+	if (result < 1) {
 		ERR_print_errors_fp(stdout);
 		_print_error(result);
 	}
 
-	X509 * peer = SSL_get_peer_certificate(ssl);
+	X509 *peer = SSL_get_peer_certificate(ssl);
 
 	if (peer) {
 		bool cert_ok = SSL_get_verify_result(ssl) == X509_V_OK;
-		print_line("cert_ok: "+itos(cert_ok));
+		print_line("cert_ok: " + itos(cert_ok));
 
-	} else if (validate_certs){
-		status=STATUS_ERROR_NO_CERTIFICATE;
+	} else if (validate_certs) {
+		status = STATUS_ERROR_NO_CERTIFICATE;
 	}
 
-	connected=true;
-	status=STATUS_CONNECTED;
+	connected = true;
+	status = STATUS_CONNECTED;
 
 	return OK;
 }
 
 Error StreamPeerOpenSSL::accept_stream(Ref<StreamPeer> p_base) {
 
-
 	return ERR_UNAVAILABLE;
 }
 
 void StreamPeerOpenSSL::_print_error(int err) {
 
-	err = SSL_get_error(ssl,err);
-	switch(err) {
+	err = SSL_get_error(ssl, err);
+	switch (err) {
 		case SSL_ERROR_NONE: ERR_PRINT("NO ERROR: The TLS/SSL I/O operation completed"); break;
 		case SSL_ERROR_ZERO_RETURN: ERR_PRINT("The TLS/SSL connection has been closed.");
 		case SSL_ERROR_WANT_READ:
 		case SSL_ERROR_WANT_WRITE:
-			ERR_PRINT("The operation did not complete."); break;
+			ERR_PRINT("The operation did not complete.");
+			break;
 		case SSL_ERROR_WANT_CONNECT:
 		case SSL_ERROR_WANT_ACCEPT:
-			ERR_PRINT("The connect/accept operation did not complete"); break;
+			ERR_PRINT("The connect/accept operation did not complete");
+			break;
 		case SSL_ERROR_WANT_X509_LOOKUP:
-			ERR_PRINT("The operation did not complete because an application callback set by SSL_CTX_set_client_cert_cb() has asked to be called again."); break;
+			ERR_PRINT("The operation did not complete because an application callback set by SSL_CTX_set_client_cert_cb() has asked to be called again.");
+			break;
 		case SSL_ERROR_SYSCALL:
-			ERR_PRINT("Some I/O error occurred. The OpenSSL error queue may contain more information on the error."); break;
+			ERR_PRINT("Some I/O error occurred. The OpenSSL error queue may contain more information on the error.");
+			break;
 		case SSL_ERROR_SSL:
-			ERR_PRINT("A failure in the SSL library occurred, usually a protocol error."); break;
-
+			ERR_PRINT("A failure in the SSL library occurred, usually a protocol error.");
+			break;
 	}
 }
 
-Error StreamPeerOpenSSL::put_data(const uint8_t* p_data,int p_bytes) {
+Error StreamPeerOpenSSL::put_data(const uint8_t *p_data, int p_bytes) {
 
-	ERR_FAIL_COND_V(!connected,ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(!connected, ERR_UNCONFIGURED);
 
-	while(p_bytes>0) {
-		int ret = SSL_write(ssl,p_data,p_bytes);
-		if (ret<=0) {
+	while (p_bytes > 0) {
+		int ret = SSL_write(ssl, p_data, p_bytes);
+		if (ret <= 0) {
 			_print_error(ret);
 			disconnect_from_stream();
 			return ERR_CONNECTION_ERROR;
 		}
-		p_data+=ret;
-		p_bytes-=ret;
+		p_data += ret;
+		p_bytes -= ret;
 	}
 
 	return OK;
-
 }
 
-Error StreamPeerOpenSSL::put_partial_data(const uint8_t* p_data,int p_bytes, int &r_sent){
+Error StreamPeerOpenSSL::put_partial_data(const uint8_t *p_data, int p_bytes, int &r_sent) {
 
-	ERR_FAIL_COND_V(!connected,ERR_UNCONFIGURED);
-	if (p_bytes==0)
+	ERR_FAIL_COND_V(!connected, ERR_UNCONFIGURED);
+	if (p_bytes == 0)
 		return OK;
 
-	Error err = put_data(p_data,p_bytes);
-	if (err!=OK)
+	Error err = put_data(p_data, p_bytes);
+	if (err != OK)
 		return err;
 
-	r_sent=p_bytes;
+	r_sent = p_bytes;
 	return OK;
-
 }
 
-Error StreamPeerOpenSSL::get_data(uint8_t* p_buffer, int p_bytes){
+Error StreamPeerOpenSSL::get_data(uint8_t *p_buffer, int p_bytes) {
 
-	ERR_FAIL_COND_V(!connected,ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(!connected, ERR_UNCONFIGURED);
 
-	while(p_bytes>0) {
+	while (p_bytes > 0) {
 
-		int ret = SSL_read(ssl,p_buffer,p_bytes);
-		if (ret<=0) {
+		int ret = SSL_read(ssl, p_buffer, p_bytes);
+		if (ret <= 0) {
 			_print_error(ret);
 			disconnect_from_stream();
 			return ERR_CONNECTION_ERROR;
 		}
-		p_buffer+=ret;
-		p_bytes-=ret;
+		p_buffer += ret;
+		p_bytes -= ret;
 	}
 
 	return OK;
 }
 
-Error StreamPeerOpenSSL::get_partial_data(uint8_t* p_buffer, int p_bytes,int &r_received){
+Error StreamPeerOpenSSL::get_partial_data(uint8_t *p_buffer, int p_bytes, int &r_received) {
 
-	ERR_FAIL_COND_V(!connected,ERR_UNCONFIGURED);
-	if (p_bytes==0) {
-		r_received=0;
+	ERR_FAIL_COND_V(!connected, ERR_UNCONFIGURED);
+	if (p_bytes == 0) {
+		r_received = 0;
 		return OK;
 	}
 
-	Error err = get_data(p_buffer,p_bytes);
-	if (err!=OK)
+	Error err = get_data(p_buffer, p_bytes);
+	if (err != OK)
 		return err;
-	r_received=p_bytes;
+	r_received = p_bytes;
 	return OK;
 }
 
 int StreamPeerOpenSSL::get_available_bytes() const {
 
-	ERR_FAIL_COND_V(!connected,0);
+	ERR_FAIL_COND_V(!connected, 0);
 
 	return SSL_pending(ssl);
-
 }
 StreamPeerOpenSSL::StreamPeerOpenSSL() {
 
-	ctx=NULL;
-	ssl=NULL;
-	bio=NULL;
-	connected=false;
-	use_blocking=true; //might be improved int the future, but for now it always blocks
-	max_cert_chain_depth=9;
-	flags=0;
+	ctx = NULL;
+	ssl = NULL;
+	bio = NULL;
+	connected = false;
+	use_blocking = true; //might be improved int the future, but for now it always blocks
+	max_cert_chain_depth = 9;
+	flags = 0;
 }
 
 void StreamPeerOpenSSL::disconnect_from_stream() {
 
 	if (!connected)
 		return;
-	SSL_shutdown( ssl );
-	SSL_free( ssl );
+	SSL_shutdown(ssl);
+	SSL_free(ssl);
 	SSL_CTX_free(ctx);
-	base=Ref<StreamPeer>();
-	connected=false;
-	validate_certs=false;
-	validate_hostname=false;
-	status=STATUS_DISCONNECTED;
-
-
+	base = Ref<StreamPeer>();
+	connected = false;
+	validate_certs = false;
+	validate_hostname = false;
+	status = STATUS_DISCONNECTED;
 }
 
 StreamPeerOpenSSL::Status StreamPeerOpenSSL::get_status() const {
@@ -550,27 +521,24 @@ StreamPeerOpenSSL::Status StreamPeerOpenSSL::get_status() const {
 	return status;
 }
 
-
 StreamPeerOpenSSL::~StreamPeerOpenSSL() {
 	disconnect_from_stream();
 }
 
-StreamPeerSSL* StreamPeerOpenSSL::_create_func() {
+StreamPeerSSL *StreamPeerOpenSSL::_create_func() {
 
-	return memnew( StreamPeerOpenSSL );
+	return memnew(StreamPeerOpenSSL);
 }
 
+Vector<X509 *> StreamPeerOpenSSL::certs;
 
-Vector<X509*> StreamPeerOpenSSL::certs;
-
-
-void StreamPeerOpenSSL::_load_certs(const PoolByteArray& p_array) {
+void StreamPeerOpenSSL::_load_certs(const PoolByteArray &p_array) {
 
 	PoolByteArray::Read r = p_array.read();
-	BIO* mem = BIO_new(BIO_s_mem());
-	BIO_puts(mem,(const char*)r.ptr());
-	while(true) {
-		X509*cert = PEM_read_bio_X509(mem, NULL, 0, NULL);
+	BIO *mem = BIO_new(BIO_s_mem());
+	BIO_puts(mem, (const char *)r.ptr());
+	while (true) {
+		X509 *cert = PEM_read_bio_X509(mem, NULL, 0, NULL);
 		if (!cert)
 			break;
 		certs.push_back(cert);
@@ -580,66 +548,62 @@ void StreamPeerOpenSSL::_load_certs(const PoolByteArray& p_array) {
 
 void StreamPeerOpenSSL::initialize_ssl() {
 
-	available=true;
+	available = true;
 
-	load_certs_func=_load_certs;
+	load_certs_func = _load_certs;
 
-	_create=_create_func;
+	_create = _create_func;
 	CRYPTO_malloc_init(); // Initialize malloc, free, etc for OpenSSL's use
 	SSL_library_init(); // Initialize OpenSSL's SSL libraries
 	SSL_load_error_strings(); // Load SSL error strings
 	ERR_load_BIO_strings(); // Load BIO error strings
 	OpenSSL_add_all_algorithms(); // Load all available encryption algorithms
-	String certs_path =GLOBAL_DEF("network/ssl/certificates","");
-	GlobalConfig::get_singleton()->set_custom_property_info("network/ssl/certificates",PropertyInfo(Variant::STRING,"network/ssl/certificates",PROPERTY_HINT_FILE,"*.crt"));
-	if (certs_path!="") {
-
-
+	String certs_path = GLOBAL_DEF("network/ssl/certificates", "");
+	GlobalConfig::get_singleton()->set_custom_property_info("network/ssl/certificates", PropertyInfo(Variant::STRING, "network/ssl/certificates", PROPERTY_HINT_FILE, "*.crt"));
+	if (certs_path != "") {
 
-		FileAccess *f=FileAccess::open(certs_path,FileAccess::READ);
+		FileAccess *f = FileAccess::open(certs_path, FileAccess::READ);
 		if (f) {
 			PoolByteArray arr;
 			int flen = f->get_len();
-			arr.resize(flen+1);
+			arr.resize(flen + 1);
 			{
 				PoolByteArray::Write w = arr.write();
-				f->get_buffer(w.ptr(),flen);
-				w[flen]=0; //end f string
+				f->get_buffer(w.ptr(), flen);
+				w[flen] = 0; //end f string
 			}
 
 			memdelete(f);
 
 			_load_certs(arr);
-			print_line("Loaded certs from '"+certs_path+"':  "+itos(certs.size()));
+			print_line("Loaded certs from '" + certs_path + "':  " + itos(certs.size()));
 		}
 	}
-	String config_path =GLOBAL_DEF("network/ssl/config","");
-	GlobalConfig::get_singleton()->set_custom_property_info("network/ssl/config",PropertyInfo(Variant::STRING,"network/ssl/config",PROPERTY_HINT_FILE,"*.cnf"));
-	if (config_path!="") {
+	String config_path = GLOBAL_DEF("network/ssl/config", "");
+	GlobalConfig::get_singleton()->set_custom_property_info("network/ssl/config", PropertyInfo(Variant::STRING, "network/ssl/config", PROPERTY_HINT_FILE, "*.cnf"));
+	if (config_path != "") {
 
 		Vector<uint8_t> data = FileAccess::get_file_as_array(config_path);
 		if (data.size()) {
 			data.push_back(0);
-			BIO* mem = BIO_new(BIO_s_mem());
-			BIO_puts(mem,(const char*) data.ptr());
+			BIO *mem = BIO_new(BIO_s_mem());
+			BIO_puts(mem, (const char *)data.ptr());
 
-			while(true) {
-				X509*cert = PEM_read_bio_X509(mem, NULL, 0, NULL);
+			while (true) {
+				X509 *cert = PEM_read_bio_X509(mem, NULL, 0, NULL);
 				if (!cert)
 					break;
 				certs.push_back(cert);
 			}
 			BIO_free(mem);
 		}
-		print_line("Loaded certs from '"+certs_path+"':  "+itos(certs.size()));
-
+		print_line("Loaded certs from '" + certs_path + "':  " + itos(certs.size()));
 	}
-
 }
 
-void StreamPeerOpenSSL::finalize_ssl(){
+void StreamPeerOpenSSL::finalize_ssl() {
 
-	for(int i=0;i<certs.size();i++) {
+	for (int i = 0; i < certs.size(); i++) {
 		X509_free(certs[i]);
 	}
 	certs.clear();
diff --git a/modules/openssl/stream_peer_openssl.h b/modules/openssl/stream_peer_openssl.h
index 84ae03fe07..56b45802df 100644
--- a/modules/openssl/stream_peer_openssl.h
+++ b/modules/openssl/stream_peer_openssl.h
@@ -29,26 +29,26 @@
 #ifndef STREAM_PEER_OPEN_SSL_H
 #define STREAM_PEER_OPEN_SSL_H
 
-#include <stdio.h> // If you don't know what this is for stop reading now.
-#include "io/stream_peer_ssl.h"
+#include "curl_hostcheck.h"
 #include "global_config.h"
+#include "io/stream_peer_ssl.h"
 #include "os/file_access.h"
-#include "curl_hostcheck.h"
+#include <stdio.h> // If you don't know what this is for stop reading now.
 
 #include <openssl/bio.h> // BIO objects for I/O
-#include <openssl/ssl.h> // SSL and SSL_CTX for SSL connections
 #include <openssl/err.h> // Error reporting
+#include <openssl/ssl.h> // SSL and SSL_CTX for SSL connections
 #include <openssl/x509v3.h>
 
 class StreamPeerOpenSSL : public StreamPeerSSL {
 private:
-	static int _bio_create( BIO *b );
-	static int _bio_destroy( BIO *b );
-	static int _bio_read( BIO *b, char *buf, int len );
-	static int _bio_write( BIO *b, const char *buf, int len );
-	static long _bio_ctrl( BIO *b, int cmd, long num, void *ptr );
-	static int _bio_gets( BIO *b, char *buf, int len );
-	static int _bio_puts( BIO *b, const char *str );
+	static int _bio_create(BIO *b);
+	static int _bio_destroy(BIO *b);
+	static int _bio_read(BIO *b, char *buf, int len);
+	static int _bio_write(BIO *b, const char *buf, int len);
+	static long _bio_ctrl(BIO *b, int cmd, long num, void *ptr);
+	static int _bio_gets(BIO *b, char *buf, int len);
+	static int _bio_puts(BIO *b, const char *str);
 
 	static BIO_METHOD _bio_method;
 
@@ -56,16 +56,14 @@ private:
 	static Error _match_common_name(const char *hostname, const X509 *server_cert);
 	static Error _match_subject_alternative_name(const char *hostname, const X509 *server_cert);
 
-
 	static int _cert_verify_callback(X509_STORE_CTX *x509_ctx, void *arg);
 
-
 	Status status;
 	String hostname;
 	int max_cert_chain_depth;
-	SSL_CTX* ctx;
-	SSL* ssl;
-	BIO* bio;
+	SSL_CTX *ctx;
+	SSL *ssl;
+	BIO *bio;
 	bool connected;
 	int flags;
 	bool use_blocking;
@@ -74,28 +72,28 @@ private:
 
 	Ref<StreamPeer> base;
 
-	static StreamPeerSSL* _create_func();
+	static StreamPeerSSL *_create_func();
 	void _print_error(int err);
 
-	static Vector<X509*> certs;
+	static Vector<X509 *> certs;
+
+	static void _load_certs(const PoolByteArray &p_array);
 
-	static void _load_certs(const PoolByteArray& p_array);
 protected:
 	static void _bind_methods();
-public:
-
 
+public:
 	virtual Error accept_stream(Ref<StreamPeer> p_base);
-	virtual Error connect_to_stream(Ref<StreamPeer> p_base,bool p_validate_certs=false,const String& p_for_hostname=String());
+	virtual Error connect_to_stream(Ref<StreamPeer> p_base, bool p_validate_certs = false, const String &p_for_hostname = String());
 	virtual Status get_status() const;
 
 	virtual void disconnect_from_stream();
 
-	virtual Error put_data(const uint8_t* p_data,int p_bytes);
-	virtual Error put_partial_data(const uint8_t* p_data,int p_bytes, int &r_sent);
+	virtual Error put_data(const uint8_t *p_data, int p_bytes);
+	virtual Error put_partial_data(const uint8_t *p_data, int p_bytes, int &r_sent);
 
-	virtual Error get_data(uint8_t* p_buffer, int p_bytes);
-	virtual Error get_partial_data(uint8_t* p_buffer, int p_bytes,int &r_received);
+	virtual Error get_data(uint8_t *p_buffer, int p_bytes);
+	virtual Error get_partial_data(uint8_t *p_buffer, int p_bytes, int &r_received);
 
 	virtual int get_available_bytes() const;
 
diff --git a/modules/opus/audio_stream_opus.cpp b/modules/opus/audio_stream_opus.cpp
index 4a6b2e224c..52b055ca82 100644
--- a/modules/opus/audio_stream_opus.cpp
+++ b/modules/opus/audio_stream_opus.cpp
@@ -30,32 +30,32 @@
 /*************************************************************************/
 #include "audio_stream_opus.h"
 
-const float AudioStreamPlaybackOpus::osrate=48000.0f;
+const float AudioStreamPlaybackOpus::osrate = 48000.0f;
 
 int AudioStreamPlaybackOpus::_op_read_func(void *_stream, unsigned char *_ptr, int _nbytes) {
-	FileAccess *fa=(FileAccess*)_stream;
+	FileAccess *fa = (FileAccess *)_stream;
 
-	if(fa->eof_reached())
+	if (fa->eof_reached())
 		return 0;
 
-	uint8_t *dst = (uint8_t*)_ptr;
+	uint8_t *dst = (uint8_t *)_ptr;
 
 	int read = fa->get_buffer(dst, _nbytes);
 
 	return read;
 }
 
-int AudioStreamPlaybackOpus::_op_seek_func(void *_stream, opus_int64 _offset, int _whence){
+int AudioStreamPlaybackOpus::_op_seek_func(void *_stream, opus_int64 _offset, int _whence) {
 
 #ifdef SEEK_SET
-	FileAccess *fa=(FileAccess*)_stream;
+	FileAccess *fa = (FileAccess *)_stream;
 
 	switch (_whence) {
 		case SEEK_SET: {
 			fa->seek(_offset);
 		} break;
 		case SEEK_CUR: {
-			fa->seek(fa->get_pos()+_offset);
+			fa->seek(fa->get_pos() + _offset);
 		} break;
 		case SEEK_END: {
 			fa->seek_end(_offset);
@@ -64,7 +64,7 @@ int AudioStreamPlaybackOpus::_op_seek_func(void *_stream, opus_int64 _offset, in
 			ERR_PRINT("BUG, wtf was whence set to?\n");
 		}
 	}
-	int ret=fa->eof_reached()?-1:0;
+	int ret = fa->eof_reached() ? -1 : 0;
 	return ret;
 #else
 	return -1; // no seeking
@@ -74,97 +74,100 @@ int AudioStreamPlaybackOpus::_op_seek_func(void *_stream, opus_int64 _offset, in
 int AudioStreamPlaybackOpus::_op_close_func(void *_stream) {
 	if (!_stream)
 		return 0;
-	FileAccess *fa=(FileAccess*)_stream;
+	FileAccess *fa = (FileAccess *)_stream;
 	if (fa->is_open())
 		fa->close();
 	return 0;
 }
 
 opus_int64 AudioStreamPlaybackOpus::_op_tell_func(void *_stream) {
-	FileAccess *_fa = (FileAccess*)_stream;
+	FileAccess *_fa = (FileAccess *)_stream;
 	return (opus_int64)_fa->get_pos();
 }
 
 void AudioStreamPlaybackOpus::_clear_stream() {
-	if(!stream_loaded)
+	if (!stream_loaded)
 		return;
 
 	op_free(opus_file);
 	_close_file();
 
-	stream_loaded=false;
-	stream_channels=1;
-	playing=false;
+	stream_loaded = false;
+	stream_channels = 1;
+	playing = false;
 }
 
 void AudioStreamPlaybackOpus::_close_file() {
 	if (f) {
 		memdelete(f);
-		f=NULL;
+		f = NULL;
 	}
 }
 
 Error AudioStreamPlaybackOpus::_load_stream() {
 
-	ERR_FAIL_COND_V(!stream_valid,ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(!stream_valid, ERR_UNCONFIGURED);
 
 	_clear_stream();
-	if (file=="")
+	if (file == "")
 		return ERR_INVALID_DATA;
 
 	Error err;
-	f=FileAccess::open(file,FileAccess::READ,&err);
+	f = FileAccess::open(file, FileAccess::READ, &err);
 
 	if (err) {
-		ERR_FAIL_COND_V( err, err );
+		ERR_FAIL_COND_V(err, err);
 	}
 
 	int _err = 0;
 
-	opus_file = op_open_callbacks(f,&_op_callbacks,NULL,0,&_err);
+	opus_file = op_open_callbacks(f, &_op_callbacks, NULL, 0, &_err);
 
 	switch (_err) {
 		case OP_EREAD: { // - Can't read the file.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_CANT_READ );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_CANT_READ);
 		} break;
 		case OP_EVERSION: // - Unrecognized version number.
 		case OP_ENOTFORMAT: // - Stream is not Opus data.
-		case OP_EIMPL : { // - Stream used non-implemented feature.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_UNRECOGNIZED );
+		case OP_EIMPL: { // - Stream used non-implemented feature.
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_UNRECOGNIZED);
 		} break;
 		case OP_EBADLINK: // - Failed to find old data after seeking.
 		case OP_EBADTIMESTAMP: // - Timestamp failed the validity checks.
 		case OP_EBADHEADER: { // - Invalid or mising Opus bitstream header.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_CORRUPT );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_CORRUPT);
 		} break;
 		case OP_EFAULT: { // - Internal logic fault; indicates a bug or heap/stack corruption.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_BUG );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_BUG);
 		} break;
 	}
-	repeats=0;
-	stream_loaded=true;
-
+	repeats = 0;
+	stream_loaded = true;
 
 	return OK;
 }
 
 AudioStreamPlaybackOpus::AudioStreamPlaybackOpus() {
-	loops=false;
-	playing=false;
+	loops = false;
+	playing = false;
 	f = NULL;
-	stream_loaded=false;
-	stream_valid=false;
-	repeats=0;
-	paused=true;
-	stream_channels=0;
-	current_section=0;
-	length=0;
-	loop_restart_time=0;
-	pre_skip=0;
+	stream_loaded = false;
+	stream_valid = false;
+	repeats = 0;
+	paused = true;
+	stream_channels = 0;
+	current_section = 0;
+	length = 0;
+	loop_restart_time = 0;
+	pre_skip = 0;
 
 	_op_callbacks.read = _op_read_func;
 	_op_callbacks.seek = _op_seek_func;
@@ -173,59 +176,62 @@ AudioStreamPlaybackOpus::AudioStreamPlaybackOpus() {
 }
 
 Error AudioStreamPlaybackOpus::set_file(const String &p_file) {
-	file=p_file;
-	stream_valid=false;
+	file = p_file;
+	stream_valid = false;
 	Error err;
-	f=FileAccess::open(file,FileAccess::READ,&err);
+	f = FileAccess::open(file, FileAccess::READ, &err);
 
 	if (err) {
-		ERR_FAIL_COND_V( err, err );
+		ERR_FAIL_COND_V(err, err);
 	}
 
 	int _err;
 
-	opus_file = op_open_callbacks(f,&_op_callbacks,NULL,0,&_err);
+	opus_file = op_open_callbacks(f, &_op_callbacks, NULL, 0, &_err);
 
 	switch (_err) {
 		case OP_EREAD: { // - Can't read the file.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_CANT_READ );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_CANT_READ);
 		} break;
 		case OP_EVERSION: // - Unrecognized version number.
 		case OP_ENOTFORMAT: // - Stream is not Opus data.
-		case OP_EIMPL : { // - Stream used non-implemented feature.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_UNRECOGNIZED );
+		case OP_EIMPL: { // - Stream used non-implemented feature.
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_UNRECOGNIZED);
 		} break;
 		case OP_EBADLINK: // - Failed to find old data after seeking.
 		case OP_EBADTIMESTAMP: // - Timestamp failed the validity checks.
 		case OP_EBADHEADER: { // - Invalid or mising Opus bitstream header.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_CORRUPT );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_CORRUPT);
 		} break;
 		case OP_EFAULT: { // - Internal logic fault; indicates a bug or heap/stack corruption.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_BUG );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_BUG);
 		} break;
 	}
 
-	const OpusHead *oinfo = op_head(opus_file,-1);
+	const OpusHead *oinfo = op_head(opus_file, -1);
 
-	stream_channels=oinfo->channel_count;
-	pre_skip=oinfo->pre_skip;
-	frames_mixed=pre_skip;
-	ogg_int64_t len = op_pcm_total(opus_file,-1);
-	if(len < 0) {
+	stream_channels = oinfo->channel_count;
+	pre_skip = oinfo->pre_skip;
+	frames_mixed = pre_skip;
+	ogg_int64_t len = op_pcm_total(opus_file, -1);
+	if (len < 0) {
 		length = 0;
 	} else {
-		length=(len/osrate);
+		length = (len / osrate);
 	}
 
 	op_free(opus_file);
 	memdelete(f);
-	f=NULL;
-	stream_valid=true;
-
+	f = NULL;
+	stream_valid = true;
 
 	return OK;
 }
@@ -234,102 +240,100 @@ void AudioStreamPlaybackOpus::play(float p_from) {
 	if (playing)
 		stop();
 
-	if (_load_stream()!=OK)
+	if (_load_stream() != OK)
 		return;
 
-	frames_mixed=pre_skip;
-	playing=true;
-	if (p_from>0) {
+	frames_mixed = pre_skip;
+	playing = true;
+	if (p_from > 0) {
 		seek_pos(p_from);
 	}
 }
 
 void AudioStreamPlaybackOpus::stop() {
 	_clear_stream();
-	playing=false;
+	playing = false;
 }
 
 void AudioStreamPlaybackOpus::seek_pos(float p_time) {
-	if(!playing) return;
+	if (!playing) return;
 	ogg_int64_t pcm_offset = (ogg_int64_t)(p_time * osrate);
-	bool ok = op_pcm_seek(opus_file,pcm_offset)==0;
-	if(!ok) {
+	bool ok = op_pcm_seek(opus_file, pcm_offset) == 0;
+	if (!ok) {
 		ERR_PRINT("Seek time over stream size.");
 		return;
 	}
-	frames_mixed=osrate*p_time;
+	frames_mixed = osrate * p_time;
 }
 
-int AudioStreamPlaybackOpus::mix(int16_t* p_bufer,int p_frames) {
+int AudioStreamPlaybackOpus::mix(int16_t *p_bufer, int p_frames) {
 	if (!playing)
 		return 0;
 
-	int total=p_frames;
+	int total = p_frames;
 
 	while (true) {
 
 		int todo = p_frames;
 
-		if (todo==0 || todo<MIN_MIX) {
+		if (todo == 0 || todo < MIN_MIX) {
 			break;
 		}
 
-		int ret=op_read(opus_file,(opus_int16*)p_bufer,todo*stream_channels,&current_section);
-		if (ret<0) {
+		int ret = op_read(opus_file, (opus_int16 *)p_bufer, todo * stream_channels, &current_section);
+		if (ret < 0) {
 			playing = false;
-			ERR_EXPLAIN("Error reading Opus File: "+file);
-			ERR_BREAK(ret<0);
-		} else if (ret==0) { // end of song, reload?
+			ERR_EXPLAIN("Error reading Opus File: " + file);
+			ERR_BREAK(ret < 0);
+		} else if (ret == 0) { // end of song, reload?
 			op_free(opus_file);
 
 			_close_file();
 
-			f=FileAccess::open(file,FileAccess::READ);
+			f = FileAccess::open(file, FileAccess::READ);
 
 			int errv = 0;
-			opus_file = op_open_callbacks(f,&_op_callbacks,NULL,0,&errv);
-			if (errv!=0) {
-				playing=false;
+			opus_file = op_open_callbacks(f, &_op_callbacks, NULL, 0, &errv);
+			if (errv != 0) {
+				playing = false;
 				break; // :(
 			}
 
 			if (!has_loop()) {
-				playing=false;
-				repeats=1;
+				playing = false;
+				repeats = 1;
 				break;
 			}
 
 			if (loop_restart_time) {
-				bool ok = op_pcm_seek(opus_file, (loop_restart_time*osrate)+pre_skip)==0;
+				bool ok = op_pcm_seek(opus_file, (loop_restart_time * osrate) + pre_skip) == 0;
 				if (!ok) {
-					playing=false;
+					playing = false;
 					ERR_PRINT("loop restart time rejected")
 				}
 
-				frames_mixed=(loop_restart_time*osrate)+pre_skip;
+				frames_mixed = (loop_restart_time * osrate) + pre_skip;
 			} else {
-				frames_mixed=pre_skip;
+				frames_mixed = pre_skip;
 			}
 			repeats++;
 			continue;
-
 		}
 
-		stream_channels=op_head(opus_file,current_section)->channel_count;
-
-		frames_mixed+=ret;
+		stream_channels = op_head(opus_file, current_section)->channel_count;
 
-		p_bufer+=ret*stream_channels;
-		p_frames-=ret;
+		frames_mixed += ret;
 
+		p_bufer += ret * stream_channels;
+		p_frames -= ret;
 	}
 
-	return total-p_frames;
+	return total - p_frames;
 }
 
 float AudioStreamPlaybackOpus::get_length() const {
-	if(!stream_loaded) {
-		if(const_cast<AudioStreamPlaybackOpus*>(this)->_load_stream() != OK)
+	if (!stream_loaded) {
+		if (const_cast<AudioStreamPlaybackOpus *>(this)->_load_stream() != OK)
 			return 0;
 	}
 	return length;
@@ -339,7 +343,7 @@ float AudioStreamPlaybackOpus::get_pos() const {
 
 	int32_t frames = int32_t(frames_mixed);
 	if (frames < 0)
-		frames=0;
+		frames = 0;
 	return double(frames) / osrate;
 }
 
@@ -351,9 +355,9 @@ AudioStreamPlaybackOpus::~AudioStreamPlaybackOpus() {
 	_clear_stream();
 }
 
-RES ResourceFormatLoaderAudioStreamOpus::load(const String &p_path, const String& p_original_path, Error *r_error) {
+RES ResourceFormatLoaderAudioStreamOpus::load(const String &p_path, const String &p_original_path, Error *r_error) {
 	if (r_error)
-		*r_error=OK;
+		*r_error = OK;
 
 	AudioStreamOpus *opus_stream = memnew(AudioStreamOpus);
 	opus_stream->set_file(p_path);
@@ -366,11 +370,11 @@ void ResourceFormatLoaderAudioStreamOpus::get_recognized_extensions(List<String>
 }
 String ResourceFormatLoaderAudioStreamOpus::get_resource_type(const String &p_path) const {
 
-	if (p_path.get_extension().to_lower()=="opus")
+	if (p_path.get_extension().to_lower() == "opus")
 		return "AudioStreamOpus";
 	return "";
 }
 
-bool ResourceFormatLoaderAudioStreamOpus::handles_type(const String& p_type) const {
-	return (p_type=="AudioStream" || p_type=="AudioStreamOpus");
+bool ResourceFormatLoaderAudioStreamOpus::handles_type(const String &p_type) const {
+	return (p_type == "AudioStream" || p_type == "AudioStreamOpus");
 }
diff --git a/modules/opus/audio_stream_opus.h b/modules/opus/audio_stream_opus.h
index 5093456ccd..f1bee121b2 100644
--- a/modules/opus/audio_stream_opus.h
+++ b/modules/opus/audio_stream_opus.h
@@ -40,10 +40,10 @@
 
 class AudioStreamPlaybackOpus : public AudioStreamPlayback {
 
-	GDCLASS(AudioStreamPlaybackOpus,AudioStreamPlayback)
+	GDCLASS(AudioStreamPlaybackOpus, AudioStreamPlayback)
 
 	enum {
-		MIN_MIX=1024
+		MIN_MIX = 1024
 	};
 
 	FileAccess *f;
@@ -78,19 +78,19 @@ class AudioStreamPlaybackOpus : public AudioStreamPlayback {
 	float loop_restart_time;
 
 public:
-	Error set_file(const String& p_file);
+	Error set_file(const String &p_file);
 
-	virtual void play(float p_from=0);
+	virtual void play(float p_from = 0);
 	virtual void stop();
 	virtual bool is_playing() const { return playing; }
 
-	virtual void set_loop_restart_time(float p_time) { loop_restart_time=p_time; }
+	virtual void set_loop_restart_time(float p_time) { loop_restart_time = p_time; }
 
-	virtual void set_paused(bool p_paused) { paused=p_paused; }
+	virtual void set_paused(bool p_paused) { paused = p_paused; }
 	virtual bool is_paused() const { return paused; }
 
-	virtual void set_loop(bool p_enable) { loops=p_enable; }
-	virtual bool has_loop() const {return loops; }
+	virtual void set_loop(bool p_enable) { loops = p_enable; }
+	virtual bool has_loop() const { return loops; }
 
 	virtual float get_length() const;
 
@@ -106,35 +106,33 @@ public:
 
 	virtual int get_minimum_buffer_size() const;
 
-	virtual int mix(int16_t* p_bufer,int p_frames);
+	virtual int mix(int16_t *p_bufer, int p_frames);
 
 	AudioStreamPlaybackOpus();
 	~AudioStreamPlaybackOpus();
 };
 
+class AudioStreamOpus : public AudioStream {
 
-class AudioStreamOpus: public AudioStream {
-
-	GDCLASS(AudioStreamOpus,AudioStream)
+	GDCLASS(AudioStreamOpus, AudioStream)
 
 	String file;
-public:
 
+public:
 	Ref<AudioStreamPlayback> instance_playback() {
-		Ref<AudioStreamPlaybackOpus> pb = memnew( AudioStreamPlaybackOpus );
+		Ref<AudioStreamPlaybackOpus> pb = memnew(AudioStreamPlaybackOpus);
 		pb->set_file(file);
 		return pb;
 	}
 
-	void set_file(const String& p_file) { file=p_file; }
-
+	void set_file(const String &p_file) { file = p_file; }
 };
 
-class ResourceFormatLoaderAudioStreamOpus: public ResourceFormatLoader {
+class ResourceFormatLoaderAudioStreamOpus : public ResourceFormatLoader {
 public:
-	virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual bool handles_type(const String& p_type) const;
+	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;
 };
 
diff --git a/modules/opus/register_types.cpp b/modules/opus/register_types.cpp
index a177bc9463..8a48c5084e 100644
--- a/modules/opus/register_types.cpp
+++ b/modules/opus/register_types.cpp
@@ -34,12 +34,12 @@ static ResourceFormatLoaderAudioStreamOpus *opus_stream_loader = NULL;
 
 void register_opus_types() {
 
-	opus_stream_loader = memnew( ResourceFormatLoaderAudioStreamOpus );
+	opus_stream_loader = memnew(ResourceFormatLoaderAudioStreamOpus);
 	ResourceLoader::add_resource_format_loader(opus_stream_loader);
 	ClassDB::register_class<AudioStreamOpus>();
 }
 
 void unregister_opus_types() {
 
-	memdelete( opus_stream_loader );
+	memdelete(opus_stream_loader);
 }
diff --git a/modules/pbm/bitmap_loader_pbm.cpp b/modules/pbm/bitmap_loader_pbm.cpp
index ab0805a6b0..04051fc38f 100644
--- a/modules/pbm/bitmap_loader_pbm.cpp
+++ b/modules/pbm/bitmap_loader_pbm.cpp
@@ -30,30 +30,27 @@
 #include "os/file_access.h"
 #include "scene/resources/bit_mask.h"
 
-
-static bool _get_token(FileAccessRef& f,uint8_t &saved,PoolVector<uint8_t>& r_token,bool p_binary=false,bool p_single_chunk=false) {
-
+static bool _get_token(FileAccessRef &f, uint8_t &saved, PoolVector<uint8_t> &r_token, bool p_binary = false, bool p_single_chunk = false) {
 
 	int token_max = r_token.size();
 	PoolVector<uint8_t>::Write w;
 	if (token_max)
-		w=r_token.write();
-	int ofs=0;
-	bool lf=false;
-
+		w = r_token.write();
+	int ofs = 0;
+	bool lf = false;
 
-	while(true) {
+	while (true) {
 
 		uint8_t b;
 		if (saved) {
-			b=saved;
-			saved=0;
+			b = saved;
+			saved = 0;
 		} else {
 			b = f->get_8();
 		}
 		if (f->eof_reached()) {
 			if (ofs) {
-				w=PoolVector<uint8_t>::Write();
+				w = PoolVector<uint8_t>::Write();
 				r_token.resize(ofs);
 				return true;
 			} else {
@@ -61,9 +58,9 @@ static bool _get_token(FileAccessRef& f,uint8_t &saved,PoolVector<uint8_t>& r_to
 			}
 		}
 
-		if (!ofs && !p_binary && b=='#') {
+		if (!ofs && !p_binary && b == '#') {
 			//skip comment
-			while(b!='\n') {
+			while (b != '\n') {
 				if (f->eof_reached()) {
 					return false;
 				}
@@ -71,182 +68,165 @@ static bool _get_token(FileAccessRef& f,uint8_t &saved,PoolVector<uint8_t>& r_to
 				b = f->get_8();
 			}
 
-			lf=true;
+			lf = true;
 
-		} else if (b<=32 && !(p_binary && (ofs || lf))) {
+		} else if (b <= 32 && !(p_binary && (ofs || lf))) {
 
-			if (b=='\n') {
-				lf=true;
+			if (b == '\n') {
+				lf = true;
 			}
 
-
 			if (ofs && !p_single_chunk) {
-				w=PoolVector<uint8_t>::Write();
+				w = PoolVector<uint8_t>::Write();
 				r_token.resize(ofs);
-				saved=b;
+				saved = b;
 
 				return true;
 			}
 		} else {
 
-			bool resized=false;
-			while (ofs>=token_max) {
+			bool resized = false;
+			while (ofs >= token_max) {
 				if (token_max)
-					token_max<<=1;
+					token_max <<= 1;
 				else
-					token_max=1;
-				resized=true;
+					token_max = 1;
+				resized = true;
 			}
 			if (resized) {
-				w=PoolVector<uint8_t>::Write();
+				w = PoolVector<uint8_t>::Write();
 				r_token.resize(token_max);
-				w=r_token.write();
+				w = r_token.write();
 			}
-			w[ofs++]=b;
+			w[ofs++] = b;
 		}
 	}
 
 	return false;
 }
 
-static int _get_number_from_token(PoolVector<uint8_t>& r_token) {
+static int _get_number_from_token(PoolVector<uint8_t> &r_token) {
 
 	int len = r_token.size();
 	PoolVector<uint8_t>::Read r = r_token.read();
-	return String::to_int((const char*)r.ptr(),len);
-
+	return String::to_int((const char *)r.ptr(), len);
 }
 
+RES ResourceFormatPBM::load(const String &p_path, const String &p_original_path, Error *r_error) {
 
-RES ResourceFormatPBM::load(const String &p_path,const String& p_original_path,Error *r_error) {
-
-#define _RETURN(m_err)\
-{\
-	if (r_error)\
-		*r_error=m_err;\
-	ERR_FAIL_V(RES());\
-}
-
+#define _RETURN(m_err)        \
+	{                         \
+		if (r_error)          \
+			*r_error = m_err; \
+		ERR_FAIL_V(RES());    \
+	}
 
-	FileAccessRef f=FileAccess::open(p_path,FileAccess::READ);
-	uint8_t saved=0;
+	FileAccessRef f = FileAccess::open(p_path, FileAccess::READ);
+	uint8_t saved = 0;
 	if (!f)
 		_RETURN(ERR_CANT_OPEN);
 
 	PoolVector<uint8_t> token;
 
-	if (!_get_token(f,saved,token)) {
+	if (!_get_token(f, saved, token)) {
 		_RETURN(ERR_PARSE_ERROR);
 	}
 
-	if (token.size()!=2) {
+	if (token.size() != 2) {
 		_RETURN(ERR_FILE_CORRUPT);
 	}
-	if (token[0]!='P') {
+	if (token[0] != 'P') {
 		_RETURN(ERR_FILE_CORRUPT);
 	}
-	if (token[1]!='1' && token[1]!='4') {
+	if (token[1] != '1' && token[1] != '4') {
 		_RETURN(ERR_FILE_CORRUPT);
 	}
 
-	bool bits = token[1]=='4';
+	bool bits = token[1] == '4';
 
-	if (!_get_token(f,saved,token)) {
+	if (!_get_token(f, saved, token)) {
 		_RETURN(ERR_PARSE_ERROR);
 	}
 
 	int width = _get_number_from_token(token);
-	if (width<=0) {
+	if (width <= 0) {
 		_RETURN(ERR_FILE_CORRUPT);
 	}
 
-
-	if (!_get_token(f,saved,token)) {
+	if (!_get_token(f, saved, token)) {
 		_RETURN(ERR_PARSE_ERROR);
 	}
 
 	int height = _get_number_from_token(token);
-	if (height<=0) {
+	if (height <= 0) {
 		_RETURN(ERR_FILE_CORRUPT);
 	}
 
-
 	Ref<BitMap> bm;
 	bm.instance();
-	bm->create(Size2i(width,height));
+	bm->create(Size2i(width, height));
 
 	if (!bits) {
 
-		int required_bytes = width*height;
-		if (!_get_token(f,saved,token,false,true)) {
+		int required_bytes = width * height;
+		if (!_get_token(f, saved, token, false, true)) {
 			_RETURN(ERR_PARSE_ERROR);
 		}
 
-		if (token.size()<required_bytes) {
+		if (token.size() < required_bytes) {
 			_RETURN(ERR_FILE_CORRUPT);
 		}
 
-		PoolVector<uint8_t>::Read r=token.read();
-			
-		for(int i=0;i<height;i++) {
-			for(int j=0;j<width;j++) {
+		PoolVector<uint8_t>::Read r = token.read();
 
+		for (int i = 0; i < height; i++) {
+			for (int j = 0; j < width; j++) {
 
-				char num = r[i*width+j];
-				bm->set_bit(Point2i(j,i),num=='0');
+				char num = r[i * width + j];
+				bm->set_bit(Point2i(j, i), num == '0');
 			}
-
 		}
 
-
-
 	} else {
 		//a single, entire token of bits!
-		if (!_get_token(f,saved,token,true)) {
+		if (!_get_token(f, saved, token, true)) {
 			_RETURN(ERR_PARSE_ERROR);
 		}
-		int required_bytes = Math::ceil((width*height)/8.0);
-		if (token.size()<required_bytes) {
+		int required_bytes = Math::ceil((width * height) / 8.0);
+		if (token.size() < required_bytes) {
 			_RETURN(ERR_FILE_CORRUPT);
 		}
 
-		PoolVector<uint8_t>::Read r=token.read();
+		PoolVector<uint8_t>::Read r = token.read();
 		int bitwidth = width;
 		if (bitwidth % 8)
-			bitwidth+=8-(bitwidth%8);
+			bitwidth += 8 - (bitwidth % 8);
 
-		for(int i=0;i<height;i++) {
-			for(int j=0;j<width;j++) {
+		for (int i = 0; i < height; i++) {
+			for (int j = 0; j < width; j++) {
 
-				int ofs = bitwidth*i+j;
+				int ofs = bitwidth * i + j;
 
-				uint8_t byte = r[ofs/8];
-				bool bit = (byte>>(7-(ofs%8)))&1;
-
-				bm->set_bit(Point2i(j,i),!bit);
+				uint8_t byte = r[ofs / 8];
+				bool bit = (byte >> (7 - (ofs % 8))) & 1;
 
+				bm->set_bit(Point2i(j, i), !bit);
 			}
-
 		}
-
 	}
 
 	return bm;
-
-
 }
 
 void ResourceFormatPBM::get_recognized_extensions(List<String> *p_extensions) const {
 	p_extensions->push_back("pbm");
 }
-bool ResourceFormatPBM::handles_type(const String& p_type) const {
-	return p_type=="BitMap";
+bool ResourceFormatPBM::handles_type(const String &p_type) const {
+	return p_type == "BitMap";
 }
 String ResourceFormatPBM::get_resource_type(const String &p_path) const {
 
-	if (p_path.get_extension().to_lower()=="pbm")
+	if (p_path.get_extension().to_lower() == "pbm")
 		return "BitMap";
 	return "";
 }
-
-
diff --git a/modules/pbm/bitmap_loader_pbm.h b/modules/pbm/bitmap_loader_pbm.h
index b60b38fcca..5e5062f435 100644
--- a/modules/pbm/bitmap_loader_pbm.h
+++ b/modules/pbm/bitmap_loader_pbm.h
@@ -36,15 +36,11 @@
 */
 class ResourceFormatPBM : public ResourceFormatLoader {
 
-
 public:
-
-	virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual bool handles_type(const String& p_type) const;
+	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;
 };
 
-
-
 #endif
diff --git a/modules/pbm/register_types.cpp b/modules/pbm/register_types.cpp
index 0dd39ce1e4..abfc08c909 100644
--- a/modules/pbm/register_types.cpp
+++ b/modules/pbm/register_types.cpp
@@ -30,15 +30,15 @@
 
 #include "bitmap_loader_pbm.h"
 
-static ResourceFormatPBM * pbm_loader = NULL;
+static ResourceFormatPBM *pbm_loader = NULL;
 
 void register_pbm_types() {
 
-	pbm_loader = memnew( ResourceFormatPBM );
+	pbm_loader = memnew(ResourceFormatPBM);
 	ResourceLoader::add_resource_format_loader(pbm_loader);
 }
 
 void unregister_pbm_types() {
 
-	memdelete( pbm_loader );
+	memdelete(pbm_loader);
 }
diff --git a/modules/pvr/register_types.cpp b/modules/pvr/register_types.cpp
index 2464e78984..76fe7970d3 100644
--- a/modules/pvr/register_types.cpp
+++ b/modules/pvr/register_types.cpp
@@ -34,7 +34,7 @@ static ResourceFormatPVR *resource_loader_pvr = NULL;
 
 void register_pvr_types() {
 
-	resource_loader_pvr = memnew( ResourceFormatPVR );
+	resource_loader_pvr = memnew(ResourceFormatPVR);
 	ResourceLoader::add_resource_format_loader(resource_loader_pvr);
 }
 
diff --git a/modules/pvr/texture_loader_pvr.cpp b/modules/pvr/texture_loader_pvr.cpp
index 9805675f2c..0409998408 100644
--- a/modules/pvr/texture_loader_pvr.cpp
+++ b/modules/pvr/texture_loader_pvr.cpp
@@ -27,49 +27,47 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 #include "texture_loader_pvr.h"
-#include "os/file_access.h"
-#include <string.h>
 #include "PvrTcEncoder.h"
 #include "RgbaBitmap.h"
+#include "os/file_access.h"
+#include <string.h>
 
-static void _pvrtc_decompress(Image* p_img);
+static void _pvrtc_decompress(Image *p_img);
 
 enum PVRFLags {
 
-	PVR_HAS_MIPMAPS=0x00000100,
-	PVR_TWIDDLED=0x00000200,
-	PVR_NORMAL_MAP=0x00000400,
-	PVR_BORDER=0x00000800,
-	PVR_CUBE_MAP=0x00001000,
-	PVR_FALSE_MIPMAPS=0x00002000,
-	PVR_VOLUME_TEXTURES=0x00004000,
-	PVR_HAS_ALPHA=0x00008000,
-	PVR_VFLIP=0x00010000
+	PVR_HAS_MIPMAPS = 0x00000100,
+	PVR_TWIDDLED = 0x00000200,
+	PVR_NORMAL_MAP = 0x00000400,
+	PVR_BORDER = 0x00000800,
+	PVR_CUBE_MAP = 0x00001000,
+	PVR_FALSE_MIPMAPS = 0x00002000,
+	PVR_VOLUME_TEXTURES = 0x00004000,
+	PVR_HAS_ALPHA = 0x00008000,
+	PVR_VFLIP = 0x00010000
 
 };
 
-
-
-RES ResourceFormatPVR::load(const String &p_path,const String& p_original_path,Error *r_error) {
+RES ResourceFormatPVR::load(const String &p_path, const String &p_original_path, Error *r_error) {
 
 	if (r_error)
-		*r_error=ERR_CANT_OPEN;
+		*r_error = ERR_CANT_OPEN;
 
 	Error err;
-	FileAccess *f = FileAccess::open(p_path,FileAccess::READ,&err);
+	FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
 	if (!f)
 		return RES();
 
 	FileAccessRef faref(f);
 
-	ERR_FAIL_COND_V(err,RES());
+	ERR_FAIL_COND_V(err, RES());
 
 	if (r_error)
-		*r_error=ERR_FILE_CORRUPT;
+		*r_error = ERR_FILE_CORRUPT;
 
 	uint32_t hsize = f->get_32();
 
-	ERR_FAIL_COND_V(hsize!=52,RES());
+	ERR_FAIL_COND_V(hsize != 52, RES());
 	uint32_t height = f->get_32();
 	uint32_t width = f->get_32();
 	uint32_t mipmaps = f->get_32();
@@ -80,12 +78,12 @@ RES ResourceFormatPVR::load(const String &p_path,const String& p_original_path,E
 	uint32_t gmask = f->get_32();
 	uint32_t bmask = f->get_32();
 	uint32_t amask = f->get_32();
-	uint8_t pvrid[5]={0,0,0,0,0};
-	f->get_buffer(pvrid,4);
-	ERR_FAIL_COND_V(String((char*)pvrid)!="PVR!",RES());
+	uint8_t pvrid[5] = { 0, 0, 0, 0, 0 };
+	f->get_buffer(pvrid, 4);
+	ERR_FAIL_COND_V(String((char *)pvrid) != "PVR!", RES());
 	uint32_t surfcount = f->get_32();
 
-/*
+	/*
 	print_line("height: "+itos(height));
 	print_line("width: "+itos(width));
 	print_line("mipmaps: "+itos(mipmaps));
@@ -102,149 +100,144 @@ RES ResourceFormatPVR::load(const String &p_path,const String& p_original_path,E
 	PoolVector<uint8_t> data;
 	data.resize(surfsize);
 
-	ERR_FAIL_COND_V(data.size()==0,RES());
-
+	ERR_FAIL_COND_V(data.size() == 0, RES());
 
 	PoolVector<uint8_t>::Write w = data.write();
-	f->get_buffer(&w[0],surfsize);
+	f->get_buffer(&w[0], surfsize);
 	err = f->get_error();
-	ERR_FAIL_COND_V(err!=OK,RES());
+	ERR_FAIL_COND_V(err != OK, RES());
 
-	Image::Format format=Image::FORMAT_MAX;
+	Image::Format format = Image::FORMAT_MAX;
 
-
-	switch(flags&0xFF) {
+	switch (flags & 0xFF) {
 
 		case 0x18:
-		case 0xC: format=(flags&PVR_HAS_ALPHA)?Image::FORMAT_PVRTC2A:Image::FORMAT_PVRTC2;  break;
+		case 0xC: format = (flags & PVR_HAS_ALPHA) ? Image::FORMAT_PVRTC2A : Image::FORMAT_PVRTC2; break;
 		case 0x19:
-		case 0xD: format=(flags&PVR_HAS_ALPHA)?Image::FORMAT_PVRTC4A:Image::FORMAT_PVRTC4;  break;
+		case 0xD: format = (flags & PVR_HAS_ALPHA) ? Image::FORMAT_PVRTC4A : Image::FORMAT_PVRTC4; break;
 		case 0x16:
-			format=Image::FORMAT_L8; break;
+			format = Image::FORMAT_L8;
+			break;
 		case 0x17:
-			format=Image::FORMAT_LA8; break;
+			format = Image::FORMAT_LA8;
+			break;
 		case 0x20:
 		case 0x80:
 		case 0x81:
-			format=Image::FORMAT_DXT1; break;
+			format = Image::FORMAT_DXT1;
+			break;
 		case 0x21:
 		case 0x22:
 		case 0x82:
 		case 0x83:
-			format=Image::FORMAT_DXT3; break;
+			format = Image::FORMAT_DXT3;
+			break;
 		case 0x23:
 		case 0x24:
 		case 0x84:
 		case 0x85:
-			format=Image::FORMAT_DXT5; break;
+			format = Image::FORMAT_DXT5;
+			break;
 		case 0x4:
 		case 0x15:
-			format=Image::FORMAT_RGB8; break;
+			format = Image::FORMAT_RGB8;
+			break;
 		case 0x5:
 		case 0x12:
-			format=Image::FORMAT_RGBA8; break;
+			format = Image::FORMAT_RGBA8;
+			break;
 		case 0x36:
-			format=Image::FORMAT_ETC; break;
+			format = Image::FORMAT_ETC;
+			break;
 		default:
-			ERR_EXPLAIN("Unsupported format in PVR texture: "+itos(flags&0xFF));
+			ERR_EXPLAIN("Unsupported format in PVR texture: " + itos(flags & 0xFF));
 			ERR_FAIL_V(RES());
-
 	}
 
 	w = PoolVector<uint8_t>::Write();
 
-	int tex_flags=Texture::FLAG_FILTER|Texture::FLAG_REPEAT;
+	int tex_flags = Texture::FLAG_FILTER | Texture::FLAG_REPEAT;
 
 	if (mipmaps)
-		tex_flags|=Texture::FLAG_MIPMAPS;
+		tex_flags |= Texture::FLAG_MIPMAPS;
 
+	print_line("flip: " + itos(flags & PVR_VFLIP));
 
-	print_line("flip: "+itos(flags&PVR_VFLIP));
+	Image image(width, height, mipmaps, format, data);
+	ERR_FAIL_COND_V(image.empty(), RES());
 
-	Image image(width,height,mipmaps,format,data);
-	ERR_FAIL_COND_V(image.empty(),RES());
-
-	Ref<ImageTexture> texture = memnew( ImageTexture );
-	texture->create_from_image(image,tex_flags);
+	Ref<ImageTexture> texture = memnew(ImageTexture);
+	texture->create_from_image(image, tex_flags);
 
 	if (r_error)
-		*r_error=OK;
+		*r_error = OK;
 
 	return texture;
-
 }
 
 void ResourceFormatPVR::get_recognized_extensions(List<String> *p_extensions) const {
 
 	p_extensions->push_back("pvr");
 }
-bool ResourceFormatPVR::handles_type(const String& p_type) const {
+bool ResourceFormatPVR::handles_type(const String &p_type) const {
 
-	return ClassDB::is_parent_class(p_type,"Texture");
+	return ClassDB::is_parent_class(p_type, "Texture");
 }
 String ResourceFormatPVR::get_resource_type(const String &p_path) const {
 
-
-	if (p_path.get_extension().to_lower()=="pvr")
+	if (p_path.get_extension().to_lower() == "pvr")
 		return "Texture";
 	return "";
 }
 
-
-
-static void _compress_pvrtc4(Image * p_img) {
+static void _compress_pvrtc4(Image *p_img) {
 
 	Image img = *p_img;
 
-	bool make_mipmaps=false;
-	if (img.get_width()%8 || img.get_height()%8) {
-		make_mipmaps=img.has_mipmaps();
-		img.resize(img.get_width()+(8-(img.get_width()%8)),img.get_height()+(8-(img.get_height()%8)));
+	bool make_mipmaps = false;
+	if (img.get_width() % 8 || img.get_height() % 8) {
+		make_mipmaps = img.has_mipmaps();
+		img.resize(img.get_width() + (8 - (img.get_width() % 8)), img.get_height() + (8 - (img.get_height() % 8)));
 	}
 	img.convert(Image::FORMAT_RGBA8);
 	if (!img.has_mipmaps() && make_mipmaps)
 		img.generate_mipmaps();
 
-	bool use_alpha=img.detect_alpha();
+	bool use_alpha = img.detect_alpha();
 
 	Image new_img;
-	new_img.create(img.get_width(),img.get_height(),true,use_alpha?Image::FORMAT_PVRTC4A:Image::FORMAT_PVRTC4);
-	PoolVector<uint8_t> data=new_img.get_data();
+	new_img.create(img.get_width(), img.get_height(), true, use_alpha ? Image::FORMAT_PVRTC4A : Image::FORMAT_PVRTC4);
+	PoolVector<uint8_t> data = new_img.get_data();
 	{
-		PoolVector<uint8_t>::Write wr=data.write();
-		PoolVector<uint8_t>::Read r=img.get_data().read();
+		PoolVector<uint8_t>::Write wr = data.write();
+		PoolVector<uint8_t>::Read r = img.get_data().read();
 
+		for (int i = 0; i <= new_img.get_mipmap_count(); i++) {
 
-		for(int i=0;i<=new_img.get_mipmap_count();i++) {
-
-			int ofs,size,w,h;
-			img.get_mipmap_offset_size_and_dimensions(i,ofs,size,w,h);
-			Javelin::RgbaBitmap bm(w,h);
-			copymem(bm.GetData(),&r[ofs],size);
+			int ofs, size, w, h;
+			img.get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h);
+			Javelin::RgbaBitmap bm(w, h);
+			copymem(bm.GetData(), &r[ofs], size);
 			{
 				Javelin::ColorRgba<unsigned char> *dp = bm.GetData();
-				for(int j=0;j<size/4;j++) {
-					SWAP(dp[j].r,dp[j].b);
+				for (int j = 0; j < size / 4; j++) {
+					SWAP(dp[j].r, dp[j].b);
 				}
 			}
 
-			new_img.get_mipmap_offset_size_and_dimensions(i,ofs,size,w,h);
-			Javelin::PvrTcEncoder::EncodeRgba4Bpp(&wr[ofs],bm);
+			new_img.get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h);
+			Javelin::PvrTcEncoder::EncodeRgba4Bpp(&wr[ofs], bm);
 		}
-
 	}
 
-	*p_img = Image(new_img.get_width(),new_img.get_height(),new_img.has_mipmaps(),new_img.get_format(),data);
-
+	*p_img = Image(new_img.get_width(), new_img.get_height(), new_img.has_mipmaps(), new_img.get_format(), data);
 }
 
 ResourceFormatPVR::ResourceFormatPVR() {
 
-
-	Image::_image_decompress_pvrtc=_pvrtc_decompress;
-	Image::_image_compress_pvrtc4_func=_compress_pvrtc4;
-	Image::_image_compress_pvrtc2_func=_compress_pvrtc4;
-
+	Image::_image_decompress_pvrtc = _pvrtc_decompress;
+	Image::_image_compress_pvrtc4_func = _compress_pvrtc4;
+	Image::_image_compress_pvrtc2_func = _compress_pvrtc4;
 }
 
 /////////////////////////////////////////////////////////
@@ -253,7 +246,6 @@ ResourceFormatPVR::ResourceFormatPVR() {
 
 /////////////////////////////////////////////////////////
 
-
 #define PT_INDEX 2
 #define BLK_Y_SIZE 4
 #define BLK_X_MAX 8
@@ -267,52 +259,48 @@ ResourceFormatPVR::ResourceFormatPVR() {
 	legal coordinate range
 */
 #define LIMIT_COORD(Val, Size, p_tiled) \
-      ((p_tiled)? WRAP_COORD((Val), (Size)): CLAMP((Val), 0, (Size)-1))
-
+	((p_tiled) ? WRAP_COORD((Val), (Size)) : CLAMP((Val), 0, (Size)-1))
 
 struct PVRTCBlock {
 	//blocks are 64 bits
 	uint32_t data[2];
 };
 
+_FORCE_INLINE_ bool is_po2(uint32_t p_input) {
 
-
-_FORCE_INLINE_ bool is_po2( uint32_t p_input ) {
-
-  if( p_input==0 )
-	  return 0;
-  uint32_t minus1=p_input- 1;
-  return ((p_input|minus1)==(p_input^minus1))?1:0;
+	if (p_input == 0)
+		return 0;
+	uint32_t minus1 = p_input - 1;
+	return ((p_input | minus1) == (p_input ^ minus1)) ? 1 : 0;
 }
 
-
-static void unpack_5554(const PVRTCBlock *p_block, int   p_ab_colors[2][4]) {
+static void unpack_5554(const PVRTCBlock *p_block, int p_ab_colors[2][4]) {
 
 	uint32_t raw_bits[2];
 	raw_bits[0] = p_block->data[1] & (0xFFFE);
 	raw_bits[1] = p_block->data[1] >> 16;
 
-	for(int i=0;i<2;i++) {
+	for (int i = 0; i < 2; i++) {
 
-		if(raw_bits[i] & (1<<15)) {
+		if (raw_bits[i] & (1 << 15)) {
 
-			p_ab_colors[i][0]= (raw_bits[i] >> 10) & 0x1F;
-			p_ab_colors[i][1]= (raw_bits[i] >>  5) & 0x1F;
-			p_ab_colors[i][2]= raw_bits[i] & 0x1F;
-			if(i==0)
-				p_ab_colors[0][2]|= p_ab_colors[0][2] >> 4;
+			p_ab_colors[i][0] = (raw_bits[i] >> 10) & 0x1F;
+			p_ab_colors[i][1] = (raw_bits[i] >> 5) & 0x1F;
+			p_ab_colors[i][2] = raw_bits[i] & 0x1F;
+			if (i == 0)
+				p_ab_colors[0][2] |= p_ab_colors[0][2] >> 4;
 			p_ab_colors[i][3] = 0xF;
 		} else {
 
-			p_ab_colors[i][0] = (raw_bits[i] >>  (8-1)) & 0x1E;
-			p_ab_colors[i][1] = (raw_bits[i] >>  (4-1)) & 0x1E;
+			p_ab_colors[i][0] = (raw_bits[i] >> (8 - 1)) & 0x1E;
+			p_ab_colors[i][1] = (raw_bits[i] >> (4 - 1)) & 0x1E;
 
 			p_ab_colors[i][0] |= p_ab_colors[i][0] >> 4;
 			p_ab_colors[i][1] |= p_ab_colors[i][1] >> 4;
 
 			p_ab_colors[i][2] = (raw_bits[i] & 0xF) << 1;
 
-			if(i==0)
+			if (i == 0)
 				p_ab_colors[0][2] |= p_ab_colors[0][2] >> 3;
 			else
 				p_ab_colors[0][2] |= p_ab_colors[0][2] >> 4;
@@ -322,55 +310,52 @@ static void unpack_5554(const PVRTCBlock *p_block, int   p_ab_colors[2][4]) {
 	}
 }
 
-
-static void unpack_modulations(const PVRTCBlock *p_block, const int p_2bit, int p_modulation[8][16], int p_modulation_modes[8][16],  int p_x,  int p_y) {
+static void unpack_modulations(const PVRTCBlock *p_block, const int p_2bit, int p_modulation[8][16], int p_modulation_modes[8][16], int p_x, int p_y) {
 
 	int block_mod_mode = p_block->data[1] & 1;
 	uint32_t modulation_bits = p_block->data[0];
 
-	if(p_2bit && block_mod_mode) {
+	if (p_2bit && block_mod_mode) {
 
-		for(int y = 0; y < BLK_Y_SIZE; y++) {
-			for(int x = 0; x < BLK_X_2BPP; x++) {
+		for (int y = 0; y < BLK_Y_SIZE; y++) {
+			for (int x = 0; x < BLK_X_2BPP; x++) {
 
-				p_modulation_modes[y+p_y][x+p_x] = block_mod_mode;
+				p_modulation_modes[y + p_y][x + p_x] = block_mod_mode;
 
-				if(((x^y)&1) == 0) {
-					p_modulation[y+p_y][x+p_x] = modulation_bits & 3;
+				if (((x ^ y) & 1) == 0) {
+					p_modulation[y + p_y][x + p_x] = modulation_bits & 3;
 					modulation_bits >>= 2;
 				}
 			}
 		}
 
-	} else if(p_2bit) {
+	} else if (p_2bit) {
 
-		for(int y = 0; y < BLK_Y_SIZE; y++) {
-			for(int x = 0; x < BLK_X_2BPP; x++) {
-				p_modulation_modes[y+p_y][x+p_x] = block_mod_mode;
+		for (int y = 0; y < BLK_Y_SIZE; y++) {
+			for (int x = 0; x < BLK_X_2BPP; x++) {
+				p_modulation_modes[y + p_y][x + p_x] = block_mod_mode;
 
-				if(modulation_bits & 1)
-					p_modulation[y+p_y][x+p_x] = 0x3;
+				if (modulation_bits & 1)
+					p_modulation[y + p_y][x + p_x] = 0x3;
 				else
-					p_modulation[y+p_y][x+p_x] = 0x0;
+					p_modulation[y + p_y][x + p_x] = 0x0;
 
 				modulation_bits >>= 1;
 			}
 		}
-	} else 	{
-		for(int y = 0; y < BLK_Y_SIZE; y++) {
-			for(int x = 0; x < BLK_X_4BPP; x++) {
-				p_modulation_modes[y+p_y][x+p_x] = block_mod_mode;
-				p_modulation[y+p_y][x+p_x] = modulation_bits & 3;
+	} else {
+		for (int y = 0; y < BLK_Y_SIZE; y++) {
+			for (int x = 0; x < BLK_X_4BPP; x++) {
+				p_modulation_modes[y + p_y][x + p_x] = block_mod_mode;
+				p_modulation[y + p_y][x + p_x] = modulation_bits & 3;
 				modulation_bits >>= 2;
 			}
 		}
 	}
 
-	ERR_FAIL_COND(modulation_bits!=0);
+	ERR_FAIL_COND(modulation_bits != 0);
 }
 
-
-
 static void interpolate_colors(const int p_colorp[4], const int p_colorq[4], const int p_colorr[4], const int p_colors[4], bool p_2bit, const int x, const int y, int r_result[4]) {
 	int u, v, uscale;
 	int k;
@@ -379,7 +364,7 @@ static void interpolate_colors(const int p_colorp[4], const int p_colorq[4], con
 
 	int P[4], Q[4], R[4], S[4];
 
-	for(k = 0; k < 4; k++) {
+	for (k = 0; k < 4; k++) {
 		P[k] = p_colorp[k];
 		Q[k] = p_colorq[k];
 		R[k] = p_colorr[k];
@@ -388,22 +373,22 @@ static void interpolate_colors(const int p_colorp[4], const int p_colorq[4], con
 
 	v = (y & 0x3) | ((~y & 0x2) << 1);
 
-	if(p_2bit)
+	if (p_2bit)
 		u = (x & 0x7) | ((~x & 0x4) << 1);
 	else
 		u = (x & 0x3) | ((~x & 0x2) << 1);
 
-	v  = v - BLK_Y_SIZE/2;
+	v = v - BLK_Y_SIZE / 2;
 
-	if(p_2bit) {
-		u = u - BLK_X_2BPP/2;
+	if (p_2bit) {
+		u = u - BLK_X_2BPP / 2;
 		uscale = 8;
 	} else {
-		u = u - BLK_X_4BPP/2;
+		u = u - BLK_X_4BPP / 2;
 		uscale = 4;
 	}
 
-	for(k = 0; k < 4; k++) {
+	for (k = 0; k < 4; k++) {
 		tmp1 = P[k] * uscale + u * (Q[k] - P[k]);
 		tmp2 = R[k] * uscale + u * (S[k] - R[k]);
 
@@ -412,82 +397,77 @@ static void interpolate_colors(const int p_colorp[4], const int p_colorq[4], con
 		r_result[k] = tmp1;
 	}
 
-	if(p_2bit) {
-		for(k = 0; k < 3; k++) {
+	if (p_2bit) {
+		for (k = 0; k < 3; k++) {
 			r_result[k] >>= 2;
 		}
 
 		r_result[3] >>= 1;
 	} else {
-		for(k = 0; k < 3; k++) {
+		for (k = 0; k < 3; k++) {
 			r_result[k] >>= 1;
 		}
 	}
 
-	for(k = 0; k < 4; k++) {
+	for (k = 0; k < 4; k++) {
 		ERR_FAIL_COND(r_result[k] >= 256);
 	}
 
-
-	for(k = 0; k < 3; k++) {
+	for (k = 0; k < 3; k++) {
 		r_result[k] += r_result[k] >> 5;
 	}
 
 	r_result[3] += r_result[3] >> 4;
 
-	for(k = 0; k < 4; k++) {
+	for (k = 0; k < 4; k++) {
 		ERR_FAIL_COND(r_result[k] >= 256);
 	}
-
 }
 
-
-static void get_modulation_value(int x, int y, const int p_2bit, const int p_modulation[8][16], const int p_modulation_modes[8][16], int *r_mod, int *p_dopt)
-{
-	static const int rep_vals0[4] = {0, 3, 5, 8};
-	static const int rep_vals1[4] = {0, 4, 4, 8};
+static void get_modulation_value(int x, int y, const int p_2bit, const int p_modulation[8][16], const int p_modulation_modes[8][16], int *r_mod, int *p_dopt) {
+	static const int rep_vals0[4] = { 0, 3, 5, 8 };
+	static const int rep_vals1[4] = { 0, 4, 4, 8 };
 
 	int mod_val;
 
 	y = (y & 0x3) | ((~y & 0x2) << 1);
 
-	if(p_2bit)
+	if (p_2bit)
 		x = (x & 0x7) | ((~x & 0x4) << 1);
 	else
 		x = (x & 0x3) | ((~x & 0x2) << 1);
 
 	*p_dopt = 0;
 
-	if(p_modulation_modes[y][x]==0)	{
+	if (p_modulation_modes[y][x] == 0) {
 		mod_val = rep_vals0[p_modulation[y][x]];
-	} else if(p_2bit) {
-		if(((x^y)&1)==0)
+	} else if (p_2bit) {
+		if (((x ^ y) & 1) == 0)
 			mod_val = rep_vals0[p_modulation[y][x]];
-		else if(p_modulation_modes[y][x] == 1) {
-			mod_val = (
-					rep_vals0[p_modulation[y-1][x]] +
-					rep_vals0[p_modulation[y+1][x]] +
-					rep_vals0[p_modulation[y][x-1]] +
-					rep_vals0[p_modulation[y][x+1]] + 2) / 4;
-		} else if(p_modulation_modes[y][x] == 2) {
-			mod_val = (
-					rep_vals0[p_modulation[y][x-1]] +
-					rep_vals0[p_modulation[y][x+1]] + 1) / 2;
+		else if (p_modulation_modes[y][x] == 1) {
+			mod_val = (rep_vals0[p_modulation[y - 1][x]] +
+							  rep_vals0[p_modulation[y + 1][x]] +
+							  rep_vals0[p_modulation[y][x - 1]] +
+							  rep_vals0[p_modulation[y][x + 1]] + 2) /
+					  4;
+		} else if (p_modulation_modes[y][x] == 2) {
+			mod_val = (rep_vals0[p_modulation[y][x - 1]] +
+							  rep_vals0[p_modulation[y][x + 1]] + 1) /
+					  2;
 		} else {
-			mod_val = (
-					rep_vals0[p_modulation[y-1][x]] +
-					rep_vals0[p_modulation[y+1][x]] + 1) / 2;
+			mod_val = (rep_vals0[p_modulation[y - 1][x]] +
+							  rep_vals0[p_modulation[y + 1][x]] + 1) /
+					  2;
 		}
-	} else  {
+	} else {
 		mod_val = rep_vals1[p_modulation[y][x]];
 
 		*p_dopt = p_modulation[y][x] == PT_INDEX;
 	}
 
-	*r_mod =mod_val;
+	*r_mod = mod_val;
 }
 
-
 static int disable_twiddling = 0;
 
 static uint32_t twiddle_uv(uint32_t p_height, uint32_t p_width, uint32_t p_y, uint32_t p_x) {
@@ -502,51 +482,50 @@ static uint32_t twiddle_uv(uint32_t p_height, uint32_t p_width, uint32_t p_y, ui
 
 	int shift_count;
 
-	ERR_FAIL_COND_V(p_y >= p_height,0);
-	ERR_FAIL_COND_V(p_x >= p_width,0);
+	ERR_FAIL_COND_V(p_y >= p_height, 0);
+	ERR_FAIL_COND_V(p_x >= p_width, 0);
 
-	ERR_FAIL_COND_V(!is_po2(p_height),0);
-	ERR_FAIL_COND_V(!is_po2(p_width),0);
+	ERR_FAIL_COND_V(!is_po2(p_height), 0);
+	ERR_FAIL_COND_V(!is_po2(p_width), 0);
 
-	if(p_height < p_width) {
+	if (p_height < p_width) {
 		min_dimension = p_height;
-		max_value	 = p_x;
+		max_value = p_x;
 	} else {
 		min_dimension = p_width;
-		max_value	 = p_y;
+		max_value = p_y;
 	}
 
-	if(disable_twiddling)
-		return (p_y* p_width + p_x);
+	if (disable_twiddling)
+		return (p_y * p_width + p_x);
 
 	scr_bit_pos = 1;
 	dst_bit_pos = 1;
-	twiddled  = 0;
+	twiddled = 0;
 	shift_count = 0;
 
-	while(scr_bit_pos < min_dimension) {
-		if(p_y & scr_bit_pos) {
+	while (scr_bit_pos < min_dimension) {
+		if (p_y & scr_bit_pos) {
 			twiddled |= dst_bit_pos;
 		}
 
-		if(p_x & scr_bit_pos) {
+		if (p_x & scr_bit_pos) {
 			twiddled |= (dst_bit_pos << 1);
 		}
 
 		scr_bit_pos <<= 1;
 		dst_bit_pos <<= 2;
 		shift_count += 1;
-
 	}
 
 	max_value >>= shift_count;
 
-	twiddled |=  (max_value << (2*shift_count));
+	twiddled |= (max_value << (2 * shift_count));
 
 	return twiddled;
 }
 
-static void decompress_pvrtc(PVRTCBlock *p_comp_img, const int p_2bit, const int p_width, const int p_height, const int p_tiled, unsigned char* p_dst) {
+static void decompress_pvrtc(PVRTCBlock *p_comp_img, const int p_2bit, const int p_width, const int p_height, const int p_tiled, unsigned char *p_dst) {
 	int x, y;
 	int i, j;
 
@@ -567,55 +546,50 @@ static void decompress_pvrtc(PVRTCBlock *p_comp_img, const int p_2bit, const int
 	// local neighbourhood of blocks
 	PVRTCBlock *p_blocks[2][2];
 
-	PVRTCBlock *prev[2][2] = {{NULL, NULL}, {NULL, NULL}};
+	PVRTCBlock *prev[2][2] = { { NULL, NULL }, { NULL, NULL } };
 
 	struct
 	{
 		int Reps[2][4];
-	}colors5554[2][2];
-
+	} colors5554[2][2];
 
 	int ASig[4], BSig[4];
 
 	int r_result[4];
 
-	if(p_2bit)
+	if (p_2bit)
 		x_block_size = BLK_X_2BPP;
 	else
 		x_block_size = BLK_X_4BPP;
 
-
 	block_width = MAX(2, p_width / x_block_size);
 	block_height = MAX(2, p_height / BLK_Y_SIZE);
 
-	for(y = 0; y < p_height; y++)
-	{
-		for(x = 0; x < p_width; x++)
-		{
+	for (y = 0; y < p_height; y++) {
+		for (x = 0; x < p_width; x++) {
 
-			block_x = (x - x_block_size/2);
-			blk_y = (y - BLK_Y_SIZE/2);
+			block_x = (x - x_block_size / 2);
+			blk_y = (y - BLK_Y_SIZE / 2);
 
 			block_x = LIMIT_COORD(block_x, p_width, p_tiled);
 			blk_y = LIMIT_COORD(blk_y, p_height, p_tiled);
 
-
 			block_x /= x_block_size;
 			blk_y /= BLK_Y_SIZE;
 
-			block_xp1 = LIMIT_COORD(block_x+1, block_width, p_tiled);
-			blk_yp1 = LIMIT_COORD(blk_y+1, block_height, p_tiled);
+			block_xp1 = LIMIT_COORD(block_x + 1, block_width, p_tiled);
+			blk_yp1 = LIMIT_COORD(blk_y + 1, block_height, p_tiled);
 
-			p_blocks[0][0] = p_comp_img +twiddle_uv(block_height, block_width, blk_y, block_x);
-			p_blocks[0][1] = p_comp_img +twiddle_uv(block_height, block_width, blk_y, block_xp1);
-			p_blocks[1][0] = p_comp_img +twiddle_uv(block_height, block_width, blk_yp1, block_x);
-			p_blocks[1][1] = p_comp_img +twiddle_uv(block_height, block_width, blk_yp1, block_xp1);
+			p_blocks[0][0] = p_comp_img + twiddle_uv(block_height, block_width, blk_y, block_x);
+			p_blocks[0][1] = p_comp_img + twiddle_uv(block_height, block_width, blk_y, block_xp1);
+			p_blocks[1][0] = p_comp_img + twiddle_uv(block_height, block_width, blk_yp1, block_x);
+			p_blocks[1][1] = p_comp_img + twiddle_uv(block_height, block_width, blk_yp1, block_xp1);
 
-			if(memcmp(prev, p_blocks, 4*sizeof(void*)) != 0) {
+			if (memcmp(prev, p_blocks, 4 * sizeof(void *)) != 0) {
 				p_y = 0;
-				for(i = 0; i < 2; i++) {
+				for (i = 0; i < 2; i++) {
 					p_x = 0;
-					for(j = 0; j < 2; j++) {
+					for (j = 0; j < 2; j++) {
 						unpack_5554(p_blocks[i][j], colors5554[i][j].Reps);
 
 						unpack_modulations(
@@ -631,11 +605,9 @@ static void decompress_pvrtc(PVRTCBlock *p_comp_img, const int p_2bit, const int
 					p_y += BLK_Y_SIZE;
 				}
 
-
-				memcpy(prev, p_blocks, 4*sizeof(void*));
+				memcpy(prev, p_blocks, 4 * sizeof(void *));
 			}
 
-
 			interpolate_colors(
 					colors5554[0][0].Reps[0],
 					colors5554[0][1].Reps[0],
@@ -652,28 +624,27 @@ static void decompress_pvrtc(PVRTCBlock *p_comp_img, const int p_2bit, const int
 					p_2bit, x, y,
 					BSig);
 
-			get_modulation_value(x,y, p_2bit, (const int (*)[16])p_modulation, (const int (*)[16])p_modulation_modes,
-							   &Mod, &DoPT);
+			get_modulation_value(x, y, p_2bit, (const int(*)[16])p_modulation, (const int(*)[16])p_modulation_modes,
+					&Mod, &DoPT);
 
-			for(i = 0; i < 4; i++) {
+			for (i = 0; i < 4; i++) {
 				r_result[i] = ASig[i] * 8 + Mod * (BSig[i] - ASig[i]);
 				r_result[i] >>= 3;
 			}
 
-			if(DoPT)
+			if (DoPT)
 				r_result[3] = 0;
 
-
-			u_pos = (x+y*p_width)<<2;
-			p_dst[u_pos+0] = (uint8_t)r_result[0];
-			p_dst[u_pos+1] = (uint8_t)r_result[1];
-			p_dst[u_pos+2] = (uint8_t)r_result[2];
-			p_dst[u_pos+3] = (uint8_t)r_result[3];
+			u_pos = (x + y * p_width) << 2;
+			p_dst[u_pos + 0] = (uint8_t)r_result[0];
+			p_dst[u_pos + 1] = (uint8_t)r_result[1];
+			p_dst[u_pos + 2] = (uint8_t)r_result[2];
+			p_dst[u_pos + 3] = (uint8_t)r_result[3];
 		}
 	}
 }
 
-static void _pvrtc_decompress(Image* p_img) {
+static void _pvrtc_decompress(Image *p_img) {
 
 	/*
 	static void decompress_pvrtc(const void *p_comp_img, const int p_2bit, const int p_width, const int p_height, unsigned char* p_dst) {
@@ -681,19 +652,18 @@ static void _pvrtc_decompress(Image* p_img) {
 	}
 	*/
 
-	ERR_FAIL_COND( p_img->get_format()!=Image::FORMAT_PVRTC2 && p_img->get_format()!=Image::FORMAT_PVRTC2A && p_img->get_format()!=Image::FORMAT_PVRTC4 && p_img->get_format()!=Image::FORMAT_PVRTC4A);
+	ERR_FAIL_COND(p_img->get_format() != Image::FORMAT_PVRTC2 && p_img->get_format() != Image::FORMAT_PVRTC2A && p_img->get_format() != Image::FORMAT_PVRTC4 && p_img->get_format() != Image::FORMAT_PVRTC4A);
 
-	bool _2bit = (p_img->get_format()==Image::FORMAT_PVRTC2 || p_img->get_format()==Image::FORMAT_PVRTC2A );
+	bool _2bit = (p_img->get_format() == Image::FORMAT_PVRTC2 || p_img->get_format() == Image::FORMAT_PVRTC2A);
 
 	PoolVector<uint8_t> data = p_img->get_data();
 	PoolVector<uint8_t>::Read r = data.read();
 
-
 	PoolVector<uint8_t> newdata;
-	newdata.resize( p_img->get_width() * p_img->get_height() * 4);
-	PoolVector<uint8_t>::Write w=newdata.write();
+	newdata.resize(p_img->get_width() * p_img->get_height() * 4);
+	PoolVector<uint8_t>::Write w = newdata.write();
 
-	decompress_pvrtc((PVRTCBlock*)r.ptr(),_2bit,p_img->get_width(),p_img->get_height(),0,(unsigned char*)w.ptr());
+	decompress_pvrtc((PVRTCBlock *)r.ptr(), _2bit, p_img->get_width(), p_img->get_height(), 0, (unsigned char *)w.ptr());
 
 	/*
 	for(int i=0;i<newdata.size();i++) {
@@ -701,21 +671,12 @@ static void _pvrtc_decompress(Image* p_img) {
 	}
 	*/
 
-	w=PoolVector<uint8_t>::Write();
-	r=PoolVector<uint8_t>::Read();
+	w = PoolVector<uint8_t>::Write();
+	r = PoolVector<uint8_t>::Read();
 
-	bool make_mipmaps=p_img->has_mipmaps();
-	Image newimg(p_img->get_width(),p_img->get_height(),false,Image::FORMAT_RGBA8,newdata);
+	bool make_mipmaps = p_img->has_mipmaps();
+	Image newimg(p_img->get_width(), p_img->get_height(), false, Image::FORMAT_RGBA8, newdata);
 	if (make_mipmaps)
 		newimg.generate_mipmaps();
-	*p_img=newimg;
-
+	*p_img = newimg;
 }
-
-
-
-
-
-
-
-
diff --git a/modules/pvr/texture_loader_pvr.h b/modules/pvr/texture_loader_pvr.h
index bad48b4569..768070ee61 100644
--- a/modules/pvr/texture_loader_pvr.h
+++ b/modules/pvr/texture_loader_pvr.h
@@ -29,22 +29,18 @@
 #ifndef TEXTURE_LOADER_PVR_H
 #define TEXTURE_LOADER_PVR_H
 
-
-#include "scene/resources/texture.h"
 #include "io/resource_loader.h"
+#include "scene/resources/texture.h"
 
-
-class ResourceFormatPVR : public ResourceFormatLoader{
+class ResourceFormatPVR : public ResourceFormatLoader {
 public:
-
-	virtual RES load(const String &p_path,const String& p_original_path,Error *r_error=NULL);
+	virtual RES load(const String &p_path, const String &p_original_path, Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual bool handles_type(const String& p_type) const;
+	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;
 
 	ResourceFormatPVR();
 	virtual ~ResourceFormatPVR() {}
 };
 
-
 #endif // TEXTURE_LOADER_PVR_H
diff --git a/modules/regex/regex.cpp b/modules/regex/regex.cpp
index 3d1dd048a8..e8fed382b5 100644
--- a/modules/regex/regex.cpp
+++ b/modules/regex/regex.cpp
@@ -28,11 +28,10 @@
 /*************************************************************************/
 
 #include "regex.h"
-#include <wctype.h>
 #include <wchar.h>
+#include <wctype.h>
 
-static int RegEx_hex2int(const CharType c)
-{
+static int RegEx_hex2int(const CharType c) {
 	if ('0' <= c && c <= '9')
 		return int(c - '0');
 	else if ('a' <= c && c <= 'f')
@@ -45,7 +44,7 @@ static int RegEx_hex2int(const CharType c)
 struct RegExSearch {
 
 	Ref<RegExMatch> match;
-	const CharType* str;
+	const CharType *str;
 	int end;
 	int eof;
 
@@ -63,7 +62,8 @@ struct RegExSearch {
 		return str[p_pos];
 	}
 
-	RegExSearch(Ref<RegExMatch>& p_match, int p_end, int p_lookahead) : match(p_match) {
+	RegExSearch(Ref<RegExMatch> &p_match, int p_end, int p_lookahead)
+		: match(p_match) {
 
 		str = p_match->string.c_str();
 		end = p_end;
@@ -71,14 +71,13 @@ struct RegExSearch {
 		complete = false;
 		lookahead_pos.resize(p_lookahead);
 	}
-
 };
 
 struct RegExNode {
 
-	RegExNode* next;
-	RegExNode* previous;
-	RegExNode* parent;
+	RegExNode *next;
+	RegExNode *previous;
+	RegExNode *parent;
 	bool quantifiable;
 	int length;
 
@@ -100,12 +99,12 @@ struct RegExNode {
 	// For avoiding RTTI
 	virtual bool is_look_behind() { return false; }
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		return next ? next->test(s, pos) : -1;
 	}
 
-	virtual int test_parent(RegExSearch& s, int pos) const {
+	virtual int test_parent(RegExSearch &s, int pos) const {
 
 		if (next)
 			pos = next->test(s, pos);
@@ -135,9 +134,7 @@ struct RegExNode {
 
 		if (parent)
 			parent->increment_length(amount, subtract);
-
 	}
-
 };
 
 struct RegExNodeChar : public RegExNode {
@@ -151,7 +148,7 @@ struct RegExNodeChar : public RegExNode {
 		ch = p_char;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		if (s.end <= pos || 0 > pos || s.at(pos) != ch)
 			return -1;
@@ -159,7 +156,7 @@ struct RegExNodeChar : public RegExNode {
 		return next ? next->test(s, pos + 1) : pos + 1;
 	}
 
-	static CharType parse_escape(const CharType*& c) {
+	static CharType parse_escape(const CharType *&c) {
 
 		int point = 0;
 		switch (c[1]) {
@@ -209,7 +206,7 @@ struct RegExNodeRange : public RegExNode {
 		end = p_end;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		if (s.end <= pos || 0 > pos)
 			return -1;
@@ -233,7 +230,7 @@ struct RegExNodeShorthand : public RegExNode {
 		repr = p_repr;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		if (s.end <= pos || 0 > pos)
 			return -1;
@@ -351,7 +348,7 @@ struct RegExNodeClass : public RegExNode {
 		type = p_type;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		if (s.end <= pos || 0 > pos)
 			return -1;
@@ -362,9 +359,10 @@ struct RegExNodeClass : public RegExNode {
 		return next ? next->test(s, pos + 1) : pos + 1;
 	}
 
-#define REGEX_CMP_CLASS(POS, NAME) if (cmp_class(POS, #NAME)) return Type_ ## NAME
+#define REGEX_CMP_CLASS(POS, NAME) \
+	if (cmp_class(POS, #NAME)) return Type_##NAME
 
-	static Type parse_type(const CharType*& p_pos) {
+	static Type parse_type(const CharType *&p_pos) {
 
 		REGEX_CMP_CLASS(p_pos, alnum);
 		REGEX_CMP_CLASS(p_pos, alpha);
@@ -383,7 +381,7 @@ struct RegExNodeClass : public RegExNode {
 		return Type_none;
 	}
 
-	static bool cmp_class(const CharType*& p_pos, const char* p_text) {
+	static bool cmp_class(const CharType *&p_pos, const char *p_text) {
 
 		unsigned int i = 0;
 		for (i = 0; p_text[i] != '\0'; ++i)
@@ -405,7 +403,7 @@ struct RegExNodeAnchorStart : public RegExNode {
 		length = 0;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		if (pos != 0)
 			return -1;
@@ -421,7 +419,7 @@ struct RegExNodeAnchorEnd : public RegExNode {
 		length = 0;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		if (pos != s.eof)
 			return -1;
@@ -440,7 +438,7 @@ struct RegExNodeWordBoundary : public RegExNode {
 		inverse = p_inverse;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		bool left = false;
 		bool right = false;
@@ -469,7 +467,7 @@ struct RegExNodeQuantifier : public RegExNode {
 	int min;
 	int max;
 	bool greedy;
-	RegExNode* child;
+	RegExNode *child;
 
 	RegExNodeQuantifier(int p_min, int p_max) {
 
@@ -485,18 +483,18 @@ struct RegExNodeQuantifier : public RegExNode {
 			memdelete(child);
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		return test_step(s, pos, 0, pos);
 	}
 
-	virtual int test_parent(RegExSearch& s, int pos) const {
+	virtual int test_parent(RegExSearch &s, int pos) const {
 
 		s.complete = false;
 		return pos;
 	}
 
-	int test_step(RegExSearch& s, int pos, int level, int start) const {
+	int test_step(RegExSearch &s, int pos, int level, int start) const {
 
 		if (pos > s.end)
 			return -1;
@@ -554,9 +552,9 @@ struct RegExNodeBackReference : public RegExNode {
 		id = p_id;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
-		RegExMatch::Group& ref = s.match->captures[id];
+		RegExMatch::Group &ref = s.match->captures[id];
 		for (int i = 0; i < ref.length; ++i) {
 
 			if (pos + i >= s.end)
@@ -569,13 +567,12 @@ struct RegExNodeBackReference : public RegExNode {
 	}
 };
 
-
 struct RegExNodeGroup : public RegExNode {
 
 	bool inverse;
 	bool reset_pos;
-	Vector<RegExNode*> childset;
-	RegExNode* back;
+	Vector<RegExNode *> childset;
+	RegExNode *back;
 
 	RegExNodeGroup() {
 
@@ -592,7 +589,7 @@ struct RegExNodeGroup : public RegExNode {
 			memdelete(childset[i]);
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		for (int i = 0; i < childset.size(); ++i) {
 
@@ -622,7 +619,7 @@ struct RegExNodeGroup : public RegExNode {
 		return -1;
 	}
 
-	void add_child(RegExNode* node) {
+	void add_child(RegExNode *node) {
 
 		node->parent = this;
 		node->previous = back;
@@ -644,9 +641,9 @@ struct RegExNodeGroup : public RegExNode {
 		back = NULL;
 	}
 
-	RegExNode* swap_back(RegExNode* node) {
+	RegExNode *swap_back(RegExNode *node) {
 
-		RegExNode* old = back;
+		RegExNode *old = back;
 
 		if (old) {
 			if (!old->previous)
@@ -670,9 +667,9 @@ struct RegExNodeCapturing : public RegExNodeGroup {
 		id = p_id;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
-		RegExMatch::Group& ref = s.match->captures[id];
+		RegExMatch::Group &ref = s.match->captures[id];
 		int old_start = ref.start;
 		ref.start = pos;
 
@@ -688,14 +685,14 @@ struct RegExNodeCapturing : public RegExNodeGroup {
 		return res;
 	}
 
-	virtual int test_parent(RegExSearch& s, int pos) const {
+	virtual int test_parent(RegExSearch &s, int pos) const {
 
-		RegExMatch::Group& ref = s.match->captures[id];
+		RegExMatch::Group &ref = s.match->captures[id];
 		ref.length = pos - ref.start;
 		return RegExNode::test_parent(s, pos);
 	}
 
-	static Variant parse_name(const CharType*& c, bool p_allow_numeric) {
+	static Variant parse_name(const CharType *&c, bool p_allow_numeric) {
 
 		if (c[1] == '0') {
 			return -1;
@@ -732,13 +729,13 @@ struct RegExNodeLookAhead : public RegExNodeGroup {
 		id = p_id;
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		s.lookahead_pos[id] = pos;
 		return RegExNodeGroup::test(s, pos);
 	}
 
-	virtual int test_parent(RegExSearch& s, int pos) const {
+	virtual int test_parent(RegExSearch &s, int pos) const {
 
 		return RegExNode::test_parent(s, s.lookahead_pos[id]);
 	}
@@ -755,7 +752,7 @@ struct RegExNodeLookBehind : public RegExNodeGroup {
 
 	virtual bool is_look_behind() { return true; }
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		if (pos < length)
 			return -1;
@@ -766,7 +763,7 @@ struct RegExNodeLookBehind : public RegExNodeGroup {
 struct RegExNodeBracket : public RegExNode {
 
 	bool inverse;
-	Vector<RegExNode*> children;
+	Vector<RegExNode *> children;
 
 	RegExNodeBracket() {
 
@@ -781,7 +778,7 @@ struct RegExNodeBracket : public RegExNode {
 			memdelete(children[i]);
 	}
 
-	virtual int test(RegExSearch& s, int pos) const {
+	virtual int test(RegExSearch &s, int pos) const {
 
 		for (int i = 0; i < children.size(); ++i) {
 
@@ -803,7 +800,7 @@ struct RegExNodeBracket : public RegExNode {
 		return -1;
 	}
 
-	void add_child(RegExNode* node) {
+	void add_child(RegExNode *node) {
 
 		node->parent = this;
 		children.push_back(node);
@@ -816,16 +813,16 @@ struct RegExNodeBracket : public RegExNode {
 	}
 };
 
-#define REGEX_EXPAND_FAIL(MSG)\
-{\
-	ERR_PRINT(MSG);\
-	return String();\
-}
+#define REGEX_EXPAND_FAIL(MSG) \
+	{                          \
+		ERR_PRINT(MSG);        \
+		return String();       \
+	}
 
-String RegExMatch::expand(const String& p_template) const {
+String RegExMatch::expand(const String &p_template) const {
 
 	String res;
-	for (const CharType* c = p_template.c_str(); *c != '\0'; ++c) {
+	for (const CharType *c = p_template.c_str(); *c != '\0'; ++c) {
 		if (c[0] == '\\') {
 			if (('1' <= c[1] && c[1] <= '9') || (c[1] == 'g' && c[2] == '{')) {
 
@@ -850,9 +847,9 @@ String RegExMatch::expand(const String& p_template) const {
 
 				res += get_string(ref);
 
-			} else if (c[1] =='g' && c[2] == '<') {
+			} else if (c[1] == 'g' && c[2] == '<') {
 
-				const CharType* d = &c[2];
+				const CharType *d = &c[2];
 
 				Variant name = RegExNodeCapturing::parse_name(d, true);
 				if (name == Variant(-1))
@@ -864,7 +861,7 @@ String RegExMatch::expand(const String& p_template) const {
 
 			} else {
 
-				const CharType* d = c;
+				const CharType *d = c;
 				CharType ch = RegExNodeChar::parse_escape(d);
 				if (c == d)
 					REGEX_EXPAND_FAIL("invalid escape token");
@@ -891,7 +888,7 @@ Array RegExMatch::get_group_array() const {
 
 	Array res;
 	for (int i = 1; i < captures.size(); ++i) {
-		const RegExMatch::Group& capture = captures[i];
+		const RegExMatch::Group &capture = captures[i];
 		if (capture.name.get_type() != Variant::INT)
 			continue;
 
@@ -916,7 +913,7 @@ Dictionary RegExMatch::get_name_dict() const {
 
 	Dictionary res;
 	for (int i = 1; i < captures.size(); ++i) {
-		const RegExMatch::Group& capture = captures[i];
+		const RegExMatch::Group &capture = captures[i];
 		if (capture.name.get_type() != Variant::STRING)
 			continue;
 
@@ -928,11 +925,11 @@ Dictionary RegExMatch::get_name_dict() const {
 	return res;
 }
 
-String RegExMatch::get_string(const Variant& p_name) const {
+String RegExMatch::get_string(const Variant &p_name) const {
 
 	for (int i = 0; i < captures.size(); ++i) {
 
-		const RegExMatch::Group& capture = captures[i];
+		const RegExMatch::Group &capture = captures[i];
 
 		if (capture.name != p_name)
 			continue;
@@ -945,7 +942,7 @@ String RegExMatch::get_string(const Variant& p_name) const {
 	return String();
 }
 
-int RegExMatch::get_start(const Variant& p_name) const {
+int RegExMatch::get_start(const Variant &p_name) const {
 
 	for (int i = 0; i < captures.size(); ++i)
 		if (captures[i].name == p_name)
@@ -953,7 +950,7 @@ int RegExMatch::get_start(const Variant& p_name) const {
 	return -1;
 }
 
-int RegExMatch::get_end(const Variant& p_name) const {
+int RegExMatch::get_end(const Variant &p_name) const {
 
 	for (int i = 0; i < captures.size(); ++i)
 		if (captures[i].name == p_name)
@@ -962,7 +959,6 @@ int RegExMatch::get_end(const Variant& p_name) const {
 }
 
 RegExMatch::RegExMatch() {
-
 }
 
 static bool RegEx_is_shorthand(CharType ch) {
@@ -981,14 +977,14 @@ static bool RegEx_is_shorthand(CharType ch) {
 	return false;
 }
 
-#define REGEX_COMPILE_FAIL(MSG)\
-{\
-	ERR_PRINT(MSG);\
-	clear();\
-	return FAILED;\
-}
+#define REGEX_COMPILE_FAIL(MSG) \
+	{                           \
+		ERR_PRINT(MSG);         \
+		clear();                \
+		return FAILED;          \
+	}
 
-Error RegEx::compile(const String& p_pattern) {
+Error RegEx::compile(const String &p_pattern) {
 
 	ERR_FAIL_COND_V(p_pattern.length() == 0, FAILED);
 
@@ -998,21 +994,21 @@ Error RegEx::compile(const String& p_pattern) {
 	clear();
 	pattern = p_pattern;
 	group_names.push_back(0);
-	RegExNodeGroup* root_group = memnew(RegExNodeCapturing(0));
+	RegExNodeGroup *root_group = memnew(RegExNodeCapturing(0));
 	root = root_group;
-	Vector<RegExNodeGroup*> stack;
+	Vector<RegExNodeGroup *> stack;
 	stack.push_back(root_group);
 	int lookahead_level = 0;
 	int numeric_groups = 0;
 	const int numeric_max = 9;
 
-	for (const CharType* c = p_pattern.c_str(); *c != '\0'; ++c) {
+	for (const CharType *c = p_pattern.c_str(); *c != '\0'; ++c) {
 
 		switch (c[0]) {
 			case '(':
 				if (c[1] == '?') {
 
-					RegExNodeGroup* group = NULL;
+					RegExNodeGroup *group = NULL;
 					switch (c[2]) {
 						case ':':
 							c = &c[2];
@@ -1033,7 +1029,7 @@ Error RegEx::compile(const String& p_pattern) {
 							break;
 						case 'P':
 							if (c[3] == '<') {
-								const CharType* d = &c[3];
+								const CharType *d = &c[3];
 								Variant name = RegExNodeCapturing::parse_name(d, false);
 								if (name == Variant(-1))
 									REGEX_COMPILE_FAIL("unrecognised character for group name");
@@ -1051,14 +1047,14 @@ Error RegEx::compile(const String& p_pattern) {
 
 				} else if (numeric_groups < numeric_max) {
 
-					RegExNodeCapturing* group = memnew(RegExNodeCapturing(group_names.size()));
+					RegExNodeCapturing *group = memnew(RegExNodeCapturing(group_names.size()));
 					group_names.push_back(++numeric_groups);
 					stack[0]->add_child(group);
 					stack.insert(0, group);
 
 				} else {
 
-					RegExNodeGroup* group = memnew(RegExNodeGroup());
+					RegExNodeGroup *group = memnew(RegExNodeGroup());
 					stack[0]->add_child(group);
 					stack.insert(0, group);
 				}
@@ -1105,10 +1101,10 @@ Error RegEx::compile(const String& p_pattern) {
 					}
 
 					stack[0]->add_child(memnew(RegExNodeBackReference(ref)));
+				}
+				if (c[1] == 'g' && c[2] == '<') {
 
-				} if (c[1] =='g' && c[2] == '<') {
-
-					const CharType* d = &c[2];
+					const CharType *d = &c[2];
 
 					Variant name = RegExNodeCapturing::parse_name(d, true);
 					if (name == Variant(-1))
@@ -1144,103 +1140,100 @@ Error RegEx::compile(const String& p_pattern) {
 
 				} else {
 
-					const CharType* d = c;
+					const CharType *d = c;
 					CharType ch = RegExNodeChar::parse_escape(d);
 					if (c == d)
 						REGEX_COMPILE_FAIL("invalid escape token");
 					stack[0]->add_child(memnew(RegExNodeChar(ch)));
 					c = d;
-
 				}
 				break;
-			case '[':
-				{
-					RegExNodeBracket* bracket = memnew(RegExNodeBracket());
-					stack[0]->add_child(bracket);
-					if (c[1] == '^') {
-						bracket->inverse = true;
-						++c;
-					}
-					bool first_child = true;
-					CharType previous_child;
-					bool previous_child_single = false;
-					while (true) {
-						++c;
-						if (!first_child && c[0] == ']') {
+			case '[': {
+				RegExNodeBracket *bracket = memnew(RegExNodeBracket());
+				stack[0]->add_child(bracket);
+				if (c[1] == '^') {
+					bracket->inverse = true;
+					++c;
+				}
+				bool first_child = true;
+				CharType previous_child;
+				bool previous_child_single = false;
+				while (true) {
+					++c;
+					if (!first_child && c[0] == ']') {
 
-							break;
+						break;
 
-						} else if (c[0] == '\0') {
+					} else if (c[0] == '\0') {
 
-							REGEX_COMPILE_FAIL("unclosed bracket expression '['");
+						REGEX_COMPILE_FAIL("unclosed bracket expression '['");
 
-						} else if (c[0] == '\\') {
+					} else if (c[0] == '\\') {
 
-							if (RegEx_is_shorthand(c[1])) {
-								bracket->add_child(memnew(RegExNodeShorthand(*(++c))));
-							} else {
-								const CharType* d = c;
-								CharType ch = RegExNodeChar::parse_escape(d);
-								if (c == d)
-									REGEX_COMPILE_FAIL("invalid escape token");
-								bracket->add_child(memnew(RegExNodeChar(ch)));
-								c = d;
-								previous_child = ch;
-								previous_child_single = true;
-							}
-
-						} else if (c[0] == ']' && c[1] == ':') {
-
-							const CharType* d = &c[2];
-							RegExNodeClass::Type type = RegExNodeClass::parse_type(d);
-							if (type != RegExNodeClass::Type_none) {
+						if (RegEx_is_shorthand(c[1])) {
+							bracket->add_child(memnew(RegExNodeShorthand(*(++c))));
+						} else {
+							const CharType *d = c;
+							CharType ch = RegExNodeChar::parse_escape(d);
+							if (c == d)
+								REGEX_COMPILE_FAIL("invalid escape token");
+							bracket->add_child(memnew(RegExNodeChar(ch)));
+							c = d;
+							previous_child = ch;
+							previous_child_single = true;
+						}
 
-								c = d;
-								previous_child_single = false;
+					} else if (c[0] == ']' && c[1] == ':') {
 
-							} else {
+						const CharType *d = &c[2];
+						RegExNodeClass::Type type = RegExNodeClass::parse_type(d);
+						if (type != RegExNodeClass::Type_none) {
 
-								bracket->add_child(memnew(RegExNodeChar('[')));
-								previous_child = '[';
-								previous_child_single = true;
-							}
-						} else if (previous_child_single && c[0] == '-') {
+							c = d;
+							previous_child_single = false;
 
-							if (c[1] != '\0' && c[1] != ']') {
+						} else {
 
-								CharType next;
+							bracket->add_child(memnew(RegExNodeChar('[')));
+							previous_child = '[';
+							previous_child_single = true;
+						}
+					} else if (previous_child_single && c[0] == '-') {
 
-								if (c[1] == '\\') {
-									const CharType* d = ++c;
-									next = RegExNodeChar::parse_escape(d);
-									if (c == d)
-										REGEX_COMPILE_FAIL("invalid escape token");
-								} else {
-									next = *(++c);
-								}
+						if (c[1] != '\0' && c[1] != ']') {
 
-								if (next < previous_child)
-									REGEX_COMPILE_FAIL("text range out of order");
+							CharType next;
 
-								bracket->pop_back();
-								bracket->add_child(memnew(RegExNodeRange(previous_child, next)));
-								previous_child_single = false;
+							if (c[1] == '\\') {
+								const CharType *d = ++c;
+								next = RegExNodeChar::parse_escape(d);
+								if (c == d)
+									REGEX_COMPILE_FAIL("invalid escape token");
 							} else {
-
-								bracket->add_child(memnew(RegExNodeChar('-')));
-								previous_child = '-';
-								previous_child_single = true;
+								next = *(++c);
 							}
+
+							if (next < previous_child)
+								REGEX_COMPILE_FAIL("text range out of order");
+
+							bracket->pop_back();
+							bracket->add_child(memnew(RegExNodeRange(previous_child, next)));
+							previous_child_single = false;
 						} else {
 
-							bracket->add_child(memnew(RegExNodeChar(c[0])));
-							previous_child = c[0];
+							bracket->add_child(memnew(RegExNodeChar('-')));
+							previous_child = '-';
 							previous_child_single = true;
 						}
-						first_child = false;
+					} else {
+
+						bracket->add_child(memnew(RegExNodeChar(c[0])));
+						previous_child = c[0];
+						previous_child_single = true;
 					}
+					first_child = false;
 				}
-				break;
+			} break;
 			case '|':
 				for (int i = 0; i < stack.size(); ++i)
 					if (stack[i]->is_look_behind())
@@ -1259,82 +1252,81 @@ Error RegEx::compile(const String& p_pattern) {
 			case '?':
 			case '*':
 			case '+':
-			case '{':
-				{
-					int min_val = 0;
-					int max_val = -1;
-					bool valid = true;
-					const CharType* d = c;
-					bool max_set = true;
-					switch (c[0]) {
-						case '?':
-							min_val = 0;
-							max_val = 1;
-							break;
-						case '*':
-							min_val = 0;
-							max_val = -1;
-							break;
-						case '+':
-							min_val = 1;
-							max_val = -1;
-							break;
-						case '{':
-							max_set = false;
-							while (valid) {
-								++d;
-								if (d[0] == '}') {
-									break;
-								} else if (d[0] == ',') {
-									max_set = true;
-								} else if ('0' <= d[0] && d[0] <= '9') {
-									if (max_set) {
-										if (max_val < 0)
-											max_val = int(d[0] - '0');
-										else
-											max_val = max_val * 10 + int(d[0] - '0');
-									} else {
-										min_val = min_val * 10 + int(d[0] - '0');
-									}
+			case '{': {
+				int min_val = 0;
+				int max_val = -1;
+				bool valid = true;
+				const CharType *d = c;
+				bool max_set = true;
+				switch (c[0]) {
+					case '?':
+						min_val = 0;
+						max_val = 1;
+						break;
+					case '*':
+						min_val = 0;
+						max_val = -1;
+						break;
+					case '+':
+						min_val = 1;
+						max_val = -1;
+						break;
+					case '{':
+						max_set = false;
+						while (valid) {
+							++d;
+							if (d[0] == '}') {
+								break;
+							} else if (d[0] == ',') {
+								max_set = true;
+							} else if ('0' <= d[0] && d[0] <= '9') {
+								if (max_set) {
+									if (max_val < 0)
+										max_val = int(d[0] - '0');
+									else
+										max_val = max_val * 10 + int(d[0] - '0');
 								} else {
-									valid = false;
+									min_val = min_val * 10 + int(d[0] - '0');
 								}
+							} else {
+								valid = false;
 							}
-							break;
-						default:
-							break;
-					}
+						}
+						break;
+					default:
+						break;
+				}
 
-					if (!max_set)
-						max_val = min_val;
+				if (!max_set)
+					max_val = min_val;
 
-					if (valid) {
+				if (valid) {
 
-						c = d;
+					c = d;
 
-						if (stack[0]->back == NULL || !stack[0]->back->quantifiable)
-							REGEX_COMPILE_FAIL("element not quantifiable");
+					if (stack[0]->back == NULL || !stack[0]->back->quantifiable)
+						REGEX_COMPILE_FAIL("element not quantifiable");
 
-						if (min_val != max_val)
-							for (int i = 0; i < stack.size(); ++i)
-								if (stack[i]->is_look_behind())
-									REGEX_COMPILE_FAIL("variable length quantifiers inside lookbehind not supported");
+					if (min_val != max_val)
+						for (int i = 0; i < stack.size(); ++i)
+							if (stack[i]->is_look_behind())
+								REGEX_COMPILE_FAIL("variable length quantifiers inside lookbehind not supported");
 
-						RegExNodeQuantifier* quant = memnew(RegExNodeQuantifier(min_val, max_val));
-						quant->child = stack[0]->swap_back(quant);
-						quant->child->previous = NULL;
-						quant->child->parent = quant;
+					RegExNodeQuantifier *quant = memnew(RegExNodeQuantifier(min_val, max_val));
+					quant->child = stack[0]->swap_back(quant);
+					quant->child->previous = NULL;
+					quant->child->parent = quant;
 
-						if (min_val == max_val && quant->child->length >= 0)
-							quant->length = max_val * quant->child->length;
+					if (min_val == max_val && quant->child->length >= 0)
+						quant->length = max_val * quant->child->length;
 
-						if (c[1] == '?') {
-							quant->greedy = false;
-							++c;
-						}
-						break;
+					if (c[1] == '?') {
+						quant->greedy = false;
+						++c;
 					}
+					break;
 				}
+			}
 			default:
 				stack[0]->add_child(memnew(RegExNodeChar(c[0])));
 				break;
@@ -1345,7 +1337,7 @@ Error RegEx::compile(const String& p_pattern) {
 	return OK;
 }
 
-Ref<RegExMatch> RegEx::search(const String& p_text, int p_start, int p_end) const {
+Ref<RegExMatch> RegEx::search(const String &p_text, int p_start, int p_end) const {
 
 	ERR_FAIL_COND_V(!is_valid(), NULL);
 	ERR_FAIL_COND_V(p_start < 0, NULL);
@@ -1382,7 +1374,7 @@ Ref<RegExMatch> RegEx::search(const String& p_text, int p_start, int p_end) cons
 	return NULL;
 }
 
-String RegEx::sub(const String& p_text, const String& p_replacement, bool p_all, int p_start, int p_end) const {
+String RegEx::sub(const String &p_text, const String &p_replacement, bool p_all, int p_start, int p_end) const {
 
 	ERR_FAIL_COND_V(!is_valid(), p_text);
 	ERR_FAIL_COND_V(p_start < 0, p_text);
@@ -1400,7 +1392,7 @@ String RegEx::sub(const String& p_text, const String& p_replacement, bool p_all,
 
 		Ref<RegExMatch> m = search(text, start, p_end);
 
-		RegExMatch::Group& s = m->captures[0];
+		RegExMatch::Group &s = m->captures[0];
 
 		if (s.start < 0)
 			break;
@@ -1467,7 +1459,7 @@ RegEx::RegEx() {
 	lookahead_depth = 0;
 }
 
-RegEx::RegEx(const String& p_pattern) {
+RegEx::RegEx(const String &p_pattern) {
 
 	root = NULL;
 	compile(p_pattern);
@@ -1481,27 +1473,26 @@ RegEx::~RegEx() {
 
 void RegExMatch::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("expand","template"),&RegExMatch::expand);
-	ClassDB::bind_method(D_METHOD("get_group_count"),&RegExMatch::get_group_count);
-	ClassDB::bind_method(D_METHOD("get_group_array"),&RegExMatch::get_group_array);
-	ClassDB::bind_method(D_METHOD("get_names"),&RegExMatch::get_names);
-	ClassDB::bind_method(D_METHOD("get_name_dict"),&RegExMatch::get_name_dict);
-	ClassDB::bind_method(D_METHOD("get_string","name"),&RegExMatch::get_string, DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("get_start","name"),&RegExMatch::get_start, DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("get_end","name"),&RegExMatch::get_end, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("expand", "template"), &RegExMatch::expand);
+	ClassDB::bind_method(D_METHOD("get_group_count"), &RegExMatch::get_group_count);
+	ClassDB::bind_method(D_METHOD("get_group_array"), &RegExMatch::get_group_array);
+	ClassDB::bind_method(D_METHOD("get_names"), &RegExMatch::get_names);
+	ClassDB::bind_method(D_METHOD("get_name_dict"), &RegExMatch::get_name_dict);
+	ClassDB::bind_method(D_METHOD("get_string", "name"), &RegExMatch::get_string, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_start", "name"), &RegExMatch::get_start, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_end", "name"), &RegExMatch::get_end, DEFVAL(0));
 }
 
 void RegEx::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("clear"),&RegEx::clear);
-	ClassDB::bind_method(D_METHOD("compile","pattern"),&RegEx::compile);
-	ClassDB::bind_method(D_METHOD("search","text","start","end"),&RegEx::search, DEFVAL(0), DEFVAL(-1));
-	ClassDB::bind_method(D_METHOD("sub","text","replacement","all","start","end"),&RegEx::sub, DEFVAL(false), DEFVAL(0), DEFVAL(-1));
-	ClassDB::bind_method(D_METHOD("is_valid"),&RegEx::is_valid);
-	ClassDB::bind_method(D_METHOD("get_pattern"),&RegEx::get_pattern);
-	ClassDB::bind_method(D_METHOD("get_group_count"),&RegEx::get_group_count);
-	ClassDB::bind_method(D_METHOD("get_names"),&RegEx::get_names);
+	ClassDB::bind_method(D_METHOD("clear"), &RegEx::clear);
+	ClassDB::bind_method(D_METHOD("compile", "pattern"), &RegEx::compile);
+	ClassDB::bind_method(D_METHOD("search", "text", "start", "end"), &RegEx::search, DEFVAL(0), DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("sub", "text", "replacement", "all", "start", "end"), &RegEx::sub, DEFVAL(false), DEFVAL(0), DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("is_valid"), &RegEx::is_valid);
+	ClassDB::bind_method(D_METHOD("get_pattern"), &RegEx::get_pattern);
+	ClassDB::bind_method(D_METHOD("get_group_count"), &RegEx::get_group_count);
+	ClassDB::bind_method(D_METHOD("get_names"), &RegEx::get_names);
 
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "pattern"), "compile", "get_pattern");
 }
-
diff --git a/modules/regex/regex.h b/modules/regex/regex.h
index 193d818da3..7aecf9b3ec 100644
--- a/modules/regex/regex.h
+++ b/modules/regex/regex.h
@@ -30,11 +30,11 @@
 #ifndef REGEX_H
 #define REGEX_H
 
-#include "core/vector.h"
-#include "core/ustring.h"
 #include "core/dictionary.h"
 #include "core/reference.h"
 #include "core/resource.h"
+#include "core/ustring.h"
+#include "core/vector.h"
 
 class RegExNode;
 
@@ -57,12 +57,10 @@ class RegExMatch : public Reference {
 	friend class RegExNodeBackReference;
 
 protected:
-
 	static void _bind_methods();
 
 public:
-
-	String expand(const String& p_template) const;
+	String expand(const String &p_template) const;
 
 	int get_group_count() const;
 	Array get_group_array() const;
@@ -70,34 +68,31 @@ public:
 	Array get_names() const;
 	Dictionary get_name_dict() const;
 
-	String get_string(const Variant& p_name) const;
-	int get_start(const Variant& p_name) const;
-	int get_end(const Variant& p_name) const;
+	String get_string(const Variant &p_name) const;
+	int get_start(const Variant &p_name) const;
+	int get_end(const Variant &p_name) const;
 
 	RegExMatch();
-
 };
 
 class RegEx : public Resource {
 
 	GDCLASS(RegEx, Resource);
 
-	RegExNode* root;
+	RegExNode *root;
 	Vector<Variant> group_names;
 	String pattern;
 	int lookahead_depth;
 
 protected:
-
 	static void _bind_methods();
 
 public:
-
 	void clear();
-	Error compile(const String& p_pattern);
+	Error compile(const String &p_pattern);
 
-	Ref<RegExMatch> search(const String& p_text, int p_start = 0, int p_end = -1) const;
-	String sub(const String& p_text, const String& p_replacement, bool p_all = false, int p_start = 0, int p_end = -1) const;
+	Ref<RegExMatch> search(const String &p_text, int p_start = 0, int p_end = -1) const;
+	String sub(const String &p_text, const String &p_replacement, bool p_all = false, int p_start = 0, int p_end = -1) const;
 
 	bool is_valid() const;
 	String get_pattern() const;
@@ -105,10 +100,8 @@ public:
 	Array get_names() const;
 
 	RegEx();
-	RegEx(const String& p_pattern);
+	RegEx(const String &p_pattern);
 	~RegEx();
-
 };
 
 #endif // REGEX_H
-
diff --git a/modules/regex/register_types.cpp b/modules/regex/register_types.cpp
index c62a04d80f..2e24edcd84 100644
--- a/modules/regex/register_types.cpp
+++ b/modules/regex/register_types.cpp
@@ -38,6 +38,4 @@ void register_regex_types() {
 }
 
 void unregister_regex_types() {
-
 }
-
diff --git a/modules/squish/image_compress_squish.cpp b/modules/squish/image_compress_squish.cpp
index 28c200596b..dd46dac234 100644
--- a/modules/squish/image_compress_squish.cpp
+++ b/modules/squish/image_compress_squish.cpp
@@ -34,58 +34,61 @@
 
 void image_compress_squish(Image *p_image) {
 
-	int w=p_image->get_width();
-	int h=p_image->get_height();
+	int w = p_image->get_width();
+	int h = p_image->get_height();
 
-	if (!p_image->has_mipmaps() ) {
-		ERR_FAIL_COND( !w || w % 4 != 0);
-		ERR_FAIL_COND( !h || h % 4 != 0);
+	if (!p_image->has_mipmaps()) {
+		ERR_FAIL_COND(!w || w % 4 != 0);
+		ERR_FAIL_COND(!h || h % 4 != 0);
 	} else {
-		ERR_FAIL_COND( !w || w !=nearest_power_of_2(w) );
-		ERR_FAIL_COND( !h || h !=nearest_power_of_2(h) );
+		ERR_FAIL_COND(!w || w != nearest_power_of_2(w));
+		ERR_FAIL_COND(!h || h != nearest_power_of_2(h));
 	};
 
-	if (p_image->get_format()>=Image::FORMAT_DXT1)
+	if (p_image->get_format() >= Image::FORMAT_DXT1)
 		return; //do not compress, already compressed
 
-	int shift=0;
-	int squish_comp=squish::kColourRangeFit;
+	int shift = 0;
+	int squish_comp = squish::kColourRangeFit;
 	Image::Format target_format;
 
-	if (p_image->get_format()==Image::FORMAT_LA8) {
+	if (p_image->get_format() == Image::FORMAT_LA8) {
 		//compressed normalmap
-		target_format = Image::FORMAT_DXT5; squish_comp|=squish::kDxt5;
-	} else if (p_image->detect_alpha()!=Image::ALPHA_NONE) {
+		target_format = Image::FORMAT_DXT5;
+		squish_comp |= squish::kDxt5;
+	} else if (p_image->detect_alpha() != Image::ALPHA_NONE) {
 
-		target_format = Image::FORMAT_DXT3; squish_comp|=squish::kDxt3;
+		target_format = Image::FORMAT_DXT3;
+		squish_comp |= squish::kDxt3;
 	} else {
-		target_format = Image::FORMAT_DXT1; shift=1; squish_comp|=squish::kDxt1;
+		target_format = Image::FORMAT_DXT1;
+		shift = 1;
+		squish_comp |= squish::kDxt1;
 	}
 
 	p_image->convert(Image::FORMAT_RGBA8); //always expects rgba
 
 	PoolVector<uint8_t> data;
-	int target_size = Image::get_image_data_size(w,h,target_format,p_image->has_mipmaps()?-1:0);
-	int mm_count = p_image->has_mipmaps() ? Image::get_image_required_mipmaps(w,h,target_format) : 0;
+	int target_size = Image::get_image_data_size(w, h, target_format, p_image->has_mipmaps() ? -1 : 0);
+	int mm_count = p_image->has_mipmaps() ? Image::get_image_required_mipmaps(w, h, target_format) : 0;
 	data.resize(target_size);
 
 	PoolVector<uint8_t>::Read rb = p_image->get_data().read();
 	PoolVector<uint8_t>::Write wb = data.write();
 
-	int dst_ofs=0;
+	int dst_ofs = 0;
 
-	for(int i=0;i<=mm_count;i++) {
+	for (int i = 0; i <= mm_count; i++) {
 
 		int src_ofs = p_image->get_mipmap_offset(i);
-		squish::CompressImage( &rb[src_ofs],w,h,&wb[dst_ofs],squish_comp);
-		dst_ofs+=(MAX(4,w)*MAX(4,h))>>shift;
-		w>>=1;
-		h>>=1;
+		squish::CompressImage(&rb[src_ofs], w, h, &wb[dst_ofs], squish_comp);
+		dst_ofs += (MAX(4, w) * MAX(4, h)) >> shift;
+		w >>= 1;
+		h >>= 1;
 	}
 
 	rb = PoolVector<uint8_t>::Read();
 	wb = PoolVector<uint8_t>::Write();
 
-	p_image->create(p_image->get_width(),p_image->get_height(),p_image->has_mipmaps(),target_format,data);
-
+	p_image->create(p_image->get_width(), p_image->get_height(), p_image->has_mipmaps(), target_format, data);
 }
diff --git a/modules/stb_vorbis/audio_stream_ogg_vorbis.cpp b/modules/stb_vorbis/audio_stream_ogg_vorbis.cpp
index d3d7ab2307..884eb905fa 100644
--- a/modules/stb_vorbis/audio_stream_ogg_vorbis.cpp
+++ b/modules/stb_vorbis/audio_stream_ogg_vorbis.cpp
@@ -28,20 +28,19 @@
 /*************************************************************************/
 #include "audio_stream_ogg_vorbis.h"
 
-#include "thirdparty/stb_vorbis/stb_vorbis.c"
 #include "os/file_access.h"
+#include "thirdparty/stb_vorbis/stb_vorbis.c"
 
-
-void AudioStreamPlaybackOGGVorbis::_mix_internal(AudioFrame* p_buffer,int p_frames) {
+void AudioStreamPlaybackOGGVorbis::_mix_internal(AudioFrame *p_buffer, int p_frames) {
 
 	ERR_FAIL_COND(!active);
 
-	int todo=p_frames;
+	int todo = p_frames;
 
-	while(todo) {
+	while (todo) {
 
-		int mixed = stb_vorbis_get_samples_float_interleaved(ogg_stream,2,(float*)p_buffer,todo*2);
-		todo-=mixed;
+		int mixed = stb_vorbis_get_samples_float_interleaved(ogg_stream, 2, (float *)p_buffer, todo * 2);
+		todo -= mixed;
 
 		if (todo) {
 			//end of file!
@@ -50,15 +49,13 @@ void AudioStreamPlaybackOGGVorbis::_mix_internal(AudioFrame* p_buffer,int p_fram
 				seek_pos(0);
 				loops++;
 			} else {
-				for(int i=mixed;i<p_frames;i++) {
-					p_buffer[i]=AudioFrame(0,0);
+				for (int i = mixed; i < p_frames; i++) {
+					p_buffer[i] = AudioFrame(0, 0);
 				}
-				active=false;
+				active = false;
 			}
 		}
 	}
-
-
 }
 
 float AudioStreamPlaybackOGGVorbis::get_stream_sampling_rate() {
@@ -66,20 +63,17 @@ float AudioStreamPlaybackOGGVorbis::get_stream_sampling_rate() {
 	return vorbis_stream->sample_rate;
 }
 
-
 void AudioStreamPlaybackOGGVorbis::start(float p_from_pos) {
 
 	seek_pos(p_from_pos);
-	active=true;
-	loops=0;
+	active = true;
+	loops = 0;
 	_begin_resample();
-
-
 }
 
 void AudioStreamPlaybackOGGVorbis::stop() {
 
-	active=false;
+	active = false;
 }
 bool AudioStreamPlaybackOGGVorbis::is_playing() const {
 
@@ -93,14 +87,14 @@ int AudioStreamPlaybackOGGVorbis::get_loop_count() const {
 
 float AudioStreamPlaybackOGGVorbis::get_pos() const {
 
-	return float(frames_mixed)/vorbis_stream->sample_rate;
+	return float(frames_mixed) / vorbis_stream->sample_rate;
 }
 void AudioStreamPlaybackOGGVorbis::seek_pos(float p_time) {
 
 	if (!active)
 		return;
 
-	stb_vorbis_seek(ogg_stream, uint32_t(p_time*vorbis_stream->sample_rate));
+	stb_vorbis_seek(ogg_stream, uint32_t(p_time * vorbis_stream->sample_rate));
 }
 
 float AudioStreamPlaybackOGGVorbis::get_length() const {
@@ -117,27 +111,25 @@ AudioStreamPlaybackOGGVorbis::~AudioStreamPlaybackOGGVorbis() {
 
 Ref<AudioStreamPlayback> AudioStreamOGGVorbis::instance_playback() {
 
-
-
 	Ref<AudioStreamPlaybackOGGVorbis> ovs;
-	printf("instance at %p, data %p\n",this,data);
+	printf("instance at %p, data %p\n", this, data);
 
-	ERR_FAIL_COND_V(data==NULL,ovs);
+	ERR_FAIL_COND_V(data == NULL, ovs);
 
 	ovs.instance();
-	ovs->vorbis_stream=Ref<AudioStreamOGGVorbis>(this);
-	ovs->ogg_alloc.alloc_buffer=(char*)AudioServer::get_singleton()->audio_data_alloc(decode_mem_size);
-	ovs->ogg_alloc.alloc_buffer_length_in_bytes=decode_mem_size;
-	ovs->frames_mixed=0;
-	ovs->active=false;
-	ovs->loops=0;
-	int error ;
-	ovs->ogg_stream = stb_vorbis_open_memory( (const unsigned char*)data, data_len, &error, &ovs->ogg_alloc );
+	ovs->vorbis_stream = Ref<AudioStreamOGGVorbis>(this);
+	ovs->ogg_alloc.alloc_buffer = (char *)AudioServer::get_singleton()->audio_data_alloc(decode_mem_size);
+	ovs->ogg_alloc.alloc_buffer_length_in_bytes = decode_mem_size;
+	ovs->frames_mixed = 0;
+	ovs->active = false;
+	ovs->loops = 0;
+	int error;
+	ovs->ogg_stream = stb_vorbis_open_memory((const unsigned char *)data, data_len, &error, &ovs->ogg_alloc);
 	if (!ovs->ogg_stream) {
 
 		AudioServer::get_singleton()->audio_data_free(ovs->ogg_alloc.alloc_buffer);
-		ovs->ogg_alloc.alloc_buffer=NULL;
-		ERR_FAIL_COND_V(!ovs->ogg_stream,Ref<AudioStreamPlaybackOGGVorbis>());
+		ovs->ogg_alloc.alloc_buffer = NULL;
+		ERR_FAIL_COND_V(!ovs->ogg_stream, Ref<AudioStreamPlaybackOGGVorbis>());
 	}
 
 	return ovs;
@@ -145,40 +137,40 @@ Ref<AudioStreamPlayback> AudioStreamOGGVorbis::instance_playback() {
 
 String AudioStreamOGGVorbis::get_stream_name() const {
 
-	return "";//return stream_name;
+	return ""; //return stream_name;
 }
 
-void AudioStreamOGGVorbis::set_data(const PoolVector<uint8_t>& p_data) {
+void AudioStreamOGGVorbis::set_data(const PoolVector<uint8_t> &p_data) {
 
-	int src_data_len=p_data.size();
-#define MAX_TEST_MEM (1<<20)
+	int src_data_len = p_data.size();
+#define MAX_TEST_MEM (1 << 20)
 
-	uint32_t alloc_try=1024;
+	uint32_t alloc_try = 1024;
 	PoolVector<char> alloc_mem;
 	PoolVector<char>::Write w;
-	stb_vorbis * ogg_stream=NULL;
+	stb_vorbis *ogg_stream = NULL;
 	stb_vorbis_alloc ogg_alloc;
 
-	while(alloc_try<MAX_TEST_MEM) {
+	while (alloc_try < MAX_TEST_MEM) {
 
 		alloc_mem.resize(alloc_try);
 		w = alloc_mem.write();
 
-		ogg_alloc.alloc_buffer=w.ptr();
-		ogg_alloc.alloc_buffer_length_in_bytes=alloc_try;
+		ogg_alloc.alloc_buffer = w.ptr();
+		ogg_alloc.alloc_buffer_length_in_bytes = alloc_try;
 
 		PoolVector<uint8_t>::Read src_datar = p_data.read();
 
 		int error;
-		ogg_stream = stb_vorbis_open_memory( (const unsigned char*)src_datar.ptr(), src_data_len, &error, &ogg_alloc );
+		ogg_stream = stb_vorbis_open_memory((const unsigned char *)src_datar.ptr(), src_data_len, &error, &ogg_alloc);
 
-		if (!ogg_stream && error==VORBIS_outofmem) {
+		if (!ogg_stream && error == VORBIS_outofmem) {
 			w = PoolVector<char>::Write();
-			alloc_try*=2;
+			alloc_try *= 2;
 		} else {
 
-			ERR_FAIL_COND(alloc_try==MAX_TEST_MEM);
-			ERR_FAIL_COND(ogg_stream==NULL);
+			ERR_FAIL_COND(alloc_try == MAX_TEST_MEM);
+			ERR_FAIL_COND(ogg_stream == NULL);
 
 			stb_vorbis_info info = stb_vorbis_get_info(ogg_stream);
 
@@ -190,19 +182,17 @@ void AudioStreamOGGVorbis::set_data(const PoolVector<uint8_t>& p_data) {
 
 			//print_line("succeded "+itos(ogg_alloc.alloc_buffer_length_in_bytes)+" setup "+itos(info.setup_memory_required)+" setup temp "+itos(info.setup_temp_memory_required)+" temp "+itos(info.temp_memory_required)+" maxframe"+itos(info.max_frame_size));
 
-			length=stb_vorbis_stream_length_in_seconds(ogg_stream);
+			length = stb_vorbis_stream_length_in_seconds(ogg_stream);
 			stb_vorbis_close(ogg_stream);
 
-			data = AudioServer::get_singleton()->audio_data_alloc(src_data_len,src_datar.ptr());
-			data_len=src_data_len;
+			data = AudioServer::get_singleton()->audio_data_alloc(src_data_len, src_datar.ptr());
+			data_len = src_data_len;
 
 			break;
 		}
 	}
 
-
-	printf("create at %p, data %p\n",this,data);
-
+	printf("create at %p, data %p\n", this, data);
 }
 
 PoolVector<uint8_t> AudioStreamOGGVorbis::get_data() const {
@@ -213,16 +203,15 @@ PoolVector<uint8_t> AudioStreamOGGVorbis::get_data() const {
 		vdata.resize(data_len);
 		{
 			PoolVector<uint8_t>::Write w = vdata.write();
-			copymem(w.ptr(),data,data_len);
+			copymem(w.ptr(), data, data_len);
 		}
-
 	}
 
 	return vdata;
 }
 
 void AudioStreamOGGVorbis::set_loop(bool p_enable) {
-	loop=p_enable;
+	loop = p_enable;
 }
 
 bool AudioStreamOGGVorbis::has_loop() const {
@@ -230,31 +219,24 @@ bool AudioStreamOGGVorbis::has_loop() const {
 	return loop;
 }
 
-
 void AudioStreamOGGVorbis::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_data","data"),&AudioStreamOGGVorbis::set_data);
-	ClassDB::bind_method(D_METHOD("get_data"),&AudioStreamOGGVorbis::get_data);
-
-	ClassDB::bind_method(D_METHOD("set_loop","enable"),&AudioStreamOGGVorbis::set_loop);
-	ClassDB::bind_method(D_METHOD("has_loop"),&AudioStreamOGGVorbis::has_loop);
+	ClassDB::bind_method(D_METHOD("set_data", "data"), &AudioStreamOGGVorbis::set_data);
+	ClassDB::bind_method(D_METHOD("get_data"), &AudioStreamOGGVorbis::get_data);
 
-	ADD_PROPERTY(PropertyInfo(Variant::POOL_BYTE_ARRAY,"data",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"set_data","get_data");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL,"loop",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"set_loop","has_loop");
+	ClassDB::bind_method(D_METHOD("set_loop", "enable"), &AudioStreamOGGVorbis::set_loop);
+	ClassDB::bind_method(D_METHOD("has_loop"), &AudioStreamOGGVorbis::has_loop);
 
+	ADD_PROPERTY(PropertyInfo(Variant::POOL_BYTE_ARRAY, "data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_data", "get_data");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "loop", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_loop", "has_loop");
 }
 
 AudioStreamOGGVorbis::AudioStreamOGGVorbis() {
 
-
-	data=NULL;
-	length=0;
-	sample_rate=1;
-	channels=1;
-	decode_mem_size=0;
-	loop=false;
+	data = NULL;
+	length = 0;
+	sample_rate = 1;
+	channels = 1;
+	decode_mem_size = 0;
+	loop = false;
 }
-
-
-
-
diff --git a/modules/stb_vorbis/audio_stream_ogg_vorbis.h b/modules/stb_vorbis/audio_stream_ogg_vorbis.h
index 2313fc4ae3..c32b3e578d 100644
--- a/modules/stb_vorbis/audio_stream_ogg_vorbis.h
+++ b/modules/stb_vorbis/audio_stream_ogg_vorbis.h
@@ -29,36 +29,35 @@
 #ifndef AUDIO_STREAM_STB_VORBIS_H
 #define AUDIO_STREAM_STB_VORBIS_H
 
-#include "servers/audio/audio_stream.h"
 #include "io/resource_loader.h"
+#include "servers/audio/audio_stream.h"
 
 #define STB_VORBIS_HEADER_ONLY
 #include "thirdparty/stb_vorbis/stb_vorbis.c"
 #undef STB_VORBIS_HEADER_ONLY
 
-
 class AudioStreamOGGVorbis;
 
 class AudioStreamPlaybackOGGVorbis : public AudioStreamPlaybackResampled {
 
-	GDCLASS( AudioStreamPlaybackOGGVorbis, AudioStreamPlaybackResampled )
+	GDCLASS(AudioStreamPlaybackOGGVorbis, AudioStreamPlaybackResampled)
 
-	stb_vorbis * ogg_stream;
+	stb_vorbis *ogg_stream;
 	stb_vorbis_alloc ogg_alloc;
 	uint32_t frames_mixed;
 	bool active;
 	int loops;
 
-friend class AudioStreamOGGVorbis;
+	friend class AudioStreamOGGVorbis;
 
 	Ref<AudioStreamOGGVorbis> vorbis_stream;
-protected:
 
-	virtual void _mix_internal(AudioFrame* p_buffer, int p_frames);
+protected:
+	virtual void _mix_internal(AudioFrame *p_buffer, int p_frames);
 	virtual float get_stream_sampling_rate();
 
 public:
-	virtual void start(float p_from_pos=0.0);
+	virtual void start(float p_from_pos = 0.0);
 	virtual void stop();
 	virtual bool is_playing() const;
 
@@ -69,17 +68,17 @@ public:
 
 	virtual float get_length() const; //if supported, otherwise return 0
 
-	AudioStreamPlaybackOGGVorbis() {   }
+	AudioStreamPlaybackOGGVorbis() {}
 	~AudioStreamPlaybackOGGVorbis();
 };
 
 class AudioStreamOGGVorbis : public AudioStream {
 
-	GDCLASS( AudioStreamOGGVorbis, AudioStream )
-	OBJ_SAVE_TYPE( AudioStream ) //children are all saved as AudioStream, so they can be exchanged
+	GDCLASS(AudioStreamOGGVorbis, AudioStream)
+	OBJ_SAVE_TYPE(AudioStream) //children are all saved as AudioStream, so they can be exchanged
 	RES_BASE_EXTENSION("asogg");
 
-friend class AudioStreamPlaybackOGGVorbis;
+	friend class AudioStreamPlaybackOGGVorbis;
 
 	void *data;
 	uint32_t data_len;
@@ -89,23 +88,21 @@ friend class AudioStreamPlaybackOGGVorbis;
 	int channels;
 	float length;
 	bool loop;
-protected:
 
+protected:
 	static void _bind_methods();
-public:
 
+public:
 	void set_loop(bool p_enable);
 	bool has_loop() const;
 
 	virtual Ref<AudioStreamPlayback> instance_playback();
 	virtual String get_stream_name() const;
 
-	void set_data(const PoolVector<uint8_t>& p_data);
+	void set_data(const PoolVector<uint8_t> &p_data);
 	PoolVector<uint8_t> get_data() const;
 
 	AudioStreamOGGVorbis();
 };
 
-
-
 #endif
diff --git a/modules/stb_vorbis/register_types.cpp b/modules/stb_vorbis/register_types.cpp
index 41fbc6fbd7..36b7ebc11a 100644
--- a/modules/stb_vorbis/register_types.cpp
+++ b/modules/stb_vorbis/register_types.cpp
@@ -41,5 +41,4 @@ void register_stb_vorbis_types() {
 }
 
 void unregister_stb_vorbis_types() {
-
 }
diff --git a/modules/stb_vorbis/resource_importer_ogg_vorbis.cpp b/modules/stb_vorbis/resource_importer_ogg_vorbis.cpp
index 03495652d4..11d8551db5 100644
--- a/modules/stb_vorbis/resource_importer_ogg_vorbis.cpp
+++ b/modules/stb_vorbis/resource_importer_ogg_vorbis.cpp
@@ -37,11 +37,11 @@ String ResourceImporterOGGVorbis::get_importer_name() const {
 	return "ogg_vorbis";
 }
 
-String ResourceImporterOGGVorbis::get_visible_name() const{
+String ResourceImporterOGGVorbis::get_visible_name() const {
 
 	return "OGGVorbis";
 }
-void ResourceImporterOGGVorbis::get_recognized_extensions(List<String> *p_extensions) const{
+void ResourceImporterOGGVorbis::get_recognized_extensions(List<String> *p_extensions) const {
 
 	p_extensions->push_back("ogg");
 }
@@ -50,12 +50,12 @@ String ResourceImporterOGGVorbis::get_save_extension() const {
 	return "asogg";
 }
 
-String ResourceImporterOGGVorbis::get_resource_type() const{
+String ResourceImporterOGGVorbis::get_resource_type() const {
 
 	return "AudioStreamOGGVorbis";
 }
 
-bool ResourceImporterOGGVorbis::get_option_visibility(const String& p_option,const Map<StringName,Variant>& p_options) const {
+bool ResourceImporterOGGVorbis::get_option_visibility(const String &p_option, const Map<StringName, Variant> &p_options) const {
 
 	return true;
 }
@@ -68,23 +68,18 @@ String ResourceImporterOGGVorbis::get_preset_name(int p_idx) const {
 	return String();
 }
 
+void ResourceImporterOGGVorbis::get_import_options(List<ImportOption> *r_options, int p_preset) const {
 
-void ResourceImporterOGGVorbis::get_import_options(List<ImportOption> *r_options,int p_preset) const {
-
-
-	r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL,"loop"),true));
-
+	r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "loop"), true));
 }
 
-
-
-Error ResourceImporterOGGVorbis::import(const String& p_source_file, const String& p_save_path, const Map<StringName,Variant>& p_options, List<String>* r_platform_variants, List<String> *r_gen_files) {
+Error ResourceImporterOGGVorbis::import(const String &p_source_file, const String &p_save_path, const Map<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files) {
 
 	bool loop = p_options["loop"];
 
-	FileAccess *f = FileAccess::open(p_source_file,FileAccess::READ);
+	FileAccess *f = FileAccess::open(p_source_file, FileAccess::READ);
 	if (!f) {
-		ERR_FAIL_COND_V(!f,ERR_CANT_OPEN);
+		ERR_FAIL_COND_V(!f, ERR_CANT_OPEN);
 	}
 
 	size_t len = f->get_len();
@@ -93,7 +88,7 @@ Error ResourceImporterOGGVorbis::import(const String& p_source_file, const Strin
 	data.resize(len);
 	PoolVector<uint8_t>::Write w = data.write();
 
-	f->get_buffer(w.ptr(),len);
+	f->get_buffer(w.ptr(), len);
 
 	memdelete(f);
 
@@ -103,10 +98,8 @@ Error ResourceImporterOGGVorbis::import(const String& p_source_file, const Strin
 	ogg_stream->set_data(data);
 	ogg_stream->set_loop(loop);
 
-	return ResourceSaver::save(p_save_path+".asogg",ogg_stream);
+	return ResourceSaver::save(p_save_path + ".asogg", ogg_stream);
 }
 
-ResourceImporterOGGVorbis::ResourceImporterOGGVorbis()
-{
-
+ResourceImporterOGGVorbis::ResourceImporterOGGVorbis() {
 }
diff --git a/modules/stb_vorbis/resource_importer_ogg_vorbis.h b/modules/stb_vorbis/resource_importer_ogg_vorbis.h
index 15fc2cd2f3..2f0fcbe9a1 100644
--- a/modules/stb_vorbis/resource_importer_ogg_vorbis.h
+++ b/modules/stb_vorbis/resource_importer_ogg_vorbis.h
@@ -29,12 +29,11 @@
 #ifndef RESOURCEIMPORTEROGGVORBIS_H
 #define RESOURCEIMPORTEROGGVORBIS_H
 
-
-#include "io/resource_import.h"
 #include "audio_stream_ogg_vorbis.h"
+#include "io/resource_import.h"
 
 class ResourceImporterOGGVorbis : public ResourceImporter {
-	GDCLASS(ResourceImporterOGGVorbis,ResourceImporter)
+	GDCLASS(ResourceImporterOGGVorbis, ResourceImporter)
 public:
 	virtual String get_importer_name() const;
 	virtual String get_visible_name() const;
@@ -45,10 +44,10 @@ public:
 	virtual int get_preset_count() const;
 	virtual String get_preset_name(int p_idx) const;
 
-	virtual void get_import_options(List<ImportOption> *r_options,int p_preset=0) const;
-	virtual bool get_option_visibility(const String& p_option,const Map<StringName,Variant>& p_options) const;
+	virtual void get_import_options(List<ImportOption> *r_options, int p_preset = 0) const;
+	virtual bool get_option_visibility(const String &p_option, const Map<StringName, Variant> &p_options) const;
 
-	virtual Error import(const String& p_source_file,const String& p_save_path,const Map<StringName,Variant>& p_options,List<String>* r_platform_variants,List<String>* r_gen_files=NULL);
+	virtual Error import(const String &p_source_file, const String &p_save_path, const Map<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files = NULL);
 
 	ResourceImporterOGGVorbis();
 };
diff --git a/modules/theora/register_types.cpp b/modules/theora/register_types.cpp
index 58f63465c9..deb54b5d80 100644
--- a/modules/theora/register_types.cpp
+++ b/modules/theora/register_types.cpp
@@ -30,16 +30,16 @@
 
 #include "video_stream_theora.h"
 
-static ResourceFormatLoaderVideoStreamTheora* theora_stream_loader = NULL;
+static ResourceFormatLoaderVideoStreamTheora *theora_stream_loader = NULL;
 
 void register_theora_types() {
 
-	theora_stream_loader = memnew( ResourceFormatLoaderVideoStreamTheora );
+	theora_stream_loader = memnew(ResourceFormatLoaderVideoStreamTheora);
 	ResourceLoader::add_resource_format_loader(theora_stream_loader);
 	ClassDB::register_class<VideoStreamTheora>();
 }
 
 void unregister_theora_types() {
 
-	memdelete( theora_stream_loader );
+	memdelete(theora_stream_loader);
 }
diff --git a/modules/theora/video_stream_theora.cpp b/modules/theora/video_stream_theora.cpp
index 2a7b2707bf..c390701adb 100644
--- a/modules/theora/video_stream_theora.cpp
+++ b/modules/theora/video_stream_theora.cpp
@@ -32,9 +32,9 @@
 #include "os/os.h"
 #include "yuv2rgb.h"
 
-int VideoStreamPlaybackTheora::	buffer_data() {
+int VideoStreamPlaybackTheora::buffer_data() {
 
-	char *buffer=ogg_sync_buffer(&oy,4096);
+	char *buffer = ogg_sync_buffer(&oy, 4096);
 
 #ifdef THEORA_USE_THREAD_STREAMING
 
@@ -42,44 +42,44 @@ int VideoStreamPlaybackTheora::	buffer_data() {
 
 	do {
 		thread_sem->post();
-		read = MIN(ring_buffer.data_left(),4096);
+		read = MIN(ring_buffer.data_left(), 4096);
 		if (read) {
-			ring_buffer.read((uint8_t*)buffer,read);
-			ogg_sync_wrote(&oy,read);
+			ring_buffer.read((uint8_t *)buffer, read);
+			ogg_sync_wrote(&oy, read);
 		} else {
 			OS::get_singleton()->delay_usec(100);
 		}
 
-	} while(read==0);
+	} while (read == 0);
 
 	return read;
 
 #else
 
-	int bytes=file->get_buffer((uint8_t*)buffer, 4096);
-	ogg_sync_wrote(&oy,bytes);
-	return(bytes);
+	int bytes = file->get_buffer((uint8_t *)buffer, 4096);
+	ogg_sync_wrote(&oy, bytes);
+	return (bytes);
 
 #endif
 }
 
-int VideoStreamPlaybackTheora::queue_page(ogg_page *page){
-  if(theora_p) {
-	  ogg_stream_pagein(&to,page);
-	  if (to.e_o_s)
-		  theora_eos=true;
-  }
-  if(vorbis_p) {
-	  ogg_stream_pagein(&vo,page);
-	  if (vo.e_o_s)
-		  vorbis_eos=true;
-  }
-  return 0;
+int VideoStreamPlaybackTheora::queue_page(ogg_page *page) {
+	if (theora_p) {
+		ogg_stream_pagein(&to, page);
+		if (to.e_o_s)
+			theora_eos = true;
+	}
+	if (vorbis_p) {
+		ogg_stream_pagein(&vo, page);
+		if (vo.e_o_s)
+			vorbis_eos = true;
+	}
+	return 0;
 }
 
-void VideoStreamPlaybackTheora::video_write(void){
+void VideoStreamPlaybackTheora::video_write(void) {
 	th_ycbcr_buffer yuv;
-	th_decode_ycbcr_out(td,yuv);
+	th_decode_ycbcr_out(td, yuv);
 
 	// FIXME: The way stuff is commented out with `//*/` closing comments
 	// sounds very fishy...
@@ -116,27 +116,27 @@ void VideoStreamPlaybackTheora::video_write(void){
 	frame_data.resize(size.x * size.y * pitch);
 	{
 		PoolVector<uint8_t>::Write w = frame_data.write();
-		char* dst = (char*)w.ptr();
+		char *dst = (char *)w.ptr();
 
 		//uv_offset=(ti.pic_x/2)+(yuv[1].stride)*(ti.pic_y/2);
 
 		if (px_fmt == TH_PF_444) {
 
-			yuv444_2_rgb8888((uint8_t*)dst, (uint8_t*)yuv[0].data, (uint8_t*)yuv[1].data, (uint8_t*)yuv[2].data, size.x, size.y, yuv[0].stride, yuv[1].stride, size.x<<2, 0);
+			yuv444_2_rgb8888((uint8_t *)dst, (uint8_t *)yuv[0].data, (uint8_t *)yuv[1].data, (uint8_t *)yuv[2].data, size.x, size.y, yuv[0].stride, yuv[1].stride, size.x << 2, 0);
 
 		} else if (px_fmt == TH_PF_422) {
 
-			yuv422_2_rgb8888((uint8_t*)dst, (uint8_t*)yuv[0].data, (uint8_t*)yuv[1].data, (uint8_t*)yuv[2].data, size.x, size.y, yuv[0].stride, yuv[1].stride, size.x<<2, 0);
+			yuv422_2_rgb8888((uint8_t *)dst, (uint8_t *)yuv[0].data, (uint8_t *)yuv[1].data, (uint8_t *)yuv[2].data, size.x, size.y, yuv[0].stride, yuv[1].stride, size.x << 2, 0);
 
 		} else if (px_fmt == TH_PF_420) {
 
-			yuv420_2_rgb8888((uint8_t*)dst, (uint8_t*)yuv[0].data, (uint8_t*)yuv[2].data, (uint8_t*)yuv[1].data, size.x, size.y, yuv[0].stride, yuv[1].stride, size.x<<2, 0);
+			yuv420_2_rgb8888((uint8_t *)dst, (uint8_t *)yuv[0].data, (uint8_t *)yuv[2].data, (uint8_t *)yuv[1].data, size.x, size.y, yuv[0].stride, yuv[1].stride, size.x << 2, 0);
 		};
 
 		format = Image::FORMAT_RGBA8;
 	}
 
-	Image img(size.x,size.y,0,Image::FORMAT_RGBA8,frame_data); //zero copy image creation
+	Image img(size.x, size.y, 0, Image::FORMAT_RGBA8, frame_data); //zero copy image creation
 
 	texture->set_data(img); //zero copy send to visual server
 
@@ -241,7 +241,7 @@ void VideoStreamPlaybackTheora::clear() {
 	if (!file)
 		return;
 
-	if(vorbis_p){
+	if (vorbis_p) {
 		ogg_stream_clear(&vo);
 		if (vorbis_p >= 3) {
 			vorbis_block_clear(&vb);
@@ -251,7 +251,7 @@ void VideoStreamPlaybackTheora::clear() {
 		vorbis_info_clear(&vi);
 		vorbis_p = 0;
 	}
-	if(theora_p){
+	if (theora_p) {
 		ogg_stream_clear(&to);
 		th_decode_free(td);
 		th_comment_clear(&tc);
@@ -261,11 +261,11 @@ void VideoStreamPlaybackTheora::clear() {
 	ogg_sync_clear(&oy);
 
 #ifdef THEORA_USE_THREAD_STREAMING
-	thread_exit=true;
+	thread_exit = true;
 	thread_sem->post(); //just in case
 	Thread::wait_to_finish(thread);
 	memdelete(thread);
-	thread=NULL;
+	thread = NULL;
 	ring_buffer.clear();
 #endif
 	//file_name = "";
@@ -275,21 +275,21 @@ void VideoStreamPlaybackTheora::clear() {
 	videobuf_ready = 0;
 	frames_pending = 0;
 	videobuf_time = 0;
-	theora_eos=false;
-	vorbis_eos=false;
+	theora_eos = false;
+	vorbis_eos = false;
 
 	if (file) {
 		memdelete(file);
 	}
-	file=NULL;
+	file = NULL;
 	playing = false;
 };
 
-void VideoStreamPlaybackTheora::set_file(const String& p_file) {
+void VideoStreamPlaybackTheora::set_file(const String &p_file) {
 
 	ERR_FAIL_COND(playing);
 	ogg_packet op;
-	th_setup_info    *ts = NULL;
+	th_setup_info *ts = NULL;
 
 	file_name = p_file;
 	if (file) {
@@ -299,14 +299,14 @@ void VideoStreamPlaybackTheora::set_file(const String& p_file) {
 	ERR_FAIL_COND(!file);
 
 #ifdef THEORA_USE_THREAD_STREAMING
-	thread_exit=false;
-	thread_eof=false;
+	thread_exit = false;
+	thread_eof = false;
 	//pre-fill buffer
 	int to_read = ring_buffer.space_left();
-	int read = file->get_buffer(read_buffer.ptr(),to_read);
-	ring_buffer.write(read_buffer.ptr(),read);
+	int read = file->get_buffer(read_buffer.ptr(), to_read);
+	ring_buffer.write(read_buffer.ptr(), read);
 
-	thread=Thread::create(_streaming_thread,this);
+	thread = Thread::create(_streaming_thread, this);
 
 #endif
 
@@ -320,42 +320,39 @@ void VideoStreamPlaybackTheora::set_file(const String& p_file) {
 	th_comment_init(&tc);
 	th_info_init(&ti);
 
-	theora_eos=false;
-	vorbis_eos=false;
+	theora_eos = false;
+	vorbis_eos = false;
 
 	/* Ogg file open; parse the headers */
 	/* Only interested in Vorbis/Theora streams */
 	int stateflag = 0;
 
-	int audio_track_skip=audio_track;
-
+	int audio_track_skip = audio_track;
 
-	while(!stateflag){
-		int ret=buffer_data();
-		if(ret==0)break;
-		while(ogg_sync_pageout(&oy,&og)>0){
+	while (!stateflag) {
+		int ret = buffer_data();
+		if (ret == 0) break;
+		while (ogg_sync_pageout(&oy, &og) > 0) {
 			ogg_stream_state test;
 
 			/* is this a mandated initial header? If not, stop parsing */
-			if(!ogg_page_bos(&og)){
+			if (!ogg_page_bos(&og)) {
 				/* don't leak the page; get it into the appropriate stream */
 				queue_page(&og);
-				stateflag=1;
+				stateflag = 1;
 				break;
 			}
 
-			ogg_stream_init(&test,ogg_page_serialno(&og));
-			ogg_stream_pagein(&test,&og);
-			ogg_stream_packetout(&test,&op);
-
+			ogg_stream_init(&test, ogg_page_serialno(&og));
+			ogg_stream_pagein(&test, &og);
+			ogg_stream_packetout(&test, &op);
 
 			/* identify the codec: try theora */
-			if(!theora_p && th_decode_headerin(&ti,&tc,&ts,&op)>=0){
+			if (!theora_p && th_decode_headerin(&ti, &tc, &ts, &op) >= 0) {
 				/* it is theora */
-				copymem(&to,&test,sizeof(test));
-				theora_p=1;
-			}else if(!vorbis_p && vorbis_synthesis_headerin(&vi,&vc,&op)>=0){
-
+				copymem(&to, &test, sizeof(test));
+				theora_p = 1;
+			} else if (!vorbis_p && vorbis_synthesis_headerin(&vi, &vc, &op) >= 0) {
 
 				/* it is vorbis */
 				if (audio_track_skip) {
@@ -367,10 +364,10 @@ void VideoStreamPlaybackTheora::set_file(const String& p_file) {
 
 					audio_track_skip--;
 				} else {
-                                        copymem(&vo,&test,sizeof(test));
-					vorbis_p=1;
+					copymem(&vo, &test, sizeof(test));
+					vorbis_p = 1;
 				}
-			}else{
+			} else {
 				/* whatever it is, we don't care about it */
 				ogg_stream_clear(&test);
 			}
@@ -379,20 +376,20 @@ void VideoStreamPlaybackTheora::set_file(const String& p_file) {
 	}
 
 	/* we're expecting more header packets. */
-	while((theora_p && theora_p<3) || (vorbis_p && vorbis_p<3)){
+	while ((theora_p && theora_p < 3) || (vorbis_p && vorbis_p < 3)) {
 		int ret;
 
 		/* look for further theora headers */
-		while(theora_p && (theora_p<3) && (ret=ogg_stream_packetout(&to,&op))){
-			if(ret<0){
-				fprintf(stderr,"Error parsing Theora stream headers; "
-						"corrupt stream?\n");
+		while (theora_p && (theora_p < 3) && (ret = ogg_stream_packetout(&to, &op))) {
+			if (ret < 0) {
+				fprintf(stderr, "Error parsing Theora stream headers; "
+								"corrupt stream?\n");
 				clear();
 				return;
 			}
-			if(!th_decode_headerin(&ti,&tc,&ts,&op)){
-				fprintf(stderr,"Error parsing Theora stream headers; "
-						"corrupt stream?\n");
+			if (!th_decode_headerin(&ti, &tc, &ts, &op)) {
+				fprintf(stderr, "Error parsing Theora stream headers; "
+								"corrupt stream?\n");
 				clear();
 				return;
 			}
@@ -400,31 +397,31 @@ void VideoStreamPlaybackTheora::set_file(const String& p_file) {
 		}
 
 		/* look for more vorbis header packets */
-		while(vorbis_p && (vorbis_p<3) && (ret=ogg_stream_packetout(&vo,&op))){
-			if(ret<0){
-				fprintf(stderr,"Error parsing Vorbis stream headers; corrupt stream?\n");
+		while (vorbis_p && (vorbis_p < 3) && (ret = ogg_stream_packetout(&vo, &op))) {
+			if (ret < 0) {
+				fprintf(stderr, "Error parsing Vorbis stream headers; corrupt stream?\n");
 				clear();
 				return;
 			}
-			ret = vorbis_synthesis_headerin(&vi,&vc,&op);
-			if(ret){
-				fprintf(stderr,"Error parsing Vorbis stream headers; corrupt stream?\n");
+			ret = vorbis_synthesis_headerin(&vi, &vc, &op);
+			if (ret) {
+				fprintf(stderr, "Error parsing Vorbis stream headers; corrupt stream?\n");
 				clear();
 				return;
 			}
 			vorbis_p++;
-			if(vorbis_p==3)break;
+			if (vorbis_p == 3) break;
 		}
 
 		/* The header pages/packets will arrive before anything else we
 		care about, or the stream is not obeying spec */
 
-		if(ogg_sync_pageout(&oy,&og)>0){
+		if (ogg_sync_pageout(&oy, &og) > 0) {
 			queue_page(&og); /* demux into the appropriate stream */
-		}else{
-			int ret=buffer_data(); /* someone needs more data */
-			if(ret==0){
-				fprintf(stderr,"End of file while searching for codec headers.\n");
+		} else {
+			int ret = buffer_data(); /* someone needs more data */
+			if (ret == 0) {
+				fprintf(stderr, "End of file while searching for codec headers.\n");
 				clear();
 				return;
 			}
@@ -432,30 +429,30 @@ void VideoStreamPlaybackTheora::set_file(const String& p_file) {
 	}
 
 	/* and now we have it all.  initialize decoders */
-	if(theora_p){
-		td=th_decode_alloc(&ti,ts);
+	if (theora_p) {
+		td = th_decode_alloc(&ti, ts);
 		printf("Ogg logical stream %lx is Theora %dx%d %.02f fps",
-			   to.serialno,ti.pic_width,ti.pic_height,
-			   (double)ti.fps_numerator/ti.fps_denominator);
-		px_fmt=ti.pixel_fmt;
-		switch(ti.pixel_fmt){
-		case TH_PF_420: printf(" 4:2:0 video\n"); break;
-		case TH_PF_422: printf(" 4:2:2 video\n"); break;
-		case TH_PF_444: printf(" 4:4:4 video\n"); break;
-		case TH_PF_RSVD:
-		default:
-			printf(" video\n  (UNKNOWN Chroma sampling!)\n");
-			break;
+				to.serialno, ti.pic_width, ti.pic_height,
+				(double)ti.fps_numerator / ti.fps_denominator);
+		px_fmt = ti.pixel_fmt;
+		switch (ti.pixel_fmt) {
+			case TH_PF_420: printf(" 4:2:0 video\n"); break;
+			case TH_PF_422: printf(" 4:2:2 video\n"); break;
+			case TH_PF_444: printf(" 4:4:4 video\n"); break;
+			case TH_PF_RSVD:
+			default:
+				printf(" video\n  (UNKNOWN Chroma sampling!)\n");
+				break;
 		}
-		if(ti.pic_width!=ti.frame_width || ti.pic_height!=ti.frame_height)
+		if (ti.pic_width != ti.frame_width || ti.pic_height != ti.frame_height)
 			printf("  Frame content is %dx%d with offset (%d,%d).\n",
-				   ti.frame_width, ti.frame_height, ti.pic_x, ti.pic_y);
-		th_decode_ctl(td,TH_DECCTL_GET_PPLEVEL_MAX,&pp_level_max,
-					  sizeof(pp_level_max));
-		pp_level=pp_level_max;
-		pp_level=0;
-		th_decode_ctl(td,TH_DECCTL_SET_PPLEVEL,&pp_level,sizeof(pp_level));
-		pp_inc=0;
+					ti.frame_width, ti.frame_height, ti.pic_x, ti.pic_y);
+		th_decode_ctl(td, TH_DECCTL_GET_PPLEVEL_MAX, &pp_level_max,
+				sizeof(pp_level_max));
+		pp_level = pp_level_max;
+		pp_level = 0;
+		th_decode_ctl(td, TH_DECCTL_SET_PPLEVEL, &pp_level, sizeof(pp_level));
+		pp_inc = 0;
 
 		/*{
 		int arg = 0xffff;
@@ -468,14 +465,14 @@ void VideoStreamPlaybackTheora::set_file(const String& p_file) {
 
 		int w;
 		int h;
-		w=(ti.pic_x+ti.frame_width+1&~1)-(ti.pic_x&~1);
-		h=(ti.pic_y+ti.frame_height+1&~1)-(ti.pic_y&~1);
+		w = (ti.pic_x + ti.frame_width + 1 & ~1) - (ti.pic_x & ~1);
+		h = (ti.pic_y + ti.frame_height + 1 & ~1) - (ti.pic_y & ~1);
 		size.x = w;
 		size.y = h;
 
-		texture->create(w,h,Image::FORMAT_RGBA8,Texture::FLAG_FILTER|Texture::FLAG_VIDEO_SURFACE);
+		texture->create(w, h, Image::FORMAT_RGBA8, Texture::FLAG_FILTER | Texture::FLAG_VIDEO_SURFACE);
 
-	}else{
+	} else {
 		/* tear down the partial theora setup */
 		th_info_clear(&ti);
 		th_comment_clear(&tc);
@@ -483,32 +480,30 @@ void VideoStreamPlaybackTheora::set_file(const String& p_file) {
 
 	th_setup_free(ts);
 
-	if(vorbis_p){
-		vorbis_synthesis_init(&vd,&vi);
-		vorbis_block_init(&vd,&vb);
-		fprintf(stderr,"Ogg logical stream %lx is Vorbis %d channel %ld Hz audio.\n",
-				vo.serialno,vi.channels,vi.rate);
+	if (vorbis_p) {
+		vorbis_synthesis_init(&vd, &vi);
+		vorbis_block_init(&vd, &vb);
+		fprintf(stderr, "Ogg logical stream %lx is Vorbis %d channel %ld Hz audio.\n",
+				vo.serialno, vi.channels, vi.rate);
 		//_setup(vi.channels, vi.rate);
 
-	}else{
+	} else {
 		/* tear down the partial vorbis setup */
 		vorbis_info_clear(&vi);
 		vorbis_comment_clear(&vc);
 	}
 
 	playing = false;
-	buffering=true;
-	time=0;
-	audio_frames_wrote=0;
-
-
+	buffering = true;
+	time = 0;
+	audio_frames_wrote = 0;
 };
 
 float VideoStreamPlaybackTheora::get_time() const {
 
 	//print_line("total: "+itos(get_total())+" todo: "+itos(get_todo()));
 	//return MAX(0,time-((get_total())/(float)vi.rate));
-	return time-AudioServer::get_singleton()->get_output_delay()-delay_compensation;//-((get_total())/(float)vi.rate);
+	return time - AudioServer::get_singleton()->get_output_delay() - delay_compensation; //-((get_total())/(float)vi.rate);
 };
 
 Ref<Texture> VideoStreamPlaybackTheora::get_texture() {
@@ -526,8 +521,6 @@ void VideoStreamPlaybackTheora::update(float p_delta) {
 		return;
 	};
 
-
-
 #ifdef THEORA_USE_THREAD_STREAMING
 	thread_sem->post();
 #endif
@@ -535,112 +528,102 @@ void VideoStreamPlaybackTheora::update(float p_delta) {
 	//double ctime =AudioServer::get_singleton()->get_mix_time();
 
 	//print_line("play "+rtos(p_delta));
-	time+=p_delta;
+	time += p_delta;
 
-	if (videobuf_time>get_time()) {
+	if (videobuf_time > get_time()) {
 		return; //no new frames need to be produced
 	}
 
-	bool frame_done=false;
-	bool audio_done=!vorbis_p;
+	bool frame_done = false;
+	bool audio_done = !vorbis_p;
 
 	while (!frame_done || (!audio_done && !vorbis_eos)) {
 		//a frame needs to be produced
 
 		ogg_packet op;
-		bool no_theora=false;
-
+		bool no_theora = false;
 
 		while (vorbis_p) {
 			int ret;
 			float **pcm;
 
-			bool buffer_full=false;
+			bool buffer_full = false;
 
 			/* if there's pending, decoded audio, grab it */
-			if ((ret=vorbis_synthesis_pcmout(&vd,&pcm))>0) {
+			if ((ret = vorbis_synthesis_pcmout(&vd, &pcm)) > 0) {
 
-
-
-				const int AUXBUF_LEN=4096;
+				const int AUXBUF_LEN = 4096;
 				int to_read = ret;
 				int16_t aux_buffer[AUXBUF_LEN];
 
-				while(to_read) {
+				while (to_read) {
 
-					int m = MIN(AUXBUF_LEN/vi.channels,to_read);
+					int m = MIN(AUXBUF_LEN / vi.channels, to_read);
 
 					int count = 0;
 
-					for(int j=0;j<m;j++){
-						for(int i=0;i<vi.channels;i++){
+					for (int j = 0; j < m; j++) {
+						for (int i = 0; i < vi.channels; i++) {
 
-							int val=Math::fast_ftoi(pcm[i][j]*32767.f);
-							if(val>32767)val=32767;
-							if(val<-32768)val=-32768;
+							int val = Math::fast_ftoi(pcm[i][j] * 32767.f);
+							if (val > 32767) val = 32767;
+							if (val < -32768) val = -32768;
 							aux_buffer[count++] = val;
 						}
 					}
 
 					if (mix_callback) {
-						int mixed = mix_callback(mix_udata,aux_buffer,m);
-						to_read-=mixed;
-						if (mixed!=m) { //could mix no more
-							buffer_full=true;
+						int mixed = mix_callback(mix_udata, aux_buffer, m);
+						to_read -= mixed;
+						if (mixed != m) { //could mix no more
+							buffer_full = true;
 							break;
 						}
 					} else {
-						to_read-=m; //just pretend we sent the audio
+						to_read -= m; //just pretend we sent the audio
 					}
-
-
 				}
 
+				int tr = vorbis_synthesis_read(&vd, ret - to_read);
 
-				int tr = vorbis_synthesis_read(&vd, ret-to_read);
-
-
-				if (vd.granulepos>=0) {
+				if (vd.granulepos >= 0) {
 					//print_line("wrote: "+itos(audio_frames_wrote)+" gpos: "+itos(vd.granulepos));
 				}
 
 				//print_line("mix audio!");
 
-				audio_frames_wrote+=ret-to_read;
+				audio_frames_wrote += ret - to_read;
 
 				//print_line("AGP: "+itos(vd.granulepos)+" added "+itos(ret-to_read));
 
-
 			} else {
 
 				/* no pending audio; is there a pending packet to decode? */
-				if (ogg_stream_packetout(&vo,&op)>0){
-					if(vorbis_synthesis(&vb,&op)==0) { /* test for success! */
-						vorbis_synthesis_blockin(&vd,&vb);
+				if (ogg_stream_packetout(&vo, &op) > 0) {
+					if (vorbis_synthesis(&vb, &op) == 0) { /* test for success! */
+						vorbis_synthesis_blockin(&vd, &vb);
 					}
-				} else {  /* we need more data; break out to suck in another page */
+				} else { /* we need more data; break out to suck in another page */
 					//printf("need moar data\n");
 					break;
 				};
 			}
 
-
-			audio_done = videobuf_time < (audio_frames_wrote/float(vi.rate));
+			audio_done = videobuf_time < (audio_frames_wrote / float(vi.rate));
 
 			if (buffer_full)
 				break;
 		}
 
-		while(theora_p && !frame_done){
+		while (theora_p && !frame_done) {
 			/* theora is one in, one out... */
-			if(ogg_stream_packetout(&to,&op)>0){
+			if (ogg_stream_packetout(&to, &op) > 0) {
 
-
-				if(false && pp_inc){
-					pp_level+=pp_inc;
-					th_decode_ctl(td,TH_DECCTL_SET_PPLEVEL,&pp_level,
-								  sizeof(pp_level));
-					pp_inc=0;
+				if (false && pp_inc) {
+					pp_level += pp_inc;
+					th_decode_ctl(td, TH_DECCTL_SET_PPLEVEL, &pp_level,
+							sizeof(pp_level));
+					pp_inc = 0;
 				}
 				/*HACK: This should be set after a seek or a gap, but we might not have
 				a granulepos for the first packet (we only have them for the last
@@ -648,13 +631,13 @@ void VideoStreamPlaybackTheora::update(float p_delta) {
 				To do this right, we should back-track from the last packet on the
 				page and compute the correct granulepos for the first packet after
 				a seek or a gap.*/
-				if(op.granulepos>=0){
-					th_decode_ctl(td,TH_DECCTL_SET_GRANPOS,&op.granulepos,
-								  sizeof(op.granulepos));
+				if (op.granulepos >= 0) {
+					th_decode_ctl(td, TH_DECCTL_SET_GRANPOS, &op.granulepos,
+							sizeof(op.granulepos));
 				}
 				ogg_int64_t videobuf_granulepos;
-				if(th_decode_packetin(td,&op,&videobuf_granulepos)==0){
-					videobuf_time=th_granule_time(td,videobuf_granulepos);
+				if (th_decode_packetin(td, &op, &videobuf_granulepos) == 0) {
+					videobuf_time = th_granule_time(td, videobuf_granulepos);
 
 					//printf("frame time %f, play time %f, ready %i\n", (float)videobuf_time, get_time(), videobuf_ready);
 
@@ -664,27 +647,25 @@ void VideoStreamPlaybackTheora::update(float p_delta) {
 					 keyframing.  Soon enough libtheora will be able to deal
 					 with non-keyframe seeks.  */
 
-					if(videobuf_time>=get_time()) {
-						frame_done=true;
-					} else{
+					if (videobuf_time >= get_time()) {
+						frame_done = true;
+					} else {
 						/*If we are too slow, reduce the pp level.*/
-						pp_inc=pp_level>0?-1:0;
+						pp_inc = pp_level > 0 ? -1 : 0;
 					}
 				} else {
-
 				}
 
 			} else {
-				no_theora=true;
+				no_theora = true;
 				break;
 			}
 		}
 
-
-		//print_line("no theora: "+itos(no_theora)+" theora eos: "+itos(theora_eos)+" frame done "+itos(frame_done));
+//print_line("no theora: "+itos(no_theora)+" theora eos: "+itos(theora_eos)+" frame done "+itos(frame_done));
 
 #ifdef THEORA_USE_THREAD_STREAMING
-		if (file && thread_eof && no_theora && theora_eos && ring_buffer.data_left()==0) {
+		if (file && thread_eof && no_theora && theora_eos && ring_buffer.data_left() == 0) {
 #else
 		if (file && /*!videobuf_ready && */ no_theora && theora_eos) {
 #endif
@@ -692,7 +673,7 @@ void VideoStreamPlaybackTheora::update(float p_delta) {
 			stop();
 			return;
 		};
-	#if 0
+#if 0
 		if (!videobuf_ready || audio_todo > 0){
 			/* no data yet for somebody.  Grab another page */
 
@@ -701,23 +682,22 @@ void VideoStreamPlaybackTheora::update(float p_delta) {
 				queue_page(&og);
 			}
 		}
-	#else
-
+#else
 
-		if (!frame_done || !audio_done){
+		if (!frame_done || !audio_done) {
 			//what's the point of waiting for audio to grab a page?
 
 			buffer_data();
-			while(ogg_sync_pageout(&oy,&og)>0){
+			while (ogg_sync_pageout(&oy, &og) > 0) {
 				queue_page(&og);
 			}
 		}
-	#endif
+#endif
 		/* If playback has begun, top audio buffer off immediately. */
 		//if(stateflag) audio_write_nonblocking();
 
 		/* are we at or past time for this video frame? */
-		if(videobuf_ready && videobuf_time<=get_time()){
+		if (videobuf_ready && videobuf_time <= get_time()) {
 
 			//video_write();
 			//videobuf_ready=0;
@@ -725,35 +705,29 @@ void VideoStreamPlaybackTheora::update(float p_delta) {
 			//printf("frame at %f not ready (time %f), ready %i\n", (float)videobuf_time, get_time(), videobuf_ready);
 		}
 
-		float tdiff=videobuf_time-get_time();
+		float tdiff = videobuf_time - get_time();
 		/*If we have lots of extra time, increase the post-processing level.*/
-		if(tdiff>ti.fps_denominator*0.25/ti.fps_numerator){
-			pp_inc=pp_level<pp_level_max?1:0;
-		}
-		else if(tdiff<ti.fps_denominator*0.05/ti.fps_numerator){
-			pp_inc=pp_level>0?-1:0;
+		if (tdiff > ti.fps_denominator * 0.25 / ti.fps_numerator) {
+			pp_inc = pp_level < pp_level_max ? 1 : 0;
+		} else if (tdiff < ti.fps_denominator * 0.05 / ti.fps_numerator) {
+			pp_inc = pp_level > 0 ? -1 : 0;
 		}
-
 	}
 
 	video_write();
-
 };
 
-
 void VideoStreamPlaybackTheora::play() {
 
 	if (!playing)
-		time=0;
+		time = 0;
 	else {
 		stop();
 	}
 
 	playing = true;
-	delay_compensation=GlobalConfig::get_singleton()->get("audio/video_delay_compensation_ms");
-	delay_compensation/=1000.0;
-
-
+	delay_compensation = GlobalConfig::get_singleton()->get("audio/video_delay_compensation_ms");
+	delay_compensation /= 1000.0;
 };
 
 void VideoStreamPlaybackTheora::stop() {
@@ -764,7 +738,7 @@ void VideoStreamPlaybackTheora::stop() {
 		set_file(file_name); //reset
 	}
 	playing = false;
-	time=0;
+	time = 0;
 };
 
 bool VideoStreamPlaybackTheora::is_playing() const {
@@ -774,7 +748,7 @@ bool VideoStreamPlaybackTheora::is_playing() const {
 
 void VideoStreamPlaybackTheora::set_paused(bool p_paused) {
 
-	paused=p_paused;
+	paused = p_paused;
 	//pau = !p_paused;
 };
 
@@ -783,7 +757,7 @@ bool VideoStreamPlaybackTheora::is_paused(bool p_paused) const {
 	return paused;
 };
 
-void VideoStreamPlaybackTheora::set_loop(bool p_enable) {
+void VideoStreamPlaybackTheora::set_loop(bool p_enable){
 
 };
 
@@ -812,52 +786,49 @@ float VideoStreamPlaybackTheora::get_pos() const {
 	return get_time();
 };
 
-void VideoStreamPlaybackTheora::seek_pos(float p_time) {
+void VideoStreamPlaybackTheora::seek_pos(float p_time){
 
 	// no
 };
 
-void VideoStreamPlaybackTheora::set_mix_callback(AudioMixCallback p_callback,void *p_userdata) {
+void VideoStreamPlaybackTheora::set_mix_callback(AudioMixCallback p_callback, void *p_userdata) {
 
-	mix_callback=p_callback;
-	mix_udata=p_userdata;
+	mix_callback = p_callback;
+	mix_udata = p_userdata;
 }
 
-int VideoStreamPlaybackTheora::get_channels() const{
+int VideoStreamPlaybackTheora::get_channels() const {
 
 	return vi.channels;
 }
 
 void VideoStreamPlaybackTheora::set_audio_track(int p_idx) {
 
-    audio_track=p_idx;
+	audio_track = p_idx;
 }
 
-int VideoStreamPlaybackTheora::get_mix_rate() const{
+int VideoStreamPlaybackTheora::get_mix_rate() const {
 
 	return vi.rate;
 }
 
 #ifdef THEORA_USE_THREAD_STREAMING
 
-
 void VideoStreamPlaybackTheora::_streaming_thread(void *ud) {
 
-	VideoStreamPlaybackTheora *vs=(VideoStreamPlaybackTheora*)ud;
+	VideoStreamPlaybackTheora *vs = (VideoStreamPlaybackTheora *)ud;
 
-	while(!vs->thread_exit) {
+	while (!vs->thread_exit) {
 
 		//just fill back the buffer
 		if (!vs->thread_eof) {
 
 			int to_read = vs->ring_buffer.space_left();
 			if (to_read) {
-				int read = vs->file->get_buffer(vs->read_buffer.ptr(),to_read);
-				vs->ring_buffer.write(vs->read_buffer.ptr(),read);
-				vs->thread_eof=vs->file->eof_reached();
+				int read = vs->file->get_buffer(vs->read_buffer.ptr(), to_read);
+				vs->ring_buffer.write(vs->read_buffer.ptr(), read);
+				vs->thread_eof = vs->file->eof_reached();
 			}
-
-
 		}
 
 		vs->thread_sem->wait();
@@ -875,24 +846,24 @@ VideoStreamPlaybackTheora::VideoStreamPlaybackTheora() {
 	playing = false;
 	frames_pending = 0;
 	videobuf_time = 0;
-	paused=false;
+	paused = false;
 
-	buffering=false;
-	texture = Ref<ImageTexture>( memnew(ImageTexture ));
-	mix_callback=NULL;
-	mix_udata=NULL;
-	    audio_track=0;
-	delay_compensation=0;
-	audio_frames_wrote=0;
+	buffering = false;
+	texture = Ref<ImageTexture>(memnew(ImageTexture));
+	mix_callback = NULL;
+	mix_udata = NULL;
+	audio_track = 0;
+	delay_compensation = 0;
+	audio_frames_wrote = 0;
 
 #ifdef THEORA_USE_THREAD_STREAMING
-	int rb_power = nearest_shift(RB_SIZE_KB*1024);
+	int rb_power = nearest_shift(RB_SIZE_KB * 1024);
 	ring_buffer.resize(rb_power);
-	read_buffer.resize(RB_SIZE_KB*1024);
-	thread_sem=Semaphore::create();
-	thread=NULL;
-	thread_exit=false;
-	thread_eof=false;
+	read_buffer.resize(RB_SIZE_KB * 1024);
+	thread_sem = Semaphore::create();
+	thread = NULL;
+	thread_exit = false;
+	thread_eof = false;
 
 #endif
 };
@@ -907,20 +878,17 @@ VideoStreamPlaybackTheora::~VideoStreamPlaybackTheora() {
 
 	if (file)
 		memdelete(file);
-
-
 };
 
-
-RES ResourceFormatLoaderVideoStreamTheora::load(const String &p_path,const String& p_original_path, Error *r_error) {
+RES ResourceFormatLoaderVideoStreamTheora::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;
 
 	VideoStreamTheora *stream = memnew(VideoStreamTheora);
 	stream->set_file(p_path);
 
 	if (r_error)
-		*r_error=OK;
+		*r_error = OK;
 
 	return Ref<VideoStreamTheora>(stream);
 }
@@ -930,14 +898,14 @@ void ResourceFormatLoaderVideoStreamTheora::get_recognized_extensions(List<Strin
 	p_extensions->push_back("ogm");
 	p_extensions->push_back("ogv");
 }
-bool ResourceFormatLoaderVideoStreamTheora::handles_type(const String& p_type) const {
-	return (p_type=="VideoStream" || p_type=="VideoStreamTheora");
+bool ResourceFormatLoaderVideoStreamTheora::handles_type(const String &p_type) const {
+	return (p_type == "VideoStream" || p_type == "VideoStreamTheora");
 }
 
 String ResourceFormatLoaderVideoStreamTheora::get_resource_type(const String &p_path) const {
 
-	String exl=p_path.get_extension().to_lower();
-	if (exl=="ogm" || exl=="ogv")
+	String exl = p_path.get_extension().to_lower();
+	if (exl == "ogm" || exl == "ogv")
 		return "VideoStreamTheora";
 	return "";
 }
diff --git a/modules/theora/video_stream_theora.h b/modules/theora/video_stream_theora.h
index 0e1f5fa864..ea568906da 100644
--- a/modules/theora/video_stream_theora.h
+++ b/modules/theora/video_stream_theora.h
@@ -31,8 +31,8 @@
 
 #include "io/resource_loader.h"
 #include "os/file_access.h"
-#include "os/thread.h"
 #include "os/semaphore.h"
+#include "os/thread.h"
 #include "ring_buffer.h"
 #include "scene/resources/video_stream.h"
 
@@ -53,7 +53,7 @@ class VideoStreamPlaybackTheora : public VideoStreamPlayback {
 	Image::Format format;
 	PoolVector<uint8_t> frame_data;
 	int frames_pending;
-	FileAccess* file;
+	FileAccess *file;
 	String file_name;
 	int audio_frames_wrote;
 	Point2i size;
@@ -66,18 +66,18 @@ class VideoStreamPlaybackTheora : public VideoStreamPlayback {
 	bool theora_eos;
 	bool vorbis_eos;
 
-	ogg_sync_state   oy;
-	ogg_page         og;
+	ogg_sync_state oy;
+	ogg_page og;
 	ogg_stream_state vo;
 	ogg_stream_state to;
-	th_info      ti;
-	th_comment   tc;
-	th_dec_ctx       *td;
-	vorbis_info      vi;
+	th_info ti;
+	th_comment tc;
+	th_dec_ctx *td;
+	vorbis_info vi;
 	vorbis_dsp_state vd;
-	vorbis_block     vb;
-	vorbis_comment   vc;
-	th_pixel_fmt     px_fmt;
+	vorbis_block vb;
+	vorbis_comment vc;
+	th_pixel_fmt px_fmt;
 	double videobuf_time;
 	int pp_inc;
 
@@ -97,13 +97,13 @@ class VideoStreamPlaybackTheora : public VideoStreamPlayback {
 	Ref<ImageTexture> texture;
 
 	AudioMixCallback mix_callback;
-	void* mix_udata;
+	void *mix_udata;
 	bool paused;
 
 #ifdef THEORA_USE_THREAD_STREAMING
 
 	enum {
-		RB_SIZE_KB=1024
+		RB_SIZE_KB = 1024
 	};
 
 	RingBuffer<uint8_t> ring_buffer;
@@ -117,15 +117,12 @@ class VideoStreamPlaybackTheora : public VideoStreamPlayback {
 
 #endif
 
-
 	int audio_track;
 
 protected:
-
 	void clear();
-	
-public:
 
+public:
 	virtual void play();
 	virtual void stop();
 	virtual bool is_playing() const;
@@ -145,13 +142,12 @@ public:
 	virtual float get_pos() const;
 	virtual void seek_pos(float p_time);
 
-
-	void set_file(const String& p_file);
+	void set_file(const String &p_file);
 
 	virtual Ref<Texture> get_texture();
 	virtual void update(float p_delta);
 
-	virtual void set_mix_callback(AudioMixCallback p_callback,void *p_userdata);
+	virtual void set_mix_callback(AudioMixCallback p_callback, void *p_userdata);
 	virtual int get_channels() const;
 	virtual int get_mix_rate() const;
 
@@ -161,39 +157,33 @@ public:
 	~VideoStreamPlaybackTheora();
 };
 
-
-
 class VideoStreamTheora : public VideoStream {
 
-	GDCLASS(VideoStreamTheora,VideoStream);
+	GDCLASS(VideoStreamTheora, VideoStream);
 
 	String file;
 	int audio_track;
 
-
 public:
-
 	Ref<VideoStreamPlayback> instance_playback() {
-		Ref<VideoStreamPlaybackTheora> pb = memnew( VideoStreamPlaybackTheora );
+		Ref<VideoStreamPlaybackTheora> pb = memnew(VideoStreamPlaybackTheora);
 		pb->set_audio_track(audio_track);
 		pb->set_file(file);
 		return pb;
 	}
 
-	void set_file(const String& p_file) { file=p_file; }
-	void set_audio_track(int p_track) { audio_track=p_track; }
-
-    VideoStreamTheora() { audio_track=0; }
+	void set_file(const String &p_file) { file = p_file; }
+	void set_audio_track(int p_track) { audio_track = p_track; }
 
+	VideoStreamTheora() { audio_track = 0; }
 };
 
 class ResourceFormatLoaderVideoStreamTheora : public ResourceFormatLoader {
 public:
-	virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual bool handles_type(const String& p_type) const;
+	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;
-
 };
 
 #endif
diff --git a/modules/visual_script/register_types.cpp b/modules/visual_script/register_types.cpp
index 5fe87a4956..b05ea716ed 100644
--- a/modules/visual_script/register_types.cpp
+++ b/modules/visual_script/register_types.cpp
@@ -28,23 +28,21 @@
 /*************************************************************************/
 #include "register_types.h"
 
-#include "visual_script.h"
-#include "visual_script_editor.h"
 #include "io/resource_loader.h"
-#include "visual_script_nodes.h"
-#include "visual_script_func_nodes.h"
+#include "visual_script.h"
 #include "visual_script_builtin_funcs.h"
+#include "visual_script_editor.h"
+#include "visual_script_expression.h"
 #include "visual_script_flow_control.h"
+#include "visual_script_func_nodes.h"
+#include "visual_script_nodes.h"
 #include "visual_script_yield_nodes.h"
-#include "visual_script_expression.h"
-
-
-VisualScriptLanguage *visual_script_language=NULL;
 
+VisualScriptLanguage *visual_script_language = NULL;
 
 void register_visual_script_types() {
 
-	visual_script_language=memnew( VisualScriptLanguage );
+	visual_script_language = memnew(VisualScriptLanguage);
 	//script_language_gd->init();
 	ScriptServer::register_language(visual_script_language);
 
@@ -78,7 +76,6 @@ void register_visual_script_types() {
 	ClassDB::register_class<VisualScriptPreload>();
 	ClassDB::register_class<VisualScriptTypeCast>();
 
-
 	ClassDB::register_class<VisualScriptFunctionCall>();
 	ClassDB::register_class<VisualScriptPropertySet>();
 	ClassDB::register_class<VisualScriptPropertyGet>();
@@ -91,14 +88,13 @@ void register_visual_script_types() {
 	ClassDB::register_class<VisualScriptIterator>();
 	ClassDB::register_class<VisualScriptSequence>();
 	ClassDB::register_class<VisualScriptInputFilter>();
-	ClassDB::register_class<VisualScriptSwitch	>();
+	ClassDB::register_class<VisualScriptSwitch>();
 
 	ClassDB::register_class<VisualScriptYield>();
 	ClassDB::register_class<VisualScriptYieldSignal>();
 
 	ClassDB::register_class<VisualScriptBuiltinFunc>();
 
-
 	ClassDB::register_class<VisualScriptExpression>();
 
 	register_visual_script_nodes();
@@ -111,13 +107,10 @@ void register_visual_script_types() {
 #ifdef TOOLS_ENABLED
 	VisualScriptEditor::register_editor();
 #endif
-
-
 }
 
 void unregister_visual_script_types() {
 
-
 	unregister_visual_script_nodes();
 
 	ScriptServer::unregister_language(visual_script_language);
@@ -126,6 +119,5 @@ void unregister_visual_script_types() {
 	VisualScriptEditor::free_clipboard();
 #endif
 	if (visual_script_language)
-		memdelete( visual_script_language );
-
+		memdelete(visual_script_language);
 }
diff --git a/modules/visual_script/visual_script.cpp b/modules/visual_script/visual_script.cpp
index 9f742591d5..2b884c34fb 100644
--- a/modules/visual_script/visual_script.cpp
+++ b/modules/visual_script/visual_script.cpp
@@ -28,16 +28,14 @@
 /*************************************************************************/
 #include "visual_script.h"
 
-#include "visual_script_nodes.h"
-#include "scene/main/node.h"
-#include "os/os.h"
 #include "global_config.h"
-
-
+#include "os/os.h"
+#include "scene/main/node.h"
+#include "visual_script_nodes.h"
 
 //used by editor, this is not really saved
 void VisualScriptNode::set_breakpoint(bool p_breakpoint) {
-	breakpoint=p_breakpoint;
+	breakpoint = p_breakpoint;
 }
 
 bool VisualScriptNode::is_breakpoint() const {
@@ -47,76 +45,68 @@ bool VisualScriptNode::is_breakpoint() const {
 
 void VisualScriptNode::_notification(int p_what) {
 
-	if (p_what==NOTIFICATION_POSTINITIALIZE) {
+	if (p_what == NOTIFICATION_POSTINITIALIZE) {
 
 		int dvc = get_input_value_port_count();
-		for(int i=0;i<dvc;i++) {
+		for (int i = 0; i < dvc; i++) {
 			Variant::Type expected = get_input_value_port_info(i).type;
 			Variant::CallError ce;
-			default_input_values.push_back(Variant::construct(expected,NULL,0,ce,false));
+			default_input_values.push_back(Variant::construct(expected, NULL, 0, ce, false));
 		}
 	}
 }
 
-void VisualScriptNode::ports_changed_notify(){
+void VisualScriptNode::ports_changed_notify() {
 
-
-	default_input_values.resize( MAX(default_input_values.size(),get_input_value_port_count()) ); //let it grow as big as possible, we don't want to lose values on resize
+	default_input_values.resize(MAX(default_input_values.size(), get_input_value_port_count())); //let it grow as big as possible, we don't want to lose values on resize
 
 	emit_signal("ports_changed");
-
 }
 
-void VisualScriptNode::set_default_input_value(int p_port,const Variant& p_value) {
+void VisualScriptNode::set_default_input_value(int p_port, const Variant &p_value) {
 
-	ERR_FAIL_INDEX(p_port,default_input_values.size());
+	ERR_FAIL_INDEX(p_port, default_input_values.size());
 
-	default_input_values[p_port]=p_value;
+	default_input_values[p_port] = p_value;
 
 #ifdef TOOLS_ENABLED
-	for (Set<VisualScript*>::Element *E=scripts_used.front();E;E=E->next()) {
+	for (Set<VisualScript *>::Element *E = scripts_used.front(); E; E = E->next()) {
 		E->get()->set_edited(true);
 	}
 #endif
-
 }
 
 Variant VisualScriptNode::get_default_input_value(int p_port) const {
 
-	ERR_FAIL_INDEX_V(p_port,default_input_values.size(),Variant());
+	ERR_FAIL_INDEX_V(p_port, default_input_values.size(), Variant());
 	return default_input_values[p_port];
 }
 
 void VisualScriptNode::_set_default_input_values(Array p_values) {
 
-
-	default_input_values=p_values;
+	default_input_values = p_values;
 }
 
-
 void VisualScriptNode::validate_input_default_values() {
 
-
-
 	default_input_values.resize(get_input_value_port_count());
 
 	//actually validate on save
-	for(int i=0;i<get_input_value_port_count();i++) {
+	for (int i = 0; i < get_input_value_port_count(); i++) {
 
 		Variant::Type expected = get_input_value_port_info(i).type;
 
-
-		if (expected==Variant::NIL || expected==default_input_values[i].get_type()) {
+		if (expected == Variant::NIL || expected == default_input_values[i].get_type()) {
 			continue;
-		} else  {
+		} else {
 			//not the same, reconvert
 			Variant::CallError ce;
 			Variant existing = default_input_values[i];
-			const Variant *existingp=&existing;
-			default_input_values[i] = Variant::construct(expected,&existingp,1,ce,false);
-			if (ce.error!=Variant::CallError::CALL_OK) {
+			const Variant *existingp = &existing;
+			default_input_values[i] = Variant::construct(expected, &existingp, 1, ce, false);
+			if (ce.error != Variant::CallError::CALL_OK) {
 				//could not convert? force..
-				default_input_values[i] = Variant::construct(expected,NULL,0,ce,false);
+				default_input_values[i] = Variant::construct(expected, NULL, 0, ce, false);
 			}
 		}
 	}
@@ -129,29 +119,27 @@ Array VisualScriptNode::_get_default_input_values() const {
 	return default_input_values;
 }
 
-
-
 void VisualScriptNode::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("get_visual_script:VisualScript"),&VisualScriptNode::get_visual_script);
-	ClassDB::bind_method(D_METHOD("set_default_input_value","port_idx","value:Variant"),&VisualScriptNode::set_default_input_value);
-	ClassDB::bind_method(D_METHOD("get_default_input_value:Variant","port_idx"),&VisualScriptNode::get_default_input_value);
-	ClassDB::bind_method(D_METHOD("_set_default_input_values","values"),&VisualScriptNode::_set_default_input_values);
-	ClassDB::bind_method(D_METHOD("_get_default_input_values"),&VisualScriptNode::_get_default_input_values);
+	ClassDB::bind_method(D_METHOD("get_visual_script:VisualScript"), &VisualScriptNode::get_visual_script);
+	ClassDB::bind_method(D_METHOD("set_default_input_value", "port_idx", "value:Variant"), &VisualScriptNode::set_default_input_value);
+	ClassDB::bind_method(D_METHOD("get_default_input_value:Variant", "port_idx"), &VisualScriptNode::get_default_input_value);
+	ClassDB::bind_method(D_METHOD("_set_default_input_values", "values"), &VisualScriptNode::_set_default_input_values);
+	ClassDB::bind_method(D_METHOD("_get_default_input_values"), &VisualScriptNode::_get_default_input_values);
 
-	ADD_PROPERTY(PropertyInfo(Variant::ARRAY,"_default_input_values",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"_set_default_input_values","_get_default_input_values");
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "_default_input_values", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_default_input_values", "_get_default_input_values");
 	ADD_SIGNAL(MethodInfo("ports_changed"));
 }
 
-VisualScriptNode::TypeGuess VisualScriptNode::guess_output_type(TypeGuess* p_inputs,int p_output) const {
+VisualScriptNode::TypeGuess VisualScriptNode::guess_output_type(TypeGuess *p_inputs, int p_output) const {
 
 	PropertyInfo pinfo = get_output_value_port_info(p_output);
 
 	TypeGuess tg;
 
-	tg.type=pinfo.type;
-	if (pinfo.hint==PROPERTY_HINT_RESOURCE_TYPE) {
-		tg.GDCLASS=pinfo.hint_string;
+	tg.type = pinfo.type;
+	if (pinfo.hint == PROPERTY_HINT_RESOURCE_TYPE) {
+		tg.GDCLASS = pinfo.hint_string;
 	}
 
 	return tg;
@@ -166,7 +154,7 @@ Ref<VisualScript> VisualScriptNode::get_visual_script() const {
 }
 
 VisualScriptNode::VisualScriptNode() {
-	breakpoint=false;
+	breakpoint = false;
 }
 
 ////////////////
@@ -175,8 +163,8 @@ VisualScriptNode::VisualScriptNode() {
 
 VisualScriptNodeInstance::VisualScriptNodeInstance() {
 
-	sequence_outputs=NULL;
-	input_ports=NULL;
+	sequence_outputs = NULL;
+	input_ports = NULL;
 }
 
 VisualScriptNodeInstance::~VisualScriptNodeInstance() {
@@ -192,44 +180,41 @@ VisualScriptNodeInstance::~VisualScriptNodeInstance() {
 	if (output_ports) {
 		memdelete_arr(output_ports);
 	}
-
 }
 
-void VisualScript::add_function(const StringName& p_name) {
+void VisualScript::add_function(const StringName &p_name) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!String(p_name).is_valid_identifier());
 	ERR_FAIL_COND(functions.has(p_name));
 
-	functions[p_name]=Function();
-	functions[p_name].scroll=Vector2(-50,-100);
+	functions[p_name] = Function();
+	functions[p_name].scroll = Vector2(-50, -100);
 }
 
-bool VisualScript::has_function(const StringName& p_name) const {
+bool VisualScript::has_function(const StringName &p_name) const {
 
 	return functions.has(p_name);
-
 }
-void VisualScript::remove_function(const StringName& p_name) {
+void VisualScript::remove_function(const StringName &p_name) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!functions.has(p_name));
 
-	for (Map<int,Function::NodeData>::Element *E=functions[p_name].nodes.front();E;E=E->next()) {
+	for (Map<int, Function::NodeData>::Element *E = functions[p_name].nodes.front(); E; E = E->next()) {
 
-		E->get().node->disconnect("ports_changed",this,"_node_ports_changed");
+		E->get().node->disconnect("ports_changed", this, "_node_ports_changed");
 		E->get().node->scripts_used.erase(this);
 	}
 
 	functions.erase(p_name);
-
 }
 
-void VisualScript::rename_function(const StringName& p_name,const StringName& p_new_name) {
+void VisualScript::rename_function(const StringName &p_name, const StringName &p_new_name) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!functions.has(p_name));
-	if (p_new_name==p_name)
+	if (p_new_name == p_name)
 		return;
 
 	ERR_FAIL_COND(!String(p_new_name).is_valid_identifier());
@@ -238,60 +223,51 @@ void VisualScript::rename_function(const StringName& p_name,const StringName& p_
 	ERR_FAIL_COND(variables.has(p_new_name));
 	ERR_FAIL_COND(custom_signals.has(p_new_name));
 
-	functions[p_new_name]=functions[p_name];
+	functions[p_new_name] = functions[p_name];
 	functions.erase(p_name);
-
 }
 
-void VisualScript::set_function_scroll(const StringName& p_name, const Vector2& p_scroll) {
+void VisualScript::set_function_scroll(const StringName &p_name, const Vector2 &p_scroll) {
 
 	ERR_FAIL_COND(!functions.has(p_name));
-	functions[p_name].scroll=p_scroll;
-
+	functions[p_name].scroll = p_scroll;
 }
 
-Vector2 VisualScript::get_function_scroll(const StringName& p_name) const {
+Vector2 VisualScript::get_function_scroll(const StringName &p_name) const {
 
-	ERR_FAIL_COND_V(!functions.has(p_name),Vector2());
+	ERR_FAIL_COND_V(!functions.has(p_name), Vector2());
 	return functions[p_name].scroll;
-
 }
 
-
 void VisualScript::get_function_list(List<StringName> *r_functions) const {
 
-	for (const Map<StringName,Function>::Element *E=functions.front();E;E=E->next()) {
+	for (const Map<StringName, Function>::Element *E = functions.front(); E; E = E->next()) {
 		r_functions->push_back(E->key());
 	}
 
 	r_functions->sort_custom<StringName::AlphCompare>();
-
 }
 
-int VisualScript::get_function_node_id(const StringName& p_name) const {
+int VisualScript::get_function_node_id(const StringName &p_name) const {
 
-	ERR_FAIL_COND_V(!functions.has(p_name),-1);
+	ERR_FAIL_COND_V(!functions.has(p_name), -1);
 
 	return functions[p_name].function_id;
-
 }
 
-
 void VisualScript::_node_ports_changed(int p_id) {
 
-
-
 	StringName function;
 
-	for (Map<StringName,Function>::Element *E=functions.front();E;E=E->next()) {
+	for (Map<StringName, Function>::Element *E = functions.front(); E; E = E->next()) {
 
 		if (E->get().nodes.has(p_id)) {
-			function=E->key();
+			function = E->key();
 			break;
 		}
 	}
 
-	ERR_FAIL_COND(function==StringName());
+	ERR_FAIL_COND(function == StringName());
 
 	Function &func = functions[function];
 	Ref<VisualScriptNode> vsn = func.nodes[p_id].node;
@@ -305,18 +281,18 @@ void VisualScript::_node_ports_changed(int p_id) {
 	{
 		List<SequenceConnection> to_remove;
 
-		for (Set<SequenceConnection>::Element *E=func.sequence_connections.front();E;E=E->next()) {
-			if (E->get().from_node==p_id && E->get().from_output>=vsn->get_output_sequence_port_count()) {
+		for (Set<SequenceConnection>::Element *E = func.sequence_connections.front(); E; E = E->next()) {
+			if (E->get().from_node == p_id && E->get().from_output >= vsn->get_output_sequence_port_count()) {
 
 				to_remove.push_back(E->get());
 			}
-			if (E->get().to_node==p_id && !vsn->has_input_sequence_port()) {
+			if (E->get().to_node == p_id && !vsn->has_input_sequence_port()) {
 
 				to_remove.push_back(E->get());
 			}
 		}
 
-		while(to_remove.size()) {
+		while (to_remove.size()) {
 			func.sequence_connections.erase(to_remove.front()->get());
 			to_remove.pop_front();
 		}
@@ -326,17 +302,16 @@ void VisualScript::_node_ports_changed(int p_id) {
 
 		List<DataConnection> to_remove;
 
-
-		for (Set<DataConnection>::Element *E=func.data_connections.front();E;E=E->next()) {
-			if (E->get().from_node==p_id && E->get().from_port>=vsn->get_output_value_port_count()) {
+		for (Set<DataConnection>::Element *E = func.data_connections.front(); E; E = E->next()) {
+			if (E->get().from_node == p_id && E->get().from_port >= vsn->get_output_value_port_count()) {
 				to_remove.push_back(E->get());
 			}
-			if (E->get().to_node==p_id && E->get().to_port>=vsn->get_input_value_port_count()) {
+			if (E->get().to_node == p_id && E->get().to_port >= vsn->get_input_value_port_count()) {
 				to_remove.push_back(E->get());
 			}
 		}
 
-		while(to_remove.size()) {
+		while (to_remove.size()) {
 			func.data_connections.erase(to_remove.front()->get());
 			to_remove.pop_front();
 		}
@@ -344,48 +319,44 @@ void VisualScript::_node_ports_changed(int p_id) {
 
 #ifdef TOOLS_ENABLED
 	set_edited(true); //something changed, let's set as edited
-	emit_signal("node_ports_changed",function,p_id);
+	emit_signal("node_ports_changed", function, p_id);
 #endif
 }
 
-void VisualScript::add_node(const StringName& p_func,int p_id, const Ref<VisualScriptNode>& p_node, const Point2 &p_pos) {
+void VisualScript::add_node(const StringName &p_func, int p_id, const Ref<VisualScriptNode> &p_node, const Point2 &p_pos) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!functions.has(p_func));
 
-
-	for (Map<StringName,Function>::Element *E=functions.front();E;E=E->next()) {
+	for (Map<StringName, Function>::Element *E = functions.front(); E; E = E->next()) {
 
 		ERR_FAIL_COND(E->get().nodes.has(p_id)); //id can exist only one in script, even for different functions
 	}
 
 	Function &func = functions[p_func];
 
-
 	if (p_node->cast_to<VisualScriptFunction>()) {
 		//the function indeed
 		ERR_EXPLAIN("A function node already has been set here.");
-		ERR_FAIL_COND(func.function_id>=0);
+		ERR_FAIL_COND(func.function_id >= 0);
 
-		func.function_id=p_id;
+		func.function_id = p_id;
 	}
 
 	Function::NodeData nd;
-	nd.node=p_node;
-	nd.pos=p_pos;
+	nd.node = p_node;
+	nd.pos = p_pos;
 
 	Ref<VisualScriptNode> vsn = p_node;
-	vsn->connect("ports_changed",this,"_node_ports_changed",varray(p_id));
+	vsn->connect("ports_changed", this, "_node_ports_changed", varray(p_id));
 	vsn->scripts_used.insert(this);
 
-
-
-	func.nodes[p_id]=nd;
+	func.nodes[p_id] = nd;
 }
 
-void VisualScript::remove_node(const StringName& p_func,int p_id){
+void VisualScript::remove_node(const StringName &p_func, int p_id) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!functions.has(p_func));
 	Function &func = functions[p_func];
 
@@ -393,13 +364,13 @@ void VisualScript::remove_node(const StringName& p_func,int p_id){
 	{
 		List<SequenceConnection> to_remove;
 
-		for (Set<SequenceConnection>::Element *E=func.sequence_connections.front();E;E=E->next()) {
-			if (E->get().from_node==p_id || E->get().to_node==p_id) {
+		for (Set<SequenceConnection>::Element *E = func.sequence_connections.front(); E; E = E->next()) {
+			if (E->get().from_node == p_id || E->get().to_node == p_id) {
 				to_remove.push_back(E->get());
 			}
 		}
 
-		while(to_remove.size()) {
+		while (to_remove.size()) {
 			func.sequence_connections.erase(to_remove.front()->get());
 			to_remove.pop_front();
 		}
@@ -409,254 +380,239 @@ void VisualScript::remove_node(const StringName& p_func,int p_id){
 
 		List<DataConnection> to_remove;
 
-
-		for (Set<DataConnection>::Element *E=func.data_connections.front();E;E=E->next()) {
-			if (E->get().from_node==p_id || E->get().to_node==p_id) {
+		for (Set<DataConnection>::Element *E = func.data_connections.front(); E; E = E->next()) {
+			if (E->get().from_node == p_id || E->get().to_node == p_id) {
 				to_remove.push_back(E->get());
 			}
 		}
 
-		while(to_remove.size()) {
+		while (to_remove.size()) {
 			func.data_connections.erase(to_remove.front()->get());
 			to_remove.pop_front();
 		}
 	}
 
 	if (func.nodes[p_id].node->cast_to<VisualScriptFunction>()) {
-		func.function_id=-1; //revert to invalid
+		func.function_id = -1; //revert to invalid
 	}
 
-	func.nodes[p_id].node->disconnect("ports_changed",this,"_node_ports_changed");
+	func.nodes[p_id].node->disconnect("ports_changed", this, "_node_ports_changed");
 	func.nodes[p_id].node->scripts_used.erase(this);
 
 	func.nodes.erase(p_id);
-
-
 }
 
+bool VisualScript::has_node(const StringName &p_func, int p_id) const {
 
-bool VisualScript::has_node(const StringName& p_func,int p_id) const {
-
-	ERR_FAIL_COND_V(!functions.has(p_func),false);
+	ERR_FAIL_COND_V(!functions.has(p_func), false);
 	const Function &func = functions[p_func];
 
 	return func.nodes.has(p_id);
 }
 
-Ref<VisualScriptNode> VisualScript::get_node(const StringName& p_func,int p_id) const{
+Ref<VisualScriptNode> VisualScript::get_node(const StringName &p_func, int p_id) const {
 
-	ERR_FAIL_COND_V(!functions.has(p_func),Ref<VisualScriptNode>());
+	ERR_FAIL_COND_V(!functions.has(p_func), Ref<VisualScriptNode>());
 	const Function &func = functions[p_func];
 
-	ERR_FAIL_COND_V(!func.nodes.has(p_id),Ref<VisualScriptNode>());
+	ERR_FAIL_COND_V(!func.nodes.has(p_id), Ref<VisualScriptNode>());
 
 	return func.nodes[p_id].node;
 }
 
-void VisualScript::set_node_pos(const StringName& p_func,int p_id,const Point2& p_pos) {
+void VisualScript::set_node_pos(const StringName &p_func, int p_id, const Point2 &p_pos) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!functions.has(p_func));
 	Function &func = functions[p_func];
 
 	ERR_FAIL_COND(!func.nodes.has(p_id));
-	func.nodes[p_id].pos=p_pos;
+	func.nodes[p_id].pos = p_pos;
 }
 
-Point2 VisualScript::get_node_pos(const StringName& p_func,int p_id) const{
+Point2 VisualScript::get_node_pos(const StringName &p_func, int p_id) const {
 
-	ERR_FAIL_COND_V(!functions.has(p_func),Point2());
+	ERR_FAIL_COND_V(!functions.has(p_func), Point2());
 	const Function &func = functions[p_func];
 
-	ERR_FAIL_COND_V(!func.nodes.has(p_id),Point2());
+	ERR_FAIL_COND_V(!func.nodes.has(p_id), Point2());
 	return func.nodes[p_id].pos;
 }
 
-
-void VisualScript::get_node_list(const StringName& p_func,List<int> *r_nodes) const{
+void VisualScript::get_node_list(const StringName &p_func, List<int> *r_nodes) const {
 
 	ERR_FAIL_COND(!functions.has(p_func));
 	const Function &func = functions[p_func];
 
-	for (const Map<int,Function::NodeData>::Element *E=func.nodes.front();E;E=E->next()) {
+	for (const Map<int, Function::NodeData>::Element *E = func.nodes.front(); E; E = E->next()) {
 		r_nodes->push_back(E->key());
 	}
-
 }
 
+void VisualScript::sequence_connect(const StringName &p_func, int p_from_node, int p_from_output, int p_to_node) {
 
-void VisualScript::sequence_connect(const StringName& p_func,int p_from_node,int p_from_output,int p_to_node){
-
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!functions.has(p_func));
 	Function &func = functions[p_func];
 
-
 	SequenceConnection sc;
-	sc.from_node=p_from_node;
-	sc.from_output=p_from_output;
-	sc.to_node=p_to_node;
+	sc.from_node = p_from_node;
+	sc.from_output = p_from_output;
+	sc.to_node = p_to_node;
 	ERR_FAIL_COND(func.sequence_connections.has(sc));
 
 	func.sequence_connections.insert(sc);
-
 }
 
-void VisualScript::sequence_disconnect(const StringName& p_func,int p_from_node,int p_from_output,int p_to_node){
+void VisualScript::sequence_disconnect(const StringName &p_func, int p_from_node, int p_from_output, int p_to_node) {
 
 	ERR_FAIL_COND(!functions.has(p_func));
 	Function &func = functions[p_func];
 
 	SequenceConnection sc;
-	sc.from_node=p_from_node;
-	sc.from_output=p_from_output;
-	sc.to_node=p_to_node;
+	sc.from_node = p_from_node;
+	sc.from_output = p_from_output;
+	sc.to_node = p_to_node;
 	ERR_FAIL_COND(!func.sequence_connections.has(sc));
 
 	func.sequence_connections.erase(sc);
-
 }
 
-bool VisualScript::has_sequence_connection(const StringName& p_func,int p_from_node,int p_from_output,int p_to_node) const{
+bool VisualScript::has_sequence_connection(const StringName &p_func, int p_from_node, int p_from_output, int p_to_node) const {
 
-	ERR_FAIL_COND_V(!functions.has(p_func),false);
+	ERR_FAIL_COND_V(!functions.has(p_func), false);
 	const Function &func = functions[p_func];
 
 	SequenceConnection sc;
-	sc.from_node=p_from_node;
-	sc.from_output=p_from_output;
-	sc.to_node=p_to_node;
+	sc.from_node = p_from_node;
+	sc.from_output = p_from_output;
+	sc.to_node = p_to_node;
 
 	return func.sequence_connections.has(sc);
 }
 
-void VisualScript::get_sequence_connection_list(const StringName& p_func,List<SequenceConnection> *r_connection) const {
+void VisualScript::get_sequence_connection_list(const StringName &p_func, List<SequenceConnection> *r_connection) const {
 
 	ERR_FAIL_COND(!functions.has(p_func));
 	const Function &func = functions[p_func];
 
-	for (const Set<SequenceConnection>::Element *E=func.sequence_connections.front();E;E=E->next()) {
+	for (const Set<SequenceConnection>::Element *E = func.sequence_connections.front(); E; E = E->next()) {
 		r_connection->push_back(E->get());
 	}
 }
 
+void VisualScript::data_connect(const StringName &p_func, int p_from_node, int p_from_port, int p_to_node, int p_to_port) {
 
-void VisualScript::data_connect(const StringName& p_func,int p_from_node,int p_from_port,int p_to_node,int p_to_port) {
-
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!functions.has(p_func));
 	Function &func = functions[p_func];
 
 	DataConnection dc;
-	dc.from_node=p_from_node;
-	dc.from_port=p_from_port;
-	dc.to_node=p_to_node;
-	dc.to_port=p_to_port;
+	dc.from_node = p_from_node;
+	dc.from_port = p_from_port;
+	dc.to_node = p_to_node;
+	dc.to_port = p_to_port;
 
-	ERR_FAIL_COND( func.data_connections.has(dc));
+	ERR_FAIL_COND(func.data_connections.has(dc));
 
 	func.data_connections.insert(dc);
 }
 
-void VisualScript::data_disconnect(const StringName& p_func,int p_from_node,int p_from_port,int p_to_node,int p_to_port) {
+void VisualScript::data_disconnect(const StringName &p_func, int p_from_node, int p_from_port, int p_to_node, int p_to_port) {
 
 	ERR_FAIL_COND(!functions.has(p_func));
 	Function &func = functions[p_func];
 
 	DataConnection dc;
-	dc.from_node=p_from_node;
-	dc.from_port=p_from_port;
-	dc.to_node=p_to_node;
-	dc.to_port=p_to_port;
+	dc.from_node = p_from_node;
+	dc.from_port = p_from_port;
+	dc.to_node = p_to_node;
+	dc.to_port = p_to_port;
 
-	ERR_FAIL_COND( !func.data_connections.has(dc));
+	ERR_FAIL_COND(!func.data_connections.has(dc));
 
 	func.data_connections.erase(dc);
-
 }
 
-bool VisualScript::has_data_connection(const StringName& p_func,int p_from_node,int p_from_port,int p_to_node,int p_to_port) const {
+bool VisualScript::has_data_connection(const StringName &p_func, int p_from_node, int p_from_port, int p_to_node, int p_to_port) const {
 
-	ERR_FAIL_COND_V(!functions.has(p_func),false);
+	ERR_FAIL_COND_V(!functions.has(p_func), false);
 	const Function &func = functions[p_func];
 
 	DataConnection dc;
-	dc.from_node=p_from_node;
-	dc.from_port=p_from_port;
-	dc.to_node=p_to_node;
-	dc.to_port=p_to_port;
+	dc.from_node = p_from_node;
+	dc.from_port = p_from_port;
+	dc.to_node = p_to_node;
+	dc.to_port = p_to_port;
 
 	return func.data_connections.has(dc);
-
 }
 
-bool VisualScript::is_input_value_port_connected(const StringName& p_func,int p_node,int p_port) const {
+bool VisualScript::is_input_value_port_connected(const StringName &p_func, int p_node, int p_port) const {
 
-	ERR_FAIL_COND_V(!functions.has(p_func),false);
+	ERR_FAIL_COND_V(!functions.has(p_func), false);
 	const Function &func = functions[p_func];
 
-	for (const Set<DataConnection>::Element *E=func.data_connections.front();E;E=E->next()) {
-		if (E->get().to_node==p_node && E->get().to_port==p_port)
+	for (const Set<DataConnection>::Element *E = func.data_connections.front(); E; E = E->next()) {
+		if (E->get().to_node == p_node && E->get().to_port == p_port)
 			return true;
 	}
 
 	return false;
 }
 
-bool VisualScript::get_input_value_port_connection_source(const StringName& p_func,int p_node,int p_port,int *r_node,int *r_port) const {
+bool VisualScript::get_input_value_port_connection_source(const StringName &p_func, int p_node, int p_port, int *r_node, int *r_port) const {
 
-	ERR_FAIL_COND_V(!functions.has(p_func),false);
+	ERR_FAIL_COND_V(!functions.has(p_func), false);
 	const Function &func = functions[p_func];
 
-	for (const Set<DataConnection>::Element *E=func.data_connections.front();E;E=E->next()) {
-		if (E->get().to_node==p_node && E->get().to_port==p_port) {
-			*r_node=E->get().from_node;
-			*r_port=E->get().from_port;
+	for (const Set<DataConnection>::Element *E = func.data_connections.front(); E; E = E->next()) {
+		if (E->get().to_node == p_node && E->get().to_port == p_port) {
+			*r_node = E->get().from_node;
+			*r_port = E->get().from_port;
 			return true;
 		}
 	}
 
 	return false;
-
 }
 
-void VisualScript::get_data_connection_list(const StringName& p_func,List<DataConnection> *r_connection) const {
+void VisualScript::get_data_connection_list(const StringName &p_func, List<DataConnection> *r_connection) const {
 
 	ERR_FAIL_COND(!functions.has(p_func));
 	const Function &func = functions[p_func];
 
-	for (const Set<DataConnection>::Element *E=func.data_connections.front();E;E=E->next()) {
+	for (const Set<DataConnection>::Element *E = func.data_connections.front(); E; E = E->next()) {
 		r_connection->push_back(E->get());
 	}
 }
 
-void VisualScript::add_variable(const StringName& p_name,const Variant& p_default_value,bool p_export) {
+void VisualScript::add_variable(const StringName &p_name, const Variant &p_default_value, bool p_export) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!String(p_name).is_valid_identifier());
 	ERR_FAIL_COND(variables.has(p_name));
 
 	Variable v;
-	v.default_value=p_default_value;
-	v.info.type=p_default_value.get_type();
-	v.info.name=p_name;
-	v.info.hint=PROPERTY_HINT_NONE;
-	v._export=p_export;
+	v.default_value = p_default_value;
+	v.info.type = p_default_value.get_type();
+	v.info.name = p_name;
+	v.info.hint = PROPERTY_HINT_NONE;
+	v._export = p_export;
 
-	variables[p_name]=v;
+	variables[p_name] = v;
 
 #ifdef TOOLS_ENABLED
 	_update_placeholders();
 #endif
-
 }
 
-bool VisualScript::has_variable(const StringName& p_name) const {
+bool VisualScript::has_variable(const StringName &p_name) const {
 
 	return variables.has(p_name);
 }
 
-void VisualScript::remove_variable(const StringName& p_name) {
+void VisualScript::remove_variable(const StringName &p_name) {
 
 	ERR_FAIL_COND(!variables.has(p_name));
 	variables.erase(p_name);
@@ -666,111 +622,101 @@ void VisualScript::remove_variable(const StringName& p_name) {
 #endif
 }
 
-void VisualScript::set_variable_default_value(const StringName& p_name,const Variant& p_value){
+void VisualScript::set_variable_default_value(const StringName &p_name, const Variant &p_value) {
 
 	ERR_FAIL_COND(!variables.has(p_name));
 
-	variables[p_name].default_value=p_value;
+	variables[p_name].default_value = p_value;
 
 #ifdef TOOLS_ENABLED
 	_update_placeholders();
 #endif
-
-
 }
-Variant VisualScript::get_variable_default_value(const StringName& p_name) const{
+Variant VisualScript::get_variable_default_value(const StringName &p_name) const {
 
-	ERR_FAIL_COND_V(!variables.has(p_name),Variant());
+	ERR_FAIL_COND_V(!variables.has(p_name), Variant());
 	return variables[p_name].default_value;
-
 }
-void VisualScript::set_variable_info(const StringName& p_name,const PropertyInfo& p_info){
+void VisualScript::set_variable_info(const StringName &p_name, const PropertyInfo &p_info) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!variables.has(p_name));
-	variables[p_name].info=p_info;
-	variables[p_name].info.name=p_name;
+	variables[p_name].info = p_info;
+	variables[p_name].info.name = p_name;
 
 #ifdef TOOLS_ENABLED
 	_update_placeholders();
 #endif
-
-
 }
-PropertyInfo VisualScript::get_variable_info(const StringName& p_name) const{
+PropertyInfo VisualScript::get_variable_info(const StringName &p_name) const {
 
-	ERR_FAIL_COND_V(!variables.has(p_name),PropertyInfo());
+	ERR_FAIL_COND_V(!variables.has(p_name), PropertyInfo());
 	return variables[p_name].info;
 }
 
-void VisualScript::set_variable_export(const StringName& p_name,bool p_export) {
+void VisualScript::set_variable_export(const StringName &p_name, bool p_export) {
 
 	ERR_FAIL_COND(!variables.has(p_name));
 
-	variables[p_name]._export=p_export;
+	variables[p_name]._export = p_export;
 }
 
-bool VisualScript::get_variable_export(const StringName& p_name) const {
+bool VisualScript::get_variable_export(const StringName &p_name) const {
 
-	ERR_FAIL_COND_V(!variables.has(p_name),false);
+	ERR_FAIL_COND_V(!variables.has(p_name), false);
 	return variables[p_name]._export;
-
 }
 
-
-void VisualScript::_set_variable_info(const StringName& p_name,const Dictionary& p_info) {
+void VisualScript::_set_variable_info(const StringName &p_name, const Dictionary &p_info) {
 
 	PropertyInfo pinfo;
 	if (p_info.has("type"))
-		pinfo.type=Variant::Type(int(p_info["type"]));
+		pinfo.type = Variant::Type(int(p_info["type"]));
 	if (p_info.has("name"))
-		pinfo.name=p_info["name"];
+		pinfo.name = p_info["name"];
 	if (p_info.has("hint"))
-		pinfo.hint=PropertyHint(int(p_info["hint"]));
+		pinfo.hint = PropertyHint(int(p_info["hint"]));
 	if (p_info.has("hint_string"))
-		pinfo.hint_string=p_info["hint_string"];
+		pinfo.hint_string = p_info["hint_string"];
 	if (p_info.has("usage"))
-		pinfo.usage=p_info["usage"];
+		pinfo.usage = p_info["usage"];
 
-	set_variable_info(p_name,pinfo);
+	set_variable_info(p_name, pinfo);
 }
 
-Dictionary VisualScript::_get_variable_info(const StringName& p_name) const{
+Dictionary VisualScript::_get_variable_info(const StringName &p_name) const {
 
-	PropertyInfo pinfo=get_variable_info(p_name);
+	PropertyInfo pinfo = get_variable_info(p_name);
 	Dictionary d;
-	d["type"]=pinfo.type;
-	d["name"]=pinfo.name;
-	d["hint"]=pinfo.hint;
-	d["hint_string"]=pinfo.hint_string;
-	d["usage"]=pinfo.usage;
+	d["type"] = pinfo.type;
+	d["name"] = pinfo.name;
+	d["hint"] = pinfo.hint;
+	d["hint_string"] = pinfo.hint_string;
+	d["usage"] = pinfo.usage;
 
 	return d;
 }
 
-void VisualScript::get_variable_list(List<StringName> *r_variables) const{
-
+void VisualScript::get_variable_list(List<StringName> *r_variables) const {
 
-	for (Map<StringName,Variable>::Element *E=variables.front();E;E=E->next()) {
+	for (Map<StringName, Variable>::Element *E = variables.front(); E; E = E->next()) {
 		r_variables->push_back(E->key());
 	}
 
 	r_variables->sort_custom<StringName::AlphCompare>();
 }
 
+void VisualScript::set_instance_base_type(const StringName &p_type) {
 
-void VisualScript::set_instance_base_type(const StringName& p_type) {
-
-	ERR_FAIL_COND( instances.size() );
-	base_type=p_type;
+	ERR_FAIL_COND(instances.size());
+	base_type = p_type;
 }
 
+void VisualScript::rename_variable(const StringName &p_name, const StringName &p_new_name) {
 
-void VisualScript::rename_variable(const StringName& p_name,const StringName& p_new_name) {
-
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!variables.has(p_name));
-	if (p_new_name==p_name)
+	if (p_new_name == p_name)
 		return;
 
 	ERR_FAIL_COND(!String(p_new_name).is_valid_identifier());
@@ -779,103 +725,94 @@ void VisualScript::rename_variable(const StringName& p_name,const StringName& p_
 	ERR_FAIL_COND(variables.has(p_new_name));
 	ERR_FAIL_COND(custom_signals.has(p_new_name));
 
-	variables[p_new_name]=variables[p_name];
+	variables[p_new_name] = variables[p_name];
 	variables.erase(p_name);
-
 }
 
-void VisualScript::add_custom_signal(const StringName& p_name) {
+void VisualScript::add_custom_signal(const StringName &p_name) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!String(p_name).is_valid_identifier());
 	ERR_FAIL_COND(custom_signals.has(p_name));
 
-	custom_signals[p_name]=Vector<Argument>();
+	custom_signals[p_name] = Vector<Argument>();
 }
 
-bool VisualScript::has_custom_signal(const StringName& p_name) const {
+bool VisualScript::has_custom_signal(const StringName &p_name) const {
 
 	return custom_signals.has(p_name);
-
 }
-void VisualScript::custom_signal_add_argument(const StringName& p_func,Variant::Type p_type,const String& p_name,int p_index) {
+void VisualScript::custom_signal_add_argument(const StringName &p_func, Variant::Type p_type, const String &p_name, int p_index) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!custom_signals.has(p_func));
 	Argument arg;
-	arg.type=p_type;
-	arg.name=p_name;
-	if (p_index<0)
+	arg.type = p_type;
+	arg.name = p_name;
+	if (p_index < 0)
 		custom_signals[p_func].push_back(arg);
 	else
-		custom_signals[p_func].insert(0,arg);
-
+		custom_signals[p_func].insert(0, arg);
 }
-void VisualScript::custom_signal_set_argument_type(const StringName& p_func,int p_argidx,Variant::Type p_type) {
+void VisualScript::custom_signal_set_argument_type(const StringName &p_func, int p_argidx, Variant::Type p_type) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!custom_signals.has(p_func));
-	ERR_FAIL_INDEX(p_argidx,custom_signals[p_func].size());
-	custom_signals[p_func][p_argidx].type=p_type;
+	ERR_FAIL_INDEX(p_argidx, custom_signals[p_func].size());
+	custom_signals[p_func][p_argidx].type = p_type;
 }
-Variant::Type VisualScript::custom_signal_get_argument_type(const StringName& p_func,int p_argidx) const  {
+Variant::Type VisualScript::custom_signal_get_argument_type(const StringName &p_func, int p_argidx) const {
 
-	ERR_FAIL_COND_V(!custom_signals.has(p_func),Variant::NIL);
-	ERR_FAIL_INDEX_V(p_argidx,custom_signals[p_func].size(),Variant::NIL);
+	ERR_FAIL_COND_V(!custom_signals.has(p_func), Variant::NIL);
+	ERR_FAIL_INDEX_V(p_argidx, custom_signals[p_func].size(), Variant::NIL);
 	return custom_signals[p_func][p_argidx].type;
 }
-void VisualScript::custom_signal_set_argument_name(const StringName& p_func,int p_argidx,const String& p_name) {
-	ERR_FAIL_COND( instances.size() );
+void VisualScript::custom_signal_set_argument_name(const StringName &p_func, int p_argidx, const String &p_name) {
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!custom_signals.has(p_func));
-	ERR_FAIL_INDEX(p_argidx,custom_signals[p_func].size());
-	custom_signals[p_func][p_argidx].name=p_name;
-
+	ERR_FAIL_INDEX(p_argidx, custom_signals[p_func].size());
+	custom_signals[p_func][p_argidx].name = p_name;
 }
-String VisualScript::custom_signal_get_argument_name(const StringName& p_func,int p_argidx) const {
+String VisualScript::custom_signal_get_argument_name(const StringName &p_func, int p_argidx) const {
 
-	ERR_FAIL_COND_V(!custom_signals.has(p_func),String());
-	ERR_FAIL_INDEX_V(p_argidx,custom_signals[p_func].size(),String());
+	ERR_FAIL_COND_V(!custom_signals.has(p_func), String());
+	ERR_FAIL_INDEX_V(p_argidx, custom_signals[p_func].size(), String());
 	return custom_signals[p_func][p_argidx].name;
-
 }
-void VisualScript::custom_signal_remove_argument(const StringName& p_func,int p_argidx) {
+void VisualScript::custom_signal_remove_argument(const StringName &p_func, int p_argidx) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!custom_signals.has(p_func));
-	ERR_FAIL_INDEX(p_argidx,custom_signals[p_func].size());
+	ERR_FAIL_INDEX(p_argidx, custom_signals[p_func].size());
 	custom_signals[p_func].remove(p_argidx);
-
 }
 
-int VisualScript::custom_signal_get_argument_count(const StringName& p_func) const {
+int VisualScript::custom_signal_get_argument_count(const StringName &p_func) const {
 
-	ERR_FAIL_COND_V(!custom_signals.has(p_func),0);
+	ERR_FAIL_COND_V(!custom_signals.has(p_func), 0);
 	return custom_signals[p_func].size();
-
 }
-void VisualScript::custom_signal_swap_argument(const StringName& p_func,int p_argidx,int p_with_argidx) {
+void VisualScript::custom_signal_swap_argument(const StringName &p_func, int p_argidx, int p_with_argidx) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!custom_signals.has(p_func));
-	ERR_FAIL_INDEX(p_argidx,custom_signals[p_func].size());
-	ERR_FAIL_INDEX(p_with_argidx,custom_signals[p_func].size());
-
-	SWAP( custom_signals[p_func][p_argidx], custom_signals[p_func][p_with_argidx] );
+	ERR_FAIL_INDEX(p_argidx, custom_signals[p_func].size());
+	ERR_FAIL_INDEX(p_with_argidx, custom_signals[p_func].size());
 
+	SWAP(custom_signals[p_func][p_argidx], custom_signals[p_func][p_with_argidx]);
 }
-void VisualScript::remove_custom_signal(const StringName& p_name) {
+void VisualScript::remove_custom_signal(const StringName &p_name) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!custom_signals.has(p_name));
 	custom_signals.erase(p_name);
-
 }
 
-void VisualScript::rename_custom_signal(const StringName& p_name,const StringName& p_new_name) {
+void VisualScript::rename_custom_signal(const StringName &p_name, const StringName &p_new_name) {
 
-	ERR_FAIL_COND( instances.size() );
+	ERR_FAIL_COND(instances.size());
 	ERR_FAIL_COND(!custom_signals.has(p_name));
-	if (p_new_name==p_name)
+	if (p_new_name == p_name)
 		return;
 
 	ERR_FAIL_COND(!String(p_new_name).is_valid_identifier());
@@ -884,30 +821,28 @@ void VisualScript::rename_custom_signal(const StringName& p_name,const StringNam
 	ERR_FAIL_COND(variables.has(p_new_name));
 	ERR_FAIL_COND(custom_signals.has(p_new_name));
 
-	custom_signals[p_new_name]=custom_signals[p_name];
+	custom_signals[p_new_name] = custom_signals[p_name];
 	custom_signals.erase(p_name);
-
 }
 
 void VisualScript::get_custom_signal_list(List<StringName> *r_custom_signals) const {
 
-	for (const Map<StringName,Vector<Argument> >::Element *E=custom_signals.front();E;E=E->next()) {
+	for (const Map<StringName, Vector<Argument> >::Element *E = custom_signals.front(); E; E = E->next()) {
 		r_custom_signals->push_back(E->key());
 	}
 
 	r_custom_signals->sort_custom<StringName::AlphCompare>();
-
 }
 
 int VisualScript::get_available_id() const {
 
-	int max_id=0;
-	for (Map<StringName,Function>::Element *E=functions.front();E;E=E->next()) {
+	int max_id = 0;
+	for (Map<StringName, Function>::Element *E = functions.front(); E; E = E->next()) {
 		if (E->get().nodes.empty())
 			continue;
 
 		int last_id = E->get().nodes.back()->key();
-		max_id=MAX(max_id,last_id+1);
+		max_id = MAX(max_id, last_id + 1);
 	}
 
 	return max_id;
@@ -915,14 +850,11 @@ int VisualScript::get_available_id() const {
 
 /////////////////////////////////
 
-
 bool VisualScript::can_instance() const {
 
-	return true;//ScriptServer::is_scripting_enabled();
-
+	return true; //ScriptServer::is_scripting_enabled();
 }
 
-
 StringName VisualScript::get_instance_base_type() const {
 
 	return base_type;
@@ -932,84 +864,74 @@ Ref<Script> VisualScript::get_base_script() const {
 	return Ref<Script>(); // no inheritance in visual script
 }
 
-
 #ifdef TOOLS_ENABLED
 void VisualScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
 
-
 	placeholders.erase(p_placeholder);
 }
 
-
 void VisualScript::_update_placeholders() {
 
-	if (placeholders.size()==0)
+	if (placeholders.size() == 0)
 		return; //no bother if no placeholders
 	List<PropertyInfo> pinfo;
-	Map<StringName,Variant> values;
+	Map<StringName, Variant> values;
 
-	for (Map<StringName,Variable>::Element *E=variables.front();E;E=E->next()) {
+	for (Map<StringName, Variable>::Element *E = variables.front(); E; E = E->next()) {
 
 		if (!E->get()._export)
 			continue;
 
 		PropertyInfo p = E->get().info;
-		p.name=String(E->key());
+		p.name = String(E->key());
 		pinfo.push_back(p);
-		values[p.name]=E->get().default_value;
+		values[p.name] = E->get().default_value;
 	}
 
-	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(pinfo,values);
+		E->get()->update(pinfo, values);
 	}
-
 }
 
 #endif
 
-
-ScriptInstance* VisualScript::instance_create(Object *p_this) {
-
-
+ScriptInstance *VisualScript::instance_create(Object *p_this) {
 
 #ifdef TOOLS_ENABLED
 
 	if (!ScriptServer::is_scripting_enabled()) {
 
-
-		PlaceHolderScriptInstance *sins = memnew( PlaceHolderScriptInstance(VisualScriptLanguage::singleton,Ref<Script>((Script*)this),p_this));
+		PlaceHolderScriptInstance *sins = memnew(PlaceHolderScriptInstance(VisualScriptLanguage::singleton, Ref<Script>((Script *)this), p_this));
 		placeholders.insert(sins);
 
 		List<PropertyInfo> pinfo;
-		Map<StringName,Variant> values;
+		Map<StringName, Variant> values;
 
-		for (Map<StringName,Variable>::Element *E=variables.front();E;E=E->next()) {
+		for (Map<StringName, Variable>::Element *E = variables.front(); E; E = E->next()) {
 
 			if (!E->get()._export)
 				continue;
 
 			PropertyInfo p = E->get().info;
-			p.name=String(E->key());
+			p.name = String(E->key());
 			pinfo.push_back(p);
-			values[p.name]=E->get().default_value;
+			values[p.name] = E->get().default_value;
 		}
 
-		sins->update(pinfo,values);
+		sins->update(pinfo, values);
 
 		return sins;
 	}
 #endif
 
-
-	VisualScriptInstance *instance=memnew(  VisualScriptInstance );
-	instance->create(Ref<VisualScript>(this),p_this);
-
+	VisualScriptInstance *instance = memnew(VisualScriptInstance);
+	instance->create(Ref<VisualScript>(this), p_this);
 
 	if (VisualScriptLanguage::singleton->lock)
 		VisualScriptLanguage::singleton->lock->lock();
 
-	instances[p_this]=instance;
+	instances[p_this] = instance;
 
 	if (VisualScriptLanguage::singleton->lock)
 		VisualScriptLanguage::singleton->lock->unlock();
@@ -1019,7 +941,7 @@ ScriptInstance* VisualScript::instance_create(Object *p_this) {
 
 bool VisualScript::instance_has(const Object *p_this) const {
 
-	return instances.has((Object*)p_this);
+	return instances.has((Object *)p_this);
 }
 
 bool VisualScript::has_source_code() const {
@@ -1032,8 +954,7 @@ String VisualScript::get_source_code() const {
 	return String();
 }
 
-void VisualScript::set_source_code(const String& p_code) {
-
+void VisualScript::set_source_code(const String &p_code) {
 }
 
 Error VisualScript::reload(bool p_keep_state) {
@@ -1041,74 +962,66 @@ Error VisualScript::reload(bool p_keep_state) {
 	return OK;
 }
 
-
 bool VisualScript::is_tool() const {
 
 	return false;
 }
 
-
 String VisualScript::get_node_type() const {
 
 	return String();
 }
 
-
 ScriptLanguage *VisualScript::get_language() const {
 
 	return VisualScriptLanguage::singleton;
 }
 
-
-bool VisualScript::has_script_signal(const StringName& p_signal) const {
+bool VisualScript::has_script_signal(const StringName &p_signal) const {
 
 	return custom_signals.has(p_signal);
 }
 
 void VisualScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
 
-	for (const Map<StringName,Vector<Argument> >::Element *E=custom_signals.front();E;E=E->next()) {
+	for (const Map<StringName, Vector<Argument> >::Element *E = custom_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.type=E->get()[i].type;
-			arg.name=E->get()[i].name;
+			arg.type = E->get()[i].type;
+			arg.name = E->get()[i].name;
 			mi.arguments.push_back(arg);
 		}
 
-
 		r_signals->push_back(mi);
 	}
-
-
 }
 
-
-bool VisualScript::get_property_default_value(const StringName& p_property,Variant& r_value) const {
+bool VisualScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
 
 	if (!variables.has(p_property))
 		return false;
 
-	r_value=variables[ p_property ].default_value;
+	r_value = variables[p_property].default_value;
 	return true;
 }
 void VisualScript::get_script_method_list(List<MethodInfo> *p_list) const {
 
-	for (Map<StringName,Function>::Element *E=functions.front();E;E=E->next()) {
+	for (Map<StringName, Function>::Element *E = functions.front(); E; E = E->next()) {
 
 		MethodInfo mi;
-		mi.name=E->key();
-		if (E->get().function_id>=0) {
+		mi.name = E->key();
+		if (E->get().function_id >= 0) {
 
-			Ref<VisualScriptFunction> func=E->get().nodes[E->get().function_id].node;
+			Ref<VisualScriptFunction> func = E->get().nodes[E->get().function_id].node;
 			if (func.is_valid()) {
 
-				for(int i=0;i<func->get_argument_count();i++) {
+				for (int i = 0; i < func->get_argument_count(); i++) {
 					PropertyInfo arg;
-					arg.name=func->get_argument_name(i);
-					arg.type=func->get_argument_type(i);
+					arg.name = func->get_argument_name(i);
+					arg.type = func->get_argument_type(i);
 					mi.arguments.push_back(arg);
 				}
 			}
@@ -1118,27 +1031,27 @@ void VisualScript::get_script_method_list(List<MethodInfo> *p_list) const {
 	}
 }
 
-bool VisualScript::has_method(const StringName& p_method) const {
+bool VisualScript::has_method(const StringName &p_method) const {
 
 	return functions.has(p_method);
 }
-MethodInfo VisualScript::get_method_info(const StringName& p_method) const{
+MethodInfo VisualScript::get_method_info(const StringName &p_method) const {
 
-	const Map<StringName,Function>::Element *E=functions.find(p_method);
+	const Map<StringName, Function>::Element *E = functions.find(p_method);
 	if (!E)
 		return MethodInfo();
 
 	MethodInfo mi;
-	mi.name=E->key();
-	if (E->get().function_id>=0) {
+	mi.name = E->key();
+	if (E->get().function_id >= 0) {
 
-		Ref<VisualScriptFunction> func=E->get().nodes[E->get().function_id].node;
+		Ref<VisualScriptFunction> func = E->get().nodes[E->get().function_id].node;
 		if (func.is_valid()) {
 
-			for(int i=0;i<func->get_argument_count();i++) {
+			for (int i = 0; i < func->get_argument_count(); i++) {
 				PropertyInfo arg;
-				arg.name=func->get_argument_name(i);
-				arg.type=func->get_argument_type(i);
+				arg.name = func->get_argument_name(i);
+				arg.type = func->get_argument_type(i);
 				mi.arguments.push_back(arg);
 			}
 		}
@@ -1152,7 +1065,7 @@ void VisualScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 	List<StringName> vars;
 	get_variable_list(&vars);
 
-	for (List<StringName>::Element *E=vars.front();E;E=E->next()) {
+	for (List<StringName>::Element *E = vars.front(); E; E = E->next()) {
 		if (!variables[E->get()]._export)
 			continue;
 		p_list->push_back(variables[E->get()].info);
@@ -1162,9 +1075,9 @@ void VisualScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 #ifdef TOOLS_ENABLED
 bool VisualScript::are_subnodes_edited() const {
 
-	for(const Map<StringName,Function>::Element *E=functions.front();E;E=E->next()) {
+	for (const Map<StringName, Function>::Element *E = functions.front(); E; E = E->next()) {
 
-		for (const Map<int,Function::NodeData>::Element *F=E->get().nodes.front();F;F=F->next()) {
+		for (const Map<int, Function::NodeData>::Element *F = E->get().nodes.front(); F; F = F->next()) {
 			if (F->get().node->is_edited()) {
 				return true;
 			}
@@ -1175,324 +1088,296 @@ bool VisualScript::are_subnodes_edited() const {
 }
 #endif
 
-void VisualScript::_set_data(const Dictionary& p_data) {
+void VisualScript::_set_data(const Dictionary &p_data) {
 
 	Dictionary d = p_data;
 	if (d.has("base_type"))
-		base_type=d["base_type"];
+		base_type = d["base_type"];
 
 	variables.clear();
-	Array vars=d["variables"];
-	for (int i=0;i<vars.size();i++) {
+	Array vars = d["variables"];
+	for (int i = 0; i < vars.size(); i++) {
 
-		Dictionary v=vars[i];
+		Dictionary v = vars[i];
 		StringName name = v["name"];
 		add_variable(name);
-		_set_variable_info(name,v);
-		set_variable_default_value(name,v["default_value"]);
-		set_variable_export(name,v.has("export") && bool(v["export"]));
-
+		_set_variable_info(name, v);
+		set_variable_default_value(name, v["default_value"]);
+		set_variable_export(name, v.has("export") && bool(v["export"]));
 	}
 
-
 	custom_signals.clear();
-	Array sigs=d["signals"];
-	for (int i=0;i<sigs.size();i++) {
+	Array sigs = d["signals"];
+	for (int i = 0; i < sigs.size(); i++) {
 
-		Dictionary cs=sigs[i];
+		Dictionary cs = sigs[i];
 		add_custom_signal(cs["name"]);
 
-		Array args=cs["arguments"];
-		for(int j=0;j<args.size();j+=2) {
-			custom_signal_add_argument(cs["name"],Variant::Type(int(args[j+1])),args[j]);
+		Array args = cs["arguments"];
+		for (int j = 0; j < args.size(); j += 2) {
+			custom_signal_add_argument(cs["name"], Variant::Type(int(args[j + 1])), args[j]);
 		}
 	}
 
-	Array funcs=d["functions"];
+	Array funcs = d["functions"];
 	functions.clear();
 
-	for (int i=0;i<funcs.size();i++) {
+	for (int i = 0; i < funcs.size(); i++) {
 
-		Dictionary func=funcs[i];
+		Dictionary func = funcs[i];
 
-
-		StringName name=func["name"];
+		StringName name = func["name"];
 		//int id=func["function_id"];
 		add_function(name);
 
-		set_function_scroll(name,func["scroll"]);
+		set_function_scroll(name, func["scroll"]);
 
 		Array nodes = func["nodes"];
 
-		for(int i=0;i<nodes.size();i+=3) {
+		for (int i = 0; i < nodes.size(); i += 3) {
 
-			add_node(name,nodes[i],nodes[i+2],nodes[i+1]);
+			add_node(name, nodes[i], nodes[i + 2], nodes[i + 1]);
 		}
 
+		Array sequence_connections = func["sequence_connections"];
 
-		Array sequence_connections=func["sequence_connections"];
-
-		for (int j=0;j<sequence_connections.size();j+=3) {
+		for (int j = 0; j < sequence_connections.size(); j += 3) {
 
-			sequence_connect(name,sequence_connections[j+0],sequence_connections[j+1],sequence_connections[j+2]);
+			sequence_connect(name, sequence_connections[j + 0], sequence_connections[j + 1], sequence_connections[j + 2]);
 		}
 
+		Array data_connections = func["data_connections"];
 
-		Array data_connections=func["data_connections"];
-
-		for (int j=0;j<data_connections.size();j+=4) {
-
-			data_connect(name,data_connections[j+0],data_connections[j+1],data_connections[j+2],data_connections[j+3]);
+		for (int j = 0; j < data_connections.size(); j += 4) {
 
+			data_connect(name, data_connections[j + 0], data_connections[j + 1], data_connections[j + 2], data_connections[j + 3]);
 		}
-
-
 	}
-
 }
 
-Dictionary VisualScript::_get_data() const{
+Dictionary VisualScript::_get_data() const {
 
 	Dictionary d;
-	d["base_type"]=base_type;
+	d["base_type"] = base_type;
 	Array vars;
-	for (const Map<StringName,Variable>::Element *E=variables.front();E;E=E->next()) {
+	for (const Map<StringName, Variable>::Element *E = variables.front(); E; E = E->next()) {
 
 		Dictionary var = _get_variable_info(E->key());
-		var["name"]=E->key(); //make sure it's the right one
-		var["default_value"]=E->get().default_value;
-		var["export"]=E->get()._export;
+		var["name"] = E->key(); //make sure it's the right one
+		var["default_value"] = E->get().default_value;
+		var["export"] = E->get()._export;
 		vars.push_back(var);
 	}
-	d["variables"]=vars;
+	d["variables"] = vars;
 
 	Array sigs;
-	for (const Map<StringName,Vector<Argument> >::Element *E=custom_signals.front();E;E=E->next()) {
+	for (const Map<StringName, Vector<Argument> >::Element *E = custom_signals.front(); E; E = E->next()) {
 
 		Dictionary cs;
-		cs["name"]=E->key();
+		cs["name"] = E->key();
 		Array args;
-		for(int i=0;i<E->get().size();i++) {
+		for (int i = 0; i < E->get().size(); i++) {
 			args.push_back(E->get()[i].name);
 			args.push_back(E->get()[i].type);
 		}
-		cs["arguments"]=args;
+		cs["arguments"] = args;
 
 		sigs.push_back(cs);
 	}
 
-	d["signals"]=sigs;
+	d["signals"] = sigs;
 
 	Array funcs;
 
-	for (const Map<StringName,Function>::Element *E=functions.front();E;E=E->next()) {
+	for (const Map<StringName, Function>::Element *E = functions.front(); E; E = E->next()) {
 
 		Dictionary func;
-		func["name"]=E->key();
-		func["function_id"]=E->get().function_id;
-		func["scroll"]=E->get().scroll;
+		func["name"] = E->key();
+		func["function_id"] = E->get().function_id;
+		func["scroll"] = E->get().scroll;
 
 		Array nodes;
 
-		for (const Map<int,Function::NodeData>::Element *F=E->get().nodes.front();F;F=F->next()) {
+		for (const Map<int, Function::NodeData>::Element *F = E->get().nodes.front(); F; F = F->next()) {
 
 			nodes.push_back(F->key());
 			nodes.push_back(F->get().pos);
 			nodes.push_back(F->get().node);
-
 		}
 
-		func["nodes"]=nodes;
+		func["nodes"] = nodes;
 
 		Array sequence_connections;
 
-		for (const Set<SequenceConnection>::Element *F=E->get().sequence_connections.front();F;F=F->next()) {
+		for (const Set<SequenceConnection>::Element *F = E->get().sequence_connections.front(); F; F = F->next()) {
 
 			sequence_connections.push_back(F->get().from_node);
 			sequence_connections.push_back(F->get().from_output);
 			sequence_connections.push_back(F->get().to_node);
-
 		}
 
-
-		func["sequence_connections"]=sequence_connections;
+		func["sequence_connections"] = sequence_connections;
 
 		Array data_connections;
 
-		for (const Set<DataConnection>::Element *F=E->get().data_connections.front();F;F=F->next()) {
+		for (const Set<DataConnection>::Element *F = E->get().data_connections.front(); F; F = F->next()) {
 
 			data_connections.push_back(F->get().from_node);
 			data_connections.push_back(F->get().from_port);
 			data_connections.push_back(F->get().to_node);
 			data_connections.push_back(F->get().to_port);
-
 		}
 
-
-		func["data_connections"]=data_connections;
+		func["data_connections"] = data_connections;
 
 		funcs.push_back(func);
-
 	}
 
-	d["functions"]=funcs;
-
+	d["functions"] = funcs;
 
 	return d;
-
 }
 
 void VisualScript::_bind_methods() {
 
-
-
-	ClassDB::bind_method(D_METHOD("_node_ports_changed"),&VisualScript::_node_ports_changed);
-
-	ClassDB::bind_method(D_METHOD("add_function","name"),&VisualScript::add_function);
-	ClassDB::bind_method(D_METHOD("has_function","name"),&VisualScript::has_function);	
-	ClassDB::bind_method(D_METHOD("remove_function","name"),&VisualScript::remove_function);
-	ClassDB::bind_method(D_METHOD("rename_function","name","new_name"),&VisualScript::rename_function);
-	ClassDB::bind_method(D_METHOD("set_function_scroll","ofs"),&VisualScript::set_function_scroll);
-	ClassDB::bind_method(D_METHOD("get_function_scroll"),&VisualScript::get_function_scroll);
-
-	ClassDB::bind_method(D_METHOD("add_node","func","id","node","pos"),&VisualScript::add_node,DEFVAL(Point2()));
-	ClassDB::bind_method(D_METHOD("remove_node","func","id"),&VisualScript::remove_node);
-	ClassDB::bind_method(D_METHOD("get_function_node_id","name"),&VisualScript::get_function_node_id);
-
-	ClassDB::bind_method(D_METHOD("get_node","func","id"),&VisualScript::get_node);
-	ClassDB::bind_method(D_METHOD("has_node","func","id"),&VisualScript::has_node);
-	ClassDB::bind_method(D_METHOD("set_node_pos","func","id","pos"),&VisualScript::set_node_pos);
-	ClassDB::bind_method(D_METHOD("get_node_pos","func","id"),&VisualScript::get_node_pos);
-
-	ClassDB::bind_method(D_METHOD("sequence_connect","func","from_node","from_output","to_node"),&VisualScript::sequence_connect);
-	ClassDB::bind_method(D_METHOD("sequence_disconnect","func","from_node","from_output","to_node"),&VisualScript::sequence_disconnect);
-	ClassDB::bind_method(D_METHOD("has_sequence_connection","func","from_node","from_output","to_node"),&VisualScript::has_sequence_connection);
-
-	ClassDB::bind_method(D_METHOD("data_connect","func","from_node","from_port","to_node","to_port"),&VisualScript::data_connect);
-	ClassDB::bind_method(D_METHOD("data_disconnect","func","from_node","from_port","to_node","to_port"),&VisualScript::data_disconnect);
-	ClassDB::bind_method(D_METHOD("has_data_connection","func","from_node","from_port","to_node","to_port"),&VisualScript::has_data_connection);
-
-	ClassDB::bind_method(D_METHOD("add_variable","name","default_value","export"),&VisualScript::add_variable,DEFVAL(Variant()),DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("has_variable","name"),&VisualScript::has_variable);
-	ClassDB::bind_method(D_METHOD("remove_variable","name"),&VisualScript::remove_variable);
-	ClassDB::bind_method(D_METHOD("set_variable_default_value","name","value"),&VisualScript::set_variable_default_value);
-	ClassDB::bind_method(D_METHOD("get_variable_default_value","name"),&VisualScript::get_variable_default_value);
-	ClassDB::bind_method(D_METHOD("set_variable_info","name","value"),&VisualScript::_set_variable_info);
-	ClassDB::bind_method(D_METHOD("get_variable_info","name"),&VisualScript::_get_variable_info);
-	ClassDB::bind_method(D_METHOD("set_variable_export","name","enable"),&VisualScript::set_variable_export);
-	ClassDB::bind_method(D_METHOD("get_variable_export","name"),&VisualScript::get_variable_export);
-	ClassDB::bind_method(D_METHOD("rename_variable","name","new_name"),&VisualScript::rename_variable);
-
-	ClassDB::bind_method(D_METHOD("add_custom_signal","name"),&VisualScript::add_custom_signal);
-	ClassDB::bind_method(D_METHOD("has_custom_signal","name"),&VisualScript::has_custom_signal);
-	ClassDB::bind_method(D_METHOD("custom_signal_add_argument","name","type","argname","index"),&VisualScript::custom_signal_add_argument,DEFVAL(-1));
-	ClassDB::bind_method(D_METHOD("custom_signal_set_argument_type","name","argidx","type"),&VisualScript::custom_signal_set_argument_type);
-	ClassDB::bind_method(D_METHOD("custom_signal_get_argument_type","name","argidx"),&VisualScript::custom_signal_get_argument_type);
-	ClassDB::bind_method(D_METHOD("custom_signal_set_argument_name","name","argidx","argname"),&VisualScript::custom_signal_set_argument_name);
-	ClassDB::bind_method(D_METHOD("custom_signal_get_argument_name","name","argidx"),&VisualScript::custom_signal_get_argument_name);
-	ClassDB::bind_method(D_METHOD("custom_signal_remove_argument","argidx"),&VisualScript::custom_signal_remove_argument);
-	ClassDB::bind_method(D_METHOD("custom_signal_get_argument_count","name"),&VisualScript::custom_signal_get_argument_count);
-	ClassDB::bind_method(D_METHOD("custom_signal_swap_argument","name","argidx","withidx"),&VisualScript::custom_signal_swap_argument);
-	ClassDB::bind_method(D_METHOD("remove_custom_signal","name"),&VisualScript::remove_custom_signal);
-	ClassDB::bind_method(D_METHOD("rename_custom_signal","name","new_name"),&VisualScript::rename_custom_signal);
+	ClassDB::bind_method(D_METHOD("_node_ports_changed"), &VisualScript::_node_ports_changed);
+
+	ClassDB::bind_method(D_METHOD("add_function", "name"), &VisualScript::add_function);
+	ClassDB::bind_method(D_METHOD("has_function", "name"), &VisualScript::has_function);
+	ClassDB::bind_method(D_METHOD("remove_function", "name"), &VisualScript::remove_function);
+	ClassDB::bind_method(D_METHOD("rename_function", "name", "new_name"), &VisualScript::rename_function);
+	ClassDB::bind_method(D_METHOD("set_function_scroll", "ofs"), &VisualScript::set_function_scroll);
+	ClassDB::bind_method(D_METHOD("get_function_scroll"), &VisualScript::get_function_scroll);
+
+	ClassDB::bind_method(D_METHOD("add_node", "func", "id", "node", "pos"), &VisualScript::add_node, DEFVAL(Point2()));
+	ClassDB::bind_method(D_METHOD("remove_node", "func", "id"), &VisualScript::remove_node);
+	ClassDB::bind_method(D_METHOD("get_function_node_id", "name"), &VisualScript::get_function_node_id);
+
+	ClassDB::bind_method(D_METHOD("get_node", "func", "id"), &VisualScript::get_node);
+	ClassDB::bind_method(D_METHOD("has_node", "func", "id"), &VisualScript::has_node);
+	ClassDB::bind_method(D_METHOD("set_node_pos", "func", "id", "pos"), &VisualScript::set_node_pos);
+	ClassDB::bind_method(D_METHOD("get_node_pos", "func", "id"), &VisualScript::get_node_pos);
+
+	ClassDB::bind_method(D_METHOD("sequence_connect", "func", "from_node", "from_output", "to_node"), &VisualScript::sequence_connect);
+	ClassDB::bind_method(D_METHOD("sequence_disconnect", "func", "from_node", "from_output", "to_node"), &VisualScript::sequence_disconnect);
+	ClassDB::bind_method(D_METHOD("has_sequence_connection", "func", "from_node", "from_output", "to_node"), &VisualScript::has_sequence_connection);
+
+	ClassDB::bind_method(D_METHOD("data_connect", "func", "from_node", "from_port", "to_node", "to_port"), &VisualScript::data_connect);
+	ClassDB::bind_method(D_METHOD("data_disconnect", "func", "from_node", "from_port", "to_node", "to_port"), &VisualScript::data_disconnect);
+	ClassDB::bind_method(D_METHOD("has_data_connection", "func", "from_node", "from_port", "to_node", "to_port"), &VisualScript::has_data_connection);
+
+	ClassDB::bind_method(D_METHOD("add_variable", "name", "default_value", "export"), &VisualScript::add_variable, DEFVAL(Variant()), DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("has_variable", "name"), &VisualScript::has_variable);
+	ClassDB::bind_method(D_METHOD("remove_variable", "name"), &VisualScript::remove_variable);
+	ClassDB::bind_method(D_METHOD("set_variable_default_value", "name", "value"), &VisualScript::set_variable_default_value);
+	ClassDB::bind_method(D_METHOD("get_variable_default_value", "name"), &VisualScript::get_variable_default_value);
+	ClassDB::bind_method(D_METHOD("set_variable_info", "name", "value"), &VisualScript::_set_variable_info);
+	ClassDB::bind_method(D_METHOD("get_variable_info", "name"), &VisualScript::_get_variable_info);
+	ClassDB::bind_method(D_METHOD("set_variable_export", "name", "enable"), &VisualScript::set_variable_export);
+	ClassDB::bind_method(D_METHOD("get_variable_export", "name"), &VisualScript::get_variable_export);
+	ClassDB::bind_method(D_METHOD("rename_variable", "name", "new_name"), &VisualScript::rename_variable);
+
+	ClassDB::bind_method(D_METHOD("add_custom_signal", "name"), &VisualScript::add_custom_signal);
+	ClassDB::bind_method(D_METHOD("has_custom_signal", "name"), &VisualScript::has_custom_signal);
+	ClassDB::bind_method(D_METHOD("custom_signal_add_argument", "name", "type", "argname", "index"), &VisualScript::custom_signal_add_argument, DEFVAL(-1));
+	ClassDB::bind_method(D_METHOD("custom_signal_set_argument_type", "name", "argidx", "type"), &VisualScript::custom_signal_set_argument_type);
+	ClassDB::bind_method(D_METHOD("custom_signal_get_argument_type", "name", "argidx"), &VisualScript::custom_signal_get_argument_type);
+	ClassDB::bind_method(D_METHOD("custom_signal_set_argument_name", "name", "argidx", "argname"), &VisualScript::custom_signal_set_argument_name);
+	ClassDB::bind_method(D_METHOD("custom_signal_get_argument_name", "name", "argidx"), &VisualScript::custom_signal_get_argument_name);
+	ClassDB::bind_method(D_METHOD("custom_signal_remove_argument", "argidx"), &VisualScript::custom_signal_remove_argument);
+	ClassDB::bind_method(D_METHOD("custom_signal_get_argument_count", "name"), &VisualScript::custom_signal_get_argument_count);
+	ClassDB::bind_method(D_METHOD("custom_signal_swap_argument", "name", "argidx", "withidx"), &VisualScript::custom_signal_swap_argument);
+	ClassDB::bind_method(D_METHOD("remove_custom_signal", "name"), &VisualScript::remove_custom_signal);
+	ClassDB::bind_method(D_METHOD("rename_custom_signal", "name", "new_name"), &VisualScript::rename_custom_signal);
 
 	//ClassDB::bind_method(D_METHOD("set_variable_info","name","info"),&VScript::set_variable_info);
 	//ClassDB::bind_method(D_METHOD("get_variable_info","name"),&VScript::set_variable_info);
 
-	ClassDB::bind_method(D_METHOD("set_instance_base_type","type"),&VisualScript::set_instance_base_type);
+	ClassDB::bind_method(D_METHOD("set_instance_base_type", "type"), &VisualScript::set_instance_base_type);
 
-	ClassDB::bind_method(D_METHOD("_set_data","data"),&VisualScript::_set_data);
-	ClassDB::bind_method(D_METHOD("_get_data"),&VisualScript::_get_data);
+	ClassDB::bind_method(D_METHOD("_set_data", "data"), &VisualScript::_set_data);
+	ClassDB::bind_method(D_METHOD("_get_data"), &VisualScript::_get_data);
 
-	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY,"data",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"_set_data","_get_data");
+	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_data", "_get_data");
 
-	ADD_SIGNAL(MethodInfo("node_ports_changed",PropertyInfo(Variant::STRING,"function"),PropertyInfo(Variant::INT,"id")));
+	ADD_SIGNAL(MethodInfo("node_ports_changed", PropertyInfo(Variant::STRING, "function"), PropertyInfo(Variant::INT, "id")));
 }
 
 VisualScript::VisualScript() {
 
-	base_type="Object";
-
+	base_type = "Object";
 }
 
 VisualScript::~VisualScript() {
 
-	while(!functions.empty()) {
+	while (!functions.empty()) {
 		remove_function(functions.front()->key());
 	}
-
 }
 
 ////////////////////////////////////////////
 
+bool VisualScriptInstance::set(const StringName &p_name, const Variant &p_value) {
 
-
-bool VisualScriptInstance::set(const StringName& p_name, const Variant& p_value) {
-
-
-	Map<StringName,Variant>::Element *E=variables.find(p_name);
+	Map<StringName, Variant>::Element *E = variables.find(p_name);
 	if (!E)
 		return false;
 
-	E->get()=p_value;
+	E->get() = p_value;
 
 	return true;
 }
 
+bool VisualScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 
-bool VisualScriptInstance::get(const StringName& p_name, Variant &r_ret) const {
-
-	const Map<StringName,Variant>::Element *E=variables.find(p_name);
+	const Map<StringName, Variant>::Element *E = variables.find(p_name);
 	if (!E)
 		return false;
 
-	r_ret=E->get();
+	r_ret = E->get();
 	return true;
 }
-void VisualScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const{
+void VisualScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
 
-	for (const Map<StringName,VisualScript::Variable>::Element *E=script->variables.front();E;E=E->next()) {
+	for (const Map<StringName, VisualScript::Variable>::Element *E = script->variables.front(); E; E = E->next()) {
 
 		if (!E->get()._export)
 			continue;
 		PropertyInfo p = E->get().info;
-		p.name=String(E->key());
+		p.name = String(E->key());
 		p_properties->push_back(p);
-
 	}
 }
-Variant::Type VisualScriptInstance::get_property_type(const StringName& p_name,bool *r_is_valid) const{
-
+Variant::Type VisualScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
 
-	const Map<StringName,VisualScript::Variable>::Element *E=script->variables.find(p_name);
+	const Map<StringName, VisualScript::Variable>::Element *E = script->variables.find(p_name);
 	if (!E) {
 		if (r_is_valid)
-			*r_is_valid=false;
+			*r_is_valid = false;
 		ERR_FAIL_V(Variant::NIL);
 	}
 
 	if (r_is_valid)
-		*r_is_valid=true;
+		*r_is_valid = true;
 
 	return E->get().info.type;
-
 }
 
-void VisualScriptInstance::get_method_list(List<MethodInfo> *p_list) const{
+void VisualScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
 
-	for (const Map<StringName,VisualScript::Function>::Element *E=script->functions.front();E;E=E->next()) {
+	for (const Map<StringName, VisualScript::Function>::Element *E = script->functions.front(); E; E = E->next()) {
 
 		MethodInfo mi;
-		mi.name=E->key();
-		if (E->get().function_id>=0 && E->get().nodes.has(E->get().function_id)) {
+		mi.name = E->key();
+		if (E->get().function_id >= 0 && E->get().nodes.has(E->get().function_id)) {
 
 			Ref<VisualScriptFunction> vsf = E->get().nodes[E->get().function_id].node;
 			if (vsf.is_valid()) {
 
-				for(int i=0;i<vsf->get_argument_count();i++) {
+				for (int i = 0; i < vsf->get_argument_count(); i++) {
 					PropertyInfo arg;
-					arg.name=vsf->get_argument_name(i);
-					arg.type=vsf->get_argument_type(i);
+					arg.name = vsf->get_argument_name(i);
+					arg.type = vsf->get_argument_type(i);
 
 					mi.arguments.push_back(arg);
 				}
@@ -1503,136 +1388,127 @@ void VisualScriptInstance::get_method_list(List<MethodInfo> *p_list) const{
 
 		p_list->push_back(mi);
 	}
-
 }
-bool VisualScriptInstance::has_method(const StringName& p_method) const{
+bool VisualScriptInstance::has_method(const StringName &p_method) const {
 
 	return script->functions.has(p_method);
 }
 
-
 //#define VSDEBUG(m_text) print_line(m_text)
 #define VSDEBUG(m_text)
 
-void VisualScriptInstance::_dependency_step(VisualScriptNodeInstance* node,int p_pass,int *pass_stack,const Variant **input_args,Variant **output_args,Variant *variant_stack,Variant::CallError& r_error,String& error_str,VisualScriptNodeInstance** r_error_node) {
+void VisualScriptInstance::_dependency_step(VisualScriptNodeInstance *node, int p_pass, int *pass_stack, const Variant **input_args, Variant **output_args, Variant *variant_stack, Variant::CallError &r_error, String &error_str, VisualScriptNodeInstance **r_error_node) {
 
-	ERR_FAIL_COND(node->pass_idx==-1);
+	ERR_FAIL_COND(node->pass_idx == -1);
 
-	if (pass_stack[node->pass_idx]==p_pass)
+	if (pass_stack[node->pass_idx] == p_pass)
 		return;
 
-	pass_stack[node->pass_idx]=p_pass;
+	pass_stack[node->pass_idx] = p_pass;
 
 	if (!node->dependencies.empty()) {
 
 		int dc = node->dependencies.size();
-		VisualScriptNodeInstance **deps=node->dependencies.ptr();
+		VisualScriptNodeInstance **deps = node->dependencies.ptr();
 
-		for(int i=0;i<dc;i++) {
+		for (int i = 0; i < dc; i++) {
 
-			_dependency_step(deps[i],p_pass,pass_stack,input_args,output_args,variant_stack,r_error,error_str,r_error_node);
-			if (r_error.error!=Variant::CallError::CALL_OK)
+			_dependency_step(deps[i], p_pass, pass_stack, input_args, output_args, variant_stack, r_error, error_str, r_error_node);
+			if (r_error.error != Variant::CallError::CALL_OK)
 				return;
-
 		}
 	}
 
-
-	for(int i=0;i<node->input_port_count;i++) {
+	for (int i = 0; i < node->input_port_count; i++) {
 
 		int index = node->input_ports[i] & VisualScriptNodeInstance::INPUT_MASK;
 
-
 		if (node->input_ports[i] & VisualScriptNodeInstance::INPUT_DEFAULT_VALUE_BIT) {
 			//is a default value (unassigned input port)
-			input_args[i]=&default_values[index];
+			input_args[i] = &default_values[index];
 		} else {
 			//regular temporary in stack
-			input_args[i]=&variant_stack[index];
-
+			input_args[i] = &variant_stack[index];
 		}
 	}
-	for(int i=0 ; i<node->output_port_count ; i++) {
-		output_args[i] = &variant_stack[ node->output_ports[i] ];
+	for (int i = 0; i < node->output_port_count; i++) {
+		output_args[i] = &variant_stack[node->output_ports[i]];
 	}
 
-	Variant *working_mem=node->working_mem_idx>=0 ? &variant_stack[node->working_mem_idx] : (Variant*)NULL;
+	Variant *working_mem = node->working_mem_idx >= 0 ? &variant_stack[node->working_mem_idx] : (Variant *)NULL;
 
-	node->step(input_args,output_args,VisualScriptNodeInstance::START_MODE_BEGIN_SEQUENCE,working_mem,r_error,error_str);
+	node->step(input_args, output_args, VisualScriptNodeInstance::START_MODE_BEGIN_SEQUENCE, working_mem, r_error, error_str);
 	//ignore return
-	if (r_error.error!=Variant::CallError::CALL_OK) {
-		*r_error_node=node;
+	if (r_error.error != Variant::CallError::CALL_OK) {
+		*r_error_node = node;
 	}
-
 }
 
-Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p_stack, int p_stack_size, VisualScriptNodeInstance* p_node, int p_flow_stack_pos, int p_pass, bool p_resuming_yield, Variant::CallError &r_error) {
+Variant VisualScriptInstance::_call_internal(const StringName &p_method, void *p_stack, int p_stack_size, VisualScriptNodeInstance *p_node, int p_flow_stack_pos, int p_pass, bool p_resuming_yield, Variant::CallError &r_error) {
 
-	Map<StringName,Function>::Element *F = functions.find(p_method);
-	ERR_FAIL_COND_V(!F,Variant());
-	Function *f=&F->get();
+	Map<StringName, Function>::Element *F = functions.find(p_method);
+	ERR_FAIL_COND_V(!F, Variant());
+	Function *f = &F->get();
 
 	//this call goes separate, so it can e yielded and suspended
-	Variant *variant_stack=(Variant*)p_stack;
-	bool *sequence_bits = (bool*)(variant_stack + f->max_stack);
-	const Variant **input_args=(const Variant**)(sequence_bits+f->node_count);
-	Variant **output_args=(Variant**)(input_args + max_input_args);
+	Variant *variant_stack = (Variant *)p_stack;
+	bool *sequence_bits = (bool *)(variant_stack + f->max_stack);
+	const Variant **input_args = (const Variant **)(sequence_bits + f->node_count);
+	Variant **output_args = (Variant **)(input_args + max_input_args);
 	int flow_max = f->flow_stack_size;
-	int* flow_stack = flow_max? (int*)(output_args + max_output_args) : (int*)NULL;
+	int *flow_stack = flow_max ? (int *)(output_args + max_output_args) : (int *)NULL;
 	int *pass_stack = flow_stack + flow_max;
 
 	String error_str;
 
-	VisualScriptNodeInstance* node=p_node;
-	bool error=false;
-	int current_node_id=f->node;
+	VisualScriptNodeInstance *node = p_node;
+	bool error = false;
+	int current_node_id = f->node;
 	Variant return_value;
-	Variant *working_mem=NULL;
+	Variant *working_mem = NULL;
 
-	int flow_stack_pos=p_flow_stack_pos;
+	int flow_stack_pos = p_flow_stack_pos;
 
 #ifdef DEBUG_ENABLED
 	if (ScriptDebugger::get_singleton()) {
-		VisualScriptLanguage::singleton->enter_function(this,&p_method,variant_stack,&working_mem,&current_node_id);
+		VisualScriptLanguage::singleton->enter_function(this, &p_method, variant_stack, &working_mem, &current_node_id);
 	}
 #endif
 
-	while(true) {
+	while (true) {
 
 		p_pass++; //increment pass
-		current_node_id=node->get_id();
-
-		VSDEBUG("==========AT NODE: "+itos(current_node_id)+" base: "+node->get_base_node()->get_class_name());
-		VSDEBUG("AT STACK POS: "+itos(flow_stack_pos));
+		current_node_id = node->get_id();
 
+		VSDEBUG("==========AT NODE: " + itos(current_node_id) + " base: " + node->get_base_node()->get_class_name());
+		VSDEBUG("AT STACK POS: " + itos(flow_stack_pos));
 
 		//setup working mem
-		working_mem=node->working_mem_idx>=0 ? &variant_stack[node->working_mem_idx] : (Variant*)NULL;
+		working_mem = node->working_mem_idx >= 0 ? &variant_stack[node->working_mem_idx] : (Variant *)NULL;
 
-		VSDEBUG("WORKING MEM: "+itos(node->working_mem_idx));
+		VSDEBUG("WORKING MEM: " + itos(node->working_mem_idx));
 
-		if (current_node_id==f->node) {
+		if (current_node_id == f->node) {
 			//if function node, set up function arguments from begining of stack
 
-			for(int i=0;i<f->argument_count;i++) {
-				input_args[i]=&variant_stack[i];
+			for (int i = 0; i < f->argument_count; i++) {
+				input_args[i] = &variant_stack[i];
 			}
 		} else {
 
 			//run dependencies first
 
-
 			if (!node->dependencies.empty()) {
 
 				int dc = node->dependencies.size();
-				VisualScriptNodeInstance **deps=node->dependencies.ptr();
+				VisualScriptNodeInstance **deps = node->dependencies.ptr();
 
-				for(int i=0;i<dc;i++) {
+				for (int i = 0; i < dc; i++) {
 
-					_dependency_step(deps[i],p_pass,pass_stack,input_args,output_args,variant_stack,r_error,error_str,&node);
-					if (r_error.error!=Variant::CallError::CALL_OK) {
-						error=true;
-						current_node_id=node->id;
+					_dependency_step(deps[i], p_pass, pass_stack, input_args, output_args, variant_stack, r_error, error_str, &node);
+					if (r_error.error != Variant::CallError::CALL_OK) {
+						error = true;
+						current_node_id = node->id;
 						break;
 					}
 				}
@@ -1641,22 +1517,20 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 			if (!error) {
 
 				//setup input pointers normally
-				VSDEBUG("INPUT PORTS: "+itos(node->input_port_count));
-
-				for(int i=0 ; i<node->input_port_count ; i++) {
+				VSDEBUG("INPUT PORTS: " + itos(node->input_port_count));
 
+				for (int i = 0; i < node->input_port_count; i++) {
 
 					int index = node->input_ports[i] & VisualScriptNodeInstance::INPUT_MASK;
 
 					if (node->input_ports[i] & VisualScriptNodeInstance::INPUT_DEFAULT_VALUE_BIT) {
 						//is a default value (unassigned input port)
-						input_args[i]=&default_values[index];
-						VSDEBUG("\tPORT "+itos(i)+" DEFAULT VAL");
+						input_args[i] = &default_values[index];
+						VSDEBUG("\tPORT " + itos(i) + " DEFAULT VAL");
 					} else {
 						//regular temporary in stack
-						input_args[i]=&variant_stack[index];
-						VSDEBUG("PORT "+itos(i)+" AT STACK "+itos(index));
-
+						input_args[i] = &variant_stack[index];
+						VSDEBUG("PORT " + itos(i) + " AT STACK " + itos(index));
 					}
 				}
 			}
@@ -1667,10 +1541,10 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 
 		//setup output pointers
 
-		VSDEBUG("OUTPUT PORTS: "+itos(node->output_port_count));
-		for(int i=0 ; i<node->output_port_count ; i++) {
-			output_args[i] = &variant_stack[ node->output_ports[i] ];
-			VSDEBUG("PORT "+itos(i)+" AT STACK "+itos(node->output_ports[i]));
+		VSDEBUG("OUTPUT PORTS: " + itos(node->output_port_count));
+		for (int i = 0; i < node->output_port_count; i++) {
+			output_args[i] = &variant_stack[node->output_ports[i]];
+			VSDEBUG("PORT " + itos(i) + " AT STACK " + itos(node->output_ports[i]));
 		}
 
 		//do step
@@ -1678,57 +1552,55 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 		VisualScriptNodeInstance::StartMode start_mode;
 		{
 			if (p_resuming_yield)
-				start_mode=VisualScriptNodeInstance::START_MODE_RESUME_YIELD;
+				start_mode = VisualScriptNodeInstance::START_MODE_RESUME_YIELD;
 			else if (!flow_stack || !(flow_stack[flow_stack_pos] & VisualScriptNodeInstance::FLOW_STACK_PUSHED_BIT)) //if there is a push bit, it means we are continuing a sequence
-				start_mode=VisualScriptNodeInstance::START_MODE_BEGIN_SEQUENCE;
+				start_mode = VisualScriptNodeInstance::START_MODE_BEGIN_SEQUENCE;
 			else
-				start_mode=VisualScriptNodeInstance::START_MODE_CONTINUE_SEQUENCE;
+				start_mode = VisualScriptNodeInstance::START_MODE_CONTINUE_SEQUENCE;
 		}
 
-		VSDEBUG("STEP - STARTSEQ: "+itos(start_mode));
+		VSDEBUG("STEP - STARTSEQ: " + itos(start_mode));
 
-		int ret = node->step(input_args,output_args,start_mode,working_mem,r_error,error_str);
+		int ret = node->step(input_args, output_args, start_mode, working_mem, r_error, error_str);
 
-		if (r_error.error!=Variant::CallError::CALL_OK) {
+		if (r_error.error != Variant::CallError::CALL_OK) {
 			//use error from step
-			error=true;
+			error = true;
 			break;
 		}
 
-		if (ret&VisualScriptNodeInstance::STEP_YIELD_BIT) {
+		if (ret & VisualScriptNodeInstance::STEP_YIELD_BIT) {
 			//yielded!
-			if (node->get_working_memory_size()==0) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-				error_str=RTR("A node yielded without working memory, please read the docs on how to yield properly!");
-				error=true;
+			if (node->get_working_memory_size() == 0) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				error_str = RTR("A node yielded without working memory, please read the docs on how to yield properly!");
+				error = true;
 				break;
 
 			} else {
 				Ref<VisualScriptFunctionState> state = *working_mem;
 				if (!state.is_valid()) {
 
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					error_str=RTR("Node yielded, but did not return a function state in the first working memory.");
-					error=true;
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					error_str = RTR("Node yielded, but did not return a function state in the first working memory.");
+					error = true;
 					break;
-
 				}
 
 				//step 1, capture all state
-				state->instance_id=get_owner_ptr()->get_instance_ID();
-				state->script_id=get_script()->get_instance_ID();
-				state->instance=this;
-				state->function=p_method;
-				state->working_mem_index=node->working_mem_idx;
-				state->variant_stack_size=f->max_stack;
-				state->node=node;
-				state->flow_stack_pos=flow_stack_pos;
+				state->instance_id = get_owner_ptr()->get_instance_ID();
+				state->script_id = get_script()->get_instance_ID();
+				state->instance = this;
+				state->function = p_method;
+				state->working_mem_index = node->working_mem_idx;
+				state->variant_stack_size = f->max_stack;
+				state->node = node;
+				state->flow_stack_pos = flow_stack_pos;
 				state->stack.resize(p_stack_size);
-				state->pass=p_pass;
-				copymem(state->stack.ptr(),p_stack,p_stack_size);
+				state->pass = p_pass;
+				copymem(state->stack.ptr(), p_stack, p_stack_size);
 				//step 2, run away, return directly
-				r_error.error=Variant::CallError::CALL_OK;
-
+				r_error.error = Variant::CallError::CALL_OK;
 
 #ifdef DEBUG_ENABLED
 				//will re-enter later, so exiting
@@ -1738,67 +1610,65 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 #endif
 
 				return state;
-
 			}
 		}
 
 #ifdef DEBUG_ENABLED
 		if (ScriptDebugger::get_singleton()) {
 			// line
-			bool do_break=false;
+			bool do_break = false;
 
-			if (ScriptDebugger::get_singleton()->get_lines_left()>0) {
+			if (ScriptDebugger::get_singleton()->get_lines_left() > 0) {
 
-				if (ScriptDebugger::get_singleton()->get_depth()<=0)
-					ScriptDebugger::get_singleton()->set_lines_left( ScriptDebugger::get_singleton()->get_lines_left() -1 );
-				if (ScriptDebugger::get_singleton()->get_lines_left()<=0)
-					do_break=true;
+				if (ScriptDebugger::get_singleton()->get_depth() <= 0)
+					ScriptDebugger::get_singleton()->set_lines_left(ScriptDebugger::get_singleton()->get_lines_left() - 1);
+				if (ScriptDebugger::get_singleton()->get_lines_left() <= 0)
+					do_break = true;
 			}
 
-			if (ScriptDebugger::get_singleton()->is_breakpoint(current_node_id,source))
-				do_break=true;
+			if (ScriptDebugger::get_singleton()->is_breakpoint(current_node_id, source))
+				do_break = true;
 
 			if (do_break) {
-				VisualScriptLanguage::singleton->debug_break("Breakpoint",true);
+				VisualScriptLanguage::singleton->debug_break("Breakpoint", true);
 			}
 
 			ScriptDebugger::get_singleton()->line_poll();
-
 		}
 #endif
 		int output = ret & VisualScriptNodeInstance::STEP_MASK;
 
-		VSDEBUG("STEP RETURN: "+itos(ret));
+		VSDEBUG("STEP RETURN: " + itos(ret));
 
 		if (ret & VisualScriptNodeInstance::STEP_EXIT_FUNCTION_BIT) {
-			if (node->get_working_memory_size()==0) {
+			if (node->get_working_memory_size() == 0) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-				error_str=RTR("Return value must be assigned to first element of node working memory! Fix your node please.");
-				error=true;
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				error_str = RTR("Return value must be assigned to first element of node working memory! Fix your node please.");
+				error = true;
 			} else {
 				//assign from working memory, first element
-				return_value=*working_mem;
+				return_value = *working_mem;
 			}
 
-			VSDEBUG("EXITING FUNCTION - VALUE "+String(return_value));
+			VSDEBUG("EXITING FUNCTION - VALUE " + String(return_value));
 			break; //exit function requested, bye
 		}
 
-		VisualScriptNodeInstance *next=NULL; //next node
+		VisualScriptNodeInstance *next = NULL; //next node
 
-		if ( (ret==output || ret&VisualScriptNodeInstance::STEP_FLAG_PUSH_STACK_BIT) && node->sequence_output_count) {
+		if ((ret == output || ret & VisualScriptNodeInstance::STEP_FLAG_PUSH_STACK_BIT) && node->sequence_output_count) {
 			//if no exit bit was set, and has sequence outputs, guess next node
-			if (output<0 || output>=node->sequence_output_count) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-				error_str=RTR("Node returned an invalid sequence output: ")+itos(output);
-				error=true;
+			if (output < 0 || output >= node->sequence_output_count) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				error_str = RTR("Node returned an invalid sequence output: ") + itos(output);
+				error = true;
 				break;
 			}
 
 			next = node->sequence_outputs[output];
 			if (next) {
-				VSDEBUG("GOT NEXT NODE - "+itos(next->get_id()));
+				VSDEBUG("GOT NEXT NODE - " + itos(next->get_id()));
 			} else {
 				VSDEBUG("GOT NEXT NODE - NULL");
 			}
@@ -1813,20 +1683,19 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 			if (ret & VisualScriptNodeInstance::STEP_FLAG_PUSH_STACK_BIT) {
 
 				flow_stack[flow_stack_pos] |= VisualScriptNodeInstance::FLOW_STACK_PUSHED_BIT;
-				sequence_bits[ node ->sequence_index ]=true; //remember sequence bit
+				sequence_bits[node->sequence_index] = true; //remember sequence bit
 				VSDEBUG("NEXT SEQ - FLAG BIT");
 			} else {
-				sequence_bits[ node ->sequence_index ]=false; //forget sequence bit
+				sequence_bits[node->sequence_index] = false; //forget sequence bit
 				VSDEBUG("NEXT SEQ - NORMAL");
 			}
 
-
 			if (ret & VisualScriptNodeInstance::STEP_FLAG_GO_BACK_BIT) {
 				//go back request
 
-				if (flow_stack_pos>0) {
+				if (flow_stack_pos > 0) {
 					flow_stack_pos--;
-					node = instances[ flow_stack[flow_stack_pos] & VisualScriptNodeInstance::FLOW_STACK_MASK ];
+					node = instances[flow_stack[flow_stack_pos] & VisualScriptNodeInstance::FLOW_STACK_MASK];
 					VSDEBUG("NEXT IS GO BACK");
 				} else {
 					VSDEBUG("NEXT IS GO BACK, BUT NO NEXT SO EXIT");
@@ -1834,7 +1703,6 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 				}
 			} else if (next) {
 
-
 				if (sequence_bits[next->sequence_index]) {
 					// what happened here is that we are entering a node that is in the middle of doing a sequence (pushed stack) from the front
 					// because each node has a working memory, we can't really do a sub-sequence
@@ -1843,43 +1711,41 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 
 					bool found = false;
 
-					for(int i=flow_stack_pos;i>=0;i--) {
-
+					for (int i = flow_stack_pos; i >= 0; i--) {
 
-						if ( (flow_stack[i] & VisualScriptNodeInstance::FLOW_STACK_MASK ) == next->get_id() ) {
-							flow_stack_pos=i; //roll back and remove bit
-							flow_stack[i]=next->get_id();
-							sequence_bits[next->sequence_index]=false;
-							found=true;
+						if ((flow_stack[i] & VisualScriptNodeInstance::FLOW_STACK_MASK) == next->get_id()) {
+							flow_stack_pos = i; //roll back and remove bit
+							flow_stack[i] = next->get_id();
+							sequence_bits[next->sequence_index] = false;
+							found = true;
 						}
 					}
 
 					if (!found) {
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-						error_str=RTR("Found sequence bit but not the node in the stack, report bug!");
-						error=true;
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						error_str = RTR("Found sequence bit but not the node in the stack, report bug!");
+						error = true;
 						break;
 					}
 
-					node=next;
-					VSDEBUG("RE-ENTERED A LOOP, RETURNED STACK POS TO - "+itos(flow_stack_pos));
+					node = next;
+					VSDEBUG("RE-ENTERED A LOOP, RETURNED STACK POS TO - " + itos(flow_stack_pos));
 
 				} else {
 					// check for stack overflow
-					if (flow_stack_pos+1 >= flow_max) {
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-						error_str=RTR("Stack overflow with stack depth: ")+itos(output);
-						error=true;
+					if (flow_stack_pos + 1 >= flow_max) {
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						error_str = RTR("Stack overflow with stack depth: ") + itos(output);
+						error = true;
 						break;
 					}
 
 					node = next;
 
 					flow_stack_pos++;
-					flow_stack[flow_stack_pos]=node->get_id();
+					flow_stack[flow_stack_pos] = node->get_id();
 
 					VSDEBUG("INCREASE FLOW STACK");
-
 				}
 
 			} else {
@@ -1887,14 +1753,14 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 
 				bool found = false;
 
-				for(int i=flow_stack_pos;i>=0;i--) {
+				for (int i = flow_stack_pos; i >= 0; i--) {
 
-					VSDEBUG("FS "+itos(i)+" - "+itos(flow_stack[i]));
+					VSDEBUG("FS " + itos(i) + " - " + itos(flow_stack[i]));
 					if (flow_stack[i] & VisualScriptNodeInstance::FLOW_STACK_PUSHED_BIT) {
 
-						node = instances[ flow_stack[i] & VisualScriptNodeInstance::FLOW_STACK_MASK ];
-						flow_stack_pos=i;
-						found=true;
+						node = instances[flow_stack[i] & VisualScriptNodeInstance::FLOW_STACK_MASK];
+						flow_stack_pos = i;
+						found = true;
 						break;
 					}
 				}
@@ -1904,59 +1770,53 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 					break; //done, couldn't find a push stack bit
 				}
 
-				VSDEBUG("NO NEXT NODE, GO BACK TO: "+itos(flow_stack_pos));
-
+				VSDEBUG("NO NEXT NODE, GO BACK TO: " + itos(flow_stack_pos));
 			}
 		} else {
 
-			node=next; //stackless mode, simply assign next node
+			node = next; //stackless mode, simply assign next node
 		}
-
 	}
 
-
-
 	if (error) {
 
 		//error
 		// function, file, line, error, explanation
 		String err_file = script->get_path();
 		String err_func = p_method;
-		int err_line=current_node_id; //not a line but it works as one
+		int err_line = current_node_id; //not a line but it works as one
 
-		if (node && (r_error.error!=Variant::CallError::CALL_ERROR_INVALID_METHOD || error_str==String())) {
+		if (node && (r_error.error != Variant::CallError::CALL_ERROR_INVALID_METHOD || error_str == String())) {
 
-			if (error_str!=String()) {
-				error_str+=" ";
+			if (error_str != String()) {
+				error_str += " ";
 			}
 
-			if (r_error.error==Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
-				int errorarg=r_error.argument;
-				error_str+="Cannot convert argument "+itos(errorarg+1)+" to "+Variant::get_type_name(r_error.expected)+".";
-			} else if (r_error.error==Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
-				error_str+="Expected "+itos(r_error.argument)+" arguments.";
-			} else if (r_error.error==Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
-				error_str+="Expected "+itos(r_error.argument)+" arguments.";
-			} else if (r_error.error==Variant::CallError::CALL_ERROR_INVALID_METHOD) {
-				error_str+="Invalid Call.";
-			} else if (r_error.error==Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
-				error_str+="Base Instance is null";
+			if (r_error.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
+				int errorarg = r_error.argument;
+				error_str += "Cannot convert argument " + itos(errorarg + 1) + " to " + Variant::get_type_name(r_error.expected) + ".";
+			} else if (r_error.error == Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
+				error_str += "Expected " + itos(r_error.argument) + " arguments.";
+			} else if (r_error.error == Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
+				error_str += "Expected " + itos(r_error.argument) + " arguments.";
+			} else if (r_error.error == Variant::CallError::CALL_ERROR_INVALID_METHOD) {
+				error_str += "Invalid Call.";
+			} else if (r_error.error == Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
+				error_str += "Base Instance is null";
 			}
 		}
 
-
 		//if (!GDScriptLanguage::get_singleton()->debug_break(err_text,false)) {
-			// debugger break did not happen
+		// debugger break did not happen
 
-		if (!VisualScriptLanguage::singleton->debug_break(error_str,false)) {
+		if (!VisualScriptLanguage::singleton->debug_break(error_str, false)) {
 
-			_err_print_error(err_func.utf8().get_data(),err_file.utf8().get_data(),err_line,error_str.utf8().get_data(),ERR_HANDLER_SCRIPT);
+			_err_print_error(err_func.utf8().get_data(), err_file.utf8().get_data(), err_line, error_str.utf8().get_data(), ERR_HANDLER_SCRIPT);
 		}
 
 		//}
 	} else {
 
-
 		//return_value=
 	}
 
@@ -1967,64 +1827,62 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 #endif
 
 	//clean up variant stack
-	for(int i=0;i<f->max_stack;i++) {
+	for (int i = 0; i < f->max_stack; i++) {
 		variant_stack[i].~Variant();
 	}
 
-
 	return return_value;
 }
 
+Variant VisualScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
 
-Variant VisualScriptInstance::call(const StringName& p_method, const Variant** p_args, int p_argcount, Variant::CallError &r_error){
+	r_error.error = Variant::CallError::CALL_OK; //ok by default
 
-	r_error.error=Variant::CallError::CALL_OK; //ok by default
-
-	Map<StringName,Function>::Element *F = functions.find(p_method);
+	Map<StringName, Function>::Element *F = functions.find(p_method);
 	if (!F) {
-		r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 		return Variant();
 	}
 
-	VSDEBUG("CALLING: "+String(p_method));
+	VSDEBUG("CALLING: " + String(p_method));
 
-	Function *f=&F->get();
+	Function *f = &F->get();
 
-	int total_stack_size=0;
+	int total_stack_size = 0;
 
-	total_stack_size+=f->max_stack*sizeof(Variant); //variants
-	total_stack_size+=f->node_count*sizeof(bool);
-	total_stack_size+=(max_input_args+max_output_args)*sizeof(Variant*); //arguments
-	total_stack_size+=f->flow_stack_size*sizeof(int); //flow
-	total_stack_size+=f->pass_stack_size*sizeof(int);
+	total_stack_size += f->max_stack * sizeof(Variant); //variants
+	total_stack_size += f->node_count * sizeof(bool);
+	total_stack_size += (max_input_args + max_output_args) * sizeof(Variant *); //arguments
+	total_stack_size += f->flow_stack_size * sizeof(int); //flow
+	total_stack_size += f->pass_stack_size * sizeof(int);
 
-	VSDEBUG("STACK SIZE: "+itos(total_stack_size));
-	VSDEBUG("STACK VARIANTS: : "+itos(f->max_stack));
-	VSDEBUG("SEQBITS: : "+itos(f->node_count));
-	VSDEBUG("MAX INPUT: "+itos(max_input_args));
-	VSDEBUG("MAX OUTPUT: "+itos(max_output_args));
-	VSDEBUG("FLOW STACK SIZE: "+itos(f->flow_stack_size));
-	VSDEBUG("PASS STACK SIZE: "+itos(f->pass_stack_size));
+	VSDEBUG("STACK SIZE: " + itos(total_stack_size));
+	VSDEBUG("STACK VARIANTS: : " + itos(f->max_stack));
+	VSDEBUG("SEQBITS: : " + itos(f->node_count));
+	VSDEBUG("MAX INPUT: " + itos(max_input_args));
+	VSDEBUG("MAX OUTPUT: " + itos(max_output_args));
+	VSDEBUG("FLOW STACK SIZE: " + itos(f->flow_stack_size));
+	VSDEBUG("PASS STACK SIZE: " + itos(f->pass_stack_size));
 
 	void *stack = alloca(total_stack_size);
 
-	Variant *variant_stack=(Variant*)stack;
-	bool *sequence_bits = (bool*)(variant_stack + f->max_stack);
-	const Variant **input_args=(const Variant**)(sequence_bits+f->node_count);
-	Variant **output_args=(Variant**)(input_args + max_input_args);
+	Variant *variant_stack = (Variant *)stack;
+	bool *sequence_bits = (bool *)(variant_stack + f->max_stack);
+	const Variant **input_args = (const Variant **)(sequence_bits + f->node_count);
+	Variant **output_args = (Variant **)(input_args + max_input_args);
 	int flow_max = f->flow_stack_size;
-	int* flow_stack = flow_max? (int*)(output_args + max_output_args) : (int*)NULL;
+	int *flow_stack = flow_max ? (int *)(output_args + max_output_args) : (int *)NULL;
 	int *pass_stack = flow_stack + flow_max;
 
-	for(int i=0;i<f->node_count;i++) {
-		sequence_bits[i]=false; //all starts as false
+	for (int i = 0; i < f->node_count; i++) {
+		sequence_bits[i] = false; //all starts as false
 	}
 
-	zeromem(pass_stack,f->pass_stack_size*sizeof(int));
+	zeromem(pass_stack, f->pass_stack_size * sizeof(int));
 
-	Map<int,VisualScriptNodeInstance*>::Element *E = instances.find(f->node);
+	Map<int, VisualScriptNodeInstance *>::Element *E = instances.find(f->node);
 	if (!E) {
-		r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 
 		ERR_EXPLAIN("No VisualScriptFunction node in function!");
 		ERR_FAIL_V(Variant());
@@ -2032,66 +1890,62 @@ Variant VisualScriptInstance::call(const StringName& p_method, const Variant** p
 
 	VisualScriptNodeInstance *node = E->get();
 
-
-	if (flow_stack)	{
-		flow_stack[0]=node->get_id();
+	if (flow_stack) {
+		flow_stack[0] = node->get_id();
 	}
 
-	VSDEBUG("ARGUMENTS: "+itos(f->argument_count)=" RECEIVED: "+itos(p_argcount));
+	VSDEBUG("ARGUMENTS: " + itos(f->argument_count) = " RECEIVED: " + itos(p_argcount));
 
-	if (p_argcount<f->argument_count) {
-		r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.argument=node->get_input_port_count();
+	if (p_argcount < f->argument_count) {
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+		r_error.argument = node->get_input_port_count();
 
 		return Variant();
 	}
 
-	if (p_argcount>f->argument_count) {
-		r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
-		r_error.argument=node->get_input_port_count();
+	if (p_argcount > f->argument_count) {
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+		r_error.argument = node->get_input_port_count();
 
 		return Variant();
 	}
 
 	//allocate variant stack
-	for(int i=0;i<f->max_stack;i++) {
-		memnew_placement(&variant_stack[i],Variant);
+	for (int i = 0; i < f->max_stack; i++) {
+		memnew_placement(&variant_stack[i], Variant);
 	}
 
 	//allocate function arguments (must be copied for yield to work properly)
-	for(int i=0;i<p_argcount;i++) {
-		variant_stack[i]=*p_args[i];
+	for (int i = 0; i < p_argcount; i++) {
+		variant_stack[i] = *p_args[i];
 	}
 
-	return _call_internal(p_method,stack,total_stack_size,node,0,0,false,r_error);
-
-
+	return _call_internal(p_method, stack, total_stack_size, node, 0, 0, false, r_error);
 }
 
-void VisualScriptInstance::notification(int p_notification){
+void VisualScriptInstance::notification(int p_notification) {
 
 	//do nothing as this is called using virtual
 
-	Variant what=p_notification;
-	const Variant*whatp=&what;
+	Variant what = p_notification;
+	const Variant *whatp = &what;
 	Variant::CallError ce;
-	call(VisualScriptLanguage::singleton->notification,&whatp,1,ce); //do as call
-
+	call(VisualScriptLanguage::singleton->notification, &whatp, 1, ce); //do as call
 }
 
-Ref<Script> VisualScriptInstance::get_script() const{
+Ref<Script> VisualScriptInstance::get_script() const {
 
 	return script;
 }
 
-ScriptInstance::RPCMode VisualScriptInstance::get_rpc_mode(const StringName& p_method) const {
+ScriptInstance::RPCMode VisualScriptInstance::get_rpc_mode(const StringName &p_method) const {
 
-	const Map<StringName,VisualScript::Function>::Element *E = script->functions.find(p_method);
+	const Map<StringName, VisualScript::Function>::Element *E = script->functions.find(p_method);
 	if (!E) {
 		return RPC_MODE_DISABLED;
 	}
 
-	if (E->get().function_id>=0 && E->get().nodes.has(E->get().function_id)) {
+	if (E->get().function_id >= 0 && E->get().nodes.has(E->get().function_id)) {
 
 		Ref<VisualScriptFunction> vsf = E->get().nodes[E->get().function_id].node;
 		if (vsf.is_valid()) {
@@ -2103,24 +1957,23 @@ ScriptInstance::RPCMode VisualScriptInstance::get_rpc_mode(const StringName& p_m
 	return RPC_MODE_DISABLED;
 }
 
-ScriptInstance::RPCMode VisualScriptInstance::get_rset_mode(const StringName& p_variable) const {
+ScriptInstance::RPCMode VisualScriptInstance::get_rset_mode(const StringName &p_variable) const {
 
 	return RPC_MODE_DISABLED;
 }
 
+void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_owner) {
 
-void VisualScriptInstance::create(const Ref<VisualScript>& p_script,Object *p_owner) {
-
-	script=p_script;
-	owner=p_owner;
-	source=p_script->get_path();
+	script = p_script;
+	owner = p_owner;
+	source = p_script->get_path();
 
 	max_input_args = 0;
 	max_output_args = 0;
 
 	if (p_owner->cast_to<Node>()) {
 		//turn on these if they exist and base is a node
-		Node* node = p_owner->cast_to<Node>();
+		Node *node = p_owner->cast_to<Node>();
 		if (p_script->functions.has("_process"))
 			node->set_process(true);
 		if (p_script->functions.has("_fixed_process"))
@@ -2133,86 +1986,81 @@ void VisualScriptInstance::create(const Ref<VisualScript>& p_script,Object *p_ow
 			node->set_process_unhandled_key_input(true);
 	}
 
-	for(const Map<StringName,VisualScript::Variable>::Element *E=script->variables.front();E;E=E->next()) {
-		variables[E->key()]=E->get().default_value;
+	for (const Map<StringName, VisualScript::Variable>::Element *E = script->variables.front(); E; E = E->next()) {
+		variables[E->key()] = E->get().default_value;
 		//no hacer que todo exporte, solo las que queres!
 	}
 
-
-	for(const Map<StringName,VisualScript::Function>::Element *E=script->functions.front();E;E=E->next()) {
+	for (const Map<StringName, VisualScript::Function>::Element *E = script->functions.front(); E; E = E->next()) {
 
 		Function function;
-		function.node=E->get().function_id;
-		function.max_stack=0;
-		function.flow_stack_size=0;
-		function.pass_stack_size=0;
-		function.node_count=0;
-		Map<StringName,int> local_var_indices;
+		function.node = E->get().function_id;
+		function.max_stack = 0;
+		function.flow_stack_size = 0;
+		function.pass_stack_size = 0;
+		function.node_count = 0;
+		Map<StringName, int> local_var_indices;
 
-		if (function.node<0) {
-			VisualScriptLanguage::singleton->debug_break_parse(get_script()->get_path(),0,"No start node in function: "+String(E->key()));
+		if (function.node < 0) {
+			VisualScriptLanguage::singleton->debug_break_parse(get_script()->get_path(), 0, "No start node in function: " + String(E->key()));
 
-			ERR_CONTINUE( function.node < 0 );
+			ERR_CONTINUE(function.node < 0);
 		}
 
 		{
-			Ref<VisualScriptFunction> func_node = script->get_node(E->key(),E->get().function_id);
+			Ref<VisualScriptFunction> func_node = script->get_node(E->key(), E->get().function_id);
 
 			if (func_node.is_null()) {
-				VisualScriptLanguage::singleton->debug_break_parse(get_script()->get_path(),0,"No VisualScriptFunction typed start node in function: "+String(E->key()));
+				VisualScriptLanguage::singleton->debug_break_parse(get_script()->get_path(), 0, "No VisualScriptFunction typed start node in function: " + String(E->key()));
 			}
 
-			ERR_CONTINUE( !func_node.is_valid() );
-
-			function.argument_count=func_node->get_argument_count();
-			function.max_stack+=function.argument_count;
-			function.flow_stack_size= func_node->is_stack_less() ? 0 : func_node->get_stack_size();
+			ERR_CONTINUE(!func_node.is_valid());
 
+			function.argument_count = func_node->get_argument_count();
+			function.max_stack += function.argument_count;
+			function.flow_stack_size = func_node->is_stack_less() ? 0 : func_node->get_stack_size();
 		}
 
 		//multiple passes are required to set up this complex thing..
 
-
-
-
 		//first create the nodes
-		for (const Map<int,VisualScript::Function::NodeData>::Element *F=E->get().nodes.front();F;F=F->next()) {
+		for (const Map<int, VisualScript::Function::NodeData>::Element *F = E->get().nodes.front(); F; F = F->next()) {
 
 			Ref<VisualScriptNode> node = F->get().node;
 			VisualScriptNodeInstance *instance = node->instance(this); //create instance
 			ERR_FAIL_COND(!instance);
 
-			instance->base=node.ptr();
+			instance->base = node.ptr();
 
-			instance->id=F->key();
+			instance->id = F->key();
 			instance->input_port_count = node->get_input_value_port_count();
-			instance->input_ports=NULL;
+			instance->input_ports = NULL;
 			instance->output_port_count = node->get_output_value_port_count();
-			instance->output_ports=NULL;
+			instance->output_ports = NULL;
 			instance->sequence_output_count = node->get_output_sequence_port_count();
-			instance->sequence_index=function.node_count++;
-			instance->sequence_outputs=NULL;
-			instance->pass_idx=-1;
+			instance->sequence_index = function.node_count++;
+			instance->sequence_outputs = NULL;
+			instance->pass_idx = -1;
 
 			if (instance->input_port_count) {
-				instance->input_ports = memnew_arr(int,instance->input_port_count);
-				for(int i=0;i<instance->input_port_count;i++) {
+				instance->input_ports = memnew_arr(int, instance->input_port_count);
+				for (int i = 0; i < instance->input_port_count; i++) {
 
-					instance->input_ports[i]=-1; //if not assigned, will become default value
-				}							
+					instance->input_ports[i] = -1; //if not assigned, will become default value
+				}
 			}
 
 			if (instance->output_port_count) {
-				instance->output_ports = memnew_arr(int,instance->output_port_count);
-				for(int i=0;i<instance->output_port_count;i++) {
-					instance->output_ports[i]=-1; //if not assigned, will output to trash
+				instance->output_ports = memnew_arr(int, instance->output_port_count);
+				for (int i = 0; i < instance->output_port_count; i++) {
+					instance->output_ports[i] = -1; //if not assigned, will output to trash
 				}
 			}
 
 			if (instance->sequence_output_count) {
-				instance->sequence_outputs = memnew_arr(VisualScriptNodeInstance*,instance->sequence_output_count);
-				for(int i=0;i<instance->sequence_output_count;i++) {
-					instance->sequence_outputs[i]=NULL; //if it remains null, flow ends here
+				instance->sequence_outputs = memnew_arr(VisualScriptNodeInstance *, instance->sequence_output_count);
+				for (int i = 0; i < instance->sequence_output_count; i++) {
+					instance->sequence_outputs[i] = NULL; //if it remains null, flow ends here
 				}
 			}
 
@@ -2228,32 +2076,30 @@ void VisualScriptInstance::create(const Ref<VisualScript>& p_script,Object *p_ow
 					var_name = String(node->cast_to<VisualScriptLocalVarSet>()->get_var_name()).strip_edges();
 
 				if (!local_var_indices.has(var_name)) {
-					local_var_indices[var_name]=function.max_stack;
+					local_var_indices[var_name] = function.max_stack;
 					function.max_stack++;
 				}
 
-				instance->working_mem_idx=local_var_indices[var_name];
+				instance->working_mem_idx = local_var_indices[var_name];
 
 			} else if (instance->get_working_memory_size()) {
 				instance->working_mem_idx = function.max_stack;
-				function.max_stack+=instance->get_working_memory_size();
+				function.max_stack += instance->get_working_memory_size();
 			} else {
-				instance->working_mem_idx=-1; //no working mem
+				instance->working_mem_idx = -1; //no working mem
 			}
 
-			max_input_args = MAX( max_input_args, instance->input_port_count );
-			max_output_args = MAX( max_output_args, instance->output_port_count );
-
-			instances[F->key()]=instance;
-
+			max_input_args = MAX(max_input_args, instance->input_port_count);
+			max_output_args = MAX(max_output_args, instance->output_port_count);
 
+			instances[F->key()] = instance;
 		}
 
 		function.trash_pos = function.max_stack++; //create pos for trash
 
 		//second pass, do data connections
 
-		for(const Set<VisualScript::DataConnection>::Element *F=E->get().data_connections.front();F;F=F->next()) {
+		for (const Set<VisualScript::DataConnection>::Element *F = E->get().data_connections.front(); F; F = F->next()) {
 
 			VisualScript::DataConnection dc = F->get();
 			ERR_CONTINUE(!instances.has(dc.from_node));
@@ -2263,29 +2109,27 @@ void VisualScriptInstance::create(const Ref<VisualScript>& p_script,Object *p_ow
 			ERR_CONTINUE(dc.from_port >= from->output_port_count);
 			ERR_CONTINUE(dc.to_port >= to->input_port_count);
 
-			if (from->output_ports[dc.from_port]==-1) {
+			if (from->output_ports[dc.from_port] == -1) {
 
 				int stack_pos = function.max_stack++;
 				from->output_ports[dc.from_port] = stack_pos;
 			}
 
-
-			if (from->get_sequence_output_count()==0 && to->dependencies.find(from)==-1) {
+			if (from->get_sequence_output_count() == 0 && to->dependencies.find(from) == -1) {
 				//if the node we are reading from has no output sequence, we must call step() before reading from it.
-				if (from->pass_idx==-1) {
-					from->pass_idx=function.pass_stack_size;
+				if (from->pass_idx == -1) {
+					from->pass_idx = function.pass_stack_size;
 					function.pass_stack_size++;
 				}
 				to->dependencies.push_back(from);
 			}
 
 			to->input_ports[dc.to_port] = from->output_ports[dc.from_port]; //read from wherever the stack is
-
 		}
 
 		//third pass, do sequence connections
 
-		for(const Set<VisualScript::SequenceConnection>::Element *F=E->get().sequence_connections.front();F;F=F->next()) {
+		for (const Set<VisualScript::SequenceConnection>::Element *F = E->get().sequence_connections.front(); F; F = F->next()) {
 
 			VisualScript::SequenceConnection sc = F->get();
 			ERR_CONTINUE(!instances.has(sc.from_node));
@@ -2294,16 +2138,14 @@ void VisualScriptInstance::create(const Ref<VisualScript>& p_script,Object *p_ow
 			VisualScriptNodeInstance *to = instances[sc.to_node];
 			ERR_CONTINUE(sc.from_output >= from->sequence_output_count);
 
-			from->sequence_outputs[sc.from_output]=to;
-
+			from->sequence_outputs[sc.from_output] = to;
 		}
 
 		//fourth pass:
 		// 1) unassigned input ports to default values
 		// 2) connect unassigned output ports to trash
 
-
-		for (const Map<int,VisualScript::Function::NodeData>::Element *F=E->get().nodes.front();F;F=F->next()) {
+		for (const Map<int, VisualScript::Function::NodeData>::Element *F = E->get().nodes.front(); F; F = F->next()) {
 
 			ERR_CONTINUE(!instances.has(F->key()));
 
@@ -2311,37 +2153,33 @@ void VisualScriptInstance::create(const Ref<VisualScript>& p_script,Object *p_ow
 			VisualScriptNodeInstance *instance = instances[F->key()];
 
 			// conect to default values
-			for(int i=0;i<instance->input_port_count;i++) {
-				if (instance->input_ports[i]==-1) {
+			for (int i = 0; i < instance->input_port_count; i++) {
+				if (instance->input_ports[i] == -1) {
 
 					//unassigned, connect to default val
 					instance->input_ports[i] = default_values.size() | VisualScriptNodeInstance::INPUT_DEFAULT_VALUE_BIT;
-					default_values.push_back( node->get_default_input_value(i) );
+					default_values.push_back(node->get_default_input_value(i));
 				}
 			}
 
 			// conect to trash
-			for(int i=0;i<instance->output_port_count;i++) {
-				if (instance->output_ports[i]==-1) {
+			for (int i = 0; i < instance->output_port_count; i++) {
+				if (instance->output_ports[i] == -1) {
 					instance->output_ports[i] = function.trash_pos; //trash is same for all
 				}
 			}
 		}
 
-
-		functions[E->key()]=function;
+		functions[E->key()] = function;
 	}
 }
 
-ScriptLanguage *VisualScriptInstance::get_language(){
+ScriptLanguage *VisualScriptInstance::get_language() {
 
 	return VisualScriptLanguage::singleton;
 }
 
-
 VisualScriptInstance::VisualScriptInstance() {
-
-
 }
 
 VisualScriptInstance::~VisualScriptInstance() {
@@ -2354,22 +2192,18 @@ VisualScriptInstance::~VisualScriptInstance() {
 	if (VisualScriptLanguage::singleton->lock)
 		VisualScriptLanguage::singleton->lock->unlock();
 
-	for (Map<int,VisualScriptNodeInstance*>::Element *E=instances.front();E;E=E->next()) {
+	for (Map<int, VisualScriptNodeInstance *>::Element *E = instances.front(); E; E = E->next()) {
 		memdelete(E->get());
 	}
 }
 
-
-
 /////////////////////////////////////////////
 
-
 /////////////////////
 
+Variant VisualScriptFunctionState::_signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
 
-Variant VisualScriptFunctionState::_signal_callback(const Variant** p_args, int p_argcount, Variant::CallError& r_error) {
-
-	ERR_FAIL_COND_V(function==StringName(),Variant());
+	ERR_FAIL_COND_V(function == StringName(), Variant());
 
 #ifdef DEBUG_ENABLED
 	if (instance_id && !ObjectDB::get_instance(instance_id)) {
@@ -2383,61 +2217,61 @@ Variant VisualScriptFunctionState::_signal_callback(const Variant** p_args, int
 	}
 #endif
 
-	r_error.error=Variant::CallError::CALL_OK;
+	r_error.error = Variant::CallError::CALL_OK;
 
 	Array args;
 
-	if (p_argcount==0) {
-		r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
-		r_error.argument=1;
+	if (p_argcount == 0) {
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+		r_error.argument = 1;
 		return Variant();
-	} else if (p_argcount==1) {
+	} else if (p_argcount == 1) {
 		//noooneee, reserved for me, me and only me.
 	} else {
 
-		for(int i=0;i<p_argcount-1;i++) {
+		for (int i = 0; i < p_argcount - 1; i++) {
 			args.push_back(*p_args[i]);
 		}
 	}
 
-	Ref<VisualScriptFunctionState> self = *p_args[p_argcount-1]; //hi, I'm myself, needed this to remain alive.
+	Ref<VisualScriptFunctionState> self = *p_args[p_argcount - 1]; //hi, I'm myself, needed this to remain alive.
 
 	if (self.is_null()) {
-		r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-		r_error.argument=p_argcount-1;
-		r_error.expected=Variant::OBJECT;
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+		r_error.argument = p_argcount - 1;
+		r_error.expected = Variant::OBJECT;
 		return Variant();
 	}
 
-	r_error.error=Variant::CallError::CALL_OK;
+	r_error.error = Variant::CallError::CALL_OK;
 
-	Variant *working_mem = ((Variant*)stack.ptr()) + working_mem_index;
+	Variant *working_mem = ((Variant *)stack.ptr()) + working_mem_index;
 
-	*working_mem=args; //arguments go to working mem.
+	*working_mem = args; //arguments go to working mem.
 
-	Variant ret = instance->_call_internal(function,stack.ptr(),stack.size(),node,flow_stack_pos,pass,true,r_error);
-	function=StringName(); //invalidate
+	Variant ret = instance->_call_internal(function, stack.ptr(), stack.size(), node, flow_stack_pos, pass, true, r_error);
+	function = StringName(); //invalidate
 	return ret;
 }
 
-void VisualScriptFunctionState::connect_to_signal(Object* p_obj, const String& p_signal, Array p_binds) {
+void VisualScriptFunctionState::connect_to_signal(Object *p_obj, const String &p_signal, Array p_binds) {
 
 	Vector<Variant> binds;
-	for(int i=0;i<p_binds.size();i++) {
+	for (int i = 0; i < p_binds.size(); i++) {
 		binds.push_back(p_binds[i]);
 	}
 	binds.push_back(Ref<VisualScriptFunctionState>(this)); //add myself on the back to avoid dying from unreferencing
-	p_obj->connect(p_signal,this,"_signal_callback",binds);
+	p_obj->connect(p_signal, this, "_signal_callback", binds);
 }
 
 bool VisualScriptFunctionState::is_valid() const {
 
-	return function!=StringName();
+	return function != StringName();
 }
 
 Variant VisualScriptFunctionState::resume(Array p_args) {
 
-	ERR_FAIL_COND_V(function==StringName(),Variant());
+	ERR_FAIL_COND_V(function == StringName(), Variant());
 #ifdef DEBUG_ENABLED
 	if (instance_id && !ObjectDB::get_instance(instance_id)) {
 		ERR_EXPLAIN("Resumed after yield, but class instance is gone");
@@ -2451,44 +2285,38 @@ Variant VisualScriptFunctionState::resume(Array p_args) {
 #endif
 
 	Variant::CallError r_error;
-	r_error.error=Variant::CallError::CALL_OK;
+	r_error.error = Variant::CallError::CALL_OK;
 
-	Variant *working_mem = ((Variant*)stack.ptr()) + working_mem_index;
+	Variant *working_mem = ((Variant *)stack.ptr()) + working_mem_index;
 
-	*working_mem=p_args; //arguments go to working mem.
+	*working_mem = p_args; //arguments go to working mem.
 
-	Variant ret= instance->_call_internal(function,stack.ptr(),stack.size(),node,flow_stack_pos,pass,true,r_error);
-	function=StringName(); //invalidate
+	Variant ret = instance->_call_internal(function, stack.ptr(), stack.size(), node, flow_stack_pos, pass, true, r_error);
+	function = StringName(); //invalidate
 	return ret;
 }
 
-
 void VisualScriptFunctionState::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("connect_to_signal","obj","signals","args"),&VisualScriptFunctionState::connect_to_signal);
-	ClassDB::bind_method(D_METHOD("resume:Array","args"),&VisualScriptFunctionState::resume,DEFVAL(Variant()));
-	ClassDB::bind_method(D_METHOD("is_valid"),&VisualScriptFunctionState::is_valid);
-	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT,"_signal_callback",&VisualScriptFunctionState::_signal_callback,MethodInfo("_signal_callback"));
+	ClassDB::bind_method(D_METHOD("connect_to_signal", "obj", "signals", "args"), &VisualScriptFunctionState::connect_to_signal);
+	ClassDB::bind_method(D_METHOD("resume:Array", "args"), &VisualScriptFunctionState::resume, DEFVAL(Variant()));
+	ClassDB::bind_method(D_METHOD("is_valid"), &VisualScriptFunctionState::is_valid);
+	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &VisualScriptFunctionState::_signal_callback, MethodInfo("_signal_callback"));
 }
 
 VisualScriptFunctionState::VisualScriptFunctionState() {
-
 }
 
 VisualScriptFunctionState::~VisualScriptFunctionState() {
 
-	if (function!=StringName()) {
-		Variant *s = ((Variant*)stack.ptr());
-		for(int i=0;i<variant_stack_size;i++) {
+	if (function != StringName()) {
+		Variant *s = ((Variant *)stack.ptr());
+		for (int i = 0; i < variant_stack_size; i++) {
 			s[i].~Variant();
 		}
 	}
 }
 
-
-
-
-
 ///////////////////////////////////////////////
 
 String VisualScriptLanguage::get_name() const {
@@ -2498,8 +2326,6 @@ String VisualScriptLanguage::get_name() const {
 
 /* LANGUAGE FUNCTIONS */
 void VisualScriptLanguage::init() {
-
-
 }
 String VisualScriptLanguage::get_type() const {
 
@@ -2509,207 +2335,185 @@ String VisualScriptLanguage::get_extension() const {
 
 	return "vs";
 }
-Error VisualScriptLanguage::execute_file(const String& p_path) {
+Error VisualScriptLanguage::execute_file(const String &p_path) {
 
 	return OK;
 }
 void VisualScriptLanguage::finish() {
-
-
 }
 
 /* EDITOR FUNCTIONS */
 void VisualScriptLanguage::get_reserved_words(List<String> *p_words) const {
-
-
 }
 void VisualScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
-
-
 }
 void VisualScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
-
-
 }
-Ref<Script> VisualScriptLanguage::get_template(const String& p_class_name, const String& p_base_class_name) const {
+Ref<Script> VisualScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
 
 	Ref<VisualScript> script;
 	script.instance();
 	script->set_instance_base_type(p_base_class_name);
 	return script;
 }
-bool VisualScriptLanguage::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 VisualScriptLanguage::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 {
 
 	return false;
 }
 Script *VisualScriptLanguage::create_script() const {
 
-	return memnew( VisualScript );
+	return memnew(VisualScript);
 }
 bool VisualScriptLanguage::has_named_classes() const {
 
 	return false;
 }
-int VisualScriptLanguage::find_function(const String& p_function,const String& p_code) const {
+int VisualScriptLanguage::find_function(const String &p_function, const String &p_code) const {
 
 	return -1;
 }
-String VisualScriptLanguage::make_function(const String& p_class,const String& p_name,const PoolStringArray& p_args) const {
+String VisualScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
 
 	return String();
 }
 
-void VisualScriptLanguage::auto_indent_code(String& p_code,int p_from_line,int p_to_line) const {
-
-
+void VisualScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {
 }
-void VisualScriptLanguage::add_global_constant(const StringName& p_variable,const Variant& p_value) {
-
-
+void VisualScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {
 }
 
-
 /* DEBUGGER FUNCTIONS */
 
-
-
-bool VisualScriptLanguage::debug_break_parse(const String& p_file, int p_node,const String& p_error) {
+bool VisualScriptLanguage::debug_break_parse(const String &p_file, int p_node, const String &p_error) {
 	//break because of parse error
 
-    if (ScriptDebugger::get_singleton() && Thread::get_caller_ID()==Thread::get_main_ID()) {
-
-	_debug_parse_err_node=p_node;
-	_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_node = p_node;
+		_debug_parse_err_file = p_file;
+		_debug_error = p_error;
+		ScriptDebugger::get_singleton()->debug(this, false);
+		return true;
+	} else {
+		return false;
+	}
 }
 
-bool VisualScriptLanguage::debug_break(const String& p_error,bool p_allow_continue) {
-
-    if (ScriptDebugger::get_singleton() && Thread::get_caller_ID()==Thread::get_main_ID()) {
+bool VisualScriptLanguage::debug_break(const String &p_error, bool p_allow_continue) {
 
-	_debug_parse_err_node=-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_node = -1;
+		_debug_parse_err_file = "";
+		_debug_error = p_error;
+		ScriptDebugger::get_singleton()->debug(this, p_allow_continue);
+		return true;
+	} else {
+		return false;
+	}
 }
 
-
 String VisualScriptLanguage::debug_get_error() const {
 
-    return _debug_error;
+	return _debug_error;
 }
 
 int VisualScriptLanguage::debug_get_stack_level_count() const {
 
-	if (_debug_parse_err_node>=0)
+	if (_debug_parse_err_node >= 0)
 		return 1;
 
-
 	return _debug_call_stack_pos;
 }
 int VisualScriptLanguage::debug_get_stack_level_line(int p_level) const {
 
-	if (_debug_parse_err_node>=0)
+	if (_debug_parse_err_node >= 0)
 		return _debug_parse_err_node;
 
-    ERR_FAIL_INDEX_V(p_level,_debug_call_stack_pos,-1);
-
-    int l = _debug_call_stack_pos - p_level -1;
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, -1);
 
-    return *(_call_stack[l].current_id);
+	int l = _debug_call_stack_pos - p_level - 1;
 
+	return *(_call_stack[l].current_id);
 }
 String VisualScriptLanguage::debug_get_stack_level_function(int p_level) const {
 
-	if (_debug_parse_err_node>=0)
+	if (_debug_parse_err_node >= 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;
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, "");
+	int l = _debug_call_stack_pos - p_level - 1;
+	return *_call_stack[l].function;
 }
 String VisualScriptLanguage::debug_get_stack_level_source(int p_level) const {
 
-	if (_debug_parse_err_node>=0)
+	if (_debug_parse_err_node >= 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].instance->get_script_ptr()->get_path();
-
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, "");
+	int l = _debug_call_stack_pos - p_level - 1;
+	return _call_stack[l].instance->get_script_ptr()->get_path();
 }
-void VisualScriptLanguage::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 VisualScriptLanguage::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_node>=0)
+	if (_debug_parse_err_node >= 0)
 		return;
 
-	ERR_FAIL_INDEX(p_level,_debug_call_stack_pos);
+	ERR_FAIL_INDEX(p_level, _debug_call_stack_pos);
 
-	int l = _debug_call_stack_pos - p_level -1;
+	int l = _debug_call_stack_pos - p_level - 1;
 	const StringName *f = _call_stack[l].function;
 
 	ERR_FAIL_COND(!_call_stack[l].instance->functions.has(*f));
 	//VisualScriptInstance::Function *func = &_call_stack[l].instance->functions[*f];
 
-	VisualScriptNodeInstance *node =_call_stack[l].instance->instances[*_call_stack[l].current_id];
+	VisualScriptNodeInstance *node = _call_stack[l].instance->instances[*_call_stack[l].current_id];
 	ERR_FAIL_COND(!node);
 
 	p_locals->push_back("node_name");
 	p_values->push_back(node->get_base_node()->get_text());
 
-	for(int i=0;i<node->input_port_count;i++) {
+	for (int i = 0; i < node->input_port_count; i++) {
 		String name = node->get_base_node()->get_input_value_port_info(i).name;
-		if (name==String()) {
-			name="in_"+itos(i);
+		if (name == String()) {
+			name = "in_" + itos(i);
 		}
 
-		p_locals->push_back("input/"+name);
+		p_locals->push_back("input/" + name);
 
 		//value is trickier
 
 		int in_from = node->input_ports[i];
-		int in_value = in_from&VisualScriptNodeInstance::INPUT_MASK;
+		int in_value = in_from & VisualScriptNodeInstance::INPUT_MASK;
 
-		if (in_from&VisualScriptNodeInstance::INPUT_DEFAULT_VALUE_BIT) {
+		if (in_from & VisualScriptNodeInstance::INPUT_DEFAULT_VALUE_BIT) {
 			p_values->push_back(_call_stack[l].instance->default_values[in_value]);
 		} else {
-			p_values->push_back( _call_stack[l].stack[ in_value] );
+			p_values->push_back(_call_stack[l].stack[in_value]);
 		}
 	}
 
-	for(int i=0;i<node->output_port_count;i++) {
+	for (int i = 0; i < node->output_port_count; i++) {
 
 		String name = node->get_base_node()->get_output_value_port_info(i).name;
-		if (name==String()) {
-			name="out_"+itos(i);
+		if (name == String()) {
+			name = "out_" + itos(i);
 		}
 
-		p_locals->push_back("output/"+name);
+		p_locals->push_back("output/" + name);
 
 		//value is trickier
 
 		int in_from = node->output_ports[i];
-		p_values->push_back( _call_stack[l].stack[ in_from] );
-
+		p_values->push_back(_call_stack[l].stack[in_from]);
 	}
 
-	for(int i=0;i<node->get_working_memory_size();i++) {
-		p_locals->push_back("working_mem/mem_"+itos(i));
-		p_values->push_back( (*_call_stack[l].work_mem)[i]);
+	for (int i = 0; i < node->get_working_memory_size(); i++) {
+		p_locals->push_back("working_mem/mem_" + itos(i));
+		p_values->push_back((*_call_stack[l].work_mem)[i]);
 	}
 
-/*
+	/*
     ERR_FAIL_INDEX(p_level,_debug_call_stack_pos);
 
 
@@ -2725,14 +2529,13 @@ void VisualScriptLanguage::debug_get_stack_level_locals(int p_level,List<String>
     }
 */
 }
-void VisualScriptLanguage::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 VisualScriptLanguage::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_node>=0)
+	if (_debug_parse_err_node >= 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;
 
 	Ref<VisualScript> vs = _call_stack[l].instance->get_script();
 	if (vs.is_null())
@@ -2740,123 +2543,103 @@ void VisualScriptLanguage::debug_get_stack_level_members(int p_level,List<String
 
 	List<StringName> vars;
 	vs->get_variable_list(&vars);
-	for (List<StringName>::Element *E=vars.front();E;E=E->next()) {
+	for (List<StringName>::Element *E = vars.front(); E; E = E->next()) {
 		Variant v;
-		if (_call_stack[l].instance->get_variable(E->get(),&v)) {
-			p_members->push_back("variables/"+E->get());
+		if (_call_stack[l].instance->get_variable(E->get(), &v)) {
+			p_members->push_back("variables/" + E->get());
 			p_values->push_back(v);
 		}
 	}
 }
 
-void VisualScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems,int p_max_depth) {
+void VisualScriptLanguage::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 VisualScriptLanguage::debug_parse_stack_level_expression(int p_level,const String& p_expression,int p_max_subitems,int p_max_depth) {
+String VisualScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
 
-	if (_debug_parse_err_node>=0)
+	if (_debug_parse_err_node >= 0)
 		return "";
 	return "";
 }
 
-
-
 void VisualScriptLanguage::reload_all_scripts() {
-
-
 }
-void VisualScriptLanguage::reload_tool_script(const Ref<Script>& p_script,bool p_soft_reload) {
-
-
+void VisualScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {
 }
 /* LOADER FUNCTIONS */
 
 void VisualScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
 
 	p_extensions->push_back("vs");
-
 }
 void VisualScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
-
-
 }
-void VisualScriptLanguage::get_public_constants(List<Pair<String,Variant> > *p_constants) const {
-
-
+void VisualScriptLanguage::get_public_constants(List<Pair<String, Variant> > *p_constants) const {
 }
 
 void VisualScriptLanguage::profiling_start() {
-
-
 }
 void VisualScriptLanguage::profiling_stop() {
-
-
 }
 
-int VisualScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr,int p_info_max) {
+int VisualScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) {
 
 	return 0;
 }
 
-int VisualScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr,int p_info_max) {
+int VisualScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) {
 
 	return 0;
 }
 
+VisualScriptLanguage *VisualScriptLanguage::singleton = NULL;
 
-VisualScriptLanguage* VisualScriptLanguage::singleton=NULL;
-
-
-void VisualScriptLanguage::add_register_func(const String& p_name,VisualScriptNodeRegisterFunc p_func) {
+void VisualScriptLanguage::add_register_func(const String &p_name, VisualScriptNodeRegisterFunc p_func) {
 
 	ERR_FAIL_COND(register_funcs.has(p_name));
-	register_funcs[p_name]=p_func;
+	register_funcs[p_name] = p_func;
 }
 
-Ref<VisualScriptNode> VisualScriptLanguage::create_node_from_name(const String& p_name) {
+Ref<VisualScriptNode> VisualScriptLanguage::create_node_from_name(const String &p_name) {
 
-	ERR_FAIL_COND_V(!register_funcs.has(p_name),Ref<VisualScriptNode>());
+	ERR_FAIL_COND_V(!register_funcs.has(p_name), Ref<VisualScriptNode>());
 
 	return register_funcs[p_name](p_name);
 }
 
 void VisualScriptLanguage::get_registered_node_names(List<String> *r_names) {
 
-	for (Map<String,VisualScriptNodeRegisterFunc>::Element *E=register_funcs.front();E;E=E->next()) {
+	for (Map<String, VisualScriptNodeRegisterFunc>::Element *E = register_funcs.front(); E; E = E->next()) {
 		r_names->push_back(E->key());
 	}
 }
 
-
 VisualScriptLanguage::VisualScriptLanguage() {
 
-	notification="_notification";
-	_step="_step";
-	_subcall="_subcall";
-	singleton=this;
+	notification = "_notification";
+	_step = "_step";
+	_subcall = "_subcall";
+	singleton = this;
 #ifndef NO_THREADS
 	lock = Mutex::create();
 #endif
 
-
-	_debug_parse_err_node=-1;
-	_debug_parse_err_file="";
-	_debug_call_stack_pos=0;
-	int dmcs=GLOBAL_DEF("debug/script/max_call_stack",1024);
+	_debug_parse_err_node = -1;
+	_debug_parse_err_file = "";
+	_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;
 	}
-
 }
 
 VisualScriptLanguage::~VisualScriptLanguage() {
@@ -2864,8 +2647,8 @@ VisualScriptLanguage::~VisualScriptLanguage() {
 	if (lock)
 		memdelete(lock);
 
-	if (_call_stack)  {
+	if (_call_stack) {
 		memdelete_arr(_call_stack);
 	}
-	singleton=NULL;
+	singleton = NULL;
 }
diff --git a/modules/visual_script/visual_script.h b/modules/visual_script/visual_script.h
index ef73a89048..e3af3f4a1b 100644
--- a/modules/visual_script/visual_script.h
+++ b/modules/visual_script/visual_script.h
@@ -29,19 +29,19 @@
 #ifndef VSCRIPT_H
 #define VSCRIPT_H
 
-#include "script_language.h"
 #include "os/thread.h"
+#include "script_language.h"
 
 class VisualScriptInstance;
 class VisualScriptNodeInstance;
 class VisualScript;
 
 class VisualScriptNode : public Resource {
-	GDCLASS(VisualScriptNode,Resource)
+	GDCLASS(VisualScriptNode, Resource)
 
-friend class VisualScript;
+	friend class VisualScript;
 
-	Set<VisualScript*> scripts_used;
+	Set<VisualScript *> scripts_used;
 
 	Array default_input_values;
 	bool breakpoint;
@@ -50,41 +50,40 @@ friend class VisualScript;
 	Array _get_default_input_values() const;
 
 	void validate_input_default_values();
-protected:
 
+protected:
 	void _notification(int p_what);
 	void ports_changed_notify();
 	static void _bind_methods();
-public:
 
+public:
 	Ref<VisualScript> get_visual_script() const;
 
-	virtual int get_output_sequence_port_count() const=0;
-	virtual bool has_input_sequence_port() const=0;
+	virtual int get_output_sequence_port_count() const = 0;
+	virtual bool has_input_sequence_port() const = 0;
 
-	virtual String get_output_sequence_port_text(int p_port) const=0;
+	virtual String get_output_sequence_port_text(int p_port) const = 0;
 
 	virtual bool has_mixed_input_and_sequence_ports() const { return false; }
 
-	virtual int get_input_value_port_count() const=0;
-	virtual int get_output_value_port_count() const=0;
+	virtual int get_input_value_port_count() const = 0;
+	virtual int get_output_value_port_count() const = 0;
 
+	virtual PropertyInfo get_input_value_port_info(int p_idx) const = 0;
+	virtual PropertyInfo get_output_value_port_info(int p_idx) const = 0;
 
-	virtual PropertyInfo get_input_value_port_info(int p_idx) const=0;
-	virtual PropertyInfo get_output_value_port_info(int p_idx) const=0;
-
-	void set_default_input_value(int p_port,const Variant& p_value);
+	void set_default_input_value(int p_port, const Variant &p_value);
 	Variant get_default_input_value(int p_port) const;
 
-	virtual String get_caption() const=0;
-	virtual String get_text() const=0;
-	virtual String get_category() const=0;
+	virtual String get_caption() const = 0;
+	virtual String get_text() const = 0;
+	virtual String get_category() const = 0;
 
 	//used by editor, this is not really saved
 	void set_breakpoint(bool p_breakpoint);
 	bool is_breakpoint() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance)=0;
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance) = 0;
 
 	struct TypeGuess {
 
@@ -93,32 +92,32 @@ public:
 		StringName GDCLASS;
 		Ref<Script> script;
 
-		TypeGuess() { type=Variant::NIL; ev_type=InputEvent::NONE; }
+		TypeGuess() {
+			type = Variant::NIL;
+			ev_type = InputEvent::NONE;
+		}
 	};
 
-	virtual TypeGuess guess_output_type(TypeGuess* p_inputs, int p_output) const;
+	virtual TypeGuess guess_output_type(TypeGuess *p_inputs, int p_output) const;
 
 	VisualScriptNode();
 };
 
-
 class VisualScriptNodeInstance {
-friend class VisualScriptInstance;
-friend class VisualScriptLanguage; //for debugger
-
+	friend class VisualScriptInstance;
+	friend class VisualScriptLanguage; //for debugger
 
 	enum { //input argument addressing
-		INPUT_SHIFT=1<<24,
-		INPUT_MASK=INPUT_SHIFT-1,
-		INPUT_DEFAULT_VALUE_BIT=INPUT_SHIFT, // from unassigned input port, using default value (edited by user)
+		INPUT_SHIFT = 1 << 24,
+		INPUT_MASK = INPUT_SHIFT - 1,
+		INPUT_DEFAULT_VALUE_BIT = INPUT_SHIFT, // from unassigned input port, using default value (edited by user)
 	};
 
-
 	int id;
 	int sequence_index;
 	VisualScriptNodeInstance **sequence_outputs;
 	int sequence_output_count;
-	Vector<VisualScriptNodeInstance*> dependencies;
+	Vector<VisualScriptNodeInstance *> dependencies;
 	int *input_ports;
 	int input_port_count;
 	int *output_ports;
@@ -129,7 +128,6 @@ friend class VisualScriptLanguage; //for debugger
 	VisualScriptNode *base;
 
 public:
-
 	enum StartMode {
 		START_MODE_BEGIN_SEQUENCE,
 		START_MODE_CONTINUE_SEQUENCE,
@@ -137,44 +135,42 @@ public:
 	};
 
 	enum {
-		STEP_SHIFT=1<<24,
-		STEP_MASK=STEP_SHIFT-1,
-		STEP_FLAG_PUSH_STACK_BIT=STEP_SHIFT, //push bit to stack
-		STEP_FLAG_GO_BACK_BIT=STEP_SHIFT<<1, //go back to previous node
-		STEP_NO_ADVANCE_BIT=STEP_SHIFT<<2, //do not advance past this node
-		STEP_EXIT_FUNCTION_BIT=STEP_SHIFT<<3, //return from function
-		STEP_YIELD_BIT=STEP_SHIFT<<4, //yield (will find VisualScriptFunctionState state in first working memory)
+		STEP_SHIFT = 1 << 24,
+		STEP_MASK = STEP_SHIFT - 1,
+		STEP_FLAG_PUSH_STACK_BIT = STEP_SHIFT, //push bit to stack
+		STEP_FLAG_GO_BACK_BIT = STEP_SHIFT << 1, //go back to previous node
+		STEP_NO_ADVANCE_BIT = STEP_SHIFT << 2, //do not advance past this node
+		STEP_EXIT_FUNCTION_BIT = STEP_SHIFT << 3, //return from function
+		STEP_YIELD_BIT = STEP_SHIFT << 4, //yield (will find VisualScriptFunctionState state in first working memory)
 
-		FLOW_STACK_PUSHED_BIT=1<<30, //in flow stack, means bit was pushed (must go back here if end of sequence)
-		FLOW_STACK_MASK=FLOW_STACK_PUSHED_BIT-1
+		FLOW_STACK_PUSHED_BIT = 1 << 30, //in flow stack, means bit was pushed (must go back here if end of sequence)
+		FLOW_STACK_MASK = FLOW_STACK_PUSHED_BIT - 1
 
 	};
 
-	_FORCE_INLINE_ int  get_input_port_count() const { return input_port_count; }
-	_FORCE_INLINE_ int  get_output_port_count() const { return output_port_count; }
-	_FORCE_INLINE_ int  get_sequence_output_count() const { return sequence_output_count; }
+	_FORCE_INLINE_ int get_input_port_count() const { return input_port_count; }
+	_FORCE_INLINE_ int get_output_port_count() const { return output_port_count; }
+	_FORCE_INLINE_ int get_sequence_output_count() const { return sequence_output_count; }
 
-	_FORCE_INLINE_ int  get_id() const { return id; }
+	_FORCE_INLINE_ int get_id() const { return id; }
 
 	virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str)=0; //do a step, return which sequence port to go out
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) = 0; //do a step, return which sequence port to go out
 
-	Ref<VisualScriptNode> get_base_node() { return Ref<VisualScriptNode>( base ); }
+	Ref<VisualScriptNode> get_base_node() { return Ref<VisualScriptNode>(base); }
 
 	VisualScriptNodeInstance();
 	virtual ~VisualScriptNodeInstance();
 };
 
-
 class VisualScript : public Script {
 
-	GDCLASS( VisualScript, Script )
+	GDCLASS(VisualScript, Script)
 
 	RES_BASE_EXTENSION("vs");
 
 public:
-
 	struct SequenceConnection {
 
 		union {
@@ -187,9 +183,9 @@ public:
 			uint64_t id;
 		};
 
-		bool operator<(const SequenceConnection& p_connection) const {
+		bool operator<(const SequenceConnection &p_connection) const {
 
-			return id<p_connection.id;
+			return id < p_connection.id;
 		}
 	};
 
@@ -206,15 +202,14 @@ public:
 			uint64_t id;
 		};
 
-		bool operator<(const DataConnection& p_connection) const {
+		bool operator<(const DataConnection &p_connection) const {
 
-			return id<p_connection.id;
+			return id < p_connection.id;
 		}
 	};
 
-
 private:
-friend class VisualScriptInstance;
+	friend class VisualScriptInstance;
 
 	StringName base_type;
 	struct Argument {
@@ -228,7 +223,7 @@ friend class VisualScriptInstance;
 			Ref<VisualScriptNode> node;
 		};
 
-		Map<int,NodeData> nodes;
+		Map<int, NodeData> nodes;
 
 		Set<SequenceConnection> sequence_connections;
 
@@ -238,9 +233,7 @@ friend class VisualScriptInstance;
 
 		Vector2 scroll;
 
-
-		Function() { function_id=-1; }
-
+		Function() { function_id = -1; }
 	};
 
 	struct Variable {
@@ -249,109 +242,101 @@ friend class VisualScriptInstance;
 		bool _export;
 	};
 
+	Map<StringName, Function> functions;
+	Map<StringName, Variable> variables;
+	Map<StringName, Vector<Argument> > custom_signals;
 
-
-	Map<StringName,Function> functions;
-	Map<StringName,Variable> variables;
-	Map<StringName,Vector<Argument> > custom_signals;
-
-	Map<Object*,VisualScriptInstance*> instances;
+	Map<Object *, VisualScriptInstance *> instances;
 
 #ifdef TOOLS_ENABLED
-	Set<PlaceHolderScriptInstance*> placeholders;
+	Set<PlaceHolderScriptInstance *> placeholders;
 	//void _update_placeholder(PlaceHolderScriptInstance *p_placeholder);
 	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder);
 	void _update_placeholders();
 #endif
 
-	void _set_variable_info(const StringName& p_name,const Dictionary& p_info);
-	Dictionary _get_variable_info(const StringName& p_name) const;
-
+	void _set_variable_info(const StringName &p_name, const Dictionary &p_info);
+	Dictionary _get_variable_info(const StringName &p_name) const;
 
-	void _set_data(const Dictionary& p_data);
+	void _set_data(const Dictionary &p_data);
 	Dictionary _get_data() const;
 
 protected:
-
 	void _node_ports_changed(int p_id);
 	static void _bind_methods();
-public:
 
-
-	void add_function(const StringName& p_name);
-	bool has_function(const StringName& p_name) const;
-	void remove_function(const StringName& p_name);
-	void rename_function(const StringName& p_name,const StringName& p_new_name);
-	void set_function_scroll(const StringName& p_name, const Vector2& p_scroll);
-	Vector2 get_function_scroll(const StringName& p_name) const;
+public:
+	void add_function(const StringName &p_name);
+	bool has_function(const StringName &p_name) const;
+	void remove_function(const StringName &p_name);
+	void rename_function(const StringName &p_name, const StringName &p_new_name);
+	void set_function_scroll(const StringName &p_name, const Vector2 &p_scroll);
+	Vector2 get_function_scroll(const StringName &p_name) const;
 	void get_function_list(List<StringName> *r_functions) const;
-	int get_function_node_id(const StringName& p_name) const;
-
-
-	void add_node(const StringName& p_func,int p_id,const Ref<VisualScriptNode>& p_node,const Point2& p_pos=Point2());
-	void remove_node(const StringName& p_func,int p_id);
-	bool has_node(const StringName& p_func,int p_id) const;
-	Ref<VisualScriptNode> get_node(const StringName& p_func,int p_id) const;
-	void set_node_pos(const StringName& p_func,int p_id,const Point2& p_pos);
-	Point2 get_node_pos(const StringName& p_func,int p_id) const;
-	void get_node_list(const StringName& p_func,List<int> *r_nodes) const;
-
-	void sequence_connect(const StringName& p_func,int p_from_node,int p_from_output,int p_to_node);
-	void sequence_disconnect(const StringName& p_func,int p_from_node,int p_from_output,int p_to_node);
-	bool has_sequence_connection(const StringName& p_func,int p_from_node,int p_from_output,int p_to_node) const;
-	void get_sequence_connection_list(const StringName& p_func,List<SequenceConnection> *r_connection) const;
-
-	void data_connect(const StringName& p_func,int p_from_node,int p_from_port,int p_to_node,int p_to_port);
-	void data_disconnect(const StringName& p_func,int p_from_node,int p_from_port,int p_to_node,int p_to_port);
-	bool has_data_connection(const StringName& p_func,int p_from_node,int p_from_port,int p_to_node,int p_to_port) const;
-	void get_data_connection_list(const StringName& p_func,List<DataConnection> *r_connection) const;
-	bool is_input_value_port_connected(const StringName& p_name,int p_node,int p_port) const;
-	bool get_input_value_port_connection_source(const StringName& p_name,int p_node,int p_port,int *r_node,int *r_port) const;
-
-	void add_variable(const StringName& p_name,const Variant& p_default_value=Variant(),bool p_export=false);
-	bool has_variable(const StringName& p_name) const;
-	void remove_variable(const StringName& p_name);
-	void set_variable_default_value(const StringName& p_name,const Variant& p_value);
-	Variant get_variable_default_value(const StringName& p_name) const;
-	void set_variable_info(const StringName& p_name,const PropertyInfo& p_info);
-	PropertyInfo get_variable_info(const StringName& p_name) const;
-	void set_variable_export(const StringName& p_name,bool p_export);
-	bool get_variable_export(const StringName& p_name) const;
+	int get_function_node_id(const StringName &p_name) const;
+
+	void add_node(const StringName &p_func, int p_id, const Ref<VisualScriptNode> &p_node, const Point2 &p_pos = Point2());
+	void remove_node(const StringName &p_func, int p_id);
+	bool has_node(const StringName &p_func, int p_id) const;
+	Ref<VisualScriptNode> get_node(const StringName &p_func, int p_id) const;
+	void set_node_pos(const StringName &p_func, int p_id, const Point2 &p_pos);
+	Point2 get_node_pos(const StringName &p_func, int p_id) const;
+	void get_node_list(const StringName &p_func, List<int> *r_nodes) const;
+
+	void sequence_connect(const StringName &p_func, int p_from_node, int p_from_output, int p_to_node);
+	void sequence_disconnect(const StringName &p_func, int p_from_node, int p_from_output, int p_to_node);
+	bool has_sequence_connection(const StringName &p_func, int p_from_node, int p_from_output, int p_to_node) const;
+	void get_sequence_connection_list(const StringName &p_func, List<SequenceConnection> *r_connection) const;
+
+	void data_connect(const StringName &p_func, int p_from_node, int p_from_port, int p_to_node, int p_to_port);
+	void data_disconnect(const StringName &p_func, int p_from_node, int p_from_port, int p_to_node, int p_to_port);
+	bool has_data_connection(const StringName &p_func, int p_from_node, int p_from_port, int p_to_node, int p_to_port) const;
+	void get_data_connection_list(const StringName &p_func, List<DataConnection> *r_connection) const;
+	bool is_input_value_port_connected(const StringName &p_name, int p_node, int p_port) const;
+	bool get_input_value_port_connection_source(const StringName &p_name, int p_node, int p_port, int *r_node, int *r_port) const;
+
+	void add_variable(const StringName &p_name, const Variant &p_default_value = Variant(), bool p_export = false);
+	bool has_variable(const StringName &p_name) const;
+	void remove_variable(const StringName &p_name);
+	void set_variable_default_value(const StringName &p_name, const Variant &p_value);
+	Variant get_variable_default_value(const StringName &p_name) const;
+	void set_variable_info(const StringName &p_name, const PropertyInfo &p_info);
+	PropertyInfo get_variable_info(const StringName &p_name) const;
+	void set_variable_export(const StringName &p_name, bool p_export);
+	bool get_variable_export(const StringName &p_name) const;
 	void get_variable_list(List<StringName> *r_variables) const;
-	void rename_variable(const StringName& p_name,const StringName& p_new_name);
-
-
-	void add_custom_signal(const StringName& p_name);
-	bool has_custom_signal(const StringName& p_name) const;
-	void custom_signal_add_argument(const StringName& p_func,Variant::Type p_type,const String& p_name,int p_index=-1);
-	void custom_signal_set_argument_type(const StringName& p_func,int p_argidx,Variant::Type p_type);
-	Variant::Type custom_signal_get_argument_type(const StringName& p_func,int p_argidx) const;
-	void custom_signal_set_argument_name(const StringName& p_func,int p_argidx,const String& p_name);
-	String custom_signal_get_argument_name(const StringName& p_func,int p_argidx) const;
-	void custom_signal_remove_argument(const StringName& p_func,int p_argidx);
-	int custom_signal_get_argument_count(const StringName& p_func) const;
-	void custom_signal_swap_argument(const StringName& p_func,int p_argidx,int p_with_argidx);
-	void remove_custom_signal(const StringName& p_name);
-	void rename_custom_signal(const StringName& p_name,const StringName& p_new_name);
+	void rename_variable(const StringName &p_name, const StringName &p_new_name);
+
+	void add_custom_signal(const StringName &p_name);
+	bool has_custom_signal(const StringName &p_name) const;
+	void custom_signal_add_argument(const StringName &p_func, Variant::Type p_type, const String &p_name, int p_index = -1);
+	void custom_signal_set_argument_type(const StringName &p_func, int p_argidx, Variant::Type p_type);
+	Variant::Type custom_signal_get_argument_type(const StringName &p_func, int p_argidx) const;
+	void custom_signal_set_argument_name(const StringName &p_func, int p_argidx, const String &p_name);
+	String custom_signal_get_argument_name(const StringName &p_func, int p_argidx) const;
+	void custom_signal_remove_argument(const StringName &p_func, int p_argidx);
+	int custom_signal_get_argument_count(const StringName &p_func) const;
+	void custom_signal_swap_argument(const StringName &p_func, int p_argidx, int p_with_argidx);
+	void remove_custom_signal(const StringName &p_name);
+	void rename_custom_signal(const StringName &p_name, const StringName &p_new_name);
 
 	void get_custom_signal_list(List<StringName> *r_custom_signals) const;
 
 	int get_available_id() const;
 
-	void set_instance_base_type(const StringName& p_type);
+	void set_instance_base_type(const StringName &p_type);
 
 	virtual bool can_instance() const;
 
 	virtual Ref<Script> get_base_script() const;
 	virtual StringName get_instance_base_type() const;
-	virtual ScriptInstance* instance_create(Object *p_this);
+	virtual ScriptInstance *instance_create(Object *p_this);
 	virtual bool instance_has(const Object *p_this) const;
 
-
 	virtual bool has_source_code() const;
 	virtual String get_source_code() const;
-	virtual void set_source_code(const String& p_code);
-	virtual Error reload(bool p_keep_state=false);
+	virtual void set_source_code(const String &p_code);
+	virtual Error reload(bool p_keep_state = false);
 
 	virtual bool is_tool() const;
 
@@ -359,14 +344,14 @@ public:
 
 	virtual ScriptLanguage *get_language() const;
 
-	virtual bool has_script_signal(const StringName& p_signal) const;
+	virtual bool has_script_signal(const StringName &p_signal) const;
 	virtual void get_script_signal_list(List<MethodInfo> *r_signals) const;
 
-	virtual bool get_property_default_value(const StringName& p_property,Variant& r_value) const;
+	virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const;
 	virtual void get_script_method_list(List<MethodInfo> *p_list) const;
 
-	virtual bool has_method(const StringName& p_method) const;
-	virtual MethodInfo get_method_info(const StringName& p_method) const;
+	virtual bool has_method(const StringName &p_method) const;
+	virtual MethodInfo get_method_info(const StringName &p_method) const;
 
 	virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
 
@@ -378,13 +363,12 @@ public:
 	~VisualScript();
 };
 
-
 class VisualScriptInstance : public ScriptInstance {
 	Object *owner;
 	Ref<VisualScript> script;
 
-	Map<StringName,Variant> variables; //using variable path, not script
-	Map<int,VisualScriptNodeInstance*> instances;
+	Map<StringName, Variant> variables; //using variable path, not script
+	Map<int, VisualScriptNodeInstance *> instances;
 
 	struct Function {
 		int node;
@@ -398,50 +382,48 @@ class VisualScriptInstance : public ScriptInstance {
 		bool valid;
 	};
 
-	Map<StringName,Function> functions;
+	Map<StringName, Function> functions;
 
 	Vector<Variant> default_values;
-	int max_input_args,max_output_args;
+	int max_input_args, max_output_args;
 
 	StringName source;
 
-	void _dependency_step(VisualScriptNodeInstance* node, int p_pass, int *pass_stack, const Variant **input_args, Variant **output_args, Variant *variant_stack, Variant::CallError& r_error, String& error_str, VisualScriptNodeInstance **r_error_node);
-	Variant _call_internal(const StringName& p_method, void* p_stack,int p_stack_size, VisualScriptNodeInstance* p_node, int p_flow_stack_pos, int p_pass, bool p_resuming_yield,Variant::CallError &r_error);
-
+	void _dependency_step(VisualScriptNodeInstance *node, int p_pass, int *pass_stack, const Variant **input_args, Variant **output_args, Variant *variant_stack, Variant::CallError &r_error, String &error_str, VisualScriptNodeInstance **r_error_node);
+	Variant _call_internal(const StringName &p_method, void *p_stack, int p_stack_size, VisualScriptNodeInstance *p_node, int p_flow_stack_pos, int p_pass, bool p_resuming_yield, Variant::CallError &r_error);
 
 	//Map<StringName,Function> functions;
-friend class VisualScriptFunctionState; //for yield
-friend class VisualScriptLanguage; //for debugger
+	friend class VisualScriptFunctionState; //for yield
+	friend class VisualScriptLanguage; //for debugger
 public:
-	virtual bool set(const StringName& p_name, const Variant& p_value);
-	virtual bool get(const StringName& p_name, Variant &r_ret) const;
+	virtual bool set(const StringName &p_name, const Variant &p_value);
+	virtual bool get(const StringName &p_name, Variant &r_ret) const;
 	virtual void get_property_list(List<PropertyInfo> *p_properties) const;
-	virtual Variant::Type get_property_type(const StringName& p_name,bool *r_is_valid=NULL) const;
+	virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = NULL) const;
 
 	virtual void get_method_list(List<MethodInfo> *p_list) const;
-	virtual bool has_method(const StringName& p_method) const;
-	virtual Variant call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error);
+	virtual bool has_method(const StringName &p_method) const;
+	virtual Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error);
 	virtual void notification(int p_notification);
 
-	bool set_variable(const StringName& p_variable,const Variant& p_value) {
+	bool set_variable(const StringName &p_variable, const Variant &p_value) {
 
-		Map<StringName,Variant>::Element *E=variables.find(p_variable);
+		Map<StringName, Variant>::Element *E = variables.find(p_variable);
 		if (!E)
 			return false;
 
-		E->get()=p_value;
+		E->get() = p_value;
 		return true;
 	}
 
-	bool get_variable(const StringName& p_variable,Variant* r_variable) const {
+	bool get_variable(const StringName &p_variable, Variant *r_variable) const {
 
-		const Map<StringName,Variant>::Element *E=variables.find(p_variable);
+		const Map<StringName, Variant>::Element *E = variables.find(p_variable);
 		if (!E)
 			return false;
 
-		*r_variable=E->get();
+		*r_variable = E->get();
 		return true;
-
 	}
 
 	virtual Ref<Script> get_script() const;
@@ -449,22 +431,21 @@ public:
 	_FORCE_INLINE_ VisualScript *get_script_ptr() { return script.ptr(); }
 	_FORCE_INLINE_ Object *get_owner_ptr() { return owner; }
 
-	void create(const Ref<VisualScript>& p_script,Object *p_owner);
+	void create(const Ref<VisualScript> &p_script, Object *p_owner);
 
 	virtual ScriptLanguage *get_language();
 
-	virtual RPCMode get_rpc_mode(const StringName& p_method) const;
-	virtual RPCMode get_rset_mode(const StringName& p_variable) const;
+	virtual RPCMode get_rpc_mode(const StringName &p_method) const;
+	virtual RPCMode get_rset_mode(const StringName &p_variable) const;
 
 	VisualScriptInstance();
 	~VisualScriptInstance();
 };
 
-
 class VisualScriptFunctionState : public Reference {
 
-	GDCLASS(VisualScriptFunctionState,Reference);
-friend class VisualScriptInstance;
+	GDCLASS(VisualScriptFunctionState, Reference);
+	friend class VisualScriptInstance;
 
 	ObjectID instance_id;
 	ObjectID script_id;
@@ -477,36 +458,34 @@ friend class VisualScriptInstance;
 	int flow_stack_pos;
 	int pass;
 
-	Variant _signal_callback(const Variant** p_args, int p_argcount, Variant::CallError& r_error);
+	Variant _signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+
 protected:
 	static void _bind_methods();
-public:
 
-	void connect_to_signal(Object* p_obj,const String& p_signal,Array p_binds);
+public:
+	void connect_to_signal(Object *p_obj, const String &p_signal, Array p_binds);
 	bool is_valid() const;
 	Variant resume(Array p_args);
 	VisualScriptFunctionState();
 	~VisualScriptFunctionState();
 };
 
-
-typedef Ref<VisualScriptNode> (*VisualScriptNodeRegisterFunc)(const String& p_type);
+typedef Ref<VisualScriptNode> (*VisualScriptNodeRegisterFunc)(const String &p_type);
 
 class VisualScriptLanguage : public ScriptLanguage {
 
-	Map<String,VisualScriptNodeRegisterFunc> register_funcs;
+	Map<String, VisualScriptNodeRegisterFunc> register_funcs;
 
 	struct CallLevel {
 
-	    Variant *stack;
-	    Variant **work_mem;
-	    const StringName *function;
-	    VisualScriptInstance *instance;
-	    int *current_id;
-
+		Variant *stack;
+		Variant **work_mem;
+		const StringName *function;
+		VisualScriptInstance *instance;
+		int *current_id;
 	};
 
-
 	int _debug_parse_err_node;
 	String _debug_parse_err_file;
 	String _debug_error;
@@ -520,52 +499,52 @@ public:
 	StringName _step;
 	StringName _subcall;
 
-	static VisualScriptLanguage* singleton;
+	static VisualScriptLanguage *singleton;
 
 	Mutex *lock;
 
-	bool debug_break(const String& p_error,bool p_allow_continue=true);
-	bool debug_break_parse(const String& p_file, int p_node,const String& p_error);
+	bool debug_break(const String &p_error, bool p_allow_continue = true);
+	bool debug_break_parse(const String &p_file, int p_node, const String &p_error);
 
-	_FORCE_INLINE_ void enter_function(VisualScriptInstance *p_instance,const StringName* p_function, Variant *p_stack, Variant **p_work_mem,int *current_id) {
+	_FORCE_INLINE_ void enter_function(VisualScriptInstance *p_instance, const StringName *p_function, Variant *p_stack, Variant **p_work_mem, int *current_id) {
 
-	    if (Thread::get_main_ID()!=Thread::get_caller_ID())
-		return; //no support for other threads than main for now
+		if (Thread::get_main_ID() != Thread::get_caller_ID())
+			return; //no support for other threads than main for now
 
-	    if (ScriptDebugger::get_singleton()->get_lines_left()>0 && ScriptDebugger::get_singleton()->get_depth()>=0)
-		ScriptDebugger::get_singleton()->set_depth( ScriptDebugger::get_singleton()->get_depth() +1 );
+		if (ScriptDebugger::get_singleton()->get_lines_left() > 0 && ScriptDebugger::get_singleton()->get_depth() >= 0)
+			ScriptDebugger::get_singleton()->set_depth(ScriptDebugger::get_singleton()->get_depth() + 1);
 
-	    if (_debug_call_stack_pos >= _debug_max_call_stack) {
-		//stack overflow
-		_debug_error="Stack Overflow (Stack Size: "+itos(_debug_max_call_stack)+")";
-		ScriptDebugger::get_singleton()->debug(this);
-		return;
-	    }
+		if (_debug_call_stack_pos >= _debug_max_call_stack) {
+			//stack overflow
+			_debug_error = "Stack Overflow (Stack Size: " + itos(_debug_max_call_stack) + ")";
+			ScriptDebugger::get_singleton()->debug(this);
+			return;
+		}
 
-	    _call_stack[_debug_call_stack_pos].stack=p_stack;
-	    _call_stack[_debug_call_stack_pos].instance=p_instance;
-	    _call_stack[_debug_call_stack_pos].function=p_function;
-	    _call_stack[_debug_call_stack_pos].work_mem=p_work_mem;
-	    _call_stack[_debug_call_stack_pos].current_id=current_id;
-	    _debug_call_stack_pos++;
+		_call_stack[_debug_call_stack_pos].stack = p_stack;
+		_call_stack[_debug_call_stack_pos].instance = p_instance;
+		_call_stack[_debug_call_stack_pos].function = p_function;
+		_call_stack[_debug_call_stack_pos].work_mem = p_work_mem;
+		_call_stack[_debug_call_stack_pos].current_id = current_id;
+		_debug_call_stack_pos++;
 	}
 
 	_FORCE_INLINE_ void exit_function() {
 
-	    if (Thread::get_main_ID()!=Thread::get_caller_ID())
-		return; //no support for other threads than main for now
+		if (Thread::get_main_ID() != Thread::get_caller_ID())
+			return; //no support for other threads than main for now
 
-	    if (ScriptDebugger::get_singleton()->get_lines_left()>0 && ScriptDebugger::get_singleton()->get_depth()>=0)
-		ScriptDebugger::get_singleton()->set_depth( ScriptDebugger::get_singleton()->get_depth() -1 );
+		if (ScriptDebugger::get_singleton()->get_lines_left() > 0 && ScriptDebugger::get_singleton()->get_depth() >= 0)
+			ScriptDebugger::get_singleton()->set_depth(ScriptDebugger::get_singleton()->get_depth() - 1);
 
-	    if (_debug_call_stack_pos==0) {
+		if (_debug_call_stack_pos == 0) {
 
-		_debug_error="Stack Underflow (Engine Bug)";
-		ScriptDebugger::get_singleton()->debug(this);
-		return;
-	    }
+			_debug_error = "Stack Underflow (Engine Bug)";
+			ScriptDebugger::get_singleton()->debug(this);
+			return;
+		}
 
-	    _debug_call_stack_pos--;
+		_debug_call_stack_pos--;
 	}
 
 	//////////////////////////////////////
@@ -576,22 +555,21 @@ public:
 	virtual void init();
 	virtual String get_type() const;
 	virtual String get_extension() const;
-	virtual Error execute_file(const String& p_path) ;
+	virtual Error execute_file(const String &p_path);
 	virtual void finish();
 
 	/* EDITOR FUNCTIONS */
 	virtual void get_reserved_words(List<String> *p_words) const;
 	virtual void get_comment_delimiters(List<String> *p_delimiters) const;
 	virtual void get_string_delimiters(List<String> *p_delimiters) const;
-	virtual Ref<Script> get_template(const String& p_class_name, const String& p_base_class_name) const;
-	virtual bool 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=NULL) const;
+	virtual Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const;
+	virtual bool 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 = NULL) const;
 	virtual Script *create_script() const;
 	virtual bool has_named_classes() const;
-	virtual int find_function(const String& p_function,const String& p_code) const;
-	virtual String make_function(const String& p_class,const String& p_name,const PoolStringArray& p_args) const;
-	virtual void auto_indent_code(String& p_code,int p_from_line,int p_to_line) const;
-	virtual void add_global_constant(const StringName& p_variable,const Variant& p_value);
-
+	virtual int find_function(const String &p_function, const String &p_code) const;
+	virtual String make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const;
+	virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const;
+	virtual void add_global_constant(const StringName &p_variable, const Variant &p_value);
 
 	/* DEBUGGER FUNCTIONS */
 
@@ -600,45 +578,40 @@ public:
 	virtual int debug_get_stack_level_line(int p_level) const;
 	virtual String debug_get_stack_level_function(int p_level) const;
 	virtual String debug_get_stack_level_source(int p_level) const;
-	virtual void debug_get_stack_level_locals(int p_level,List<String> *p_locals, List<Variant> *p_values, int p_max_subitems=-1,int p_max_depth=-1);
-	virtual void debug_get_stack_level_members(int p_level,List<String> *p_members, List<Variant> *p_values, int p_max_subitems=-1,int p_max_depth=-1);
-	virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems=-1,int p_max_depth=-1);
-	virtual String debug_parse_stack_level_expression(int p_level,const String& p_expression,int p_max_subitems=-1,int p_max_depth=-1);
-
+	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
+	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
+	virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
+	virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems = -1, int p_max_depth = -1);
 
 	virtual void reload_all_scripts();
-	virtual void reload_tool_script(const Ref<Script>& p_script,bool p_soft_reload);
+	virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload);
 	/* LOADER FUNCTIONS */
 
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual void get_public_functions(List<MethodInfo> *p_functions) const;
-	virtual void get_public_constants(List<Pair<String,Variant> > *p_constants) const;
+	virtual void get_public_constants(List<Pair<String, Variant> > *p_constants) const;
 
 	virtual void profiling_start();
 	virtual void profiling_stop();
 
-	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr,int p_info_max);
-	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr,int p_info_max);
+	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max);
+	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max);
 
-	void add_register_func(const String& p_name,VisualScriptNodeRegisterFunc p_func);
-	Ref<VisualScriptNode> create_node_from_name(const String& p_name);
+	void add_register_func(const String &p_name, VisualScriptNodeRegisterFunc p_func);
+	Ref<VisualScriptNode> create_node_from_name(const String &p_name);
 	void get_registered_node_names(List<String> *r_names);
 
-
 	VisualScriptLanguage();
 	~VisualScriptLanguage();
-
 };
 
 //aid for registering
-template<class T>
-static Ref<VisualScriptNode> create_node_generic(const String& p_name) {
+template <class T>
+static Ref<VisualScriptNode> create_node_generic(const String &p_name) {
 
 	Ref<T> node;
 	node.instance();
 	return node;
 }
 
-
-
 #endif // VSCRIPT_H
diff --git a/modules/visual_script/visual_script_builtin_funcs.cpp b/modules/visual_script/visual_script_builtin_funcs.cpp
index e83cd3e614..378ca06f90 100644
--- a/modules/visual_script/visual_script_builtin_funcs.cpp
+++ b/modules/visual_script/visual_script_builtin_funcs.cpp
@@ -28,15 +28,15 @@
 /*************************************************************************/
 #include "visual_script_builtin_funcs.h"
 
-#include "math_funcs.h"
 #include "class_db.h"
-#include "reference.h"
 #include "func_ref.h"
+#include "io/marshalls.h"
+#include "math_funcs.h"
 #include "os/os.h"
+#include "reference.h"
 #include "variant_parser.h"
-#include "io/marshalls.h"
 
-const char* VisualScriptBuiltinFunc::func_name[VisualScriptBuiltinFunc::FUNC_MAX]={
+const char *VisualScriptBuiltinFunc::func_name[VisualScriptBuiltinFunc::FUNC_MAX] = {
 	"sin",
 	"cos",
 	"tan",
@@ -96,10 +96,10 @@ const char* VisualScriptBuiltinFunc::func_name[VisualScriptBuiltinFunc::FUNC_MAX
 	"color_named",
 };
 
-VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::find_function(const String& p_string) {
+VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::find_function(const String &p_string) {
 
-	for(int i=0;i<FUNC_MAX;i++) {
-		if (p_string==func_name[i])
+	for (int i = 0; i < FUNC_MAX; i++) {
+		if (p_string == func_name[i])
 			return BuiltinFunc(i);
 	}
 
@@ -108,19 +108,18 @@ VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::find_function(cons
 
 String VisualScriptBuiltinFunc::get_func_name(BuiltinFunc p_func) {
 
-	ERR_FAIL_INDEX_V(p_func,FUNC_MAX,String());
+	ERR_FAIL_INDEX_V(p_func, FUNC_MAX, String());
 	return func_name[p_func];
 }
 
-
 int VisualScriptBuiltinFunc::get_output_sequence_port_count() const {
 
 	return has_input_sequence_port() ? 1 : 0;
 }
 
-bool VisualScriptBuiltinFunc::has_input_sequence_port() const{
+bool VisualScriptBuiltinFunc::has_input_sequence_port() const {
 
-	switch(func) {
+	switch (func) {
 
 		case MATH_RANDOMIZE:
 		case TEXT_PRINT:
@@ -129,15 +128,12 @@ bool VisualScriptBuiltinFunc::has_input_sequence_port() const{
 			return true;
 		default:
 			return false;
-
 	}
-
 }
 
 int VisualScriptBuiltinFunc::get_func_argument_count(BuiltinFunc p_func) {
 
-
-	switch(p_func) {
+	switch (p_func) {
 
 		case MATH_RANDOMIZE:
 		case MATH_RAND:
@@ -200,19 +196,19 @@ int VisualScriptBuiltinFunc::get_func_argument_count(BuiltinFunc p_func) {
 		case MATH_DECTIME:
 		case LOGIC_CLAMP:
 			return 3;
-		case FUNC_MAX:{}
-
+		case FUNC_MAX: {
+		}
 	}
 	return 0;
 }
 
-int VisualScriptBuiltinFunc::get_input_value_port_count() const{
+int VisualScriptBuiltinFunc::get_input_value_port_count() const {
 
 	return get_func_argument_count(func);
 }
-int VisualScriptBuiltinFunc::get_output_value_port_count() const{
+int VisualScriptBuiltinFunc::get_output_value_port_count() const {
 
-	switch(func) {
+	switch (func) {
 		case MATH_RANDOMIZE:
 		case TEXT_PRINT:
 		case TEXT_PRINTERR:
@@ -233,9 +229,9 @@ String VisualScriptBuiltinFunc::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const {
 
-	switch(func) {
+	switch (func) {
 
 		case MATH_SIN:
 		case MATH_COS:
@@ -248,67 +244,67 @@ PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const
 		case MATH_ATAN:
 		case MATH_ATAN2:
 		case MATH_SQRT: {
-			return PropertyInfo(Variant::REAL,"num");
+			return PropertyInfo(Variant::REAL, "num");
 		} break;
 		case MATH_FMOD:
 		case MATH_FPOSMOD: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"x");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "x");
 			else
-				return PropertyInfo(Variant::REAL,"y");
+				return PropertyInfo(Variant::REAL, "y");
 		} break;
 		case MATH_FLOOR:
 		case MATH_CEIL:
 		case MATH_ROUND:
 		case MATH_ABS:
 		case MATH_SIGN: {
-			return PropertyInfo(Variant::REAL,"num");
+			return PropertyInfo(Variant::REAL, "num");
 
 		} break;
 
 		case MATH_POW: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"x");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "x");
 			else
-				return PropertyInfo(Variant::REAL,"y");
+				return PropertyInfo(Variant::REAL, "y");
 		} break;
 		case MATH_LOG:
 		case MATH_EXP:
 		case MATH_ISNAN:
 		case MATH_ISINF: {
-			return PropertyInfo(Variant::REAL,"num");
+			return PropertyInfo(Variant::REAL, "num");
 		} break;
 		case MATH_EASE: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"s");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "s");
 			else
-				return PropertyInfo(Variant::REAL,"curve");
+				return PropertyInfo(Variant::REAL, "curve");
 		} break;
 		case MATH_DECIMALS: {
-			return PropertyInfo(Variant::REAL,"step");
+			return PropertyInfo(Variant::REAL, "step");
 		} break;
 		case MATH_STEPIFY: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"s");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "s");
 			else
-				return PropertyInfo(Variant::REAL,"steps");
+				return PropertyInfo(Variant::REAL, "steps");
 		} break;
 		case MATH_LERP: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"from");
-			else if (p_idx==1)
-				return PropertyInfo(Variant::REAL,"to");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "from");
+			else if (p_idx == 1)
+				return PropertyInfo(Variant::REAL, "to");
 			else
-				return PropertyInfo(Variant::REAL,"weight");
+				return PropertyInfo(Variant::REAL, "weight");
 
 		} break;
 		case MATH_DECTIME: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"value");
-			else if (p_idx==1)
-				return PropertyInfo(Variant::REAL,"amount");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "value");
+			else if (p_idx == 1)
+				return PropertyInfo(Variant::REAL, "amount");
 			else
-				return PropertyInfo(Variant::REAL,"step");
+				return PropertyInfo(Variant::REAL, "step");
 		} break;
 		case MATH_RANDOMIZE: {
 
@@ -320,139 +316,140 @@ PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const
 
 		} break;
 		case MATH_RANDOM: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"from");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "from");
 			else
-				return PropertyInfo(Variant::REAL,"to");
+				return PropertyInfo(Variant::REAL, "to");
 		} break;
 		case MATH_SEED: {
-			return PropertyInfo(Variant::INT,"seed");
+			return PropertyInfo(Variant::INT, "seed");
 		} break;
 		case MATH_RANDSEED: {
-			return PropertyInfo(Variant::INT,"seed");
+			return PropertyInfo(Variant::INT, "seed");
 		} break;
 		case MATH_DEG2RAD: {
-			return PropertyInfo(Variant::REAL,"deg");
+			return PropertyInfo(Variant::REAL, "deg");
 		} break;
 		case MATH_RAD2DEG: {
-			return PropertyInfo(Variant::REAL,"rad");
+			return PropertyInfo(Variant::REAL, "rad");
 		} break;
 		case MATH_LINEAR2DB: {
-			return PropertyInfo(Variant::REAL,"nrg");
+			return PropertyInfo(Variant::REAL, "nrg");
 		} break;
 		case MATH_DB2LINEAR: {
-			return PropertyInfo(Variant::REAL,"db");
+			return PropertyInfo(Variant::REAL, "db");
 		} break;
 		case LOGIC_MAX: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"a");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "a");
 			else
-				return PropertyInfo(Variant::REAL,"b");
+				return PropertyInfo(Variant::REAL, "b");
 		} break;
 		case LOGIC_MIN: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"a");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "a");
 			else
-				return PropertyInfo(Variant::REAL,"b");
+				return PropertyInfo(Variant::REAL, "b");
 		} break;
 		case LOGIC_CLAMP: {
-			if (p_idx==0)
-				return PropertyInfo(Variant::REAL,"a");
-			else if (p_idx==0)	// FIXME: is it ok to test p_idx == 0 twice?
-				return PropertyInfo(Variant::REAL,"min");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "a");
+			else if (p_idx == 0) // FIXME: is it ok to test p_idx == 0 twice?
+				return PropertyInfo(Variant::REAL, "min");
 			else
-				return PropertyInfo(Variant::REAL,"max");
+				return PropertyInfo(Variant::REAL, "max");
 		} break;
 		case LOGIC_NEAREST_PO2: {
-			return PropertyInfo(Variant::INT,"num");
+			return PropertyInfo(Variant::INT, "num");
 		} break;
 		case OBJ_WEAKREF: {
 
-			return PropertyInfo(Variant::OBJECT,"source");
+			return PropertyInfo(Variant::OBJECT, "source");
 
 		} break;
 		case FUNC_FUNCREF: {
 
-			if (p_idx==0)
-				return PropertyInfo(Variant::OBJECT,"instance");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::OBJECT, "instance");
 			else
-				return PropertyInfo(Variant::STRING,"funcname");
+				return PropertyInfo(Variant::STRING, "funcname");
 
 		} break;
 		case TYPE_CONVERT: {
 
-			if (p_idx==0)
-				return PropertyInfo(Variant::NIL,"what");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::NIL, "what");
 			else
-				return PropertyInfo(Variant::STRING,"type");
+				return PropertyInfo(Variant::STRING, "type");
 		} break;
 		case TYPE_OF: {
-			return PropertyInfo(Variant::NIL,"what");
+			return PropertyInfo(Variant::NIL, "what");
 
 		} break;
 		case TYPE_EXISTS: {
 
-			return PropertyInfo(Variant::STRING,"type");
+			return PropertyInfo(Variant::STRING, "type");
 
 		} break;
 		case TEXT_CHAR: {
 
-			return PropertyInfo(Variant::INT,"ascii");
+			return PropertyInfo(Variant::INT, "ascii");
 
 		} break;
 		case TEXT_STR: {
 
-			return PropertyInfo(Variant::NIL,"value");
+			return PropertyInfo(Variant::NIL, "value");
 
 		} break;
 		case TEXT_PRINT: {
 
-			return PropertyInfo(Variant::NIL,"value");
+			return PropertyInfo(Variant::NIL, "value");
 
 		} break;
 		case TEXT_PRINTERR: {
-			return PropertyInfo(Variant::NIL,"value");
+			return PropertyInfo(Variant::NIL, "value");
 
 		} break;
 		case TEXT_PRINTRAW: {
 
-			return PropertyInfo(Variant::NIL,"value");
+			return PropertyInfo(Variant::NIL, "value");
 
 		} break;
 		case VAR_TO_STR: {
-			return PropertyInfo(Variant::NIL,"var");
+			return PropertyInfo(Variant::NIL, "var");
 
 		} break;
 		case STR_TO_VAR: {
 
-			return PropertyInfo(Variant::STRING,"string");
+			return PropertyInfo(Variant::STRING, "string");
 		} break;
 		case VAR_TO_BYTES: {
-			return PropertyInfo(Variant::NIL,"var");
+			return PropertyInfo(Variant::NIL, "var");
 
 		} break;
 		case BYTES_TO_VAR: {
 
-			return PropertyInfo(Variant::POOL_BYTE_ARRAY,"bytes");
+			return PropertyInfo(Variant::POOL_BYTE_ARRAY, "bytes");
 		} break;
 		case COLORN: {
 
-			if (p_idx==0)
-				return PropertyInfo(Variant::STRING,"name");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::STRING, "name");
 			else
-				return PropertyInfo(Variant::REAL,"alpha");
+				return PropertyInfo(Variant::REAL, "alpha");
 
 		} break;
-		case FUNC_MAX:{}
+		case FUNC_MAX: {
+		}
 	}
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) const {
 
-	Variant::Type t=Variant::NIL;
-	switch(func) {
+	Variant::Type t = Variant::NIL;
+	switch (func) {
 
 		case MATH_SIN:
 		case MATH_COS:
@@ -469,36 +466,36 @@ PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) cons
 		case MATH_FPOSMOD:
 		case MATH_FLOOR:
 		case MATH_CEIL: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case MATH_ROUND: {
-			t=Variant::INT;
+			t = Variant::INT;
 		} break;
 		case MATH_ABS: {
-			t=Variant::NIL;
+			t = Variant::NIL;
 		} break;
 		case MATH_SIGN: {
-			t=Variant::NIL;
+			t = Variant::NIL;
 		} break;
 		case MATH_POW:
 		case MATH_LOG:
 		case MATH_EXP: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case MATH_ISNAN:
 		case MATH_ISINF: {
-			t=Variant::BOOL;
+			t = Variant::BOOL;
 		} break;
 		case MATH_EASE: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case MATH_DECIMALS: {
-			t=Variant::INT;
+			t = Variant::INT;
 		} break;
 		case MATH_STEPIFY:
 		case MATH_LERP:
 		case MATH_DECTIME: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 
 		} break;
 		case MATH_RANDOMIZE: {
@@ -506,71 +503,67 @@ PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) cons
 		} break;
 		case MATH_RAND: {
 
-			t=Variant::INT;
+			t = Variant::INT;
 		} break;
 		case MATH_RANDF:
 		case MATH_RANDOM: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case MATH_SEED: {
 
 		} break;
 		case MATH_RANDSEED: {
 
-			if (p_idx==0)
-				return PropertyInfo(Variant::INT,"rnd");
+			if (p_idx == 0)
+				return PropertyInfo(Variant::INT, "rnd");
 			else
-				return PropertyInfo(Variant::INT,"seed");
+				return PropertyInfo(Variant::INT, "seed");
 		} break;
 		case MATH_DEG2RAD:
 		case MATH_RAD2DEG:
 		case MATH_LINEAR2DB:
 		case MATH_DB2LINEAR: {
-			t=Variant::REAL;
+			t = Variant::REAL;
 		} break;
 		case LOGIC_MAX:
 		case LOGIC_MIN:
 		case LOGIC_CLAMP: {
 
-
 		} break;
 
 		case LOGIC_NEAREST_PO2: {
-			t=Variant::NIL;
+			t = Variant::NIL;
 		} break;
 		case OBJ_WEAKREF: {
 
-			t=Variant::OBJECT;
+			t = Variant::OBJECT;
 
 		} break;
 		case FUNC_FUNCREF: {
 
-			t=Variant::OBJECT;
+			t = Variant::OBJECT;
 
 		} break;
 		case TYPE_CONVERT: {
 
-
-
 		} break;
 		case TYPE_OF: {
-			t=Variant::INT;
+			t = Variant::INT;
 
 		} break;
 		case TYPE_EXISTS: {
 
-			t=Variant::BOOL;
+			t = Variant::BOOL;
 
 		} break;
 		case TEXT_CHAR:
 		case TEXT_STR: {
 
-			t=Variant::STRING;
+			t = Variant::STRING;
 
 		} break;
 		case TEXT_PRINT: {
 
-
 		} break;
 		case TEXT_PRINTERR: {
 
@@ -579,26 +572,26 @@ PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) cons
 
 		} break;
 		case VAR_TO_STR: {
-			t=Variant::STRING;
+			t = Variant::STRING;
 		} break;
 		case STR_TO_VAR: {
 
 		} break;
 		case VAR_TO_BYTES: {
-			t=Variant::POOL_BYTE_ARRAY;
+			t = Variant::POOL_BYTE_ARRAY;
 
 		} break;
 		case BYTES_TO_VAR: {
 
-
 		} break;
 		case COLORN: {
-			t=Variant::COLOR;
+			t = Variant::COLOR;
 		} break;
-		case FUNC_MAX:{}
+		case FUNC_MAX: {
+		}
 	}
 
-	return PropertyInfo(t,"");
+	return PropertyInfo(t, "");
 }
 
 String VisualScriptBuiltinFunc::get_caption() const {
@@ -613,8 +606,8 @@ String VisualScriptBuiltinFunc::get_text() const {
 
 void VisualScriptBuiltinFunc::set_func(BuiltinFunc p_which) {
 
-	ERR_FAIL_INDEX(p_which,FUNC_MAX);
-	func=p_which;
+	ERR_FAIL_INDEX(p_which, FUNC_MAX);
+	func = p_which;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -623,256 +616,252 @@ VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::get_func() {
 	return func;
 }
 
-
-#define VALIDATE_ARG_NUM(m_arg) \
-	if (!p_inputs[m_arg]->is_num()) {\
-		r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;\
-		r_error.argument=m_arg;\
-		r_error.expected=Variant::REAL;\
-		return;\
+#define VALIDATE_ARG_NUM(m_arg)                                          \
+	if (!p_inputs[m_arg]->is_num()) {                                    \
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; \
+		r_error.argument = m_arg;                                        \
+		r_error.expected = Variant::REAL;                                \
+		return;                                                          \
 	}
 
+void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant *r_return, Variant::CallError &r_error, String &r_error_str) {
 
-void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inputs,Variant* r_return,Variant::CallError& r_error,String& r_error_str) {
-
-	switch(p_func) {
+	switch (p_func) {
 		case VisualScriptBuiltinFunc::MATH_SIN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::sin((double)*p_inputs[0]);
+			*r_return = Math::sin((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_COS: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::cos((double)*p_inputs[0]);
+			*r_return = Math::cos((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_TAN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::tan((double)*p_inputs[0]);
+			*r_return = Math::tan((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_SINH: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::sinh((double)*p_inputs[0]);
+			*r_return = Math::sinh((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_COSH: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::cosh((double)*p_inputs[0]);
+			*r_return = Math::cosh((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_TANH: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::tanh((double)*p_inputs[0]);
+			*r_return = Math::tanh((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ASIN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::asin((double)*p_inputs[0]);
+			*r_return = Math::asin((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ACOS: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::acos((double)*p_inputs[0]);
+			*r_return = Math::acos((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ATAN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::atan((double)*p_inputs[0]);
+			*r_return = Math::atan((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ATAN2: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::atan2((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::atan2((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_SQRT: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::sqrt((double)*p_inputs[0]);
+			*r_return = Math::sqrt((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_FMOD: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::fmod((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::fmod((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_FPOSMOD: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::fposmod((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::fposmod((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_FLOOR: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::floor((double)*p_inputs[0]);
-		  } break;
+			*r_return = Math::floor((double)*p_inputs[0]);
+		} break;
 		case VisualScriptBuiltinFunc::MATH_CEIL: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::ceil((double)*p_inputs[0]);
+			*r_return = Math::ceil((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ROUND: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::round((double)*p_inputs[0]);
+			*r_return = Math::round((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ABS: {
 
-			if (p_inputs[0]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT) {
 
 				int64_t i = *p_inputs[0];
-				*r_return=ABS(i);
-			} else if (p_inputs[0]->get_type()==Variant::REAL) {
+				*r_return = ABS(i);
+			} else if (p_inputs[0]->get_type() == Variant::REAL) {
 
 				real_t r = *p_inputs[0];
-				*r_return=Math::abs(r);
+				*r_return = Math::abs(r);
 			} else {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::REAL;
-
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::REAL;
 			}
 		} break;
 		case VisualScriptBuiltinFunc::MATH_SIGN: {
 
-				if (p_inputs[0]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT) {
 
-					int64_t i = *p_inputs[0];
-					*r_return= i < 0 ? -1 : ( i > 0 ? +1 : 0);
-				} else if (p_inputs[0]->get_type()==Variant::REAL) {
-
-					real_t r = *p_inputs[0];
-					*r_return= r < 0.0 ? -1.0 : ( r > 0.0 ? +1.0 : 0.0);
-				} else {
+				int64_t i = *p_inputs[0];
+				*r_return = i < 0 ? -1 : (i > 0 ? +1 : 0);
+			} else if (p_inputs[0]->get_type() == Variant::REAL) {
 
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-					r_error.argument=0;
-					r_error.expected=Variant::REAL;
+				real_t r = *p_inputs[0];
+				*r_return = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
+			} else {
 
-				}
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::REAL;
+			}
 		} break;
 		case VisualScriptBuiltinFunc::MATH_POW: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::pow((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::pow((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_LOG: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::log((double)*p_inputs[0]);
+			*r_return = Math::log((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_EXP: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::exp((double)*p_inputs[0]);
+			*r_return = Math::exp((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ISNAN: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::is_nan((double)*p_inputs[0]);
+			*r_return = Math::is_nan((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_ISINF: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::is_inf((double)*p_inputs[0]);
+			*r_return = Math::is_inf((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_EASE: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::ease((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::ease((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_DECIMALS: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::step_decimals((double)*p_inputs[0]);
+			*r_return = Math::step_decimals((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_STEPIFY: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::stepify((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::stepify((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_LERP: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
-			*r_return=Math::lerp((double)*p_inputs[0],(double)*p_inputs[1],(double)*p_inputs[2]);
+			*r_return = Math::lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_DECTIME: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
 			VALIDATE_ARG_NUM(2);
-			*r_return=Math::dectime((double)*p_inputs[0],(double)*p_inputs[1],(double)*p_inputs[2]);
+			*r_return = Math::dectime((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RANDOMIZE: {
 			Math::randomize();
 
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RAND: {
-			*r_return=Math::rand();
+			*r_return = Math::rand();
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RANDF: {
-			*r_return=Math::randf();
+			*r_return = Math::randf();
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RANDOM: {
 
 			VALIDATE_ARG_NUM(0);
 			VALIDATE_ARG_NUM(1);
-			*r_return=Math::random((double)*p_inputs[0],(double)*p_inputs[1]);
+			*r_return = Math::random((double)*p_inputs[0], (double)*p_inputs[1]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_SEED: {
 
 			VALIDATE_ARG_NUM(0);
-			uint64_t seed=*p_inputs[0];
+			uint64_t seed = *p_inputs[0];
 			Math::seed(seed);
 
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RANDSEED: {
 
 			VALIDATE_ARG_NUM(0);
-			uint64_t seed=*p_inputs[0];
+			uint64_t seed = *p_inputs[0];
 			int ret = Math::rand_from_seed(&seed);
 			Array reta;
 			reta.push_back(ret);
 			reta.push_back(seed);
-			*r_return=reta;
+			*r_return = reta;
 
 		} break;
 		case VisualScriptBuiltinFunc::MATH_DEG2RAD: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::deg2rad((double)*p_inputs[0]);
+			*r_return = Math::deg2rad((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_RAD2DEG: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::rad2deg((double)*p_inputs[0]);
+			*r_return = Math::rad2deg((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_LINEAR2DB: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::linear2db((double)*p_inputs[0]);
+			*r_return = Math::linear2db((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::MATH_DB2LINEAR: {
 
 			VALIDATE_ARG_NUM(0);
-			*r_return=Math::db2linear((double)*p_inputs[0]);
+			*r_return = Math::db2linear((double)*p_inputs[0]);
 		} break;
 		case VisualScriptBuiltinFunc::LOGIC_MAX: {
 
-			if (p_inputs[0]->get_type()==Variant::INT && p_inputs[1]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
 
 				int64_t a = *p_inputs[0];
 				int64_t b = *p_inputs[1];
-				*r_return=MAX(a,b);
+				*r_return = MAX(a, b);
 			} else {
 				VALIDATE_ARG_NUM(0);
 				VALIDATE_ARG_NUM(1);
@@ -880,17 +869,17 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 				real_t a = *p_inputs[0];
 				real_t b = *p_inputs[1];
 
-				*r_return=MAX(a,b);
+				*r_return = MAX(a, b);
 			}
 
 		} break;
 		case VisualScriptBuiltinFunc::LOGIC_MIN: {
 
-			if (p_inputs[0]->get_type()==Variant::INT && p_inputs[1]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
 
 				int64_t a = *p_inputs[0];
 				int64_t b = *p_inputs[1];
-				*r_return=MIN(a,b);
+				*r_return = MIN(a, b);
 			} else {
 				VALIDATE_ARG_NUM(0);
 				VALIDATE_ARG_NUM(1);
@@ -898,17 +887,17 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 				real_t a = *p_inputs[0];
 				real_t b = *p_inputs[1];
 
-				*r_return=MIN(a,b);
+				*r_return = MIN(a, b);
 			}
 		} break;
 		case VisualScriptBuiltinFunc::LOGIC_CLAMP: {
 
-			if (p_inputs[0]->get_type()==Variant::INT && p_inputs[1]->get_type()==Variant::INT && p_inputs[2]->get_type()==Variant::INT) {
+			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT && p_inputs[2]->get_type() == Variant::INT) {
 
 				int64_t a = *p_inputs[0];
 				int64_t b = *p_inputs[1];
 				int64_t c = *p_inputs[2];
-				*r_return=CLAMP(a,b,c);
+				*r_return = CLAMP(a, b, c);
 			} else {
 				VALIDATE_ARG_NUM(0);
 				VALIDATE_ARG_NUM(1);
@@ -918,7 +907,7 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 				real_t b = *p_inputs[1];
 				real_t c = *p_inputs[2];
 
-				*r_return=CLAMP(a,b,c);
+				*r_return = CLAMP(a, b, c);
 			}
 		} break;
 		case VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2: {
@@ -929,14 +918,13 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 		} break;
 		case VisualScriptBuiltinFunc::OBJ_WEAKREF: {
 
-			if (p_inputs[0]->get_type()!=Variant::OBJECT) {
+			if (p_inputs[0]->get_type() != Variant::OBJECT) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::OBJECT;
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
 
 				return;
-
 			}
 
 			if (p_inputs[0]->is_ref()) {
@@ -947,95 +935,87 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 					return;
 				}
 
-				Ref<WeakRef> wref = memnew( WeakRef );
+				Ref<WeakRef> wref = memnew(WeakRef);
 				wref->set_ref(r);
-				*r_return=wref;
+				*r_return = wref;
 			} else {
 				Object *obj = *p_inputs[0];
 				if (!obj) {
 
 					return;
 				}
-				Ref<WeakRef> wref = memnew( WeakRef );
+				Ref<WeakRef> wref = memnew(WeakRef);
 				wref->set_obj(obj);
-				*r_return=wref;
+				*r_return = wref;
 			}
 
-
-
-
 		} break;
 		case VisualScriptBuiltinFunc::FUNC_FUNCREF: {
 
-			if (p_inputs[0]->get_type()!=Variant::OBJECT) {
+			if (p_inputs[0]->get_type() != Variant::OBJECT) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::OBJECT;
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
 
 				return;
-
 			}
-			if (p_inputs[1]->get_type()!=Variant::STRING && p_inputs[1]->get_type()!=Variant::NODE_PATH) {
+			if (p_inputs[1]->get_type() != Variant::STRING && p_inputs[1]->get_type() != Variant::NODE_PATH) {
 
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=1;
-				r_error.expected=Variant::STRING;
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 1;
+				r_error.expected = Variant::STRING;
 
 				return;
-
 			}
 
-			Ref<FuncRef> fr = memnew( FuncRef);
+			Ref<FuncRef> fr = memnew(FuncRef);
 
 			fr->set_instance(*p_inputs[0]);
 			fr->set_function(*p_inputs[1]);
 
-			*r_return=fr;
+			*r_return = fr;
 
 		} break;
 		case VisualScriptBuiltinFunc::TYPE_CONVERT: {
 
 			VALIDATE_ARG_NUM(1);
-			int type=*p_inputs[1];
-			if (type<0 || type>=Variant::VARIANT_MAX) {
+			int type = *p_inputs[1];
+			if (type < 0 || type >= Variant::VARIANT_MAX) {
 
-				r_error_str=RTR("Invalid type argument to convert(), use TYPE_* constants.");
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::INT;
+				r_error_str = RTR("Invalid type argument to convert(), use TYPE_* constants.");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::INT;
 				return;
 
 			} else {
 
-
-				*r_return=Variant::construct(Variant::Type(type),p_inputs,1,r_error);
+				*r_return = Variant::construct(Variant::Type(type), p_inputs, 1, r_error);
 			}
 		} break;
 		case VisualScriptBuiltinFunc::TYPE_OF: {
 
-
 			*r_return = p_inputs[0]->get_type();
 
 		} break;
 		case VisualScriptBuiltinFunc::TYPE_EXISTS: {
 
-
 			*r_return = ClassDB::class_exists(*p_inputs[0]);
 
 		} break;
 		case VisualScriptBuiltinFunc::TEXT_CHAR: {
 
-			CharType result[2] = {*p_inputs[0], 0};
-			
-			*r_return=String(result);
+			CharType result[2] = { *p_inputs[0], 0 };
+
+			*r_return = String(result);
 
 		} break;
 		case VisualScriptBuiltinFunc::TEXT_STR: {
 
 			String str = *p_inputs[0];
 
-			*r_return=str;
+			*r_return = str;
 
 		} break;
 		case VisualScriptBuiltinFunc::TEXT_PRINT: {
@@ -1043,7 +1023,6 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 			String str = *p_inputs[0];
 			print_line(str);
 
-
 		} break;
 
 		case VisualScriptBuiltinFunc::TEXT_PRINTERR: {
@@ -1051,98 +1030,93 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 			String str = *p_inputs[0];
 
 			//str+="\n";
-			OS::get_singleton()->printerr("%s\n",str.utf8().get_data());
-
+			OS::get_singleton()->printerr("%s\n", str.utf8().get_data());
 
 		} break;
 		case VisualScriptBuiltinFunc::TEXT_PRINTRAW: {
 			String str = *p_inputs[0];
 
 			//str+="\n";
-			OS::get_singleton()->print("%s",str.utf8().get_data());
-
+			OS::get_singleton()->print("%s", str.utf8().get_data());
 
 		} break;
 		case VisualScriptBuiltinFunc::VAR_TO_STR: {
 
 			String vars;
-			VariantWriter::write_to_string(*p_inputs[0],vars);
-			*r_return=vars;
+			VariantWriter::write_to_string(*p_inputs[0], vars);
+			*r_return = vars;
 		} break;
 		case VisualScriptBuiltinFunc::STR_TO_VAR: {
 
-			if (p_inputs[0]->get_type()!=Variant::STRING) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::STRING;
+			if (p_inputs[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
 
 				return;
 			}
 
 			VariantParser::StreamString ss;
-			ss.s=*p_inputs[0];
+			ss.s = *p_inputs[0];
 
 			String errs;
 			int line;
-			Error err = VariantParser::parse(&ss,*r_return,errs,line);
+			Error err = VariantParser::parse(&ss, *r_return, errs, line);
 
-			if (err!=OK) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::STRING;
-				*r_return="Parse error at line "+itos(line)+": "+errs;
+			if (err != OK) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				*r_return = "Parse error at line " + itos(line) + ": " + errs;
 				return;
 			}
 
 		} break;
 		case VisualScriptBuiltinFunc::VAR_TO_BYTES: {
 
-
 			PoolByteArray barr;
 			int len;
-			Error err = encode_variant(*p_inputs[0],NULL,len);
+			Error err = encode_variant(*p_inputs[0], NULL, len);
 			if (err) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::NIL;
-				r_error_str="Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::NIL;
+				r_error_str = "Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
 				return;
 			}
 
 			barr.resize(len);
 			{
 				PoolByteArray::Write w = barr.write();
-				encode_variant(*p_inputs[0],w.ptr(),len);
-
+				encode_variant(*p_inputs[0], w.ptr(), len);
 			}
-			*r_return=barr;
+			*r_return = barr;
 		} break;
 		case VisualScriptBuiltinFunc::BYTES_TO_VAR: {
 
-			if (p_inputs[0]->get_type()!=Variant::POOL_BYTE_ARRAY) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-				r_error.argument=0;
-				r_error.expected=Variant::POOL_BYTE_ARRAY;
+			if (p_inputs[0]->get_type() != Variant::POOL_BYTE_ARRAY) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::POOL_BYTE_ARRAY;
 
 				return;
 			}
 
-			PoolByteArray varr=*p_inputs[0];
+			PoolByteArray varr = *p_inputs[0];
 			Variant ret;
 			{
-				PoolByteArray::Read r=varr.read();
-				Error err = decode_variant(ret,r.ptr(),varr.size(),NULL);
-				if (err!=OK) {
-					r_error_str=RTR("Not enough bytes for decoding bytes, or invalid format.");
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-					r_error.argument=0;
-					r_error.expected=Variant::POOL_BYTE_ARRAY;
+				PoolByteArray::Read r = varr.read();
+				Error err = decode_variant(ret, r.ptr(), varr.size(), NULL);
+				if (err != OK) {
+					r_error_str = RTR("Not enough bytes for decoding bytes, or invalid format.");
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 0;
+					r_error.expected = Variant::POOL_BYTE_ARRAY;
 					return;
 				}
-
 			}
 
-			*r_return=ret;
+			*r_return = ret;
 
 		} break;
 		case VisualScriptBuiltinFunc::COLORN: {
@@ -1150,72 +1124,65 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func,const Variant** p_inp
 			VALIDATE_ARG_NUM(1);
 
 			Color color = Color::named(*p_inputs[0]);
-			color.a=*p_inputs[1];
-			
-			*r_return=String(color);
+			color.a = *p_inputs[1];
+
+			*r_return = String(color);
 
 		} break;
 		default: {}
 	}
-
 }
 
-
 class VisualScriptNodeInstanceBuiltinFunc : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptBuiltinFunc *node;
 	VisualScriptInstance *instance;
 
 	VisualScriptBuiltinFunc::BuiltinFunc func;
 
-
 	//virtual int get_working_memory_size() const { return 0; }
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		VisualScriptBuiltinFunc::exec_func(func,p_inputs,p_outputs[0],r_error,r_error_str);
+		VisualScriptBuiltinFunc::exec_func(func, p_inputs, p_outputs[0], r_error, r_error_str);
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptBuiltinFunc::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptBuiltinFunc::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceBuiltinFunc * instance = memnew(VisualScriptNodeInstanceBuiltinFunc );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->func=func;
+	VisualScriptNodeInstanceBuiltinFunc *instance = memnew(VisualScriptNodeInstanceBuiltinFunc);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->func = func;
 	return instance;
 }
 
-
 void VisualScriptBuiltinFunc::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_func","which"),&VisualScriptBuiltinFunc::set_func);
-	ClassDB::bind_method(D_METHOD("get_func"),&VisualScriptBuiltinFunc::get_func);
+	ClassDB::bind_method(D_METHOD("set_func", "which"), &VisualScriptBuiltinFunc::set_func);
+	ClassDB::bind_method(D_METHOD("get_func"), &VisualScriptBuiltinFunc::get_func);
 
 	String cc;
 
-	for(int i=0;i<FUNC_MAX;i++) {
+	for (int i = 0; i < FUNC_MAX; i++) {
 
-		if (i>0)
-			cc+=",";
-		cc+=func_name[i];
+		if (i > 0)
+			cc += ",";
+		cc += func_name[i];
 	}
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"function",PROPERTY_HINT_ENUM,cc),"set_func","get_func");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, cc), "set_func", "get_func");
 }
 
 VisualScriptBuiltinFunc::VisualScriptBuiltinFunc() {
 
-	func=MATH_SIN;
+	func = MATH_SIN;
 }
 
-template<VisualScriptBuiltinFunc::BuiltinFunc func>
-static Ref<VisualScriptNode> create_builtin_func_node(const String& p_name) {
+template <VisualScriptBuiltinFunc::BuiltinFunc func>
+static Ref<VisualScriptNode> create_builtin_func_node(const String &p_name) {
 
 	Ref<VisualScriptBuiltinFunc> node;
 	node.instance();
@@ -1225,69 +1192,67 @@ static Ref<VisualScriptNode> create_builtin_func_node(const String& p_name) {
 
 void register_visual_script_builtin_func_node() {
 
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sin",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/cos",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/tan",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TAN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sinh",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SINH>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/cosh",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COSH>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/tanh",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TANH>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/asin",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ASIN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/acos",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ACOS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan2",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN2>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sqrt",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SQRT>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/fmod",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FMOD>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/fposmod",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FPOSMOD>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/floor",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FLOOR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/ceil",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_CEIL>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/round",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ROUND>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/abs",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ABS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sign",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIGN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/pow",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_POW>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/log",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LOG>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/exp",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EXP>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/isnan",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISNAN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/isinf",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISINF>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/ease",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EASE>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/decimals",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECIMALS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/stepify",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_STEPIFY>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/lerp",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LERP>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/dectime",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECTIME>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randomize",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOMIZE>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/rand",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAND>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randf",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDF>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/random",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOM>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/seed",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SEED>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randseed",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDSEED>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/deg2rad",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DEG2RAD>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/rad2deg",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAD2DEG>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/linear2db",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LINEAR2DB>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/db2linear",create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DB2LINEAR>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/max",create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MAX>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/min",create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MIN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/clamp",create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_CLAMP>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/nearest_po2",create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2>);
-
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/weakref",create_builtin_func_node<VisualScriptBuiltinFunc::OBJ_WEAKREF>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/funcref",create_builtin_func_node<VisualScriptBuiltinFunc::FUNC_FUNCREF>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/convert",create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_CONVERT>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/typeof",create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_OF>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/type_exists",create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_EXISTS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/char",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_CHAR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/str",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_STR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/print",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINT>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/printerr",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTERR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/printraw",create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTRAW>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2str",create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_STR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/str2var",create_builtin_func_node<VisualScriptBuiltinFunc::STR_TO_VAR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2bytes",create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_BYTES>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/bytes2var",create_builtin_func_node<VisualScriptBuiltinFunc::BYTES_TO_VAR>);
-	VisualScriptLanguage::singleton->add_register_func("functions/built_in/color_named",create_builtin_func_node<VisualScriptBuiltinFunc::COLORN>);
-
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sin", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/cos", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/tan", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TAN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sinh", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SINH>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/cosh", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COSH>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/tanh", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TANH>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/asin", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ASIN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/acos", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ACOS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan2", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN2>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sqrt", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SQRT>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/fmod", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FMOD>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/fposmod", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FPOSMOD>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/floor", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FLOOR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/ceil", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_CEIL>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/round", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ROUND>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/abs", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ABS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/sign", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIGN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/pow", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_POW>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/log", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LOG>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/exp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EXP>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/isnan", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISNAN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/isinf", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISINF>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/ease", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EASE>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/decimals", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECIMALS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/stepify", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_STEPIFY>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/lerp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LERP>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/dectime", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECTIME>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randomize", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOMIZE>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/rand", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAND>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randf", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDF>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/random", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOM>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/seed", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SEED>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randseed", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDSEED>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/deg2rad", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DEG2RAD>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/rad2deg", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAD2DEG>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/linear2db", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LINEAR2DB>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/db2linear", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DB2LINEAR>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/max", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MAX>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/min", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MIN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/clamp", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_CLAMP>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/nearest_po2", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2>);
+
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/weakref", create_builtin_func_node<VisualScriptBuiltinFunc::OBJ_WEAKREF>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/funcref", create_builtin_func_node<VisualScriptBuiltinFunc::FUNC_FUNCREF>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/convert", create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_CONVERT>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/typeof", create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_OF>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/type_exists", create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_EXISTS>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/char", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_CHAR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/str", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_STR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/print", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINT>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/printerr", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTERR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/printraw", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTRAW>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2str", create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_STR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/str2var", create_builtin_func_node<VisualScriptBuiltinFunc::STR_TO_VAR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2bytes", create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_BYTES>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/bytes2var", create_builtin_func_node<VisualScriptBuiltinFunc::BYTES_TO_VAR>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/color_named", create_builtin_func_node<VisualScriptBuiltinFunc::COLORN>);
 }
diff --git a/modules/visual_script/visual_script_builtin_funcs.h b/modules/visual_script/visual_script_builtin_funcs.h
index 75bea4b1b5..7246239513 100644
--- a/modules/visual_script/visual_script_builtin_funcs.h
+++ b/modules/visual_script/visual_script_builtin_funcs.h
@@ -31,12 +31,10 @@
 
 #include "visual_script.h"
 
-
 class VisualScriptBuiltinFunc : public VisualScriptNode {
 
-	GDCLASS(VisualScriptBuiltinFunc,VisualScriptNode)
+	GDCLASS(VisualScriptBuiltinFunc, VisualScriptNode)
 public:
-
 	enum BuiltinFunc {
 		MATH_SIN,
 		MATH_COS,
@@ -100,27 +98,25 @@ public:
 
 	static int get_func_argument_count(BuiltinFunc p_func);
 	static String get_func_name(BuiltinFunc p_func);
-	static void exec_func(BuiltinFunc p_func, const Variant** p_inputs, Variant* r_return, Variant::CallError& r_error, String& r_error_str);
-	static BuiltinFunc find_function(const String& p_string);
+	static void exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant *r_return, Variant::CallError &r_error, String &r_error_str);
+	static BuiltinFunc find_function(const String &p_string);
 
 private:
-	static const char* func_name[FUNC_MAX];
+	static const char *func_name[FUNC_MAX];
 	BuiltinFunc func;
+
 protected:
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -131,15 +127,13 @@ public:
 	void set_func(BuiltinFunc p_which);
 	BuiltinFunc get_func();
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptBuiltinFunc();
 };
 
 VARIANT_ENUM_CAST(VisualScriptBuiltinFunc::BuiltinFunc)
 
-
 void register_visual_script_builtin_func_node();
 
-
 #endif // VISUAL_SCRIPT_BUILTIN_FUNCS_H
diff --git a/modules/visual_script/visual_script_editor.cpp b/modules/visual_script/visual_script_editor.cpp
index 7dd7059c31..5b1b496f72 100644
--- a/modules/visual_script/visual_script_editor.cpp
+++ b/modules/visual_script/visual_script_editor.cpp
@@ -29,29 +29,28 @@
 #include "visual_script_editor.h"
 
 #include "editor/editor_node.h"
-#include "visual_script_nodes.h"
-#include "visual_script_flow_control.h"
-#include "visual_script_func_nodes.h"
-#include "visual_script_expression.h"
-#include "os/input.h"
 #include "editor/editor_resource_preview.h"
+#include "os/input.h"
 #include "os/keyboard.h"
+#include "visual_script_expression.h"
+#include "visual_script_flow_control.h"
+#include "visual_script_func_nodes.h"
+#include "visual_script_nodes.h"
 
 #ifdef TOOLS_ENABLED
 class VisualScriptEditorSignalEdit : public Object {
 
-	GDCLASS(VisualScriptEditorSignalEdit,Object)
+	GDCLASS(VisualScriptEditorSignalEdit, Object)
 
 	StringName sig;
+
 public:
 	UndoRedo *undo_redo;
 	Ref<VisualScript> script;
 
-
 protected:
-
 	static void _bind_methods() {
-		ClassDB::bind_method("_sig_changed",&VisualScriptEditorSignalEdit::_sig_changed);
+		ClassDB::bind_method("_sig_changed", &VisualScriptEditorSignalEdit::_sig_changed);
 	}
 
 	void _sig_changed() {
@@ -59,149 +58,138 @@ protected:
 		_change_notify();
 	}
 
-	bool _set(const StringName& p_name, const Variant& p_value) {
+	bool _set(const StringName &p_name, const Variant &p_value) {
 
-		if (sig==StringName())
+		if (sig == StringName())
 			return false;
 
-		if (p_name=="argument_count") {
+		if (p_name == "argument_count") {
 
-			int new_argc=p_value;
+			int new_argc = p_value;
 			int argc = script->custom_signal_get_argument_count(sig);
-			if (argc==new_argc)
+			if (argc == new_argc)
 				return true;
 
 			undo_redo->create_action("Change Signal Arguments");
 
-
-
 			if (new_argc < argc) {
-				for(int i=new_argc;i<argc;i++) {
-					undo_redo->add_do_method(script.ptr(),"custom_signal_remove_argument",sig,new_argc);
-					undo_redo->add_undo_method(script.ptr(),"custom_signal_add_argument",sig,script->custom_signal_get_argument_name(sig,i),script->custom_signal_get_argument_type(sig,i),-1);
+				for (int i = new_argc; i < argc; i++) {
+					undo_redo->add_do_method(script.ptr(), "custom_signal_remove_argument", sig, new_argc);
+					undo_redo->add_undo_method(script.ptr(), "custom_signal_add_argument", sig, script->custom_signal_get_argument_name(sig, i), script->custom_signal_get_argument_type(sig, i), -1);
 				}
-			} else if (new_argc>argc) {
+			} else if (new_argc > argc) {
 
-				for(int i=argc;i<new_argc;i++) {
+				for (int i = argc; i < new_argc; i++) {
 
-					undo_redo->add_do_method(script.ptr(),"custom_signal_add_argument",sig,Variant::NIL,"arg"+itos(i+1),-1);
-					undo_redo->add_undo_method(script.ptr(),"custom_signal_remove_argument",sig,argc);
+					undo_redo->add_do_method(script.ptr(), "custom_signal_add_argument", sig, Variant::NIL, "arg" + itos(i + 1), -1);
+					undo_redo->add_undo_method(script.ptr(), "custom_signal_remove_argument", sig, argc);
 				}
 			}
 
-			undo_redo->add_do_method(this,"_sig_changed");
-			undo_redo->add_undo_method(this,"_sig_changed");
+			undo_redo->add_do_method(this, "_sig_changed");
+			undo_redo->add_undo_method(this, "_sig_changed");
 
 			undo_redo->commit_action();
 
 			return true;
 		}
 		if (String(p_name).begins_with("argument/")) {
-			int idx = String(p_name).get_slice("/",1).to_int()-1;
-			ERR_FAIL_INDEX_V(idx,script->custom_signal_get_argument_count(sig),false);
-			String what = String(p_name).get_slice("/",2);
-			if (what=="type") {
+			int idx = String(p_name).get_slice("/", 1).to_int() - 1;
+			ERR_FAIL_INDEX_V(idx, script->custom_signal_get_argument_count(sig), false);
+			String what = String(p_name).get_slice("/", 2);
+			if (what == "type") {
 
-				int old_type = script->custom_signal_get_argument_type(sig,idx);
-				int new_type=p_value;
+				int old_type = script->custom_signal_get_argument_type(sig, idx);
+				int new_type = p_value;
 				undo_redo->create_action("Change Argument Type");
-				undo_redo->add_do_method(script.ptr(),"custom_signal_set_argument_type",sig,idx,new_type);
-				undo_redo->add_undo_method(script.ptr(),"custom_signal_set_argument_type",sig,idx,old_type);
+				undo_redo->add_do_method(script.ptr(), "custom_signal_set_argument_type", sig, idx, new_type);
+				undo_redo->add_undo_method(script.ptr(), "custom_signal_set_argument_type", sig, idx, old_type);
 				undo_redo->commit_action();
 
 				return true;
 			}
 
-			if (what=="name") {
+			if (what == "name") {
 
-				String old_name = script->custom_signal_get_argument_name(sig,idx);
-				String new_name=p_value;
+				String old_name = script->custom_signal_get_argument_name(sig, idx);
+				String new_name = p_value;
 				undo_redo->create_action("Change Argument name");
-				undo_redo->add_do_method(script.ptr(),"custom_signal_set_argument_name",sig,idx,new_name);
-				undo_redo->add_undo_method(script.ptr(),"custom_signal_set_argument_name",sig,idx,old_name);
+				undo_redo->add_do_method(script.ptr(), "custom_signal_set_argument_name", sig, idx, new_name);
+				undo_redo->add_undo_method(script.ptr(), "custom_signal_set_argument_name", sig, idx, old_name);
 				undo_redo->commit_action();
 				return true;
 			}
-
-
 		}
 
-
 		return false;
 	}
 
-	bool _get(const StringName& p_name,Variant &r_ret) const {
+	bool _get(const StringName &p_name, Variant &r_ret) const {
 
-		if (sig==StringName())
+		if (sig == StringName())
 			return false;
 
-		if (p_name=="argument_count") {
+		if (p_name == "argument_count") {
 			r_ret = script->custom_signal_get_argument_count(sig);
 			return true;
 		}
 		if (String(p_name).begins_with("argument/")) {
-			int idx = String(p_name).get_slice("/",1).to_int()-1;
-			ERR_FAIL_INDEX_V(idx,script->custom_signal_get_argument_count(sig),false);
-			String what = String(p_name).get_slice("/",2);
-			if (what=="type") {
-				r_ret = script->custom_signal_get_argument_type(sig,idx);
+			int idx = String(p_name).get_slice("/", 1).to_int() - 1;
+			ERR_FAIL_INDEX_V(idx, script->custom_signal_get_argument_count(sig), false);
+			String what = String(p_name).get_slice("/", 2);
+			if (what == "type") {
+				r_ret = script->custom_signal_get_argument_type(sig, idx);
 				return true;
 			}
-			if (what=="name") {
-				r_ret = script->custom_signal_get_argument_name(sig,idx);
+			if (what == "name") {
+				r_ret = script->custom_signal_get_argument_name(sig, idx);
 				return true;
 			}
-
-
-
 		}
 
 		return false;
 	}
-	void _get_property_list( List<PropertyInfo> *p_list) const {
+	void _get_property_list(List<PropertyInfo> *p_list) const {
 
-		if (sig==StringName())
+		if (sig == StringName())
 			return;
 
-		p_list->push_back(PropertyInfo(Variant::INT,"argument_count",PROPERTY_HINT_RANGE,"0,256"));
-		String argt="Variant";
-		for(int i=1;i<Variant::VARIANT_MAX;i++) {
-			argt+=","+Variant::get_type_name(Variant::Type(i));
+		p_list->push_back(PropertyInfo(Variant::INT, "argument_count", PROPERTY_HINT_RANGE, "0,256"));
+		String argt = "Variant";
+		for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+			argt += "," + Variant::get_type_name(Variant::Type(i));
 		}
 
-		for(int i=0;i<script->custom_signal_get_argument_count(sig);i++) {
-			p_list->push_back(PropertyInfo(Variant::INT,"argument/"+itos(i+1)+"/type",PROPERTY_HINT_ENUM,argt));
-			p_list->push_back(PropertyInfo(Variant::STRING,"argument/"+itos(i+1)+"/name"));
+		for (int i = 0; i < script->custom_signal_get_argument_count(sig); i++) {
+			p_list->push_back(PropertyInfo(Variant::INT, "argument/" + itos(i + 1) + "/type", PROPERTY_HINT_ENUM, argt));
+			p_list->push_back(PropertyInfo(Variant::STRING, "argument/" + itos(i + 1) + "/name"));
 		}
 	}
 
 public:
+	void edit(const StringName &p_sig) {
 
-
-	void edit(const StringName& p_sig) {
-
-		sig=p_sig;
+		sig = p_sig;
 		_change_notify();
 	}
 
-	VisualScriptEditorSignalEdit() { undo_redo=NULL; }
+	VisualScriptEditorSignalEdit() { undo_redo = NULL; }
 };
 
 class VisualScriptEditorVariableEdit : public Object {
 
-	GDCLASS(VisualScriptEditorVariableEdit,Object)
+	GDCLASS(VisualScriptEditorVariableEdit, Object)
 
 	StringName var;
+
 public:
 	UndoRedo *undo_redo;
 	Ref<VisualScript> script;
 
-
 protected:
-
 	static void _bind_methods() {
-		ClassDB::bind_method("_var_changed",&VisualScriptEditorVariableEdit::_var_changed);
-		ClassDB::bind_method("_var_value_changed",&VisualScriptEditorVariableEdit::_var_value_changed);
+		ClassDB::bind_method("_var_changed", &VisualScriptEditorVariableEdit::_var_changed);
+		ClassDB::bind_method("_var_value_changed", &VisualScriptEditorVariableEdit::_var_value_changed);
 	}
 
 	void _var_changed() {
@@ -213,138 +201,132 @@ protected:
 		_change_notify("value"); //so the whole tree is not redrawn, makes editing smoother in general
 	}
 
-	bool _set(const StringName& p_name, const Variant& p_value) {
+	bool _set(const StringName &p_name, const Variant &p_value) {
 
-		if (var==StringName())
+		if (var == StringName())
 			return false;
 
-
-
-		if (String(p_name)=="value") {
+		if (String(p_name) == "value") {
 			undo_redo->create_action("Set Variable Default Value");
-			Variant current=script->get_variable_default_value(var);
-			undo_redo->add_do_method(script.ptr(),"set_variable_default_value",var,p_value);
-			undo_redo->add_undo_method(script.ptr(),"set_variable_default_value",var,current);
-			undo_redo->add_do_method(this,"_var_value_changed");
-			undo_redo->add_undo_method(this,"_var_value_changed");
+			Variant current = script->get_variable_default_value(var);
+			undo_redo->add_do_method(script.ptr(), "set_variable_default_value", var, p_value);
+			undo_redo->add_undo_method(script.ptr(), "set_variable_default_value", var, current);
+			undo_redo->add_do_method(this, "_var_value_changed");
+			undo_redo->add_undo_method(this, "_var_value_changed");
 			undo_redo->commit_action();
 			return true;
 		}
 
-		Dictionary d = script->call("get_variable_info",var);
+		Dictionary d = script->call("get_variable_info", var);
 
-		if (String(p_name)=="type") {
+		if (String(p_name) == "type") {
 
-			Dictionary dc=d.copy();
-			dc["type"]=p_value;
+			Dictionary dc = d.copy();
+			dc["type"] = p_value;
 			undo_redo->create_action("Set Variable Type");
-			undo_redo->add_do_method(script.ptr(),"set_variable_info",var,dc);
-			undo_redo->add_undo_method(script.ptr(),"set_variable_info",var,d);
-			undo_redo->add_do_method(this,"_var_changed");
-			undo_redo->add_undo_method(this,"_var_changed");
+			undo_redo->add_do_method(script.ptr(), "set_variable_info", var, dc);
+			undo_redo->add_undo_method(script.ptr(), "set_variable_info", var, d);
+			undo_redo->add_do_method(this, "_var_changed");
+			undo_redo->add_undo_method(this, "_var_changed");
 			undo_redo->commit_action();
 			return true;
 		}
 
-		if (String(p_name)=="hint") {
+		if (String(p_name) == "hint") {
 
-			Dictionary dc=d.copy();
-			dc["hint"]=p_value;
+			Dictionary dc = d.copy();
+			dc["hint"] = p_value;
 			undo_redo->create_action("Set Variable Type");
-			undo_redo->add_do_method(script.ptr(),"set_variable_info",var,dc);
-			undo_redo->add_undo_method(script.ptr(),"set_variable_info",var,d);
-			undo_redo->add_do_method(this,"_var_changed");
-			undo_redo->add_undo_method(this,"_var_changed");
+			undo_redo->add_do_method(script.ptr(), "set_variable_info", var, dc);
+			undo_redo->add_undo_method(script.ptr(), "set_variable_info", var, d);
+			undo_redo->add_do_method(this, "_var_changed");
+			undo_redo->add_undo_method(this, "_var_changed");
 			undo_redo->commit_action();
 			return true;
 		}
 
-		if (String(p_name)=="hint_string") {
+		if (String(p_name) == "hint_string") {
 
-			Dictionary dc=d.copy();
-			dc["hint_string"]=p_value;
+			Dictionary dc = d.copy();
+			dc["hint_string"] = p_value;
 			undo_redo->create_action("Set Variable Type");
-			undo_redo->add_do_method(script.ptr(),"set_variable_info",var,dc);
-			undo_redo->add_undo_method(script.ptr(),"set_variable_info",var,d);
-			undo_redo->add_do_method(this,"_var_changed");
-			undo_redo->add_undo_method(this,"_var_changed");
+			undo_redo->add_do_method(script.ptr(), "set_variable_info", var, dc);
+			undo_redo->add_undo_method(script.ptr(), "set_variable_info", var, d);
+			undo_redo->add_do_method(this, "_var_changed");
+			undo_redo->add_undo_method(this, "_var_changed");
 			undo_redo->commit_action();
 			return true;
 		}
 
-		if (String(p_name)=="export") {
-			script->set_variable_export(var,p_value);
+		if (String(p_name) == "export") {
+			script->set_variable_export(var, p_value);
 			return true;
 		}
 
-
 		return false;
 	}
 
-	bool _get(const StringName& p_name,Variant &r_ret) const {
+	bool _get(const StringName &p_name, Variant &r_ret) const {
 
-		if (var==StringName())
+		if (var == StringName())
 			return false;
 
-		if (String(p_name)=="value") {
-			r_ret=script->get_variable_default_value(var);
+		if (String(p_name) == "value") {
+			r_ret = script->get_variable_default_value(var);
 			return true;
 		}
 
 		PropertyInfo pinfo = script->get_variable_info(var);
 
-		if (String(p_name)=="type") {
-			r_ret=pinfo.type;
+		if (String(p_name) == "type") {
+			r_ret = pinfo.type;
 			return true;
 		}
-		if (String(p_name)=="hint") {
-			r_ret=pinfo.hint;
+		if (String(p_name) == "hint") {
+			r_ret = pinfo.hint;
 			return true;
 		}
-		if (String(p_name)=="hint_string") {
-			r_ret=pinfo.hint_string;
+		if (String(p_name) == "hint_string") {
+			r_ret = pinfo.hint_string;
 			return true;
 		}
 
-		if (String(p_name)=="export") {
-			r_ret=script->get_variable_export(var);
+		if (String(p_name) == "export") {
+			r_ret = script->get_variable_export(var);
 			return true;
 		}
 
 		return false;
 	}
-	void _get_property_list( List<PropertyInfo> *p_list) const {
+	void _get_property_list(List<PropertyInfo> *p_list) const {
 
-		if (var==StringName())
+		if (var == StringName())
 			return;
 
-		String argt="Variant";
-		for(int i=1;i<Variant::VARIANT_MAX;i++) {
-			argt+=","+Variant::get_type_name(Variant::Type(i));
+		String argt = "Variant";
+		for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+			argt += "," + Variant::get_type_name(Variant::Type(i));
 		}
-		p_list->push_back(PropertyInfo(Variant::INT,"type",PROPERTY_HINT_ENUM,argt));
-		p_list->push_back(PropertyInfo(script->get_variable_info(var).type,"value",script->get_variable_info(var).hint,script->get_variable_info(var).hint_string,PROPERTY_USAGE_DEFAULT));
-		p_list->push_back(PropertyInfo(Variant::INT,"hint",PROPERTY_HINT_ENUM,"None,Range,ExpRange,Enum,ExpEasing,Length,SpriteFrame,KeyAccel,BitFlags,AllFlags,File,Dir,GlobalFile,GlobalDir,ResourceType,MultilineText"));
-		p_list->push_back(PropertyInfo(Variant::STRING,"hint_string"));
-		p_list->push_back(PropertyInfo(Variant::BOOL,"export"));
-
+		p_list->push_back(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt));
+		p_list->push_back(PropertyInfo(script->get_variable_info(var).type, "value", script->get_variable_info(var).hint, script->get_variable_info(var).hint_string, PROPERTY_USAGE_DEFAULT));
+		p_list->push_back(PropertyInfo(Variant::INT, "hint", PROPERTY_HINT_ENUM, "None,Range,ExpRange,Enum,ExpEasing,Length,SpriteFrame,KeyAccel,BitFlags,AllFlags,File,Dir,GlobalFile,GlobalDir,ResourceType,MultilineText"));
+		p_list->push_back(PropertyInfo(Variant::STRING, "hint_string"));
+		p_list->push_back(PropertyInfo(Variant::BOOL, "export"));
 	}
 
 public:
+	void edit(const StringName &p_var) {
 
-
-	void edit(const StringName& p_var) {
-
-		var=p_var;
+		var = p_var;
 		_change_notify();
 	}
 
-	VisualScriptEditorVariableEdit() { undo_redo=NULL; }
+	VisualScriptEditorVariableEdit() { undo_redo = NULL; }
 };
 
 static Color _color_from_type(Variant::Type p_type) {
 	Color color;
-	switch(p_type) {
+	switch (p_type) {
 		case Variant::NIL: color = Color::html("69ecbd"); break;
 
 		case Variant::BOOL: color = Color::html("8da6f0"); break;
@@ -380,66 +362,60 @@ static Color _color_from_type(Variant::Type p_type) {
 		case Variant::POOL_COLOR_ARRAY: color = Color::html("e9ff97"); break;
 
 		default:
-			color.set_hsv(p_type/float(Variant::VARIANT_MAX),0.7,0.7);
+			color.set_hsv(p_type / float(Variant::VARIANT_MAX), 0.7, 0.7);
 	}
 	return color;
 }
 
-
-
 void VisualScriptEditor::_update_graph_connections() {
 
 	graph->clear_connections();
 
 	List<VisualScript::SequenceConnection> sequence_conns;
-	script->get_sequence_connection_list(edited_func,&sequence_conns);
+	script->get_sequence_connection_list(edited_func, &sequence_conns);
 
+	for (List<VisualScript::SequenceConnection>::Element *E = sequence_conns.front(); E; E = E->next()) {
 
-	for (List<VisualScript::SequenceConnection>::Element *E=sequence_conns.front();E;E=E->next()) {
-
-		graph->connect_node(itos(E->get().from_node),E->get().from_output,itos(E->get().to_node),0);
+		graph->connect_node(itos(E->get().from_node), E->get().from_output, itos(E->get().to_node), 0);
 	}
 
 	List<VisualScript::DataConnection> data_conns;
-	script->get_data_connection_list(edited_func,&data_conns);
-
-	for (List<VisualScript::DataConnection>::Element *E=data_conns.front();E;E=E->next()) {
+	script->get_data_connection_list(edited_func, &data_conns);
 
-		VisualScript::DataConnection dc=E->get();
+	for (List<VisualScript::DataConnection>::Element *E = data_conns.front(); E; E = E->next()) {
 
+		VisualScript::DataConnection dc = E->get();
 
-		Ref<VisualScriptNode> from_node = script->get_node(edited_func,E->get().from_node);
-		Ref<VisualScriptNode> to_node = script->get_node(edited_func,E->get().to_node);
+		Ref<VisualScriptNode> from_node = script->get_node(edited_func, E->get().from_node);
+		Ref<VisualScriptNode> to_node = script->get_node(edited_func, E->get().to_node);
 
 		if (to_node->has_input_sequence_port()) {
 			dc.to_port++;
 		}
 
-		dc.from_port+=from_node->get_output_sequence_port_count();
+		dc.from_port += from_node->get_output_sequence_port_count();
 
-		graph->connect_node(itos(E->get().from_node),dc.from_port,itos(E->get().to_node),dc.to_port);
+		graph->connect_node(itos(E->get().from_node), dc.from_port, itos(E->get().to_node), dc.to_port);
 	}
-
 }
 
-
 void VisualScriptEditor::_update_graph(int p_only_id) {
 
 	if (updating_graph)
 		return;
 
-	updating_graph=true;
+	updating_graph = true;
 
 	//byebye all nodes
-	if (p_only_id>=0) {
+	if (p_only_id >= 0) {
 		if (graph->has_node(itos(p_only_id))) {
-			Node* gid = graph->get_node(itos(p_only_id));
+			Node *gid = graph->get_node(itos(p_only_id));
 			if (gid)
 				memdelete(gid);
 		}
 	} else {
 
-		for(int i=0;i<graph->get_child_count();i++) {
+		for (int i = 0; i < graph->get_child_count(); i++) {
 
 			if (graph->get_child(i)->cast_to<GraphNode>()) {
 				memdelete(graph->get_child(i));
@@ -451,172 +427,160 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 	if (!script->has_function(edited_func)) {
 		graph->hide();
 		select_func_text->show();
-		updating_graph=false;
+		updating_graph = false;
 		return;
 	}
 
 	graph->show();
 	select_func_text->hide();
 
-	Ref<Texture> type_icons[Variant::VARIANT_MAX]={
-		Control::get_icon("MiniVariant","EditorIcons"),
-		Control::get_icon("MiniBoolean","EditorIcons"),
-		Control::get_icon("MiniInteger","EditorIcons"),
-		Control::get_icon("MiniFloat","EditorIcons"),
-		Control::get_icon("MiniString","EditorIcons"),
-		Control::get_icon("MiniVector2","EditorIcons"),
-		Control::get_icon("MiniRect2","EditorIcons"),
-		Control::get_icon("MiniVector3","EditorIcons"),
-		Control::get_icon("MiniTransform2D","EditorIcons"),
-		Control::get_icon("MiniPlane","EditorIcons"),
-		Control::get_icon("MiniQuat","EditorIcons"),
-		Control::get_icon("MiniAabb","EditorIcons"),
-		Control::get_icon("MiniBasis","EditorIcons"),
-		Control::get_icon("MiniTransform","EditorIcons"),
-		Control::get_icon("MiniColor","EditorIcons"),
-		Control::get_icon("MiniImage","EditorIcons"),
-		Control::get_icon("MiniPath","EditorIcons"),
-		Control::get_icon("MiniRid","EditorIcons"),
-		Control::get_icon("MiniObject","EditorIcons"),
-		Control::get_icon("MiniInput","EditorIcons"),
-		Control::get_icon("MiniDictionary","EditorIcons"),
-		Control::get_icon("MiniArray","EditorIcons"),
-		Control::get_icon("MiniRawArray","EditorIcons"),
-		Control::get_icon("MiniIntArray","EditorIcons"),
-		Control::get_icon("MiniFloatArray","EditorIcons"),
-		Control::get_icon("MiniStringArray","EditorIcons"),
-		Control::get_icon("MiniVector2Array","EditorIcons"),
-		Control::get_icon("MiniVector3Array","EditorIcons"),
-		Control::get_icon("MiniColorArray","EditorIcons")
+	Ref<Texture> type_icons[Variant::VARIANT_MAX] = {
+		Control::get_icon("MiniVariant", "EditorIcons"),
+		Control::get_icon("MiniBoolean", "EditorIcons"),
+		Control::get_icon("MiniInteger", "EditorIcons"),
+		Control::get_icon("MiniFloat", "EditorIcons"),
+		Control::get_icon("MiniString", "EditorIcons"),
+		Control::get_icon("MiniVector2", "EditorIcons"),
+		Control::get_icon("MiniRect2", "EditorIcons"),
+		Control::get_icon("MiniVector3", "EditorIcons"),
+		Control::get_icon("MiniTransform2D", "EditorIcons"),
+		Control::get_icon("MiniPlane", "EditorIcons"),
+		Control::get_icon("MiniQuat", "EditorIcons"),
+		Control::get_icon("MiniAabb", "EditorIcons"),
+		Control::get_icon("MiniBasis", "EditorIcons"),
+		Control::get_icon("MiniTransform", "EditorIcons"),
+		Control::get_icon("MiniColor", "EditorIcons"),
+		Control::get_icon("MiniImage", "EditorIcons"),
+		Control::get_icon("MiniPath", "EditorIcons"),
+		Control::get_icon("MiniRid", "EditorIcons"),
+		Control::get_icon("MiniObject", "EditorIcons"),
+		Control::get_icon("MiniInput", "EditorIcons"),
+		Control::get_icon("MiniDictionary", "EditorIcons"),
+		Control::get_icon("MiniArray", "EditorIcons"),
+		Control::get_icon("MiniRawArray", "EditorIcons"),
+		Control::get_icon("MiniIntArray", "EditorIcons"),
+		Control::get_icon("MiniFloatArray", "EditorIcons"),
+		Control::get_icon("MiniStringArray", "EditorIcons"),
+		Control::get_icon("MiniVector2Array", "EditorIcons"),
+		Control::get_icon("MiniVector3Array", "EditorIcons"),
+		Control::get_icon("MiniColorArray", "EditorIcons")
 	};
 
-
-
-	Ref<Texture> seq_port = Control::get_icon("VisualShaderPort","EditorIcons");
+	Ref<Texture> seq_port = Control::get_icon("VisualShaderPort", "EditorIcons");
 
 	List<int> ids;
-	script->get_node_list(edited_func,&ids);
-	StringName editor_icons="EditorIcons";
+	script->get_node_list(edited_func, &ids);
+	StringName editor_icons = "EditorIcons";
 
-	for(List<int>::Element *E=ids.front();E;E=E->next()) {
+	for (List<int>::Element *E = ids.front(); E; E = E->next()) {
 
-		if (p_only_id>=0 && p_only_id!=E->get())
+		if (p_only_id >= 0 && p_only_id != E->get())
 			continue;
 
-		Ref<VisualScriptNode> node = script->get_node(edited_func,E->get());
-		Vector2 pos = script->get_node_pos(edited_func,E->get());
+		Ref<VisualScriptNode> node = script->get_node(edited_func, E->get());
+		Vector2 pos = script->get_node_pos(edited_func, E->get());
 
-		GraphNode *gnode = memnew( GraphNode );
+		GraphNode *gnode = memnew(GraphNode);
 		gnode->set_title(node->get_caption());
-		if (error_line==E->get()) {
+		if (error_line == E->get()) {
 			gnode->set_overlay(GraphNode::OVERLAY_POSITION);
 		} else if (node->is_breakpoint()) {
 			gnode->set_overlay(GraphNode::OVERLAY_BREAKPOINT);
 		}
 
-		if (EditorSettings::get_singleton()->has("editors/visual_script/color_"+node->get_category())) {
-			gnode->set_modulate(EditorSettings::get_singleton()->get("editors/visual_script/color_"+node->get_category()));
+		if (EditorSettings::get_singleton()->has("editors/visual_script/color_" + node->get_category())) {
+			gnode->set_modulate(EditorSettings::get_singleton()->get("editors/visual_script/color_" + node->get_category()));
 		}
 
-
-
-		gnode->set_meta("__vnode",node);
+		gnode->set_meta("__vnode", node);
 		gnode->set_name(itos(E->get()));
-		gnode->connect("dragged",this,"_node_moved",varray(E->get()));
-		gnode->connect("close_request",this,"_remove_node",varray(E->get()),CONNECT_DEFERRED);
+		gnode->connect("dragged", this, "_node_moved", varray(E->get()));
+		gnode->connect("close_request", this, "_remove_node", varray(E->get()), CONNECT_DEFERRED);
 
-
-		if (E->get()!=script->get_function_node_id(edited_func)) {
+		if (E->get() != script->get_function_node_id(edited_func)) {
 			//function can't be erased
 			gnode->set_show_close_button(true);
 		}
 
-
 		if (node->cast_to<VisualScriptExpression>()) {
 
-			LineEdit *line_edit = memnew( LineEdit );
+			LineEdit *line_edit = memnew(LineEdit);
 			line_edit->set_text(node->get_text());
 			line_edit->set_expand_to_text_length(true);
-			line_edit->add_font_override("font",get_font("source","EditorFonts"));
+			line_edit->add_font_override("font", get_font("source", "EditorFonts"));
 			gnode->add_child(line_edit);
-			line_edit->connect("text_changed",this,"_expression_text_changed",varray(E->get()));
+			line_edit->connect("text_changed", this, "_expression_text_changed", varray(E->get()));
 		} else {
-			Label *text = memnew( Label );
+			Label *text = memnew(Label);
 			text->set_text(node->get_text());
 			gnode->add_child(text);
 		}
 
-
 		if (node->cast_to<VisualScriptComment>()) {
-			Ref<VisualScriptComment> vsc=node;
+			Ref<VisualScriptComment> vsc = node;
 			gnode->set_comment(true);
 			gnode->set_resizeable(true);
-			gnode->set_custom_minimum_size(vsc->get_size()*EDSCALE);
-			gnode->connect("resize_request",this,"_comment_node_resized",varray(E->get()));
-
+			gnode->set_custom_minimum_size(vsc->get_size() * EDSCALE);
+			gnode->connect("resize_request", this, "_comment_node_resized", varray(E->get()));
 		}
 
+		int slot_idx = 0;
 
-		int slot_idx=0;
-
-		bool single_seq_output = node->get_output_sequence_port_count()==1 && node->get_output_sequence_port_text(0)==String();
-		gnode->set_slot(0,node->has_input_sequence_port(),TYPE_SEQUENCE,Color(1,1,1,1),single_seq_output,TYPE_SEQUENCE,Color(1,1,1,1),seq_port,seq_port);
-		gnode->set_offset(pos*EDSCALE);
+		bool single_seq_output = node->get_output_sequence_port_count() == 1 && node->get_output_sequence_port_text(0) == String();
+		gnode->set_slot(0, node->has_input_sequence_port(), TYPE_SEQUENCE, Color(1, 1, 1, 1), single_seq_output, TYPE_SEQUENCE, Color(1, 1, 1, 1), seq_port, seq_port);
+		gnode->set_offset(pos * EDSCALE);
 		slot_idx++;
 
-
-		int mixed_seq_ports=0;
+		int mixed_seq_ports = 0;
 
 		if (!single_seq_output) {
 
 			if (node->has_mixed_input_and_sequence_ports()) {
-				mixed_seq_ports=node->get_output_sequence_port_count();
+				mixed_seq_ports = node->get_output_sequence_port_count();
 			} else {
-				for(int i=0;i<node->get_output_sequence_port_count();i++) {
+				for (int i = 0; i < node->get_output_sequence_port_count(); i++) {
 
-					Label *text2 = memnew( Label );
+					Label *text2 = memnew(Label);
 					text2->set_text(node->get_output_sequence_port_text(i));
 					text2->set_align(Label::ALIGN_RIGHT);
 					gnode->add_child(text2);
-					gnode->set_slot(slot_idx,false,0,Color(),true,TYPE_SEQUENCE,Color(1,1,1,1),seq_port,seq_port);
+					gnode->set_slot(slot_idx, false, 0, Color(), true, TYPE_SEQUENCE, Color(1, 1, 1, 1), seq_port, seq_port);
 					slot_idx++;
 				}
 			}
 		}
 
-		for(int i=0;i<MAX(node->get_output_value_port_count(),MAX(mixed_seq_ports,node->get_input_value_port_count()));i++) {
+		for (int i = 0; i < MAX(node->get_output_value_port_count(), MAX(mixed_seq_ports, node->get_input_value_port_count())); i++) {
 
-			bool left_ok=false;
-			Variant::Type left_type=Variant::NIL;
+			bool left_ok = false;
+			Variant::Type left_type = Variant::NIL;
 			String left_name;
 
-
-
-			if (i<node->get_input_value_port_count()) {
+			if (i < node->get_input_value_port_count()) {
 				PropertyInfo pi = node->get_input_value_port_info(i);
-				left_ok=true;
-				left_type=pi.type;
-				left_name=pi.name;
+				left_ok = true;
+				left_type = pi.type;
+				left_name = pi.name;
 			}
 
-			bool right_ok=false;
-			Variant::Type right_type=Variant::NIL;
+			bool right_ok = false;
+			Variant::Type right_type = Variant::NIL;
 			String right_name;
 
-			if (i>=mixed_seq_ports && i<node->get_output_value_port_count()+mixed_seq_ports) {
-				PropertyInfo pi = node->get_output_value_port_info(i-mixed_seq_ports);
-				right_ok=true;
-				right_type=pi.type;
-				right_name=pi.name;
+			if (i >= mixed_seq_ports && i < node->get_output_value_port_count() + mixed_seq_ports) {
+				PropertyInfo pi = node->get_output_value_port_info(i - mixed_seq_ports);
+				right_ok = true;
+				right_type = pi.type;
+				right_name = pi.name;
 			}
 
-			HBoxContainer *hbc = memnew( HBoxContainer);
+			HBoxContainer *hbc = memnew(HBoxContainer);
 
 			if (left_ok) {
 
 				Ref<Texture> t;
-				if (left_type>=0 && left_type<Variant::VARIANT_MAX) {
-					t=type_icons[left_type];
+				if (left_type >= 0 && left_type < Variant::VARIANT_MAX) {
+					t = type_icons[left_type];
 				}
 				if (t.is_valid()) {
 					TextureRect *tf = memnew(TextureRect);
@@ -627,51 +591,51 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 
 				hbc->add_child(memnew(Label(left_name)));
 
-				if (left_type!=Variant::NIL && !script->is_input_value_port_connected(edited_func,E->get(),i)) {
+				if (left_type != Variant::NIL && !script->is_input_value_port_connected(edited_func, E->get(), i)) {
 
 					PropertyInfo pi = node->get_input_value_port_info(i);
-					Button *button = memnew( Button );
+					Button *button = memnew(Button);
 					Variant value = node->get_default_input_value(i);
-					if (value.get_type()!=left_type) {
+					if (value.get_type() != left_type) {
 						//different type? for now convert
 						//not the same, reconvert
 						Variant::CallError ce;
-						const Variant *existingp=&value;
-						value = Variant::construct(left_type,&existingp,1,ce,false);
+						const Variant *existingp = &value;
+						value = Variant::construct(left_type, &existingp, 1, ce, false);
 					}
 
-					if (left_type==Variant::COLOR) {
-						button->set_custom_minimum_size(Size2(30,0)*EDSCALE);
-						button->connect("draw",this,"_draw_color_over_button",varray(button,value));
-					} else if (left_type==Variant::OBJECT && Ref<Resource>(value).is_valid()) {
+					if (left_type == Variant::COLOR) {
+						button->set_custom_minimum_size(Size2(30, 0) * EDSCALE);
+						button->connect("draw", this, "_draw_color_over_button", varray(button, value));
+					} else if (left_type == Variant::OBJECT && Ref<Resource>(value).is_valid()) {
 
 						Ref<Resource> res = value;
 						Array arr;
 						arr.push_back(button->get_instance_ID());
 						arr.push_back(String(value));
-						EditorResourcePreview::get_singleton()->queue_edited_resource_preview(res,this,"_button_resource_previewed",arr);
+						EditorResourcePreview::get_singleton()->queue_edited_resource_preview(res, this, "_button_resource_previewed", arr);
 
-					} else if (pi.type==Variant::INT && pi.hint==PROPERTY_HINT_ENUM){
+					} else if (pi.type == Variant::INT && pi.hint == PROPERTY_HINT_ENUM) {
 
-						button->set_text(pi.hint_string.get_slice(",",value));
+						button->set_text(pi.hint_string.get_slice(",", value));
 					} else {
 
 						button->set_text(value);
 					}
-					button->connect("pressed",this,"_default_value_edited",varray(button,E->get(),i));
+					button->connect("pressed", this, "_default_value_edited", varray(button, E->get(), i));
 					hbc->add_child(button);
 				}
 			} else {
 				Control *c = memnew(Control);
-				c->set_custom_minimum_size(Size2(10,0)*EDSCALE);
+				c->set_custom_minimum_size(Size2(10, 0) * EDSCALE);
 				hbc->add_child(c);
 			}
 
 			hbc->add_spacer();
 
-			if (i<mixed_seq_ports) {
+			if (i < mixed_seq_ports) {
 
-				Label *text2 = memnew( Label );
+				Label *text2 = memnew(Label);
 				text2->set_text(node->get_output_sequence_port_text(i));
 				text2->set_align(Label::ALIGN_RIGHT);
 				hbc->add_child(text2);
@@ -682,8 +646,8 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 				hbc->add_child(memnew(Label(right_name)));
 
 				Ref<Texture> t;
-				if (right_type>=0 && right_type<Variant::VARIANT_MAX) {
-					t=type_icons[right_type];
+				if (right_type >= 0 && right_type < Variant::VARIANT_MAX) {
+					t = type_icons[right_type];
 				}
 				if (t.is_valid()) {
 					TextureRect *tf = memnew(TextureRect);
@@ -691,15 +655,14 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 					tf->set_stretch_mode(TextureRect::STRETCH_KEEP_CENTERED);
 					hbc->add_child(tf);
 				}
-
 			}
 
 			gnode->add_child(hbc);
 
-			if (i<mixed_seq_ports) {
-				gnode->set_slot(slot_idx,left_ok,left_type,_color_from_type(left_type),true,TYPE_SEQUENCE,Color(1,1,1,1),Ref<Texture>(),seq_port);
+			if (i < mixed_seq_ports) {
+				gnode->set_slot(slot_idx, left_ok, left_type, _color_from_type(left_type), true, TYPE_SEQUENCE, Color(1, 1, 1, 1), Ref<Texture>(), seq_port);
 			} else {
-				gnode->set_slot(slot_idx,left_ok,left_type,_color_from_type(left_type),right_ok,right_type,_color_from_type(right_type));
+				gnode->set_slot(slot_idx, left_ok, left_type, _color_from_type(left_type), right_ok, right_type, _color_from_type(right_type));
 			}
 
 			slot_idx++;
@@ -708,137 +671,134 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 		graph->add_child(gnode);
 
 		if (gnode->is_comment()) {
-			graph->move_child(gnode,0);
+			graph->move_child(gnode, 0);
 		}
 	}
 
 	_update_graph_connections();
-	graph->call_deferred("set_scroll_ofs",script->get_function_scroll(edited_func)*EDSCALE); //may need to adapt a bit, let it do so
-	updating_graph=false;
-
+	graph->call_deferred("set_scroll_ofs", script->get_function_scroll(edited_func) * EDSCALE); //may need to adapt a bit, let it do so
+	updating_graph = false;
 }
 
 void VisualScriptEditor::_update_members() {
 
-
-	updating_members=true;
+	updating_members = true;
 
 	members->clear();
 	TreeItem *root = members->create_item();
 
 	TreeItem *functions = members->create_item(root);
-	functions->set_selectable(0,false);
-	functions->set_text(0,TTR("Functions:"));
-	functions->add_button(0,Control::get_icon("Override","EditorIcons"),1);
-	functions->add_button(0,Control::get_icon("Add","EditorIcons"),0);
-	functions->set_custom_bg_color(0,Control::get_color("prop_section","Editor"));
+	functions->set_selectable(0, false);
+	functions->set_text(0, TTR("Functions:"));
+	functions->add_button(0, Control::get_icon("Override", "EditorIcons"), 1);
+	functions->add_button(0, Control::get_icon("Add", "EditorIcons"), 0);
+	functions->set_custom_bg_color(0, Control::get_color("prop_section", "Editor"));
 
 	List<StringName> func_names;
 	script->get_function_list(&func_names);
-	for (List<StringName>::Element *E=func_names.front();E;E=E->next()) {
-		TreeItem *ti = members->create_item(functions)		;
-		ti->set_text(0,E->get());
-		ti->set_selectable(0,true);
-		ti->set_editable(0,true);
+	for (List<StringName>::Element *E = func_names.front(); E; E = E->next()) {
+		TreeItem *ti = members->create_item(functions);
+		ti->set_text(0, E->get());
+		ti->set_selectable(0, true);
+		ti->set_editable(0, true);
 		//ti->add_button(0,Control::get_icon("Edit","EditorIcons"),0); function arguments are in the node now
-		ti->add_button(0,Control::get_icon("Del","EditorIcons"),1);
-		ti->set_metadata(0,E->get());
-		if (E->get()==edited_func) {
-			ti->set_custom_bg_color(0,get_color("prop_category","Editor"));
-			ti->set_custom_color(0,Color(1,1,1,1));
+		ti->add_button(0, Control::get_icon("Del", "EditorIcons"), 1);
+		ti->set_metadata(0, E->get());
+		if (E->get() == edited_func) {
+			ti->set_custom_bg_color(0, get_color("prop_category", "Editor"));
+			ti->set_custom_color(0, Color(1, 1, 1, 1));
 		}
-		if (selected==E->get())
+		if (selected == E->get())
 			ti->select(0);
 	}
 
 	TreeItem *variables = members->create_item(root);
-	variables->set_selectable(0,false);
-	variables->set_text(0,TTR("Variables:"));
-	variables->add_button(0,Control::get_icon("Add","EditorIcons"));
-	variables->set_custom_bg_color(0,Control::get_color("prop_section","Editor"));
-
-	Ref<Texture> type_icons[Variant::VARIANT_MAX]={
-		Control::get_icon("MiniVariant","EditorIcons"),
-		Control::get_icon("MiniBoolean","EditorIcons"),
-		Control::get_icon("MiniInteger","EditorIcons"),
-		Control::get_icon("MiniFloat","EditorIcons"),
-		Control::get_icon("MiniString","EditorIcons"),
-		Control::get_icon("MiniVector2","EditorIcons"),
-		Control::get_icon("MiniRect2","EditorIcons"),
-		Control::get_icon("MiniVector3","EditorIcons"),
-		Control::get_icon("MiniMatrix32","EditorIcons"),
-		Control::get_icon("MiniPlane","EditorIcons"),
-		Control::get_icon("MiniQuat","EditorIcons"),
-		Control::get_icon("MiniAabb","EditorIcons"),
-		Control::get_icon("MiniMatrix3","EditorIcons"),
-		Control::get_icon("MiniTransform","EditorIcons"),
-		Control::get_icon("MiniColor","EditorIcons"),
-		Control::get_icon("MiniImage","EditorIcons"),
-		Control::get_icon("MiniPath","EditorIcons"),
-		Control::get_icon("MiniRid","EditorIcons"),
-		Control::get_icon("MiniObject","EditorIcons"),
-		Control::get_icon("MiniInput","EditorIcons"),
-		Control::get_icon("MiniDictionary","EditorIcons"),
-		Control::get_icon("MiniArray","EditorIcons"),
-		Control::get_icon("MiniRawArray","EditorIcons"),
-		Control::get_icon("MiniIntArray","EditorIcons"),
-		Control::get_icon("MiniFloatArray","EditorIcons"),
-		Control::get_icon("MiniStringArray","EditorIcons"),
-		Control::get_icon("MiniVector2Array","EditorIcons"),
-		Control::get_icon("MiniVector3Array","EditorIcons"),
-		Control::get_icon("MiniColorArray","EditorIcons")
+	variables->set_selectable(0, false);
+	variables->set_text(0, TTR("Variables:"));
+	variables->add_button(0, Control::get_icon("Add", "EditorIcons"));
+	variables->set_custom_bg_color(0, Control::get_color("prop_section", "Editor"));
+
+	Ref<Texture> type_icons[Variant::VARIANT_MAX] = {
+		Control::get_icon("MiniVariant", "EditorIcons"),
+		Control::get_icon("MiniBoolean", "EditorIcons"),
+		Control::get_icon("MiniInteger", "EditorIcons"),
+		Control::get_icon("MiniFloat", "EditorIcons"),
+		Control::get_icon("MiniString", "EditorIcons"),
+		Control::get_icon("MiniVector2", "EditorIcons"),
+		Control::get_icon("MiniRect2", "EditorIcons"),
+		Control::get_icon("MiniVector3", "EditorIcons"),
+		Control::get_icon("MiniMatrix32", "EditorIcons"),
+		Control::get_icon("MiniPlane", "EditorIcons"),
+		Control::get_icon("MiniQuat", "EditorIcons"),
+		Control::get_icon("MiniAabb", "EditorIcons"),
+		Control::get_icon("MiniMatrix3", "EditorIcons"),
+		Control::get_icon("MiniTransform", "EditorIcons"),
+		Control::get_icon("MiniColor", "EditorIcons"),
+		Control::get_icon("MiniImage", "EditorIcons"),
+		Control::get_icon("MiniPath", "EditorIcons"),
+		Control::get_icon("MiniRid", "EditorIcons"),
+		Control::get_icon("MiniObject", "EditorIcons"),
+		Control::get_icon("MiniInput", "EditorIcons"),
+		Control::get_icon("MiniDictionary", "EditorIcons"),
+		Control::get_icon("MiniArray", "EditorIcons"),
+		Control::get_icon("MiniRawArray", "EditorIcons"),
+		Control::get_icon("MiniIntArray", "EditorIcons"),
+		Control::get_icon("MiniFloatArray", "EditorIcons"),
+		Control::get_icon("MiniStringArray", "EditorIcons"),
+		Control::get_icon("MiniVector2Array", "EditorIcons"),
+		Control::get_icon("MiniVector3Array", "EditorIcons"),
+		Control::get_icon("MiniColorArray", "EditorIcons")
 	};
 
 	List<StringName> var_names;
 	script->get_variable_list(&var_names);
-	for (List<StringName>::Element *E=var_names.front();E;E=E->next()) {
+	for (List<StringName>::Element *E = var_names.front(); E; E = E->next()) {
 		TreeItem *ti = members->create_item(variables);
 
-		ti->set_text(0,E->get());
+		ti->set_text(0, E->get());
 		Variant var = script->get_variable_default_value(E->get());
-		ti->set_suffix(0,"="+String(var));
-		ti->set_icon(0,type_icons[script->get_variable_info(E->get()).type]);
-
-		ti->set_selectable(0,true);
-		ti->set_editable(0,true);
-		ti->add_button(0,Control::get_icon("Edit","EditorIcons"),0);
-		ti->add_button(0,Control::get_icon("Del","EditorIcons"),1);
-		ti->set_metadata(0,E->get());
-		if (selected==E->get())
+		ti->set_suffix(0, "=" + String(var));
+		ti->set_icon(0, type_icons[script->get_variable_info(E->get()).type]);
+
+		ti->set_selectable(0, true);
+		ti->set_editable(0, true);
+		ti->add_button(0, Control::get_icon("Edit", "EditorIcons"), 0);
+		ti->add_button(0, Control::get_icon("Del", "EditorIcons"), 1);
+		ti->set_metadata(0, E->get());
+		if (selected == E->get())
 			ti->select(0);
 	}
 
 	TreeItem *_signals = members->create_item(root);
-	_signals->set_selectable(0,false);
-	_signals->set_text(0,TTR("Signals:"));
-	_signals->add_button(0,Control::get_icon("Add","EditorIcons"));
-	_signals->set_custom_bg_color(0,Control::get_color("prop_section","Editor"));
+	_signals->set_selectable(0, false);
+	_signals->set_text(0, TTR("Signals:"));
+	_signals->add_button(0, Control::get_icon("Add", "EditorIcons"));
+	_signals->set_custom_bg_color(0, Control::get_color("prop_section", "Editor"));
 
 	List<StringName> signal_names;
 	script->get_custom_signal_list(&signal_names);
-	for (List<StringName>::Element *E=signal_names.front();E;E=E->next()) {
+	for (List<StringName>::Element *E = signal_names.front(); E; E = E->next()) {
 		TreeItem *ti = members->create_item(_signals);
-		ti->set_text(0,E->get());
-		ti->set_selectable(0,true);
-		ti->set_editable(0,true);
-		ti->add_button(0,Control::get_icon("Edit","EditorIcons"),0);
-		ti->add_button(0,Control::get_icon("Del","EditorIcons"),1);
-		ti->set_metadata(0,E->get());
-		if (selected==E->get())
+		ti->set_text(0, E->get());
+		ti->set_selectable(0, true);
+		ti->set_editable(0, true);
+		ti->add_button(0, Control::get_icon("Edit", "EditorIcons"), 0);
+		ti->add_button(0, Control::get_icon("Del", "EditorIcons"), 1);
+		ti->set_metadata(0, E->get());
+		if (selected == E->get())
 			ti->select(0);
 	}
 
-	String base_type=script->get_instance_base_type();
-	String icon_type=base_type;
-	if (!Control::has_icon(base_type,"EditorIcons")) {
-		icon_type="Object";
+	String base_type = script->get_instance_base_type();
+	String icon_type = base_type;
+	if (!Control::has_icon(base_type, "EditorIcons")) {
+		icon_type = "Object";
 	}
 
 	base_type_select->set_text(base_type);
-	base_type_select->set_icon(Control::get_icon(icon_type,"EditorIcons"));
-
-	updating_members=false;
+	base_type_select->set_icon(Control::get_icon(icon_type, "EditorIcons"));
 
+	updating_members = false;
 }
 
 void VisualScriptEditor::_member_selected() {
@@ -846,30 +806,24 @@ void VisualScriptEditor::_member_selected() {
 	if (updating_members)
 		return;
 
-	TreeItem *ti=members->get_selected();
+	TreeItem *ti = members->get_selected();
 	ERR_FAIL_COND(!ti);
 
-
-	selected=ti->get_metadata(0);
+	selected = ti->get_metadata(0);
 	//print_line("selected: "+String(selected));
 
+	if (ti->get_parent() == members->get_root()->get_children()) {
 
-	if (ti->get_parent()==members->get_root()->get_children()) {
-
-		if (edited_func!=selected) {
+		if (edited_func != selected) {
 
-			revert_on_drag=edited_func;
-			edited_func=selected;
+			revert_on_drag = edited_func;
+			edited_func = selected;
 			_update_members();
 			_update_graph();
 		}
 
 		return; //or crash because it will become invalid
-
 	}
-
-
-
 }
 
 void VisualScriptEditor::_member_edited() {
@@ -877,78 +831,75 @@ void VisualScriptEditor::_member_edited() {
 	if (updating_members)
 		return;
 
-	TreeItem *ti=members->get_edited();
+	TreeItem *ti = members->get_edited();
 	ERR_FAIL_COND(!ti);
 
 	String name = ti->get_metadata(0);
 	String new_name = ti->get_text(0);
 
-	if (name==new_name)
+	if (name == new_name)
 		return;
 
 	if (!new_name.is_valid_identifier()) {
 
-		EditorNode::get_singleton()->show_warning(TTR("Name is not a valid identifier:")+" "+new_name);
-		updating_members=true;
-		ti->set_text(0,name);
-		updating_members=false;
+		EditorNode::get_singleton()->show_warning(TTR("Name is not a valid identifier:") + " " + new_name);
+		updating_members = true;
+		ti->set_text(0, name);
+		updating_members = false;
 		return;
-
 	}
 
 	if (script->has_function(new_name) || script->has_variable(new_name) || script->has_custom_signal(new_name)) {
 
-		EditorNode::get_singleton()->show_warning(TTR("Name already in use by another func/var/signal:")+" "+new_name);
-		updating_members=true;
-		ti->set_text(0,name);
-		updating_members=false;
+		EditorNode::get_singleton()->show_warning(TTR("Name already in use by another func/var/signal:") + " " + new_name);
+		updating_members = true;
+		ti->set_text(0, name);
+		updating_members = false;
 		return;
 	}
 
-	TreeItem *root=members->get_root();
+	TreeItem *root = members->get_root();
 
-	if (ti->get_parent()==root->get_children()) {
+	if (ti->get_parent() == root->get_children()) {
 
-		if (edited_func==selected) {
-			edited_func=new_name;
+		if (edited_func == selected) {
+			edited_func = new_name;
 		}
-		selected=new_name;
-
+		selected = new_name;
 
 		_update_graph();
 
 		undo_redo->create_action(TTR("Rename Function"));
-		undo_redo->add_do_method(script.ptr(),"rename_function",name,new_name);
-		undo_redo->add_undo_method(script.ptr(),"rename_function",new_name,name);
-		undo_redo->add_do_method(this,"_update_members");
-		undo_redo->add_undo_method(this,"_update_members");
+		undo_redo->add_do_method(script.ptr(), "rename_function", name, new_name);
+		undo_redo->add_undo_method(script.ptr(), "rename_function", new_name, name);
+		undo_redo->add_do_method(this, "_update_members");
+		undo_redo->add_undo_method(this, "_update_members");
 		undo_redo->commit_action();
 
 		return; //or crash because it will become invalid
-
 	}
 
-	if (ti->get_parent()==root->get_children()->get_next()) {
+	if (ti->get_parent() == root->get_children()->get_next()) {
 
-		selected=new_name;
+		selected = new_name;
 		undo_redo->create_action(TTR("Rename Variable"));
-		undo_redo->add_do_method(script.ptr(),"rename_variable",name,new_name);
-		undo_redo->add_undo_method(script.ptr(),"rename_variable",new_name,name);
-		undo_redo->add_do_method(this,"_update_members");
-		undo_redo->add_undo_method(this,"_update_members");
+		undo_redo->add_do_method(script.ptr(), "rename_variable", name, new_name);
+		undo_redo->add_undo_method(script.ptr(), "rename_variable", new_name, name);
+		undo_redo->add_do_method(this, "_update_members");
+		undo_redo->add_undo_method(this, "_update_members");
 		undo_redo->commit_action();
 
 		return; //or crash because it will become invalid
 	}
 
-	if (ti->get_parent()==root->get_children()->get_next()->get_next()) {
+	if (ti->get_parent() == root->get_children()->get_next()->get_next()) {
 
-		selected=new_name;
+		selected = new_name;
 		undo_redo->create_action(TTR("Rename Signal"));
-		undo_redo->add_do_method(script.ptr(),"rename_custom_signal",name,new_name);
-		undo_redo->add_undo_method(script.ptr(),"rename_custom_signal",new_name,name);
-		undo_redo->add_do_method(this,"_update_members");
-		undo_redo->add_undo_method(this,"_update_members");
+		undo_redo->add_do_method(script.ptr(), "rename_custom_signal", name, new_name);
+		undo_redo->add_undo_method(script.ptr(), "rename_custom_signal", new_name, name);
+		undo_redo->add_do_method(this, "_update_members");
+		undo_redo->add_undo_method(this, "_update_members");
 		undo_redo->commit_action();
 
 		return; //or crash because it will become invalid
@@ -961,137 +912,131 @@ void VisualScriptEditor::_override_pressed(int p_id) {
 
 	ERR_FAIL_COND(!virtuals_in_menu.has(p_id));
 
-	VirtualInMenu vim=virtuals_in_menu[p_id];
+	VirtualInMenu vim = virtuals_in_menu[p_id];
 
 	String name = _validate_name(vim.name);
-	selected=name;
-	edited_func=selected;
+	selected = name;
+	edited_func = selected;
 	Ref<VisualScriptFunction> func_node;
 	func_node.instance();
 	func_node->set_name(vim.name);
 
 	undo_redo->create_action(TTR("Add Function"));
-	undo_redo->add_do_method(script.ptr(),"add_function",name);
-	for(int i=0;i<vim.args.size();i++) {
-		func_node->add_argument(vim.args[i].first,vim.args[i].second);
+	undo_redo->add_do_method(script.ptr(), "add_function", name);
+	for (int i = 0; i < vim.args.size(); i++) {
+		func_node->add_argument(vim.args[i].first, vim.args[i].second);
 	}
 
-
-	undo_redo->add_do_method(script.ptr(),"add_node",name,script->get_available_id(),func_node);
-	if (vim.ret!=Variant::NIL || vim.ret_variant) {
+	undo_redo->add_do_method(script.ptr(), "add_node", name, script->get_available_id(), func_node);
+	if (vim.ret != Variant::NIL || vim.ret_variant) {
 		Ref<VisualScriptReturn> ret_node;
 		ret_node.instance();
 		ret_node->set_return_type(vim.ret);
 		ret_node->set_enable_return_value(true);
 		ret_node->set_name(vim.name);
-		undo_redo->add_do_method(script.ptr(),"add_node",name,script->get_available_id()+1,ret_node,Vector2(500,0));
-
+		undo_redo->add_do_method(script.ptr(), "add_node", name, script->get_available_id() + 1, ret_node, Vector2(500, 0));
 	}
 
-	undo_redo->add_undo_method(script.ptr(),"remove_function",name);
-	undo_redo->add_do_method(this,"_update_members");
-	undo_redo->add_undo_method(this,"_update_members");
-	undo_redo->add_do_method(this,"_update_graph");
-	undo_redo->add_undo_method(this,"_update_graph");
+	undo_redo->add_undo_method(script.ptr(), "remove_function", name);
+	undo_redo->add_do_method(this, "_update_members");
+	undo_redo->add_undo_method(this, "_update_members");
+	undo_redo->add_do_method(this, "_update_graph");
+	undo_redo->add_undo_method(this, "_update_graph");
 
 	undo_redo->commit_action();
 
-
 	_update_graph();
 }
 
 void VisualScriptEditor::_member_button(Object *p_item, int p_column, int p_button) {
 
-	TreeItem *ti=p_item->cast_to<TreeItem>();
+	TreeItem *ti = p_item->cast_to<TreeItem>();
 
-	TreeItem *root=members->get_root();
+	TreeItem *root = members->get_root();
 
-	if (ti->get_parent()==root) {
+	if (ti->get_parent() == root) {
 		//main buttons
-		if (ti==root->get_children()) {
+		if (ti == root->get_children()) {
 			//add function, this one uses menu
 
-			if (p_button==1) {
+			if (p_button == 1) {
 				new_function_menu->clear();
-				new_function_menu->set_size(Size2(0,0));
-				int idx=0;
+				new_function_menu->set_size(Size2(0, 0));
+				int idx = 0;
 
 				virtuals_in_menu.clear();
 
 				List<MethodInfo> mi;
-				ClassDB::get_method_list(script->get_instance_base_type(),&mi);
-				for (List<MethodInfo>::Element *E=mi.front();E;E=E->next()) {
-					MethodInfo mi=E->get();
-					if (mi.flags&METHOD_FLAG_VIRTUAL) {
+				ClassDB::get_method_list(script->get_instance_base_type(), &mi);
+				for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) {
+					MethodInfo mi = E->get();
+					if (mi.flags & METHOD_FLAG_VIRTUAL) {
 
 						VirtualInMenu vim;
-						vim.name=mi.name;
-						vim.ret=mi.return_val.type;
-						if (mi.return_val.name!=String())
-							vim.ret_variant=true;
+						vim.name = mi.name;
+						vim.ret = mi.return_val.type;
+						if (mi.return_val.name != String())
+							vim.ret_variant = true;
 						else
-							vim.ret_variant=false;
+							vim.ret_variant = false;
 
 						String desc;
 
-						if (mi.return_val.type==Variant::NIL)
-							desc="var";
+						if (mi.return_val.type == Variant::NIL)
+							desc = "var";
 						else
-							desc=Variant::get_type_name(mi.return_val.type);
-						desc+=" "+mi.name+" ( ";
-
+							desc = Variant::get_type_name(mi.return_val.type);
+						desc += " " + mi.name + " ( ";
 
-						for(int i=0;i<mi.arguments.size();i++) {
+						for (int i = 0; i < mi.arguments.size(); i++) {
 
-							if (i>0)
-								desc+=", ";
+							if (i > 0)
+								desc += ", ";
 
-							if (mi.arguments[i].type==Variant::NIL)
-								desc+="var ";
+							if (mi.arguments[i].type == Variant::NIL)
+								desc += "var ";
 							else
-								desc+=Variant::get_type_name(mi.arguments[i].type)+" ";
+								desc += Variant::get_type_name(mi.arguments[i].type) + " ";
 
-							desc+=mi.arguments[i].name;
-
-							Pair<Variant::Type,String> p;
-							p.first=mi.arguments[i].type;
-							p.second=mi.arguments[i].name;
-							vim.args.push_back( p );
+							desc += mi.arguments[i].name;
 
+							Pair<Variant::Type, String> p;
+							p.first = mi.arguments[i].type;
+							p.second = mi.arguments[i].name;
+							vim.args.push_back(p);
 						}
 
-						desc+=" )";
+						desc += " )";
 
-						virtuals_in_menu[idx]=vim;
+						virtuals_in_menu[idx] = vim;
 
-						new_function_menu->add_item(desc,idx);
+						new_function_menu->add_item(desc, idx);
 						idx++;
 					}
 				}
 
 				Rect2 pos = members->get_item_rect(ti);
-				new_function_menu->set_pos(members->get_global_pos()+pos.pos+Vector2(0,pos.size.y));
+				new_function_menu->set_pos(members->get_global_pos() + pos.pos + Vector2(0, pos.size.y));
 				new_function_menu->popup();
 				return;
-			} else if (p_button==0) {
-
+			} else if (p_button == 0) {
 
 				String name = _validate_name("new_function");
-				selected=name;
-				edited_func=selected;
+				selected = name;
+				edited_func = selected;
 
 				Ref<VisualScriptFunction> func_node;
 				func_node.instance();
 				func_node->set_name(name);
 
 				undo_redo->create_action(TTR("Add Function"));
-				undo_redo->add_do_method(script.ptr(),"add_function",name);
-				undo_redo->add_do_method(script.ptr(),"add_node",name,script->get_available_id(),func_node);
-				undo_redo->add_undo_method(script.ptr(),"remove_function",name);
-				undo_redo->add_do_method(this,"_update_members");
-				undo_redo->add_undo_method(this,"_update_members");
-				undo_redo->add_do_method(this,"_update_graph");
-				undo_redo->add_undo_method(this,"_update_graph");
+				undo_redo->add_do_method(script.ptr(), "add_function", name);
+				undo_redo->add_do_method(script.ptr(), "add_node", name, script->get_available_id(), func_node);
+				undo_redo->add_undo_method(script.ptr(), "remove_function", name);
+				undo_redo->add_do_method(this, "_update_members");
+				undo_redo->add_undo_method(this, "_update_members");
+				undo_redo->add_do_method(this, "_update_graph");
+				undo_redo->add_undo_method(this, "_update_graph");
 
 				undo_redo->commit_action();
 
@@ -1099,70 +1044,67 @@ void VisualScriptEditor::_member_button(Object *p_item, int p_column, int p_butt
 			}
 
 			return; //or crash because it will become invalid
-
 		}
 
-		if (ti==root->get_children()->get_next()) {
+		if (ti == root->get_children()->get_next()) {
 			//add variable
 			String name = _validate_name("new_variable");
-			selected=name;
+			selected = name;
 
 			undo_redo->create_action(TTR("Add Variable"));
-			undo_redo->add_do_method(script.ptr(),"add_variable",name);
-			undo_redo->add_undo_method(script.ptr(),"remove_variable",name);
-			undo_redo->add_do_method(this,"_update_members");
-			undo_redo->add_undo_method(this,"_update_members");
+			undo_redo->add_do_method(script.ptr(), "add_variable", name);
+			undo_redo->add_undo_method(script.ptr(), "remove_variable", name);
+			undo_redo->add_do_method(this, "_update_members");
+			undo_redo->add_undo_method(this, "_update_members");
 			undo_redo->commit_action();
 			return; //or crash because it will become invalid
-
 		}
 
-		if (ti==root->get_children()->get_next()->get_next()) {
+		if (ti == root->get_children()->get_next()->get_next()) {
 			//add variable
 			String name = _validate_name("new_signal");
-			selected=name;
+			selected = name;
 
 			undo_redo->create_action(TTR("Add Signal"));
-			undo_redo->add_do_method(script.ptr(),"add_custom_signal",name);
-			undo_redo->add_undo_method(script.ptr(),"remove_custom_signal",name);
-			undo_redo->add_do_method(this,"_update_members");
-			undo_redo->add_undo_method(this,"_update_members");
+			undo_redo->add_do_method(script.ptr(), "add_custom_signal", name);
+			undo_redo->add_undo_method(script.ptr(), "remove_custom_signal", name);
+			undo_redo->add_do_method(this, "_update_members");
+			undo_redo->add_undo_method(this, "_update_members");
 			undo_redo->commit_action();
 			return; //or crash because it will become invalid
-
 		}
 
 	} else {
 
-		if (ti->get_parent()==root->get_children()) {
+		if (ti->get_parent() == root->get_children()) {
 			//edit/remove function
 			String name = ti->get_metadata(0);
 
-			if (p_button==1) {
+			if (p_button == 1) {
 				//delete the function
 				undo_redo->create_action(TTR("Remove Function"));
-				undo_redo->add_do_method(script.ptr(),"remove_function",name);
-				undo_redo->add_undo_method(script.ptr(),"add_function",name);
+				undo_redo->add_do_method(script.ptr(), "remove_function", name);
+				undo_redo->add_undo_method(script.ptr(), "add_function", name);
 				List<int> nodes;
-				script->get_node_list(name,&nodes);
-				for (List<int>::Element *E=nodes.front();E;E=E->next()) {
-					undo_redo->add_undo_method(script.ptr(),"add_node",name,E->get(),script->get_node(name,E->get()),script->get_node_pos(name,E->get()));
+				script->get_node_list(name, &nodes);
+				for (List<int>::Element *E = nodes.front(); E; E = E->next()) {
+					undo_redo->add_undo_method(script.ptr(), "add_node", name, E->get(), script->get_node(name, E->get()), script->get_node_pos(name, E->get()));
 				}
 
 				List<VisualScript::SequenceConnection> seq_connections;
 
-				script->get_sequence_connection_list(name,&seq_connections);
+				script->get_sequence_connection_list(name, &seq_connections);
 
-				for (List<VisualScript::SequenceConnection>::Element *E=seq_connections.front();E;E=E->next()) {
-					undo_redo->add_undo_method(script.ptr(),"sequence_connect",name,E->get().from_node,E->get().from_output,E->get().to_node);
+				for (List<VisualScript::SequenceConnection>::Element *E = seq_connections.front(); E; E = E->next()) {
+					undo_redo->add_undo_method(script.ptr(), "sequence_connect", name, E->get().from_node, E->get().from_output, E->get().to_node);
 				}
 
 				List<VisualScript::DataConnection> data_connections;
 
-				script->get_data_connection_list(name,&data_connections);
+				script->get_data_connection_list(name, &data_connections);
 
-				for (List<VisualScript::DataConnection>::Element *E=data_connections.front();E;E=E->next()) {
-					undo_redo->add_undo_method(script.ptr(),"data_connect",name,E->get().from_node,E->get().from_port,E->get().to_node,E->get().to_port);
+				for (List<VisualScript::DataConnection>::Element *E = data_connections.front(); E; E = E->next()) {
+					undo_redo->add_undo_method(script.ptr(), "data_connect", name, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
 				}
 
 				/*
@@ -1170,98 +1112,89 @@ void VisualScriptEditor::_member_button(Object *p_item, int p_column, int p_butt
 					undo_redo->add_undo_method(script.ptr(),"function_add_argument",name,script->function_get_argument_name(name,i),script->function_get_argument_type(name,i));
 				}
 				*/
-				undo_redo->add_do_method(this,"_update_members");
-				undo_redo->add_undo_method(this,"_update_members");
-				undo_redo->add_do_method(this,"_update_graph");
-				undo_redo->add_undo_method(this,"_update_graph");
+				undo_redo->add_do_method(this, "_update_members");
+				undo_redo->add_undo_method(this, "_update_members");
+				undo_redo->add_do_method(this, "_update_graph");
+				undo_redo->add_undo_method(this, "_update_graph");
 				undo_redo->commit_action();
 
-			} else if (p_button==0) {
-
+			} else if (p_button == 0) {
 			}
 			return; //or crash because it will become invalid
-
 		}
 
-		if (ti->get_parent()==root->get_children()->get_next()) {
+		if (ti->get_parent() == root->get_children()->get_next()) {
 			//edit/remove variable
 
 			String name = ti->get_metadata(0);
 
-			if (p_button==1) {
-
+			if (p_button == 1) {
 
 				undo_redo->create_action(TTR("Remove Variable"));
-				undo_redo->add_do_method(script.ptr(),"remove_variable",name);
-				undo_redo->add_undo_method(script.ptr(),"add_variable",name,script->get_variable_default_value(name));
-				undo_redo->add_undo_method(script.ptr(),"set_variable_info",name,script->call("get_variable_info",name)); //return as dict
-				undo_redo->add_do_method(this,"_update_members");
-				undo_redo->add_undo_method(this,"_update_members");
+				undo_redo->add_do_method(script.ptr(), "remove_variable", name);
+				undo_redo->add_undo_method(script.ptr(), "add_variable", name, script->get_variable_default_value(name));
+				undo_redo->add_undo_method(script.ptr(), "set_variable_info", name, script->call("get_variable_info", name)); //return as dict
+				undo_redo->add_do_method(this, "_update_members");
+				undo_redo->add_undo_method(this, "_update_members");
 				undo_redo->commit_action();
 				return; //or crash because it will become invalid
-			} else if (p_button==0) {
+			} else if (p_button == 0) {
 
 				variable_editor->edit(name);
-				edit_variable_dialog->set_title(TTR("Editing Variable:")+" "+name);
-				edit_variable_dialog->popup_centered_minsize(Size2(400,200)*EDSCALE);
+				edit_variable_dialog->set_title(TTR("Editing Variable:") + " " + name);
+				edit_variable_dialog->popup_centered_minsize(Size2(400, 200) * EDSCALE);
 			}
-
 		}
 
-		if (ti->get_parent()==root->get_children()->get_next()->get_next()) {
+		if (ti->get_parent() == root->get_children()->get_next()->get_next()) {
 			//edit/remove variable
 			String name = ti->get_metadata(0);
 
-			if (p_button==1) {
+			if (p_button == 1) {
 
 				undo_redo->create_action(TTR("Remove Signal"));
-				undo_redo->add_do_method(script.ptr(),"remove_custom_signal",name);
-				undo_redo->add_undo_method(script.ptr(),"add_custom_signal",name);
+				undo_redo->add_do_method(script.ptr(), "remove_custom_signal", name);
+				undo_redo->add_undo_method(script.ptr(), "add_custom_signal", name);
 
-				for(int i=0;i<script->custom_signal_get_argument_count(name);i++) {
-					undo_redo->add_undo_method(script.ptr(),"custom_signal_add_argument",name,script->custom_signal_get_argument_name(name,i),script->custom_signal_get_argument_type(name,i));
+				for (int i = 0; i < script->custom_signal_get_argument_count(name); i++) {
+					undo_redo->add_undo_method(script.ptr(), "custom_signal_add_argument", name, script->custom_signal_get_argument_name(name, i), script->custom_signal_get_argument_type(name, i));
 				}
 
-				undo_redo->add_do_method(this,"_update_members");
-				undo_redo->add_undo_method(this,"_update_members");
+				undo_redo->add_do_method(this, "_update_members");
+				undo_redo->add_undo_method(this, "_update_members");
 				undo_redo->commit_action();
-			} else if (p_button==0) {
+			} else if (p_button == 0) {
 
 				signal_editor->edit(name);
-				edit_signal_dialog->set_title(TTR("Editing Signal:")+" "+name);
-				edit_signal_dialog->popup_centered_minsize(Size2(400,300)*EDSCALE);
+				edit_signal_dialog->set_title(TTR("Editing Signal:") + " " + name);
+				edit_signal_dialog->popup_centered_minsize(Size2(400, 300) * EDSCALE);
 			}
 
 			return; //or crash because it will become invalid
-
 		}
-
-
 	}
 }
 
-void VisualScriptEditor::_expression_text_changed(const String& p_text,int p_id) {
+void VisualScriptEditor::_expression_text_changed(const String &p_text, int p_id) {
 
-	Ref<VisualScriptExpression> vse = script->get_node(edited_func,p_id);
+	Ref<VisualScriptExpression> vse = script->get_node(edited_func, p_id);
 	if (!vse.is_valid())
 		return;
 
+	updating_graph = true;
 
-	updating_graph=true;
-
-	undo_redo->create_action(TTR("Change Expression"),UndoRedo::MERGE_ENDS);
-	undo_redo->add_do_property(vse.ptr(),"expression",p_text);
-	undo_redo->add_undo_property(vse.ptr(),"expression",vse->get("expression"));
-	undo_redo->add_do_method(this,"_update_graph",p_id);
-	undo_redo->add_undo_method(this,"_update_graph",p_id);
+	undo_redo->create_action(TTR("Change Expression"), UndoRedo::MERGE_ENDS);
+	undo_redo->add_do_property(vse.ptr(), "expression", p_text);
+	undo_redo->add_undo_property(vse.ptr(), "expression", vse->get("expression"));
+	undo_redo->add_do_method(this, "_update_graph", p_id);
+	undo_redo->add_undo_method(this, "_update_graph", p_id);
 	undo_redo->commit_action();
 
 	Node *node = graph->get_node(itos(p_id));
 	if (node->cast_to<Control>())
-		node->cast_to<Control>()->set_size(Vector2(1,1)); //shrink if text is smaller
-
-	updating_graph=false;
+		node->cast_to<Control>()->set_size(Vector2(1, 1)); //shrink if text is smaller
 
+	updating_graph = false;
 }
 
 void VisualScriptEditor::_available_node_doubleclicked() {
@@ -1272,27 +1205,27 @@ void VisualScriptEditor::_available_node_doubleclicked() {
 		return;
 
 	String which = item->get_metadata(0);
-	if (which==String())
+	if (which == String())
 		return;
 
 	Vector2 ofs = graph->get_scroll_ofs() + graph->get_size() * 0.5;
 
 	if (graph->is_using_snap()) {
 		int snap = graph->get_snap();
-		ofs = ofs.snapped(Vector2(snap,snap));
+		ofs = ofs.snapped(Vector2(snap, snap));
 	}
 
-	ofs/=EDSCALE;
+	ofs /= EDSCALE;
 
-	while(true) {
-		bool exists=false;
+	while (true) {
+		bool exists = false;
 		List<int> existing;
-		script->get_node_list(edited_func,&existing);
-		for (List<int>::Element *E=existing.front();E;E=E->next()) {
-			Point2 pos = script->get_node_pos(edited_func,E->get());
-			if (pos.distance_to(ofs)<15) {
-				ofs+=Vector2(graph->get_snap(),graph->get_snap());
-				exists=true;
+		script->get_node_list(edited_func, &existing);
+		for (List<int>::Element *E = existing.front(); E; E = E->next()) {
+			Point2 pos = script->get_node_pos(edited_func, E->get());
+			if (pos.distance_to(ofs) < 15) {
+				ofs += Vector2(graph->get_snap(), graph->get_snap());
+				exists = true;
 				break;
 			}
 		}
@@ -1300,26 +1233,23 @@ void VisualScriptEditor::_available_node_doubleclicked() {
 		if (exists)
 			continue;
 		break;
-
 	}
 
-
 	Ref<VisualScriptNode> vnode = VisualScriptLanguage::singleton->create_node_from_name(which);
 	int new_id = script->get_available_id();
 
 	undo_redo->create_action(TTR("Add Node"));
-	undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,vnode,ofs);
-	undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
-	undo_redo->add_do_method(this,"_update_graph");
-	undo_redo->add_undo_method(this,"_update_graph");
+	undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
+	undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
+	undo_redo->add_do_method(this, "_update_graph");
+	undo_redo->add_undo_method(this, "_update_graph");
 	undo_redo->commit_action();
 
-	Node* node = graph->get_node(itos(new_id));
+	Node *node = graph->get_node(itos(new_id));
 	if (node) {
 		graph->set_selected(node);
 		_node_selected(node);
 	}
-
 }
 
 void VisualScriptEditor::_update_available_nodes() {
@@ -1328,63 +1258,61 @@ void VisualScriptEditor::_update_available_nodes() {
 
 	TreeItem *root = nodes->create_item();
 
-	Map<String,TreeItem*> path_cache;
+	Map<String, TreeItem *> path_cache;
 
 	String filter = node_filter->get_text();
 
 	List<String> fnodes;
 	VisualScriptLanguage::singleton->get_registered_node_names(&fnodes);
 
-	for (List<String>::Element *E=fnodes.front();E;E=E->next()) {
-
+	for (List<String>::Element *E = fnodes.front(); E; E = E->next()) {
 
 		Vector<String> path = E->get().split("/");
 
-		if (filter!=String() && path.size() && path[path.size()-1].findn(filter)==-1)
+		if (filter != String() && path.size() && path[path.size() - 1].findn(filter) == -1)
 			continue;
 
 		String sp;
-		TreeItem* parent=root;
+		TreeItem *parent = root;
 
-		for(int i=0;i<path.size()-1;i++) {
+		for (int i = 0; i < path.size() - 1; i++) {
 
-			if (i>0)
-				sp+=",";
-			sp+=path[i];
+			if (i > 0)
+				sp += ",";
+			sp += path[i];
 			if (!path_cache.has(sp)) {
-				TreeItem* pathn = nodes->create_item(parent);
-				pathn->set_selectable(0,false);
-				pathn->set_text(0,path[i].capitalize());
-				path_cache[sp]=pathn;
-				parent=pathn;
-				if (filter==String()) {
+				TreeItem *pathn = nodes->create_item(parent);
+				pathn->set_selectable(0, false);
+				pathn->set_text(0, path[i].capitalize());
+				path_cache[sp] = pathn;
+				parent = pathn;
+				if (filter == String()) {
 					pathn->set_collapsed(true); //should remember state
 				}
 			} else {
-				parent=path_cache[sp];
+				parent = path_cache[sp];
 			}
 		}
 
 		TreeItem *item = nodes->create_item(parent);
-		item->set_text(0,path[path.size()-1].capitalize());
-		item->set_selectable(0,true);
-		item->set_metadata(0,E->get());
+		item->set_text(0, path[path.size() - 1].capitalize());
+		item->set_selectable(0, true);
+		item->set_metadata(0, E->get());
 	}
-
 }
 
-String VisualScriptEditor::_validate_name(const String& p_name) const {
+String VisualScriptEditor::_validate_name(const String &p_name) const {
 
-	String valid=p_name;
+	String valid = p_name;
 
-	int counter=1;
-	while(true) {
+	int counter = 1;
+	while (true) {
 
 		bool exists = script->has_function(valid) || script->has_variable(valid) || script->has_custom_signal(valid);
 
 		if (exists) {
 			counter++;
-			valid=p_name+"_"+itos(counter);
+			valid = p_name + "_" + itos(counter);
 			continue;
 		}
 
@@ -1396,10 +1324,9 @@ String VisualScriptEditor::_validate_name(const String& p_name) const {
 
 void VisualScriptEditor::_on_nodes_delete() {
 
-
 	List<int> to_erase;
 
-	for(int i=0;i<graph->get_child_count();i++) {
+	for (int i = 0; i < graph->get_child_count(); i++) {
 		GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
 		if (gn) {
 			if (gn->is_selected() && gn->is_close_button_visible()) {
@@ -1413,48 +1340,42 @@ void VisualScriptEditor::_on_nodes_delete() {
 
 	undo_redo->create_action("Remove VisualScript Nodes");
 
-	for(List<int>::Element*F=to_erase.front();F;F=F->next()) {
-
-
-		undo_redo->add_do_method(script.ptr(),"remove_node",edited_func,F->get());
-		undo_redo->add_undo_method(script.ptr(),"add_node",edited_func,F->get(),script->get_node(edited_func,F->get()),script->get_node_pos(edited_func,F->get()));
+	for (List<int>::Element *F = to_erase.front(); F; F = F->next()) {
 
+		undo_redo->add_do_method(script.ptr(), "remove_node", edited_func, F->get());
+		undo_redo->add_undo_method(script.ptr(), "add_node", edited_func, F->get(), script->get_node(edited_func, F->get()), script->get_node_pos(edited_func, F->get()));
 
 		List<VisualScript::SequenceConnection> sequence_conns;
-		script->get_sequence_connection_list(edited_func,&sequence_conns);
+		script->get_sequence_connection_list(edited_func, &sequence_conns);
 
+		for (List<VisualScript::SequenceConnection>::Element *E = sequence_conns.front(); E; E = E->next()) {
 
-		for (List<VisualScript::SequenceConnection>::Element *E=sequence_conns.front();E;E=E->next()) {
-
-			if (E->get().from_node==F->get() || E->get().to_node==F->get()) {
-				undo_redo->add_undo_method(script.ptr(),"sequence_connect",edited_func,E->get().from_node,E->get().from_output,E->get().to_node);
+			if (E->get().from_node == F->get() || E->get().to_node == F->get()) {
+				undo_redo->add_undo_method(script.ptr(), "sequence_connect", edited_func, E->get().from_node, E->get().from_output, E->get().to_node);
 			}
 		}
 
 		List<VisualScript::DataConnection> data_conns;
-		script->get_data_connection_list(edited_func,&data_conns);
+		script->get_data_connection_list(edited_func, &data_conns);
 
-		for (List<VisualScript::DataConnection>::Element *E=data_conns.front();E;E=E->next()) {
+		for (List<VisualScript::DataConnection>::Element *E = data_conns.front(); E; E = E->next()) {
 
-			if (E->get().from_node==F->get() || E->get().to_node==F->get()) {
-				undo_redo->add_undo_method(script.ptr(),"data_connect",edited_func,E->get().from_node,E->get().from_port,E->get().to_node,E->get().to_port);
+			if (E->get().from_node == F->get() || E->get().to_node == F->get()) {
+				undo_redo->add_undo_method(script.ptr(), "data_connect", edited_func, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
 			}
 		}
-
 	}
-	undo_redo->add_do_method(this,"_update_graph");
-	undo_redo->add_undo_method(this,"_update_graph");
+	undo_redo->add_do_method(this, "_update_graph");
+	undo_redo->add_undo_method(this, "_update_graph");
 
 	undo_redo->commit_action();
 }
 
-
 void VisualScriptEditor::_on_nodes_duplicate() {
 
-
 	List<int> to_duplicate;
 
-	for(int i=0;i<graph->get_child_count();i++) {
+	for (int i = 0; i < graph->get_child_count(); i++) {
 		GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
 		if (gn) {
 			if (gn->is_selected() && gn->is_close_button_visible()) {
@@ -1467,64 +1388,60 @@ void VisualScriptEditor::_on_nodes_duplicate() {
 		return;
 
 	undo_redo->create_action("Duplicate VisualScript Nodes");
-	int idc=script->get_available_id()+1;
+	int idc = script->get_available_id() + 1;
 
 	Set<int> to_select;
 
-	for(List<int>::Element*F=to_duplicate.front();F;F=F->next()) {
+	for (List<int>::Element *F = to_duplicate.front(); F; F = F->next()) {
 
-		Ref<VisualScriptNode> node = script->get_node(edited_func,F->get());
+		Ref<VisualScriptNode> node = script->get_node(edited_func, F->get());
 
 		Ref<VisualScriptNode> dupe = node->duplicate();
 
 		int new_id = idc++;
 		to_select.insert(new_id);
-		undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,dupe,script->get_node_pos(edited_func,F->get())+Vector2(20,20));
-		undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
-
+		undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, dupe, script->get_node_pos(edited_func, F->get()) + Vector2(20, 20));
+		undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
 	}
-	undo_redo->add_do_method(this,"_update_graph");
-	undo_redo->add_undo_method(this,"_update_graph");
+	undo_redo->add_do_method(this, "_update_graph");
+	undo_redo->add_undo_method(this, "_update_graph");
 
 	undo_redo->commit_action();
 
-	for(int i=0;i<graph->get_child_count();i++) {
+	for (int i = 0; i < graph->get_child_count(); i++) {
 		GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
 		if (gn) {
 			int id = gn->get_name().operator String().to_int();
 			gn->set_selected(to_select.has(id));
-
 		}
 	}
 
 	if (to_select.size()) {
-		EditorNode::get_singleton()->push_item(script->get_node(edited_func,to_select.front()->get()).ptr());
+		EditorNode::get_singleton()->push_item(script->get_node(edited_func, to_select.front()->get()).ptr());
 	}
-
 }
 
-void VisualScriptEditor::_input(const InputEvent& p_event) {
+void VisualScriptEditor::_input(const InputEvent &p_event) {
 
-	if (p_event.type==InputEvent::MOUSE_BUTTON && !p_event.mouse_button.pressed && p_event.mouse_button.button_index==BUTTON_LEFT) {
-		revert_on_drag=String(); //so we can still drag functions
+	if (p_event.type == InputEvent::MOUSE_BUTTON && !p_event.mouse_button.pressed && p_event.mouse_button.button_index == BUTTON_LEFT) {
+		revert_on_drag = String(); //so we can still drag functions
 	}
 }
 
-Variant VisualScriptEditor::get_drag_data_fw(const Point2& p_point,Control* p_from) {
+Variant VisualScriptEditor::get_drag_data_fw(const Point2 &p_point, Control *p_from) {
 
-
-	if (p_from==nodes) {
+	if (p_from == nodes) {
 
 		TreeItem *it = nodes->get_item_at_pos(p_point);
 		if (!it)
 			return Variant();
-		String type=it->get_metadata(0);
-		if (type==String())
+		String type = it->get_metadata(0);
+		if (type == String())
 			return Variant();
 
 		Dictionary dd;
-		dd["type"]="visual_script_node_drag";
-		dd["node_type"]=type;
+		dd["type"] = "visual_script_node_drag";
+		dd["node_type"] = type;
 
 		Label *label = memnew(Label);
 		label->set_text(it->get_text(0));
@@ -1532,49 +1449,42 @@ Variant VisualScriptEditor::get_drag_data_fw(const Point2& p_point,Control* p_fr
 		return dd;
 	}
 
-	if (p_from==members) {
-
+	if (p_from == members) {
 
 		TreeItem *it = members->get_item_at_pos(p_point);
 		if (!it)
 			return Variant();
 
-		String type=it->get_metadata(0);
+		String type = it->get_metadata(0);
 
-		if (type==String())
+		if (type == String())
 			return Variant();
 
-
 		Dictionary dd;
-		TreeItem *root=members->get_root();
+		TreeItem *root = members->get_root();
 
-		if (it->get_parent()==root->get_children()) {
+		if (it->get_parent() == root->get_children()) {
 
-			dd["type"]="visual_script_function_drag";
-			dd["function"]=type;
-			if (revert_on_drag!=String()) {
-				edited_func=revert_on_drag; //revert so function does not change
-				revert_on_drag=String();
+			dd["type"] = "visual_script_function_drag";
+			dd["function"] = type;
+			if (revert_on_drag != String()) {
+				edited_func = revert_on_drag; //revert so function does not change
+				revert_on_drag = String();
 				_update_graph();
 			}
-		} else if (it->get_parent()==root->get_children()->get_next()) {
+		} else if (it->get_parent() == root->get_children()->get_next()) {
 
-			dd["type"]="visual_script_variable_drag";
-			dd["variable"]=type;
-		} else if (it->get_parent()==root->get_children()->get_next()->get_next()) {
+			dd["type"] = "visual_script_variable_drag";
+			dd["variable"] = type;
+		} else if (it->get_parent() == root->get_children()->get_next()->get_next()) {
 
-			dd["type"]="visual_script_signal_drag";
-			dd["signal"]=type;
+			dd["type"] = "visual_script_signal_drag";
+			dd["signal"] = type;
 
 		} else {
 			return Variant();
 		}
 
-
-
-
-
-
 		Label *label = memnew(Label);
 		label->set_text(it->get_text(0));
 		set_drag_preview(label);
@@ -1583,78 +1493,69 @@ Variant VisualScriptEditor::get_drag_data_fw(const Point2& p_point,Control* p_fr
 	return Variant();
 }
 
-bool VisualScriptEditor::can_drop_data_fw(const Point2& p_point,const Variant& p_data,Control* p_from) const{
-
-	if (p_from==graph) {
+bool VisualScriptEditor::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const {
 
+	if (p_from == graph) {
 
 		Dictionary d = p_data;
 		if (d.has("type") &&
-				(
-					String(d["type"])=="visual_script_node_drag" ||
-					String(d["type"])=="visual_script_function_drag" ||
-					String(d["type"])=="visual_script_variable_drag" ||
-					String(d["type"])=="visual_script_signal_drag" ||
-					String(d["type"])=="obj_property" ||
-					String(d["type"])=="resource" ||
-					String(d["type"])=="files" ||
-					String(d["type"])=="nodes"
-				) ) {
-
+				(String(d["type"]) == "visual_script_node_drag" ||
+						String(d["type"]) == "visual_script_function_drag" ||
+						String(d["type"]) == "visual_script_variable_drag" ||
+						String(d["type"]) == "visual_script_signal_drag" ||
+						String(d["type"]) == "obj_property" ||
+						String(d["type"]) == "resource" ||
+						String(d["type"]) == "files" ||
+						String(d["type"]) == "nodes")) {
 
-				if (String(d["type"])=="obj_property") {
+			if (String(d["type"]) == "obj_property") {
 
 #ifdef OSX_ENABLED
-					const_cast<VisualScriptEditor*>(this)->_show_hint(TTR("Hold Meta to drop a Getter. Hold Shift to drop a generic signature."));
+				const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Meta to drop a Getter. Hold Shift to drop a generic signature."));
 #else
-					const_cast<VisualScriptEditor*>(this)->_show_hint(TTR("Hold Ctrl to drop a Getter. Hold Shift to drop a generic signature."));
+				const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Ctrl to drop a Getter. Hold Shift to drop a generic signature."));
 #endif
-				}
+			}
 
-				if (String(d["type"])=="nodes") {
+			if (String(d["type"]) == "nodes") {
 
 #ifdef OSX_ENABLED
-					const_cast<VisualScriptEditor*>(this)->_show_hint(TTR("Hold Meta to drop a simple reference to the node."));
+				const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Meta to drop a simple reference to the node."));
 #else
-					const_cast<VisualScriptEditor*>(this)->_show_hint(TTR("Hold Ctrl to drop a simple reference to the node."));
+				const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Ctrl to drop a simple reference to the node."));
 #endif
-				}
+			}
 
-				if (String(d["type"])=="visual_script_variable_drag") {
+			if (String(d["type"]) == "visual_script_variable_drag") {
 
 #ifdef OSX_ENABLED
-					const_cast<VisualScriptEditor*>(this)->_show_hint(TTR("Hold Meta to drop a Variable Setter."));
+				const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Meta to drop a Variable Setter."));
 #else
-					const_cast<VisualScriptEditor*>(this)->_show_hint(TTR("Hold Ctrl to drop a Variable Setter."));
+				const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Ctrl to drop a Variable Setter."));
 #endif
-				}
-
-				return true;
+			}
 
+			return true;
 		}
-
-
-
 	}
 
-
 	return false;
 }
 
 #ifdef TOOLS_ENABLED
 
-static Node* _find_script_node(Node* p_edited_scene,Node* p_current_node,const Ref<Script> &script) {
+static Node *_find_script_node(Node *p_edited_scene, Node *p_current_node, const Ref<Script> &script) {
 
-	if (p_edited_scene!=p_current_node && p_current_node->get_owner()!=p_edited_scene)
+	if (p_edited_scene != p_current_node && p_current_node->get_owner() != p_edited_scene)
 		return NULL;
 
 	Ref<Script> scr = p_current_node->get_script();
 
-	if (scr.is_valid() && scr==script)
+	if (scr.is_valid() && scr == script)
 		return p_current_node;
 
-	for(int i=0;i<p_current_node->get_child_count();i++) {
-		Node *n = _find_script_node(p_edited_scene,p_current_node->get_child(i),script);
+	for (int i = 0; i < p_current_node->get_child_count(); i++) {
+		Node *n = _find_script_node(p_edited_scene, p_current_node->get_child(i), script);
 		if (n)
 			return n;
 	}
@@ -1664,43 +1565,40 @@ static Node* _find_script_node(Node* p_edited_scene,Node* p_current_node,const R
 
 #endif
 
+void VisualScriptEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) {
 
-
-void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_data,Control* p_from){
-
-	if (p_from==graph) {
+	if (p_from == graph) {
 
 		Dictionary d = p_data;
-		if (d.has("type") && String(d["type"])=="visual_script_node_drag") {
+		if (d.has("type") && String(d["type"]) == "visual_script_node_drag") {
 
 			Vector2 ofs = graph->get_scroll_ofs() + p_point;
 
 			if (graph->is_using_snap()) {
 				int snap = graph->get_snap();
-				ofs = ofs.snapped(Vector2(snap,snap));
+				ofs = ofs.snapped(Vector2(snap, snap));
 			}
 
-
-			ofs/=EDSCALE;
+			ofs /= EDSCALE;
 
 			Ref<VisualScriptNode> vnode = VisualScriptLanguage::singleton->create_node_from_name(d["node_type"]);
 			int new_id = script->get_available_id();
 
 			undo_redo->create_action(TTR("Add Node"));
-			undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,vnode,ofs);
-			undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
-			undo_redo->add_do_method(this,"_update_graph");
-			undo_redo->add_undo_method(this,"_update_graph");
+			undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
+			undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
+			undo_redo->add_do_method(this, "_update_graph");
+			undo_redo->add_undo_method(this, "_update_graph");
 			undo_redo->commit_action();
 
-			Node* node = graph->get_node(itos(new_id));
+			Node *node = graph->get_node(itos(new_id));
 			if (node) {
 				graph->set_selected(node);
 				_node_selected(node);
 			}
 		}
 
-		if (d.has("type") && String(d["type"])=="visual_script_variable_drag") {
+		if (d.has("type") && String(d["type"]) == "visual_script_variable_drag") {
 
 #ifdef OSX_ENABLED
 			bool use_set = Input::get_singleton()->is_key_pressed(KEY_META);
@@ -1710,50 +1608,50 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 			Vector2 ofs = graph->get_scroll_ofs() + p_point;
 			if (graph->is_using_snap()) {
 				int snap = graph->get_snap();
-				ofs = ofs.snapped(Vector2(snap,snap));
+				ofs = ofs.snapped(Vector2(snap, snap));
 			}
 
-			ofs/=EDSCALE;
+			ofs /= EDSCALE;
 
 			Ref<VisualScriptNode> vnode;
 			if (use_set) {
 				Ref<VisualScriptVariableSet> vnodes;
 				vnodes.instance();
 				vnodes->set_variable(d["variable"]);
-				vnode=vnodes;
+				vnode = vnodes;
 			} else {
 
 				Ref<VisualScriptVariableGet> vnodeg;
 				vnodeg.instance();
 				vnodeg->set_variable(d["variable"]);
-				vnode=vnodeg;
+				vnode = vnodeg;
 			}
 
 			int new_id = script->get_available_id();
 
 			undo_redo->create_action(TTR("Add Node"));
-			undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,vnode,ofs);
-			undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
-			undo_redo->add_do_method(this,"_update_graph");
-			undo_redo->add_undo_method(this,"_update_graph");
+			undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
+			undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
+			undo_redo->add_do_method(this, "_update_graph");
+			undo_redo->add_undo_method(this, "_update_graph");
 			undo_redo->commit_action();
 
-			Node* node = graph->get_node(itos(new_id));
+			Node *node = graph->get_node(itos(new_id));
 			if (node) {
 				graph->set_selected(node);
 				_node_selected(node);
 			}
 		}
 
-		if (d.has("type") && String(d["type"])=="visual_script_function_drag") {
+		if (d.has("type") && String(d["type"]) == "visual_script_function_drag") {
 
 			Vector2 ofs = graph->get_scroll_ofs() + p_point;
 			if (graph->is_using_snap()) {
 				int snap = graph->get_snap();
-				ofs = ofs.snapped(Vector2(snap,snap));
+				ofs = ofs.snapped(Vector2(snap, snap));
 			}
 
-			ofs/=EDSCALE;
+			ofs /= EDSCALE;
 
 			Ref<VisualScriptFunctionCall> vnode;
 			vnode.instance();
@@ -1762,33 +1660,31 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 			int new_id = script->get_available_id();
 
 			undo_redo->create_action(TTR("Add Node"));
-			undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,vnode,ofs);
-			undo_redo->add_do_method(vnode.ptr(),"set_base_type",script->get_instance_base_type());
-			undo_redo->add_do_method(vnode.ptr(),"set_function",d["function"]);
+			undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
+			undo_redo->add_do_method(vnode.ptr(), "set_base_type", script->get_instance_base_type());
+			undo_redo->add_do_method(vnode.ptr(), "set_function", d["function"]);
 
-			undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
-			undo_redo->add_do_method(this,"_update_graph");
-			undo_redo->add_undo_method(this,"_update_graph");
+			undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
+			undo_redo->add_do_method(this, "_update_graph");
+			undo_redo->add_undo_method(this, "_update_graph");
 			undo_redo->commit_action();
 
-			Node* node = graph->get_node(itos(new_id));
+			Node *node = graph->get_node(itos(new_id));
 			if (node) {
 				graph->set_selected(node);
 				_node_selected(node);
 			}
-
 		}
 
-
-		if (d.has("type") && String(d["type"])=="visual_script_signal_drag") {
+		if (d.has("type") && String(d["type"]) == "visual_script_signal_drag") {
 
 			Vector2 ofs = graph->get_scroll_ofs() + p_point;
 			if (graph->is_using_snap()) {
 				int snap = graph->get_snap();
-				ofs = ofs.snapped(Vector2(snap,snap));
+				ofs = ofs.snapped(Vector2(snap, snap));
 			}
 
-			ofs/=EDSCALE;
+			ofs /= EDSCALE;
 
 			Ref<VisualScriptEmitSignal> vnode;
 			vnode.instance();
@@ -1797,28 +1693,28 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 			int new_id = script->get_available_id();
 
 			undo_redo->create_action(TTR("Add Node"));
-			undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,vnode,ofs);
-			undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
-			undo_redo->add_do_method(this,"_update_graph");
-			undo_redo->add_undo_method(this,"_update_graph");
+			undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
+			undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
+			undo_redo->add_do_method(this, "_update_graph");
+			undo_redo->add_undo_method(this, "_update_graph");
 			undo_redo->commit_action();
 
-			Node* node = graph->get_node(itos(new_id));
+			Node *node = graph->get_node(itos(new_id));
 			if (node) {
 				graph->set_selected(node);
 				_node_selected(node);
 			}
 		}
 
-		if (d.has("type") && String(d["type"])=="resource") {
+		if (d.has("type") && String(d["type"]) == "resource") {
 
 			Vector2 ofs = graph->get_scroll_ofs() + p_point;
 			if (graph->is_using_snap()) {
 				int snap = graph->get_snap();
-				ofs = ofs.snapped(Vector2(snap,snap));
+				ofs = ofs.snapped(Vector2(snap, snap));
 			}
 
-			ofs/=EDSCALE;
+			ofs /= EDSCALE;
 
 			Ref<VisualScriptPreload> prnode;
 			prnode.instance();
@@ -1827,28 +1723,28 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 			int new_id = script->get_available_id();
 
 			undo_redo->create_action(TTR("Add Preload Node"));
-			undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,prnode,ofs);
-			undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
-			undo_redo->add_do_method(this,"_update_graph");
-			undo_redo->add_undo_method(this,"_update_graph");
+			undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, prnode, ofs);
+			undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
+			undo_redo->add_do_method(this, "_update_graph");
+			undo_redo->add_undo_method(this, "_update_graph");
 			undo_redo->commit_action();
 
-			Node* node = graph->get_node(itos(new_id));
+			Node *node = graph->get_node(itos(new_id));
 			if (node) {
 				graph->set_selected(node);
 				_node_selected(node);
 			}
 		}
 
-		if (d.has("type") && String(d["type"])=="files") {
+		if (d.has("type") && String(d["type"]) == "files") {
 
 			Vector2 ofs = graph->get_scroll_ofs() + p_point;
 			if (graph->is_using_snap()) {
 				int snap = graph->get_snap();
-				ofs = ofs.snapped(Vector2(snap,snap));
+				ofs = ofs.snapped(Vector2(snap, snap));
 			}
 
-			ofs/=EDSCALE;
+			ofs /= EDSCALE;
 
 			Array files = d["files"];
 
@@ -1858,7 +1754,7 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 			if (files.size()) {
 				undo_redo->create_action(TTR("Add Preload Node"));
 
-				for(int i=0;i<files.size();i++) {
+				for (int i = 0; i < files.size(); i++) {
 
 					Ref<Resource> res = ResourceLoader::load(files[i]);
 					if (!res.is_valid())
@@ -1868,22 +1764,21 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 					prnode.instance();
 					prnode->set_preload(res);
 
-					undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,prnode,ofs);
-					undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
+					undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, prnode, ofs);
+					undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
 					new_ids.push_back(new_id);
 					new_id++;
-					ofs+=Vector2(20,20)*EDSCALE;
+					ofs += Vector2(20, 20) * EDSCALE;
 				}
 
-
-				undo_redo->add_do_method(this,"_update_graph");
-				undo_redo->add_undo_method(this,"_update_graph");
+				undo_redo->add_do_method(this, "_update_graph");
+				undo_redo->add_undo_method(this, "_update_graph");
 				undo_redo->commit_action();
 			}
 
-			for(List<int>::Element *E=new_ids.front();E;E=E->next()) {
+			for (List<int>::Element *E = new_ids.front(); E; E = E->next()) {
 
-				Node* node = graph->get_node(itos(E->get()));
+				Node *node = graph->get_node(itos(E->get()));
 				if (node) {
 					graph->set_selected(node);
 					_node_selected(node);
@@ -1891,42 +1786,39 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 			}
 		}
 
-		if (d.has("type") && String(d["type"])=="nodes") {
-
-			Node* sn = _find_script_node(get_tree()->get_edited_scene_root(),get_tree()->get_edited_scene_root(),script);
+		if (d.has("type") && String(d["type"]) == "nodes") {
 
+			Node *sn = _find_script_node(get_tree()->get_edited_scene_root(), get_tree()->get_edited_scene_root(), script);
 
 			if (!sn) {
-				EditorNode::get_singleton()->show_warning("Can't drop nodes because script '"+get_name()+"' is not used in this scene.");
+				EditorNode::get_singleton()->show_warning("Can't drop nodes because script '" + get_name() + "' is not used in this scene.");
 				return;
 			}
 
-
 #ifdef OSX_ENABLED
 			bool use_node = Input::get_singleton()->is_key_pressed(KEY_META);
 #else
 			bool use_node = Input::get_singleton()->is_key_pressed(KEY_CONTROL);
 #endif
 
-
 			Array nodes = d["nodes"];
 
 			Vector2 ofs = graph->get_scroll_ofs() + p_point;
 
 			if (graph->is_using_snap()) {
 				int snap = graph->get_snap();
-				ofs = ofs.snapped(Vector2(snap,snap));
+				ofs = ofs.snapped(Vector2(snap, snap));
 			}
-			ofs/=EDSCALE;
+			ofs /= EDSCALE;
 
 			undo_redo->create_action(TTR("Add Node(s) From Tree"));
 			int base_id = script->get_available_id();
 
-			if (nodes.size()>1) {
-				use_node=true;
+			if (nodes.size() > 1) {
+				use_node = true;
 			}
 
-			for(int i=0;i<nodes.size();i++) {
+			for (int i = 0; i < nodes.size(); i++) {
 
 				NodePath np = nodes[i];
 				Node *node = get_node(np);
@@ -1940,8 +1832,7 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 					Ref<VisualScriptSceneNode> scene_node;
 					scene_node.instance();
 					scene_node->set_node_path(sn->get_path_to(node));
-					n=scene_node;
-
+					n = scene_node;
 
 				} else {
 					Ref<VisualScriptFunctionCall> call;
@@ -1949,38 +1840,33 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 					call->set_call_mode(VisualScriptFunctionCall::CALL_MODE_NODE_PATH);
 					call->set_base_path(sn->get_path_to(node));
 					call->set_base_type(node->get_class());
-					n=call;
+					n = call;
 
 					method_select->select_method_from_instance(node);
-					selecting_method_id=base_id;
-
+					selecting_method_id = base_id;
 				}
 
-
-				undo_redo->add_do_method(script.ptr(),"add_node",edited_func,base_id,n,ofs);
-				undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,base_id);
+				undo_redo->add_do_method(script.ptr(), "add_node", edited_func, base_id, n, ofs);
+				undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, base_id);
 
 				base_id++;
-				ofs+=Vector2(25,25);
+				ofs += Vector2(25, 25);
 			}
-			undo_redo->add_do_method(this,"_update_graph");
-			undo_redo->add_undo_method(this,"_update_graph");
+			undo_redo->add_do_method(this, "_update_graph");
+			undo_redo->add_undo_method(this, "_update_graph");
 			undo_redo->commit_action();
-
-
 		}
 
-		if (d.has("type") && String(d["type"])=="obj_property") {
-
-			Node* sn = _find_script_node(get_tree()->get_edited_scene_root(),get_tree()->get_edited_scene_root(),script);
+		if (d.has("type") && String(d["type"]) == "obj_property") {
 
+			Node *sn = _find_script_node(get_tree()->get_edited_scene_root(), get_tree()->get_edited_scene_root(), script);
 
 			if (!sn && !Input::get_singleton()->is_key_pressed(KEY_SHIFT)) {
-				EditorNode::get_singleton()->show_warning("Can't drop properties because script '"+get_name()+"' is not used in this scene.\nDrop holding 'Shift' to just copy the signature.");
+				EditorNode::get_singleton()->show_warning("Can't drop properties because script '" + get_name() + "' is not used in this scene.\nDrop holding 'Shift' to just copy the signature.");
 				return;
 			}
 
-			Object *obj=d["object"];
+			Object *obj = d["object"];
 
 			if (!obj)
 				return;
@@ -1990,10 +1876,10 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 
 			if (graph->is_using_snap()) {
 				int snap = graph->get_snap();
-				ofs = ofs.snapped(Vector2(snap,snap));
+				ofs = ofs.snapped(Vector2(snap, snap));
 			}
 
-			ofs/=EDSCALE;
+			ofs /= EDSCALE;
 #ifdef OSX_ENABLED
 			bool use_get = Input::get_singleton()->is_key_pressed(KEY_META);
 #else
@@ -2002,7 +1888,6 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 
 			if (!node || Input::get_singleton()->is_key_pressed(KEY_SHIFT)) {
 
-
 				if (use_get)
 					undo_redo->create_action(TTR("Add Getter Property"));
 				else
@@ -2022,7 +1907,7 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 						pset->set_use_builtin_value(true);
 						pset->set_builtin_value(d["value"]);
 					}*/
-					vnode=pset;
+					vnode = pset;
 				} else {
 
 					Ref<VisualScriptPropertyGet> pget;
@@ -2030,26 +1915,23 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 					pget->set_call_mode(VisualScriptPropertyGet::CALL_MODE_INSTANCE);
 					pget->set_base_type(obj->get_class());
 
-					vnode=pget;
-
+					vnode = pget;
 				}
 
-				undo_redo->add_do_method(script.ptr(),"add_node",edited_func,base_id,vnode,ofs);
-				undo_redo->add_do_method(vnode.ptr(),"set_property",d["property"]);
+				undo_redo->add_do_method(script.ptr(), "add_node", edited_func, base_id, vnode, ofs);
+				undo_redo->add_do_method(vnode.ptr(), "set_property", d["property"]);
 				if (!use_get) {
-					undo_redo->add_do_method(vnode.ptr(),"set_default_input_value",0,d["value"]);
+					undo_redo->add_do_method(vnode.ptr(), "set_default_input_value", 0, d["value"]);
 				}
 
-				undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,base_id);
+				undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, base_id);
 
-				undo_redo->add_do_method(this,"_update_graph");
-				undo_redo->add_undo_method(this,"_update_graph");
+				undo_redo->add_do_method(this, "_update_graph");
+				undo_redo->add_undo_method(this, "_update_graph");
 				undo_redo->commit_action();
 
 			} else {
 
-
-
 				if (use_get)
 					undo_redo->create_action(TTR("Add Getter Property"));
 				else
@@ -2063,74 +1945,63 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 
 					Ref<VisualScriptPropertySet> pset;
 					pset.instance();
-					if (sn==node) {
+					if (sn == node) {
 						pset->set_call_mode(VisualScriptPropertySet::CALL_MODE_SELF);
 					} else {
 						pset->set_call_mode(VisualScriptPropertySet::CALL_MODE_NODE_PATH);
 						pset->set_base_path(sn->get_path_to(node));
 					}
 
-					vnode=pset;
+					vnode = pset;
 				} else {
 
 					Ref<VisualScriptPropertyGet> pget;
 					pget.instance();
-					if (sn==node) {
+					if (sn == node) {
 						pget->set_call_mode(VisualScriptPropertyGet::CALL_MODE_SELF);
 					} else {
 						pget->set_call_mode(VisualScriptPropertyGet::CALL_MODE_NODE_PATH);
 						pget->set_base_path(sn->get_path_to(node));
 					}
-					vnode=pget;
-
+					vnode = pget;
 				}
-				undo_redo->add_do_method(script.ptr(),"add_node",edited_func,base_id,vnode,ofs);
-				undo_redo->add_do_method(vnode.ptr(),"set_property",d["property"]);
+				undo_redo->add_do_method(script.ptr(), "add_node", edited_func, base_id, vnode, ofs);
+				undo_redo->add_do_method(vnode.ptr(), "set_property", d["property"]);
 				if (!use_get) {
-					undo_redo->add_do_method(vnode.ptr(),"set_default_input_value",0,d["value"]);
+					undo_redo->add_do_method(vnode.ptr(), "set_default_input_value", 0, d["value"]);
 				}
-				undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,base_id);
+				undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, base_id);
 
-				undo_redo->add_do_method(this,"_update_graph");
-				undo_redo->add_undo_method(this,"_update_graph");
+				undo_redo->add_do_method(this, "_update_graph");
+				undo_redo->add_undo_method(this, "_update_graph");
 				undo_redo->commit_action();
 			}
-
-
 		}
-
-
 	}
-
-
 }
 
+void VisualScriptEditor::_selected_method(const String &p_method) {
 
-void VisualScriptEditor::_selected_method(const String& p_method) {
-
-	Ref<VisualScriptFunctionCall> vsfc = script->get_node(edited_func,selecting_method_id);
+	Ref<VisualScriptFunctionCall> vsfc = script->get_node(edited_func, selecting_method_id);
 	if (!vsfc.is_valid())
 		return;
 	vsfc->set_function(p_method);
-
 }
 
-void VisualScriptEditor::_draw_color_over_button(Object* obj,Color p_color) {
+void VisualScriptEditor::_draw_color_over_button(Object *obj, Color p_color) {
 
 	Button *button = obj->cast_to<Button>();
 	if (!button)
 		return;
 
-	Ref<StyleBox> normal = get_stylebox("normal","Button" );
-	button->draw_rect(Rect2(normal->get_offset(),button->get_size()-normal->get_minimum_size()),p_color);
-
+	Ref<StyleBox> normal = get_stylebox("normal", "Button");
+	button->draw_rect(Rect2(normal->get_offset(), button->get_size() - normal->get_minimum_size()), p_color);
 }
 
-void VisualScriptEditor::_button_resource_previewed(const String& p_path,const Ref<Texture>& p_preview,Variant p_ud) {
-
+void VisualScriptEditor::_button_resource_previewed(const String &p_path, const Ref<Texture> &p_preview, Variant p_ud) {
 
-	Array ud=p_ud;
-	ERR_FAIL_COND(ud.size()!=2);
+	Array ud = p_ud;
+	ERR_FAIL_COND(ud.size() != 2);
 
 	ObjectID id = ud[0];
 	Object *obj = ObjectDB::get_instance(id);
@@ -2147,73 +2018,63 @@ void VisualScriptEditor::_button_resource_previewed(const String& p_path,const R
 
 		b->set_icon(p_preview);
 	}
-
 }
 
 /////////////////////////
 
-
-
 void VisualScriptEditor::apply_code() {
-
-
 }
 
-Ref<Script> VisualScriptEditor::get_edited_script() const{
+Ref<Script> VisualScriptEditor::get_edited_script() const {
 
 	return script;
 }
 
-Vector<String> VisualScriptEditor::get_functions(){
+Vector<String> VisualScriptEditor::get_functions() {
 
 	return Vector<String>();
 }
 
-void VisualScriptEditor::set_edited_script(const Ref<Script>& p_script){
-
-
-	script=p_script;
-	signal_editor->script=p_script;
-	signal_editor->undo_redo=undo_redo;
-	variable_editor->script=p_script;
-	variable_editor->undo_redo=undo_redo;
+void VisualScriptEditor::set_edited_script(const Ref<Script> &p_script) {
 
+	script = p_script;
+	signal_editor->script = p_script;
+	signal_editor->undo_redo = undo_redo;
+	variable_editor->script = p_script;
+	variable_editor->undo_redo = undo_redo;
 
-	script->connect("node_ports_changed",this,"_node_ports_changed");
+	script->connect("node_ports_changed", this, "_node_ports_changed");
 
 	_update_members();
 	_update_available_nodes();
 }
 
-void VisualScriptEditor::reload_text(){
-
-
+void VisualScriptEditor::reload_text() {
 }
 
-String VisualScriptEditor::get_name(){
+String VisualScriptEditor::get_name() {
 
 	String name;
 
-	if (script->get_path().find("local://")==-1 && script->get_path().find("::")==-1) {
-		name=script->get_path().get_file();
+	if (script->get_path().find("local://") == -1 && script->get_path().find("::") == -1) {
+		name = script->get_path().get_file();
 		if (is_unsaved()) {
-			name+="(*)";
+			name += "(*)";
 		}
-	} else if (script->get_name()!="")
-		name=script->get_name();
+	} else if (script->get_name() != "")
+		name = script->get_name();
 	else
-		name=script->get_class()+"("+itos(script->get_instance_ID())+")";
+		name = script->get_class() + "(" + itos(script->get_instance_ID()) + ")";
 
 	return name;
-
 }
 
-Ref<Texture> VisualScriptEditor::get_icon(){
+Ref<Texture> VisualScriptEditor::get_icon() {
 
-	return Control::get_icon("VisualScript","EditorIcons");
+	return Control::get_icon("VisualScript", "EditorIcons");
 }
 
-bool VisualScriptEditor::is_unsaved(){
+bool VisualScriptEditor::is_unsaved() {
 #ifdef TOOLS_ENABLED
 
 	return script->is_edited() || script->are_subnodes_edited();
@@ -2222,24 +2083,23 @@ bool VisualScriptEditor::is_unsaved(){
 #endif
 }
 
-Variant VisualScriptEditor::get_edit_state(){
+Variant VisualScriptEditor::get_edit_state() {
 
 	Dictionary d;
-	d["function"]=edited_func;
-	d["scroll"]=graph->get_scroll_ofs();
-	d["zoom"]=graph->get_zoom();
-	d["using_snap"]=graph->is_using_snap();
-	d["snap"]=graph->get_snap();
+	d["function"] = edited_func;
+	d["scroll"] = graph->get_scroll_ofs();
+	d["zoom"] = graph->get_zoom();
+	d["using_snap"] = graph->is_using_snap();
+	d["snap"] = graph->get_snap();
 	return d;
 }
 
-void VisualScriptEditor::set_edit_state(const Variant& p_state){
+void VisualScriptEditor::set_edit_state(const Variant &p_state) {
 
 	Dictionary d = p_state;
 	if (d.has("function")) {
-		edited_func=p_state;
-		selected=edited_func;
-
+		edited_func = p_state;
+		selected = edited_func;
 	}
 
 	_update_graph();
@@ -2257,10 +2117,8 @@ void VisualScriptEditor::set_edit_state(const Variant& p_state){
 	if (d.has("snap_enabled")) {
 		graph->set_use_snap(d["snap_enabled"]);
 	}
-
 }
 
-
 void VisualScriptEditor::_center_on_node(int p_id) {
 
 	Node *n = graph->get_node(itos(p_id));
@@ -2269,94 +2127,87 @@ void VisualScriptEditor::_center_on_node(int p_id) {
 	GraphNode *gn = n->cast_to<GraphNode>();
 	if (gn) {
 		gn->set_selected(true);
-		Vector2 new_scroll = gn->get_offset() - graph->get_size()*0.5 + gn->get_size()*0.5;
-		graph->set_scroll_ofs( new_scroll );
-		script->set_function_scroll(edited_func,new_scroll/EDSCALE);
+		Vector2 new_scroll = gn->get_offset() - graph->get_size() * 0.5 + gn->get_size() * 0.5;
+		graph->set_scroll_ofs(new_scroll);
+		script->set_function_scroll(edited_func, new_scroll / EDSCALE);
 		script->set_edited(true); //so it's saved
-
 	}
 }
 
-void VisualScriptEditor::goto_line(int p_line, bool p_with_error){
+void VisualScriptEditor::goto_line(int p_line, bool p_with_error) {
 
-	p_line+=1; //add one because script lines begin from 0.
+	p_line += 1; //add one because script lines begin from 0.
 
 	if (p_with_error)
-		error_line=p_line;
+		error_line = p_line;
 
 	List<StringName> functions;
 	script->get_function_list(&functions);
-	for (List<StringName>::Element *E=functions.front();E;E=E->next()) {
+	for (List<StringName>::Element *E = functions.front(); E; E = E->next()) {
 
-		if (script->has_node(E->get(),p_line)) {
+		if (script->has_node(E->get(), p_line)) {
 
-			edited_func=E->get();
-			selected=edited_func;
+			edited_func = E->get();
+			selected = edited_func;
 			_update_graph();
 			_update_members();
 
-			call_deferred("_center_on_node",p_line); //editor might be just created and size might not exist yet
+			call_deferred("_center_on_node", p_line); //editor might be just created and size might not exist yet
 
 			return;
 		}
 	}
 }
 
-void VisualScriptEditor::trim_trailing_whitespace(){
-
-
+void VisualScriptEditor::trim_trailing_whitespace() {
 }
 
-void VisualScriptEditor::ensure_focus(){
+void VisualScriptEditor::ensure_focus() {
 
 	graph->grab_focus();
 }
 
-void VisualScriptEditor::tag_saved_version(){
-
-
+void VisualScriptEditor::tag_saved_version() {
 }
 
-void VisualScriptEditor::reload(bool p_soft){
-
-
+void VisualScriptEditor::reload(bool p_soft) {
 }
 
-void VisualScriptEditor::get_breakpoints(List<int> *p_breakpoints){
+void VisualScriptEditor::get_breakpoints(List<int> *p_breakpoints) {
 
 	List<StringName> functions;
 	script->get_function_list(&functions);
-	for (List<StringName>::Element *E=functions.front();E;E=E->next()) {
+	for (List<StringName>::Element *E = functions.front(); E; E = E->next()) {
 
 		List<int> nodes;
-		script->get_node_list(E->get(),&nodes);
-		for (List<int>::Element *F=nodes.front();F;F=F->next()) {
+		script->get_node_list(E->get(), &nodes);
+		for (List<int>::Element *F = nodes.front(); F; F = F->next()) {
 
-			Ref<VisualScriptNode> vsn = script->get_node(E->get(),F->get());
+			Ref<VisualScriptNode> vsn = script->get_node(E->get(), F->get());
 			if (vsn->is_breakpoint()) {
-				p_breakpoints->push_back(F->get()-1); //subtract 1 because breakpoints in text start from zero
+				p_breakpoints->push_back(F->get() - 1); //subtract 1 because breakpoints in text start from zero
 			}
 		}
 	}
 }
 
-bool VisualScriptEditor::goto_method(const String& p_method){
+bool VisualScriptEditor::goto_method(const String &p_method) {
 
 	if (!script->has_function(p_method))
 		return false;
 
-	edited_func=p_method;
-	selected=edited_func;
+	edited_func = p_method;
+	selected = edited_func;
 	_update_members();
 	_update_graph();
 	return true;
 }
 
-void VisualScriptEditor::add_callback(const String& p_function,PoolStringArray p_args){
+void VisualScriptEditor::add_callback(const String &p_function, PoolStringArray p_args) {
 
 	if (script->has_function(p_function)) {
-		edited_func=p_function;
-		selected=edited_func;
+		edited_func = p_function;
+		selected = edited_func;
 		_update_members();
 		_update_graph();
 		return;
@@ -2364,59 +2215,56 @@ void VisualScriptEditor::add_callback(const String& p_function,PoolStringArray p
 
 	Ref<VisualScriptFunction> func;
 	func.instance();
-	for(int i=0;i<p_args.size();i++) {
+	for (int i = 0; i < p_args.size(); i++) {
 
 		String name = p_args[i];
-		Variant::Type type=Variant::NIL;
+		Variant::Type type = Variant::NIL;
 
-		if (name.find(":")!=-1) {
-			String tt = name.get_slice(":",1);
-			name=name.get_slice(":",0);
-			for(int j=0;j<Variant::VARIANT_MAX;j++) {
+		if (name.find(":") != -1) {
+			String tt = name.get_slice(":", 1);
+			name = name.get_slice(":", 0);
+			for (int j = 0; j < Variant::VARIANT_MAX; j++) {
 
 				String tname = Variant::get_type_name(Variant::Type(j));
-				if (tname==tt) {
-					type=Variant::Type(j);
+				if (tname == tt) {
+					type = Variant::Type(j);
 					break;
 				}
 			}
 		}
 
-		func->add_argument(type,name);
+		func->add_argument(type, name);
 	}
 
 	func->set_name(p_function);
 	script->add_function(p_function);
-	script->add_node(p_function,script->get_available_id(),func);
+	script->add_node(p_function, script->get_available_id(), func);
 
-	edited_func=p_function;
-	selected=edited_func;
+	edited_func = p_function;
+	selected = edited_func;
 	_update_members();
 	_update_graph();
-	graph->call_deferred("set_scroll_ofs",script->get_function_scroll(edited_func)); //for first time it might need to be later
+	graph->call_deferred("set_scroll_ofs", script->get_function_scroll(edited_func)); //for first time it might need to be later
 
 	//undo_redo->clear_history();
-
 }
 
-void VisualScriptEditor::update_settings(){
+void VisualScriptEditor::update_settings() {
 
 	_update_graph();
 }
 
 void VisualScriptEditor::set_debugger_active(bool p_active) {
 	if (!p_active) {
-		error_line=-1;
+		error_line = -1;
 		_update_graph(); //clear line break
 	}
 }
 
-void VisualScriptEditor::set_tooltip_request_func(String p_method,Object* p_obj){
-
-
+void VisualScriptEditor::set_tooltip_request_func(String p_method, Object *p_obj) {
 }
 
-Control *VisualScriptEditor::get_edit_menu(){
+Control *VisualScriptEditor::get_edit_menu() {
 
 	return edit_menu;
 }
@@ -2430,58 +2278,53 @@ void VisualScriptEditor::_change_base_type_callback() {
 
 	String bt = select_base_type->get_selected_type();
 
-	ERR_FAIL_COND(bt==String());
+	ERR_FAIL_COND(bt == String());
 	undo_redo->create_action("Change Base Type");
-	undo_redo->add_do_method(script.ptr(),"set_instance_base_type",bt);
-	undo_redo->add_undo_method(script.ptr(),"set_instance_base_type",script->get_instance_base_type());
-	undo_redo->add_do_method(this,"_update_members");
-	undo_redo->add_undo_method(this,"_update_members");
+	undo_redo->add_do_method(script.ptr(), "set_instance_base_type", bt);
+	undo_redo->add_undo_method(script.ptr(), "set_instance_base_type", script->get_instance_base_type());
+	undo_redo->add_do_method(this, "_update_members");
+	undo_redo->add_undo_method(this, "_update_members");
 	undo_redo->commit_action();
-
 }
 
-void VisualScriptEditor::_node_selected(Node* p_node) {
+void VisualScriptEditor::_node_selected(Node *p_node) {
 
 	Ref<VisualScriptNode> vnode = p_node->get_meta("__vnode");
 	if (vnode.is_null())
 		return;
 
-	EditorNode::get_singleton()->push_item(vnode.ptr());	//edit node in inspector
+	EditorNode::get_singleton()->push_item(vnode.ptr()); //edit node in inspector
 }
 
-static bool _get_out_slot(const Ref<VisualScriptNode>& p_node,int p_slot,int& r_real_slot,bool& r_sequence) {
+static bool _get_out_slot(const Ref<VisualScriptNode> &p_node, int p_slot, int &r_real_slot, bool &r_sequence) {
 
-	if (p_slot<p_node->get_output_sequence_port_count()) {
-		r_sequence=true;
-		r_real_slot=p_slot;
+	if (p_slot < p_node->get_output_sequence_port_count()) {
+		r_sequence = true;
+		r_real_slot = p_slot;
 
 		return true;
 	}
 
-	r_real_slot=p_slot-p_node->get_output_sequence_port_count();
-	r_sequence=false;
-
-	return (r_real_slot<p_node->get_output_value_port_count());
+	r_real_slot = p_slot - p_node->get_output_sequence_port_count();
+	r_sequence = false;
 
+	return (r_real_slot < p_node->get_output_value_port_count());
 }
 
-static bool _get_in_slot(const Ref<VisualScriptNode>& p_node,int p_slot,int& r_real_slot,bool& r_sequence) {
+static bool _get_in_slot(const Ref<VisualScriptNode> &p_node, int p_slot, int &r_real_slot, bool &r_sequence) {
 
-	if (p_slot==0 && p_node->has_input_sequence_port()) {
-		r_sequence=true;
-		r_real_slot=0;
+	if (p_slot == 0 && p_node->has_input_sequence_port()) {
+		r_sequence = true;
+		r_real_slot = 0;
 		return true;
 	}
 
+	r_real_slot = p_slot - (p_node->has_input_sequence_port() ? 1 : 0);
+	r_sequence = false;
 
-	r_real_slot=p_slot-(p_node->has_input_sequence_port()?1:0);
-	r_sequence=false;
-
-	return r_real_slot<p_node->get_input_value_port_count();
-
+	return r_real_slot < p_node->get_input_value_port_count();
 }
 
-
 void VisualScriptEditor::_begin_node_move() {
 
 	undo_redo->create_action("Move Node(s)");
@@ -2492,164 +2335,151 @@ void VisualScriptEditor::_end_node_move() {
 	undo_redo->commit_action();
 }
 
-void VisualScriptEditor::_move_node(String func,int p_id,const Vector2& p_to) {
-
+void VisualScriptEditor::_move_node(String func, int p_id, const Vector2 &p_to) {
 
-
-	if (func==String(edited_func)) {
-		Node* node = graph->get_node(itos(p_id));
+	if (func == String(edited_func)) {
+		Node *node = graph->get_node(itos(p_id));
 		if (node && node->cast_to<GraphNode>())
 			node->cast_to<GraphNode>()->set_offset(p_to);
 	}
-	script->set_node_pos(edited_func,p_id,p_to/EDSCALE);
+	script->set_node_pos(edited_func, p_id, p_to / EDSCALE);
 }
 
-void VisualScriptEditor::_node_moved(Vector2 p_from,Vector2 p_to, int p_id) {
+void VisualScriptEditor::_node_moved(Vector2 p_from, Vector2 p_to, int p_id) {
 
-	undo_redo->add_do_method(this,"_move_node",String(edited_func),p_id,p_to);
-	undo_redo->add_undo_method(this,"_move_node",String(edited_func),p_id,p_from);
+	undo_redo->add_do_method(this, "_move_node", String(edited_func), p_id, p_to);
+	undo_redo->add_undo_method(this, "_move_node", String(edited_func), p_id, p_from);
 }
 
 void VisualScriptEditor::_remove_node(int p_id) {
 
-
 	undo_redo->create_action("Remove VisualScript Node");
 
-	undo_redo->add_do_method(script.ptr(),"remove_node",edited_func,p_id);
-	undo_redo->add_undo_method(script.ptr(),"add_node",edited_func,p_id,script->get_node(edited_func,p_id),script->get_node_pos(edited_func,p_id));
-
+	undo_redo->add_do_method(script.ptr(), "remove_node", edited_func, p_id);
+	undo_redo->add_undo_method(script.ptr(), "add_node", edited_func, p_id, script->get_node(edited_func, p_id), script->get_node_pos(edited_func, p_id));
 
 	List<VisualScript::SequenceConnection> sequence_conns;
-	script->get_sequence_connection_list(edited_func,&sequence_conns);
-
+	script->get_sequence_connection_list(edited_func, &sequence_conns);
 
-	for (List<VisualScript::SequenceConnection>::Element *E=sequence_conns.front();E;E=E->next()) {
+	for (List<VisualScript::SequenceConnection>::Element *E = sequence_conns.front(); E; E = E->next()) {
 
-		if (E->get().from_node==p_id || E->get().to_node==p_id) {
-			undo_redo->add_undo_method(script.ptr(),"sequence_connect",edited_func,E->get().from_node,E->get().from_output,E->get().to_node);
+		if (E->get().from_node == p_id || E->get().to_node == p_id) {
+			undo_redo->add_undo_method(script.ptr(), "sequence_connect", edited_func, E->get().from_node, E->get().from_output, E->get().to_node);
 		}
 	}
 
 	List<VisualScript::DataConnection> data_conns;
-	script->get_data_connection_list(edited_func,&data_conns);
+	script->get_data_connection_list(edited_func, &data_conns);
 
-	for (List<VisualScript::DataConnection>::Element *E=data_conns.front();E;E=E->next()) {
+	for (List<VisualScript::DataConnection>::Element *E = data_conns.front(); E; E = E->next()) {
 
-		if (E->get().from_node==p_id || E->get().to_node==p_id) {
-			undo_redo->add_undo_method(script.ptr(),"data_connect",edited_func,E->get().from_node,E->get().from_port,E->get().to_node,E->get().to_port);
+		if (E->get().from_node == p_id || E->get().to_node == p_id) {
+			undo_redo->add_undo_method(script.ptr(), "data_connect", edited_func, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
 		}
 	}
 
-	undo_redo->add_do_method(this,"_update_graph");
-	undo_redo->add_undo_method(this,"_update_graph");
+	undo_redo->add_do_method(this, "_update_graph");
+	undo_redo->add_undo_method(this, "_update_graph");
 
 	undo_redo->commit_action();
 }
 
+void VisualScriptEditor::_node_ports_changed(const String &p_func, int p_id) {
 
-void VisualScriptEditor::_node_ports_changed(const String& p_func,int p_id) {
-
-	if (p_func!=String(edited_func))
+	if (p_func != String(edited_func))
 		return;
 
 	_update_graph(p_id);
 }
 
-void VisualScriptEditor::_graph_connected(const String& p_from,int p_from_slot,const String& p_to,int p_to_slot) {
+void VisualScriptEditor::_graph_connected(const String &p_from, int p_from_slot, const String &p_to, int p_to_slot) {
 
-	Ref<VisualScriptNode> from_node = script->get_node(edited_func,p_from.to_int());
+	Ref<VisualScriptNode> from_node = script->get_node(edited_func, p_from.to_int());
 	ERR_FAIL_COND(!from_node.is_valid());
 
 	bool from_seq;
 	int from_port;
 
-	if (!_get_out_slot(from_node,p_from_slot,from_port,from_seq))
+	if (!_get_out_slot(from_node, p_from_slot, from_port, from_seq))
 		return; //can't  connect this, it' s invalid
 
-	Ref<VisualScriptNode> to_node = script->get_node(edited_func,p_to.to_int());
+	Ref<VisualScriptNode> to_node = script->get_node(edited_func, p_to.to_int());
 	ERR_FAIL_COND(!to_node.is_valid());
 
 	bool to_seq;
 	int to_port;
 
-	if (!_get_in_slot(to_node,p_to_slot,to_port,to_seq))
+	if (!_get_in_slot(to_node, p_to_slot, to_port, to_seq))
 		return; //can't  connect this, it' s invalid
 
-
-	ERR_FAIL_COND(from_seq!=to_seq);
-
+	ERR_FAIL_COND(from_seq != to_seq);
 
 	undo_redo->create_action("Connect Nodes");
 
 	if (from_seq) {
-		undo_redo->add_do_method(script.ptr(),"sequence_connect",edited_func,p_from.to_int(),from_port,p_to.to_int());
-		undo_redo->add_undo_method(script.ptr(),"sequence_disconnect",edited_func,p_from.to_int(),from_port,p_to.to_int());
+		undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, p_from.to_int(), from_port, p_to.to_int());
+		undo_redo->add_undo_method(script.ptr(), "sequence_disconnect", edited_func, p_from.to_int(), from_port, p_to.to_int());
 	} else {
-		undo_redo->add_do_method(script.ptr(),"data_connect",edited_func,p_from.to_int(),from_port,p_to.to_int(),to_port);
-		undo_redo->add_undo_method(script.ptr(),"data_disconnect",edited_func,p_from.to_int(),from_port,p_to.to_int(),to_port);
+		undo_redo->add_do_method(script.ptr(), "data_connect", edited_func, p_from.to_int(), from_port, p_to.to_int(), to_port);
+		undo_redo->add_undo_method(script.ptr(), "data_disconnect", edited_func, p_from.to_int(), from_port, p_to.to_int(), to_port);
 		//update nodes in sgraph
-		undo_redo->add_do_method(this,"_update_graph",p_from.to_int());
-		undo_redo->add_do_method(this,"_update_graph",p_to.to_int());
-		undo_redo->add_undo_method(this,"_update_graph",p_from.to_int());
-		undo_redo->add_undo_method(this,"_update_graph",p_to.to_int());
+		undo_redo->add_do_method(this, "_update_graph", p_from.to_int());
+		undo_redo->add_do_method(this, "_update_graph", p_to.to_int());
+		undo_redo->add_undo_method(this, "_update_graph", p_from.to_int());
+		undo_redo->add_undo_method(this, "_update_graph", p_to.to_int());
 	}
 
-	undo_redo->add_do_method(this,"_update_graph_connections");
-	undo_redo->add_undo_method(this,"_update_graph_connections");
+	undo_redo->add_do_method(this, "_update_graph_connections");
+	undo_redo->add_undo_method(this, "_update_graph_connections");
 
 	undo_redo->commit_action();
-
 }
 
-void VisualScriptEditor::_graph_disconnected(const String& p_from,int p_from_slot,const String& p_to,int p_to_slot){
+void VisualScriptEditor::_graph_disconnected(const String &p_from, int p_from_slot, const String &p_to, int p_to_slot) {
 
-	Ref<VisualScriptNode> from_node = script->get_node(edited_func,p_from.to_int());
+	Ref<VisualScriptNode> from_node = script->get_node(edited_func, p_from.to_int());
 	ERR_FAIL_COND(!from_node.is_valid());
 
 	bool from_seq;
 	int from_port;
 
-	if (!_get_out_slot(from_node,p_from_slot,from_port,from_seq))
+	if (!_get_out_slot(from_node, p_from_slot, from_port, from_seq))
 		return; //can't  connect this, it' s invalid
 
-	Ref<VisualScriptNode> to_node = script->get_node(edited_func,p_to.to_int());
+	Ref<VisualScriptNode> to_node = script->get_node(edited_func, p_to.to_int());
 	ERR_FAIL_COND(!to_node.is_valid());
 
 	bool to_seq;
 	int to_port;
 
-	if (!_get_in_slot(to_node,p_to_slot,to_port,to_seq))
+	if (!_get_in_slot(to_node, p_to_slot, to_port, to_seq))
 		return; //can't  connect this, it' s invalid
 
-
-	ERR_FAIL_COND(from_seq!=to_seq);
-
+	ERR_FAIL_COND(from_seq != to_seq);
 
 	undo_redo->create_action("Connect Nodes");
 
 	if (from_seq) {
-		undo_redo->add_do_method(script.ptr(),"sequence_disconnect",edited_func,p_from.to_int(),from_port,p_to.to_int());
-		undo_redo->add_undo_method(script.ptr(),"sequence_connect",edited_func,p_from.to_int(),from_port,p_to.to_int());
+		undo_redo->add_do_method(script.ptr(), "sequence_disconnect", edited_func, p_from.to_int(), from_port, p_to.to_int());
+		undo_redo->add_undo_method(script.ptr(), "sequence_connect", edited_func, p_from.to_int(), from_port, p_to.to_int());
 	} else {
-		undo_redo->add_do_method(script.ptr(),"data_disconnect",edited_func,p_from.to_int(),from_port,p_to.to_int(),to_port);
-		undo_redo->add_undo_method(script.ptr(),"data_connect",edited_func,p_from.to_int(),from_port,p_to.to_int(),to_port);
+		undo_redo->add_do_method(script.ptr(), "data_disconnect", edited_func, p_from.to_int(), from_port, p_to.to_int(), to_port);
+		undo_redo->add_undo_method(script.ptr(), "data_connect", edited_func, p_from.to_int(), from_port, p_to.to_int(), to_port);
 		//update nodes in sgraph
-		undo_redo->add_do_method(this,"_update_graph",p_from.to_int());
-		undo_redo->add_do_method(this,"_update_graph",p_to.to_int());
-		undo_redo->add_undo_method(this,"_update_graph",p_from.to_int());
-		undo_redo->add_undo_method(this,"_update_graph",p_to.to_int());
+		undo_redo->add_do_method(this, "_update_graph", p_from.to_int());
+		undo_redo->add_do_method(this, "_update_graph", p_to.to_int());
+		undo_redo->add_undo_method(this, "_update_graph", p_from.to_int());
+		undo_redo->add_undo_method(this, "_update_graph", p_to.to_int());
 	}
-	undo_redo->add_do_method(this,"_update_graph_connections");
-	undo_redo->add_undo_method(this,"_update_graph_connections");
+	undo_redo->add_do_method(this, "_update_graph_connections");
+	undo_redo->add_undo_method(this, "_update_graph_connections");
 
 	undo_redo->commit_action();
 }
 
+void VisualScriptEditor::_graph_connect_to_empty(const String &p_from, int p_from_slot, const Vector2 &p_release_pos) {
 
-
-void VisualScriptEditor::_graph_connect_to_empty(const String& p_from,int p_from_slot,const Vector2& p_release_pos) {
-
-	Node* node = graph->get_node(p_from);
+	Node *node = graph->get_node(p_from);
 	if (!node)
 		return;
 
@@ -2657,54 +2487,50 @@ void VisualScriptEditor::_graph_connect_to_empty(const String& p_from,int p_from
 	if (!gn)
 		return;
 
-	Ref<VisualScriptNode> vsn = script->get_node(edited_func,p_from.to_int());
+	Ref<VisualScriptNode> vsn = script->get_node(edited_func, p_from.to_int());
 	if (!vsn.is_valid())
 		return;
 
-	if (p_from_slot<vsn->get_output_sequence_port_count()) {
+	if (p_from_slot < vsn->get_output_sequence_port_count()) {
 
 		port_action_popup->clear();
-		port_action_popup->add_item(TTR("Condition"),CREATE_COND);
-		port_action_popup->add_item(TTR("Sequence"),CREATE_SEQUENCE);
-		port_action_popup->add_item(TTR("Switch"),CREATE_SWITCH);
-		port_action_popup->add_item(TTR("Iterator"),CREATE_ITERATOR);
-		port_action_popup->add_item(TTR("While"),CREATE_WHILE);
-		port_action_popup->add_item(TTR("Return"),CREATE_RETURN);
+		port_action_popup->add_item(TTR("Condition"), CREATE_COND);
+		port_action_popup->add_item(TTR("Sequence"), CREATE_SEQUENCE);
+		port_action_popup->add_item(TTR("Switch"), CREATE_SWITCH);
+		port_action_popup->add_item(TTR("Iterator"), CREATE_ITERATOR);
+		port_action_popup->add_item(TTR("While"), CREATE_WHILE);
+		port_action_popup->add_item(TTR("Return"), CREATE_RETURN);
 
-		port_action_node=p_from.to_int();
-		port_action_output=p_from_slot;
+		port_action_node = p_from.to_int();
+		port_action_output = p_from_slot;
 
 	} else {
 		port_action_popup->clear();
-		port_action_popup->add_item(TTR("Call"),CREATE_CALL);
-		port_action_popup->add_item(TTR("Get"),CREATE_GET);
-		port_action_popup->add_item(TTR("Set"),CREATE_SET);
-
-
-		port_action_output=p_from_slot-vsn->get_output_sequence_port_count();
-		port_action_node=p_from.to_int();
-
+		port_action_popup->add_item(TTR("Call"), CREATE_CALL);
+		port_action_popup->add_item(TTR("Get"), CREATE_GET);
+		port_action_popup->add_item(TTR("Set"), CREATE_SET);
 
+		port_action_output = p_from_slot - vsn->get_output_sequence_port_count();
+		port_action_node = p_from.to_int();
 	}
 
-	port_action_pos=p_release_pos;
-	port_action_popup->set_size(Size2(1,1));
-	port_action_popup->set_pos(graph->get_global_pos()+p_release_pos);
+	port_action_pos = p_release_pos;
+	port_action_popup->set_size(Size2(1, 1));
+	port_action_popup->set_pos(graph->get_global_pos() + p_release_pos);
 	port_action_popup->popup();
 }
 
-VisualScriptNode::TypeGuess  VisualScriptEditor::_guess_output_type(int p_node,int p_output,Set<int> &visited_nodes) {
-
+VisualScriptNode::TypeGuess VisualScriptEditor::_guess_output_type(int p_node, int p_output, Set<int> &visited_nodes) {
 
 	VisualScriptNode::TypeGuess tg;
-	tg.type=Variant::NIL;
+	tg.type = Variant::NIL;
 
 	if (visited_nodes.has(p_node))
 		return tg; //no loop
 
 	visited_nodes.insert(p_node);
 
-	Ref<VisualScriptNode> node = script->get_node(edited_func,p_node);
+	Ref<VisualScriptNode> node = script->get_node(edited_func, p_node);
 
 	if (!node.is_valid()) {
 
@@ -2713,40 +2539,39 @@ VisualScriptNode::TypeGuess  VisualScriptEditor::_guess_output_type(int p_node,i
 
 	Vector<VisualScriptNode::TypeGuess> in_guesses;
 
-	for(int i=0;i<node->get_input_value_port_count();i++) {
+	for (int i = 0; i < node->get_input_value_port_count(); i++) {
 		PropertyInfo pi = node->get_input_value_port_info(i);
 		VisualScriptNode::TypeGuess g;
-		g.type=pi.type;
+		g.type = pi.type;
 
-		if (g.type==Variant::NIL || g.type==Variant::OBJECT) {
+		if (g.type == Variant::NIL || g.type == Variant::OBJECT) {
 			//any or object input, must further guess what this is
 			int from_node;
 			int from_port;
 
-			if (script->get_input_value_port_connection_source(edited_func,p_node,i,&from_node,&from_port)) {
+			if (script->get_input_value_port_connection_source(edited_func, p_node, i, &from_node, &from_port)) {
 
-				g = _guess_output_type(from_node,from_port,visited_nodes);
+				g = _guess_output_type(from_node, from_port, visited_nodes);
 			} else {
 				Variant defval = node->get_default_input_value(i);
-				if (defval.get_type()==Variant::OBJECT) {
+				if (defval.get_type() == Variant::OBJECT) {
 
 					Object *obj = defval;
 
 					if (obj) {
 
-						g.type=Variant::OBJECT;
-						g.GDCLASS=obj->get_class();
-						g.script=obj->get_script();
+						g.type = Variant::OBJECT;
+						g.GDCLASS = obj->get_class();
+						g.script = obj->get_script();
 					}
 				}
 			}
-
 		}
 
 		in_guesses.push_back(g);
 	}
 
-	return node->guess_output_type(in_guesses.ptr(),p_output);
+	return node->guess_output_type(in_guesses.ptr(), p_output);
 }
 
 void VisualScriptEditor::_port_action_menu(int p_option) {
@@ -2754,29 +2579,29 @@ void VisualScriptEditor::_port_action_menu(int p_option) {
 	Vector2 ofs = graph->get_scroll_ofs() + port_action_pos;
 	if (graph->is_using_snap()) {
 		int snap = graph->get_snap();
-		ofs = ofs.snapped(Vector2(snap,snap));
+		ofs = ofs.snapped(Vector2(snap, snap));
 	}
-	ofs/=EDSCALE;
+	ofs /= EDSCALE;
 
-	bool seq_connect=false;
+	bool seq_connect = false;
 
 	Ref<VisualScriptNode> vnode;
 	Set<int> vn;
 
-	switch(p_option) {
+	switch (p_option) {
 
 		case CREATE_CALL: {
 
 			Ref<VisualScriptFunctionCall> n;
 			n.instance();
-			vnode=n;
+			vnode = n;
 
-			VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node,port_action_output,vn);
+			VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
 
-			if (tg.type==Variant::OBJECT) {
+			if (tg.type == Variant::OBJECT) {
 				n->set_call_mode(VisualScriptFunctionCall::CALL_MODE_INSTANCE);
 
-				if (tg.GDCLASS!=StringName()) {
+				if (tg.GDCLASS != StringName()) {
 					n->set_base_type(tg.GDCLASS);
 				} else {
 					n->set_base_type("Object");
@@ -2789,29 +2614,25 @@ void VisualScriptEditor::_port_action_menu(int p_option) {
 					new_connect_node_select->select_method_from_base_type(n->get_base_type());
 				}
 
-
 			} else {
 				n->set_call_mode(VisualScriptFunctionCall::CALL_MODE_BASIC_TYPE);
 				n->set_basic_type(tg.type);
 				new_connect_node_select->select_method_from_basic_type(tg.type);
 			}
 
-
-
 		} break;
 		case CREATE_SET: {
 
 			Ref<VisualScriptPropertySet> n;
 			n.instance();
-			vnode=n;
-
+			vnode = n;
 
-			VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node,port_action_output,vn);
+			VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
 
-			if (tg.type==Variant::OBJECT) {
+			if (tg.type == Variant::OBJECT) {
 				n->set_call_mode(VisualScriptPropertySet::CALL_MODE_INSTANCE);
 
-				if (tg.GDCLASS!=StringName()) {
+				if (tg.GDCLASS != StringName()) {
 					n->set_base_type(tg.GDCLASS);
 				} else {
 					n->set_base_type("Object");
@@ -2824,25 +2645,24 @@ void VisualScriptEditor::_port_action_menu(int p_option) {
 					new_connect_node_select->select_property_from_base_type(n->get_base_type());
 				}
 
-
 			} else {
 				n->set_call_mode(VisualScriptPropertySet::CALL_MODE_BASIC_TYPE);
 				n->set_basic_type(tg.type);
-				new_connect_node_select->select_property_from_basic_type(tg.type,tg.ev_type);
+				new_connect_node_select->select_property_from_basic_type(tg.type, tg.ev_type);
 			}
 		} break;
 		case CREATE_GET: {
 
 			Ref<VisualScriptPropertyGet> n;
 			n.instance();
-			vnode=n;
+			vnode = n;
 
-			VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node,port_action_output,vn);
+			VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
 
-			if (tg.type==Variant::OBJECT) {
+			if (tg.type == Variant::OBJECT) {
 				n->set_call_mode(VisualScriptPropertyGet::CALL_MODE_INSTANCE);
 
-				if (tg.GDCLASS!=StringName()) {
+				if (tg.GDCLASS != StringName()) {
 					n->set_base_type(tg.GDCLASS);
 				} else {
 					n->set_base_type("Object");
@@ -2855,11 +2675,10 @@ void VisualScriptEditor::_port_action_menu(int p_option) {
 					new_connect_node_select->select_property_from_base_type(n->get_base_type());
 				}
 
-
 			} else {
 				n->set_call_mode(VisualScriptPropertyGet::CALL_MODE_BASIC_TYPE);
 				n->set_basic_type(tg.type);
-				new_connect_node_select->select_property_from_basic_type(tg.type,tg.ev_type);
+				new_connect_node_select->select_property_from_basic_type(tg.type, tg.ev_type);
 			}
 
 		} break;
@@ -2867,147 +2686,139 @@ void VisualScriptEditor::_port_action_menu(int p_option) {
 
 			Ref<VisualScriptCondition> n;
 			n.instance();
-			vnode=n;
-			seq_connect=true;
+			vnode = n;
+			seq_connect = true;
 
 		} break;
 		case CREATE_SEQUENCE: {
 
 			Ref<VisualScriptSequence> n;
 			n.instance();
-			vnode=n;
-			seq_connect=true;
+			vnode = n;
+			seq_connect = true;
 
 		} break;
 		case CREATE_SWITCH: {
 
 			Ref<VisualScriptSwitch> n;
 			n.instance();
-			vnode=n;
-			seq_connect=true;
+			vnode = n;
+			seq_connect = true;
 
 		} break;
 		case CREATE_ITERATOR: {
 
 			Ref<VisualScriptIterator> n;
 			n.instance();
-			vnode=n;
-			seq_connect=true;
+			vnode = n;
+			seq_connect = true;
 
 		} break;
 		case CREATE_WHILE: {
 
 			Ref<VisualScriptWhile> n;
 			n.instance();
-			vnode=n;
-			seq_connect=true;
+			vnode = n;
+			seq_connect = true;
 
 		} break;
 		case CREATE_RETURN: {
 
 			Ref<VisualScriptReturn> n;
 			n.instance();
-			vnode=n;
-			seq_connect=true;
+			vnode = n;
+			seq_connect = true;
 
 		} break;
-
 	}
 
 	int new_id = script->get_available_id();
 	undo_redo->create_action(TTR("Add Node"));
-	undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,vnode,ofs);
+	undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
 	if (seq_connect) {
-		undo_redo->add_do_method(script.ptr(),"sequence_connect",edited_func,port_action_node,port_action_output,new_id);
+		undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, port_action_node, port_action_output, new_id);
 	}
-	undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
-	undo_redo->add_do_method(this,"_update_graph",new_id);
-	undo_redo->add_undo_method(this,"_update_graph",new_id);
+	undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
+	undo_redo->add_do_method(this, "_update_graph", new_id);
+	undo_redo->add_undo_method(this, "_update_graph", new_id);
 	undo_redo->commit_action();
 
-	port_action_new_node=new_id;
-
+	port_action_new_node = new_id;
 }
 
-void VisualScriptEditor::_selected_connect_node_method_or_setget(const String& p_text) {
+void VisualScriptEditor::_selected_connect_node_method_or_setget(const String &p_text) {
 
-	Ref<VisualScriptNode> vsn = script->get_node(edited_func,port_action_new_node);
+	Ref<VisualScriptNode> vsn = script->get_node(edited_func, port_action_new_node);
 
 	if (vsn->cast_to<VisualScriptFunctionCall>()) {
 
 		Ref<VisualScriptFunctionCall> vsfc = vsn;
 		vsfc->set_function(p_text);
-		script->data_connect(edited_func,port_action_node,port_action_output,port_action_new_node,0);
+		script->data_connect(edited_func, port_action_node, port_action_output, port_action_new_node, 0);
 	}
 
 	if (vsn->cast_to<VisualScriptPropertySet>()) {
 
 		Ref<VisualScriptPropertySet> vsp = vsn;
 		vsp->set_property(p_text);
-		script->data_connect(edited_func,port_action_node,port_action_output,port_action_new_node,0);
+		script->data_connect(edited_func, port_action_node, port_action_output, port_action_new_node, 0);
 	}
 
 	if (vsn->cast_to<VisualScriptPropertyGet>()) {
 
 		Ref<VisualScriptPropertyGet> vsp = vsn;
 		vsp->set_property(p_text);
-		script->data_connect(edited_func,port_action_node,port_action_output,port_action_new_node,0);
+		script->data_connect(edited_func, port_action_node, port_action_output, port_action_new_node, 0);
 	}
 
 	_update_graph(port_action_new_node);
 	_update_graph_connections();
-
 }
 
-
 void VisualScriptEditor::_default_value_changed() {
 
-
-	Ref<VisualScriptNode> vsn = script->get_node(edited_func,editing_id);
+	Ref<VisualScriptNode> vsn = script->get_node(edited_func, editing_id);
 	if (vsn.is_null())
 		return;
 
 	undo_redo->create_action("Change Input Value");
-	undo_redo->add_do_method(vsn.ptr(),"set_default_input_value",editing_input,default_value_edit->get_variant());
-	undo_redo->add_undo_method(vsn.ptr(),"set_default_input_value",editing_input,vsn->get_default_input_value(editing_input));
+	undo_redo->add_do_method(vsn.ptr(), "set_default_input_value", editing_input, default_value_edit->get_variant());
+	undo_redo->add_undo_method(vsn.ptr(), "set_default_input_value", editing_input, vsn->get_default_input_value(editing_input));
 
-	undo_redo->add_do_method(this,"_update_graph",editing_id);
-	undo_redo->add_undo_method(this,"_update_graph",editing_id);
+	undo_redo->add_do_method(this, "_update_graph", editing_id);
+	undo_redo->add_undo_method(this, "_update_graph", editing_id);
 	undo_redo->commit_action();
-
 }
 
-void VisualScriptEditor::_default_value_edited(Node * p_button,int p_id,int p_input_port) {
+void VisualScriptEditor::_default_value_edited(Node *p_button, int p_id, int p_input_port) {
 
-	Ref<VisualScriptNode> vsn = script->get_node(edited_func,p_id);
+	Ref<VisualScriptNode> vsn = script->get_node(edited_func, p_id);
 	if (vsn.is_null())
 		return;
 
 	PropertyInfo pinfo = vsn->get_input_value_port_info(p_input_port);
 	Variant existing = vsn->get_default_input_value(p_input_port);
-	if (pinfo.type!=Variant::NIL && existing.get_type()!=pinfo.type) {
+	if (pinfo.type != Variant::NIL && existing.get_type() != pinfo.type) {
 
 		Variant::CallError ce;
-		const Variant *existingp=&existing;
-		existing = Variant::construct(pinfo.type,&existingp,1,ce,false);
-
+		const Variant *existingp = &existing;
+		existing = Variant::construct(pinfo.type, &existingp, 1, ce, false);
 	}
 
-	default_value_edit->set_pos(p_button->cast_to<Control>()->get_global_pos()+Vector2(0,p_button->cast_to<Control>()->get_size().y));
-	default_value_edit->set_size(Size2(1,1));
-	if (default_value_edit->edit(NULL,pinfo.name,pinfo.type,existing,pinfo.hint,pinfo.hint_string)) {
-		if (pinfo.hint==PROPERTY_HINT_MULTILINE_TEXT)
+	default_value_edit->set_pos(p_button->cast_to<Control>()->get_global_pos() + Vector2(0, p_button->cast_to<Control>()->get_size().y));
+	default_value_edit->set_size(Size2(1, 1));
+	if (default_value_edit->edit(NULL, pinfo.name, pinfo.type, existing, pinfo.hint, pinfo.hint_string)) {
+		if (pinfo.hint == PROPERTY_HINT_MULTILINE_TEXT)
 			default_value_edit->popup_centered_ratio();
 		else
 			default_value_edit->popup();
 	}
 
 	editing_id = p_id;
-	editing_input=p_input_port;
-
+	editing_input = p_input_port;
 }
 
-void VisualScriptEditor::_show_hint(const String& p_hint) {
+void VisualScriptEditor::_show_hint(const String &p_hint) {
 
 	hint_text->set_text(p_hint);
 	hint_text->show();
@@ -3019,38 +2830,38 @@ void VisualScriptEditor::_hide_timer() {
 	hint_text->hide();
 }
 
-void VisualScriptEditor::_node_filter_changed(const String& p_text) {
+void VisualScriptEditor::_node_filter_changed(const String &p_text) {
 
 	_update_available_nodes();
 }
 
-void  VisualScriptEditor::_notification(int p_what) {
+void VisualScriptEditor::_notification(int p_what) {
 
-	if (p_what==NOTIFICATION_READY) {
-		node_filter_icon->set_texture(Control::get_icon("Zoom","EditorIcons"));
+	if (p_what == NOTIFICATION_READY) {
+		node_filter_icon->set_texture(Control::get_icon("Zoom", "EditorIcons"));
 	}
 }
 
-void VisualScriptEditor::_graph_ofs_changed(const Vector2& p_ofs) {
+void VisualScriptEditor::_graph_ofs_changed(const Vector2 &p_ofs) {
 
 	if (updating_graph)
 		return;
 
-	updating_graph=true;
+	updating_graph = true;
 
 	if (script->has_function(edited_func)) {
-		script->set_function_scroll(edited_func,graph->get_scroll_ofs()/EDSCALE);
+		script->set_function_scroll(edited_func, graph->get_scroll_ofs() / EDSCALE);
 		script->set_edited(true);
 	}
-	updating_graph=false;
+	updating_graph = false;
 }
 
-void VisualScriptEditor::_comment_node_resized(const Vector2& p_new_size,int p_node) {
+void VisualScriptEditor::_comment_node_resized(const Vector2 &p_new_size, int p_node) {
 
 	if (updating_graph)
 		return;
 
-	Ref<VisualScriptComment> vsc = script->get_node(edited_func,p_node);
+	Ref<VisualScriptComment> vsc = script->get_node(edited_func, p_node);
 	if (vsc.is_null())
 		return;
 
@@ -3061,38 +2872,36 @@ void VisualScriptEditor::_comment_node_resized(const Vector2& p_new_size,int p_n
 	if (!gn)
 		return;
 
-	updating_graph=true;
+	updating_graph = true;
 
 	graph->set_block_minimum_size_adjust(true); //faster resize
 
-	undo_redo->create_action("Resize Comment",UndoRedo::MERGE_ENDS);
-	undo_redo->add_do_method(vsc.ptr(),"set_size",p_new_size/EDSCALE);
-	undo_redo->add_undo_method(vsc.ptr(),"set_size",vsc->get_size());
+	undo_redo->create_action("Resize Comment", UndoRedo::MERGE_ENDS);
+	undo_redo->add_do_method(vsc.ptr(), "set_size", p_new_size / EDSCALE);
+	undo_redo->add_undo_method(vsc.ptr(), "set_size", vsc->get_size());
 	undo_redo->commit_action();
 
 	gn->set_custom_minimum_size(p_new_size); //for this time since graph update is blocked
-	gn->set_size(Size2(1,1));
+	gn->set_size(Size2(1, 1));
 	graph->set_block_minimum_size_adjust(false);
-	updating_graph=false;
-
-
+	updating_graph = false;
 }
 
 void VisualScriptEditor::_menu_option(int p_what) {
 
-	switch(p_what) {
+	switch (p_what) {
 		case EDIT_DELETE_NODES: {
 			_on_nodes_delete();
 		} break;
 		case EDIT_TOGGLE_BREAKPOINT: {
 
 			List<String> reselect;
-			for(int i=0;i<graph->get_child_count();i++) {
+			for (int i = 0; i < graph->get_child_count(); i++) {
 				GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
 				if (gn) {
 					if (gn->is_selected()) {
 						int id = String(gn->get_name()).to_int();
-						Ref<VisualScriptNode> vsn = script->get_node(edited_func,id);
+						Ref<VisualScriptNode> vsn = script->get_node(edited_func, id);
 						if (vsn.is_valid()) {
 							vsn->set_breakpoint(!vsn->is_breakpoint());
 							reselect.push_back(gn->get_name());
@@ -3103,7 +2912,7 @@ void VisualScriptEditor::_menu_option(int p_what) {
 
 			_update_graph();
 
-			for(List<String>::Element *E=reselect.front();E;E=E->next()) {
+			for (List<String>::Element *E = reselect.front(); E; E = E->next()) {
 				GraphNode *gn = graph->get_node(E->get())->cast_to<GraphNode>();
 				gn->set_selected(true);
 			}
@@ -3124,22 +2933,21 @@ void VisualScriptEditor::_menu_option(int p_what) {
 			clipboard->data_connections.clear();
 			clipboard->sequence_connections.clear();
 
-			for(int i=0;i<graph->get_child_count();i++) {
+			for (int i = 0; i < graph->get_child_count(); i++) {
 				GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
 				if (gn) {
 					if (gn->is_selected()) {
 
 						int id = String(gn->get_name()).to_int();
-						Ref<VisualScriptNode> node = script->get_node(edited_func,id);
+						Ref<VisualScriptNode> node = script->get_node(edited_func, id);
 						if (node->cast_to<VisualScriptFunction>()) {
 							EditorNode::get_singleton()->show_warning("Can't copy the function node.");
 							return;
 						}
 						if (node.is_valid()) {
-							clipboard->nodes[id]=node->duplicate();
-							clipboard->nodes_positions[id]=script->get_node_pos(edited_func,id);
+							clipboard->nodes[id] = node->duplicate();
+							clipboard->nodes_positions[id] = script->get_node_pos(edited_func, id);
 						}
-
 					}
 				}
 			}
@@ -3149,9 +2957,9 @@ void VisualScriptEditor::_menu_option(int p_what) {
 
 			List<VisualScript::SequenceConnection> sequence_connections;
 
-			script->get_sequence_connection_list(edited_func,&sequence_connections);
+			script->get_sequence_connection_list(edited_func, &sequence_connections);
 
-			for (List<VisualScript::SequenceConnection>::Element *E=sequence_connections.front();E;E=E->next()) {
+			for (List<VisualScript::SequenceConnection>::Element *E = sequence_connections.front(); E; E = E->next()) {
 
 				if (clipboard->nodes.has(E->get().from_node) && clipboard->nodes.has(E->get().to_node)) {
 
@@ -3161,9 +2969,9 @@ void VisualScriptEditor::_menu_option(int p_what) {
 
 			List<VisualScript::DataConnection> data_connections;
 
-			script->get_data_connection_list(edited_func,&data_connections);
+			script->get_data_connection_list(edited_func, &data_connections);
 
-			for (List<VisualScript::DataConnection>::Element *E=data_connections.front();E;E=E->next()) {
+			for (List<VisualScript::DataConnection>::Element *E = data_connections.front(); E; E = E->next()) {
 
 				if (clipboard->nodes.has(E->get().from_node) && clipboard->nodes.has(E->get().to_node)) {
 
@@ -3171,11 +2979,10 @@ void VisualScriptEditor::_menu_option(int p_what) {
 				}
 			}
 
-			if (p_what==EDIT_CUT_NODES) {
+			if (p_what == EDIT_CUT_NODES) {
 				_on_nodes_delete(); // oh yeah, also delete on cut
 			}
 
-
 		} break;
 		case EDIT_PASTE_NODES: {
 			if (!script->has_function(edited_func))
@@ -3186,10 +2993,10 @@ void VisualScriptEditor::_menu_option(int p_what) {
 				break;
 			}
 
-			Map<int,int> remap;
+			Map<int, int> remap;
 
 			undo_redo->create_action("Paste VisualScript Nodes");
-			int idc=script->get_available_id()+1;
+			int idc = script->get_available_id() + 1;
 
 			Set<int> to_select;
 
@@ -3197,137 +3004,118 @@ void VisualScriptEditor::_menu_option(int p_what) {
 
 			{
 				List<int> nodes;
-				script->get_node_list(edited_func,&nodes);
-				for (List<int>::Element *E=nodes.front();E;E=E->next()) {
-					Vector2 pos = script->get_node_pos(edited_func,E->get()).snapped(Vector2(2,2));
+				script->get_node_list(edited_func, &nodes);
+				for (List<int>::Element *E = nodes.front(); E; E = E->next()) {
+					Vector2 pos = script->get_node_pos(edited_func, E->get()).snapped(Vector2(2, 2));
 					existing_positions.insert(pos);
 				}
 			}
 
-			for (Map<int,Ref<VisualScriptNode> >::Element *E=clipboard->nodes.front();E;E=E->next()) {
-
+			for (Map<int, Ref<VisualScriptNode> >::Element *E = clipboard->nodes.front(); E; E = E->next()) {
 
 				Ref<VisualScriptNode> node = E->get()->duplicate();
 
 				int new_id = idc++;
 				to_select.insert(new_id);
 
-				remap[E->key()]=new_id;
+				remap[E->key()] = new_id;
 
 				Vector2 paste_pos = clipboard->nodes_positions[E->key()];
 
-				while(existing_positions.has(paste_pos.snapped(Vector2(2,2)))) {
-					paste_pos+=Vector2(20,20)*EDSCALE;
+				while (existing_positions.has(paste_pos.snapped(Vector2(2, 2)))) {
+					paste_pos += Vector2(20, 20) * EDSCALE;
 				}
 
-
-				undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,node,paste_pos);
-				undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
-
+				undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, node, paste_pos);
+				undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
 			}
 
-			for (Set<VisualScript::SequenceConnection>::Element *E=clipboard->sequence_connections.front();E;E=E->next()) {
-
-
-				undo_redo->add_do_method(script.ptr(),"sequence_connect",edited_func,remap[E->get().from_node],E->get().from_output,remap[E->get().to_node]);
-				undo_redo->add_undo_method(script.ptr(),"sequence_disconnect",edited_func,remap[E->get().from_node],E->get().from_output,remap[E->get().to_node]);
+			for (Set<VisualScript::SequenceConnection>::Element *E = clipboard->sequence_connections.front(); E; E = E->next()) {
 
+				undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, remap[E->get().from_node], E->get().from_output, remap[E->get().to_node]);
+				undo_redo->add_undo_method(script.ptr(), "sequence_disconnect", edited_func, remap[E->get().from_node], E->get().from_output, remap[E->get().to_node]);
 			}
 
-			for (Set<VisualScript::DataConnection>::Element *E=clipboard->data_connections.front();E;E=E->next()) {
-
-
-				undo_redo->add_do_method(script.ptr(),"data_connect",edited_func,remap[E->get().from_node],E->get().from_port,remap[E->get().to_node],E->get().to_port);
-				undo_redo->add_undo_method(script.ptr(),"data_disconnect",edited_func,remap[E->get().from_node],E->get().from_port,remap[E->get().to_node],E->get().to_port);
+			for (Set<VisualScript::DataConnection>::Element *E = clipboard->data_connections.front(); E; E = E->next()) {
 
+				undo_redo->add_do_method(script.ptr(), "data_connect", edited_func, remap[E->get().from_node], E->get().from_port, remap[E->get().to_node], E->get().to_port);
+				undo_redo->add_undo_method(script.ptr(), "data_disconnect", edited_func, remap[E->get().from_node], E->get().from_port, remap[E->get().to_node], E->get().to_port);
 			}
 
-			undo_redo->add_do_method(this,"_update_graph");
-			undo_redo->add_undo_method(this,"_update_graph");
+			undo_redo->add_do_method(this, "_update_graph");
+			undo_redo->add_undo_method(this, "_update_graph");
 
 			undo_redo->commit_action();
 
-			for(int i=0;i<graph->get_child_count();i++) {
+			for (int i = 0; i < graph->get_child_count(); i++) {
 				GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
 				if (gn) {
 					int id = gn->get_name().operator String().to_int();
 					gn->set_selected(to_select.has(id));
-
 				}
 			}
 		} break;
-
-
 	}
 }
 
 void VisualScriptEditor::_bind_methods() {
 
-	ClassDB::bind_method("_member_button",&VisualScriptEditor::_member_button);
-	ClassDB::bind_method("_member_edited",&VisualScriptEditor::_member_edited);
-	ClassDB::bind_method("_member_selected",&VisualScriptEditor::_member_selected);
-	ClassDB::bind_method("_update_members",&VisualScriptEditor::_update_members);
-	ClassDB::bind_method("_change_base_type",&VisualScriptEditor::_change_base_type);
-	ClassDB::bind_method("_change_base_type_callback",&VisualScriptEditor::_change_base_type_callback);
-	ClassDB::bind_method("_override_pressed",&VisualScriptEditor::_override_pressed);
-	ClassDB::bind_method("_node_selected",&VisualScriptEditor::_node_selected);
-	ClassDB::bind_method("_node_moved",&VisualScriptEditor::_node_moved);
-	ClassDB::bind_method("_move_node",&VisualScriptEditor::_move_node);
-	ClassDB::bind_method("_begin_node_move",&VisualScriptEditor::_begin_node_move);
-	ClassDB::bind_method("_end_node_move",&VisualScriptEditor::_end_node_move);
-	ClassDB::bind_method("_remove_node",&VisualScriptEditor::_remove_node);
-	ClassDB::bind_method("_update_graph",&VisualScriptEditor::_update_graph,DEFVAL(-1));
-	ClassDB::bind_method("_node_ports_changed",&VisualScriptEditor::_node_ports_changed);
-	ClassDB::bind_method("_available_node_doubleclicked",&VisualScriptEditor::_available_node_doubleclicked);
-	ClassDB::bind_method("_default_value_edited",&VisualScriptEditor::_default_value_edited);
-	ClassDB::bind_method("_default_value_changed",&VisualScriptEditor::_default_value_changed);
-	ClassDB::bind_method("_menu_option",&VisualScriptEditor::_menu_option);
-	ClassDB::bind_method("_graph_ofs_changed",&VisualScriptEditor::_graph_ofs_changed);
-	ClassDB::bind_method("_center_on_node",&VisualScriptEditor::_center_on_node);
-	ClassDB::bind_method("_comment_node_resized",&VisualScriptEditor::_comment_node_resized);
-	ClassDB::bind_method("_button_resource_previewed",&VisualScriptEditor::_button_resource_previewed);
-	ClassDB::bind_method("_port_action_menu",&VisualScriptEditor::_port_action_menu);
-	ClassDB::bind_method("_selected_connect_node_method_or_setget",&VisualScriptEditor::_selected_connect_node_method_or_setget);
-	ClassDB::bind_method("_expression_text_changed",&VisualScriptEditor::_expression_text_changed);
-
-
-
-
-	ClassDB::bind_method("get_drag_data_fw",&VisualScriptEditor::get_drag_data_fw);
-	ClassDB::bind_method("can_drop_data_fw",&VisualScriptEditor::can_drop_data_fw);
-	ClassDB::bind_method("drop_data_fw",&VisualScriptEditor::drop_data_fw);
-
-	ClassDB::bind_method("_input",&VisualScriptEditor::_input);
-	ClassDB::bind_method("_on_nodes_delete",&VisualScriptEditor::_on_nodes_delete);
-	ClassDB::bind_method("_on_nodes_duplicate",&VisualScriptEditor::_on_nodes_duplicate);
-
-	ClassDB::bind_method("_hide_timer",&VisualScriptEditor::_hide_timer);
-
-	ClassDB::bind_method("_graph_connected",&VisualScriptEditor::_graph_connected);
-	ClassDB::bind_method("_graph_disconnected",&VisualScriptEditor::_graph_disconnected);
-	ClassDB::bind_method("_graph_connect_to_empty",&VisualScriptEditor::_graph_connect_to_empty);
-
-	ClassDB::bind_method("_update_graph_connections",&VisualScriptEditor::_update_graph_connections);
-	ClassDB::bind_method("_node_filter_changed",&VisualScriptEditor::_node_filter_changed);
-
-	ClassDB::bind_method("_selected_method",&VisualScriptEditor::_selected_method);
-	ClassDB::bind_method("_draw_color_over_button",&VisualScriptEditor::_draw_color_over_button);
-
-
-
-
+	ClassDB::bind_method("_member_button", &VisualScriptEditor::_member_button);
+	ClassDB::bind_method("_member_edited", &VisualScriptEditor::_member_edited);
+	ClassDB::bind_method("_member_selected", &VisualScriptEditor::_member_selected);
+	ClassDB::bind_method("_update_members", &VisualScriptEditor::_update_members);
+	ClassDB::bind_method("_change_base_type", &VisualScriptEditor::_change_base_type);
+	ClassDB::bind_method("_change_base_type_callback", &VisualScriptEditor::_change_base_type_callback);
+	ClassDB::bind_method("_override_pressed", &VisualScriptEditor::_override_pressed);
+	ClassDB::bind_method("_node_selected", &VisualScriptEditor::_node_selected);
+	ClassDB::bind_method("_node_moved", &VisualScriptEditor::_node_moved);
+	ClassDB::bind_method("_move_node", &VisualScriptEditor::_move_node);
+	ClassDB::bind_method("_begin_node_move", &VisualScriptEditor::_begin_node_move);
+	ClassDB::bind_method("_end_node_move", &VisualScriptEditor::_end_node_move);
+	ClassDB::bind_method("_remove_node", &VisualScriptEditor::_remove_node);
+	ClassDB::bind_method("_update_graph", &VisualScriptEditor::_update_graph, DEFVAL(-1));
+	ClassDB::bind_method("_node_ports_changed", &VisualScriptEditor::_node_ports_changed);
+	ClassDB::bind_method("_available_node_doubleclicked", &VisualScriptEditor::_available_node_doubleclicked);
+	ClassDB::bind_method("_default_value_edited", &VisualScriptEditor::_default_value_edited);
+	ClassDB::bind_method("_default_value_changed", &VisualScriptEditor::_default_value_changed);
+	ClassDB::bind_method("_menu_option", &VisualScriptEditor::_menu_option);
+	ClassDB::bind_method("_graph_ofs_changed", &VisualScriptEditor::_graph_ofs_changed);
+	ClassDB::bind_method("_center_on_node", &VisualScriptEditor::_center_on_node);
+	ClassDB::bind_method("_comment_node_resized", &VisualScriptEditor::_comment_node_resized);
+	ClassDB::bind_method("_button_resource_previewed", &VisualScriptEditor::_button_resource_previewed);
+	ClassDB::bind_method("_port_action_menu", &VisualScriptEditor::_port_action_menu);
+	ClassDB::bind_method("_selected_connect_node_method_or_setget", &VisualScriptEditor::_selected_connect_node_method_or_setget);
+	ClassDB::bind_method("_expression_text_changed", &VisualScriptEditor::_expression_text_changed);
+
+	ClassDB::bind_method("get_drag_data_fw", &VisualScriptEditor::get_drag_data_fw);
+	ClassDB::bind_method("can_drop_data_fw", &VisualScriptEditor::can_drop_data_fw);
+	ClassDB::bind_method("drop_data_fw", &VisualScriptEditor::drop_data_fw);
+
+	ClassDB::bind_method("_input", &VisualScriptEditor::_input);
+	ClassDB::bind_method("_on_nodes_delete", &VisualScriptEditor::_on_nodes_delete);
+	ClassDB::bind_method("_on_nodes_duplicate", &VisualScriptEditor::_on_nodes_duplicate);
+
+	ClassDB::bind_method("_hide_timer", &VisualScriptEditor::_hide_timer);
+
+	ClassDB::bind_method("_graph_connected", &VisualScriptEditor::_graph_connected);
+	ClassDB::bind_method("_graph_disconnected", &VisualScriptEditor::_graph_disconnected);
+	ClassDB::bind_method("_graph_connect_to_empty", &VisualScriptEditor::_graph_connect_to_empty);
+
+	ClassDB::bind_method("_update_graph_connections", &VisualScriptEditor::_update_graph_connections);
+	ClassDB::bind_method("_node_filter_changed", &VisualScriptEditor::_node_filter_changed);
+
+	ClassDB::bind_method("_selected_method", &VisualScriptEditor::_selected_method);
+	ClassDB::bind_method("_draw_color_over_button", &VisualScriptEditor::_draw_color_over_button);
 }
 
-
-
 VisualScriptEditor::VisualScriptEditor() {
 
 	if (!clipboard) {
-		clipboard = memnew( Clipboard );
+		clipboard = memnew(Clipboard);
 	}
-	updating_graph=false;
+	updating_graph = false;
 
-	edit_menu = memnew( MenuButton );
+	edit_menu = memnew(MenuButton);
 	edit_menu->set_text(TTR("Edit"));
 	edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/delete_selected"), EDIT_DELETE_NODES);
 	edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/toggle_breakpoint"), EDIT_TOGGLE_BREAKPOINT);
@@ -3337,101 +3125,98 @@ VisualScriptEditor::VisualScriptEditor() {
 	edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/cut_nodes"), EDIT_CUT_NODES);
 	edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/paste_nodes"), EDIT_PASTE_NODES);
 
-	edit_menu->get_popup()->connect("id_pressed",this,"_menu_option");
+	edit_menu->get_popup()->connect("id_pressed", this, "_menu_option");
 
-	main_hsplit = memnew( HSplitContainer );
+	main_hsplit = memnew(HSplitContainer);
 	add_child(main_hsplit);
 	main_hsplit->set_area_as_parent_rect();
 
-	left_vsplit = memnew( VSplitContainer );
+	left_vsplit = memnew(VSplitContainer);
 	main_hsplit->add_child(left_vsplit);
 
-	VBoxContainer *left_vb = memnew( VBoxContainer );
+	VBoxContainer *left_vb = memnew(VBoxContainer);
 	left_vsplit->add_child(left_vb);
 	left_vb->set_v_size_flags(SIZE_EXPAND_FILL);
-	left_vb->set_custom_minimum_size(Size2(230,1)*EDSCALE);
+	left_vb->set_custom_minimum_size(Size2(230, 1) * EDSCALE);
 
-	base_type_select = memnew( Button );
-	left_vb->add_margin_child(TTR("Base Type:"),base_type_select);
-	base_type_select->connect("pressed",this,"_change_base_type");
+	base_type_select = memnew(Button);
+	left_vb->add_margin_child(TTR("Base Type:"), base_type_select);
+	base_type_select->connect("pressed", this, "_change_base_type");
 
-	members = memnew( Tree );
-	left_vb->add_margin_child(TTR("Members:"),members,true);
+	members = memnew(Tree);
+	left_vb->add_margin_child(TTR("Members:"), members, true);
 	members->set_hide_root(true);
-	members->connect("button_pressed",this,"_member_button");
-	members->connect("item_edited",this,"_member_edited");
-	members->connect("cell_selected",this,"_member_selected",varray(),CONNECT_DEFERRED);
+	members->connect("button_pressed", this, "_member_button");
+	members->connect("item_edited", this, "_member_edited");
+	members->connect("cell_selected", this, "_member_selected", varray(), CONNECT_DEFERRED);
 	members->set_single_select_cell_editing_only_when_already_selected(true);
 	members->set_hide_folding(true);
 	members->set_drag_forwarding(this);
 
-
-	VBoxContainer *left_vb2 = memnew( VBoxContainer );
+	VBoxContainer *left_vb2 = memnew(VBoxContainer);
 	left_vsplit->add_child(left_vb2);
 	left_vb2->set_v_size_flags(SIZE_EXPAND_FILL);
 
-
-	VBoxContainer *vbc_nodes = memnew( VBoxContainer );
-	HBoxContainer *hbc_nodes = memnew( HBoxContainer );
-	node_filter = memnew (LineEdit);
-	node_filter->connect("text_changed",this,"_node_filter_changed");
+	VBoxContainer *vbc_nodes = memnew(VBoxContainer);
+	HBoxContainer *hbc_nodes = memnew(HBoxContainer);
+	node_filter = memnew(LineEdit);
+	node_filter->connect("text_changed", this, "_node_filter_changed");
 	hbc_nodes->add_child(node_filter);
 	node_filter->set_h_size_flags(SIZE_EXPAND_FILL);
-	node_filter_icon = memnew( TextureRect );
+	node_filter_icon = memnew(TextureRect);
 	node_filter_icon->set_stretch_mode(TextureRect::STRETCH_KEEP_CENTERED);
 	hbc_nodes->add_child(node_filter_icon);
 	vbc_nodes->add_child(hbc_nodes);
 
-	nodes = memnew( Tree );
+	nodes = memnew(Tree);
 	vbc_nodes->add_child(nodes);
 	nodes->set_v_size_flags(SIZE_EXPAND_FILL);
 
-	left_vb2->add_margin_child(TTR("Available Nodes:"),vbc_nodes,true);
+	left_vb2->add_margin_child(TTR("Available Nodes:"), vbc_nodes, true);
 
 	nodes->set_hide_root(true);
-	nodes->connect("item_activated",this,"_available_node_doubleclicked");
+	nodes->connect("item_activated", this, "_available_node_doubleclicked");
 	nodes->set_drag_forwarding(this);
 
-	graph = memnew( GraphEdit );
+	graph = memnew(GraphEdit);
 	main_hsplit->add_child(graph);
 	graph->set_h_size_flags(SIZE_EXPAND_FILL);
-	graph->connect("node_selected",this,"_node_selected");
-	graph->connect("_begin_node_move",this,"_begin_node_move");
-	graph->connect("_end_node_move",this,"_end_node_move");
-	graph->connect("delete_nodes_request",this,"_on_nodes_delete");
-	graph->connect("duplicate_nodes_request",this,"_on_nodes_duplicate");
+	graph->connect("node_selected", this, "_node_selected");
+	graph->connect("_begin_node_move", this, "_begin_node_move");
+	graph->connect("_end_node_move", this, "_end_node_move");
+	graph->connect("delete_nodes_request", this, "_on_nodes_delete");
+	graph->connect("duplicate_nodes_request", this, "_on_nodes_duplicate");
 	graph->set_drag_forwarding(this);
 	graph->hide();
-	graph->connect("scroll_offset_changed",this,"_graph_ofs_changed");
+	graph->connect("scroll_offset_changed", this, "_graph_ofs_changed");
 
-	select_func_text = memnew( Label );
+	select_func_text = memnew(Label);
 	select_func_text->set_text(TTR("Select or create a function to edit graph"));
 	select_func_text->set_align(Label::ALIGN_CENTER);
 	select_func_text->set_valign(Label::VALIGN_CENTER);
 	select_func_text->set_h_size_flags(SIZE_EXPAND_FILL);
 	main_hsplit->add_child(select_func_text);
 
-
-	hint_text = memnew( Label );
-	hint_text->set_anchor_and_margin(MARGIN_TOP,ANCHOR_END,100);
-	hint_text->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,0);
-	hint_text->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,0);
+	hint_text = memnew(Label);
+	hint_text->set_anchor_and_margin(MARGIN_TOP, ANCHOR_END, 100);
+	hint_text->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, 0);
+	hint_text->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 0);
 	hint_text->set_align(Label::ALIGN_CENTER);
 	hint_text->set_valign(Label::VALIGN_CENTER);
 	graph->add_child(hint_text);
 
-	hint_text_timer = memnew( Timer );
+	hint_text_timer = memnew(Timer);
 	hint_text_timer->set_wait_time(4);
-	hint_text_timer->connect("timeout",this,"_hide_timer");
+	hint_text_timer->connect("timeout", this, "_hide_timer");
 	add_child(hint_text_timer);
 
 	//allowed casts (connections)
-	for(int i=0;i<Variant::VARIANT_MAX;i++) {
-		graph->add_valid_connection_type(Variant::NIL,i);
-		graph->add_valid_connection_type(i,Variant::NIL);
-		for(int j=0;j<Variant::VARIANT_MAX;j++) {
-			if (Variant::can_convert(Variant::Type(i),Variant::Type(j))) {
-				graph->add_valid_connection_type(i,j);
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		graph->add_valid_connection_type(Variant::NIL, i);
+		graph->add_valid_connection_type(i, Variant::NIL);
+		for (int j = 0; j < Variant::VARIANT_MAX; j++) {
+			if (Variant::can_convert(Variant::Type(i), Variant::Type(j))) {
+				graph->add_valid_connection_type(i, j);
 			}
 		}
 
@@ -3440,68 +3225,66 @@ VisualScriptEditor::VisualScriptEditor() {
 
 	graph->add_valid_left_disconnect_type(TYPE_SEQUENCE);
 
-	graph->connect("connection_request",this,"_graph_connected");
-	graph->connect("disconnection_request",this,"_graph_disconnected");
-	graph->connect("connection_to_empty",this,"_graph_connect_to_empty");
+	graph->connect("connection_request", this, "_graph_connected");
+	graph->connect("disconnection_request", this, "_graph_disconnected");
+	graph->connect("connection_to_empty", this, "_graph_connect_to_empty");
 
-	edit_signal_dialog = memnew( AcceptDialog );
+	edit_signal_dialog = memnew(AcceptDialog);
 	edit_signal_dialog->get_ok()->set_text(TTR("Close"));
 	add_child(edit_signal_dialog);
 	edit_signal_dialog->set_title(TTR("Edit Signal Arguments:"));
 
-	signal_editor = memnew( VisualScriptEditorSignalEdit );
-	edit_signal_edit = memnew( PropertyEditor );
+	signal_editor = memnew(VisualScriptEditorSignalEdit);
+	edit_signal_edit = memnew(PropertyEditor);
 	edit_signal_edit->hide_top_label();
 	edit_signal_dialog->add_child(edit_signal_edit);
 
 	edit_signal_edit->edit(signal_editor);
 
-	edit_variable_dialog = memnew( AcceptDialog );
+	edit_variable_dialog = memnew(AcceptDialog);
 	edit_variable_dialog->get_ok()->set_text(TTR("Close"));
 	add_child(edit_variable_dialog);
 	edit_variable_dialog->set_title(TTR("Edit Variable:"));
 
-	variable_editor = memnew( VisualScriptEditorVariableEdit );
-	edit_variable_edit = memnew( PropertyEditor );
+	variable_editor = memnew(VisualScriptEditorVariableEdit);
+	edit_variable_edit = memnew(PropertyEditor);
 	edit_variable_edit->hide_top_label();
 	edit_variable_dialog->add_child(edit_variable_edit);
 
 	edit_variable_edit->edit(variable_editor);
 
-	select_base_type=memnew(CreateDialog);
+	select_base_type = memnew(CreateDialog);
 	select_base_type->set_base_type("Object"); //anything goes
-	select_base_type->connect("create",this,"_change_base_type_callback");
+	select_base_type->connect("create", this, "_change_base_type_callback");
 	select_base_type->get_ok()->set_text(TTR("Change"));
 	add_child(select_base_type);
 
 	undo_redo = EditorNode::get_singleton()->get_undo_redo();
 
-	new_function_menu = memnew( PopupMenu );
-	new_function_menu->connect("id_pressed",this,"_override_pressed");
+	new_function_menu = memnew(PopupMenu);
+	new_function_menu->connect("id_pressed", this, "_override_pressed");
 	add_child(new_function_menu);
-	updating_members=false;
+	updating_members = false;
 
 	set_process_input(true); //for revert on drag
 	set_process_unhandled_input(true); //for revert on drag
 
-	default_value_edit= memnew( CustomPropertyEditor);
+	default_value_edit = memnew(CustomPropertyEditor);
 	add_child(default_value_edit);
-	default_value_edit->connect("variant_changed",this,"_default_value_changed");
+	default_value_edit->connect("variant_changed", this, "_default_value_changed");
 
-	method_select = memnew( PropertySelector );
+	method_select = memnew(PropertySelector);
 	add_child(method_select);
-	method_select->connect("selected",this,"_selected_method");
-	error_line=-1;
+	method_select->connect("selected", this, "_selected_method");
+	error_line = -1;
 
-	new_connect_node_select = memnew( PropertySelector );
+	new_connect_node_select = memnew(PropertySelector);
 	add_child(new_connect_node_select);
-	new_connect_node_select->connect("selected",this,"_selected_connect_node_method_or_setget");
+	new_connect_node_select->connect("selected", this, "_selected_connect_node_method_or_setget");
 
-	port_action_popup = memnew( PopupMenu );
+	port_action_popup = memnew(PopupMenu);
 	add_child(port_action_popup);
-	port_action_popup->connect("id_pressed",this,"_port_action_menu");
-
-
+	port_action_popup->connect("id_pressed", this, "_port_action_menu");
 }
 
 VisualScriptEditor::~VisualScriptEditor() {
@@ -3511,17 +3294,16 @@ VisualScriptEditor::~VisualScriptEditor() {
 	memdelete(variable_editor);
 }
 
-static ScriptEditorBase * create_editor(const Ref<Script>& p_script) {
+static ScriptEditorBase *create_editor(const Ref<Script> &p_script) {
 
 	if (p_script->cast_to<VisualScript>()) {
-		return memnew( VisualScriptEditor );
+		return memnew(VisualScriptEditor);
 	}
 
 	return NULL;
 }
 
-
-VisualScriptEditor::Clipboard *VisualScriptEditor::clipboard=NULL;
+VisualScriptEditor::Clipboard *VisualScriptEditor::clipboard = NULL;
 
 void VisualScriptEditor::free_clipboard() {
 	if (clipboard)
@@ -3531,30 +3313,25 @@ void VisualScriptEditor::free_clipboard() {
 static void register_editor_callback() {
 
 	ScriptEditor::register_create_script_editor_function(create_editor);
-	EditorSettings::get_singleton()->set("editors/visual_script/color_functions",Color(1,0.9,0.9));
-	EditorSettings::get_singleton()->set("editors/visual_script/color_data",Color(0.9,1.0,0.9));
-	EditorSettings::get_singleton()->set("editors/visual_script/color_operators",Color(0.9,0.9,1.0));
-	EditorSettings::get_singleton()->set("editors/visual_script/color_flow_control",Color(1.0,1.0,0.8));
-	EditorSettings::get_singleton()->set("editors/visual_script/color_custom",Color(0.8,1.0,1.0));
-	EditorSettings::get_singleton()->set("editors/visual_script/color_constants",Color(1.0,0.8,1.0));
-
+	EditorSettings::get_singleton()->set("editors/visual_script/color_functions", Color(1, 0.9, 0.9));
+	EditorSettings::get_singleton()->set("editors/visual_script/color_data", Color(0.9, 1.0, 0.9));
+	EditorSettings::get_singleton()->set("editors/visual_script/color_operators", Color(0.9, 0.9, 1.0));
+	EditorSettings::get_singleton()->set("editors/visual_script/color_flow_control", Color(1.0, 1.0, 0.8));
+	EditorSettings::get_singleton()->set("editors/visual_script/color_custom", Color(0.8, 1.0, 1.0));
+	EditorSettings::get_singleton()->set("editors/visual_script/color_constants", Color(1.0, 0.8, 1.0));
 
 	ED_SHORTCUT("visual_script_editor/delete_selected", TTR("Delete Selected"));
 	ED_SHORTCUT("visual_script_editor/toggle_breakpoint", TTR("Toggle Breakpoint"), KEY_F9);
-	ED_SHORTCUT("visual_script_editor/find_node_type", TTR("Find Node Type"), KEY_MASK_CMD+KEY_F);
-	ED_SHORTCUT("visual_script_editor/copy_nodes", TTR("Copy Nodes"), KEY_MASK_CMD+KEY_C);
-	ED_SHORTCUT("visual_script_editor/cut_nodes", TTR("Cut Nodes"), KEY_MASK_CMD+KEY_X);
-	ED_SHORTCUT("visual_script_editor/paste_nodes", TTR("Paste Nodes"), KEY_MASK_CMD+KEY_V);
-
+	ED_SHORTCUT("visual_script_editor/find_node_type", TTR("Find Node Type"), KEY_MASK_CMD + KEY_F);
+	ED_SHORTCUT("visual_script_editor/copy_nodes", TTR("Copy Nodes"), KEY_MASK_CMD + KEY_C);
+	ED_SHORTCUT("visual_script_editor/cut_nodes", TTR("Cut Nodes"), KEY_MASK_CMD + KEY_X);
+	ED_SHORTCUT("visual_script_editor/paste_nodes", TTR("Paste Nodes"), KEY_MASK_CMD + KEY_V);
 }
 
 void VisualScriptEditor::register_editor() {
 
 	//too early to register stuff here, request a callback
 	EditorNode::add_plugin_init_callback(register_editor_callback);
-
-
-
 }
 
 #endif
diff --git a/modules/visual_script/visual_script_editor.h b/modules/visual_script/visual_script_editor.h
index cdaef8d0ce..5ece1c9e2c 100644
--- a/modules/visual_script/visual_script_editor.h
+++ b/modules/visual_script/visual_script_editor.h
@@ -29,26 +29,23 @@
 #ifndef VISUALSCRIPT_EDITOR_H
 #define VISUALSCRIPT_EDITOR_H
 
+#include "editor/create_dialog.h"
 #include "editor/plugins/script_editor_plugin.h"
-#include "visual_script.h"
 #include "editor/property_editor.h"
-#include "scene/gui/graph_edit.h"
-#include "editor/create_dialog.h"
 #include "editor/property_selector.h"
+#include "scene/gui/graph_edit.h"
+#include "visual_script.h"
 class VisualScriptEditorSignalEdit;
 class VisualScriptEditorVariableEdit;
 
-
 #ifdef TOOLS_ENABLED
 
-
 class VisualScriptEditor : public ScriptEditorBase {
-	GDCLASS(VisualScriptEditor,ScriptEditorBase)
+	GDCLASS(VisualScriptEditor, ScriptEditorBase)
 
 	enum {
-		TYPE_SEQUENCE=1000,
-		INDEX_BASE_SEQUENCE=1024
-
+		TYPE_SEQUENCE = 1000,
+		INDEX_BASE_SEQUENCE = 1024
 
 	};
 
@@ -115,7 +112,7 @@ class VisualScriptEditor : public ScriptEditorBase {
 
 	bool updating_graph;
 
-	void _show_hint(const String& p_hint);
+	void _show_hint(const String &p_hint);
 	void _hide_timer();
 
 	CreateDialog *select_base_type;
@@ -124,18 +121,17 @@ class VisualScriptEditor : public ScriptEditorBase {
 		String name;
 		Variant::Type ret;
 		bool ret_variant;
-		Vector< Pair<Variant::Type,String> > args;
+		Vector<Pair<Variant::Type, String> > args;
 	};
 
-	Map<int,VirtualInMenu> virtuals_in_menu;
+	Map<int, VirtualInMenu> virtuals_in_menu;
 
 	PopupMenu *new_function_menu;
 
-
 	StringName edited_func;
 
 	void _update_graph_connections();
-	void _update_graph(int p_only_id=-1);
+	void _update_graph(int p_only_id = -1);
 
 	bool updating_members;
 
@@ -143,12 +139,12 @@ class VisualScriptEditor : public ScriptEditorBase {
 
 	StringName selected;
 
-	String _validate_name(const String& p_name) const;
+	String _validate_name(const String &p_name) const;
 
 	struct Clipboard {
 
-		Map<int,Ref<VisualScriptNode> > nodes;
-		Map<int,Vector2 > nodes_positions;
+		Map<int, Ref<VisualScriptNode> > nodes;
+		Map<int, Vector2> nodes_positions;
 
 		Set<VisualScript::SequenceConnection> sequence_connections;
 		Set<VisualScript::DataConnection> data_connections;
@@ -164,15 +160,14 @@ class VisualScriptEditor : public ScriptEditorBase {
 	Vector2 port_action_pos;
 	int port_action_new_node;
 	void _port_action_menu(int p_option);
-	void _selected_connect_node_method_or_setget(const String& p_text);
-
+	void _selected_connect_node_method_or_setget(const String &p_text);
 
 	int error_line;
 
-	void _node_selected(Node* p_node);
+	void _node_selected(Node *p_node);
 	void _center_on_node(int p_id);
 
-	void _node_filter_changed(const String& p_text);
+	void _node_filter_changed(const String &p_text);
 	void _change_base_type_callback();
 	void _change_base_type();
 	void _member_selected();
@@ -181,82 +176,78 @@ class VisualScriptEditor : public ScriptEditorBase {
 
 	void _begin_node_move();
 	void _end_node_move();
-	void _move_node(String func,int p_id,const Vector2& p_to);
+	void _move_node(String func, int p_id, const Vector2 &p_to);
 
-	void _node_moved(Vector2 p_from,Vector2 p_to, int p_id);
+	void _node_moved(Vector2 p_from, Vector2 p_to, int p_id);
 	void _remove_node(int p_id);
-	void _graph_connected(const String& p_from,int p_from_slot,const String& p_to,int p_to_slot);
-	void _graph_disconnected(const String& p_from,int p_from_slot,const String& p_to,int p_to_slot);
-	void _graph_connect_to_empty(const String& p_from,int p_from_slot,const Vector2& p_release_pos);
+	void _graph_connected(const String &p_from, int p_from_slot, const String &p_to, int p_to_slot);
+	void _graph_disconnected(const String &p_from, int p_from_slot, const String &p_to, int p_to_slot);
+	void _graph_connect_to_empty(const String &p_from, int p_from_slot, const Vector2 &p_release_pos);
 
-	void _node_ports_changed(const String& p_func,int p_id);
+	void _node_ports_changed(const String &p_func, int p_id);
 	void _available_node_doubleclicked();
 
 	void _update_available_nodes();
 
 	void _member_button(Object *p_item, int p_column, int p_button);
 
-	void _expression_text_changed(const String& p_text,int p_id);
-
+	void _expression_text_changed(const String &p_text, int p_id);
 
 	String revert_on_drag;
 
-	void _input(const InputEvent& p_event);
+	void _input(const InputEvent &p_event);
 	void _on_nodes_delete();
 	void _on_nodes_duplicate();
 
-	Variant get_drag_data_fw(const Point2& p_point,Control* p_from);
-	bool can_drop_data_fw(const Point2& p_point,const Variant& p_data,Control* p_from) const;
-	void drop_data_fw(const Point2& p_point,const Variant& p_data,Control* p_from);
-
+	Variant get_drag_data_fw(const Point2 &p_point, Control *p_from);
+	bool can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const;
+	void drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from);
 
 	int editing_id;
 	int editing_input;
 
 	void _default_value_changed();
-	void _default_value_edited(Node * p_button,int p_id,int p_input_port);
+	void _default_value_edited(Node *p_button, int p_id, int p_input_port);
 
 	void _menu_option(int p_what);
 
-	void _graph_ofs_changed(const Vector2& p_ofs);
-	void _comment_node_resized(const Vector2& p_new_size,int p_node);
+	void _graph_ofs_changed(const Vector2 &p_ofs);
+	void _comment_node_resized(const Vector2 &p_new_size, int p_node);
 
 	int selecting_method_id;
-	void _selected_method(const String& p_method);
+	void _selected_method(const String &p_method);
 
-	void _draw_color_over_button(Object* obj,Color p_color);
-	void _button_resource_previewed(const String& p_path,const Ref<Texture>& p_preview,Variant p_ud);
-
-	VisualScriptNode::TypeGuess  _guess_output_type(int p_port_action_node,int p_port_action_output,Set<int> &visited_nodes);
+	void _draw_color_over_button(Object *obj, Color p_color);
+	void _button_resource_previewed(const String &p_path, const Ref<Texture> &p_preview, Variant p_ud);
 
+	VisualScriptNode::TypeGuess _guess_output_type(int p_port_action_node, int p_port_action_output, Set<int> &visited_nodes);
 
 protected:
-
 	void _notification(int p_what);
 	static void _bind_methods();
-public:
 
+public:
 	virtual void apply_code();
 	virtual Ref<Script> get_edited_script() const;
 	virtual Vector<String> get_functions();
-	virtual void set_edited_script(const Ref<Script>& p_script);
+	virtual void set_edited_script(const Ref<Script> &p_script);
 	virtual void reload_text();
 	virtual String get_name();
 	virtual Ref<Texture> get_icon();
 	virtual bool is_unsaved();
 	virtual Variant get_edit_state();
-	virtual void set_edit_state(const Variant& p_state);
-	virtual void goto_line(int p_line,bool p_with_error=false);
+	virtual void set_edit_state(const Variant &p_state);
+	virtual void goto_line(int p_line, bool p_with_error = false);
 	virtual void trim_trailing_whitespace();
 	virtual void ensure_focus();
 	virtual void tag_saved_version();
 	virtual void reload(bool p_soft);
 	virtual void get_breakpoints(List<int> *p_breakpoints);
-	virtual bool goto_method(const String& p_method);
-	virtual void add_callback(const String& p_function,PoolStringArray p_args);
+	virtual bool goto_method(const String &p_method);
+	virtual void add_callback(const String &p_function, PoolStringArray p_args);
 	virtual void update_settings();
 	virtual void set_debugger_active(bool p_active);
-	virtual void set_tooltip_request_func(String p_method,Object* p_obj);
+	virtual void set_tooltip_request_func(String p_method, Object *p_obj);
 	virtual Control *get_edit_menu();
 	virtual bool can_lose_focus_on_node_selection() { return false; }
 
diff --git a/modules/visual_script/visual_script_expression.cpp b/modules/visual_script/visual_script_expression.cpp
index 3d15e696ef..741b422848 100644
--- a/modules/visual_script/visual_script_expression.cpp
+++ b/modules/visual_script/visual_script_expression.cpp
@@ -28,41 +28,40 @@
 /*************************************************************************/
 #include "visual_script_expression.h"
 
+bool VisualScriptExpression::_set(const StringName &p_name, const Variant &p_value) {
 
-bool VisualScriptExpression::_set(const StringName& p_name, const Variant& p_value) {
-
-	if (String(p_name)=="expression") {
-		expression=p_value;
-		expression_dirty=true;
+	if (String(p_name) == "expression") {
+		expression = p_value;
+		expression_dirty = true;
 		ports_changed_notify();
 		return true;
 	}
 
-	if (String(p_name)=="out_type") {
-		output_type=Variant::Type(int(p_value));
-		expression_dirty=true;
+	if (String(p_name) == "out_type") {
+		output_type = Variant::Type(int(p_value));
+		expression_dirty = true;
 		ports_changed_notify();
 		return true;
 	}
-	if (String(p_name)=="sequenced") {
-		sequenced=p_value;
+	if (String(p_name) == "sequenced") {
+		sequenced = p_value;
 		ports_changed_notify();
 		return true;
 	}
 
-	if (String(p_name)=="input_count") {
+	if (String(p_name) == "input_count") {
 
-		int from=inputs.size();
+		int from = inputs.size();
 		inputs.resize(int(p_value));
-		for(int i=from;i<inputs.size();i++) {
-			inputs[i].name=String::chr('a'+i);
-			if (from==0) {
-				inputs[i].type=output_type;
+		for (int i = from; i < inputs.size(); i++) {
+			inputs[i].name = String::chr('a' + i);
+			if (from == 0) {
+				inputs[i].type = output_type;
 			} else {
-				inputs[i].type=inputs[from-1].type;
+				inputs[i].type = inputs[from - 1].type;
 			}
 		}
-		expression_dirty=true;
+		expression_dirty = true;
 		ports_changed_notify();
 		_change_notify();
 		return true;
@@ -70,66 +69,64 @@ bool VisualScriptExpression::_set(const StringName& p_name, const Variant& p_val
 
 	if (String(p_name).begins_with("input/")) {
 
-		int idx=String(p_name).get_slice("/",1).to_int();
-		ERR_FAIL_INDEX_V(idx,inputs.size(),false);
+		int idx = String(p_name).get_slice("/", 1).to_int();
+		ERR_FAIL_INDEX_V(idx, inputs.size(), false);
 
-		String what=String(p_name).get_slice("/",2);
+		String what = String(p_name).get_slice("/", 2);
 
-		if (what=="type") {
+		if (what == "type") {
 
-			inputs[idx].type=Variant::Type(int(p_value));
-		} else if (what=="name") {
+			inputs[idx].type = Variant::Type(int(p_value));
+		} else if (what == "name") {
 
-			inputs[idx].name=p_value;
+			inputs[idx].name = p_value;
 		} else {
 			return false;
 		}
 
-		expression_dirty=true;
+		expression_dirty = true;
 		ports_changed_notify();
 		return true;
 	}
 
-
 	return false;
-
 }
 
-bool VisualScriptExpression::_get(const StringName& p_name,Variant &r_ret) const {
+bool VisualScriptExpression::_get(const StringName &p_name, Variant &r_ret) const {
 
-	if (String(p_name)=="expression") {
-		r_ret=expression;
+	if (String(p_name) == "expression") {
+		r_ret = expression;
 		return true;
 	}
 
-	if (String(p_name)=="out_type") {
-		r_ret=output_type;
+	if (String(p_name) == "out_type") {
+		r_ret = output_type;
 		return true;
 	}
 
-	if (String(p_name)=="sequenced") {
-		r_ret=sequenced;
+	if (String(p_name) == "sequenced") {
+		r_ret = sequenced;
 		return true;
 	}
 
-	if (String(p_name)=="input_count") {
-		r_ret=inputs.size();
+	if (String(p_name) == "input_count") {
+		r_ret = inputs.size();
 		return true;
 	}
 
 	if (String(p_name).begins_with("input/")) {
 
-		int idx=String(p_name).get_slice("/",1).to_int();
-		ERR_FAIL_INDEX_V(idx,inputs.size(),false);
+		int idx = String(p_name).get_slice("/", 1).to_int();
+		ERR_FAIL_INDEX_V(idx, inputs.size(), false);
 
-		String what=String(p_name).get_slice("/",2);
+		String what = String(p_name).get_slice("/", 2);
 
-		if (what=="type") {
+		if (what == "type") {
 
-			r_ret=inputs[idx].type;
-		} else if (what=="name") {
+			r_ret = inputs[idx].type;
+		} else if (what == "name") {
 
-			r_ret=inputs[idx].name;
+			r_ret = inputs[idx].name;
 		} else {
 			return false;
 		}
@@ -137,310 +134,296 @@ bool VisualScriptExpression::_get(const StringName& p_name,Variant &r_ret) const
 		return true;
 	}
 
-
 	return false;
 }
-void VisualScriptExpression::_get_property_list( List<PropertyInfo> *p_list) const {
-
+void VisualScriptExpression::_get_property_list(List<PropertyInfo> *p_list) const {
 
-	String argt="Any";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	String argt = "Any";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-	p_list->push_back(PropertyInfo(Variant::STRING,"expression",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR));
-	p_list->push_back(PropertyInfo(Variant::INT,"out_type",PROPERTY_HINT_ENUM,argt));
-	p_list->push_back(PropertyInfo(Variant::INT,"input_count",PROPERTY_HINT_RANGE,"0,64,1"));
-	p_list->push_back(PropertyInfo(Variant::BOOL,"sequenced"));
+	p_list->push_back(PropertyInfo(Variant::STRING, "expression", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR));
+	p_list->push_back(PropertyInfo(Variant::INT, "out_type", PROPERTY_HINT_ENUM, argt));
+	p_list->push_back(PropertyInfo(Variant::INT, "input_count", PROPERTY_HINT_RANGE, "0,64,1"));
+	p_list->push_back(PropertyInfo(Variant::BOOL, "sequenced"));
 
-	for(int i=0;i<inputs.size();i++) {
+	for (int i = 0; i < inputs.size(); i++) {
 
-		p_list->push_back(PropertyInfo(Variant::INT,"input/"+itos(i)+"/type",PROPERTY_HINT_ENUM,argt));
-		p_list->push_back(PropertyInfo(Variant::STRING,"input/"+itos(i)+"/name"));
+		p_list->push_back(PropertyInfo(Variant::INT, "input/" + itos(i) + "/type", PROPERTY_HINT_ENUM, argt));
+		p_list->push_back(PropertyInfo(Variant::STRING, "input/" + itos(i) + "/name"));
 	}
 }
 
 int VisualScriptExpression::get_output_sequence_port_count() const {
 
-	return sequenced?1:0;
+	return sequenced ? 1 : 0;
 }
-bool VisualScriptExpression::has_input_sequence_port() const{
+bool VisualScriptExpression::has_input_sequence_port() const {
 
 	return sequenced;
 }
 
-
-String VisualScriptExpression::get_output_sequence_port_text(int p_port) const{
+String VisualScriptExpression::get_output_sequence_port_text(int p_port) const {
 
 	return String();
 }
 
-
-int VisualScriptExpression::get_input_value_port_count() const{
+int VisualScriptExpression::get_input_value_port_count() const {
 
 	return inputs.size();
-
 }
-int VisualScriptExpression::get_output_value_port_count() const{
+int VisualScriptExpression::get_output_value_port_count() const {
 
 	return 1;
 }
 
+PropertyInfo VisualScriptExpression::get_input_value_port_info(int p_idx) const {
 
-PropertyInfo VisualScriptExpression::get_input_value_port_info(int p_idx) const{
-
-	return PropertyInfo(inputs[p_idx].type,inputs[p_idx].name);
+	return PropertyInfo(inputs[p_idx].type, inputs[p_idx].name);
 }
-PropertyInfo VisualScriptExpression::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptExpression::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(output_type,"result");
+	return PropertyInfo(output_type, "result");
 }
 
-String VisualScriptExpression::get_caption() const{
+String VisualScriptExpression::get_caption() const {
 
 	return "Expression";
 }
-String VisualScriptExpression::get_text() const{
+String VisualScriptExpression::get_text() const {
 
 	return expression;
 }
 
-
-Error VisualScriptExpression::_get_token(Token& r_token) {
+Error VisualScriptExpression::_get_token(Token &r_token) {
 
 	while (true) {
-#define GET_CHAR() (str_ofs>=expression.length()?0:expression[str_ofs++])
+#define GET_CHAR() (str_ofs >= expression.length() ? 0 : expression[str_ofs++])
 
 		CharType cchar = GET_CHAR();
-		if (cchar==0) {
-			r_token.type=TK_EOF;
+		if (cchar == 0) {
+			r_token.type = TK_EOF;
 			return OK;
 		}
 
-
-		switch(cchar) {
+		switch (cchar) {
 
 			case 0: {
-				r_token.type=TK_EOF;
+				r_token.type = TK_EOF;
 				return OK;
 			} break;
 			case '{': {
 
-				r_token.type=TK_CURLY_BRACKET_OPEN;
+				r_token.type = TK_CURLY_BRACKET_OPEN;
 				return OK;
 			};
 			case '}': {
 
-				r_token.type=TK_CURLY_BRACKET_CLOSE;
+				r_token.type = TK_CURLY_BRACKET_CLOSE;
 				return OK;
 			};
 			case '[': {
 
-				r_token.type=TK_BRACKET_OPEN;
+				r_token.type = TK_BRACKET_OPEN;
 				return OK;
 			};
 			case ']': {
 
-				r_token.type=TK_BRACKET_CLOSE;
+				r_token.type = TK_BRACKET_CLOSE;
 				return OK;
 			};
 			case '(': {
 
-				r_token.type=TK_PARENTHESIS_OPEN;
+				r_token.type = TK_PARENTHESIS_OPEN;
 				return OK;
 			};
 			case ')': {
 
-				r_token.type=TK_PARENTHESIS_CLOSE;
+				r_token.type = TK_PARENTHESIS_CLOSE;
 				return OK;
 			};
 			case ',': {
 
-				r_token.type=TK_COMMA;
+				r_token.type = TK_COMMA;
 				return OK;
 			};
 			case ':': {
 
-				r_token.type=TK_COLON;
+				r_token.type = TK_COLON;
 				return OK;
 			};
 			case '.': {
 
-				r_token.type=TK_PERIOD;
+				r_token.type = TK_PERIOD;
 				return OK;
 			};
 			case '=': {
 
-				cchar=GET_CHAR();
-				if (cchar=='=') {
-					r_token.type=TK_OP_EQUAL;
+				cchar = GET_CHAR();
+				if (cchar == '=') {
+					r_token.type = TK_OP_EQUAL;
 				} else {
 					_set_error("Expected '='");
-					r_token.type=TK_ERROR;
+					r_token.type = TK_ERROR;
 					return ERR_PARSE_ERROR;
 				}
 				return OK;
 			};
 			case '!': {
 
-				if (expression[str_ofs]=='=') {
-					r_token.type=TK_OP_NOT_EQUAL;
+				if (expression[str_ofs] == '=') {
+					r_token.type = TK_OP_NOT_EQUAL;
 					str_ofs++;
 				} else {
-					r_token.type=TK_OP_NOT;
+					r_token.type = TK_OP_NOT;
 				}
 				return OK;
 			};
 			case '>': {
 
-				if (expression[str_ofs]=='=') {
-					r_token.type=TK_OP_GREATER_EQUAL;
+				if (expression[str_ofs] == '=') {
+					r_token.type = TK_OP_GREATER_EQUAL;
 					str_ofs++;
-				} else if (expression[str_ofs]=='>') {
-					r_token.type=TK_OP_SHIFT_RIGHT;
+				} else if (expression[str_ofs] == '>') {
+					r_token.type = TK_OP_SHIFT_RIGHT;
 					str_ofs++;
 				} else {
-					r_token.type=TK_OP_GREATER;
+					r_token.type = TK_OP_GREATER;
 				}
 				return OK;
 			};
 			case '<': {
 
-				if (expression[str_ofs]=='=') {
-					r_token.type=TK_OP_LESS_EQUAL;
+				if (expression[str_ofs] == '=') {
+					r_token.type = TK_OP_LESS_EQUAL;
 					str_ofs++;
-				} else if (expression[str_ofs]=='<') {
-					r_token.type=TK_OP_SHIFT_LEFT;
+				} else if (expression[str_ofs] == '<') {
+					r_token.type = TK_OP_SHIFT_LEFT;
 					str_ofs++;
 				} else {
-					r_token.type=TK_OP_LESS;
+					r_token.type = TK_OP_LESS;
 				}
 				return OK;
 			};
 			case '+': {
-				r_token.type=TK_OP_ADD;
+				r_token.type = TK_OP_ADD;
 				return OK;
 			};
 			case '-': {
-				r_token.type=TK_OP_SUB;
+				r_token.type = TK_OP_SUB;
 				return OK;
 			};
 			case '/': {
-				r_token.type=TK_OP_DIV;
+				r_token.type = TK_OP_DIV;
 				return OK;
 			};
 			case '*': {
-				r_token.type=TK_OP_MUL;
+				r_token.type = TK_OP_MUL;
 				return OK;
 			};
 			case '%': {
-				r_token.type=TK_OP_MOD;
+				r_token.type = TK_OP_MOD;
 				return OK;
 			};
 			case '&': {
 
-				if (expression[str_ofs]=='&') {
-					r_token.type=TK_OP_AND;
+				if (expression[str_ofs] == '&') {
+					r_token.type = TK_OP_AND;
 					str_ofs++;
 				} else {
-					r_token.type=TK_OP_BIT_AND;
+					r_token.type = TK_OP_BIT_AND;
 				}
 				return OK;
 			};
 			case '|': {
 
-				if (expression[str_ofs]=='|') {
-					r_token.type=TK_OP_OR;
+				if (expression[str_ofs] == '|') {
+					r_token.type = TK_OP_OR;
 					str_ofs++;
 				} else {
-					r_token.type=TK_OP_BIT_OR;
+					r_token.type = TK_OP_BIT_OR;
 				}
 				return OK;
 			};
 			case '^': {
 
-				r_token.type=TK_OP_BIT_XOR;
+				r_token.type = TK_OP_BIT_XOR;
 
 				return OK;
 			};
 			case '~': {
 
-				r_token.type=TK_OP_BIT_INVERT;
+				r_token.type = TK_OP_BIT_INVERT;
 
 				return OK;
 			};
 			case '"': {
 
-
 				String str;
-				while(true) {
+				while (true) {
 
-					CharType ch=GET_CHAR();
+					CharType ch = GET_CHAR();
 
-					if (ch==0) {
+					if (ch == 0) {
 						_set_error("Unterminated String");
-						r_token.type=TK_ERROR;
+						r_token.type = TK_ERROR;
 						return ERR_PARSE_ERROR;
-					} else if (ch=='"') {
+					} else if (ch == '"') {
 						break;
-					} else if (ch=='\\') {
+					} else if (ch == '\\') {
 						//escaped characters...
 
 						CharType next = GET_CHAR();
-						if (next==0) {
+						if (next == 0) {
 							_set_error("Unterminated String");
-							r_token.type=TK_ERROR;
-							return  ERR_PARSE_ERROR;
+							r_token.type = TK_ERROR;
+							return ERR_PARSE_ERROR;
 						}
-						CharType res=0;
+						CharType res = 0;
 
-						switch(next) {
+						switch (next) {
 
-							case 'b': res=8; break;
-							case 't': res=9; break;
-							case 'n': res=10; break;
-							case 'f': res=12; break;
-							case 'r': res=13; break;
+							case 'b': res = 8; break;
+							case 't': res = 9; break;
+							case 'n': res = 10; break;
+							case 'f': res = 12; break;
+							case 'r': res = 13; break;
 							case 'u': {
 								//hexnumbarh - oct is deprecated
 
-
-								for(int j=0;j<4;j++) {
+								for (int j = 0; j < 4; j++) {
 									CharType c = GET_CHAR();
 
-									if (c==0) {
+									if (c == 0) {
 										_set_error("Unterminated String");
-										r_token.type=TK_ERROR;
+										r_token.type = TK_ERROR;
 										return ERR_PARSE_ERROR;
 									}
-									if (!((c>='0' && c<='9') || (c>='a' && c<='f') || (c>='A' && c<='F'))) {
+									if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
 
 										_set_error("Malformed hex constant in string");
-										r_token.type=TK_ERROR;
+										r_token.type = TK_ERROR;
 										return ERR_PARSE_ERROR;
 									}
 									CharType v;
-									if (c>='0' && c<='9') {
-										v=c-'0';
-									} else if (c>='a' && c<='f') {
-										v=c-'a';
-										v+=10;
-									} else if (c>='A' && c<='F') {
-										v=c-'A';
-										v+=10;
+									if (c >= '0' && c <= '9') {
+										v = c - '0';
+									} else if (c >= 'a' && c <= 'f') {
+										v = c - 'a';
+										v += 10;
+									} else if (c >= 'A' && c <= 'F') {
+										v = c - 'A';
+										v += 10;
 									} else {
 										ERR_PRINT("BUG");
-										v=0;
+										v = 0;
 									}
 
-									res<<=4;
-									res|=v;
-
-
+									res <<= 4;
+									res |= v;
 								}
 
-
-
 							} break;
 							//case '\"': res='\"'; break;
 							//case '\\': res='\\'; break;
@@ -452,408 +435,397 @@ Error VisualScriptExpression::_get_token(Token& r_token) {
 							} break;
 						}
 
-						str+=res;
+						str += res;
 
 					} else {
-						str+=ch;
+						str += ch;
 					}
 				}
 
-				r_token.type=TK_CONSTANT;
-				r_token.value=str;
+				r_token.type = TK_CONSTANT;
+				r_token.value = str;
 				return OK;
 
 			} break;
 			default: {
 
-				if (cchar<=32) {
+				if (cchar <= 32) {
 					break;
 				}
 
-				if (cchar=='-' || (cchar>='0' && cchar<='9')) {
+				if (cchar == '-' || (cchar >= '0' && cchar <= '9')) {
 					//a number
 
-
 					String num;
 #define READING_SIGN 0
 #define READING_INT 1
 #define READING_DEC 2
 #define READING_EXP 3
 #define READING_DONE 4
-					int reading=READING_INT;
-
-					if (cchar=='-') {
-						num+='-';
-						cchar=GET_CHAR();
+					int reading = READING_INT;
 
+					if (cchar == '-') {
+						num += '-';
+						cchar = GET_CHAR();
 					}
 
-
-
 					CharType c = cchar;
-					bool exp_sign=false;
-					bool exp_beg=false;
-					bool is_float=false;
+					bool exp_sign = false;
+					bool exp_beg = false;
+					bool is_float = false;
 
-					while(true) {
+					while (true) {
 
-						switch(reading) {
+						switch (reading) {
 							case READING_INT: {
 
-								if (c>='0' && c<='9') {
+								if (c >= '0' && c <= '9') {
 									//pass
-								} else if (c=='.') {
-									reading=READING_DEC;
-									is_float=true;
-								} else if (c=='e') {
-									reading=READING_EXP;
+								} else if (c == '.') {
+									reading = READING_DEC;
+									is_float = true;
+								} else if (c == 'e') {
+									reading = READING_EXP;
 								} else {
-									reading=READING_DONE;
+									reading = READING_DONE;
 								}
 
-							 } break;
+							} break;
 							case READING_DEC: {
 
-								if (c>='0' && c<='9') {
+								if (c >= '0' && c <= '9') {
 
-								} else if (c=='e') {
-									reading=READING_EXP;
+								} else if (c == 'e') {
+									reading = READING_EXP;
 
 								} else {
-									reading=READING_DONE;
+									reading = READING_DONE;
 								}
 
-							 } break;
+							} break;
 							case READING_EXP: {
 
-								if (c>='0' && c<='9') {
-									exp_beg=true;
+								if (c >= '0' && c <= '9') {
+									exp_beg = true;
 
-								} else if ((c=='-' || c=='+') && !exp_sign && !exp_beg) {
-									if (c=='-')
-										is_float=true;
-									exp_sign=true;
+								} else if ((c == '-' || c == '+') && !exp_sign && !exp_beg) {
+									if (c == '-')
+										is_float = true;
+									exp_sign = true;
 
 								} else {
-									reading=READING_DONE;
+									reading = READING_DONE;
 								}
-							 } break;
+							} break;
 						}
 
-						if (reading==READING_DONE)
+						if (reading == READING_DONE)
 							break;
-						num+=String::chr(c);
+						num += String::chr(c);
 						c = GET_CHAR();
-
-
 					}
 
 					str_ofs--;
 
-					r_token.type=TK_CONSTANT;
+					r_token.type = TK_CONSTANT;
 
 					if (is_float)
-						r_token.value=num.to_double();
+						r_token.value = num.to_double();
 					else
-						r_token.value=num.to_int();
+						r_token.value = num.to_int();
 					return OK;
 
-				} else if ((cchar>='A' && cchar<='Z') || (cchar>='a' && cchar<='z') || cchar=='_') {
+				} else if ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_') {
 
 					String id;
-					bool first=true;
+					bool first = true;
 
-					while((cchar>='A' && cchar<='Z') || (cchar>='a' && cchar<='z') || cchar=='_' || (!first && cchar>='0' && cchar<='9')) {
+					while ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_' || (!first && cchar >= '0' && cchar <= '9')) {
 
-						id+=String::chr(cchar);
-						cchar=GET_CHAR();
-						first=false;
+						id += String::chr(cchar);
+						cchar = GET_CHAR();
+						first = false;
 					}
 
 					str_ofs--; //go back one
 
-					if (id=="in") {
-						r_token.type=TK_OP_IN;
-					} else if (id=="null") {
-						r_token.type=TK_CONSTANT;
-						r_token.value=Variant();
-					} else if (id=="true") {
-						r_token.type=TK_CONSTANT;
-						r_token.value=true;
-					} else if (id=="false") {
-						r_token.type=TK_CONSTANT;
-						r_token.value=false;
-					} else if (id=="PI") {
-						r_token.type=TK_CONSTANT;
-						r_token.value=Math_PI;
+					if (id == "in") {
+						r_token.type = TK_OP_IN;
+					} else if (id == "null") {
+						r_token.type = TK_CONSTANT;
+						r_token.value = Variant();
+					} else if (id == "true") {
+						r_token.type = TK_CONSTANT;
+						r_token.value = true;
+					} else if (id == "false") {
+						r_token.type = TK_CONSTANT;
+						r_token.value = false;
+					} else if (id == "PI") {
+						r_token.type = TK_CONSTANT;
+						r_token.value = Math_PI;
 					} else if (id == "INF") {
 						r_token.type = TK_CONSTANT;
 						r_token.value = Math_INF;
 					} else if (id == "NAN") {
 						r_token.type = TK_CONSTANT;
 						r_token.value = Math_NAN;
-					} else if (id=="not") {
-						r_token.type=TK_OP_NOT;
-					} else if (id=="or") {
-						r_token.type=TK_OP_OR;
-					} else if (id=="and") {
-						r_token.type=TK_OP_AND;
-					} else if (id=="self") {
-						r_token.type=TK_SELF;
+					} else if (id == "not") {
+						r_token.type = TK_OP_NOT;
+					} else if (id == "or") {
+						r_token.type = TK_OP_OR;
+					} else if (id == "and") {
+						r_token.type = TK_OP_AND;
+					} else if (id == "self") {
+						r_token.type = TK_SELF;
 					} else {
 
-						for(int i=0;i<Variant::VARIANT_MAX;i++) {
-							if (id==Variant::get_type_name(Variant::Type(i))) {
-								r_token.type=TK_BASIC_TYPE;
-								r_token.value=i;
+						for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+							if (id == Variant::get_type_name(Variant::Type(i))) {
+								r_token.type = TK_BASIC_TYPE;
+								r_token.value = i;
 								return OK;
 								break;
 							}
 						}
 
 						VisualScriptBuiltinFunc::BuiltinFunc bifunc = VisualScriptBuiltinFunc::find_function(id);
-						if (bifunc!=VisualScriptBuiltinFunc::FUNC_MAX) {
-							r_token.type=TK_BUILTIN_FUNC;
-							r_token.value=bifunc;
+						if (bifunc != VisualScriptBuiltinFunc::FUNC_MAX) {
+							r_token.type = TK_BUILTIN_FUNC;
+							r_token.value = bifunc;
 							return OK;
 						}
 
-						r_token.type=TK_IDENTIFIER;
-						r_token.value=id;
+						r_token.type = TK_IDENTIFIER;
+						r_token.value = id;
 					}
 
 					return OK;
 				} else {
 					_set_error("Unexpected character.");
-					r_token.type=TK_ERROR;
+					r_token.type = TK_ERROR;
 					return ERR_PARSE_ERROR;
 				}
 			}
 		}
 	}
 
-	r_token.type=TK_ERROR;
+	r_token.type = TK_ERROR;
 	return ERR_PARSE_ERROR;
 }
 
-const char* VisualScriptExpression::token_name[TK_MAX]={
-"CURLY BRACKET OPEN",
-"CURLY BRACKET CLOSE",
-"BRACKET OPEN",
-"BRACKET CLOSE",
-"PARENTHESIS OPEN",
-"PARENTHESIS CLOSE",
-"IDENTIFIER",
-"BUILTIN FUNC",
-"SELF",
-"CONSTANT",
-"BASIC TYPE",
-"COLON",
-"COMMA",
-"PERIOD",
-"OP IN",
-"OP EQUAL",
-"OP NOT EQUAL",
-"OP LESS",
-"OP LESS EQUAL",
-"OP GREATER",
-"OP GREATER EQUAL",
-"OP AND",
-"OP OR",
-"OP NOT",
-"OP ADD",
-"OP SUB",
-"OP MUL",
-"OP DIV",
-"OP MOD",
-"OP SHIFT LEFT",
-"OP SHIFT RIGHT",
-"OP BIT AND",
-"OP BIT OR",
-"OP BIT XOR",
-"OP BIT INVERT",
-"EOF",
-"ERROR"
+const char *VisualScriptExpression::token_name[TK_MAX] = {
+	"CURLY BRACKET OPEN",
+	"CURLY BRACKET CLOSE",
+	"BRACKET OPEN",
+	"BRACKET CLOSE",
+	"PARENTHESIS OPEN",
+	"PARENTHESIS CLOSE",
+	"IDENTIFIER",
+	"BUILTIN FUNC",
+	"SELF",
+	"CONSTANT",
+	"BASIC TYPE",
+	"COLON",
+	"COMMA",
+	"PERIOD",
+	"OP IN",
+	"OP EQUAL",
+	"OP NOT EQUAL",
+	"OP LESS",
+	"OP LESS EQUAL",
+	"OP GREATER",
+	"OP GREATER EQUAL",
+	"OP AND",
+	"OP OR",
+	"OP NOT",
+	"OP ADD",
+	"OP SUB",
+	"OP MUL",
+	"OP DIV",
+	"OP MOD",
+	"OP SHIFT LEFT",
+	"OP SHIFT RIGHT",
+	"OP BIT AND",
+	"OP BIT OR",
+	"OP BIT XOR",
+	"OP BIT INVERT",
+	"EOF",
+	"ERROR"
 };
 
-VisualScriptExpression::ENode* VisualScriptExpression::_parse_expression() {
-
+VisualScriptExpression::ENode *VisualScriptExpression::_parse_expression() {
 
 	Vector<Expression> expression;
 
-	while(true) {
+	while (true) {
 		//keep appending stuff to expression
-		ENode*expr=NULL;
+		ENode *expr = NULL;
 
 		Token tk;
 		_get_token(tk);
 		if (error_set)
 			return NULL;
 
-
-
-		switch(tk.type) {
+		switch (tk.type) {
 			case TK_CURLY_BRACKET_OPEN: {
 				//a dictionary
 				DictionaryNode *dn = alloc_node<DictionaryNode>();
 
+				while (true) {
 
-				while(true) {
-
-					int cofs=str_ofs;
+					int cofs = str_ofs;
 					_get_token(tk);
-					if (tk.type==TK_CURLY_BRACKET_CLOSE) {
+					if (tk.type == TK_CURLY_BRACKET_CLOSE) {
 						break;
 					}
-					str_ofs=cofs; //revert
+					str_ofs = cofs; //revert
 					//parse an expression
-					ENode* expr=_parse_expression();
+					ENode *expr = _parse_expression();
 					if (!expr)
 						return NULL;
 					dn->dict.push_back(expr);
 
 					_get_token(tk);
-					if (tk.type!=TK_COLON) {
+					if (tk.type != TK_COLON) {
 						_set_error("Expected ':'");
 						return NULL;
 					}
 
-					expr=_parse_expression();
+					expr = _parse_expression();
 					if (!expr)
 						return NULL;
 
 					dn->dict.push_back(expr);
 
-					cofs=str_ofs;
+					cofs = str_ofs;
 					_get_token(tk);
-					if (tk.type==TK_COMMA) {
+					if (tk.type == TK_COMMA) {
 						//all good
-					} else if (tk.type==TK_CURLY_BRACKET_CLOSE) {
-						str_ofs=cofs;
+					} else if (tk.type == TK_CURLY_BRACKET_CLOSE) {
+						str_ofs = cofs;
 					} else {
 						_set_error("Expected ',' or '}'");
 					}
 				}
 
-				expr=dn;
+				expr = dn;
 			} break;
 			case TK_BRACKET_OPEN: {
 				//an array
 
 				ArrayNode *an = alloc_node<ArrayNode>();
 
+				while (true) {
 
-				while(true) {
-
-					int cofs=str_ofs;
+					int cofs = str_ofs;
 					_get_token(tk);
-					if (tk.type==TK_BRACKET_CLOSE) {
+					if (tk.type == TK_BRACKET_CLOSE) {
 						break;
 					}
-					str_ofs=cofs; //revert
+					str_ofs = cofs; //revert
 					//parse an expression
-					ENode* expr=_parse_expression();
+					ENode *expr = _parse_expression();
 					if (!expr)
 						return NULL;
 					an->array.push_back(expr);
 
-					cofs=str_ofs;
+					cofs = str_ofs;
 					_get_token(tk);
-					if (tk.type==TK_COMMA) {
+					if (tk.type == TK_COMMA) {
 						//all good
-					} else if (tk.type==TK_BRACKET_CLOSE) {
-						str_ofs=cofs;
+					} else if (tk.type == TK_BRACKET_CLOSE) {
+						str_ofs = cofs;
 					} else {
 						_set_error("Expected ',' or ']'");
 					}
 				}
 
-				expr=an;
+				expr = an;
 			} break;
 			case TK_PARENTHESIS_OPEN: {
 				//a suexpression
-				ENode* e=_parse_expression();
+				ENode *e = _parse_expression();
 				if (error_set)
 					return NULL;
 				_get_token(tk);
-				if (tk.type!=TK_PARENTHESIS_CLOSE) {
+				if (tk.type != TK_PARENTHESIS_CLOSE) {
 					_set_error("Expected ')'");
 					return NULL;
 				}
 
-				expr=e;
+				expr = e;
 
 			} break;
 			case TK_IDENTIFIER: {
 
 				String what = tk.value;
-				int index=-1;
-				for(int i=0;i<inputs.size();i++) {
-					if (what==inputs[i].name) {
-						index=i;
+				int index = -1;
+				for (int i = 0; i < inputs.size(); i++) {
+					if (what == inputs[i].name) {
+						index = i;
 						break;
 					}
 				}
 
-				if (index!=-1) {
+				if (index != -1) {
 					InputNode *input = alloc_node<InputNode>();
-					input->index=index;
-					expr=input;
+					input->index = index;
+					expr = input;
 				} else {
-					_set_error("Invalid input identifier '"+what+"'. For script variables, use self (locals are for inputs)."+what);
+					_set_error("Invalid input identifier '" + what + "'. For script variables, use self (locals are for inputs)." + what);
 					return NULL;
 				}
 			} break;
 			case TK_SELF: {
 
 				SelfNode *self = alloc_node<SelfNode>();
-				expr=self;
+				expr = self;
 			} break;
 			case TK_CONSTANT: {
 				ConstantNode *constant = alloc_node<ConstantNode>();
-				constant->value=tk.value;
-				expr=constant;
+				constant->value = tk.value;
+				expr = constant;
 			} break;
 			case TK_BASIC_TYPE: {
 				//constructor..
 
 				Variant::Type bt = Variant::Type(int(tk.value));
 				_get_token(tk);
-				if (tk.type!=TK_PARENTHESIS_OPEN) {
+				if (tk.type != TK_PARENTHESIS_OPEN) {
 					_set_error("Expected '('");
 					return NULL;
 				}
 
 				ConstructorNode *constructor = alloc_node<ConstructorNode>();
-				constructor->data_type=bt;
+				constructor->data_type = bt;
 
-				while(true) {
+				while (true) {
 
-					int cofs=str_ofs;
+					int cofs = str_ofs;
 					_get_token(tk);
-					if (tk.type==TK_PARENTHESIS_CLOSE) {
+					if (tk.type == TK_PARENTHESIS_CLOSE) {
 						break;
 					}
-					str_ofs=cofs; //revert
+					str_ofs = cofs; //revert
 					//parse an expression
-					ENode* expr=_parse_expression();
+					ENode *expr = _parse_expression();
 					if (!expr)
 						return NULL;
 
 					constructor->arguments.push_back(expr);
 
-					cofs=str_ofs;
+					cofs = str_ofs;
 					_get_token(tk);
-					if (tk.type==TK_COMMA) {
+					if (tk.type == TK_COMMA) {
 						//all good
-					} else if (tk.type==TK_PARENTHESIS_CLOSE) {
-						str_ofs=cofs;
+					} else if (tk.type == TK_PARENTHESIS_CLOSE) {
+						str_ofs = cofs;
 					} else {
 						_set_error("Expected ',' or ')'");
 					}
 				}
 
-				expr=constructor;
+				expr = constructor;
 
 			} break;
 			case TK_BUILTIN_FUNC: {
@@ -861,35 +833,35 @@ VisualScriptExpression::ENode* VisualScriptExpression::_parse_expression() {
 
 				Variant::Type bt = Variant::Type(int(tk.value));
 				_get_token(tk);
-				if (tk.type!=TK_PARENTHESIS_OPEN) {
+				if (tk.type != TK_PARENTHESIS_OPEN) {
 					_set_error("Expected '('");
 					return NULL;
 				}
 
 				BuiltinFuncNode *bifunc = alloc_node<BuiltinFuncNode>();
-				bifunc->func=VisualScriptBuiltinFunc::BuiltinFunc(int(tk.value));
+				bifunc->func = VisualScriptBuiltinFunc::BuiltinFunc(int(tk.value));
 
-				while(true) {
+				while (true) {
 
-					int cofs=str_ofs;
+					int cofs = str_ofs;
 					_get_token(tk);
-					if (tk.type==TK_PARENTHESIS_CLOSE) {
+					if (tk.type == TK_PARENTHESIS_CLOSE) {
 						break;
 					}
-					str_ofs=cofs; //revert
+					str_ofs = cofs; //revert
 					//parse an expression
-					ENode* expr=_parse_expression();
+					ENode *expr = _parse_expression();
 					if (!expr)
 						return NULL;
 
 					bifunc->arguments.push_back(expr);
 
-					cofs=str_ofs;
+					cofs = str_ofs;
 					_get_token(tk);
-					if (tk.type==TK_COMMA) {
+					if (tk.type == TK_COMMA) {
 						//all good
-					} else if (tk.type==TK_PARENTHESIS_CLOSE) {
-						str_ofs=cofs;
+					} else if (tk.type == TK_PARENTHESIS_CLOSE) {
+						str_ofs = cofs;
 					} else {
 						_set_error("Expected ',' or ')'");
 					}
@@ -897,25 +869,25 @@ VisualScriptExpression::ENode* VisualScriptExpression::_parse_expression() {
 
 				int expected_args = VisualScriptBuiltinFunc::get_func_argument_count(bifunc->func);
 				if (bifunc->arguments.size() != expected_args) {
-					_set_error("Builtin func '"+VisualScriptBuiltinFunc::get_func_name(bifunc->func)+"' expects "+itos(expected_args)+" arguments.");
+					_set_error("Builtin func '" + VisualScriptBuiltinFunc::get_func_name(bifunc->func) + "' expects " + itos(expected_args) + " arguments.");
 				}
 
-				expr=bifunc;
+				expr = bifunc;
 
 			} break;
 			case TK_OP_SUB: {
 
 				Expression e;
-				e.is_op=true;
-				e.op=Variant::OP_NEGATE;
+				e.is_op = true;
+				e.op = Variant::OP_NEGATE;
 				expression.push_back(e);
 				continue;
 			} break;
 			case TK_OP_NOT: {
 
 				Expression e;
-				e.is_op=true;
-				e.op=Variant::OP_NOT;
+				e.is_op = true;
+				e.op = Variant::OP_NOT;
 				expression.push_back(e);
 				continue;
 			} break;
@@ -924,100 +896,98 @@ VisualScriptExpression::ENode* VisualScriptExpression::_parse_expression() {
 				_set_error("Expected expression.");
 				return NULL;
 			} break;
-
 		}
 
 		//before going to operators, must check indexing!
 
-		while(true) {
-			int cofs2=str_ofs;
+		while (true) {
+			int cofs2 = str_ofs;
 			_get_token(tk);
 			if (error_set)
 				return NULL;
 
-			bool done=false;
+			bool done = false;
 
-			switch(tk.type) {
+			switch (tk.type) {
 				case TK_BRACKET_OPEN: {
 					//value indexing
 
 					IndexNode *index = alloc_node<IndexNode>();
-					index->base=expr;
+					index->base = expr;
 
-					ENode* what=_parse_expression();
+					ENode *what = _parse_expression();
 					if (!what)
 						return NULL;
 
-					index->index=what;
+					index->index = what;
 
 					_get_token(tk);
-					if (tk.type!=TK_BRACKET_CLOSE) {
+					if (tk.type != TK_BRACKET_CLOSE) {
 						_set_error("Expected ']' at end of index.");
 						return NULL;
 					}
-					expr=index;
+					expr = index;
 
 				} break;
 				case TK_PERIOD: {
 					//named indexing or function call
 					_get_token(tk);
-					if (tk.type!=TK_IDENTIFIER) {
+					if (tk.type != TK_IDENTIFIER) {
 						_set_error("Expected identifier after '.'");
 						return NULL;
 					}
 
-					StringName identifier=tk.value;
+					StringName identifier = tk.value;
 
-					int cofs=str_ofs;
+					int cofs = str_ofs;
 					_get_token(tk);
-					if (tk.type==TK_PARENTHESIS_OPEN) {
+					if (tk.type == TK_PARENTHESIS_OPEN) {
 						//function call
 						CallNode *func_call = alloc_node<CallNode>();
-						func_call->method=identifier;
-						func_call->base=expr;
+						func_call->method = identifier;
+						func_call->base = expr;
 
-						while(true) {
+						while (true) {
 
-							int cofs=str_ofs;
+							int cofs = str_ofs;
 							_get_token(tk);
-							if (tk.type==TK_PARENTHESIS_CLOSE) {
+							if (tk.type == TK_PARENTHESIS_CLOSE) {
 								break;
 							}
-							str_ofs=cofs; //revert
+							str_ofs = cofs; //revert
 							//parse an expression
-							ENode* expr=_parse_expression();
+							ENode *expr = _parse_expression();
 							if (!expr)
 								return NULL;
 
 							func_call->arguments.push_back(expr);
 
-							cofs=str_ofs;
+							cofs = str_ofs;
 							_get_token(tk);
-							if (tk.type==TK_COMMA) {
+							if (tk.type == TK_COMMA) {
 								//all good
-							} else if (tk.type==TK_PARENTHESIS_CLOSE) {
-								str_ofs=cofs;
+							} else if (tk.type == TK_PARENTHESIS_CLOSE) {
+								str_ofs = cofs;
 							} else {
 								_set_error("Expected ',' or ')'");
 							}
 						}
 
-						expr=func_call;
+						expr = func_call;
 					} else {
 						//named indexing
-						str_ofs=cofs;
+						str_ofs = cofs;
 
 						NamedIndexNode *index = alloc_node<NamedIndexNode>();
-						index->base=expr;
-						index->name=identifier;
-						expr=index;
-
+						index->base = expr;
+						index->name = identifier;
+						expr = index;
 					}
 
 				} break;
 				default: {
-					str_ofs=cofs2;
-					done=true;
+					str_ofs = cofs2;
+					done = true;
 				} break;
 			}
 
@@ -1028,74 +998,68 @@ VisualScriptExpression::ENode* VisualScriptExpression::_parse_expression() {
 		//push expression
 		{
 			Expression e;
-			e.is_op=false;
-			e.node=expr;
+			e.is_op = false;
+			e.node = expr;
 			expression.push_back(e);
 		}
 
 		//ok finally look for an operator
 
-
-		int cofs=str_ofs;
+		int cofs = str_ofs;
 		_get_token(tk);
 		if (error_set)
 			return NULL;
 
-
 		Variant::Operator op = Variant::OP_MAX;
 
-		switch(tk.type) {
-			case TK_OP_IN: op=Variant::OP_IN; break;
-			case TK_OP_EQUAL: op=Variant::OP_EQUAL; break;
-			case TK_OP_NOT_EQUAL: op=Variant::OP_NOT_EQUAL; break;
-			case TK_OP_LESS: op=Variant::OP_LESS; break;
-			case TK_OP_LESS_EQUAL: op=Variant::OP_LESS_EQUAL; break;
-			case TK_OP_GREATER: op=Variant::OP_GREATER; break;
-			case TK_OP_GREATER_EQUAL: op=Variant::OP_GREATER_EQUAL; break;
-			case TK_OP_AND: op=Variant::OP_AND; break;
-			case TK_OP_OR: op=Variant::OP_OR; break;
-			case TK_OP_NOT: op=Variant::OP_NOT; break;
-			case TK_OP_ADD: op=Variant::OP_ADD; break;
-			case TK_OP_SUB: op=Variant::OP_SUBSTRACT; break;
-			case TK_OP_MUL: op=Variant::OP_MULTIPLY; break;
-			case TK_OP_DIV: op=Variant::OP_DIVIDE; break;
-			case TK_OP_MOD: op=Variant::OP_MODULE; break;
-			case TK_OP_SHIFT_LEFT: op=Variant::OP_SHIFT_LEFT; break;
-			case TK_OP_SHIFT_RIGHT: op=Variant::OP_SHIFT_RIGHT; break;
-			case TK_OP_BIT_AND: op=Variant::OP_BIT_AND; break;
-			case TK_OP_BIT_OR: op=Variant::OP_BIT_OR; break;
-			case TK_OP_BIT_XOR: op=Variant::OP_BIT_XOR; break;
-			case TK_OP_BIT_INVERT: op=Variant::OP_BIT_NEGATE; break;
+		switch (tk.type) {
+			case TK_OP_IN: op = Variant::OP_IN; break;
+			case TK_OP_EQUAL: op = Variant::OP_EQUAL; break;
+			case TK_OP_NOT_EQUAL: op = Variant::OP_NOT_EQUAL; break;
+			case TK_OP_LESS: op = Variant::OP_LESS; break;
+			case TK_OP_LESS_EQUAL: op = Variant::OP_LESS_EQUAL; break;
+			case TK_OP_GREATER: op = Variant::OP_GREATER; break;
+			case TK_OP_GREATER_EQUAL: op = Variant::OP_GREATER_EQUAL; break;
+			case TK_OP_AND: op = Variant::OP_AND; break;
+			case TK_OP_OR: op = Variant::OP_OR; break;
+			case TK_OP_NOT: op = Variant::OP_NOT; break;
+			case TK_OP_ADD: op = Variant::OP_ADD; break;
+			case TK_OP_SUB: op = Variant::OP_SUBSTRACT; break;
+			case TK_OP_MUL: op = Variant::OP_MULTIPLY; break;
+			case TK_OP_DIV: op = Variant::OP_DIVIDE; break;
+			case TK_OP_MOD: op = Variant::OP_MODULE; break;
+			case TK_OP_SHIFT_LEFT: op = Variant::OP_SHIFT_LEFT; break;
+			case TK_OP_SHIFT_RIGHT: op = Variant::OP_SHIFT_RIGHT; break;
+			case TK_OP_BIT_AND: op = Variant::OP_BIT_AND; break;
+			case TK_OP_BIT_OR: op = Variant::OP_BIT_OR; break;
+			case TK_OP_BIT_XOR: op = Variant::OP_BIT_XOR; break;
+			case TK_OP_BIT_INVERT: op = Variant::OP_BIT_NEGATE; break;
 			default: {};
 		}
 
-		if (op==Variant::OP_MAX) { //stop appending stuff
-			str_ofs=cofs;
+		if (op == Variant::OP_MAX) { //stop appending stuff
+			str_ofs = cofs;
 			break;
 		}
 
 		//push operator and go on
 		{
 			Expression e;
-			e.is_op=true;
-			e.op=op;
+			e.is_op = true;
+			e.op = op;
 			expression.push_back(e);
 		}
 	}
 
-
 	/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
 
+	while (expression.size() > 1) {
 
-	while(expression.size()>1) {
-
-		int next_op=-1;
-		int min_priority=0xFFFFF;
-		bool is_unary=false;
-
-		for(int i=0;i<expression.size();i++) {
-
+		int next_op = -1;
+		int min_priority = 0xFFFFF;
+		bool is_unary = false;
 
+		for (int i = 0; i < expression.size(); i++) {
 
 			if (!expression[i].is_op) {
 
@@ -1104,77 +1068,80 @@ VisualScriptExpression::ENode* VisualScriptExpression::_parse_expression() {
 
 			int priority;
 
-			bool unary=false;
-
-			switch(expression[i].op) {
-
+			bool unary = false;
 
-				case Variant::OP_BIT_NEGATE: priority=0; unary=true; break;
-				case Variant::OP_NEGATE: priority=1; unary=true; break;
+			switch (expression[i].op) {
 
-				case Variant::OP_MULTIPLY: priority=2; break;
-				case Variant::OP_DIVIDE: priority=2; break;
-				case Variant::OP_MODULE: priority=2; break;
+				case Variant::OP_BIT_NEGATE:
+					priority = 0;
+					unary = true;
+					break;
+				case Variant::OP_NEGATE:
+					priority = 1;
+					unary = true;
+					break;
 
-				case Variant::OP_ADD: priority=3; break;
-				case Variant::OP_SUBSTRACT: priority=3; break;
+				case Variant::OP_MULTIPLY: priority = 2; break;
+				case Variant::OP_DIVIDE: priority = 2; break;
+				case Variant::OP_MODULE: priority = 2; break;
 
-				case Variant::OP_SHIFT_LEFT: priority=4; break;
-				case Variant::OP_SHIFT_RIGHT: priority=4; break;
+				case Variant::OP_ADD: priority = 3; break;
+				case Variant::OP_SUBSTRACT: priority = 3; break;
 
-				case Variant::OP_BIT_AND: priority=5; break;
-				case Variant::OP_BIT_XOR: priority=6; break;
-				case Variant::OP_BIT_OR: priority=7; break;
+				case Variant::OP_SHIFT_LEFT: priority = 4; break;
+				case Variant::OP_SHIFT_RIGHT: priority = 4; break;
 
-				case Variant::OP_LESS: priority=8; break;
-				case Variant::OP_LESS_EQUAL: priority=8; break;
-				case Variant::OP_GREATER: priority=8; break;
-				case Variant::OP_GREATER_EQUAL: priority=8; break;
+				case Variant::OP_BIT_AND: priority = 5; break;
+				case Variant::OP_BIT_XOR: priority = 6; break;
+				case Variant::OP_BIT_OR: priority = 7; break;
 
-				case Variant::OP_EQUAL: priority=8; break;
-				case Variant::OP_NOT_EQUAL: priority=8; break;
+				case Variant::OP_LESS: priority = 8; break;
+				case Variant::OP_LESS_EQUAL: priority = 8; break;
+				case Variant::OP_GREATER: priority = 8; break;
+				case Variant::OP_GREATER_EQUAL: priority = 8; break;
 
-				case Variant::OP_IN: priority=10; break;
+				case Variant::OP_EQUAL: priority = 8; break;
+				case Variant::OP_NOT_EQUAL: priority = 8; break;
 
-				case Variant::OP_NOT: priority=11; unary=true; break;
-				case Variant::OP_AND: priority=12; break;
-				case Variant::OP_OR: priority=13; break;
+				case Variant::OP_IN: priority = 10; break;
 
+				case Variant::OP_NOT:
+					priority = 11;
+					unary = true;
+					break;
+				case Variant::OP_AND: priority = 12; break;
+				case Variant::OP_OR: priority = 13; break;
 
 				default: {
-					_set_error("Parser bug, invalid operator in expression: "+itos(expression[i].op));
+					_set_error("Parser bug, invalid operator in expression: " + itos(expression[i].op));
 					return NULL;
 				}
-
 			}
 
-			if (priority<min_priority) {
+			if (priority < min_priority) {
 				// < is used for left to right (default)
 				// <= is used for right to left
 
-				next_op=i;
-				min_priority=priority;
-				is_unary=unary;
+				next_op = i;
+				min_priority = priority;
+				is_unary = unary;
 			}
-
 		}
 
-		if (next_op==-1) {
-
+		if (next_op == -1) {
 
 			_set_error("Yet another parser bug....");
-			ERR_FAIL_COND_V(next_op==-1,NULL);
+			ERR_FAIL_COND_V(next_op == -1, NULL);
 		}
 
-
 		// OK! create operator..
 		if (is_unary) {
 
-			int expr_pos=next_op;
-			while(expression[expr_pos].is_op) {
+			int expr_pos = next_op;
+			while (expression[expr_pos].is_op) {
 
 				expr_pos++;
-				if (expr_pos==expression.size()) {
+				if (expr_pos == expression.size()) {
 					//can happen..
 					_set_error("Unexpected end of expression..");
 					return NULL;
@@ -1182,35 +1149,34 @@ VisualScriptExpression::ENode* VisualScriptExpression::_parse_expression() {
 			}
 
 			//consecutively do unary opeators
-			for(int i=expr_pos-1;i>=next_op;i--) {
+			for (int i = expr_pos - 1; i >= next_op; i--) {
 
 				OperatorNode *op = alloc_node<OperatorNode>();
-				op->op=expression[i].op;
-				op->nodes[0]=expression[i+1].node;
-				op->nodes[1]=NULL;
-				expression[i].is_op=false;
-				expression[i].node=op;
-				expression.remove(i+1);
+				op->op = expression[i].op;
+				op->nodes[0] = expression[i + 1].node;
+				op->nodes[1] = NULL;
+				expression[i].is_op = false;
+				expression[i].node = op;
+				expression.remove(i + 1);
 			}
 
-
 		} else {
 
-			if (next_op <1 || next_op>=(expression.size()-1)) {
+			if (next_op < 1 || next_op >= (expression.size() - 1)) {
 				_set_error("Parser bug..");
 				ERR_FAIL_V(NULL);
 			}
 
 			OperatorNode *op = alloc_node<OperatorNode>();
-			op->op=expression[next_op].op;
+			op->op = expression[next_op].op;
 
-			if (expression[next_op-1].is_op) {
+			if (expression[next_op - 1].is_op) {
 
 				_set_error("Parser bug..");
 				ERR_FAIL_V(NULL);
 			}
 
-			if (expression[next_op+1].is_op) {
+			if (expression[next_op + 1].is_op) {
 				// this is not invalid and can really appear
 				// but it becomes invalid anyway because no binary op
 				// can be followed by an unary op in a valid combination,
@@ -1220,12 +1186,11 @@ VisualScriptExpression::ENode* VisualScriptExpression::_parse_expression() {
 				return NULL;
 			}
 
-
-			op->nodes[0]=expression[next_op-1].node; //expression goes as left
-			op->nodes[1]=expression[next_op+1].node; //next expression goes as right
+			op->nodes[0] = expression[next_op - 1].node; //expression goes as left
+			op->nodes[1] = expression[next_op + 1].node; //next expression goes as right
 
 			//replace all 3 nodes by this operator and make it an expression
-			expression[next_op-1].node=op;
+			expression[next_op - 1].node = op;
 			expression.remove(next_op);
 			expression.remove(next_op);
 		}
@@ -1241,250 +1206,239 @@ bool VisualScriptExpression::_compile_expression() {
 
 	if (nodes) {
 		memdelete(nodes);
-		nodes=NULL;
-		root=NULL;
-
+		nodes = NULL;
+		root = NULL;
 	}
 
-	error_str=String();
-	error_set=false;
-	str_ofs=0;
+	error_str = String();
+	error_set = false;
+	str_ofs = 0;
 
-	root=_parse_expression();
+	root = _parse_expression();
 
 	if (error_set) {
-		root=NULL;
+		root = NULL;
 		if (nodes) {
 			memdelete(nodes);
 		}
-		nodes=NULL;
+		nodes = NULL;
 		return true;
 	}
 
-	expression_dirty=false;
+	expression_dirty = false;
 	return false;
 }
 
-
 class VisualScriptNodeInstanceExpression : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	VisualScriptExpression *expression;
 
 	//virtual int get_working_memory_size() const { return 0; }
 	//execute by parsing the tree directly
-	virtual bool _execute(const Variant** p_inputs,VisualScriptExpression::ENode *p_node,Variant& r_ret,String& r_error_str,Variant::CallError &ce) {
+	virtual bool _execute(const Variant **p_inputs, VisualScriptExpression::ENode *p_node, Variant &r_ret, String &r_error_str, Variant::CallError &ce) {
 
-		switch(p_node->type) {
-			case VisualScriptExpression::ENode::TYPE_INPUT:  {
+		switch (p_node->type) {
+			case VisualScriptExpression::ENode::TYPE_INPUT: {
 
-				const VisualScriptExpression::InputNode *in = static_cast<const VisualScriptExpression::InputNode*>(p_node);
-				r_ret=*p_inputs[in->index];
+				const VisualScriptExpression::InputNode *in = static_cast<const VisualScriptExpression::InputNode *>(p_node);
+				r_ret = *p_inputs[in->index];
 			} break;
-			case VisualScriptExpression::ENode::TYPE_CONSTANT:  {
+			case VisualScriptExpression::ENode::TYPE_CONSTANT: {
 
-				const VisualScriptExpression::ConstantNode *c = static_cast<const VisualScriptExpression::ConstantNode*>(p_node);
-				r_ret=c->value;
+				const VisualScriptExpression::ConstantNode *c = static_cast<const VisualScriptExpression::ConstantNode *>(p_node);
+				r_ret = c->value;
 
 			} break;
-			case VisualScriptExpression::ENode::TYPE_SELF:  {
+			case VisualScriptExpression::ENode::TYPE_SELF: {
 
-				r_ret=instance->get_owner_ptr();
+				r_ret = instance->get_owner_ptr();
 			} break;
-			case VisualScriptExpression::ENode::TYPE_OPERATOR:  {
+			case VisualScriptExpression::ENode::TYPE_OPERATOR: {
 
-
-				const VisualScriptExpression::OperatorNode *op = static_cast<const VisualScriptExpression::OperatorNode*>(p_node);
+				const VisualScriptExpression::OperatorNode *op = static_cast<const VisualScriptExpression::OperatorNode *>(p_node);
 
 				Variant a;
-				bool ret = _execute(p_inputs,op->nodes[0],a,r_error_str,ce);
+				bool ret = _execute(p_inputs, op->nodes[0], a, r_error_str, ce);
 				if (ret)
 					return true;
 
 				Variant b;
 
 				if (op->nodes[1]) {
-					ret = _execute(p_inputs,op->nodes[1],b,r_error_str,ce);
+					ret = _execute(p_inputs, op->nodes[1], b, r_error_str, ce);
 					if (ret)
 						return true;
 				}
 
-				bool valid=true;
-				Variant::evaluate(op->op,a,b,r_ret,valid);
+				bool valid = true;
+				Variant::evaluate(op->op, a, b, r_ret, valid);
 				if (!valid) {
-					r_error_str="Invalid operands to operator "+Variant::get_operator_name(op->op)+": "+Variant::get_type_name(a.get_type())+" and "+Variant::get_type_name(b.get_type())+".";
+					r_error_str = "Invalid operands to operator " + Variant::get_operator_name(op->op) + ": " + Variant::get_type_name(a.get_type()) + " and " + Variant::get_type_name(b.get_type()) + ".";
 					return true;
 				}
 
 			} break;
-			case VisualScriptExpression::ENode::TYPE_INDEX:  {
+			case VisualScriptExpression::ENode::TYPE_INDEX: {
 
-				const VisualScriptExpression::IndexNode *index = static_cast<const VisualScriptExpression::IndexNode*>(p_node);
+				const VisualScriptExpression::IndexNode *index = static_cast<const VisualScriptExpression::IndexNode *>(p_node);
 
 				Variant base;
-				bool ret = _execute(p_inputs,index->base,base,r_error_str,ce);
+				bool ret = _execute(p_inputs, index->base, base, r_error_str, ce);
 				if (ret)
 					return true;
 
 				Variant idx;
 
-				ret = _execute(p_inputs,index->index,idx,r_error_str,ce);
+				ret = _execute(p_inputs, index->index, idx, r_error_str, ce);
 				if (ret)
 					return true;
 
 				bool valid;
-				r_ret=base.get(idx,&valid);
+				r_ret = base.get(idx, &valid);
 				if (!valid) {
-					r_error_str="Invalid index of type "+Variant::get_type_name(idx.get_type())+" for base of type "+Variant::get_type_name(base.get_type())+".";
+					r_error_str = "Invalid index of type " + Variant::get_type_name(idx.get_type()) + " for base of type " + Variant::get_type_name(base.get_type()) + ".";
 					return true;
 				}
 
-
-
 			} break;
-			case VisualScriptExpression::ENode::TYPE_NAMED_INDEX:  {
+			case VisualScriptExpression::ENode::TYPE_NAMED_INDEX: {
 
-				const VisualScriptExpression::NamedIndexNode *index = static_cast<const VisualScriptExpression::NamedIndexNode*>(p_node);
+				const VisualScriptExpression::NamedIndexNode *index = static_cast<const VisualScriptExpression::NamedIndexNode *>(p_node);
 
 				Variant base;
-				bool ret = _execute(p_inputs,index->base,base,r_error_str,ce);
+				bool ret = _execute(p_inputs, index->base, base, r_error_str, ce);
 				if (ret)
 					return true;
 
 				bool valid;
-				r_ret=base.get_named(index->name,&valid);
+				r_ret = base.get_named(index->name, &valid);
 				if (!valid) {
-					r_error_str="Invalid index '"+String(index->name)+"' for base of type "+Variant::get_type_name(base.get_type())+".";
+					r_error_str = "Invalid index '" + String(index->name) + "' for base of type " + Variant::get_type_name(base.get_type()) + ".";
 					return true;
 				}
 
 			} break;
-			case VisualScriptExpression::ENode::TYPE_ARRAY:  {
-				const VisualScriptExpression::ArrayNode *array = static_cast<const VisualScriptExpression::ArrayNode*>(p_node);
+			case VisualScriptExpression::ENode::TYPE_ARRAY: {
+				const VisualScriptExpression::ArrayNode *array = static_cast<const VisualScriptExpression::ArrayNode *>(p_node);
 
 				Array arr;
 				arr.resize(array->array.size());
-				for (int i=0;i<array->array.size();i++) {
+				for (int i = 0; i < array->array.size(); i++) {
 
 					Variant value;
-					bool ret = _execute(p_inputs,array->array[i],value,r_error_str,ce);
+					bool ret = _execute(p_inputs, array->array[i], value, r_error_str, ce);
 					if (ret)
 						return true;
-					arr[i]=value;
+					arr[i] = value;
 				}
 
-				r_ret=arr;
+				r_ret = arr;
 
 			} break;
-			case VisualScriptExpression::ENode::TYPE_DICTIONARY:  {
-				const VisualScriptExpression::DictionaryNode *dictionary = static_cast<const VisualScriptExpression::DictionaryNode*>(p_node);
+			case VisualScriptExpression::ENode::TYPE_DICTIONARY: {
+				const VisualScriptExpression::DictionaryNode *dictionary = static_cast<const VisualScriptExpression::DictionaryNode *>(p_node);
 
 				Dictionary d;
-				for (int i=0;i<dictionary->dict.size();i+=2) {
+				for (int i = 0; i < dictionary->dict.size(); i += 2) {
 
 					Variant key;
-					bool ret = _execute(p_inputs,dictionary->dict[i+0],key,r_error_str,ce);
+					bool ret = _execute(p_inputs, dictionary->dict[i + 0], key, r_error_str, ce);
 					if (ret)
 						return true;
 
 					Variant value;
-					ret = _execute(p_inputs,dictionary->dict[i+1],value,r_error_str,ce);
+					ret = _execute(p_inputs, dictionary->dict[i + 1], value, r_error_str, ce);
 					if (ret)
 						return true;
 
-					d[key]=value;
+					d[key] = value;
 				}
 
-				r_ret=d;
+				r_ret = d;
 			} break;
-			case VisualScriptExpression::ENode::TYPE_CONSTRUCTOR:  {
+			case VisualScriptExpression::ENode::TYPE_CONSTRUCTOR: {
 
-				const VisualScriptExpression::ConstructorNode *constructor = static_cast<const VisualScriptExpression::ConstructorNode*>(p_node);
+				const VisualScriptExpression::ConstructorNode *constructor = static_cast<const VisualScriptExpression::ConstructorNode *>(p_node);
 
 				Vector<Variant> arr;
-				Vector<const Variant*> argp;
+				Vector<const Variant *> argp;
 				arr.resize(constructor->arguments.size());
 				argp.resize(constructor->arguments.size());
 
-				for (int i=0;i<constructor->arguments.size();i++) {
+				for (int i = 0; i < constructor->arguments.size(); i++) {
 
 					Variant value;
-					bool ret = _execute(p_inputs,constructor->arguments[i],value,r_error_str,ce);
+					bool ret = _execute(p_inputs, constructor->arguments[i], value, r_error_str, ce);
 					if (ret)
 						return true;
-					arr[i]=value;
-					argp[i]=&arr[i];
+					arr[i] = value;
+					argp[i] = &arr[i];
 				}
 
+				r_ret = Variant::construct(constructor->data_type, argp.ptr(), argp.size(), ce);
 
-				r_ret=Variant::construct(constructor->data_type,argp.ptr(),argp.size(),ce);
-
-				if (ce.error!=Variant::CallError::CALL_OK) {
-					r_error_str="Invalid arguments to construct '"+Variant::get_type_name(constructor->data_type)+"'.";
+				if (ce.error != Variant::CallError::CALL_OK) {
+					r_error_str = "Invalid arguments to construct '" + Variant::get_type_name(constructor->data_type) + "'.";
 					return true;
 				}
 
-
 			} break;
-			case VisualScriptExpression::ENode::TYPE_BUILTIN_FUNC:  {
+			case VisualScriptExpression::ENode::TYPE_BUILTIN_FUNC: {
 
-				const VisualScriptExpression::BuiltinFuncNode *bifunc = static_cast<const VisualScriptExpression::BuiltinFuncNode*>(p_node);
+				const VisualScriptExpression::BuiltinFuncNode *bifunc = static_cast<const VisualScriptExpression::BuiltinFuncNode *>(p_node);
 
 				Vector<Variant> arr;
-				Vector<const Variant*> argp;
+				Vector<const Variant *> argp;
 				arr.resize(bifunc->arguments.size());
 				argp.resize(bifunc->arguments.size());
 
-				for (int i=0;i<bifunc->arguments.size();i++) {
+				for (int i = 0; i < bifunc->arguments.size(); i++) {
 
 					Variant value;
-					bool ret = _execute(p_inputs,bifunc->arguments[i],value,r_error_str,ce);
+					bool ret = _execute(p_inputs, bifunc->arguments[i], value, r_error_str, ce);
 					if (ret)
 						return true;
-					arr[i]=value;
-					argp[i]=&arr[i];
+					arr[i] = value;
+					argp[i] = &arr[i];
 				}
 
+				VisualScriptBuiltinFunc::exec_func(bifunc->func, argp.ptr(), &r_ret, ce, r_error_str);
 
-				VisualScriptBuiltinFunc::exec_func(bifunc->func,argp.ptr(),&r_ret,ce,r_error_str);
-
-				if (ce.error!=Variant::CallError::CALL_OK) {
-					r_error_str="Builtin Call Failed. "+r_error_str;
+				if (ce.error != Variant::CallError::CALL_OK) {
+					r_error_str = "Builtin Call Failed. " + r_error_str;
 					return true;
 				}
 
 			} break;
-			case VisualScriptExpression::ENode::TYPE_CALL:  {
-
-				const VisualScriptExpression::CallNode *call = static_cast<const VisualScriptExpression::CallNode*>(p_node);
+			case VisualScriptExpression::ENode::TYPE_CALL: {
 
+				const VisualScriptExpression::CallNode *call = static_cast<const VisualScriptExpression::CallNode *>(p_node);
 
 				Variant base;
-				bool ret = _execute(p_inputs,call->base,base,r_error_str,ce);
+				bool ret = _execute(p_inputs, call->base, base, r_error_str, ce);
 				if (ret)
 					return true;
 
 				Vector<Variant> arr;
-				Vector<const Variant*> argp;
+				Vector<const Variant *> argp;
 				arr.resize(call->arguments.size());
 				argp.resize(call->arguments.size());
 
-				for (int i=0;i<call->arguments.size();i++) {
+				for (int i = 0; i < call->arguments.size(); i++) {
 
 					Variant value;
-					bool ret = _execute(p_inputs,call->arguments[i],value,r_error_str,ce);
+					bool ret = _execute(p_inputs, call->arguments[i], value, r_error_str, ce);
 					if (ret)
 						return true;
-					arr[i]=value;
-					argp[i]=&arr[i];
+					arr[i] = value;
+					argp[i] = &arr[i];
 				}
 
+				r_ret = base.call(call->method, argp.ptr(), argp.size(), ce);
 
-				r_ret=base.call(call->method,argp.ptr(),argp.size(),ce);
-
-				if (ce.error!=Variant::CallError::CALL_OK) {
-					r_error_str="On call to '"+String(call->method)+"':";
+				if (ce.error != Variant::CallError::CALL_OK) {
+					r_error_str = "On call to '" + String(call->method) + "':";
 					return true;
 				}
 
@@ -1493,53 +1447,47 @@ public:
 		return false;
 	}
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		if (!expression->root || expression->error_set) {
-			r_error_str=expression->error_str;
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = expression->error_str;
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 			return 0;
 		}
 
-
-		bool error = _execute(p_inputs,expression->root,*p_outputs[0],r_error_str,r_error);
-		if (error && r_error.error==Variant::CallError::CALL_OK) {
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		bool error = _execute(p_inputs, expression->root, *p_outputs[0], r_error_str, r_error);
+		if (error && r_error.error == Variant::CallError::CALL_OK) {
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 		}
 
 #ifdef DEBUG_ENABLED
-		if (!error && expression->output_type!=Variant::NIL && !Variant::can_convert_strict(p_outputs[0]->get_type(),expression->output_type)) {
-
-			r_error_str+="Can't convert expression result from "+Variant::get_type_name(p_outputs[0]->get_type())+" to "+Variant::get_type_name(expression->output_type)+".";
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		if (!error && expression->output_type != Variant::NIL && !Variant::can_convert_strict(p_outputs[0]->get_type(), expression->output_type)) {
 
+			r_error_str += "Can't convert expression result from " + Variant::get_type_name(p_outputs[0]->get_type()) + " to " + Variant::get_type_name(expression->output_type) + ".";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 		}
 #endif
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptExpression::instance(VisualScriptInstance* p_instance){
+VisualScriptNodeInstance *VisualScriptExpression::instance(VisualScriptInstance *p_instance) {
 
 	_compile_expression();
-	VisualScriptNodeInstanceExpression *instance = memnew( VisualScriptNodeInstanceExpression );
-	instance->instance=p_instance;
-	instance->expression=this;
+	VisualScriptNodeInstanceExpression *instance = memnew(VisualScriptNodeInstanceExpression);
+	instance->instance = p_instance;
+	instance->expression = this;
 	return instance;
 }
 
-
-VisualScriptExpression::VisualScriptExpression()
-{
-	output_type=Variant::NIL;
-	expression_dirty=true;
-	error_set=true;
-	root=NULL;
-	nodes=NULL;
-	sequenced=false;
+VisualScriptExpression::VisualScriptExpression() {
+	output_type = Variant::NIL;
+	expression_dirty = true;
+	error_set = true;
+	root = NULL;
+	nodes = NULL;
+	sequenced = false;
 }
 
 VisualScriptExpression::~VisualScriptExpression() {
@@ -1549,9 +1497,7 @@ VisualScriptExpression::~VisualScriptExpression() {
 	}
 }
 
-
 void register_visual_script_expression_node() {
 
-	VisualScriptLanguage::singleton->add_register_func("operators/expression",create_node_generic<VisualScriptExpression>);
-
+	VisualScriptLanguage::singleton->add_register_func("operators/expression", create_node_generic<VisualScriptExpression>);
 }
diff --git a/modules/visual_script/visual_script_expression.h b/modules/visual_script/visual_script_expression.h
index 5bd960f60c..59a7d9fba0 100644
--- a/modules/visual_script/visual_script_expression.h
+++ b/modules/visual_script/visual_script_expression.h
@@ -34,15 +34,15 @@
 
 class VisualScriptExpression : public VisualScriptNode {
 
-	GDCLASS(VisualScriptExpression,VisualScriptNode)
-friend class VisualScriptNodeInstanceExpression;
+	GDCLASS(VisualScriptExpression, VisualScriptNode)
+	friend class VisualScriptNodeInstanceExpression;
 
 	struct Input {
 
 		Variant::Type type;
 		String name;
 
-		Input() { type=Variant::NIL; }
+		Input() { type = Variant::NIL; }
 	};
 
 	Vector<Input> inputs;
@@ -97,28 +97,25 @@ friend class VisualScriptNodeInstanceExpression;
 		TK_MAX
 	};
 
-	static const char* token_name[TK_MAX];
+	static const char *token_name[TK_MAX];
 	struct Token {
 
 		TokenType type;
 		Variant value;
 	};
 
-
-	void _set_error(const String& p_err) {
+	void _set_error(const String &p_err) {
 		if (error_set)
 			return;
-		error_str=p_err;
-		error_set=true;
+		error_str = p_err;
+		error_set = true;
 	}
 
-	Error _get_token(Token& r_token);
+	Error _get_token(Token &r_token);
 
 	String error_str;
 	bool error_set;
 
-
-
 	struct ENode {
 
 		enum Type {
@@ -139,8 +136,12 @@ friend class VisualScriptNodeInstanceExpression;
 
 		Type type;
 
-		ENode() { next=NULL; }
-		virtual ~ENode() { if (next) { memdelete(next); } }
+		ENode() { next = NULL; }
+		virtual ~ENode() {
+			if (next) {
+				memdelete(next);
+			}
+		}
 	};
 
 	struct Expression {
@@ -152,22 +153,21 @@ friend class VisualScriptNodeInstanceExpression;
 		};
 	};
 
-	ENode* _parse_expression();
+	ENode *_parse_expression();
 
 	struct InputNode : public ENode {
 
 		int index;
 		InputNode() {
-			type=TYPE_INPUT;
+			type = TYPE_INPUT;
 		}
 	};
 
-
 	struct ConstantNode : public ENode {
 
 		Variant value;
 		ConstantNode() {
-			type=TYPE_CONSTANT;
+			type = TYPE_CONSTANT;
 		}
 	};
 
@@ -175,119 +175,104 @@ friend class VisualScriptNodeInstanceExpression;
 
 		Variant::Operator op;
 
-		ENode* nodes[2];
+		ENode *nodes[2];
 
 		OperatorNode() {
-			type=TYPE_OPERATOR;
+			type = TYPE_OPERATOR;
 		}
 	};
 
 	struct SelfNode : public ENode {
 
-
 		SelfNode() {
-			type=TYPE_SELF;
+			type = TYPE_SELF;
 		}
 	};
 
 	struct IndexNode : public ENode {
-		ENode*base;
-		ENode*index;
+		ENode *base;
+		ENode *index;
 
 		IndexNode() {
-			type=TYPE_INDEX;
+			type = TYPE_INDEX;
 		}
 	};
 
 	struct NamedIndexNode : public ENode {
-		ENode*base;
+		ENode *base;
 		StringName name;
 
 		NamedIndexNode() {
-			type=TYPE_NAMED_INDEX;
+			type = TYPE_NAMED_INDEX;
 		}
-
 	};
 
 	struct ConstructorNode : public ENode {
 		Variant::Type data_type;
-		Vector<ENode*> arguments;
+		Vector<ENode *> arguments;
 
 		ConstructorNode() {
-			type=TYPE_CONSTRUCTOR;
+			type = TYPE_CONSTRUCTOR;
 		}
 	};
 
 	struct CallNode : public ENode {
-		ENode*base;
+		ENode *base;
 		StringName method;
-		Vector<ENode*> arguments;
+		Vector<ENode *> arguments;
 
 		CallNode() {
-			type=TYPE_CALL;
+			type = TYPE_CALL;
 		}
-
 	};
 
 	struct ArrayNode : public ENode {
-		Vector<ENode*> array;
+		Vector<ENode *> array;
 		ArrayNode() {
-			type=TYPE_ARRAY;
+			type = TYPE_ARRAY;
 		}
-
 	};
 
 	struct DictionaryNode : public ENode {
-		Vector<ENode*> dict;
+		Vector<ENode *> dict;
 		DictionaryNode() {
-			type=TYPE_DICTIONARY;
+			type = TYPE_DICTIONARY;
 		}
-
 	};
 
 	struct BuiltinFuncNode : public ENode {
 		VisualScriptBuiltinFunc::BuiltinFunc func;
-		Vector<ENode*> arguments;
+		Vector<ENode *> arguments;
 		BuiltinFuncNode() {
-			type=TYPE_BUILTIN_FUNC;
+			type = TYPE_BUILTIN_FUNC;
 		}
 	};
 
-	template<class T>
-	T* alloc_node() {
-		T* node = memnew(T);
-		node->next=nodes;
-		nodes=node;
+	template <class T>
+	T *alloc_node() {
+		T *node = memnew(T);
+		node->next = nodes;
+		nodes = node;
 		return node;
 	}
 
 	ENode *root;
 	ENode *nodes;
 
-
-
-
-
 protected:
-
-	bool _set(const StringName& p_name, const Variant& p_value);
-	bool _get(const StringName& p_name,Variant &r_ret) const;
-	void _get_property_list( List<PropertyInfo> *p_list) const;
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
 
 public:
-
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -295,14 +280,12 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "operators"; }
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptExpression();
 	~VisualScriptExpression();
 };
 
-
 void register_visual_script_expression_node();
 
-
 #endif // VISUALSCRIPTEXPRESSION_H
diff --git a/modules/visual_script/visual_script_flow_control.cpp b/modules/visual_script/visual_script_flow_control.cpp
index 8aff96b70c..78847fb588 100644
--- a/modules/visual_script/visual_script_flow_control.cpp
+++ b/modules/visual_script/visual_script_flow_control.cpp
@@ -28,9 +28,8 @@
 /*************************************************************************/
 #include "visual_script_flow_control.h"
 
-#include "os/keyboard.h"
 #include "global_config.h"
-
+#include "os/keyboard.h"
 
 //////////////////////////////////////////
 ////////////////RETURN////////////////////
@@ -41,16 +40,16 @@ int VisualScriptReturn::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptReturn::has_input_sequence_port() const{
+bool VisualScriptReturn::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptReturn::get_input_value_port_count() const{
+int VisualScriptReturn::get_input_value_port_count() const {
 
-	return with_value?1:0;
+	return with_value ? 1 : 0;
 }
-int VisualScriptReturn::get_output_value_port_count() const{
+int VisualScriptReturn::get_output_value_port_count() const {
 
 	return 0;
 }
@@ -60,14 +59,14 @@ String VisualScriptReturn::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptReturn::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptReturn::get_input_value_port_info(int p_idx) const {
 
 	PropertyInfo pinfo;
-	pinfo.name="result";
-	pinfo.type=type;
+	pinfo.name = "result";
+	pinfo.type = type;
 	return pinfo;
 }
-PropertyInfo VisualScriptReturn::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptReturn::get_output_value_port_info(int p_idx) const {
 	return PropertyInfo();
 }
 
@@ -83,23 +82,22 @@ String VisualScriptReturn::get_text() const {
 
 void VisualScriptReturn::set_return_type(Variant::Type p_type) {
 
-	if (type==p_type)
+	if (type == p_type)
 		return;
-	type=p_type;
+	type = p_type;
 	ports_changed_notify();
-
 }
 
-Variant::Type VisualScriptReturn::get_return_type() const{
+Variant::Type VisualScriptReturn::get_return_type() const {
 
 	return type;
 }
 
 void VisualScriptReturn::set_enable_return_value(bool p_enable) {
-	if (with_value==p_enable)
+	if (with_value == p_enable)
 		return;
 
-	with_value=p_enable;
+	with_value = p_enable;
 	ports_changed_notify();
 }
 
@@ -110,24 +108,22 @@ bool VisualScriptReturn::is_return_value_enabled() const {
 
 void VisualScriptReturn::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_return_type","type"),&VisualScriptReturn::set_return_type);
-	ClassDB::bind_method(D_METHOD("get_return_type"),&VisualScriptReturn::get_return_type);
-	ClassDB::bind_method(D_METHOD("set_enable_return_value","enable"),&VisualScriptReturn::set_enable_return_value);
-	ClassDB::bind_method(D_METHOD("is_return_value_enabled"),&VisualScriptReturn::is_return_value_enabled);
+	ClassDB::bind_method(D_METHOD("set_return_type", "type"), &VisualScriptReturn::set_return_type);
+	ClassDB::bind_method(D_METHOD("get_return_type"), &VisualScriptReturn::get_return_type);
+	ClassDB::bind_method(D_METHOD("set_enable_return_value", "enable"), &VisualScriptReturn::set_enable_return_value);
+	ClassDB::bind_method(D_METHOD("is_return_value_enabled"), &VisualScriptReturn::is_return_value_enabled);
 
-	String argt="Any";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	String argt = "Any";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL,"return_value/enabled"),"set_enable_return_value","is_return_value_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"return_value/type",PROPERTY_HINT_ENUM,argt),"set_return_type","get_return_type");
-
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "return_value/enabled"), "set_enable_return_value", "is_return_value_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "return_value/type", PROPERTY_HINT_ENUM, argt), "set_return_type", "get_return_type");
 }
 
 class VisualScriptNodeInstanceReturn : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptReturn *node;
 	VisualScriptInstance *instance;
 	bool with_value;
@@ -136,7 +132,7 @@ public:
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		if (with_value) {
 			*p_working_mem = *p_inputs[0];
@@ -146,27 +142,25 @@ public:
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptReturn::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptReturn::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceReturn * instance = memnew(VisualScriptNodeInstanceReturn );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->with_value=with_value;
+	VisualScriptNodeInstanceReturn *instance = memnew(VisualScriptNodeInstanceReturn);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->with_value = with_value;
 	return instance;
 }
 
 VisualScriptReturn::VisualScriptReturn() {
 
-	with_value=false;
-	type=Variant::NIL;
+	with_value = false;
+	type = Variant::NIL;
 }
 
-template<bool with_value>
-static Ref<VisualScriptNode> create_return_node(const String& p_name) {
+template <bool with_value>
+static Ref<VisualScriptNode> create_return_node(const String &p_name) {
 
 	Ref<VisualScriptReturn> node;
 	node.instance();
@@ -174,8 +168,6 @@ static Ref<VisualScriptNode> create_return_node(const String& p_name) {
 	return node;
 }
 
-
-
 //////////////////////////////////////////
 ////////////////CONDITION/////////////////
 //////////////////////////////////////////
@@ -185,38 +177,38 @@ int VisualScriptCondition::get_output_sequence_port_count() const {
 	return 3;
 }
 
-bool VisualScriptCondition::has_input_sequence_port() const{
+bool VisualScriptCondition::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptCondition::get_input_value_port_count() const{
+int VisualScriptCondition::get_input_value_port_count() const {
 
 	return 1;
 }
-int VisualScriptCondition::get_output_value_port_count() const{
+int VisualScriptCondition::get_output_value_port_count() const {
 
 	return 0;
 }
 
 String VisualScriptCondition::get_output_sequence_port_text(int p_port) const {
 
-	if (p_port==0)
+	if (p_port == 0)
 		return "true";
-	else if (p_port==1)
+	else if (p_port == 1)
 		return "false";
 	else
 		return "done";
 }
 
-PropertyInfo VisualScriptCondition::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptCondition::get_input_value_port_info(int p_idx) const {
 
 	PropertyInfo pinfo;
-	pinfo.name="cond";
-	pinfo.type=Variant::BOOL;
+	pinfo.name = "cond";
+	pinfo.type = Variant::BOOL;
 	return pinfo;
 }
-PropertyInfo VisualScriptCondition::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptCondition::get_output_value_port_info(int p_idx) const {
 	return PropertyInfo();
 }
 
@@ -230,16 +222,11 @@ String VisualScriptCondition::get_text() const {
 	return "if (cond) is:  ";
 }
 
-
 void VisualScriptCondition::_bind_methods() {
-
-
-
 }
 
 class VisualScriptNodeInstanceCondition : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptCondition *node;
 	VisualScriptInstance *instance;
 
@@ -247,33 +234,28 @@ public:
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		if (p_start_mode==START_MODE_CONTINUE_SEQUENCE)
+		if (p_start_mode == START_MODE_CONTINUE_SEQUENCE)
 			return 2;
 		else if (p_inputs[0]->operator bool())
 			return 0 | STEP_FLAG_PUSH_STACK_BIT;
 		else
 			return 1 | STEP_FLAG_PUSH_STACK_BIT;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptCondition::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptCondition::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceCondition * instance = memnew(VisualScriptNodeInstanceCondition );
-	instance->node=this;
-	instance->instance=p_instance;
+	VisualScriptNodeInstanceCondition *instance = memnew(VisualScriptNodeInstanceCondition);
+	instance->node = this;
+	instance->instance = p_instance;
 	return instance;
 }
 
 VisualScriptCondition::VisualScriptCondition() {
-
 }
 
-
-
 //////////////////////////////////////////
 ////////////////WHILE/////////////////
 //////////////////////////////////////////
@@ -283,36 +265,36 @@ int VisualScriptWhile::get_output_sequence_port_count() const {
 	return 2;
 }
 
-bool VisualScriptWhile::has_input_sequence_port() const{
+bool VisualScriptWhile::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptWhile::get_input_value_port_count() const{
+int VisualScriptWhile::get_input_value_port_count() const {
 
 	return 1;
 }
-int VisualScriptWhile::get_output_value_port_count() const{
+int VisualScriptWhile::get_output_value_port_count() const {
 
 	return 0;
 }
 
 String VisualScriptWhile::get_output_sequence_port_text(int p_port) const {
 
-	if (p_port==0)
+	if (p_port == 0)
 		return "repeat";
 	else
 		return "exit";
 }
 
-PropertyInfo VisualScriptWhile::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptWhile::get_input_value_port_info(int p_idx) const {
 
 	PropertyInfo pinfo;
-	pinfo.name="cond";
-	pinfo.type=Variant::BOOL;
+	pinfo.name = "cond";
+	pinfo.type = Variant::BOOL;
 	return pinfo;
 }
-PropertyInfo VisualScriptWhile::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptWhile::get_output_value_port_info(int p_idx) const {
 	return PropertyInfo();
 }
 
@@ -326,16 +308,11 @@ String VisualScriptWhile::get_text() const {
 	return "while (cond): ";
 }
 
-
 void VisualScriptWhile::_bind_methods() {
-
-
-
 }
 
 class VisualScriptNodeInstanceWhile : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptWhile *node;
 	VisualScriptInstance *instance;
 
@@ -343,32 +320,27 @@ public:
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		bool keep_going = p_inputs[0]->operator bool();
 
 		if (keep_going)
-			return 0|STEP_FLAG_PUSH_STACK_BIT;
+			return 0 | STEP_FLAG_PUSH_STACK_BIT;
 		else
 			return 1;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptWhile::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptWhile::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceWhile * instance = memnew(VisualScriptNodeInstanceWhile );
-	instance->node=this;
-	instance->instance=p_instance;
+	VisualScriptNodeInstanceWhile *instance = memnew(VisualScriptNodeInstanceWhile);
+	instance->node = this;
+	instance->instance = p_instance;
 	return instance;
 }
 VisualScriptWhile::VisualScriptWhile() {
-
 }
 
-
-
 //////////////////////////////////////////
 ////////////////ITERATOR/////////////////
 //////////////////////////////////////////
@@ -378,39 +350,39 @@ int VisualScriptIterator::get_output_sequence_port_count() const {
 	return 2;
 }
 
-bool VisualScriptIterator::has_input_sequence_port() const{
+bool VisualScriptIterator::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptIterator::get_input_value_port_count() const{
+int VisualScriptIterator::get_input_value_port_count() const {
 
 	return 1;
 }
-int VisualScriptIterator::get_output_value_port_count() const{
+int VisualScriptIterator::get_output_value_port_count() const {
 
 	return 1;
 }
 
 String VisualScriptIterator::get_output_sequence_port_text(int p_port) const {
 
-	if (p_port==0)
+	if (p_port == 0)
 		return "each";
 	else
 		return "exit";
 }
 
-PropertyInfo VisualScriptIterator::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptIterator::get_input_value_port_info(int p_idx) const {
 
 	PropertyInfo pinfo;
-	pinfo.name="input";
-	pinfo.type=Variant::NIL;
+	pinfo.name = "input";
+	pinfo.type = Variant::NIL;
 	return pinfo;
 }
-PropertyInfo VisualScriptIterator::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptIterator::get_output_value_port_info(int p_idx) const {
 	PropertyInfo pinfo;
-	pinfo.name="elem";
-	pinfo.type=Variant::NIL;
+	pinfo.name = "elem";
+	pinfo.type = Variant::NIL;
 	return pinfo;
 }
 String VisualScriptIterator::get_caption() const {
@@ -423,16 +395,11 @@ String VisualScriptIterator::get_text() const {
 	return "for (elem) in (input): ";
 }
 
-
 void VisualScriptIterator::_bind_methods() {
-
-
-
 }
 
 class VisualScriptNodeInstanceIterator : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptIterator *node;
 	VisualScriptInstance *instance;
 
@@ -440,77 +407,68 @@ public:
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		if (p_start_mode==START_MODE_BEGIN_SEQUENCE) {
-			p_working_mem[0]=*p_inputs[0];
+		if (p_start_mode == START_MODE_BEGIN_SEQUENCE) {
+			p_working_mem[0] = *p_inputs[0];
 			bool valid;
-			bool can_iter = p_inputs[0]->iter_init(p_working_mem[1],valid);
+			bool can_iter = p_inputs[0]->iter_init(p_working_mem[1], valid);
 
 			if (!valid) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-				r_error_str=RTR("Input type not iterable: ")+Variant::get_type_name(p_inputs[0]->get_type());
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				r_error_str = RTR("Input type not iterable: ") + Variant::get_type_name(p_inputs[0]->get_type());
 				return 0;
 			}
 
 			if (!can_iter)
 				return 1; //nothing to iterate
 
-
-			*p_outputs[0]=p_working_mem[0].iter_get( p_working_mem[1],valid);
+			*p_outputs[0] = p_working_mem[0].iter_get(p_working_mem[1], valid);
 
 			if (!valid) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-				r_error_str=RTR("Iterator became invalid");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				r_error_str = RTR("Iterator became invalid");
 				return 0;
 			}
 
-
 		} else { //continue sequence
 
 			bool valid;
-			bool can_iter = p_working_mem[0].iter_next(p_working_mem[1],valid);
+			bool can_iter = p_working_mem[0].iter_next(p_working_mem[1], valid);
 
 			if (!valid) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-				r_error_str=RTR("Iterator became invalid: ")+Variant::get_type_name(p_inputs[0]->get_type());
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				r_error_str = RTR("Iterator became invalid: ") + Variant::get_type_name(p_inputs[0]->get_type());
 				return 0;
 			}
 
 			if (!can_iter)
 				return 1; //nothing to iterate
 
-
-			*p_outputs[0]=p_working_mem[0].iter_get( p_working_mem[1],valid);
+			*p_outputs[0] = p_working_mem[0].iter_get(p_working_mem[1], valid);
 
 			if (!valid) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-				r_error_str=RTR("Iterator became invalid");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				r_error_str = RTR("Iterator became invalid");
 				return 0;
 			}
-
 		}
 
-		return 0|STEP_FLAG_PUSH_STACK_BIT; //go around
+		return 0 | STEP_FLAG_PUSH_STACK_BIT; //go around
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptIterator::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptIterator::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceIterator * instance = memnew(VisualScriptNodeInstanceIterator );
-	instance->node=this;
-	instance->instance=p_instance;
+	VisualScriptNodeInstanceIterator *instance = memnew(VisualScriptNodeInstanceIterator);
+	instance->node = this;
+	instance->instance = p_instance;
 	return instance;
 }
 
 VisualScriptIterator::VisualScriptIterator() {
-
 }
 
-
-
 //////////////////////////////////////////
 ////////////////SEQUENCE/////////////////
 //////////////////////////////////////////
@@ -520,30 +478,30 @@ int VisualScriptSequence::get_output_sequence_port_count() const {
 	return steps;
 }
 
-bool VisualScriptSequence::has_input_sequence_port() const{
+bool VisualScriptSequence::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptSequence::get_input_value_port_count() const{
+int VisualScriptSequence::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptSequence::get_output_value_port_count() const{
+int VisualScriptSequence::get_output_value_port_count() const {
 
 	return 1;
 }
 
 String VisualScriptSequence::get_output_sequence_port_text(int p_port) const {
 
-	return itos(p_port+1);
+	return itos(p_port + 1);
 }
 
-PropertyInfo VisualScriptSequence::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSequence::get_input_value_port_info(int p_idx) const {
 	return PropertyInfo();
 }
-PropertyInfo VisualScriptSequence::get_output_value_port_info(int p_idx) const{
-	return PropertyInfo(Variant::INT,"current");
+PropertyInfo VisualScriptSequence::get_output_value_port_info(int p_idx) const {
+	return PropertyInfo(Variant::INT, "current");
 }
 String VisualScriptSequence::get_caption() const {
 
@@ -557,13 +515,12 @@ String VisualScriptSequence::get_text() const {
 
 void VisualScriptSequence::set_steps(int p_steps) {
 
-	ERR_FAIL_COND(p_steps<1);
-	if (steps==p_steps)
+	ERR_FAIL_COND(p_steps < 1);
+	if (steps == p_steps)
 		return;
 
-	steps=p_steps;
+	steps = p_steps;
 	ports_changed_notify();
-
 }
 
 int VisualScriptSequence::get_steps() const {
@@ -573,16 +530,14 @@ int VisualScriptSequence::get_steps() const {
 
 void VisualScriptSequence::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_steps","steps"),&VisualScriptSequence::set_steps);
-	ClassDB::bind_method(D_METHOD("get_steps"),&VisualScriptSequence::get_steps);
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"steps",PROPERTY_HINT_RANGE,"1,64,1"),"set_steps","get_steps");
+	ClassDB::bind_method(D_METHOD("set_steps", "steps"), &VisualScriptSequence::set_steps);
+	ClassDB::bind_method(D_METHOD("get_steps"), &VisualScriptSequence::get_steps);
 
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "steps", PROPERTY_HINT_RANGE, "1,64,1"), "set_steps", "get_steps");
 }
 
 class VisualScriptNodeInstanceSequence : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptSequence *node;
 	VisualScriptInstance *instance;
 	int steps;
@@ -591,89 +546,83 @@ public:
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		if (p_start_mode==START_MODE_BEGIN_SEQUENCE) {
+		if (p_start_mode == START_MODE_BEGIN_SEQUENCE) {
 
-			p_working_mem[0]=0;
+			p_working_mem[0] = 0;
 		}
 
 		int step = p_working_mem[0];
 
-		*p_outputs[0]=step;
+		*p_outputs[0] = step;
 
-		if (step+1==steps)
+		if (step + 1 == steps)
 			return step;
 		else {
-			p_working_mem[0]=step+1;
-			return step|STEP_FLAG_PUSH_STACK_BIT;
+			p_working_mem[0] = step + 1;
+			return step | STEP_FLAG_PUSH_STACK_BIT;
 		}
-
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptSequence::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptSequence::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceSequence * instance = memnew(VisualScriptNodeInstanceSequence );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->steps=steps;
+	VisualScriptNodeInstanceSequence *instance = memnew(VisualScriptNodeInstanceSequence);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->steps = steps;
 	return instance;
 }
 VisualScriptSequence::VisualScriptSequence() {
 
-	steps=1;
+	steps = 1;
 }
 
-
 //////////////////////////////////////////
 ////////////////EVENT TYPE FILTER///////////
 //////////////////////////////////////////
 
 int VisualScriptSwitch::get_output_sequence_port_count() const {
 
-	return case_values.size()+1;
+	return case_values.size() + 1;
 }
 
-bool VisualScriptSwitch::has_input_sequence_port() const{
+bool VisualScriptSwitch::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptSwitch::get_input_value_port_count() const{
-
+int VisualScriptSwitch::get_input_value_port_count() const {
 
-	return case_values.size()+1;
+	return case_values.size() + 1;
 }
-int VisualScriptSwitch::get_output_value_port_count() const{
+int VisualScriptSwitch::get_output_value_port_count() const {
 
 	return 0;
 }
 
 String VisualScriptSwitch::get_output_sequence_port_text(int p_port) const {
 
-	if (p_port==case_values.size())
+	if (p_port == case_values.size())
 		return "done";
 
 	return String();
 }
 
-PropertyInfo VisualScriptSwitch::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSwitch::get_input_value_port_info(int p_idx) const {
 
-	if (p_idx<case_values.size()) {
-		return PropertyInfo(case_values[p_idx].type," =");
+	if (p_idx < case_values.size()) {
+		return PropertyInfo(case_values[p_idx].type, " =");
 	} else
-		return PropertyInfo(Variant::NIL,"input");
+		return PropertyInfo(Variant::NIL, "input");
 }
 
-PropertyInfo VisualScriptSwitch::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSwitch::get_output_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-
 String VisualScriptSwitch::get_caption() const {
 
 	return "Switch";
@@ -684,47 +633,43 @@ String VisualScriptSwitch::get_text() const {
 	return "'input' is:";
 }
 
-
 class VisualScriptNodeInstanceSwitch : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	int case_count;
 
 	//virtual int get_working_memory_size() const { return 0; }
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return false; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		if (p_start_mode==START_MODE_CONTINUE_SEQUENCE) {
+		if (p_start_mode == START_MODE_CONTINUE_SEQUENCE) {
 			return case_count; //exit
 		}
 
-		for(int i=0;i<case_count;i++) {
+		for (int i = 0; i < case_count; i++) {
 
-			if (*p_inputs[i]==*p_inputs[case_count]) {
-				return i|STEP_FLAG_PUSH_STACK_BIT;
+			if (*p_inputs[i] == *p_inputs[case_count]) {
+				return i | STEP_FLAG_PUSH_STACK_BIT;
 			}
 		}
 
 		return case_count;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptSwitch::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptSwitch::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceSwitch * instance = memnew(VisualScriptNodeInstanceSwitch );
-	instance->instance=p_instance;
-	instance->case_count=case_values.size();
+	VisualScriptNodeInstanceSwitch *instance = memnew(VisualScriptNodeInstanceSwitch);
+	instance->instance = p_instance;
+	instance->case_count = case_values.size();
 	return instance;
 }
 
-bool VisualScriptSwitch::_set(const StringName& p_name, const Variant& p_value) {
+bool VisualScriptSwitch::_set(const StringName &p_name, const Variant &p_value) {
 
-	if (String(p_name)=="case_count") {
+	if (String(p_name) == "case_count") {
 		case_values.resize(p_value);
 		_change_notify();
 		ports_changed_notify();
@@ -733,10 +678,10 @@ bool VisualScriptSwitch::_set(const StringName& p_name, const Variant& p_value)
 
 	if (String(p_name).begins_with("case/")) {
 
-		int idx = String(p_name).get_slice("/",1).to_int();
-		ERR_FAIL_INDEX_V(idx,case_values.size(),false);
+		int idx = String(p_name).get_slice("/", 1).to_int();
+		ERR_FAIL_INDEX_V(idx, case_values.size(), false);
 
-		case_values[idx].type=Variant::Type(int(p_value));
+		case_values[idx].type = Variant::Type(int(p_value));
 		_change_notify();
 		ports_changed_notify();
 
@@ -746,71 +691,63 @@ bool VisualScriptSwitch::_set(const StringName& p_name, const Variant& p_value)
 	return false;
 }
 
-bool VisualScriptSwitch::_get(const StringName& p_name,Variant &r_ret) const {
+bool VisualScriptSwitch::_get(const StringName &p_name, Variant &r_ret) const {
 
-	if (String(p_name)=="case_count") {
-		r_ret=case_values.size();
+	if (String(p_name) == "case_count") {
+		r_ret = case_values.size();
 		return true;
 	}
 
 	if (String(p_name).begins_with("case/")) {
 
-		int idx = String(p_name).get_slice("/",1).to_int();
-		ERR_FAIL_INDEX_V(idx,case_values.size(),false);
+		int idx = String(p_name).get_slice("/", 1).to_int();
+		ERR_FAIL_INDEX_V(idx, case_values.size(), false);
 
-		r_ret=case_values[idx].type;
+		r_ret = case_values[idx].type;
 		return true;
 	}
 
 	return false;
-
 }
-void VisualScriptSwitch::_get_property_list( List<PropertyInfo> *p_list) const {
+void VisualScriptSwitch::_get_property_list(List<PropertyInfo> *p_list) const {
 
-	p_list->push_back(PropertyInfo(Variant::INT,"case_count",PROPERTY_HINT_RANGE,"0,128"));
+	p_list->push_back(PropertyInfo(Variant::INT, "case_count", PROPERTY_HINT_RANGE, "0,128"));
 
-	String argt="Any";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	String argt = "Any";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-	for(int i=0;i<case_values.size();i++) {
-		p_list->push_back(PropertyInfo(Variant::INT,"case/"+itos(i),PROPERTY_HINT_ENUM,argt));
+	for (int i = 0; i < case_values.size(); i++) {
+		p_list->push_back(PropertyInfo(Variant::INT, "case/" + itos(i), PROPERTY_HINT_ENUM, argt));
 	}
 }
 
-
 void VisualScriptSwitch::_bind_methods() {
-
-
 }
 
 VisualScriptSwitch::VisualScriptSwitch() {
-
-
 }
 
 //////////////////////////////////////////
 ////////////////EVENT ACTION FILTER///////////
 //////////////////////////////////////////
 
-
 int VisualScriptInputFilter::get_output_sequence_port_count() const {
 
 	return filters.size();
 }
 
-bool VisualScriptInputFilter::has_input_sequence_port() const{
+bool VisualScriptInputFilter::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptInputFilter::get_input_value_port_count() const{
-
+int VisualScriptInputFilter::get_input_value_port_count() const {
 
 	return 1;
 }
-int VisualScriptInputFilter::get_output_value_port_count() const{
+int VisualScriptInputFilter::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -819,60 +756,60 @@ String VisualScriptInputFilter::get_output_sequence_port_text(int p_port) const
 
 	String text;
 
-	switch(filters[p_port].type) {
+	switch (filters[p_port].type) {
 		case InputEvent::NONE: {
-			text="None";
+			text = "None";
 		} break;
 		case InputEvent::KEY: {
 
 			InputEventKey k = filters[p_port].key;
 
-			if (k.scancode==0 && k.unicode==0) {
-				text="No Key";
+			if (k.scancode == 0 && k.unicode == 0) {
+				text = "No Key";
 			} else {
-				if (k.scancode!=0) {
-					text="KeyCode: "+keycode_get_string(k.scancode);
-				} else if (k.unicode!=0) {
-					text="Uniode: "+String::chr(k.unicode);
+				if (k.scancode != 0) {
+					text = "KeyCode: " + keycode_get_string(k.scancode);
+				} else if (k.unicode != 0) {
+					text = "Uniode: " + String::chr(k.unicode);
 				}
 
 				if (k.pressed)
-					text+=", Pressed";
+					text += ", Pressed";
 				else
-					text+=", Released";
+					text += ", Released";
 
 				if (k.echo)
-					text+=", Echo";
+					text += ", Echo";
 				if (k.mod.alt)
-					text="Alt+"+text;
+					text = "Alt+" + text;
 				if (k.mod.shift)
-					text="Shift+"+text;
+					text = "Shift+" + text;
 				if (k.mod.control)
-					text="Ctrl+"+text;
+					text = "Ctrl+" + text;
 				if (k.mod.meta)
-					text="Meta+"+text;
+					text = "Meta+" + text;
 			}
 
 		} break;
 		case InputEvent::MOUSE_MOTION: {
 			InputEventMouseMotion mm = filters[p_port].mouse_motion;
-			text="Mouse Motion";
+			text = "Mouse Motion";
 
 			String b = "Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight";
 
-			for(int i=0;i<7;i++) {
-				if (mm.button_mask&(1<<i)) {
-					text=b.get_slice(",",i)+"+"+text;
+			for (int i = 0; i < 7; i++) {
+				if (mm.button_mask & (1 << i)) {
+					text = b.get_slice(",", i) + "+" + text;
 				}
 			}
 			if (mm.mod.alt)
-				text="Alt+"+text;
+				text = "Alt+" + text;
 			if (mm.mod.shift)
-				text="Shift+"+text;
+				text = "Shift+" + text;
 			if (mm.mod.control)
-				text="Ctrl+"+text;
+				text = "Ctrl+" + text;
 			if (mm.mod.meta)
-				text="Meta+"+text;
+				text = "Meta+" + text;
 		} break;
 		case InputEvent::MOUSE_BUTTON: {
 
@@ -880,106 +817,99 @@ String VisualScriptInputFilter::get_output_sequence_port_text(int p_port) const
 
 			String b = "Any,Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight";
 
-			text=b.get_slice(",",mb.button_index)+" Mouse Button";
+			text = b.get_slice(",", mb.button_index) + " Mouse Button";
 
 			if (mb.pressed)
-				text+=", Pressed";
+				text += ", Pressed";
 			else
-				text+=", Released";
+				text += ", Released";
 
 			if (mb.doubleclick)
-				text+=", DblClick";
+				text += ", DblClick";
 			if (mb.mod.alt)
-				text="Alt+"+text;
+				text = "Alt+" + text;
 			if (mb.mod.shift)
-				text="Shift+"+text;
+				text = "Shift+" + text;
 			if (mb.mod.control)
-				text="Ctrl+"+text;
+				text = "Ctrl+" + text;
 			if (mb.mod.meta)
-				text="Meta+"+text;
-
+				text = "Meta+" + text;
 
 		} break;
 		case InputEvent::JOYPAD_MOTION: {
 
 			InputEventJoypadMotion jm = filters[p_port].joy_motion;
 
-			text="JoyMotion Axis "+itos(jm.axis>>1);
-			if (jm.axis&1)
-				text+=" > "+rtos(jm.axis_value);
+			text = "JoyMotion Axis " + itos(jm.axis >> 1);
+			if (jm.axis & 1)
+				text += " > " + rtos(jm.axis_value);
 			else
-				text+=" < "+rtos(-jm.axis_value);
+				text += " < " + rtos(-jm.axis_value);
 
 		} break;
 		case InputEvent::JOYPAD_BUTTON: {
 			InputEventJoypadButton jb = filters[p_port].joy_button;
 
-			text="JoyButton "+itos(jb.button_index);
+			text = "JoyButton " + itos(jb.button_index);
 			if (jb.pressed)
-				text+=", Pressed";
+				text += ", Pressed";
 			else
-				text+=", Released";
+				text += ", Released";
 		} break;
 		case InputEvent::SCREEN_TOUCH: {
 			InputEventScreenTouch sd = filters[p_port].screen_touch;
 
-			text="Touch Finger "+itos(sd.index);
+			text = "Touch Finger " + itos(sd.index);
 			if (sd.pressed)
-				text+=", Pressed";
+				text += ", Pressed";
 			else
-				text+=", Released";
+				text += ", Released";
 		} break;
 		case InputEvent::SCREEN_DRAG: {
 			InputEventScreenDrag sd = filters[p_port].screen_drag;
-			text="Drag Finger "+itos(sd.index);
+			text = "Drag Finger " + itos(sd.index);
 		} break;
 		case InputEvent::ACTION: {
 
-
 			List<PropertyInfo> pinfo;
 			GlobalConfig::get_singleton()->get_property_list(&pinfo);
-			int index=1;
+			int index = 1;
 
-			text="No Action";
-			for(List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
-				const PropertyInfo &pi=E->get();
+			text = "No Action";
+			for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
+				const PropertyInfo &pi = E->get();
 
 				if (!pi.name.begins_with("input/"))
 					continue;
 
-
-				if (filters[p_port].action.action==index) {
-					text="Action "+pi.name.substr(pi.name.find("/")+1,pi.name.length());
+				if (filters[p_port].action.action == index) {
+					text = "Action " + pi.name.substr(pi.name.find("/") + 1, pi.name.length());
 					break;
 				}
 				index++;
 			}
 
 			if (filters[p_port].action.pressed)
-				text+=", Pressed";
+				text += ", Pressed";
 			else
-				text+=", Released";
-
+				text += ", Released";
 
 		} break;
 	}
 
-
-
-	return text+" - "+itos(p_port);
+	return text + " - " + itos(p_port);
 }
 
-PropertyInfo VisualScriptInputFilter::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptInputFilter::get_input_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::INPUT_EVENT,"event");
+	return PropertyInfo(Variant::INPUT_EVENT, "event");
 }
 
-PropertyInfo VisualScriptInputFilter::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptInputFilter::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::INPUT_EVENT,"");
+	return PropertyInfo(Variant::INPUT_EVENT, "");
 }
 
-
 String VisualScriptInputFilter::get_caption() const {
 
 	return "InputFilter";
@@ -990,94 +920,90 @@ String VisualScriptInputFilter::get_text() const {
 	return "";
 }
 
+bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_value) {
 
-
-bool VisualScriptInputFilter::_set(const StringName& p_name, const Variant& p_value) {
-
-	if (p_name=="filter_count") {
+	if (p_name == "filter_count") {
 		filters.resize(p_value);
 		_change_notify();
 		ports_changed_notify();
 		return true;
 	}
 
-
 	if (String(p_name).begins_with("filter_")) {
 
-		int idx = String(p_name).replace_first("filters_","").get_slice("/",0).to_int();
-
-		ERR_FAIL_INDEX_V(idx,filters.size(),false);
-
-		String what = String(p_name).get_slice("/",1);
-
-
-		if (what=="type") {
-			filters[idx]=InputEvent();
-			filters[idx].type=InputEvent::Type(int(p_value));
-			if (filters[idx].type==InputEvent::JOYPAD_MOTION) {
-				filters[idx].joy_motion.axis_value=0.5; //for treshold
-			} else if (filters[idx].type==InputEvent::KEY) {
-				filters[idx].key.pressed=true; //put these as true to make it more user friendly
-			} else if (filters[idx].type==InputEvent::MOUSE_BUTTON) {
-				filters[idx].mouse_button.pressed=true;
-			} else if (filters[idx].type==InputEvent::JOYPAD_BUTTON) {
-				filters[idx].joy_button.pressed=true;
-			} else if (filters[idx].type==InputEvent::SCREEN_TOUCH) {
-				filters[idx].screen_touch.pressed=true;
-			} else if (filters[idx].type==InputEvent::ACTION) {
-				filters[idx].action.pressed=true;
+		int idx = String(p_name).replace_first("filters_", "").get_slice("/", 0).to_int();
+
+		ERR_FAIL_INDEX_V(idx, filters.size(), false);
+
+		String what = String(p_name).get_slice("/", 1);
+
+		if (what == "type") {
+			filters[idx] = InputEvent();
+			filters[idx].type = InputEvent::Type(int(p_value));
+			if (filters[idx].type == InputEvent::JOYPAD_MOTION) {
+				filters[idx].joy_motion.axis_value = 0.5; //for treshold
+			} else if (filters[idx].type == InputEvent::KEY) {
+				filters[idx].key.pressed = true; //put these as true to make it more user friendly
+			} else if (filters[idx].type == InputEvent::MOUSE_BUTTON) {
+				filters[idx].mouse_button.pressed = true;
+			} else if (filters[idx].type == InputEvent::JOYPAD_BUTTON) {
+				filters[idx].joy_button.pressed = true;
+			} else if (filters[idx].type == InputEvent::SCREEN_TOUCH) {
+				filters[idx].screen_touch.pressed = true;
+			} else if (filters[idx].type == InputEvent::ACTION) {
+				filters[idx].action.pressed = true;
 			}
 			_change_notify();
 			ports_changed_notify();
 
 			return true;
 		}
-		if (what=="device") {
-			filters[idx].device=p_value;
+		if (what == "device") {
+			filters[idx].device = p_value;
 			ports_changed_notify();
 			return true;
 		}
 
-		switch(filters[idx].type) {
+		switch (filters[idx].type) {
 
 			case InputEvent::KEY: {
 
-				if (what=="scancode") {
+				if (what == "scancode") {
 					String sc = p_value;
-					if (sc==String()) {
-						filters[idx].key.scancode=0;
+					if (sc == String()) {
+						filters[idx].key.scancode = 0;
 					} else {
-						filters[idx].key.scancode=find_keycode(p_value);
+						filters[idx].key.scancode = find_keycode(p_value);
 					}
 
-				} else if (what=="unicode") {
+				} else if (what == "unicode") {
 
 					String uc = p_value;
 
-					if (uc==String()) {
-						filters[idx].key.unicode=0;
+					if (uc == String()) {
+						filters[idx].key.unicode = 0;
 					} else {
-						filters[idx].key.unicode=uc[0];
+						filters[idx].key.unicode = uc[0];
 					}
 
-				} else if (what=="pressed") {
+				} else if (what == "pressed") {
 
-					filters[idx].key.pressed=p_value;
-				} else if (what=="echo") {
+					filters[idx].key.pressed = p_value;
+				} else if (what == "echo") {
 
-					filters[idx].key.echo=p_value;
+					filters[idx].key.echo = p_value;
 
-				} else if (what=="mod_alt") {
-					filters[idx].key.mod.alt=p_value;
+				} else if (what == "mod_alt") {
+					filters[idx].key.mod.alt = p_value;
 
-				} else if (what=="mod_shift") {
-					filters[idx].key.mod.shift=p_value;
+				} else if (what == "mod_shift") {
+					filters[idx].key.mod.shift = p_value;
 
-				} else if (what=="mod_ctrl") {
-					filters[idx].key.mod.control=p_value;
+				} else if (what == "mod_ctrl") {
+					filters[idx].key.mod.control = p_value;
 
-				} else  if (what=="mod_meta") {
-					filters[idx].key.mod.meta=p_value;
+				} else if (what == "mod_meta") {
+					filters[idx].key.mod.meta = p_value;
 				} else {
 					return false;
 				}
@@ -1087,21 +1013,20 @@ bool VisualScriptInputFilter::_set(const StringName& p_name, const Variant& p_va
 			} break;
 			case InputEvent::MOUSE_MOTION: {
 
+				if (what == "button_mask") {
+					filters[idx].mouse_motion.button_mask = p_value;
 
-				if (what=="button_mask") {
-					filters[idx].mouse_motion.button_mask=p_value;
-
-				} else if (what=="mod_alt") {
-					filters[idx].mouse_motion.mod.alt=p_value;
+				} else if (what == "mod_alt") {
+					filters[idx].mouse_motion.mod.alt = p_value;
 
-				} else if (what=="mod_shift") {
-					filters[idx].mouse_motion.mod.shift=p_value;
+				} else if (what == "mod_shift") {
+					filters[idx].mouse_motion.mod.shift = p_value;
 
-				} else if (what=="mod_ctrl") {
-					filters[idx].mouse_motion.mod.control=p_value;
+				} else if (what == "mod_ctrl") {
+					filters[idx].mouse_motion.mod.control = p_value;
 
-				} else  if (what=="mod_meta") {
-					filters[idx].mouse_motion.mod.meta=p_value;
+				} else if (what == "mod_meta") {
+					filters[idx].mouse_motion.mod.meta = p_value;
 				} else {
 					return false;
 				}
@@ -1112,24 +1037,24 @@ bool VisualScriptInputFilter::_set(const StringName& p_name, const Variant& p_va
 			} break;
 			case InputEvent::MOUSE_BUTTON: {
 
-				if (what=="button_index") {
-					filters[idx].mouse_button.button_index=p_value;
-				} else if (what=="pressed") {
-					filters[idx].mouse_button.pressed=p_value;
-				} else if (what=="doubleclicked") {
-					filters[idx].mouse_button.doubleclick=p_value;
+				if (what == "button_index") {
+					filters[idx].mouse_button.button_index = p_value;
+				} else if (what == "pressed") {
+					filters[idx].mouse_button.pressed = p_value;
+				} else if (what == "doubleclicked") {
+					filters[idx].mouse_button.doubleclick = p_value;
 
-				} else if (what=="mod_alt") {
-					filters[idx].mouse_button.mod.alt=p_value;
+				} else if (what == "mod_alt") {
+					filters[idx].mouse_button.mod.alt = p_value;
 
-				} else if (what=="mod_shift") {
-					filters[idx].mouse_button.mod.shift=p_value;
+				} else if (what == "mod_shift") {
+					filters[idx].mouse_button.mod.shift = p_value;
 
-				} else if (what=="mod_ctrl") {
-					filters[idx].mouse_button.mod.control=p_value;
+				} else if (what == "mod_ctrl") {
+					filters[idx].mouse_button.mod.control = p_value;
 
-				} else  if (what=="mod_meta") {
-					filters[idx].mouse_button.mod.meta=p_value;
+				} else if (what == "mod_meta") {
+					filters[idx].mouse_button.mod.meta = p_value;
 				} else {
 					return false;
 				}
@@ -1139,26 +1064,25 @@ bool VisualScriptInputFilter::_set(const StringName& p_name, const Variant& p_va
 			} break;
 			case InputEvent::JOYPAD_MOTION: {
 
-				if (what=="axis") {
-					filters[idx].joy_motion.axis=int(p_value)<<1|filters[idx].joy_motion.axis;
-				} else if (what=="mode") {
-					filters[idx].joy_motion.axis|=int(p_value);
-				} else if (what=="treshold") {
-					filters[idx].joy_motion.axis_value=p_value;
+				if (what == "axis") {
+					filters[idx].joy_motion.axis = int(p_value) << 1 | filters[idx].joy_motion.axis;
+				} else if (what == "mode") {
+					filters[idx].joy_motion.axis |= int(p_value);
+				} else if (what == "treshold") {
+					filters[idx].joy_motion.axis_value = p_value;
 				} else {
 					return false;
 				}
 				ports_changed_notify();
 				return true;
 
-
 			} break;
 			case InputEvent::JOYPAD_BUTTON: {
 
-				if (what=="button_index") {
-					filters[idx].joy_button.button_index=p_value;
-				} else if (what=="pressed") {
-					filters[idx].joy_button.pressed=p_value;
+				if (what == "button_index") {
+					filters[idx].joy_button.button_index = p_value;
+				} else if (what == "pressed") {
+					filters[idx].joy_button.pressed = p_value;
 				} else {
 					return false;
 				}
@@ -1168,10 +1092,10 @@ bool VisualScriptInputFilter::_set(const StringName& p_name, const Variant& p_va
 			} break;
 			case InputEvent::SCREEN_TOUCH: {
 
-				if (what=="finger_index") {
-					filters[idx].screen_touch.index=p_value;
-				} else if (what=="pressed") {
-					filters[idx].screen_touch.pressed=p_value;
+				if (what == "finger_index") {
+					filters[idx].screen_touch.index = p_value;
+				} else if (what == "pressed") {
+					filters[idx].screen_touch.pressed = p_value;
 				} else {
 					return false;
 				}
@@ -1179,8 +1103,8 @@ bool VisualScriptInputFilter::_set(const StringName& p_name, const Variant& p_va
 				return true;
 			} break;
 			case InputEvent::SCREEN_DRAG: {
-				if (what=="finger_index") {
-					filters[idx].screen_drag.index=p_value;
+				if (what == "finger_index") {
+					filters[idx].screen_drag.index = p_value;
 				} else {
 					return false;
 				}
@@ -1189,23 +1113,22 @@ bool VisualScriptInputFilter::_set(const StringName& p_name, const Variant& p_va
 			} break;
 			case InputEvent::ACTION: {
 
-
-				if (what=="action_name") {
+				if (what == "action_name") {
 
 					List<PropertyInfo> pinfo;
 					GlobalConfig::get_singleton()->get_property_list(&pinfo);
-					int index=1;
+					int index = 1;
 
-					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());
-						if (name==String(p_value)) {
+						String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length());
+						if (name == String(p_value)) {
 
-							filters[idx].action.action=index;
+							filters[idx].action.action = index;
 							ports_changed_notify();
 							return true;
 						}
@@ -1213,92 +1136,87 @@ bool VisualScriptInputFilter::_set(const StringName& p_name, const Variant& p_va
 						index++;
 					}
 
-					filters[idx].action.action=0;
+					filters[idx].action.action = 0;
 					ports_changed_notify();
 
 					return false;
 
-				} else if (what=="pressed") {
+				} else if (what == "pressed") {
 
-					filters[idx].action.pressed=p_value;
+					filters[idx].action.pressed = p_value;
 					ports_changed_notify();
 					return true;
 				}
 
-
 			} break;
-
 		}
 	}
 	return false;
 }
 
-bool VisualScriptInputFilter::_get(const StringName& p_name,Variant &r_ret) const{
+bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) const {
 
-	if (p_name=="filter_count") {
-		r_ret=filters.size();
+	if (p_name == "filter_count") {
+		r_ret = filters.size();
 		return true;
 	}
 
-
 	if (String(p_name).begins_with("filter_")) {
 
-		int idx = String(p_name).replace_first("filters_","").get_slice("/",0).to_int();
-
-		ERR_FAIL_INDEX_V(idx,filters.size(),false);
+		int idx = String(p_name).replace_first("filters_", "").get_slice("/", 0).to_int();
 
-		String what = String(p_name).get_slice("/",1);
+		ERR_FAIL_INDEX_V(idx, filters.size(), false);
 
+		String what = String(p_name).get_slice("/", 1);
 
-		if (what=="type") {
-			r_ret=filters[idx].type;
+		if (what == "type") {
+			r_ret = filters[idx].type;
 			return true;
 		}
-		if (what=="device") {
-			r_ret=filters[idx].device;
+		if (what == "device") {
+			r_ret = filters[idx].device;
 			return true;
 		}
 
-		switch(filters[idx].type) {
+		switch (filters[idx].type) {
 
 			case InputEvent::KEY: {
 
-				if (what=="scancode") {
-					if (filters[idx].key.scancode==0)
-						r_ret=String();
+				if (what == "scancode") {
+					if (filters[idx].key.scancode == 0)
+						r_ret = String();
 					else {
 
-						r_ret=keycode_get_string(filters[idx].key.scancode);
+						r_ret = keycode_get_string(filters[idx].key.scancode);
 					}
 
-				} else if (what=="unicode") {
+				} else if (what == "unicode") {
 
-
-					if (filters[idx].key.unicode==0) {
-						r_ret=String();
+					if (filters[idx].key.unicode == 0) {
+						r_ret = String();
 					} else {
-						CharType str[2]={ (CharType)filters[idx].key.unicode, 0};
-						r_ret=String(str);
+						CharType str[2] = { (CharType)filters[idx].key.unicode, 0 };
+						r_ret = String(str);
 					}
 
-				} else if (what=="pressed") {
+				} else if (what == "pressed") {
 
-					r_ret=filters[idx].key.pressed;
-				} else if (what=="echo") {
+					r_ret = filters[idx].key.pressed;
+				} else if (what == "echo") {
 
-					r_ret=filters[idx].key.echo;
+					r_ret = filters[idx].key.echo;
 
-				} else if (what=="mod_alt") {
-					r_ret=filters[idx].key.mod.alt;
+				} else if (what == "mod_alt") {
+					r_ret = filters[idx].key.mod.alt;
 
-				} else if (what=="mod_shift") {
-					r_ret=filters[idx].key.mod.shift;
+				} else if (what == "mod_shift") {
+					r_ret = filters[idx].key.mod.shift;
 
-				} else if (what=="mod_ctrl") {
-					r_ret=filters[idx].key.mod.control;
+				} else if (what == "mod_ctrl") {
+					r_ret = filters[idx].key.mod.control;
 
-				} else  if (what=="mod_meta") {
-					r_ret=filters[idx].key.mod.meta;
+				} else if (what == "mod_meta") {
+					r_ret = filters[idx].key.mod.meta;
 				} else {
 					return false;
 				}
@@ -1307,21 +1225,20 @@ bool VisualScriptInputFilter::_get(const StringName& p_name,Variant &r_ret) cons
 			} break;
 			case InputEvent::MOUSE_MOTION: {
 
+				if (what == "button_mask") {
+					r_ret = filters[idx].mouse_motion.button_mask;
 
-				if (what=="button_mask") {
-					r_ret=filters[idx].mouse_motion.button_mask;
-
-				} else if (what=="mod_alt") {
-					r_ret=filters[idx].mouse_motion.mod.alt;
+				} else if (what == "mod_alt") {
+					r_ret = filters[idx].mouse_motion.mod.alt;
 
-				} else if (what=="mod_shift") {
-					r_ret=filters[idx].mouse_motion.mod.shift;
+				} else if (what == "mod_shift") {
+					r_ret = filters[idx].mouse_motion.mod.shift;
 
-				} else if (what=="mod_ctrl") {
-					r_ret=filters[idx].mouse_motion.mod.control;
+				} else if (what == "mod_ctrl") {
+					r_ret = filters[idx].mouse_motion.mod.control;
 
-				} else  if (what=="mod_meta") {
-					r_ret=filters[idx].mouse_motion.mod.meta;
+				} else if (what == "mod_meta") {
+					r_ret = filters[idx].mouse_motion.mod.meta;
 				} else {
 					return false;
 				}
@@ -1331,24 +1248,24 @@ bool VisualScriptInputFilter::_get(const StringName& p_name,Variant &r_ret) cons
 			} break;
 			case InputEvent::MOUSE_BUTTON: {
 
-				if (what=="button_index") {
-					r_ret=filters[idx].mouse_button.button_index;
-				} else if (what=="pressed") {
-					r_ret=filters[idx].mouse_button.pressed;
-				} else if (what=="doubleclicked") {
-					r_ret=filters[idx].mouse_button.doubleclick;
+				if (what == "button_index") {
+					r_ret = filters[idx].mouse_button.button_index;
+				} else if (what == "pressed") {
+					r_ret = filters[idx].mouse_button.pressed;
+				} else if (what == "doubleclicked") {
+					r_ret = filters[idx].mouse_button.doubleclick;
 
-				} else if (what=="mod_alt") {
-					r_ret=filters[idx].mouse_button.mod.alt;
+				} else if (what == "mod_alt") {
+					r_ret = filters[idx].mouse_button.mod.alt;
 
-				} else if (what=="mod_shift") {
-					r_ret=filters[idx].mouse_button.mod.shift;
+				} else if (what == "mod_shift") {
+					r_ret = filters[idx].mouse_button.mod.shift;
 
-				} else if (what=="mod_ctrl") {
-					r_ret=filters[idx].mouse_button.mod.control;
+				} else if (what == "mod_ctrl") {
+					r_ret = filters[idx].mouse_button.mod.control;
 
-				} else  if (what=="mod_meta") {
-					r_ret=filters[idx].mouse_button.mod.meta;
+				} else if (what == "mod_meta") {
+					r_ret = filters[idx].mouse_button.mod.meta;
 				} else {
 					return false;
 				}
@@ -1357,25 +1274,24 @@ bool VisualScriptInputFilter::_get(const StringName& p_name,Variant &r_ret) cons
 			} break;
 			case InputEvent::JOYPAD_MOTION: {
 
-				if (what=="axis_index") {
-					r_ret=filters[idx].joy_motion.axis>>1;
-				} else if (what=="mode") {
-					r_ret=filters[idx].joy_motion.axis&1;
-				} else if (what=="treshold") {
-					r_ret=filters[idx].joy_motion.axis_value;
+				if (what == "axis_index") {
+					r_ret = filters[idx].joy_motion.axis >> 1;
+				} else if (what == "mode") {
+					r_ret = filters[idx].joy_motion.axis & 1;
+				} else if (what == "treshold") {
+					r_ret = filters[idx].joy_motion.axis_value;
 				} else {
 					return false;
 				}
 				return true;
 
-
 			} break;
 			case InputEvent::JOYPAD_BUTTON: {
 
-				if (what=="button_index") {
-					r_ret=filters[idx].joy_button.button_index;
-				} else if (what=="pressed") {
-					r_ret=filters[idx].joy_button.pressed;
+				if (what == "button_index") {
+					r_ret = filters[idx].joy_button.button_index;
+				} else if (what == "pressed") {
+					r_ret = filters[idx].joy_button.pressed;
 				} else {
 					return false;
 				}
@@ -1384,18 +1300,18 @@ bool VisualScriptInputFilter::_get(const StringName& p_name,Variant &r_ret) cons
 			} break;
 			case InputEvent::SCREEN_TOUCH: {
 
-				if (what=="finger_index") {
-					r_ret=filters[idx].screen_touch.index;
-				} else if (what=="pressed") {
-					r_ret=filters[idx].screen_touch.pressed;
+				if (what == "finger_index") {
+					r_ret = filters[idx].screen_touch.index;
+				} else if (what == "pressed") {
+					r_ret = filters[idx].screen_touch.pressed;
 				} else {
 					return false;
 				}
 				return true;
 			} break;
 			case InputEvent::SCREEN_DRAG: {
-				if (what=="finger_index") {
-					r_ret=filters[idx].screen_drag.index;
+				if (what == "finger_index") {
+					r_ret = filters[idx].screen_drag.index;
 				} else {
 					return false;
 				}
@@ -1403,45 +1319,41 @@ bool VisualScriptInputFilter::_get(const StringName& p_name,Variant &r_ret) cons
 			} break;
 			case InputEvent::ACTION: {
 
-
-				if (what=="action_name") {
+				if (what == "action_name") {
 
 					List<PropertyInfo> pinfo;
 					GlobalConfig::get_singleton()->get_property_list(&pinfo);
-					int index=1;
+					int index = 1;
 
-					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;
 
-
-						if (filters[idx].action.action==index) {
-							r_ret=pi.name.substr(pi.name.find("/")+1,pi.name.length());
+						if (filters[idx].action.action == index) {
+							r_ret = pi.name.substr(pi.name.find("/") + 1, pi.name.length());
 							return true;
 						}
 						index++;
 					}
 
-					r_ret="None"; //no index
+					r_ret = "None"; //no index
 					return false;
 
-				} else if (what=="pressed") {
+				} else if (what == "pressed") {
 
-					r_ret=filters[idx].action.pressed;
+					r_ret = filters[idx].action.pressed;
 					return true;
 				}
 
-
 			} break;
-
 		}
 	}
 	return false;
 }
 
-static const char* event_type_names[InputEvent::TYPE_MAX]={
+static const char *event_type_names[InputEvent::TYPE_MAX] = {
 	"None",
 	"Key",
 	"MouseMotion",
@@ -1453,186 +1365,175 @@ static const char* event_type_names[InputEvent::TYPE_MAX]={
 	"Action"
 };
 
-void VisualScriptInputFilter::_get_property_list( List<PropertyInfo> *p_list) const {
+void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) const {
 
-	p_list->push_back(PropertyInfo(Variant::INT,"filter_count",PROPERTY_HINT_RANGE,"0,64"));
+	p_list->push_back(PropertyInfo(Variant::INT, "filter_count", PROPERTY_HINT_RANGE, "0,64"));
 
 	String et;
-	for(int i=0;i<InputEvent::TYPE_MAX;i++) {
-		if (i>0)
-			et+=",";
+	for (int i = 0; i < InputEvent::TYPE_MAX; i++) {
+		if (i > 0)
+			et += ",";
 
-		et+=event_type_names[i];
+		et += event_type_names[i];
 	}
 
 	String kc;
 	String actions;
 
+	for (int i = 0; i < filters.size(); i++) {
 
-
-	for(int i=0;i<filters.size();i++) {
-
-		String base = "filter_"+itos(i)+"/";
-		p_list->push_back(PropertyInfo(Variant::INT,base+"type",PROPERTY_HINT_ENUM,et));
-		p_list->push_back(PropertyInfo(Variant::INT,base+"device"));
-		switch(filters[i].type) {
+		String base = "filter_" + itos(i) + "/";
+		p_list->push_back(PropertyInfo(Variant::INT, base + "type", PROPERTY_HINT_ENUM, et));
+		p_list->push_back(PropertyInfo(Variant::INT, base + "device"));
+		switch (filters[i].type) {
 
 			case InputEvent::NONE: {
 
 			} break;
 			case InputEvent::KEY: {
-				if (kc==String()) {
+				if (kc == String()) {
 					int kcc = keycode_get_count();
-					kc="None";
-					for(int i=0;i<kcc;i++) {
-						kc+=",";
-						kc+=String(keycode_get_name_by_index(i));
+					kc = "None";
+					for (int i = 0; i < kcc; i++) {
+						kc += ",";
+						kc += String(keycode_get_name_by_index(i));
 					}
 				}
-				p_list->push_back(PropertyInfo(Variant::STRING,base+"scancode",PROPERTY_HINT_ENUM,kc));
-				p_list->push_back(PropertyInfo(Variant::STRING,base+"unicode"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"pressed"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"echo"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_alt"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_shift"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_ctrl"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_meta"));
-
+				p_list->push_back(PropertyInfo(Variant::STRING, base + "scancode", PROPERTY_HINT_ENUM, kc));
+				p_list->push_back(PropertyInfo(Variant::STRING, base + "unicode"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "echo"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_alt"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_shift"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_ctrl"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_meta"));
 
 			} break;
 			case InputEvent::MOUSE_MOTION: {
-				p_list->push_back(PropertyInfo(Variant::INT,base+"button_mask",PROPERTY_HINT_FLAGS,"Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_alt"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_shift"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_ctrl"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_meta"));
+				p_list->push_back(PropertyInfo(Variant::INT, base + "button_mask", PROPERTY_HINT_FLAGS, "Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_alt"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_shift"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_ctrl"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_meta"));
 
 			} break;
 			case InputEvent::MOUSE_BUTTON: {
-				p_list->push_back(PropertyInfo(Variant::INT,base+"button_index",PROPERTY_HINT_ENUM,"Any,Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"pressed"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"doubleclicked"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_alt"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_shift"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_ctrl"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"mod_meta"));
+				p_list->push_back(PropertyInfo(Variant::INT, base + "button_index", PROPERTY_HINT_ENUM, "Any,Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "doubleclicked"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_alt"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_shift"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_ctrl"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_meta"));
 
 			} break;
 			case InputEvent::JOYPAD_MOTION: {
 
-				p_list->push_back(PropertyInfo(Variant::INT,base+"axis_index"));
-				p_list->push_back(PropertyInfo(Variant::INT,base+"mode",PROPERTY_HINT_ENUM,"Min,Max"));
-				p_list->push_back(PropertyInfo(Variant::REAL,base+"treshold",PROPERTY_HINT_RANGE,"0,1,0.01"));
+				p_list->push_back(PropertyInfo(Variant::INT, base + "axis_index"));
+				p_list->push_back(PropertyInfo(Variant::INT, base + "mode", PROPERTY_HINT_ENUM, "Min,Max"));
+				p_list->push_back(PropertyInfo(Variant::REAL, base + "treshold", PROPERTY_HINT_RANGE, "0,1,0.01"));
 			} break;
 			case InputEvent::JOYPAD_BUTTON: {
-				p_list->push_back(PropertyInfo(Variant::INT,base+"button_index"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"pressed"));
+				p_list->push_back(PropertyInfo(Variant::INT, base + "button_index"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed"));
 
 			} break;
 			case InputEvent::SCREEN_TOUCH: {
-				p_list->push_back(PropertyInfo(Variant::INT,base+"finger_index"));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"pressed"));
+				p_list->push_back(PropertyInfo(Variant::INT, base + "finger_index"));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed"));
 
 			} break;
 			case InputEvent::SCREEN_DRAG: {
-				p_list->push_back(PropertyInfo(Variant::INT,base+"finger_index"));
+				p_list->push_back(PropertyInfo(Variant::INT, base + "finger_index"));
 			} break;
 			case InputEvent::ACTION: {
 
+				if (actions == String()) {
 
-
-				if (actions==String()) {
-
-					actions="None";
+					actions = "None";
 
 					List<PropertyInfo> pinfo;
 					GlobalConfig::get_singleton()->get_property_list(&pinfo);
 					Vector<String> al;
 
-					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());
-
+						String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length());
 
 						al.push_back(name);
 					}
 
-					for(int i=0;i<al.size();i++) {
-						actions+=",";
-						actions+=al[i];
+					for (int i = 0; i < al.size(); i++) {
+						actions += ",";
+						actions += al[i];
 					}
 				}
 
-				p_list->push_back(PropertyInfo(Variant::STRING,base+"action_name",PROPERTY_HINT_ENUM,actions));
-				p_list->push_back(PropertyInfo(Variant::BOOL,base+"pressed"));
+				p_list->push_back(PropertyInfo(Variant::STRING, base + "action_name", PROPERTY_HINT_ENUM, actions));
+				p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed"));
 
 			} break;
-
 		}
 	}
 }
 
 class VisualScriptNodeInstanceInputFilter : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	Vector<InputEvent> filters;
 
 	//virtual int get_working_memory_size() const { return 0; }
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return false; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		if (p_inputs[0]->get_type()!=Variant::INPUT_EVENT) {
-			r_error_str="Input value not of type event";
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		if (p_inputs[0]->get_type() != Variant::INPUT_EVENT) {
+			r_error_str = "Input value not of type event";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 			return 0;
 		}
 
 		InputEvent event = *p_inputs[0];
 
-
-		for(int i=0;i<filters.size();i++) {
+		for (int i = 0; i < filters.size(); i++) {
 
 			const InputEvent &ie = filters[i];
-			if (ie.type!=event.type)
+			if (ie.type != event.type)
 				continue;
 
-			bool match=false;
+			bool match = false;
 
-			switch(ie.type) {
+			switch (ie.type) {
 
 				case InputEvent::NONE: {
 
-					match=true;
+					match = true;
 				} break;
 				case InputEvent::KEY: {
 
 					InputEventKey k = ie.key;
 					InputEventKey k2 = event.key;
 
-					if (k.scancode==0 && k.unicode==0 && k2.scancode==0 && k2.unicode==0) {
-						match=true;
+					if (k.scancode == 0 && k.unicode == 0 && k2.scancode == 0 && k2.unicode == 0) {
+						match = true;
 
 					} else {
 
-						if ( (k.scancode!=0 && k.scancode==k2.scancode) || (k.unicode!=0 && k.unicode==k2.unicode)) {
+						if ((k.scancode != 0 && k.scancode == k2.scancode) || (k.unicode != 0 && k.unicode == k2.unicode)) {
 							//key valid
 
 							if (
-								k.pressed==k2.pressed &&
-								k.echo==k2.echo &&
-								k.mod == k2.mod
-									) {
-								match=true;
+									k.pressed == k2.pressed &&
+									k.echo == k2.echo &&
+									k.mod == k2.mod) {
+								match = true;
 							}
 						}
-
 					}
 
 				} break;
@@ -1640,10 +1541,9 @@ public:
 					InputEventMouseMotion mm = ie.mouse_motion;
 					InputEventMouseMotion mm2 = event.mouse_motion;
 
-					if (	mm.button_mask==mm2.button_mask &&
-						mm.mod==mm2.mod
-						) {
-						match=true;
+					if (mm.button_mask == mm2.button_mask &&
+							mm.mod == mm2.mod) {
+						match = true;
 					}
 
 				} break;
@@ -1652,56 +1552,53 @@ public:
 					InputEventMouseButton mb = ie.mouse_button;
 					InputEventMouseButton mb2 = event.mouse_button;
 
-					if (	mb.button_index==mb2.button_index &&
-						mb.pressed==mb2.pressed &&
-						mb.doubleclick==mb2.doubleclick &&
-						mb.mod==mb2.mod) {
-						match=true;
+					if (mb.button_index == mb2.button_index &&
+							mb.pressed == mb2.pressed &&
+							mb.doubleclick == mb2.doubleclick &&
+							mb.mod == mb2.mod) {
+						match = true;
 					}
 
-
 				} break;
 				case InputEvent::JOYPAD_MOTION: {
 
 					InputEventJoypadMotion jm = ie.joy_motion;
 					InputEventJoypadMotion jm2 = event.joy_motion;
 
-					int axis = jm.axis>>1;
+					int axis = jm.axis >> 1;
 
-					if (axis==jm2.axis) {
+					if (axis == jm2.axis) {
 
-						if (jm.axis&1) {
+						if (jm.axis & 1) {
 							//greater
 							if (jm2.axis_value > jm.axis_value) {
-								match=true;
+								match = true;
 							}
 						} else {
 							//less
 							if (jm2.axis_value < -jm.axis_value) {
-								match=true;
+								match = true;
 							}
 						}
 					}
 
-
 				} break;
 				case InputEvent::JOYPAD_BUTTON: {
 					InputEventJoypadButton jb = ie.joy_button;
 					InputEventJoypadButton jb2 = event.joy_button;
 
-					if (	jb.button_index==jb2.button_index &&
-						jb.pressed == jb2.pressed
-							) {
-						match=true;
+					if (jb.button_index == jb2.button_index &&
+							jb.pressed == jb2.pressed) {
+						match = true;
 					}
 				} break;
 				case InputEvent::SCREEN_TOUCH: {
 					InputEventScreenTouch st = ie.screen_touch;
 					InputEventScreenTouch st2 = event.screen_touch;
 
-					if (	st.index==st2.index &&
-						st.pressed==st2.pressed) {
-						match=true;
+					if (st.index == st2.index &&
+							st.pressed == st2.pressed) {
+						match = true;
 					}
 
 				} break;
@@ -1709,8 +1606,8 @@ public:
 					InputEventScreenDrag sd = ie.screen_drag;
 					InputEventScreenDrag sd2 = event.screen_drag;
 
-					if (sd.index==sd2.index) {
-						match=true;
+					if (sd.index == sd2.index) {
+						match = true;
 					}
 				} break;
 				case InputEvent::ACTION: {
@@ -1718,88 +1615,72 @@ public:
 					InputEventAction ia = ie.action;
 					InputEventAction ia2 = event.action;
 
-					if (	ia.action==ia2.action &&
-						ia.pressed==ia2.pressed) {
-						match=true;
+					if (ia.action == ia2.action &&
+							ia.pressed == ia2.pressed) {
+						match = true;
 					}
 				} break;
-
 			}
 
 			*p_outputs[0] = event;
 
 			if (match)
 				return i; //go through match output
-
 		}
 
 		return STEP_NO_ADVANCE_BIT; //none found, don't advance
-
-
 	}
-
-
 };
 
+VisualScriptNodeInstance *VisualScriptInputFilter::instance(VisualScriptInstance *p_instance) {
 
-VisualScriptNodeInstance* VisualScriptInputFilter::instance(VisualScriptInstance* p_instance) {
-
-	VisualScriptNodeInstanceInputFilter * instance = memnew(VisualScriptNodeInstanceInputFilter );
-	instance->instance=p_instance;
-	instance->filters=filters;
+	VisualScriptNodeInstanceInputFilter *instance = memnew(VisualScriptNodeInstanceInputFilter);
+	instance->instance = p_instance;
+	instance->filters = filters;
 	return instance;
 }
 
-
-
-
 VisualScriptInputFilter::VisualScriptInputFilter() {
-
-
 }
 
-
 //////////////////////////////////////////
 ////////////////TYPE CAST///////////
 //////////////////////////////////////////
 
-
 int VisualScriptTypeCast::get_output_sequence_port_count() const {
 
 	return 2;
 }
 
-bool VisualScriptTypeCast::has_input_sequence_port() const{
+bool VisualScriptTypeCast::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptTypeCast::get_input_value_port_count() const{
-
+int VisualScriptTypeCast::get_input_value_port_count() const {
 
 	return 1;
 }
-int VisualScriptTypeCast::get_output_value_port_count() const{
+int VisualScriptTypeCast::get_output_value_port_count() const {
 
 	return 1;
 }
 
 String VisualScriptTypeCast::get_output_sequence_port_text(int p_port) const {
 
-	return p_port==0 ? "yes" : "no";
+	return p_port == 0 ? "yes" : "no";
 }
 
-PropertyInfo VisualScriptTypeCast::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptTypeCast::get_input_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::OBJECT,"instance");
+	return PropertyInfo(Variant::OBJECT, "instance");
 }
 
-PropertyInfo VisualScriptTypeCast::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptTypeCast::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::OBJECT,"");
+	return PropertyInfo(Variant::OBJECT, "");
 }
 
-
 String VisualScriptTypeCast::get_caption() const {
 
 	return "TypeCast";
@@ -1807,47 +1688,44 @@ String VisualScriptTypeCast::get_caption() const {
 
 String VisualScriptTypeCast::get_text() const {
 
-	if (script!=String())
-		return "Is "+script.get_file()+"?";
+	if (script != String())
+		return "Is " + script.get_file() + "?";
 	else
-		return "Is "+base_type+"?";
+		return "Is " + base_type + "?";
 }
 
-void VisualScriptTypeCast::set_base_type(const StringName& p_type) {
+void VisualScriptTypeCast::set_base_type(const StringName &p_type) {
 
-	if (base_type==p_type)
+	if (base_type == p_type)
 		return;
 
-	base_type=p_type;
+	base_type = p_type;
 	_change_notify();
 	ports_changed_notify();
 }
 
-StringName VisualScriptTypeCast::get_base_type() const{
+StringName VisualScriptTypeCast::get_base_type() const {
 
 	return base_type;
 }
 
-void VisualScriptTypeCast::set_base_script(const String& p_path){
+void VisualScriptTypeCast::set_base_script(const String &p_path) {
 
-	if (script==p_path)
+	if (script == p_path)
 		return;
 
-	script=p_path;
+	script = p_path;
 	_change_notify();
 	ports_changed_notify();
-
 }
-String VisualScriptTypeCast::get_base_script() const{
+String VisualScriptTypeCast::get_base_script() const {
 
 	return script;
 }
 
-
 class VisualScriptNodeInstanceTypeCast : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	StringName base_type;
 	String script;
 
@@ -1855,19 +1733,19 @@ public:
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return false; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		Object *obj = *p_inputs[0];
 
-		*p_outputs[0]=Variant();
+		*p_outputs[0] = Variant();
 
 		if (!obj) {
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			r_error_str="Instance is null";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Instance is null";
 			return 0;
 		}
 
-		if (script!=String()) {
+		if (script != String()) {
 
 			Ref<Script> obj_script = obj->get_script();
 			if (!obj_script.is_valid()) {
@@ -1880,90 +1758,79 @@ public:
 			}
 			Ref<Script> cast_script = Ref<Resource>(ResourceCache::get(script));
 			if (!cast_script.is_valid()) {
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-				r_error_str="Script path is not a script: "+script;
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				r_error_str = "Script path is not a script: " + script;
 				return 1;
 			}
 
-			while(obj_script.is_valid()) {
+			while (obj_script.is_valid()) {
 
-				if (cast_script==obj_script) {
-					*p_outputs[0]=*p_inputs[0]; //copy
+				if (cast_script == obj_script) {
+					*p_outputs[0] = *p_inputs[0]; //copy
 					return 0; // it is the script, yey
 				}
 
-				obj_script=obj_script->get_base_script();
+				obj_script = obj_script->get_base_script();
 			}
 
 			return 1; //not found sorry
 		}
 
-		if (ClassDB::is_parent_class(obj->get_class_name(),base_type)) {
-			*p_outputs[0]=*p_inputs[0]; //copy
+		if (ClassDB::is_parent_class(obj->get_class_name(), base_type)) {
+			*p_outputs[0] = *p_inputs[0]; //copy
 			return 0;
 		} else
 			return 1;
-
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptTypeCast::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptTypeCast::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceTypeCast * instance = memnew(VisualScriptNodeInstanceTypeCast );
-	instance->instance=p_instance;
-	instance->base_type=base_type;
-	instance->script=script;
+	VisualScriptNodeInstanceTypeCast *instance = memnew(VisualScriptNodeInstanceTypeCast);
+	instance->instance = p_instance;
+	instance->base_type = base_type;
+	instance->script = script;
 	return instance;
 }
 
-
-
 void VisualScriptTypeCast::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_base_type","type"),&VisualScriptTypeCast::set_base_type);
-	ClassDB::bind_method(D_METHOD("get_base_type"),&VisualScriptTypeCast::get_base_type);
-
-	ClassDB::bind_method(D_METHOD("set_base_script","path"),&VisualScriptTypeCast::set_base_script);
-	ClassDB::bind_method(D_METHOD("get_base_script"),&VisualScriptTypeCast::get_base_script);
+	ClassDB::bind_method(D_METHOD("set_base_type", "type"), &VisualScriptTypeCast::set_base_type);
+	ClassDB::bind_method(D_METHOD("get_base_type"), &VisualScriptTypeCast::get_base_type);
 
+	ClassDB::bind_method(D_METHOD("set_base_script", "path"), &VisualScriptTypeCast::set_base_script);
+	ClassDB::bind_method(D_METHOD("get_base_script"), &VisualScriptTypeCast::get_base_script);
 
 	List<String> script_extensions;
-	for(int i=0;i>ScriptServer::get_language_count();i++) {
+	for (int i = 0; i > ScriptServer::get_language_count(); i++) {
 		ScriptServer::get_language(i)->get_recognized_extensions(&script_extensions);
 	}
 
 	String script_ext_hint;
-	for (List<String>::Element *E=script_extensions.front();E;E=E->next()) {
-		if (script_ext_hint!=String())
-			script_ext_hint+=",";
-		script_ext_hint+="*."+E->get();
+	for (List<String>::Element *E = script_extensions.front(); E; E = E->next()) {
+		if (script_ext_hint != String())
+			script_ext_hint += ",";
+		script_ext_hint += "*." + E->get();
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"function/base_type",PROPERTY_HINT_TYPE_STRING,"Object"),"set_base_type","get_base_type");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"property/base_script",PROPERTY_HINT_FILE,script_ext_hint),"set_base_script","get_base_script");
-
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "function/base_type", PROPERTY_HINT_TYPE_STRING, "Object"), "set_base_type", "get_base_type");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/base_script", PROPERTY_HINT_FILE, script_ext_hint), "set_base_script", "get_base_script");
 }
 
 VisualScriptTypeCast::VisualScriptTypeCast() {
 
-	base_type="Object";
+	base_type = "Object";
 }
 
-
 void register_visual_script_flow_control_nodes() {
 
-	VisualScriptLanguage::singleton->add_register_func("flow_control/return",create_return_node<false>);
-	VisualScriptLanguage::singleton->add_register_func("flow_control/return_with_value",create_return_node<true>);
-	VisualScriptLanguage::singleton->add_register_func("flow_control/condition",create_node_generic<VisualScriptCondition>);
-	VisualScriptLanguage::singleton->add_register_func("flow_control/while",create_node_generic<VisualScriptWhile>);
-	VisualScriptLanguage::singleton->add_register_func("flow_control/iterator",create_node_generic<VisualScriptIterator>);
-	VisualScriptLanguage::singleton->add_register_func("flow_control/sequence",create_node_generic<VisualScriptSequence>);
-	VisualScriptLanguage::singleton->add_register_func("flow_control/switch",create_node_generic<VisualScriptSwitch>);
-	VisualScriptLanguage::singleton->add_register_func("flow_control/input_filter",create_node_generic<VisualScriptInputFilter>);
-	VisualScriptLanguage::singleton->add_register_func("flow_control/type_cast",create_node_generic<VisualScriptTypeCast>);
-
-
-
+	VisualScriptLanguage::singleton->add_register_func("flow_control/return", create_return_node<false>);
+	VisualScriptLanguage::singleton->add_register_func("flow_control/return_with_value", create_return_node<true>);
+	VisualScriptLanguage::singleton->add_register_func("flow_control/condition", create_node_generic<VisualScriptCondition>);
+	VisualScriptLanguage::singleton->add_register_func("flow_control/while", create_node_generic<VisualScriptWhile>);
+	VisualScriptLanguage::singleton->add_register_func("flow_control/iterator", create_node_generic<VisualScriptIterator>);
+	VisualScriptLanguage::singleton->add_register_func("flow_control/sequence", create_node_generic<VisualScriptSequence>);
+	VisualScriptLanguage::singleton->add_register_func("flow_control/switch", create_node_generic<VisualScriptSwitch>);
+	VisualScriptLanguage::singleton->add_register_func("flow_control/input_filter", create_node_generic<VisualScriptInputFilter>);
+	VisualScriptLanguage::singleton->add_register_func("flow_control/type_cast", create_node_generic<VisualScriptTypeCast>);
 }
diff --git a/modules/visual_script/visual_script_flow_control.h b/modules/visual_script/visual_script_flow_control.h
index 8406bb5a5b..1739f67b5b 100644
--- a/modules/visual_script/visual_script_flow_control.h
+++ b/modules/visual_script/visual_script_flow_control.h
@@ -33,27 +33,23 @@
 
 class VisualScriptReturn : public VisualScriptNode {
 
-	GDCLASS(VisualScriptReturn,VisualScriptNode)
-
+	GDCLASS(VisualScriptReturn, VisualScriptNode)
 
 	Variant::Type type;
 	bool with_value;
-protected:
 
+protected:
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -67,35 +63,27 @@ public:
 	void set_enable_return_value(bool p_enable);
 	bool is_return_value_enabled() const;
 
-
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptReturn();
 };
 
-
 class VisualScriptCondition : public VisualScriptNode {
 
-	GDCLASS(VisualScriptCondition,VisualScriptNode)
-
-
+	GDCLASS(VisualScriptCondition, VisualScriptNode)
 
 protected:
-
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -103,35 +91,27 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "flow_control"; }
 
-
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptCondition();
 };
 
-
 class VisualScriptWhile : public VisualScriptNode {
 
-	GDCLASS(VisualScriptWhile,VisualScriptNode)
-
-
+	GDCLASS(VisualScriptWhile, VisualScriptNode)
 
 protected:
-
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -139,36 +119,27 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "flow_control"; }
 
-
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptWhile();
 };
 
-
-
 class VisualScriptIterator : public VisualScriptNode {
 
-	GDCLASS(VisualScriptIterator,VisualScriptNode)
-
-
+	GDCLASS(VisualScriptIterator, VisualScriptNode)
 
 protected:
-
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -176,37 +147,29 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "flow_control"; }
 
-
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptIterator();
 };
 
-
-
 class VisualScriptSequence : public VisualScriptNode {
 
-	GDCLASS(VisualScriptSequence,VisualScriptNode)
-
+	GDCLASS(VisualScriptSequence, VisualScriptNode)
 
 	int steps;
 
 protected:
-
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -217,47 +180,41 @@ public:
 	void set_steps(int p_steps);
 	int get_steps() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptSequence();
 };
 
-
-
-
 class VisualScriptSwitch : public VisualScriptNode {
 
-	GDCLASS(VisualScriptSwitch,VisualScriptNode)
+	GDCLASS(VisualScriptSwitch, VisualScriptNode)
 
 	struct Case {
 		Variant::Type type;
-		Case() { type=Variant::NIL; }
+		Case() { type = Variant::NIL; }
 	};
 
 	Vector<Case> case_values;
 
-friend class VisualScriptNodeInstanceSwitch;
-protected:
+	friend class VisualScriptNodeInstanceSwitch;
 
-	bool _set(const StringName& p_name, const Variant& p_value);
-	bool _get(const StringName& p_name,Variant &r_ret) const;
-	void _get_property_list( List<PropertyInfo> *p_list) const;
+protected:
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
 
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 	virtual bool has_mixed_input_and_sequence_ports() const { return true; }
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -265,40 +222,31 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "flow_control"; }
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
-
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptSwitch();
 };
 
-
-
-
 class VisualScriptInputFilter : public VisualScriptNode {
 
-	GDCLASS(VisualScriptInputFilter,VisualScriptNode)
+	GDCLASS(VisualScriptInputFilter, VisualScriptNode)
 
 	Vector<InputEvent> filters;
 
-
 protected:
-	bool _set(const StringName& p_name, const Variant& p_value);
-	bool _get(const StringName& p_name,Variant &r_ret) const;
-	void _get_property_list( List<PropertyInfo> *p_list) const;
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -306,40 +254,30 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "flow_control"; }
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
-
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptInputFilter();
 };
 
-
-
-
-
 class VisualScriptTypeCast : public VisualScriptNode {
 
-	GDCLASS(VisualScriptTypeCast,VisualScriptNode)
-
+	GDCLASS(VisualScriptTypeCast, VisualScriptNode)
 
 	StringName base_type;
 	String script;
 
 protected:
-
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -347,23 +285,17 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "flow_control"; }
 
-	void set_base_type(const StringName& p_type);
+	void set_base_type(const StringName &p_type);
 	StringName get_base_type() const;
 
-	void set_base_script(const String& p_path);
+	void set_base_script(const String &p_path);
 	String get_base_script() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
-
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptTypeCast();
 };
 
-
-
-
 void register_visual_script_flow_control_nodes();
 
-
-
 #endif // VISUAL_SCRIPT_FLOW_CONTROL_H
diff --git a/modules/visual_script/visual_script_func_nodes.cpp b/modules/visual_script/visual_script_func_nodes.cpp
index c9ed49ee5c..3cd20050ce 100644
--- a/modules/visual_script/visual_script_func_nodes.cpp
+++ b/modules/visual_script/visual_script_func_nodes.cpp
@@ -28,12 +28,12 @@
 /*************************************************************************/
 #include "visual_script_func_nodes.h"
 
-#include "scene/main/scene_main_loop.h"
+#include "global_config.h"
+#include "io/resource_loader.h"
 #include "os/os.h"
 #include "scene/main/node.h"
+#include "scene/main/scene_main_loop.h"
 #include "visual_script_nodes.h"
-#include "io/resource_loader.h"
-#include "global_config.h"
 
 //////////////////////////////////////////
 ////////////////CALL//////////////////////
@@ -41,33 +41,33 @@
 
 int VisualScriptFunctionCall::get_output_sequence_port_count() const {
 
-	if (method_cache.flags&METHOD_FLAG_CONST || call_mode==CALL_MODE_BASIC_TYPE)
+	if (method_cache.flags & METHOD_FLAG_CONST || call_mode == CALL_MODE_BASIC_TYPE)
 		return 0;
 	else
 		return 1;
 }
 
-bool VisualScriptFunctionCall::has_input_sequence_port() const{
+bool VisualScriptFunctionCall::has_input_sequence_port() const {
 
-	if (method_cache.flags&METHOD_FLAG_CONST || call_mode==CALL_MODE_BASIC_TYPE)
+	if (method_cache.flags & METHOD_FLAG_CONST || call_mode == CALL_MODE_BASIC_TYPE)
 		return false;
 	else
 		return true;
 }
 #ifdef TOOLS_ENABLED
 
-static Node* _find_script_node(Node* p_edited_scene,Node* p_current_node,const Ref<Script> &script) {
+static Node *_find_script_node(Node *p_edited_scene, Node *p_current_node, const Ref<Script> &script) {
 
-	if (p_edited_scene!=p_current_node && p_current_node->get_owner()!=p_edited_scene)
+	if (p_edited_scene != p_current_node && p_current_node->get_owner() != p_edited_scene)
 		return NULL;
 
 	Ref<Script> scr = p_current_node->get_script();
 
-	if (scr.is_valid() && scr==script)
+	if (scr.is_valid() && scr == script)
 		return p_current_node;
 
-	for(int i=0;i<p_current_node->get_child_count();i++) {
-		Node *n = _find_script_node(p_edited_scene,p_current_node->get_child(i),script);
+	for (int i = 0; i < p_current_node->get_child_count(); i++) {
+		Node *n = _find_script_node(p_edited_scene, p_current_node->get_child(i), script);
 		if (n)
 			return n;
 	}
@@ -83,7 +83,7 @@ Node *VisualScriptFunctionCall::_get_base_node() const {
 	if (!script.is_valid())
 		return NULL;
 
-	MainLoop * main_loop = OS::get_singleton()->get_main_loop();
+	MainLoop *main_loop = OS::get_singleton()->get_main_loop();
 	if (!main_loop)
 		return NULL;
 
@@ -97,7 +97,7 @@ Node *VisualScriptFunctionCall::_get_base_node() const {
 	if (!edited_scene)
 		return NULL;
 
-	Node* script_node = _find_script_node(edited_scene,edited_scene,script);
+	Node *script_node = _find_script_node(edited_scene, edited_scene, script);
 
 	if (!script_node)
 		return NULL;
@@ -116,55 +116,51 @@ Node *VisualScriptFunctionCall::_get_base_node() const {
 
 StringName VisualScriptFunctionCall::_get_base_type() const {
 
-	if (call_mode==CALL_MODE_SELF && get_visual_script().is_valid())
+	if (call_mode == CALL_MODE_SELF && get_visual_script().is_valid())
 		return get_visual_script()->get_instance_base_type();
-	else if (call_mode==CALL_MODE_NODE_PATH && get_visual_script().is_valid()) {
+	else if (call_mode == CALL_MODE_NODE_PATH && get_visual_script().is_valid()) {
 		Node *path = _get_base_node();
 		if (path)
 			return path->get_class();
-
 	}
 
 	return base_type;
 }
 
+int VisualScriptFunctionCall::get_input_value_port_count() const {
 
-int VisualScriptFunctionCall::get_input_value_port_count() const{
-
-	if (call_mode==CALL_MODE_BASIC_TYPE) {
-
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
 
-		Vector<StringName> names = Variant::get_method_argument_names(basic_type,function);
-		return names.size() + (rpc_call_mode>=RPC_RELIABLE_TO_ID?1:0) + 1;
+		Vector<StringName> names = Variant::get_method_argument_names(basic_type, function);
+		return names.size() + (rpc_call_mode >= RPC_RELIABLE_TO_ID ? 1 : 0) + 1;
 
 	} else {
 
-		MethodBind *mb = ClassDB::get_method(_get_base_type(),function);
+		MethodBind *mb = ClassDB::get_method(_get_base_type(), function);
 		if (mb) {
-			return mb->get_argument_count() + (call_mode==CALL_MODE_INSTANCE?1:0) + (rpc_call_mode>=RPC_RELIABLE_TO_ID?1:0) - use_default_args;
+			return mb->get_argument_count() + (call_mode == CALL_MODE_INSTANCE ? 1 : 0) + (rpc_call_mode >= RPC_RELIABLE_TO_ID ? 1 : 0) - use_default_args;
 		}
 
-		return method_cache.arguments.size() + (call_mode==CALL_MODE_INSTANCE?1:0) + (rpc_call_mode>=RPC_RELIABLE_TO_ID?1:0) - use_default_args;
+		return method_cache.arguments.size() + (call_mode == CALL_MODE_INSTANCE ? 1 : 0) + (rpc_call_mode >= RPC_RELIABLE_TO_ID ? 1 : 0) - use_default_args;
 	}
-
 }
-int VisualScriptFunctionCall::get_output_value_port_count() const{
+int VisualScriptFunctionCall::get_output_value_port_count() const {
 
-	if (call_mode==CALL_MODE_BASIC_TYPE) {
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
 
-		bool returns=false;
-		Variant::get_method_return_type(basic_type,function,&returns);
-		return returns?1:0;
+		bool returns = false;
+		Variant::get_method_return_type(basic_type, function, &returns);
+		return returns ? 1 : 0;
 
 	} else {
 		int ret;
-		MethodBind *mb = ClassDB::get_method(_get_base_type(),function);
+		MethodBind *mb = ClassDB::get_method(_get_base_type(), function);
 		if (mb) {
 			ret = mb->has_return() ? 1 : 0;
 		} else
 			ret = 1; //it is assumed that script always returns something
 
-		if (call_mode==CALL_MODE_INSTANCE) {
+		if (call_mode == CALL_MODE_INSTANCE) {
 			ret++;
 		}
 
@@ -177,46 +173,44 @@ String VisualScriptFunctionCall::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptFunctionCall::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptFunctionCall::get_input_value_port_info(int p_idx) const {
 
-	if (call_mode==CALL_MODE_INSTANCE || call_mode==CALL_MODE_BASIC_TYPE) {
-		if (p_idx==0) {
+	if (call_mode == CALL_MODE_INSTANCE || call_mode == CALL_MODE_BASIC_TYPE) {
+		if (p_idx == 0) {
 			PropertyInfo pi;
-			pi.type=(call_mode==CALL_MODE_INSTANCE?Variant::OBJECT:basic_type);
-			pi.name=(call_mode==CALL_MODE_INSTANCE?String("instance"):Variant::get_type_name(basic_type).to_lower());
+			pi.type = (call_mode == CALL_MODE_INSTANCE ? Variant::OBJECT : basic_type);
+			pi.name = (call_mode == CALL_MODE_INSTANCE ? String("instance") : Variant::get_type_name(basic_type).to_lower());
 			return pi;
 		} else {
 			p_idx--;
 		}
 	}
 
-	if (rpc_call_mode>=RPC_RELIABLE_TO_ID) {
+	if (rpc_call_mode >= RPC_RELIABLE_TO_ID) {
 
-		if (p_idx==0)  {
-			return PropertyInfo(Variant::INT,"peer_id");
+		if (p_idx == 0) {
+			return PropertyInfo(Variant::INT, "peer_id");
 		} else {
 			p_idx--;
 		}
-
 	}
 
 #ifdef DEBUG_METHODS_ENABLED
 
-	if (call_mode==CALL_MODE_BASIC_TYPE) {
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
 
-
-		Vector<StringName> names = Variant::get_method_argument_names(basic_type,function);
-		Vector<Variant::Type> types = Variant::get_method_argument_types(basic_type,function);
-		return PropertyInfo(types[p_idx],names[p_idx]);
+		Vector<StringName> names = Variant::get_method_argument_names(basic_type, function);
+		Vector<Variant::Type> types = Variant::get_method_argument_types(basic_type, function);
+		return PropertyInfo(types[p_idx], names[p_idx]);
 
 	} else {
 
-		MethodBind *mb = ClassDB::get_method(_get_base_type(),function);
+		MethodBind *mb = ClassDB::get_method(_get_base_type(), function);
 		if (mb) {
 			return mb->get_argument_info(p_idx);
 		}
 
-		if (p_idx>=0 && p_idx < method_cache.arguments.size()) {
+		if (p_idx >= 0 && p_idx < method_cache.arguments.size()) {
 			return method_cache.arguments[p_idx];
 		}
 
@@ -225,23 +219,20 @@ PropertyInfo VisualScriptFunctionCall::get_input_value_port_info(int p_idx) cons
 #else
 	return PropertyInfo();
 #endif
-
 }
 
-PropertyInfo VisualScriptFunctionCall::get_output_value_port_info(int p_idx) const{
-
+PropertyInfo VisualScriptFunctionCall::get_output_value_port_info(int p_idx) const {
 
 #ifdef DEBUG_METHODS_ENABLED
 
-	if (call_mode==CALL_MODE_BASIC_TYPE) {
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
 
-
-		return PropertyInfo(Variant::get_method_return_type(basic_type,function),"");
+		return PropertyInfo(Variant::get_method_return_type(basic_type, function), "");
 	} else {
 
-		if (call_mode==CALL_MODE_INSTANCE) {
-			if (p_idx==0) {
-				return PropertyInfo(Variant::OBJECT,"pass");
+		if (call_mode == CALL_MODE_INSTANCE) {
+			if (p_idx == 0) {
+				return PropertyInfo(Variant::OBJECT, "pass");
 			} else {
 				p_idx--;
 			}
@@ -259,24 +250,21 @@ PropertyInfo VisualScriptFunctionCall::get_output_value_port_info(int p_idx) con
 
 		//}
 
-		if (call_mode==CALL_MODE_INSTANCE) {
-			ret.name="return";
+		if (call_mode == CALL_MODE_INSTANCE) {
+			ret.name = "return";
 		} else {
-			ret.name="";
+			ret.name = "";
 		}
 		return ret;
-
-
 	}
 #else
 	return PropertyInfo();
 #endif
 }
 
-
 String VisualScriptFunctionCall::get_caption() const {
 
-	static const char*cname[5]= {
+	static const char *cname[5] = {
 		"CallSelf",
 		"CallNode",
 		"CallInstance",
@@ -287,7 +275,7 @@ String VisualScriptFunctionCall::get_caption() const {
 	String caption = cname[call_mode];
 
 	if (rpc_call_mode) {
-		caption+=" (RPC)";
+		caption += " (RPC)";
 	}
 
 	return caption;
@@ -295,57 +283,54 @@ String VisualScriptFunctionCall::get_caption() const {
 
 String VisualScriptFunctionCall::get_text() const {
 
-	if (call_mode==CALL_MODE_SELF)
-		return "  "+String(function)+"()";
-	if (call_mode==CALL_MODE_SINGLETON)
-		return String(singleton)+":"+String(function)+"()";
-	else if (call_mode==CALL_MODE_BASIC_TYPE)
-		return Variant::get_type_name(basic_type)+"."+String(function)+"()";
-	else if (call_mode==CALL_MODE_NODE_PATH)
-		return " ["+String(base_path.simplified())+"]."+String(function)+"()";
+	if (call_mode == CALL_MODE_SELF)
+		return "  " + String(function) + "()";
+	if (call_mode == CALL_MODE_SINGLETON)
+		return String(singleton) + ":" + String(function) + "()";
+	else if (call_mode == CALL_MODE_BASIC_TYPE)
+		return Variant::get_type_name(basic_type) + "." + String(function) + "()";
+	else if (call_mode == CALL_MODE_NODE_PATH)
+		return " [" + String(base_path.simplified()) + "]." + String(function) + "()";
 	else
-		return "  "+base_type+"."+String(function)+"()";
-
+		return "  " + base_type + "." + String(function) + "()";
 }
 
-
 void VisualScriptFunctionCall::set_basic_type(Variant::Type p_type) {
 
-	if (basic_type==p_type)
+	if (basic_type == p_type)
 		return;
-	basic_type=p_type;
-
+	basic_type = p_type;
 
 	_change_notify();
 	ports_changed_notify();
 }
 
-Variant::Type VisualScriptFunctionCall::get_basic_type() const{
+Variant::Type VisualScriptFunctionCall::get_basic_type() const {
 
 	return basic_type;
 }
 
-void VisualScriptFunctionCall::set_base_type(const StringName& p_type) {
+void VisualScriptFunctionCall::set_base_type(const StringName &p_type) {
 
-	if (base_type==p_type)
+	if (base_type == p_type)
 		return;
 
-	base_type=p_type;
+	base_type = p_type;
 	_change_notify();
 	ports_changed_notify();
 }
 
-StringName VisualScriptFunctionCall::get_base_type() const{
+StringName VisualScriptFunctionCall::get_base_type() const {
 
 	return base_type;
 }
 
-void VisualScriptFunctionCall::set_base_script(const String& p_path) {
+void VisualScriptFunctionCall::set_base_script(const String &p_path) {
 
-	if (base_script==p_path)
+	if (base_script == p_path)
 		return;
 
-	base_script=p_path;
+	base_script = p_path;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -355,15 +340,15 @@ String VisualScriptFunctionCall::get_base_script() const {
 	return base_script;
 }
 
-void VisualScriptFunctionCall::set_singleton(const StringName& p_path) {
+void VisualScriptFunctionCall::set_singleton(const StringName &p_path) {
 
-	if (singleton==p_path)
+	if (singleton == p_path)
 		return;
 
-	singleton=p_path;
+	singleton = p_path;
 	Object *obj = GlobalConfig::get_singleton()->get_singleton_object(singleton);
 	if (obj) {
-		base_type=obj->get_class();
+		base_type = obj->get_class();
 	}
 
 	_change_notify();
@@ -375,40 +360,38 @@ StringName VisualScriptFunctionCall::get_singleton() const {
 	return singleton;
 }
 
-
-
 void VisualScriptFunctionCall::_update_method_cache() {
 	StringName type;
 	Ref<Script> script;
 
-	if (call_mode==CALL_MODE_NODE_PATH) {
+	if (call_mode == CALL_MODE_NODE_PATH) {
 
-		Node* node=_get_base_node();
+		Node *node = _get_base_node();
 		if (node) {
-			type=node->get_class();
-			base_type=type; //cache, too
+			type = node->get_class();
+			base_type = type; //cache, too
 			script = node->get_script();
 		}
-	} else if (call_mode==CALL_MODE_SELF) {
+	} else if (call_mode == CALL_MODE_SELF) {
 
 		if (get_visual_script().is_valid()) {
-			type=get_visual_script()->get_instance_base_type();
-			base_type=type; //cache, too
-			script=get_visual_script();
+			type = get_visual_script()->get_instance_base_type();
+			base_type = type; //cache, too
+			script = get_visual_script();
 		}
 
-	} else if (call_mode==CALL_MODE_SINGLETON) {
+	} else if (call_mode == CALL_MODE_SINGLETON) {
 
 		Object *obj = GlobalConfig::get_singleton()->get_singleton_object(singleton);
 		if (obj) {
-			type=obj->get_class();
-			script=obj->get_script();
+			type = obj->get_class();
+			script = obj->get_script();
 		}
 
-	} else if (call_mode==CALL_MODE_INSTANCE) {
+	} else if (call_mode == CALL_MODE_INSTANCE) {
 
-		type=base_type;
-		if (base_script!=String()) {
+		type = base_type;
+		if (base_script != String()) {
 
 			if (!ResourceCache::has(base_script) && ScriptServer::edit_request_func) {
 
@@ -417,20 +400,19 @@ void VisualScriptFunctionCall::_update_method_cache() {
 
 			if (ResourceCache::has(base_script)) {
 
-				script = Ref<Resource>( ResourceCache::get(base_script) );
+				script = Ref<Resource>(ResourceCache::get(base_script));
 			} else {
 				return;
 			}
 		}
 	}
 
-
 	//print_line("BASE: "+String(type)+" FUNC: "+String(function));
-	MethodBind *mb = ClassDB::get_method(type,function);
+	MethodBind *mb = ClassDB::get_method(type, function);
 	if (mb) {
-		use_default_args=mb->get_default_argument_count();
+		use_default_args = mb->get_default_argument_count();
 		method_cache = MethodInfo();
-		for(int i=0;i<mb->get_argument_count();i++) {
+		for (int i = 0; i < mb->get_argument_count(); i++) {
 #ifdef DEBUG_METHODS_ENABLED
 			method_cache.arguments.push_back(mb->get_argument_info(i));
 #else
@@ -439,7 +421,7 @@ void VisualScriptFunctionCall::_update_method_cache() {
 		}
 
 		if (mb->is_const()) {
-			method_cache.flags|=METHOD_FLAG_CONST;
+			method_cache.flags |= METHOD_FLAG_CONST;
 		}
 
 #ifdef DEBUG_METHODS_ENABLED
@@ -449,50 +431,47 @@ void VisualScriptFunctionCall::_update_method_cache() {
 
 		if (mb->is_vararg()) {
 			//for vararg just give it 10 arguments (should be enough for most use cases)
-			for(int i=0;i<10;i++) {
-				method_cache.arguments.push_back(PropertyInfo(Variant::NIL,"arg"+itos(i)));
+			for (int i = 0; i < 10; i++) {
+				method_cache.arguments.push_back(PropertyInfo(Variant::NIL, "arg" + itos(i)));
 				use_default_args++;
 			}
 		}
 	} else if (script.is_valid() && script->has_method(function)) {
 
 		method_cache = script->get_method_info(function);
-		use_default_args=method_cache.default_arguments.size();
+		use_default_args = method_cache.default_arguments.size();
 	}
 }
 
-void VisualScriptFunctionCall::set_function(const StringName& p_type){
+void VisualScriptFunctionCall::set_function(const StringName &p_type) {
 
-	if (function==p_type)
+	if (function == p_type)
 		return;
 
-	function=p_type;
+	function = p_type;
 
-	if (call_mode==CALL_MODE_BASIC_TYPE) {
-		use_default_args = Variant::get_method_default_arguments(basic_type,function).size();
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
+		use_default_args = Variant::get_method_default_arguments(basic_type, function).size();
 	} else {
 		//update all caches
 
 		_update_method_cache();
-
 	}
 
-
 	_change_notify();
 	ports_changed_notify();
 }
 StringName VisualScriptFunctionCall::get_function() const {
 
-
 	return function;
 }
 
-void VisualScriptFunctionCall::set_base_path(const NodePath& p_type) {
+void VisualScriptFunctionCall::set_base_path(const NodePath &p_type) {
 
-	if (base_path==p_type)
+	if (base_path == p_type)
 		return;
 
-	base_path=p_type;	
+	base_path = p_type;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -502,16 +481,14 @@ NodePath VisualScriptFunctionCall::get_base_path() const {
 	return base_path;
 }
 
-
 void VisualScriptFunctionCall::set_call_mode(CallMode p_mode) {
 
-	if (call_mode==p_mode)
+	if (call_mode == p_mode)
 		return;
 
-	call_mode=p_mode;
+	call_mode = p_mode;
 	_change_notify();
 	ports_changed_notify();
-
 }
 VisualScriptFunctionCall::CallMode VisualScriptFunctionCall::get_call_mode() const {
 
@@ -520,39 +497,35 @@ VisualScriptFunctionCall::CallMode VisualScriptFunctionCall::get_call_mode() con
 
 void VisualScriptFunctionCall::set_use_default_args(int p_amount) {
 
-	if (use_default_args==p_amount)
+	if (use_default_args == p_amount)
 		return;
 
-	use_default_args=p_amount;
+	use_default_args = p_amount;
 	ports_changed_notify();
-
-
 }
 
 void VisualScriptFunctionCall::set_rpc_call_mode(VisualScriptFunctionCall::RPCCallMode p_mode) {
 
-	if (rpc_call_mode==p_mode)
+	if (rpc_call_mode == p_mode)
 		return;
-	rpc_call_mode=p_mode;
+	rpc_call_mode = p_mode;
 	ports_changed_notify();
 	_change_notify();
 }
 
-VisualScriptFunctionCall::RPCCallMode VisualScriptFunctionCall::get_rpc_call_mode() const{
+VisualScriptFunctionCall::RPCCallMode VisualScriptFunctionCall::get_rpc_call_mode() const {
 
 	return rpc_call_mode;
 }
 
-
-int VisualScriptFunctionCall::get_use_default_args() const{
+int VisualScriptFunctionCall::get_use_default_args() const {
 
 	return use_default_args;
 }
 
-
 void VisualScriptFunctionCall::set_validate(bool p_amount) {
 
-	validate=p_amount;
+	validate = p_amount;
 }
 
 bool VisualScriptFunctionCall::get_validate() const {
@@ -560,11 +533,9 @@ bool VisualScriptFunctionCall::get_validate() const {
 	return validate;
 }
 
-
-void VisualScriptFunctionCall::_set_argument_cache(const Dictionary& p_cache) {
+void VisualScriptFunctionCall::_set_argument_cache(const Dictionary &p_cache) {
 	//so everything works in case all else fails
-	method_cache=MethodInfo::from_dict(p_cache);
-
+	method_cache = MethodInfo::from_dict(p_cache);
 }
 
 Dictionary VisualScriptFunctionCall::_get_argument_cache() const {
@@ -572,84 +543,82 @@ Dictionary VisualScriptFunctionCall::_get_argument_cache() const {
 	return method_cache;
 }
 
-void VisualScriptFunctionCall::_validate_property(PropertyInfo& property) const {
+void VisualScriptFunctionCall::_validate_property(PropertyInfo &property) const {
 
-	if (property.name=="function/base_type") {
-		if (call_mode!=CALL_MODE_INSTANCE) {
-			property.usage=PROPERTY_USAGE_NOEDITOR;
+	if (property.name == "function/base_type") {
+		if (call_mode != CALL_MODE_INSTANCE) {
+			property.usage = PROPERTY_USAGE_NOEDITOR;
 		}
 	}
 
-	if (property.name=="function/base_script") {
-		if (call_mode!=CALL_MODE_INSTANCE) {
-			property.usage=0;
+	if (property.name == "function/base_script") {
+		if (call_mode != CALL_MODE_INSTANCE) {
+			property.usage = 0;
 		}
 	}
 
-	if (property.name=="function/basic_type") {
-		if (call_mode!=CALL_MODE_BASIC_TYPE) {
-			property.usage=0;
+	if (property.name == "function/basic_type") {
+		if (call_mode != CALL_MODE_BASIC_TYPE) {
+			property.usage = 0;
 		}
 	}
 
-	if (property.name=="function/singleton") {
-		if (call_mode!=CALL_MODE_SINGLETON) {
-			property.usage=0;
+	if (property.name == "function/singleton") {
+		if (call_mode != CALL_MODE_SINGLETON) {
+			property.usage = 0;
 		} else {
 			List<GlobalConfig::Singleton> names;
 			GlobalConfig::get_singleton()->get_singletons(&names);
-			property.hint=PROPERTY_HINT_ENUM;
+			property.hint = PROPERTY_HINT_ENUM;
 			String sl;
-			for (List<GlobalConfig::Singleton>::Element *E=names.front();E;E=E->next()) {
-				if (sl!=String())
-					sl+=",";
-				sl+=E->get().name;
+			for (List<GlobalConfig::Singleton>::Element *E = names.front(); E; E = E->next()) {
+				if (sl != String())
+					sl += ",";
+				sl += E->get().name;
 			}
-			property.hint_string=sl;
-
+			property.hint_string = sl;
 		}
 	}
 
-	if (property.name=="function/node_path") {
-		if (call_mode!=CALL_MODE_NODE_PATH) {
-			property.usage=0;
+	if (property.name == "function/node_path") {
+		if (call_mode != CALL_MODE_NODE_PATH) {
+			property.usage = 0;
 		} else {
 
 			Node *bnode = _get_base_node();
 			if (bnode) {
-				property.hint_string=bnode->get_path(); //convert to loong string
+				property.hint_string = bnode->get_path(); //convert to loong string
 			} else {
-
 			}
 		}
 	}
 
-	if (property.name=="function/function") {
+	if (property.name == "function/function") {
 
-		if (call_mode==CALL_MODE_BASIC_TYPE) {
+		if (call_mode == CALL_MODE_BASIC_TYPE) {
 
-			property.hint=PROPERTY_HINT_METHOD_OF_VARIANT_TYPE;
-			property.hint_string=Variant::get_type_name(basic_type);
+			property.hint = PROPERTY_HINT_METHOD_OF_VARIANT_TYPE;
+			property.hint_string = Variant::get_type_name(basic_type);
 
-		} else if (call_mode==CALL_MODE_SELF && get_visual_script().is_valid()) {
-			property.hint=PROPERTY_HINT_METHOD_OF_SCRIPT;
-			property.hint_string=itos(get_visual_script()->get_instance_ID());
-		} else if (call_mode==CALL_MODE_SINGLETON) {
+		} else if (call_mode == CALL_MODE_SELF && get_visual_script().is_valid()) {
+			property.hint = PROPERTY_HINT_METHOD_OF_SCRIPT;
+			property.hint_string = itos(get_visual_script()->get_instance_ID());
+		} else if (call_mode == CALL_MODE_SINGLETON) {
 
 			Object *obj = GlobalConfig::get_singleton()->get_singleton_object(singleton);
 			if (obj) {
-				property.hint=PROPERTY_HINT_METHOD_OF_INSTANCE;
-				property.hint_string=itos(obj->get_instance_ID());
+				property.hint = PROPERTY_HINT_METHOD_OF_INSTANCE;
+				property.hint_string = itos(obj->get_instance_ID());
 			} else {
 
-				property.hint=PROPERTY_HINT_METHOD_OF_BASE_TYPE;
-				property.hint_string=base_type;//should be cached
+				property.hint = PROPERTY_HINT_METHOD_OF_BASE_TYPE;
+				property.hint_string = base_type; //should be cached
 			}
-		} else if (call_mode==CALL_MODE_INSTANCE) {
-			property.hint=PROPERTY_HINT_METHOD_OF_BASE_TYPE;
-			property.hint_string=base_type;
+		} else if (call_mode == CALL_MODE_INSTANCE) {
+			property.hint = PROPERTY_HINT_METHOD_OF_BASE_TYPE;
+			property.hint_string = base_type;
 
-			if (base_script!=String()) {
+			if (base_script != String()) {
 				if (!ResourceCache::has(base_script) && ScriptServer::edit_request_func) {
 
 					ScriptServer::edit_request_func(base_script); //make sure it's loaded
@@ -657,143 +626,134 @@ void VisualScriptFunctionCall::_validate_property(PropertyInfo& property) const
 
 				if (ResourceCache::has(base_script)) {
 
-					Ref<Script> script = Ref<Resource>( ResourceCache::get(base_script) );
+					Ref<Script> script = Ref<Resource>(ResourceCache::get(base_script));
 					if (script.is_valid()) {
 
-						property.hint=PROPERTY_HINT_METHOD_OF_SCRIPT;
-						property.hint_string=itos(script->get_instance_ID());
+						property.hint = PROPERTY_HINT_METHOD_OF_SCRIPT;
+						property.hint_string = itos(script->get_instance_ID());
 					}
 				}
 			}
 
-		} else if (call_mode==CALL_MODE_NODE_PATH) {
+		} else if (call_mode == CALL_MODE_NODE_PATH) {
 			Node *node = _get_base_node();
 			if (node) {
-				property.hint=PROPERTY_HINT_METHOD_OF_INSTANCE;
-				property.hint_string=itos(node->get_instance_ID());
+				property.hint = PROPERTY_HINT_METHOD_OF_INSTANCE;
+				property.hint_string = itos(node->get_instance_ID());
 			} else {
-				property.hint=PROPERTY_HINT_METHOD_OF_BASE_TYPE;
-				property.hint_string=get_base_type();
+				property.hint = PROPERTY_HINT_METHOD_OF_BASE_TYPE;
+				property.hint_string = get_base_type();
 			}
-
 		}
-
 	}
 
-	if (property.name=="function/use_default_args") {
+	if (property.name == "function/use_default_args") {
 
-		property.hint=PROPERTY_HINT_RANGE;
+		property.hint = PROPERTY_HINT_RANGE;
 
-		int mc=0;
+		int mc = 0;
 
-		if (call_mode==CALL_MODE_BASIC_TYPE) {
+		if (call_mode == CALL_MODE_BASIC_TYPE) {
 
-			mc = Variant::get_method_default_arguments(basic_type,function).size();
+			mc = Variant::get_method_default_arguments(basic_type, function).size();
 		} else {
-			MethodBind *mb = ClassDB::get_method(_get_base_type(),function);
+			MethodBind *mb = ClassDB::get_method(_get_base_type(), function);
 			if (mb) {
 
-				mc=mb->get_default_argument_count();
+				mc = mb->get_default_argument_count();
 			}
 		}
 
-		if (mc==0) {
-			property.usage=0; //do not show
+		if (mc == 0) {
+			property.usage = 0; //do not show
 		} else {
 
-			property.hint_string="0,"+itos(mc)+",1";
+			property.hint_string = "0," + itos(mc) + ",1";
 		}
 	}
 
-	if (property.name=="rpc/call_mode") {
-		if (call_mode==CALL_MODE_BASIC_TYPE) {
-			property.usage=0;
+	if (property.name == "rpc/call_mode") {
+		if (call_mode == CALL_MODE_BASIC_TYPE) {
+			property.usage = 0;
 		}
 	}
-
 }
 
-
 void VisualScriptFunctionCall::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_base_type","base_type"),&VisualScriptFunctionCall::set_base_type);
-	ClassDB::bind_method(D_METHOD("get_base_type"),&VisualScriptFunctionCall::get_base_type);
+	ClassDB::bind_method(D_METHOD("set_base_type", "base_type"), &VisualScriptFunctionCall::set_base_type);
+	ClassDB::bind_method(D_METHOD("get_base_type"), &VisualScriptFunctionCall::get_base_type);
 
-	ClassDB::bind_method(D_METHOD("set_base_script","base_script"),&VisualScriptFunctionCall::set_base_script);
-	ClassDB::bind_method(D_METHOD("get_base_script"),&VisualScriptFunctionCall::get_base_script);
+	ClassDB::bind_method(D_METHOD("set_base_script", "base_script"), &VisualScriptFunctionCall::set_base_script);
+	ClassDB::bind_method(D_METHOD("get_base_script"), &VisualScriptFunctionCall::get_base_script);
 
-	ClassDB::bind_method(D_METHOD("set_basic_type","basic_type"),&VisualScriptFunctionCall::set_basic_type);
-	ClassDB::bind_method(D_METHOD("get_basic_type"),&VisualScriptFunctionCall::get_basic_type);
+	ClassDB::bind_method(D_METHOD("set_basic_type", "basic_type"), &VisualScriptFunctionCall::set_basic_type);
+	ClassDB::bind_method(D_METHOD("get_basic_type"), &VisualScriptFunctionCall::get_basic_type);
 
-	ClassDB::bind_method(D_METHOD("set_singleton","singleton"),&VisualScriptFunctionCall::set_singleton);
-	ClassDB::bind_method(D_METHOD("get_singleton"),&VisualScriptFunctionCall::get_singleton);
+	ClassDB::bind_method(D_METHOD("set_singleton", "singleton"), &VisualScriptFunctionCall::set_singleton);
+	ClassDB::bind_method(D_METHOD("get_singleton"), &VisualScriptFunctionCall::get_singleton);
 
-	ClassDB::bind_method(D_METHOD("set_function","function"),&VisualScriptFunctionCall::set_function);
-	ClassDB::bind_method(D_METHOD("get_function"),&VisualScriptFunctionCall::get_function);
+	ClassDB::bind_method(D_METHOD("set_function", "function"), &VisualScriptFunctionCall::set_function);
+	ClassDB::bind_method(D_METHOD("get_function"), &VisualScriptFunctionCall::get_function);
 
-	ClassDB::bind_method(D_METHOD("set_call_mode","mode"),&VisualScriptFunctionCall::set_call_mode);
-	ClassDB::bind_method(D_METHOD("get_call_mode"),&VisualScriptFunctionCall::get_call_mode);
+	ClassDB::bind_method(D_METHOD("set_call_mode", "mode"), &VisualScriptFunctionCall::set_call_mode);
+	ClassDB::bind_method(D_METHOD("get_call_mode"), &VisualScriptFunctionCall::get_call_mode);
 
-	ClassDB::bind_method(D_METHOD("set_base_path","base_path"),&VisualScriptFunctionCall::set_base_path);
-	ClassDB::bind_method(D_METHOD("get_base_path"),&VisualScriptFunctionCall::get_base_path);
+	ClassDB::bind_method(D_METHOD("set_base_path", "base_path"), &VisualScriptFunctionCall::set_base_path);
+	ClassDB::bind_method(D_METHOD("get_base_path"), &VisualScriptFunctionCall::get_base_path);
 
-	ClassDB::bind_method(D_METHOD("set_use_default_args","amount"),&VisualScriptFunctionCall::set_use_default_args);
-	ClassDB::bind_method(D_METHOD("get_use_default_args"),&VisualScriptFunctionCall::get_use_default_args);
+	ClassDB::bind_method(D_METHOD("set_use_default_args", "amount"), &VisualScriptFunctionCall::set_use_default_args);
+	ClassDB::bind_method(D_METHOD("get_use_default_args"), &VisualScriptFunctionCall::get_use_default_args);
 
-	ClassDB::bind_method(D_METHOD("_set_argument_cache","argument_cache"),&VisualScriptFunctionCall::_set_argument_cache);
-	ClassDB::bind_method(D_METHOD("_get_argument_cache"),&VisualScriptFunctionCall::_get_argument_cache);
+	ClassDB::bind_method(D_METHOD("_set_argument_cache", "argument_cache"), &VisualScriptFunctionCall::_set_argument_cache);
+	ClassDB::bind_method(D_METHOD("_get_argument_cache"), &VisualScriptFunctionCall::_get_argument_cache);
 
-	ClassDB::bind_method(D_METHOD("set_rpc_call_mode","mode"),&VisualScriptFunctionCall::set_rpc_call_mode);
-	ClassDB::bind_method(D_METHOD("get_rpc_call_mode"),&VisualScriptFunctionCall::get_rpc_call_mode);
+	ClassDB::bind_method(D_METHOD("set_rpc_call_mode", "mode"), &VisualScriptFunctionCall::set_rpc_call_mode);
+	ClassDB::bind_method(D_METHOD("get_rpc_call_mode"), &VisualScriptFunctionCall::get_rpc_call_mode);
 
-	ClassDB::bind_method(D_METHOD("set_validate","enable"),&VisualScriptFunctionCall::set_validate);
-	ClassDB::bind_method(D_METHOD("get_validate"),&VisualScriptFunctionCall::get_validate);
+	ClassDB::bind_method(D_METHOD("set_validate", "enable"), &VisualScriptFunctionCall::set_validate);
+	ClassDB::bind_method(D_METHOD("get_validate"), &VisualScriptFunctionCall::get_validate);
 
 	String bt;
-	for(int i=0;i<Variant::VARIANT_MAX;i++) {
-		if (i>0)
-			bt+=",";
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		if (i > 0)
+			bt += ",";
 
-		bt+=Variant::get_type_name(Variant::Type(i));
+		bt += Variant::get_type_name(Variant::Type(i));
 	}
 
-
 	List<String> script_extensions;
-	for(int i=0;i<ScriptServer::get_language_count();i++) {
+	for (int i = 0; i < ScriptServer::get_language_count(); i++) {
 		ScriptServer::get_language(i)->get_recognized_extensions(&script_extensions);
 	}
 
 	String script_ext_hint;
-	for (List<String>::Element *E=script_extensions.front();E;E=E->next()) {
-		if (script_ext_hint!=String())
-			script_ext_hint+=",";
-		script_ext_hint+="*."+E->get();
-	}
-
-
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"function/call_mode",PROPERTY_HINT_ENUM,"Self,Node Path,Instance,Basic Type,Singleton"),"set_call_mode","get_call_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"function/base_type",PROPERTY_HINT_TYPE_STRING,"Object"),"set_base_type","get_base_type");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"function/base_script",PROPERTY_HINT_FILE,script_ext_hint),"set_base_script","get_base_script");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"function/singleton"),"set_singleton","get_singleton");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"function/basic_type",PROPERTY_HINT_ENUM,bt),"set_basic_type","get_basic_type");
-	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"function/node_path",PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE),"set_base_path","get_base_path");
-	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY,"function/argument_cache",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"_set_argument_cache","_get_argument_cache");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"function/function"),"set_function","get_function"); //when set, if loaded properly, will override argument count.
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"function/use_default_args"),"set_use_default_args","get_use_default_args");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL,"function/validate"),"set_validate","get_validate");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"rpc/call_mode",PROPERTY_HINT_ENUM,"Disabled,Reliable,Unreliable,ReliableToID,UnreliableToID"),"set_rpc_call_mode","get_rpc_call_mode"); //when set, if loaded properly, will override argument count.
-
-	BIND_CONSTANT( CALL_MODE_SELF );
-	BIND_CONSTANT( CALL_MODE_NODE_PATH);
-	BIND_CONSTANT( CALL_MODE_INSTANCE);
-	BIND_CONSTANT( CALL_MODE_BASIC_TYPE );
+	for (List<String>::Element *E = script_extensions.front(); E; E = E->next()) {
+		if (script_ext_hint != String())
+			script_ext_hint += ",";
+		script_ext_hint += "*." + E->get();
+	}
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "function/call_mode", PROPERTY_HINT_ENUM, "Self,Node Path,Instance,Basic Type,Singleton"), "set_call_mode", "get_call_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "function/base_type", PROPERTY_HINT_TYPE_STRING, "Object"), "set_base_type", "get_base_type");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "function/base_script", PROPERTY_HINT_FILE, script_ext_hint), "set_base_script", "get_base_script");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "function/singleton"), "set_singleton", "get_singleton");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "function/basic_type", PROPERTY_HINT_ENUM, bt), "set_basic_type", "get_basic_type");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "function/node_path", PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE), "set_base_path", "get_base_path");
+	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "function/argument_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_argument_cache", "_get_argument_cache");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "function/function"), "set_function", "get_function"); //when set, if loaded properly, will override argument count.
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "function/use_default_args"), "set_use_default_args", "get_use_default_args");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "function/validate"), "set_validate", "get_validate");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "rpc/call_mode", PROPERTY_HINT_ENUM, "Disabled,Reliable,Unreliable,ReliableToID,UnreliableToID"), "set_rpc_call_mode", "get_rpc_call_mode"); //when set, if loaded properly, will override argument count.
+
+	BIND_CONSTANT(CALL_MODE_SELF);
+	BIND_CONSTANT(CALL_MODE_NODE_PATH);
+	BIND_CONSTANT(CALL_MODE_INSTANCE);
+	BIND_CONSTANT(CALL_MODE_BASIC_TYPE);
 }
 
 class VisualScriptNodeInstanceFunctionCall : public VisualScriptNodeInstance {
 public:
-
-
 	VisualScriptFunctionCall::CallMode call_mode;
 	NodePath node_path;
 	int input_args;
@@ -806,80 +766,76 @@ public:
 	VisualScriptFunctionCall *node;
 	VisualScriptInstance *instance;
 
-
-
 	//virtual int get_working_memory_size() const { return 0; }
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-
-	_FORCE_INLINE_ bool call_rpc(Object* p_base,const Variant** p_args,int p_argcount) {
+	_FORCE_INLINE_ bool call_rpc(Object *p_base, const Variant **p_args, int p_argcount) {
 
 		if (!p_base)
 			return false;
 
-		Node * node = p_base->cast_to<Node>();
+		Node *node = p_base->cast_to<Node>();
 		if (!node)
 			return false;
 
-		int to_id=0;
-		bool reliable=true;
+		int to_id = 0;
+		bool reliable = true;
 
-		if (rpc_mode>=VisualScriptFunctionCall::RPC_RELIABLE_TO_ID) {
+		if (rpc_mode >= VisualScriptFunctionCall::RPC_RELIABLE_TO_ID) {
 			to_id = *p_args[0];
-			p_args+=1;
-			p_argcount-=1;
-			if (rpc_mode==VisualScriptFunctionCall::RPC_UNRELIABLE_TO_ID) {
-				reliable=false;
+			p_args += 1;
+			p_argcount -= 1;
+			if (rpc_mode == VisualScriptFunctionCall::RPC_UNRELIABLE_TO_ID) {
+				reliable = false;
 			}
-		} else if (rpc_mode==VisualScriptFunctionCall::RPC_UNRELIABLE) {
-			reliable=false;
+		} else if (rpc_mode == VisualScriptFunctionCall::RPC_UNRELIABLE) {
+			reliable = false;
 		}
 
-		node->rpcp(to_id,!reliable,function,p_args,p_argcount);
+		node->rpcp(to_id, !reliable, function, p_args, p_argcount);
 
 		return true;
 	}
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-
-		switch(call_mode) {
+		switch (call_mode) {
 
 			case VisualScriptFunctionCall::CALL_MODE_SELF: {
 
-				Object *object=instance->get_owner_ptr();
+				Object *object = instance->get_owner_ptr();
 
 				if (rpc_mode) {
-					call_rpc(object,p_inputs,input_args);
+					call_rpc(object, p_inputs, input_args);
 				} else if (returns) {
-					*p_outputs[0] = object->call(function,p_inputs,input_args,r_error);
+					*p_outputs[0] = object->call(function, p_inputs, input_args, r_error);
 				} else {
-					object->call(function,p_inputs,input_args,r_error);
+					object->call(function, p_inputs, input_args, r_error);
 				}
 			} break;
 			case VisualScriptFunctionCall::CALL_MODE_NODE_PATH: {
 
-				Node* node = instance->get_owner_ptr()->cast_to<Node>();
+				Node *node = instance->get_owner_ptr()->cast_to<Node>();
 				if (!node) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Base object is not a Node!";
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = "Base object is not a Node!";
 					return 0;
 				}
 
-				Node* another = node->get_node(node_path);
+				Node *another = node->get_node(node_path);
 				if (!node) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Path does not lead Node!";
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = "Path does not lead Node!";
 					return 0;
 				}
 
 				if (rpc_mode) {
-					call_rpc(node,p_inputs,input_args);
+					call_rpc(node, p_inputs, input_args);
 				} else if (returns) {
-					*p_outputs[0] = another->call(function,p_inputs,input_args,r_error);
+					*p_outputs[0] = another->call(function, p_inputs, input_args, r_error);
 				} else {
-					another->call(function,p_inputs,input_args,r_error);
+					another->call(function, p_inputs, input_args, r_error);
 				}
 
 			} break;
@@ -891,98 +847,90 @@ public:
 				if (rpc_mode) {
 					Object *obj = v;
 					if (obj) {
-						call_rpc(obj,p_inputs+1,input_args-1);
+						call_rpc(obj, p_inputs + 1, input_args - 1);
 					}
 				} else if (returns) {
-					if (call_mode==VisualScriptFunctionCall::CALL_MODE_INSTANCE) {
-						*p_outputs[1] = v.call(function,p_inputs+1,input_args,r_error);
+					if (call_mode == VisualScriptFunctionCall::CALL_MODE_INSTANCE) {
+						*p_outputs[1] = v.call(function, p_inputs + 1, input_args, r_error);
 					} else {
-						*p_outputs[0] = v.call(function,p_inputs+1,input_args,r_error);
+						*p_outputs[0] = v.call(function, p_inputs + 1, input_args, r_error);
 					}
 				} else {
-					v.call(function,p_inputs+1,input_args,r_error);
+					v.call(function, p_inputs + 1, input_args, r_error);
 				}
 
-				if (call_mode==VisualScriptFunctionCall::CALL_MODE_INSTANCE) {
-					*p_outputs[0]=*p_inputs[0];
+				if (call_mode == VisualScriptFunctionCall::CALL_MODE_INSTANCE) {
+					*p_outputs[0] = *p_inputs[0];
 				}
 
 			} break;
 			case VisualScriptFunctionCall::CALL_MODE_SINGLETON: {
 
-				Object *object=GlobalConfig::get_singleton()->get_singleton_object(singleton);
+				Object *object = GlobalConfig::get_singleton()->get_singleton_object(singleton);
 				if (!object) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Invalid singleton name: '"+String(singleton)+"'";
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = "Invalid singleton name: '" + String(singleton) + "'";
 					return 0;
 				}
 
 				if (rpc_mode) {
-					call_rpc(object,p_inputs,input_args);
+					call_rpc(object, p_inputs, input_args);
 				} else if (returns) {
-					*p_outputs[0] = object->call(function,p_inputs,input_args,r_error);
+					*p_outputs[0] = object->call(function, p_inputs, input_args, r_error);
 				} else {
-					object->call(function,p_inputs,input_args,r_error);
+					object->call(function, p_inputs, input_args, r_error);
 				}
 			} break;
-
 		}
 
 		if (!validate) {
 
 			//ignore call errors if validation is disabled
-			r_error.error=Variant::CallError::CALL_OK;
-			r_error_str=String();
+			r_error.error = Variant::CallError::CALL_OK;
+			r_error_str = String();
 		}
 
 		return 0;
-
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptFunctionCall::instance(VisualScriptInstance* p_instance) {
-
-	VisualScriptNodeInstanceFunctionCall * instance = memnew(VisualScriptNodeInstanceFunctionCall );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->singleton=singleton;
-	instance->function=function;
-	instance->call_mode=call_mode;
-	instance->returns=get_output_value_port_count();
-	instance->node_path=base_path;
-	instance->input_args = get_input_value_port_count() - ( (call_mode==CALL_MODE_BASIC_TYPE || call_mode==CALL_MODE_INSTANCE) ? 1: 0 );
-	instance->rpc_mode=rpc_call_mode;
-	instance->validate=validate;
+VisualScriptNodeInstance *VisualScriptFunctionCall::instance(VisualScriptInstance *p_instance) {
+
+	VisualScriptNodeInstanceFunctionCall *instance = memnew(VisualScriptNodeInstanceFunctionCall);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->singleton = singleton;
+	instance->function = function;
+	instance->call_mode = call_mode;
+	instance->returns = get_output_value_port_count();
+	instance->node_path = base_path;
+	instance->input_args = get_input_value_port_count() - ((call_mode == CALL_MODE_BASIC_TYPE || call_mode == CALL_MODE_INSTANCE) ? 1 : 0);
+	instance->rpc_mode = rpc_call_mode;
+	instance->validate = validate;
 	return instance;
 }
 
+VisualScriptFunctionCall::TypeGuess VisualScriptFunctionCall::guess_output_type(TypeGuess *p_inputs, int p_output) const {
 
-VisualScriptFunctionCall::TypeGuess VisualScriptFunctionCall::guess_output_type(TypeGuess* p_inputs, int p_output) const {
-
-	if (p_output==0 && call_mode==CALL_MODE_INSTANCE) {
+	if (p_output == 0 && call_mode == CALL_MODE_INSTANCE) {
 		return p_inputs[0];
 	}
 
-	return VisualScriptNode::guess_output_type(p_inputs,p_output);
-
+	return VisualScriptNode::guess_output_type(p_inputs, p_output);
 }
 
 VisualScriptFunctionCall::VisualScriptFunctionCall() {
 
-	validate=true;
-	call_mode=CALL_MODE_SELF;
-	basic_type=Variant::NIL;
-	use_default_args=0;
-	base_type="Object";
-	rpc_call_mode=RPC_DISABLED;
-
-
+	validate = true;
+	call_mode = CALL_MODE_SELF;
+	basic_type = Variant::NIL;
+	use_default_args = 0;
+	base_type = "Object";
+	rpc_call_mode = RPC_DISABLED;
 }
 
-template<VisualScriptFunctionCall::CallMode cmode>
-static Ref<VisualScriptNode> create_function_call_node(const String& p_name) {
+template <VisualScriptFunctionCall::CallMode cmode>
+static Ref<VisualScriptNode> create_function_call_node(const String &p_name) {
 
 	Ref<VisualScriptFunctionCall> node;
 	node.instance();
@@ -990,12 +938,11 @@ static Ref<VisualScriptNode> create_function_call_node(const String& p_name) {
 	return node;
 }
 
-
 //////////////////////////////////////////
 ////////////////SET//////////////////////
 //////////////////////////////////////////
 
-static const char* event_type_names[InputEvent::TYPE_MAX]={
+static const char *event_type_names[InputEvent::TYPE_MAX] = {
 	"None",
 	"Key",
 	"MouseMotion",
@@ -1007,15 +954,14 @@ static const char* event_type_names[InputEvent::TYPE_MAX]={
 	"Action"
 };
 
-
 int VisualScriptPropertySet::get_output_sequence_port_count() const {
 
-	return call_mode!=CALL_MODE_BASIC_TYPE ? 1 : 0;
+	return call_mode != CALL_MODE_BASIC_TYPE ? 1 : 0;
 }
 
-bool VisualScriptPropertySet::has_input_sequence_port() const{
+bool VisualScriptPropertySet::has_input_sequence_port() const {
 
-	return call_mode!=CALL_MODE_BASIC_TYPE ? true : false;
+	return call_mode != CALL_MODE_BASIC_TYPE ? true : false;
 }
 
 Node *VisualScriptPropertySet::_get_base_node() const {
@@ -1025,7 +971,7 @@ Node *VisualScriptPropertySet::_get_base_node() const {
 	if (!script.is_valid())
 		return NULL;
 
-	MainLoop * main_loop = OS::get_singleton()->get_main_loop();
+	MainLoop *main_loop = OS::get_singleton()->get_main_loop();
 	if (!main_loop)
 		return NULL;
 
@@ -1039,7 +985,7 @@ Node *VisualScriptPropertySet::_get_base_node() const {
 	if (!edited_scene)
 		return NULL;
 
-	Node* script_node = _find_script_node(edited_scene,edited_scene,script);
+	Node *script_node = _find_script_node(edited_scene, edited_scene, script);
 
 	if (!script_node)
 		return NULL;
@@ -1058,27 +1004,26 @@ Node *VisualScriptPropertySet::_get_base_node() const {
 
 StringName VisualScriptPropertySet::_get_base_type() const {
 
-	if (call_mode==CALL_MODE_SELF && get_visual_script().is_valid())
+	if (call_mode == CALL_MODE_SELF && get_visual_script().is_valid())
 		return get_visual_script()->get_instance_base_type();
-	else if (call_mode==CALL_MODE_NODE_PATH && get_visual_script().is_valid()) {
+	else if (call_mode == CALL_MODE_NODE_PATH && get_visual_script().is_valid()) {
 		Node *path = _get_base_node();
 		if (path)
 			return path->get_class();
-
 	}
 
 	return base_type;
 }
 
-int VisualScriptPropertySet::get_input_value_port_count() const{
+int VisualScriptPropertySet::get_input_value_port_count() const {
 
-	int pc = (call_mode==CALL_MODE_BASIC_TYPE || call_mode==CALL_MODE_INSTANCE)?2:1;
+	int pc = (call_mode == CALL_MODE_BASIC_TYPE || call_mode == CALL_MODE_INSTANCE) ? 2 : 1;
 
 	return pc;
 }
-int VisualScriptPropertySet::get_output_value_port_count() const{
+int VisualScriptPropertySet::get_output_value_port_count() const {
 
-	return (call_mode==CALL_MODE_BASIC_TYPE || call_mode==CALL_MODE_INSTANCE) ? 1 : 0;
+	return (call_mode == CALL_MODE_BASIC_TYPE || call_mode == CALL_MODE_INSTANCE) ? 1 : 0;
 }
 
 String VisualScriptPropertySet::get_output_sequence_port_text(int p_port) const {
@@ -1086,39 +1031,37 @@ String VisualScriptPropertySet::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptPropertySet::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptPropertySet::get_input_value_port_info(int p_idx) const {
 
-	if (call_mode==CALL_MODE_INSTANCE || call_mode==CALL_MODE_BASIC_TYPE) {
-		if (p_idx==0) {
+	if (call_mode == CALL_MODE_INSTANCE || call_mode == CALL_MODE_BASIC_TYPE) {
+		if (p_idx == 0) {
 			PropertyInfo pi;
-			pi.type=(call_mode==CALL_MODE_INSTANCE?Variant::OBJECT:basic_type);
-			pi.name=(call_mode==CALL_MODE_INSTANCE?String("instance"):Variant::get_type_name(basic_type).to_lower());
+			pi.type = (call_mode == CALL_MODE_INSTANCE ? Variant::OBJECT : basic_type);
+			pi.name = (call_mode == CALL_MODE_INSTANCE ? String("instance") : Variant::get_type_name(basic_type).to_lower());
 			return pi;
 		} else {
 			p_idx--;
 		}
 	}
 
-	PropertyInfo pinfo=type_cache;
-	pinfo.name="value";
+	PropertyInfo pinfo = type_cache;
+	pinfo.name = "value";
 	return pinfo;
 }
 
-PropertyInfo VisualScriptPropertySet::get_output_value_port_info(int p_idx) const{
-	if (call_mode==CALL_MODE_BASIC_TYPE) {
-		return PropertyInfo(basic_type,"out");
-	} else if (call_mode==CALL_MODE_INSTANCE) {
-		return PropertyInfo(Variant::OBJECT,"pass");
+PropertyInfo VisualScriptPropertySet::get_output_value_port_info(int p_idx) const {
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
+		return PropertyInfo(basic_type, "out");
+	} else if (call_mode == CALL_MODE_INSTANCE) {
+		return PropertyInfo(Variant::OBJECT, "pass");
 	} else {
 		return PropertyInfo();
 	}
-
 }
 
-
 String VisualScriptPropertySet::get_caption() const {
 
-	static const char*cname[4]= {
+	static const char *cname[4] = {
 		"SelfSet",
 		"NodeSet",
 		"InstanceSet",
@@ -1132,58 +1075,55 @@ String VisualScriptPropertySet::get_text() const {
 
 	String prop;
 
-	if (call_mode==CALL_MODE_BASIC_TYPE)
-		prop=Variant::get_type_name(basic_type)+"."+property;
-	else if (call_mode==CALL_MODE_NODE_PATH)
-		prop=String(base_path)+":"+property;
-	else if (call_mode==CALL_MODE_SELF)
-		prop=property;
-	else if (call_mode==CALL_MODE_INSTANCE)
-		prop=String(base_type)+":"+property;
+	if (call_mode == CALL_MODE_BASIC_TYPE)
+		prop = Variant::get_type_name(basic_type) + "." + property;
+	else if (call_mode == CALL_MODE_NODE_PATH)
+		prop = String(base_path) + ":" + property;
+	else if (call_mode == CALL_MODE_SELF)
+		prop = property;
+	else if (call_mode == CALL_MODE_INSTANCE)
+		prop = String(base_type) + ":" + property;
 
 	return prop;
-
 }
 
 void VisualScriptPropertySet::_update_base_type() {
 	//cache it because this information may not be available on load
-	if (call_mode==CALL_MODE_NODE_PATH) {
+	if (call_mode == CALL_MODE_NODE_PATH) {
 
-		Node* node=_get_base_node();
+		Node *node = _get_base_node();
 		if (node) {
-			base_type=node->get_class();
+			base_type = node->get_class();
 		}
-	} else if (call_mode==CALL_MODE_SELF) {
+	} else if (call_mode == CALL_MODE_SELF) {
 
 		if (get_visual_script().is_valid()) {
-			base_type=get_visual_script()->get_instance_base_type();
+			base_type = get_visual_script()->get_instance_base_type();
 		}
 	}
-
 }
 void VisualScriptPropertySet::set_basic_type(Variant::Type p_type) {
 
-	if (basic_type==p_type)
+	if (basic_type == p_type)
 		return;
-	basic_type=p_type;
-
+	basic_type = p_type;
 
 	_change_notify();
 	_update_base_type();
 	ports_changed_notify();
 }
 
-Variant::Type VisualScriptPropertySet::get_basic_type() const{
+Variant::Type VisualScriptPropertySet::get_basic_type() const {
 
 	return basic_type;
 }
 
 void VisualScriptPropertySet::set_event_type(InputEvent::Type p_type) {
 
-	if (event_type==p_type)
+	if (event_type == p_type)
 		return;
-	event_type=p_type;
-	if (call_mode==CALL_MODE_BASIC_TYPE) {
+	event_type = p_type;
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
 		_update_cache();
 	}
 	_change_notify();
@@ -1191,34 +1131,32 @@ void VisualScriptPropertySet::set_event_type(InputEvent::Type p_type) {
 	ports_changed_notify();
 }
 
-InputEvent::Type VisualScriptPropertySet::get_event_type() const{
+InputEvent::Type VisualScriptPropertySet::get_event_type() const {
 
 	return event_type;
 }
 
+void VisualScriptPropertySet::set_base_type(const StringName &p_type) {
 
-void VisualScriptPropertySet::set_base_type(const StringName& p_type) {
-
-	if (base_type==p_type)
+	if (base_type == p_type)
 		return;
 
-	base_type=p_type;
-	_change_notify();	
+	base_type = p_type;
+	_change_notify();
 	ports_changed_notify();
 }
 
-StringName VisualScriptPropertySet::get_base_type() const{
+StringName VisualScriptPropertySet::get_base_type() const {
 
 	return base_type;
 }
 
+void VisualScriptPropertySet::set_base_script(const String &p_path) {
 
-void VisualScriptPropertySet::set_base_script(const String& p_path) {
-
-	if (base_script==p_path)
+	if (base_script == p_path)
 		return;
 
-	base_script=p_path;
+	base_script = p_path;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -1228,10 +1166,8 @@ String VisualScriptPropertySet::get_base_script() const {
 	return base_script;
 }
 
-
 void VisualScriptPropertySet::_update_cache() {
 
-
 	if (!OS::get_singleton()->get_main_loop())
 		return;
 	if (!OS::get_singleton()->get_main_loop()->cast_to<SceneTree>())
@@ -1240,57 +1176,56 @@ void VisualScriptPropertySet::_update_cache() {
 	if (!OS::get_singleton()->get_main_loop()->cast_to<SceneTree>()->is_editor_hint()) //only update cache if editor exists, it's pointless otherwise
 		return;
 
-	if (call_mode==CALL_MODE_BASIC_TYPE) {
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
 
 		//not super efficient..
 
 		Variant v;
-		if (basic_type==Variant::INPUT_EVENT) {
+		if (basic_type == Variant::INPUT_EVENT) {
 			InputEvent ev;
-			ev.type=event_type;
-			v=ev;
+			ev.type = event_type;
+			v = ev;
 		} else {
 			Variant::CallError ce;
-			v = Variant::construct(basic_type,NULL,0,ce);
+			v = Variant::construct(basic_type, NULL, 0, ce);
 		}
 
 		List<PropertyInfo> pinfo;
 		v.get_property_list(&pinfo);
 
-		for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
+		for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
 
-			if (E->get().name==property) {
+			if (E->get().name == property) {
 
-				type_cache=E->get();
+				type_cache = E->get();
 			}
 		}
 
 	} else {
 
-
 		StringName type;
 		Ref<Script> script;
-		Node *node=NULL;
+		Node *node = NULL;
 
-		if (call_mode==CALL_MODE_NODE_PATH) {
+		if (call_mode == CALL_MODE_NODE_PATH) {
 
-			node=_get_base_node();
+			node = _get_base_node();
 			if (node) {
-				type=node->get_class();
-				base_type=type; //cache, too
+				type = node->get_class();
+				base_type = type; //cache, too
 				script = node->get_script();
 			}
-		} else if (call_mode==CALL_MODE_SELF) {
+		} else if (call_mode == CALL_MODE_SELF) {
 
 			if (get_visual_script().is_valid()) {
-				type=get_visual_script()->get_instance_base_type();
-				base_type=type; //cache, too
-				script=get_visual_script();
+				type = get_visual_script()->get_instance_base_type();
+				base_type = type; //cache, too
+				script = get_visual_script();
 			}
-		} else if (call_mode==CALL_MODE_INSTANCE) {
+		} else if (call_mode == CALL_MODE_INSTANCE) {
 
-			type=base_type;
-			if (base_script!=String()) {
+			type = base_type;
+			if (base_script != String()) {
 
 				if (!ResourceCache::has(base_script) && ScriptServer::edit_request_func) {
 
@@ -1299,7 +1234,7 @@ void VisualScriptPropertySet::_update_cache() {
 
 				if (ResourceCache::has(base_script)) {
 
-					script = Ref<Resource>( ResourceCache::get(base_script) );
+					script = Ref<Resource>(ResourceCache::get(base_script));
 				} else {
 					return;
 				}
@@ -1308,12 +1243,11 @@ void VisualScriptPropertySet::_update_cache() {
 
 		List<PropertyInfo> pinfo;
 
-
 		if (node) {
 
 			node->get_property_list(&pinfo);
 		} else {
-			ClassDB::get_property_list(type,&pinfo);
+			ClassDB::get_property_list(type, &pinfo);
 		}
 
 		if (script.is_valid()) {
@@ -1321,39 +1255,37 @@ void VisualScriptPropertySet::_update_cache() {
 			script->get_script_property_list(&pinfo);
 		}
 
-		for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
+		for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
 
-			if (E->get().name==property) {
-				type_cache=E->get();
+			if (E->get().name == property) {
+				type_cache = E->get();
 				return;
 			}
 		}
-
 	}
 }
 
-void VisualScriptPropertySet::set_property(const StringName& p_type){
+void VisualScriptPropertySet::set_property(const StringName &p_type) {
 
-	if (property==p_type)
+	if (property == p_type)
 		return;
 
-	property=p_type;
+	property = p_type;
 	_update_cache();
-	_change_notify();	
+	_change_notify();
 	ports_changed_notify();
 }
 StringName VisualScriptPropertySet::get_property() const {
 
-
 	return property;
 }
 
-void VisualScriptPropertySet::set_base_path(const NodePath& p_type) {
+void VisualScriptPropertySet::set_base_path(const NodePath &p_type) {
 
-	if (base_path==p_type)
+	if (base_path == p_type)
 		return;
 
-	base_path=p_type;
+	base_path = p_type;
 	_update_base_type();
 	_change_notify();
 	ports_changed_notify();
@@ -1364,28 +1296,23 @@ NodePath VisualScriptPropertySet::get_base_path() const {
 	return base_path;
 }
 
-
 void VisualScriptPropertySet::set_call_mode(CallMode p_mode) {
 
-	if (call_mode==p_mode)
+	if (call_mode == p_mode)
 		return;
 
-	call_mode=p_mode;
+	call_mode = p_mode;
 	_update_base_type();
 	_change_notify();
 	ports_changed_notify();
-
 }
 VisualScriptPropertySet::CallMode VisualScriptPropertySet::get_call_mode() const {
 
 	return call_mode;
 }
 
-
-
-
 void VisualScriptPropertySet::_set_type_cache(const Dictionary &p_type) {
-	type_cache=PropertyInfo::from_dict(p_type);
+	type_cache = PropertyInfo::from_dict(p_type);
 }
 
 Dictionary VisualScriptPropertySet::_get_type_cache() const {
@@ -1393,61 +1320,60 @@ Dictionary VisualScriptPropertySet::_get_type_cache() const {
 	return type_cache;
 }
 
-void VisualScriptPropertySet::_validate_property(PropertyInfo& property) const {
+void VisualScriptPropertySet::_validate_property(PropertyInfo &property) const {
 
-	if (property.name=="property/base_type") {
-		if (call_mode!=CALL_MODE_INSTANCE) {
-			property.usage=PROPERTY_USAGE_NOEDITOR;
+	if (property.name == "property/base_type") {
+		if (call_mode != CALL_MODE_INSTANCE) {
+			property.usage = PROPERTY_USAGE_NOEDITOR;
 		}
 	}
 
-	if (property.name=="property/base_script") {
-		if (call_mode!=CALL_MODE_INSTANCE) {
-			property.usage=0;
+	if (property.name == "property/base_script") {
+		if (call_mode != CALL_MODE_INSTANCE) {
+			property.usage = 0;
 		}
 	}
 
-	if (property.name=="property/basic_type") {
-		if (call_mode!=CALL_MODE_BASIC_TYPE) {
-			property.usage=0;
+	if (property.name == "property/basic_type") {
+		if (call_mode != CALL_MODE_BASIC_TYPE) {
+			property.usage = 0;
 		}
 	}
 
-	if (property.name=="property/event_type") {
-		if (call_mode!=CALL_MODE_BASIC_TYPE || basic_type!=Variant::INPUT_EVENT) {
-			property.usage=0;
+	if (property.name == "property/event_type") {
+		if (call_mode != CALL_MODE_BASIC_TYPE || basic_type != Variant::INPUT_EVENT) {
+			property.usage = 0;
 		}
 	}
 
-	if (property.name=="property/node_path") {
-		if (call_mode!=CALL_MODE_NODE_PATH) {
-			property.usage=0;
+	if (property.name == "property/node_path") {
+		if (call_mode != CALL_MODE_NODE_PATH) {
+			property.usage = 0;
 		} else {
 
 			Node *bnode = _get_base_node();
 			if (bnode) {
-				property.hint_string=bnode->get_path(); //convert to loong string
+				property.hint_string = bnode->get_path(); //convert to loong string
 			} else {
-
 			}
 		}
 	}
 
-	if (property.name=="property/property") {
+	if (property.name == "property/property") {
 
-		if (call_mode==CALL_MODE_BASIC_TYPE) {
+		if (call_mode == CALL_MODE_BASIC_TYPE) {
 
-			property.hint=PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE;
-			property.hint_string=Variant::get_type_name(basic_type);
+			property.hint = PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE;
+			property.hint_string = Variant::get_type_name(basic_type);
 
-		} else if (call_mode==CALL_MODE_SELF && get_visual_script().is_valid()) {
-			property.hint=PROPERTY_HINT_PROPERTY_OF_SCRIPT;
-			property.hint_string=itos(get_visual_script()->get_instance_ID());
-		} else if (call_mode==CALL_MODE_INSTANCE) {
-			property.hint=PROPERTY_HINT_PROPERTY_OF_BASE_TYPE;
-			property.hint_string=base_type;
+		} else if (call_mode == CALL_MODE_SELF && get_visual_script().is_valid()) {
+			property.hint = PROPERTY_HINT_PROPERTY_OF_SCRIPT;
+			property.hint_string = itos(get_visual_script()->get_instance_ID());
+		} else if (call_mode == CALL_MODE_INSTANCE) {
+			property.hint = PROPERTY_HINT_PROPERTY_OF_BASE_TYPE;
+			property.hint_string = base_type;
 
-			if (base_script!=String()) {
+			if (base_script != String()) {
 				if (!ResourceCache::has(base_script) && ScriptServer::edit_request_func) {
 
 					ScriptServer::edit_request_func(base_script); //make sure it's loaded
@@ -1455,106 +1381,98 @@ void VisualScriptPropertySet::_validate_property(PropertyInfo& property) const {
 
 				if (ResourceCache::has(base_script)) {
 
-					Ref<Script> script = Ref<Resource>( ResourceCache::get(base_script) );
+					Ref<Script> script = Ref<Resource>(ResourceCache::get(base_script));
 					if (script.is_valid()) {
 
-						property.hint=PROPERTY_HINT_PROPERTY_OF_SCRIPT;
-						property.hint_string=itos(script->get_instance_ID());
+						property.hint = PROPERTY_HINT_PROPERTY_OF_SCRIPT;
+						property.hint_string = itos(script->get_instance_ID());
 					}
 				}
 			}
 
-		} else if (call_mode==CALL_MODE_NODE_PATH) {
+		} else if (call_mode == CALL_MODE_NODE_PATH) {
 			Node *node = _get_base_node();
 			if (node) {
-				property.hint=PROPERTY_HINT_PROPERTY_OF_INSTANCE;
-				property.hint_string=itos(node->get_instance_ID());
+				property.hint = PROPERTY_HINT_PROPERTY_OF_INSTANCE;
+				property.hint_string = itos(node->get_instance_ID());
 			} else {
-				property.hint=PROPERTY_HINT_PROPERTY_OF_BASE_TYPE;
-				property.hint_string=get_base_type();
+				property.hint = PROPERTY_HINT_PROPERTY_OF_BASE_TYPE;
+				property.hint_string = get_base_type();
 			}
-
 		}
-
 	}
-
 }
 
 void VisualScriptPropertySet::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_base_type","base_type"),&VisualScriptPropertySet::set_base_type);
-	ClassDB::bind_method(D_METHOD("get_base_type"),&VisualScriptPropertySet::get_base_type);
+	ClassDB::bind_method(D_METHOD("set_base_type", "base_type"), &VisualScriptPropertySet::set_base_type);
+	ClassDB::bind_method(D_METHOD("get_base_type"), &VisualScriptPropertySet::get_base_type);
 
-	ClassDB::bind_method(D_METHOD("set_base_script","base_script"),&VisualScriptPropertySet::set_base_script);
-	ClassDB::bind_method(D_METHOD("get_base_script"),&VisualScriptPropertySet::get_base_script);
+	ClassDB::bind_method(D_METHOD("set_base_script", "base_script"), &VisualScriptPropertySet::set_base_script);
+	ClassDB::bind_method(D_METHOD("get_base_script"), &VisualScriptPropertySet::get_base_script);
 
-	ClassDB::bind_method(D_METHOD("set_basic_type","basic_type"),&VisualScriptPropertySet::set_basic_type);
-	ClassDB::bind_method(D_METHOD("get_basic_type"),&VisualScriptPropertySet::get_basic_type);
+	ClassDB::bind_method(D_METHOD("set_basic_type", "basic_type"), &VisualScriptPropertySet::set_basic_type);
+	ClassDB::bind_method(D_METHOD("get_basic_type"), &VisualScriptPropertySet::get_basic_type);
 
-	ClassDB::bind_method(D_METHOD("_set_type_cache","type_cache"),&VisualScriptPropertySet::_set_type_cache);
-	ClassDB::bind_method(D_METHOD("_get_type_cache"),&VisualScriptPropertySet::_get_type_cache);
+	ClassDB::bind_method(D_METHOD("_set_type_cache", "type_cache"), &VisualScriptPropertySet::_set_type_cache);
+	ClassDB::bind_method(D_METHOD("_get_type_cache"), &VisualScriptPropertySet::_get_type_cache);
 
-	ClassDB::bind_method(D_METHOD("set_event_type","event_type"),&VisualScriptPropertySet::set_event_type);
-	ClassDB::bind_method(D_METHOD("get_event_type"),&VisualScriptPropertySet::get_event_type);
+	ClassDB::bind_method(D_METHOD("set_event_type", "event_type"), &VisualScriptPropertySet::set_event_type);
+	ClassDB::bind_method(D_METHOD("get_event_type"), &VisualScriptPropertySet::get_event_type);
 
-	ClassDB::bind_method(D_METHOD("set_property","property"),&VisualScriptPropertySet::set_property);
-	ClassDB::bind_method(D_METHOD("get_property"),&VisualScriptPropertySet::get_property);
-
-	ClassDB::bind_method(D_METHOD("set_call_mode","mode"),&VisualScriptPropertySet::set_call_mode);
-	ClassDB::bind_method(D_METHOD("get_call_mode"),&VisualScriptPropertySet::get_call_mode);
-
-	ClassDB::bind_method(D_METHOD("set_base_path","base_path"),&VisualScriptPropertySet::set_base_path);
-	ClassDB::bind_method(D_METHOD("get_base_path"),&VisualScriptPropertySet::get_base_path);
+	ClassDB::bind_method(D_METHOD("set_property", "property"), &VisualScriptPropertySet::set_property);
+	ClassDB::bind_method(D_METHOD("get_property"), &VisualScriptPropertySet::get_property);
 
+	ClassDB::bind_method(D_METHOD("set_call_mode", "mode"), &VisualScriptPropertySet::set_call_mode);
+	ClassDB::bind_method(D_METHOD("get_call_mode"), &VisualScriptPropertySet::get_call_mode);
 
+	ClassDB::bind_method(D_METHOD("set_base_path", "base_path"), &VisualScriptPropertySet::set_base_path);
+	ClassDB::bind_method(D_METHOD("get_base_path"), &VisualScriptPropertySet::get_base_path);
 
 	String bt;
-	for(int i=0;i<Variant::VARIANT_MAX;i++) {
-		if (i>0)
-			bt+=",";
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		if (i > 0)
+			bt += ",";
 
-		bt+=Variant::get_type_name(Variant::Type(i));
+		bt += Variant::get_type_name(Variant::Type(i));
 	}
 
 	String et;
-	for(int i=0;i<InputEvent::TYPE_MAX;i++) {
-		if (i>0)
-			et+=",";
+	for (int i = 0; i < InputEvent::TYPE_MAX; i++) {
+		if (i > 0)
+			et += ",";
 
-		et+=event_type_names[i];
+		et += event_type_names[i];
 	}
 
 	List<String> script_extensions;
-	for(int i=0;i<ScriptServer::get_language_count();i++) {
+	for (int i = 0; i < ScriptServer::get_language_count(); i++) {
 		ScriptServer::get_language(i)->get_recognized_extensions(&script_extensions);
 	}
 
 	String script_ext_hint;
-	for (List<String>::Element *E=script_extensions.front();E;E=E->next()) {
-		if (script_ext_hint!=String())
-			script_ext_hint+=",";
-		script_ext_hint+="*."+E->get();
+	for (List<String>::Element *E = script_extensions.front(); E; E = E->next()) {
+		if (script_ext_hint != String())
+			script_ext_hint += ",";
+		script_ext_hint += "*." + E->get();
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"property/set_mode",PROPERTY_HINT_ENUM,"Self,Node Path,Instance,Basic Type"),"set_call_mode","get_call_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"property/base_type",PROPERTY_HINT_TYPE_STRING,"Object"),"set_base_type","get_base_type");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"property/base_script",PROPERTY_HINT_FILE,script_ext_hint),"set_base_script","get_base_script");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"property/type_cache",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"_set_type_cache","_get_type_cache");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"property/basic_type",PROPERTY_HINT_ENUM,bt),"set_basic_type","get_basic_type");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"property/event_type",PROPERTY_HINT_ENUM,et),"set_event_type","get_event_type");
-	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"property/node_path",PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE),"set_base_path","get_base_path");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"property/property"),"set_property","get_property");
-
-	BIND_CONSTANT( CALL_MODE_SELF );
-	BIND_CONSTANT( CALL_MODE_NODE_PATH);
-	BIND_CONSTANT( CALL_MODE_INSTANCE);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "property/set_mode", PROPERTY_HINT_ENUM, "Self,Node Path,Instance,Basic Type"), "set_call_mode", "get_call_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/base_type", PROPERTY_HINT_TYPE_STRING, "Object"), "set_base_type", "get_base_type");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/base_script", PROPERTY_HINT_FILE, script_ext_hint), "set_base_script", "get_base_script");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "property/type_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_type_cache", "_get_type_cache");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "property/basic_type", PROPERTY_HINT_ENUM, bt), "set_basic_type", "get_basic_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "property/event_type", PROPERTY_HINT_ENUM, et), "set_event_type", "get_event_type");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "property/node_path", PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE), "set_base_path", "get_base_path");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/property"), "set_property", "get_property");
 
+	BIND_CONSTANT(CALL_MODE_SELF);
+	BIND_CONSTANT(CALL_MODE_NODE_PATH);
+	BIND_CONSTANT(CALL_MODE_INSTANCE);
 }
 
 class VisualScriptNodeInstancePropertySet : public VisualScriptNodeInstance {
 public:
-
-
 	VisualScriptPropertySet::CallMode call_mode;
 	NodePath node_path;
 	StringName property;
@@ -1562,53 +1480,50 @@ public:
 	VisualScriptPropertySet *node;
 	VisualScriptInstance *instance;
 
-
-
 	//virtual int get_working_memory_size() const { return 0; }
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
-
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		switch(call_mode) {
+		switch (call_mode) {
 
 			case VisualScriptPropertySet::CALL_MODE_SELF: {
 
-				Object *object=instance->get_owner_ptr();
+				Object *object = instance->get_owner_ptr();
 
 				bool valid;
 
-				object->set(property,*p_inputs[0],&valid);
+				object->set(property, *p_inputs[0], &valid);
 
 				if (!valid) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Invalid set value '"+String(*p_inputs[0])+"' on property '"+String(property)+"' of type "+object->get_class();
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = "Invalid set value '" + String(*p_inputs[0]) + "' on property '" + String(property) + "' of type " + object->get_class();
 				}
 			} break;
 			case VisualScriptPropertySet::CALL_MODE_NODE_PATH: {
 
-				Node* node = instance->get_owner_ptr()->cast_to<Node>();
+				Node *node = instance->get_owner_ptr()->cast_to<Node>();
 				if (!node) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Base object is not a Node!";
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = "Base object is not a Node!";
 					return 0;
 				}
 
-				Node* another = node->get_node(node_path);
+				Node *another = node->get_node(node_path);
 				if (!node) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Path does not lead Node!";
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = "Path does not lead Node!";
 					return 0;
 				}
 
 				bool valid;
 
-				another->set(property,*p_inputs[0],&valid);
+				another->set(property, *p_inputs[0], &valid);
 
 				if (!valid) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Invalid set value '"+String(*p_inputs[0])+"' on property '"+String(property)+"' of type "+another->get_class();
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = "Invalid set value '" + String(*p_inputs[0]) + "' on property '" + String(property) + "' of type " + another->get_class();
 				}
 
 			} break;
@@ -1619,58 +1534,50 @@ public:
 
 				bool valid;
 
-				v.set(property,*p_inputs[1],&valid);
+				v.set(property, *p_inputs[1], &valid);
 
 				if (!valid) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;					
-					r_error_str="Invalid set value '"+String(*p_inputs[1])+"' ("+Variant::get_type_name(p_inputs[1]->get_type())+") on property '"+String(property)+"' of type "+Variant::get_type_name(v.get_type());
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = "Invalid set value '" + String(*p_inputs[1]) + "' (" + Variant::get_type_name(p_inputs[1]->get_type()) + ") on property '" + String(property) + "' of type " + Variant::get_type_name(v.get_type());
 				}
 
-				*p_outputs[0]=v;
+				*p_outputs[0] = v;
 
 			} break;
-
 		}
 		return 0;
-
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptPropertySet::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptPropertySet::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstancePropertySet * instance = memnew(VisualScriptNodeInstancePropertySet );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->property=property;
-	instance->call_mode=call_mode;
-	instance->node_path=base_path;
+	VisualScriptNodeInstancePropertySet *instance = memnew(VisualScriptNodeInstancePropertySet);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->property = property;
+	instance->call_mode = call_mode;
+	instance->node_path = base_path;
 	return instance;
 }
 
+VisualScriptPropertySet::TypeGuess VisualScriptPropertySet::guess_output_type(TypeGuess *p_inputs, int p_output) const {
 
-
-VisualScriptPropertySet::TypeGuess VisualScriptPropertySet::guess_output_type(TypeGuess* p_inputs, int p_output) const {
-
-	if (p_output==0 && call_mode==CALL_MODE_INSTANCE) {
+	if (p_output == 0 && call_mode == CALL_MODE_INSTANCE) {
 		return p_inputs[0];
 	}
 
-	return VisualScriptNode::guess_output_type(p_inputs,p_output);
-
+	return VisualScriptNode::guess_output_type(p_inputs, p_output);
 }
 VisualScriptPropertySet::VisualScriptPropertySet() {
 
-	call_mode=CALL_MODE_SELF;
-	base_type="Object";
-	basic_type=Variant::NIL;
-	event_type=InputEvent::NONE;
-
+	call_mode = CALL_MODE_SELF;
+	base_type = "Object";
+	basic_type = Variant::NIL;
+	event_type = InputEvent::NONE;
 }
 
-template<VisualScriptPropertySet::CallMode cmode>
-static Ref<VisualScriptNode> create_property_set_node(const String& p_name) {
+template <VisualScriptPropertySet::CallMode cmode>
+static Ref<VisualScriptNode> create_property_set_node(const String &p_name) {
 
 	Ref<VisualScriptPropertySet> node;
 	node.instance();
@@ -1678,35 +1585,33 @@ static Ref<VisualScriptNode> create_property_set_node(const String& p_name) {
 	return node;
 }
 
-
 //////////////////////////////////////////
 ////////////////GET//////////////////////
 //////////////////////////////////////////
 
 int VisualScriptPropertyGet::get_output_sequence_port_count() const {
 
-	return 0;// (call_mode==CALL_MODE_SELF || call_mode==CALL_MODE_NODE_PATH)?0:1;
+	return 0; // (call_mode==CALL_MODE_SELF || call_mode==CALL_MODE_NODE_PATH)?0:1;
 }
 
-bool VisualScriptPropertyGet::has_input_sequence_port() const{
+bool VisualScriptPropertyGet::has_input_sequence_port() const {
 
-	return false;//(call_mode==CALL_MODE_SELF || call_mode==CALL_MODE_NODE_PATH)?false:true;
+	return false; //(call_mode==CALL_MODE_SELF || call_mode==CALL_MODE_NODE_PATH)?false:true;
 }
 void VisualScriptPropertyGet::_update_base_type() {
 	//cache it because this information may not be available on load
-	if (call_mode==CALL_MODE_NODE_PATH) {
+	if (call_mode == CALL_MODE_NODE_PATH) {
 
-		Node* node=_get_base_node();
+		Node *node = _get_base_node();
 		if (node) {
-			base_type=node->get_class();
+			base_type = node->get_class();
 		}
-	} else if (call_mode==CALL_MODE_SELF) {
+	} else if (call_mode == CALL_MODE_SELF) {
 
 		if (get_visual_script().is_valid()) {
-			base_type=get_visual_script()->get_instance_base_type();
+			base_type = get_visual_script()->get_instance_base_type();
 		}
 	}
-
 }
 Node *VisualScriptPropertyGet::_get_base_node() const {
 
@@ -1715,7 +1620,7 @@ Node *VisualScriptPropertyGet::_get_base_node() const {
 	if (!script.is_valid())
 		return NULL;
 
-	MainLoop * main_loop = OS::get_singleton()->get_main_loop();
+	MainLoop *main_loop = OS::get_singleton()->get_main_loop();
 	if (!main_loop)
 		return NULL;
 
@@ -1729,7 +1634,7 @@ Node *VisualScriptPropertyGet::_get_base_node() const {
 	if (!edited_scene)
 		return NULL;
 
-	Node* script_node = _find_script_node(edited_scene,edited_scene,script);
+	Node *script_node = _find_script_node(edited_scene, edited_scene, script);
 
 	if (!script_node)
 		return NULL;
@@ -1748,25 +1653,22 @@ Node *VisualScriptPropertyGet::_get_base_node() const {
 
 StringName VisualScriptPropertyGet::_get_base_type() const {
 
-	if (call_mode==CALL_MODE_SELF && get_visual_script().is_valid())
+	if (call_mode == CALL_MODE_SELF && get_visual_script().is_valid())
 		return get_visual_script()->get_instance_base_type();
-	else if (call_mode==CALL_MODE_NODE_PATH && get_visual_script().is_valid()) {
+	else if (call_mode == CALL_MODE_NODE_PATH && get_visual_script().is_valid()) {
 		Node *path = _get_base_node();
 		if (path)
 			return path->get_class();
-
 	}
 
 	return base_type;
 }
 
+int VisualScriptPropertyGet::get_input_value_port_count() const {
 
-int VisualScriptPropertyGet::get_input_value_port_count() const{
-
-	return (call_mode==CALL_MODE_BASIC_TYPE || call_mode==CALL_MODE_INSTANCE)?1:0;
-
+	return (call_mode == CALL_MODE_BASIC_TYPE || call_mode == CALL_MODE_INSTANCE) ? 1 : 0;
 }
-int VisualScriptPropertyGet::get_output_value_port_count() const{
+int VisualScriptPropertyGet::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -1776,31 +1678,29 @@ String VisualScriptPropertyGet::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptPropertyGet::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptPropertyGet::get_input_value_port_info(int p_idx) const {
 
-	if (call_mode==CALL_MODE_INSTANCE || call_mode==CALL_MODE_BASIC_TYPE) {
-		if (p_idx==0) {
+	if (call_mode == CALL_MODE_INSTANCE || call_mode == CALL_MODE_BASIC_TYPE) {
+		if (p_idx == 0) {
 			PropertyInfo pi;
-			pi.type=(call_mode==CALL_MODE_INSTANCE?Variant::OBJECT:basic_type);
-			pi.name=(call_mode==CALL_MODE_INSTANCE?String("instance"):Variant::get_type_name(basic_type).to_lower());
+			pi.type = (call_mode == CALL_MODE_INSTANCE ? Variant::OBJECT : basic_type);
+			pi.name = (call_mode == CALL_MODE_INSTANCE ? String("instance") : Variant::get_type_name(basic_type).to_lower());
 			return pi;
 		} else {
 			p_idx--;
 		}
 	}
 	return PropertyInfo();
-
 }
 
-PropertyInfo VisualScriptPropertyGet::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptPropertyGet::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(type_cache,"value");
+	return PropertyInfo(type_cache, "value");
 }
 
-
 String VisualScriptPropertyGet::get_caption() const {
 
-	static const char*cname[4]= {
+	static const char *cname[4] = {
 		"SelfGet",
 		"NodeGet",
 		"InstanceGet",
@@ -1814,39 +1714,39 @@ String VisualScriptPropertyGet::get_text() const {
 
 	String prop;
 
-	if (call_mode==CALL_MODE_BASIC_TYPE)
-		prop=Variant::get_type_name(basic_type)+"."+property;
-	else if (call_mode==CALL_MODE_NODE_PATH)
-		prop=String(base_path)+":"+property;
-	else if (call_mode==CALL_MODE_SELF)
-		prop=property;
-	else if (call_mode==CALL_MODE_INSTANCE)
-		prop=String(base_type)+":"+property;
+	if (call_mode == CALL_MODE_BASIC_TYPE)
+		prop = Variant::get_type_name(basic_type) + "." + property;
+	else if (call_mode == CALL_MODE_NODE_PATH)
+		prop = String(base_path) + ":" + property;
+	else if (call_mode == CALL_MODE_SELF)
+		prop = property;
+	else if (call_mode == CALL_MODE_INSTANCE)
+		prop = String(base_type) + ":" + property;
 
 	return prop;
 }
 
-void VisualScriptPropertyGet::set_base_type(const StringName& p_type) {
+void VisualScriptPropertyGet::set_base_type(const StringName &p_type) {
 
-	if (base_type==p_type)
+	if (base_type == p_type)
 		return;
 
-	base_type=p_type;	
+	base_type = p_type;
 	_change_notify();
 	ports_changed_notify();
 }
 
-StringName VisualScriptPropertyGet::get_base_type() const{
+StringName VisualScriptPropertyGet::get_base_type() const {
 
 	return base_type;
 }
 
-void VisualScriptPropertyGet::set_base_script(const String& p_path) {
+void VisualScriptPropertyGet::set_base_script(const String &p_path) {
 
-	if (base_script==p_path)
+	if (base_script == p_path)
 		return;
 
-	base_script=p_path;
+	base_script = p_path;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -1856,62 +1756,59 @@ String VisualScriptPropertyGet::get_base_script() const {
 	return base_script;
 }
 
-
 void VisualScriptPropertyGet::_update_cache() {
 
-
-	if (call_mode==CALL_MODE_BASIC_TYPE) {
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
 
 		//not super efficient..
 
 		Variant v;
-		if (basic_type==Variant::INPUT_EVENT) {
+		if (basic_type == Variant::INPUT_EVENT) {
 			InputEvent ev;
-			ev.type=event_type;
-			v=ev;
+			ev.type = event_type;
+			v = ev;
 		} else {
 			Variant::CallError ce;
-			v = Variant::construct(basic_type,NULL,0,ce);
+			v = Variant::construct(basic_type, NULL, 0, ce);
 		}
 
 		List<PropertyInfo> pinfo;
 		v.get_property_list(&pinfo);
 
-		for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
+		for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
 
-			if (E->get().name==property) {
+			if (E->get().name == property) {
 
-				type_cache=E->get().type;
+				type_cache = E->get().type;
 				return;
 			}
 		}
 
 	} else {
 
-
 		StringName type;
 		Ref<Script> script;
-		Node *node=NULL;
+		Node *node = NULL;
 
-		if (call_mode==CALL_MODE_NODE_PATH) {
+		if (call_mode == CALL_MODE_NODE_PATH) {
 
-			node=_get_base_node();
+			node = _get_base_node();
 			if (node) {
-				type=node->get_class();
-				base_type=type; //cache, too
+				type = node->get_class();
+				base_type = type; //cache, too
 				script = node->get_script();
 			}
-		} else if (call_mode==CALL_MODE_SELF) {
+		} else if (call_mode == CALL_MODE_SELF) {
 
 			if (get_visual_script().is_valid()) {
-				type=get_visual_script()->get_instance_base_type();
-				base_type=type; //cache, too
-				script=get_visual_script();
+				type = get_visual_script()->get_instance_base_type();
+				base_type = type; //cache, too
+				script = get_visual_script();
 			}
-		} else if (call_mode==CALL_MODE_INSTANCE) {
+		} else if (call_mode == CALL_MODE_INSTANCE) {
 
-			type=base_type;
-			if (base_script!=String()) {
+			type = base_type;
+			if (base_script != String()) {
 
 				if (!ResourceCache::has(base_script) && ScriptServer::edit_request_func) {
 
@@ -1920,53 +1817,51 @@ void VisualScriptPropertyGet::_update_cache() {
 
 				if (ResourceCache::has(base_script)) {
 
-					script = Ref<Resource>( ResourceCache::get(base_script) );
+					script = Ref<Resource>(ResourceCache::get(base_script));
 				} else {
 					return;
 				}
 			}
 		}
 
-
-		bool valid=false;
+		bool valid = false;
 
 		Variant::Type type_ret;
 
-		type_ret=ClassDB::get_property_type(base_type,property,&valid);
+		type_ret = ClassDB::get_property_type(base_type, property, &valid);
 
 		if (valid) {
-			type_cache=type_ret;
+			type_cache = type_ret;
 			return; //all dandy
 		}
 
 		if (node) {
 
-			Variant prop = node->get(property,&valid);
+			Variant prop = node->get(property, &valid);
 			if (valid) {
-				type_cache=prop.get_type();
+				type_cache = prop.get_type();
 				return; //all dandy again
 			}
 		}
 
 		if (script.is_valid()) {
 
-			type_ret=script->get_static_property_type(property,&valid);
+			type_ret = script->get_static_property_type(property, &valid);
 
 			if (valid) {
-				type_cache=type_ret;
+				type_cache = type_ret;
 				return; //all dandy
 			}
 		}
 	}
 }
 
-void VisualScriptPropertyGet::set_property(const StringName& p_type){
+void VisualScriptPropertyGet::set_property(const StringName &p_type) {
 
-	if (property==p_type)
+	if (property == p_type)
 		return;
 
-	property=p_type;
-
+	property = p_type;
 
 	_update_cache();
 	_change_notify();
@@ -1974,16 +1869,15 @@ void VisualScriptPropertyGet::set_property(const StringName& p_type){
 }
 StringName VisualScriptPropertyGet::get_property() const {
 
-
 	return property;
 }
 
-void VisualScriptPropertyGet::set_base_path(const NodePath& p_type) {
+void VisualScriptPropertyGet::set_base_path(const NodePath &p_type) {
 
-	if (base_path==p_type)
+	if (base_path == p_type)
 		return;
 
-	base_path=p_type;
+	base_path = p_type;
 	_change_notify();
 	_update_base_type();
 	ports_changed_notify();
@@ -1994,48 +1888,42 @@ NodePath VisualScriptPropertyGet::get_base_path() const {
 	return base_path;
 }
 
-
 void VisualScriptPropertyGet::set_call_mode(CallMode p_mode) {
 
-	if (call_mode==p_mode)
+	if (call_mode == p_mode)
 		return;
 
-	call_mode=p_mode;
+	call_mode = p_mode;
 	_change_notify();
 	_update_base_type();
 	ports_changed_notify();
-
 }
 VisualScriptPropertyGet::CallMode VisualScriptPropertyGet::get_call_mode() const {
 
 	return call_mode;
 }
 
-
-
 void VisualScriptPropertyGet::set_basic_type(Variant::Type p_type) {
 
-	if (basic_type==p_type)
+	if (basic_type == p_type)
 		return;
-	basic_type=p_type;
-
+	basic_type = p_type;
 
 	_change_notify();
 	ports_changed_notify();
 }
 
-Variant::Type VisualScriptPropertyGet::get_basic_type() const{
+Variant::Type VisualScriptPropertyGet::get_basic_type() const {
 
 	return basic_type;
 }
 
-
 void VisualScriptPropertyGet::set_event_type(InputEvent::Type p_type) {
 
-	if (event_type==p_type)
+	if (event_type == p_type)
 		return;
-	event_type=p_type;
-	if(call_mode==CALL_MODE_BASIC_TYPE) {
+	event_type = p_type;
+	if (call_mode == CALL_MODE_BASIC_TYPE) {
 		_update_cache();
 	}
 	_change_notify();
@@ -2043,14 +1931,13 @@ void VisualScriptPropertyGet::set_event_type(InputEvent::Type p_type) {
 	ports_changed_notify();
 }
 
-InputEvent::Type VisualScriptPropertyGet::get_event_type() const{
+InputEvent::Type VisualScriptPropertyGet::get_event_type() const {
 
 	return event_type;
 }
 
-
 void VisualScriptPropertyGet::_set_type_cache(Variant::Type p_type) {
-	type_cache=p_type;
+	type_cache = p_type;
 }
 
 Variant::Type VisualScriptPropertyGet::_get_type_cache() const {
@@ -2058,61 +1945,59 @@ Variant::Type VisualScriptPropertyGet::_get_type_cache() const {
 	return type_cache;
 }
 
+void VisualScriptPropertyGet::_validate_property(PropertyInfo &property) const {
 
-void VisualScriptPropertyGet::_validate_property(PropertyInfo& property) const {
-
-	if (property.name=="property/base_type") {
-		if (call_mode!=CALL_MODE_INSTANCE) {
-			property.usage=PROPERTY_USAGE_NOEDITOR;
+	if (property.name == "property/base_type") {
+		if (call_mode != CALL_MODE_INSTANCE) {
+			property.usage = PROPERTY_USAGE_NOEDITOR;
 		}
 	}
 
-	if (property.name=="property/base_script") {
-		if (call_mode!=CALL_MODE_INSTANCE) {
-			property.usage=0;
+	if (property.name == "property/base_script") {
+		if (call_mode != CALL_MODE_INSTANCE) {
+			property.usage = 0;
 		}
 	}
 
-	if (property.name=="property/basic_type") {
-		if (call_mode!=CALL_MODE_BASIC_TYPE) {
-			property.usage=0;
+	if (property.name == "property/basic_type") {
+		if (call_mode != CALL_MODE_BASIC_TYPE) {
+			property.usage = 0;
 		}
 	}
-	if (property.name=="property/event_type") {
-		if (call_mode!=CALL_MODE_BASIC_TYPE || basic_type!=Variant::INPUT_EVENT) {
-			property.usage=0;
+	if (property.name == "property/event_type") {
+		if (call_mode != CALL_MODE_BASIC_TYPE || basic_type != Variant::INPUT_EVENT) {
+			property.usage = 0;
 		}
 	}
 
-	if (property.name=="property/node_path") {
-		if (call_mode!=CALL_MODE_NODE_PATH) {
-			property.usage=0;
+	if (property.name == "property/node_path") {
+		if (call_mode != CALL_MODE_NODE_PATH) {
+			property.usage = 0;
 		} else {
 
 			Node *bnode = _get_base_node();
 			if (bnode) {
-				property.hint_string=bnode->get_path(); //convert to loong string
+				property.hint_string = bnode->get_path(); //convert to loong string
 			} else {
-
 			}
 		}
 	}
 
-	if (property.name=="property/property") {
+	if (property.name == "property/property") {
 
-		if (call_mode==CALL_MODE_BASIC_TYPE) {
+		if (call_mode == CALL_MODE_BASIC_TYPE) {
 
-			property.hint=PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE;
-			property.hint_string=Variant::get_type_name(basic_type);
+			property.hint = PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE;
+			property.hint_string = Variant::get_type_name(basic_type);
 
-		} else if (call_mode==CALL_MODE_SELF && get_visual_script().is_valid()) {
-			property.hint=PROPERTY_HINT_PROPERTY_OF_SCRIPT;
-			property.hint_string=itos(get_visual_script()->get_instance_ID());
-		} else if (call_mode==CALL_MODE_INSTANCE) {
-			property.hint=PROPERTY_HINT_PROPERTY_OF_BASE_TYPE;
-			property.hint_string=base_type;
+		} else if (call_mode == CALL_MODE_SELF && get_visual_script().is_valid()) {
+			property.hint = PROPERTY_HINT_PROPERTY_OF_SCRIPT;
+			property.hint_string = itos(get_visual_script()->get_instance_ID());
+		} else if (call_mode == CALL_MODE_INSTANCE) {
+			property.hint = PROPERTY_HINT_PROPERTY_OF_BASE_TYPE;
+			property.hint_string = base_type;
 
-			if (base_script!=String()) {
+			if (base_script != String()) {
 				if (!ResourceCache::has(base_script) && ScriptServer::edit_request_func) {
 
 					ScriptServer::edit_request_func(base_script); //make sure it's loaded
@@ -2120,103 +2005,97 @@ void VisualScriptPropertyGet::_validate_property(PropertyInfo& property) const {
 
 				if (ResourceCache::has(base_script)) {
 
-					Ref<Script> script = Ref<Resource>( ResourceCache::get(base_script) );
+					Ref<Script> script = Ref<Resource>(ResourceCache::get(base_script));
 					if (script.is_valid()) {
 
-						property.hint=PROPERTY_HINT_PROPERTY_OF_SCRIPT;
-						property.hint_string=itos(script->get_instance_ID());
+						property.hint = PROPERTY_HINT_PROPERTY_OF_SCRIPT;
+						property.hint_string = itos(script->get_instance_ID());
 					}
 				}
 			}
-		} else if (call_mode==CALL_MODE_NODE_PATH) {
+		} else if (call_mode == CALL_MODE_NODE_PATH) {
 			Node *node = _get_base_node();
 			if (node) {
-				property.hint=PROPERTY_HINT_PROPERTY_OF_INSTANCE;
-				property.hint_string=itos(node->get_instance_ID());
+				property.hint = PROPERTY_HINT_PROPERTY_OF_INSTANCE;
+				property.hint_string = itos(node->get_instance_ID());
 			} else {
-				property.hint=PROPERTY_HINT_PROPERTY_OF_BASE_TYPE;
-				property.hint_string=get_base_type();
+				property.hint = PROPERTY_HINT_PROPERTY_OF_BASE_TYPE;
+				property.hint_string = get_base_type();
 			}
-
 		}
-
 	}
-
 }
 
 void VisualScriptPropertyGet::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_base_type","base_type"),&VisualScriptPropertyGet::set_base_type);
-	ClassDB::bind_method(D_METHOD("get_base_type"),&VisualScriptPropertyGet::get_base_type);
-
-	ClassDB::bind_method(D_METHOD("set_base_script","base_script"),&VisualScriptPropertyGet::set_base_script);
-	ClassDB::bind_method(D_METHOD("get_base_script"),&VisualScriptPropertyGet::get_base_script);
+	ClassDB::bind_method(D_METHOD("set_base_type", "base_type"), &VisualScriptPropertyGet::set_base_type);
+	ClassDB::bind_method(D_METHOD("get_base_type"), &VisualScriptPropertyGet::get_base_type);
 
-	ClassDB::bind_method(D_METHOD("set_basic_type","basic_type"),&VisualScriptPropertyGet::set_basic_type);
-	ClassDB::bind_method(D_METHOD("get_basic_type"),&VisualScriptPropertyGet::get_basic_type);
+	ClassDB::bind_method(D_METHOD("set_base_script", "base_script"), &VisualScriptPropertyGet::set_base_script);
+	ClassDB::bind_method(D_METHOD("get_base_script"), &VisualScriptPropertyGet::get_base_script);
 
-	ClassDB::bind_method(D_METHOD("_set_type_cache","type_cache"),&VisualScriptPropertyGet::_set_type_cache);
-	ClassDB::bind_method(D_METHOD("_get_type_cache"),&VisualScriptPropertyGet::_get_type_cache);
+	ClassDB::bind_method(D_METHOD("set_basic_type", "basic_type"), &VisualScriptPropertyGet::set_basic_type);
+	ClassDB::bind_method(D_METHOD("get_basic_type"), &VisualScriptPropertyGet::get_basic_type);
 
-	ClassDB::bind_method(D_METHOD("set_event_type","event_type"),&VisualScriptPropertyGet::set_event_type);
-	ClassDB::bind_method(D_METHOD("get_event_type"),&VisualScriptPropertyGet::get_event_type);
+	ClassDB::bind_method(D_METHOD("_set_type_cache", "type_cache"), &VisualScriptPropertyGet::_set_type_cache);
+	ClassDB::bind_method(D_METHOD("_get_type_cache"), &VisualScriptPropertyGet::_get_type_cache);
 
+	ClassDB::bind_method(D_METHOD("set_event_type", "event_type"), &VisualScriptPropertyGet::set_event_type);
+	ClassDB::bind_method(D_METHOD("get_event_type"), &VisualScriptPropertyGet::get_event_type);
 
-	ClassDB::bind_method(D_METHOD("set_property","property"),&VisualScriptPropertyGet::set_property);
-	ClassDB::bind_method(D_METHOD("get_property"),&VisualScriptPropertyGet::get_property);
+	ClassDB::bind_method(D_METHOD("set_property", "property"), &VisualScriptPropertyGet::set_property);
+	ClassDB::bind_method(D_METHOD("get_property"), &VisualScriptPropertyGet::get_property);
 
-	ClassDB::bind_method(D_METHOD("set_call_mode","mode"),&VisualScriptPropertyGet::set_call_mode);
-	ClassDB::bind_method(D_METHOD("get_call_mode"),&VisualScriptPropertyGet::get_call_mode);
+	ClassDB::bind_method(D_METHOD("set_call_mode", "mode"), &VisualScriptPropertyGet::set_call_mode);
+	ClassDB::bind_method(D_METHOD("get_call_mode"), &VisualScriptPropertyGet::get_call_mode);
 
-	ClassDB::bind_method(D_METHOD("set_base_path","base_path"),&VisualScriptPropertyGet::set_base_path);
-	ClassDB::bind_method(D_METHOD("get_base_path"),&VisualScriptPropertyGet::get_base_path);
+	ClassDB::bind_method(D_METHOD("set_base_path", "base_path"), &VisualScriptPropertyGet::set_base_path);
+	ClassDB::bind_method(D_METHOD("get_base_path"), &VisualScriptPropertyGet::get_base_path);
 
 	String bt;
-	for(int i=0;i<Variant::VARIANT_MAX;i++) {
-		if (i>0)
-			bt+=",";
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		if (i > 0)
+			bt += ",";
 
-		bt+=Variant::get_type_name(Variant::Type(i));
+		bt += Variant::get_type_name(Variant::Type(i));
 	}
 
 	String et;
-	for(int i=0;i<InputEvent::TYPE_MAX;i++) {
-		if (i>0)
-			et+=",";
+	for (int i = 0; i < InputEvent::TYPE_MAX; i++) {
+		if (i > 0)
+			et += ",";
 
-		et+=event_type_names[i];
+		et += event_type_names[i];
 	}
 
 	List<String> script_extensions;
-	for(int i=0;i<ScriptServer::get_language_count();i++) {
+	for (int i = 0; i < ScriptServer::get_language_count(); i++) {
 		ScriptServer::get_language(i)->get_recognized_extensions(&script_extensions);
 	}
 
 	String script_ext_hint;
-	for (List<String>::Element *E=script_extensions.front();E;E=E->next()) {
-		if (script_ext_hint!=String())
-			script_ext_hint+=",";
-		script_ext_hint+="."+E->get();
+	for (List<String>::Element *E = script_extensions.front(); E; E = E->next()) {
+		if (script_ext_hint != String())
+			script_ext_hint += ",";
+		script_ext_hint += "." + E->get();
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"property/set_mode",PROPERTY_HINT_ENUM,"Self,Node Path,Instance,Basic Type"),"set_call_mode","get_call_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"property/base_type",PROPERTY_HINT_TYPE_STRING,"Object"),"set_base_type","get_base_type");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"property/base_script",PROPERTY_HINT_FILE,script_ext_hint),"set_base_script","get_base_script");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"property/type_cache",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"_set_type_cache","_get_type_cache");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"property/basic_type",PROPERTY_HINT_ENUM,bt),"set_basic_type","get_basic_type");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"property/event_type",PROPERTY_HINT_ENUM,et),"set_event_type","get_event_type");
-	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"property/node_path",PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE),"set_base_path","get_base_path");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"property/property"),"set_property","get_property");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "property/set_mode", PROPERTY_HINT_ENUM, "Self,Node Path,Instance,Basic Type"), "set_call_mode", "get_call_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/base_type", PROPERTY_HINT_TYPE_STRING, "Object"), "set_base_type", "get_base_type");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/base_script", PROPERTY_HINT_FILE, script_ext_hint), "set_base_script", "get_base_script");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "property/type_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_type_cache", "_get_type_cache");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "property/basic_type", PROPERTY_HINT_ENUM, bt), "set_basic_type", "get_basic_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "property/event_type", PROPERTY_HINT_ENUM, et), "set_event_type", "get_event_type");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "property/node_path", PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE), "set_base_path", "get_base_path");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/property"), "set_property", "get_property");
 
-	BIND_CONSTANT( CALL_MODE_SELF );
-	BIND_CONSTANT( CALL_MODE_NODE_PATH);
-	BIND_CONSTANT( CALL_MODE_INSTANCE);
+	BIND_CONSTANT(CALL_MODE_SELF);
+	BIND_CONSTANT(CALL_MODE_NODE_PATH);
+	BIND_CONSTANT(CALL_MODE_INSTANCE);
 }
 
 class VisualScriptNodeInstancePropertyGet : public VisualScriptNodeInstance {
 public:
-
-
 	VisualScriptPropertyGet::CallMode call_mode;
 	NodePath node_path;
 	StringName property;
@@ -2224,51 +2103,47 @@ public:
 	VisualScriptPropertyGet *node;
 	VisualScriptInstance *instance;
 
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
-
-
-
-		switch(call_mode) {
+		switch (call_mode) {
 
 			case VisualScriptPropertyGet::CALL_MODE_SELF: {
 
-				Object *object=instance->get_owner_ptr();
+				Object *object = instance->get_owner_ptr();
 
 				bool valid;
 
-				*p_outputs[0] = object->get(property,&valid);
+				*p_outputs[0] = object->get(property, &valid);
 
 				if (!valid) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str=RTR("Invalid index property name.");
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = RTR("Invalid index property name.");
 					return 0;
 				}
 			} break;
 			case VisualScriptPropertyGet::CALL_MODE_NODE_PATH: {
 
-				Node* node = instance->get_owner_ptr()->cast_to<Node>();
+				Node *node = instance->get_owner_ptr()->cast_to<Node>();
 				if (!node) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str=RTR("Base object is not a Node!");
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = RTR("Base object is not a Node!");
 					return 0;
 				}
 
-				Node* another = node->get_node(node_path);
+				Node *another = node->get_node(node_path);
 				if (!node) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str=RTR("Path does not lead Node!");
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = RTR("Path does not lead Node!");
 					return 0;
 				}
 
 				bool valid;
 
-
-				*p_outputs[0] = another->get(property,&valid);
+				*p_outputs[0] = another->get(property, &valid);
 
 				if (!valid) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str=vformat(RTR("Invalid index property name '%s' in node %s."),String(property),another->get_name());
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = vformat(RTR("Invalid index property name '%s' in node %s."), String(property), another->get_name());
 					return 0;
 				}
 
@@ -2278,48 +2153,42 @@ public:
 				bool valid;
 				Variant v = *p_inputs[0];
 
-				*p_outputs[0] = v.get(property,&valid);
+				*p_outputs[0] = v.get(property, &valid);
 
 				if (!valid) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str=RTR("Invalid index property name.");
-
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str = RTR("Invalid index property name.");
 				}
 			};
 		}
 
 		return 0;
 	}
-
-
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptPropertyGet::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptPropertyGet::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstancePropertyGet * instance = memnew(VisualScriptNodeInstancePropertyGet );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->property=property;
-	instance->call_mode=call_mode;
-	instance->node_path=base_path;
+	VisualScriptNodeInstancePropertyGet *instance = memnew(VisualScriptNodeInstancePropertyGet);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->property = property;
+	instance->call_mode = call_mode;
+	instance->node_path = base_path;
 
 	return instance;
 }
 
 VisualScriptPropertyGet::VisualScriptPropertyGet() {
 
-	call_mode=CALL_MODE_SELF;
-	base_type="Object";
-	basic_type=Variant::NIL;
-	event_type=InputEvent::NONE;
-	type_cache=Variant::NIL;
-
+	call_mode = CALL_MODE_SELF;
+	base_type = "Object";
+	basic_type = Variant::NIL;
+	event_type = InputEvent::NONE;
+	type_cache = Variant::NIL;
 }
 
-template<VisualScriptPropertyGet::CallMode cmode>
-static Ref<VisualScriptNode> create_property_get_node(const String& p_name) {
+template <VisualScriptPropertyGet::CallMode cmode>
+static Ref<VisualScriptNode> create_property_get_node(const String &p_name) {
 
 	Ref<VisualScriptPropertyGet> node;
 	node.instance();
@@ -2327,7 +2196,6 @@ static Ref<VisualScriptNode> create_property_get_node(const String& p_name) {
 	return node;
 }
 
-
 //////////////////////////////////////////
 ////////////////EMIT//////////////////////
 //////////////////////////////////////////
@@ -2337,13 +2205,12 @@ int VisualScriptEmitSignal::get_output_sequence_port_count() const {
 	return 1;
 }
 
-bool VisualScriptEmitSignal::has_input_sequence_port() const{
+bool VisualScriptEmitSignal::has_input_sequence_port() const {
 
 	return true;
 }
 
-
-int VisualScriptEmitSignal::get_input_value_port_count() const{
+int VisualScriptEmitSignal::get_input_value_port_count() const {
 
 	Ref<VisualScript> vs = get_visual_script();
 	if (vs.is_valid()) {
@@ -2355,9 +2222,8 @@ int VisualScriptEmitSignal::get_input_value_port_count() const{
 	}
 
 	return 0;
-
 }
-int VisualScriptEmitSignal::get_output_value_port_count() const{
+int VisualScriptEmitSignal::get_output_value_port_count() const {
 	return 0;
 }
 
@@ -2366,7 +2232,7 @@ String VisualScriptEmitSignal::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptEmitSignal::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptEmitSignal::get_input_value_port_info(int p_idx) const {
 
 	Ref<VisualScript> vs = get_visual_script();
 	if (vs.is_valid()) {
@@ -2374,19 +2240,17 @@ PropertyInfo VisualScriptEmitSignal::get_input_value_port_info(int p_idx) const{
 		if (!vs->has_custom_signal(name))
 			return PropertyInfo();
 
-		return PropertyInfo(vs->custom_signal_get_argument_type(name,p_idx),vs->custom_signal_get_argument_name(name,p_idx));
+		return PropertyInfo(vs->custom_signal_get_argument_type(name, p_idx), vs->custom_signal_get_argument_name(name, p_idx));
 	}
 
 	return PropertyInfo();
-
 }
 
-PropertyInfo VisualScriptEmitSignal::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptEmitSignal::get_output_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-
 String VisualScriptEmitSignal::get_caption() const {
 
 	return "EmitSignal";
@@ -2394,35 +2258,28 @@ String VisualScriptEmitSignal::get_caption() const {
 
 String VisualScriptEmitSignal::get_text() const {
 
-	return "emit "+String(name);
+	return "emit " + String(name);
 }
 
+void VisualScriptEmitSignal::set_signal(const StringName &p_type) {
 
-
-void VisualScriptEmitSignal::set_signal(const StringName& p_type){
-
-	if (name==p_type)
+	if (name == p_type)
 		return;
 
-	name=p_type;
+	name = p_type;
 
 	_change_notify();
 	ports_changed_notify();
 }
 StringName VisualScriptEmitSignal::get_signal() const {
 
-
 	return name;
 }
 
+void VisualScriptEmitSignal::_validate_property(PropertyInfo &property) const {
 
-void VisualScriptEmitSignal::_validate_property(PropertyInfo& property) const {
-
-
-
-	if (property.name=="signal/signal") {
-		property.hint=PROPERTY_HINT_ENUM;
-
+	if (property.name == "signal/signal") {
+		property.hint = PROPERTY_HINT_ENUM;
 
 		List<StringName> sigs;
 
@@ -2430,37 +2287,30 @@ void VisualScriptEmitSignal::_validate_property(PropertyInfo& property) const {
 		if (vs.is_valid()) {
 
 			vs->get_custom_signal_list(&sigs);
-
 		}
 
 		String ml;
-		for (List<StringName>::Element *E=sigs.front();E;E=E->next()) {
+		for (List<StringName>::Element *E = sigs.front(); E; E = E->next()) {
 
-			if (ml!=String())
-				ml+=",";
-			ml+=E->get();
+			if (ml != String())
+				ml += ",";
+			ml += E->get();
 		}
 
-		property.hint_string=ml;
+		property.hint_string = ml;
 	}
-
 }
 
-
 void VisualScriptEmitSignal::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_signal","name"),&VisualScriptEmitSignal::set_signal);
-	ClassDB::bind_method(D_METHOD("get_signal"),&VisualScriptEmitSignal::get_signal);
-
-
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"signal/signal"),"set_signal","get_signal");
-
+	ClassDB::bind_method(D_METHOD("set_signal", "name"), &VisualScriptEmitSignal::set_signal);
+	ClassDB::bind_method(D_METHOD("get_signal"), &VisualScriptEmitSignal::get_signal);
 
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "signal/signal"), "set_signal", "get_signal");
 }
 
 class VisualScriptNodeInstanceEmitSignal : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptEmitSignal *node;
 	VisualScriptInstance *instance;
 	int argcount;
@@ -2470,57 +2320,50 @@ public:
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
-
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		Object *obj = instance->get_owner_ptr();
 
-		obj->emit_signal(name,p_inputs,argcount);
-
+		obj->emit_signal(name, p_inputs, argcount);
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptEmitSignal::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptEmitSignal::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceEmitSignal * instance = memnew(VisualScriptNodeInstanceEmitSignal );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->name=name;
-	instance->argcount=get_input_value_port_count();
+	VisualScriptNodeInstanceEmitSignal *instance = memnew(VisualScriptNodeInstanceEmitSignal);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->name = name;
+	instance->argcount = get_input_value_port_count();
 	return instance;
 }
 
 VisualScriptEmitSignal::VisualScriptEmitSignal() {
 }
 
-
-
-static Ref<VisualScriptNode> create_basic_type_call_node(const String& p_name) {
+static Ref<VisualScriptNode> create_basic_type_call_node(const String &p_name) {
 
 	Vector<String> path = p_name.split("/");
-	ERR_FAIL_COND_V(path.size()<4,Ref<VisualScriptNode>());
+	ERR_FAIL_COND_V(path.size() < 4, Ref<VisualScriptNode>());
 	String base_type = path[2];
 	String method = path[3];
 
 	Ref<VisualScriptFunctionCall> node;
 	node.instance();
 
-	Variant::Type type=Variant::VARIANT_MAX;
+	Variant::Type type = Variant::VARIANT_MAX;
 
-	for(int i=0;i<Variant::VARIANT_MAX;i++) {
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
 
-		if (Variant::get_type_name(Variant::Type(i))==base_type) {
-			type=Variant::Type(i);
+		if (Variant::get_type_name(Variant::Type(i)) == base_type) {
+			type = Variant::Type(i);
 			break;
 		}
 	}
 
-	ERR_FAIL_COND_V(type==Variant::VARIANT_MAX,Ref<VisualScriptNode>());
-
+	ERR_FAIL_COND_V(type == Variant::VARIANT_MAX, Ref<VisualScriptNode>());
 
 	node->set_call_mode(VisualScriptFunctionCall::CALL_MODE_BASIC_TYPE);
 	node->set_basic_type(type);
@@ -2529,29 +2372,27 @@ static Ref<VisualScriptNode> create_basic_type_call_node(const String& p_name) {
 	return node;
 }
 
-
 void register_visual_script_func_nodes() {
 
-	VisualScriptLanguage::singleton->add_register_func("functions/call",create_node_generic<VisualScriptFunctionCall>);
-	VisualScriptLanguage::singleton->add_register_func("functions/set",create_node_generic<VisualScriptPropertySet>);
-	VisualScriptLanguage::singleton->add_register_func("functions/get",create_node_generic<VisualScriptPropertyGet>);
+	VisualScriptLanguage::singleton->add_register_func("functions/call", create_node_generic<VisualScriptFunctionCall>);
+	VisualScriptLanguage::singleton->add_register_func("functions/set", create_node_generic<VisualScriptPropertySet>);
+	VisualScriptLanguage::singleton->add_register_func("functions/get", create_node_generic<VisualScriptPropertyGet>);
 
 	//VisualScriptLanguage::singleton->add_register_func("functions/call_script/call_self",create_script_call_node<VisualScriptScriptCall::CALL_MODE_SELF>);
 	//VisualScriptLanguage::singleton->add_register_func("functions/call_script/call_node",create_script_call_node<VisualScriptScriptCall::CALL_MODE_NODE_PATH>);
-	VisualScriptLanguage::singleton->add_register_func("functions/emit_signal",create_node_generic<VisualScriptEmitSignal>);
-
+	VisualScriptLanguage::singleton->add_register_func("functions/emit_signal", create_node_generic<VisualScriptEmitSignal>);
 
-	for(int i=0;i<Variant::VARIANT_MAX;i++) {
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
 
 		Variant::Type t = Variant::Type(i);
 		String type_name = Variant::get_type_name(t);
 		Variant::CallError ce;
-		Variant vt = Variant::construct(t,NULL,0,ce);
+		Variant vt = Variant::construct(t, NULL, 0, ce);
 		List<MethodInfo> ml;
 		vt.get_method_list(&ml);
 
-		for (List<MethodInfo>::Element *E=ml.front();E;E=E->next()) {
-			VisualScriptLanguage::singleton->add_register_func("functions/by_type/"+type_name+"/"+E->get().name,create_basic_type_call_node);
+		for (List<MethodInfo>::Element *E = ml.front(); E; E = E->next()) {
+			VisualScriptLanguage::singleton->add_register_func("functions/by_type/" + type_name + "/" + E->get().name, create_basic_type_call_node);
 		}
 	}
 }
diff --git a/modules/visual_script/visual_script_func_nodes.h b/modules/visual_script/visual_script_func_nodes.h
index 7c1d4511cb..3f82edc5f0 100644
--- a/modules/visual_script/visual_script_func_nodes.h
+++ b/modules/visual_script/visual_script_func_nodes.h
@@ -31,10 +31,9 @@
 
 #include "visual_script.h"
 
-
 class VisualScriptFunctionCall : public VisualScriptNode {
 
-	GDCLASS(VisualScriptFunctionCall,VisualScriptNode)
+	GDCLASS(VisualScriptFunctionCall, VisualScriptNode)
 public:
 	enum CallMode {
 		CALL_MODE_SELF,
@@ -53,7 +52,6 @@ public:
 	};
 
 private:
-
 	CallMode call_mode;
 	StringName base_type;
 	String base_script;
@@ -65,34 +63,29 @@ private:
 	StringName singleton;
 	bool validate;
 
-
 	Node *_get_base_node() const;
 	StringName _get_base_type() const;
 
 	MethodInfo method_cache;
 	void _update_method_cache();
 
-	void _set_argument_cache(const Dictionary& p_args);
+	void _set_argument_cache(const Dictionary &p_args);
 	Dictionary _get_argument_cache() const;
 
 protected:
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 	static void _bind_methods();
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -103,22 +96,21 @@ public:
 	void set_basic_type(Variant::Type p_type);
 	Variant::Type get_basic_type() const;
 
-	void set_base_type(const StringName& p_type);
+	void set_base_type(const StringName &p_type);
 	StringName get_base_type() const;
 
-	void set_base_script(const String& p_path);
+	void set_base_script(const String &p_path);
 	String get_base_script() const;
 
-	void set_singleton(const StringName& p_type);
+	void set_singleton(const StringName &p_type);
 	StringName get_singleton() const;
 
-	void set_function(const StringName& p_type);
+	void set_function(const StringName &p_type);
 	StringName get_function() const;
 
-	void set_base_path(const NodePath& p_type);
+	void set_base_path(const NodePath &p_type);
 	NodePath get_base_path() const;
 
-
 	void set_call_mode(CallMode p_mode);
 	CallMode get_call_mode() const;
 
@@ -131,21 +123,19 @@ public:
 	void set_rpc_call_mode(RPCCallMode p_mode);
 	RPCCallMode get_rpc_call_mode() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
-
-	virtual TypeGuess guess_output_type(TypeGuess* p_inputs, int p_output) const;
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
+	virtual TypeGuess guess_output_type(TypeGuess *p_inputs, int p_output) const;
 
 	VisualScriptFunctionCall();
 };
 
-VARIANT_ENUM_CAST(VisualScriptFunctionCall::CallMode );
-VARIANT_ENUM_CAST(VisualScriptFunctionCall::RPCCallMode );
-
+VARIANT_ENUM_CAST(VisualScriptFunctionCall::CallMode);
+VARIANT_ENUM_CAST(VisualScriptFunctionCall::RPCCallMode);
 
 class VisualScriptPropertySet : public VisualScriptNode {
 
-	GDCLASS(VisualScriptPropertySet,VisualScriptNode)
+	GDCLASS(VisualScriptPropertySet, VisualScriptNode)
 public:
 	enum CallMode {
 		CALL_MODE_SELF,
@@ -153,14 +143,13 @@ public:
 		CALL_MODE_INSTANCE,
 		CALL_MODE_BASIC_TYPE,
 
-
 	};
-private:
 
+private:
 	PropertyInfo type_cache;
 
 	CallMode call_mode;
-	Variant::Type basic_type;	
+	Variant::Type basic_type;
 	StringName base_type;
 	String base_script;
 	NodePath base_path;
@@ -174,28 +163,23 @@ private:
 
 	void _update_cache();
 
-	void _set_type_cache(const Dictionary& p_type);
+	void _set_type_cache(const Dictionary &p_type);
 	Dictionary _get_type_cache() const;
 
-
 protected:
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 	static void _bind_methods();
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -203,10 +187,10 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "functions"; }
 
-	void set_base_type(const StringName& p_type);
+	void set_base_type(const StringName &p_type);
 	StringName get_base_type() const;
 
-	void set_base_script(const String& p_path);
+	void set_base_script(const String &p_path);
 	String get_base_script() const;
 
 	void set_basic_type(Variant::Type p_type);
@@ -215,28 +199,26 @@ public:
 	void set_event_type(InputEvent::Type p_type);
 	InputEvent::Type get_event_type() const;
 
-	void set_property(const StringName& p_type);
+	void set_property(const StringName &p_type);
 	StringName get_property() const;
 
-	void set_base_path(const NodePath& p_type);
+	void set_base_path(const NodePath &p_type);
 	NodePath get_base_path() const;
 
 	void set_call_mode(CallMode p_mode);
 	CallMode get_call_mode() const;
 
-
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
-	virtual TypeGuess guess_output_type(TypeGuess* p_inputs, int p_output) const;
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
+	virtual TypeGuess guess_output_type(TypeGuess *p_inputs, int p_output) const;
 
 	VisualScriptPropertySet();
 };
 
-VARIANT_ENUM_CAST(VisualScriptPropertySet::CallMode );
-
+VARIANT_ENUM_CAST(VisualScriptPropertySet::CallMode);
 
 class VisualScriptPropertyGet : public VisualScriptNode {
 
-	GDCLASS(VisualScriptPropertyGet,VisualScriptNode)
+	GDCLASS(VisualScriptPropertyGet, VisualScriptNode)
 public:
 	enum CallMode {
 		CALL_MODE_SELF,
@@ -245,8 +227,8 @@ public:
 		CALL_MODE_BASIC_TYPE,
 
 	};
-private:
 
+private:
 	Variant::Type type_cache;
 
 	CallMode call_mode;
@@ -267,23 +249,19 @@ private:
 	Variant::Type _get_type_cache() const;
 
 protected:
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 	static void _bind_methods();
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -291,10 +269,10 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "functions"; }
 
-	void set_base_type(const StringName& p_type);
+	void set_base_type(const StringName &p_type);
 	StringName get_base_type() const;
 
-	void set_base_script(const String& p_path);
+	void set_base_script(const String &p_path);
 	String get_base_script() const;
 
 	void set_basic_type(Variant::Type p_type);
@@ -303,55 +281,43 @@ public:
 	void set_event_type(InputEvent::Type p_type);
 	InputEvent::Type get_event_type() const;
 
-	void set_property(const StringName& p_type);
+	void set_property(const StringName &p_type);
 	StringName get_property() const;
 
-	void set_base_path(const NodePath& p_type);
+	void set_base_path(const NodePath &p_type);
 	NodePath get_base_path() const;
 
 	void set_call_mode(CallMode p_mode);
 	CallMode get_call_mode() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptPropertyGet();
 };
 
-
-
-
-
-VARIANT_ENUM_CAST(VisualScriptPropertyGet::CallMode );
-
-
+VARIANT_ENUM_CAST(VisualScriptPropertyGet::CallMode);
 
 class VisualScriptEmitSignal : public VisualScriptNode {
 
-	GDCLASS(VisualScriptEmitSignal,VisualScriptNode)
+	GDCLASS(VisualScriptEmitSignal, VisualScriptNode)
 
 private:
-
 	StringName name;
 
-
 protected:
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 	static void _bind_methods();
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -359,19 +325,14 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "functions"; }
 
-	void set_signal(const StringName& p_type);
+	void set_signal(const StringName &p_type);
 	StringName get_signal() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
-
-
-
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptEmitSignal();
 };
 
-
-
 void register_visual_script_func_nodes();
 
 #endif // VISUAL_SCRIPT_FUNC_NODES_H
diff --git a/modules/visual_script/visual_script_nodes.cpp b/modules/visual_script/visual_script_nodes.cpp
index 824dfe88a9..68bd1e6d4c 100644
--- a/modules/visual_script/visual_script_nodes.cpp
+++ b/modules/visual_script/visual_script_nodes.cpp
@@ -28,157 +28,146 @@
 /*************************************************************************/
 #include "visual_script_nodes.h"
 
-#include "global_constants.h"
 #include "global_config.h"
-#include "scene/main/scene_main_loop.h"
+#include "global_constants.h"
+#include "os/input.h"
 #include "os/os.h"
 #include "scene/main/node.h"
-#include "os/input.h"
+#include "scene/main/scene_main_loop.h"
 
 //////////////////////////////////////////
 ////////////////FUNCTION//////////////////
 //////////////////////////////////////////
 
+bool VisualScriptFunction::_set(const StringName &p_name, const Variant &p_value) {
 
-bool  VisualScriptFunction::_set(const StringName& p_name, const Variant& p_value) {
-
-
-	if (p_name=="argument_count") {
+	if (p_name == "argument_count") {
 
-		int new_argc=p_value;
+		int new_argc = p_value;
 		int argc = arguments.size();
-		if (argc==new_argc)
+		if (argc == new_argc)
 			return true;
 
 		arguments.resize(new_argc);
 
-		for(int i=argc;i<new_argc;i++) {
-			arguments[i].name="arg"+itos(i+1);
-			arguments[i].type=Variant::NIL;
+		for (int i = argc; i < new_argc; i++) {
+			arguments[i].name = "arg" + itos(i + 1);
+			arguments[i].type = Variant::NIL;
 		}
 		ports_changed_notify();
 		_change_notify();
 		return true;
 	}
 	if (String(p_name).begins_with("argument/")) {
-		int idx = String(p_name).get_slice("/",1).to_int()-1;
-		ERR_FAIL_INDEX_V(idx,arguments.size(),false);
-		String what = String(p_name).get_slice("/",2);
-		if (what=="type") {
+		int idx = String(p_name).get_slice("/", 1).to_int() - 1;
+		ERR_FAIL_INDEX_V(idx, arguments.size(), false);
+		String what = String(p_name).get_slice("/", 2);
+		if (what == "type") {
 
 			Variant::Type new_type = Variant::Type(int(p_value));
-			arguments[idx].type=new_type;
+			arguments[idx].type = new_type;
 			ports_changed_notify();
 
 			return true;
 		}
 
-		if (what=="name") {
+		if (what == "name") {
 
-			arguments[idx].name=p_value;
+			arguments[idx].name = p_value;
 			ports_changed_notify();
 			return true;
 		}
-
-
 	}
 
-	if (p_name=="stack/stackless") {
+	if (p_name == "stack/stackless") {
 		set_stack_less(p_value);
 		return true;
 	}
 
-	if (p_name=="stack/size") {
-		stack_size=p_value;
+	if (p_name == "stack/size") {
+		stack_size = p_value;
 		return true;
 	}
 
-	if (p_name=="rpc/mode") {
-		rpc_mode=ScriptInstance::RPCMode(int(p_value));
+	if (p_name == "rpc/mode") {
+		rpc_mode = ScriptInstance::RPCMode(int(p_value));
 		return true;
 	}
 
 	return false;
 }
 
-bool  VisualScriptFunction::_get(const StringName& p_name,Variant &r_ret) const {
+bool VisualScriptFunction::_get(const StringName &p_name, Variant &r_ret) const {
 
-
-	if (p_name=="argument_count") {
+	if (p_name == "argument_count") {
 		r_ret = arguments.size();
 		return true;
 	}
 	if (String(p_name).begins_with("argument/")) {
-		int idx = String(p_name).get_slice("/",1).to_int()-1;
-		ERR_FAIL_INDEX_V(idx,arguments.size(),false);
-		String what = String(p_name).get_slice("/",2);
-		if (what=="type") {
+		int idx = String(p_name).get_slice("/", 1).to_int() - 1;
+		ERR_FAIL_INDEX_V(idx, arguments.size(), false);
+		String what = String(p_name).get_slice("/", 2);
+		if (what == "type") {
 			r_ret = arguments[idx].type;
 			return true;
 		}
-		if (what=="name") {
+		if (what == "name") {
 			r_ret = arguments[idx].name;
 			return true;
 		}
-
-
-
 	}
 
-	if (p_name=="stack/stackless") {
-		r_ret=stack_less;
+	if (p_name == "stack/stackless") {
+		r_ret = stack_less;
 		return true;
 	}
 
-	if (p_name=="stack/size") {
-		r_ret=stack_size;
+	if (p_name == "stack/size") {
+		r_ret = stack_size;
 		return true;
 	}
 
-	if (p_name=="rpc/mode") {
-		r_ret=rpc_mode;
+	if (p_name == "rpc/mode") {
+		r_ret = rpc_mode;
 		return true;
 	}
 
 	return false;
 }
-void  VisualScriptFunction::_get_property_list( List<PropertyInfo> *p_list) const {
-
+void VisualScriptFunction::_get_property_list(List<PropertyInfo> *p_list) const {
 
-	p_list->push_back(PropertyInfo(Variant::INT,"argument_count",PROPERTY_HINT_RANGE,"0,256"));
-	String argt="Any";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	p_list->push_back(PropertyInfo(Variant::INT, "argument_count", PROPERTY_HINT_RANGE, "0,256"));
+	String argt = "Any";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-	for(int i=0;i<arguments.size();i++) {
-		p_list->push_back(PropertyInfo(Variant::INT,"argument/"+itos(i+1)+"/type",PROPERTY_HINT_ENUM,argt));
-		p_list->push_back(PropertyInfo(Variant::STRING,"argument/"+itos(i+1)+"/name"));
+	for (int i = 0; i < arguments.size(); i++) {
+		p_list->push_back(PropertyInfo(Variant::INT, "argument/" + itos(i + 1) + "/type", PROPERTY_HINT_ENUM, argt));
+		p_list->push_back(PropertyInfo(Variant::STRING, "argument/" + itos(i + 1) + "/name"));
 	}
 	if (!stack_less) {
-		p_list->push_back(PropertyInfo(Variant::INT,"stack/size",PROPERTY_HINT_RANGE,"1,100000"));
+		p_list->push_back(PropertyInfo(Variant::INT, "stack/size", PROPERTY_HINT_RANGE, "1,100000"));
 	}
-	p_list->push_back(PropertyInfo(Variant::BOOL,"stack/stackless"));
-	p_list->push_back(PropertyInfo(Variant::INT,"rpc/mode",PROPERTY_HINT_ENUM,"Disabled,Remote,Sync,Master,Slave"));
-
+	p_list->push_back(PropertyInfo(Variant::BOOL, "stack/stackless"));
+	p_list->push_back(PropertyInfo(Variant::INT, "rpc/mode", PROPERTY_HINT_ENUM, "Disabled,Remote,Sync,Master,Slave"));
 }
 
-
 int VisualScriptFunction::get_output_sequence_port_count() const {
 
 	return 1;
 }
 
-bool VisualScriptFunction::has_input_sequence_port() const{
+bool VisualScriptFunction::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptFunction::get_input_value_port_count() const{
+int VisualScriptFunction::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptFunction::get_output_value_port_count() const{
+int VisualScriptFunction::get_output_value_port_count() const {
 
 	return arguments.size();
 }
@@ -188,17 +177,17 @@ String VisualScriptFunction::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptFunction::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptFunction::get_input_value_port_info(int p_idx) const {
 
 	ERR_FAIL_V(PropertyInfo());
 	return PropertyInfo();
 }
-PropertyInfo VisualScriptFunction::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptFunction::get_output_value_port_info(int p_idx) const {
 
-	ERR_FAIL_INDEX_V(p_idx,arguments.size(),PropertyInfo());
+	ERR_FAIL_INDEX_V(p_idx, arguments.size(), PropertyInfo());
 	PropertyInfo out;
-	out.type=arguments[p_idx].type;
-	out.name=arguments[p_idx].name;
+	out.type = arguments[p_idx].type;
+	out.name = arguments[p_idx].name;
 	return out;
 }
 
@@ -212,53 +201,48 @@ String VisualScriptFunction::get_text() const {
 	return get_name(); //use name as function name I guess
 }
 
-void VisualScriptFunction::add_argument(Variant::Type p_type,const String& p_name,int p_index){
+void VisualScriptFunction::add_argument(Variant::Type p_type, const String &p_name, int p_index) {
 
 	Argument arg;
-	arg.name=p_name;
-	arg.type=p_type;
-	if (p_index>=0)
-		arguments.insert(p_index,arg);
+	arg.name = p_name;
+	arg.type = p_type;
+	if (p_index >= 0)
+		arguments.insert(p_index, arg);
 	else
 		arguments.push_back(arg);
 
 	ports_changed_notify();
-
 }
-void VisualScriptFunction::set_argument_type(int p_argidx,Variant::Type p_type){
+void VisualScriptFunction::set_argument_type(int p_argidx, Variant::Type p_type) {
 
-	ERR_FAIL_INDEX(p_argidx,arguments.size());
+	ERR_FAIL_INDEX(p_argidx, arguments.size());
 
-	arguments[p_argidx].type=p_type;
+	arguments[p_argidx].type = p_type;
 	ports_changed_notify();
 }
 Variant::Type VisualScriptFunction::get_argument_type(int p_argidx) const {
 
-	ERR_FAIL_INDEX_V(p_argidx,arguments.size(),Variant::NIL);
+	ERR_FAIL_INDEX_V(p_argidx, arguments.size(), Variant::NIL);
 	return arguments[p_argidx].type;
-
 }
-void VisualScriptFunction::set_argument_name(int p_argidx,const String& p_name) {
+void VisualScriptFunction::set_argument_name(int p_argidx, const String &p_name) {
 
-	ERR_FAIL_INDEX(p_argidx,arguments.size());
+	ERR_FAIL_INDEX(p_argidx, arguments.size());
 
-	arguments[p_argidx].name=p_name;
+	arguments[p_argidx].name = p_name;
 	ports_changed_notify();
-
 }
 String VisualScriptFunction::get_argument_name(int p_argidx) const {
 
-	ERR_FAIL_INDEX_V(p_argidx,arguments.size(),String());
+	ERR_FAIL_INDEX_V(p_argidx, arguments.size(), String());
 	return arguments[p_argidx].name;
-
 }
 void VisualScriptFunction::remove_argument(int p_argidx) {
 
-	ERR_FAIL_INDEX(p_argidx,arguments.size());
+	ERR_FAIL_INDEX(p_argidx, arguments.size());
 
 	arguments.remove(p_argidx);
 	ports_changed_notify();
-
 }
 
 int VisualScriptFunction::get_argument_count() const {
@@ -266,68 +250,62 @@ int VisualScriptFunction::get_argument_count() const {
 	return arguments.size();
 }
 
-
 void VisualScriptFunction::set_rpc_mode(ScriptInstance::RPCMode p_mode) {
-	rpc_mode=p_mode;
+	rpc_mode = p_mode;
 }
 
 ScriptInstance::RPCMode VisualScriptFunction::get_rpc_mode() const {
 	return rpc_mode;
 }
 
-
 class VisualScriptNodeInstanceFunction : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptFunction *node;
 	VisualScriptInstance *instance;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		int ac = node->get_argument_count();
 
-		for(int i=0;i<ac;i++) {
+		for (int i = 0; i < ac; i++) {
 #ifdef DEBUG_ENABLED
 			Variant::Type expected = node->get_argument_type(i);
-			if (expected!=Variant::NIL) {
-				if (!Variant::can_convert_strict(p_inputs[i]->get_type(),expected)) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
-					r_error.expected=expected;
-					r_error.argument=i;
+			if (expected != Variant::NIL) {
+				if (!Variant::can_convert_strict(p_inputs[i]->get_type(), expected)) {
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.expected = expected;
+					r_error.argument = i;
 					return 0;
 				}
 			}
 #endif
 
-			*p_outputs[i]=*p_inputs[i];
+			*p_outputs[i] = *p_inputs[i];
 		}
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptFunction::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptFunction::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceFunction * instance = memnew(VisualScriptNodeInstanceFunction );
-	instance->node=this;
-	instance->instance=p_instance;
+	VisualScriptNodeInstanceFunction *instance = memnew(VisualScriptNodeInstanceFunction);
+	instance->node = this;
+	instance->instance = p_instance;
 	return instance;
 }
 
 VisualScriptFunction::VisualScriptFunction() {
 
-	stack_size=256;
-	stack_less=false;
-	rpc_mode=ScriptInstance::RPC_MODE_DISABLED;
+	stack_size = 256;
+	stack_less = false;
+	rpc_mode = ScriptInstance::RPC_MODE_DISABLED;
 }
 
-
 void VisualScriptFunction::set_stack_less(bool p_enable) {
-	stack_less=p_enable;
+	stack_less = p_enable;
 	_change_notify();
 }
 
@@ -337,8 +315,8 @@ bool VisualScriptFunction::is_stack_less() const {
 
 void VisualScriptFunction::set_stack_size(int p_size) {
 
-	ERR_FAIL_COND(p_size <1 || p_size>100000);
-	stack_size=p_size;
+	ERR_FAIL_COND(p_size < 1 || p_size > 100000);
+	stack_size = p_size;
 }
 
 int VisualScriptFunction::get_stack_size() const {
@@ -346,7 +324,6 @@ int VisualScriptFunction::get_stack_size() const {
 	return stack_size;
 }
 
-
 //////////////////////////////////////////
 ////////////////OPERATOR//////////////////
 //////////////////////////////////////////
@@ -356,16 +333,16 @@ int VisualScriptOperator::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptOperator::has_input_sequence_port() const{
+bool VisualScriptOperator::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptOperator::get_input_value_port_count() const{
+int VisualScriptOperator::get_input_value_port_count() const {
 
-	return (op==Variant::OP_BIT_NEGATE || op==Variant::OP_NOT || op==Variant::OP_NEGATE || op==Variant::OP_POSITIVE) ? 1 : 2;
+	return (op == Variant::OP_BIT_NEGATE || op == Variant::OP_NOT || op == Variant::OP_NEGATE || op == Variant::OP_POSITIVE) ? 1 : 2;
 }
-int VisualScriptOperator::get_output_value_port_count() const{
+int VisualScriptOperator::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -375,51 +352,51 @@ String VisualScriptOperator::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptOperator::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptOperator::get_input_value_port_info(int p_idx) const {
 
-	static const Variant::Type port_types[Variant::OP_MAX][2]={
-		{Variant::NIL,Variant::NIL}, //OP_EQUAL,
-		{Variant::NIL,Variant::NIL}, //OP_NOT_EQUAL,
-		{Variant::NIL,Variant::NIL}, //OP_LESS,
-		{Variant::NIL,Variant::NIL}, //OP_LESS_EQUAL,
-		{Variant::NIL,Variant::NIL}, //OP_GREATER,
-		{Variant::NIL,Variant::NIL}, //OP_GREATER_EQUAL,
+	static const Variant::Type port_types[Variant::OP_MAX][2] = {
+		{ Variant::NIL, Variant::NIL }, //OP_EQUAL,
+		{ Variant::NIL, Variant::NIL }, //OP_NOT_EQUAL,
+		{ Variant::NIL, Variant::NIL }, //OP_LESS,
+		{ Variant::NIL, Variant::NIL }, //OP_LESS_EQUAL,
+		{ Variant::NIL, Variant::NIL }, //OP_GREATER,
+		{ Variant::NIL, Variant::NIL }, //OP_GREATER_EQUAL,
 		//mathematic
-		{Variant::NIL,Variant::NIL}, //OP_ADD,
-		{Variant::NIL,Variant::NIL}, //OP_SUBSTRACT,
-		{Variant::NIL,Variant::NIL}, //OP_MULTIPLY,
-		{Variant::NIL,Variant::NIL}, //OP_DIVIDE,
-		{Variant::NIL,Variant::NIL}, //OP_NEGATE,
-		{Variant::NIL,Variant::NIL}, //OP_POSITIVE,
-		{Variant::INT,Variant::INT}, //OP_MODULE,
-		{Variant::STRING,Variant::STRING}, //OP_STRING_CONCAT,
+		{ Variant::NIL, Variant::NIL }, //OP_ADD,
+		{ Variant::NIL, Variant::NIL }, //OP_SUBSTRACT,
+		{ Variant::NIL, Variant::NIL }, //OP_MULTIPLY,
+		{ Variant::NIL, Variant::NIL }, //OP_DIVIDE,
+		{ Variant::NIL, Variant::NIL }, //OP_NEGATE,
+		{ Variant::NIL, Variant::NIL }, //OP_POSITIVE,
+		{ Variant::INT, Variant::INT }, //OP_MODULE,
+		{ Variant::STRING, Variant::STRING }, //OP_STRING_CONCAT,
 		//bitwise
-		{Variant::INT,Variant::INT}, //OP_SHIFT_LEFT,
-		{Variant::INT,Variant::INT}, //OP_SHIFT_RIGHT,
-		{Variant::INT,Variant::INT}, //OP_BIT_AND,
-		{Variant::INT,Variant::INT}, //OP_BIT_OR,
-		{Variant::INT,Variant::INT}, //OP_BIT_XOR,
-		{Variant::INT,Variant::INT}, //OP_BIT_NEGATE,
+		{ Variant::INT, Variant::INT }, //OP_SHIFT_LEFT,
+		{ Variant::INT, Variant::INT }, //OP_SHIFT_RIGHT,
+		{ Variant::INT, Variant::INT }, //OP_BIT_AND,
+		{ Variant::INT, Variant::INT }, //OP_BIT_OR,
+		{ Variant::INT, Variant::INT }, //OP_BIT_XOR,
+		{ Variant::INT, Variant::INT }, //OP_BIT_NEGATE,
 		//logic
-		{Variant::BOOL,Variant::BOOL}, //OP_AND,
-		{Variant::BOOL,Variant::BOOL}, //OP_OR,
-		{Variant::BOOL,Variant::BOOL}, //OP_XOR,
-		{Variant::BOOL,Variant::BOOL}, //OP_NOT,
+		{ Variant::BOOL, Variant::BOOL }, //OP_AND,
+		{ Variant::BOOL, Variant::BOOL }, //OP_OR,
+		{ Variant::BOOL, Variant::BOOL }, //OP_XOR,
+		{ Variant::BOOL, Variant::BOOL }, //OP_NOT,
 		//containment
-		{Variant::NIL,Variant::NIL} //OP_IN,
+		{ Variant::NIL, Variant::NIL } //OP_IN,
 	};
 
-	ERR_FAIL_INDEX_V(p_idx,Variant::OP_MAX,PropertyInfo());
+	ERR_FAIL_INDEX_V(p_idx, Variant::OP_MAX, PropertyInfo());
 
 	PropertyInfo pinfo;
-	pinfo.name=p_idx==0?"A":"B";
-	pinfo.type=port_types[op][p_idx];
-	if (pinfo.type==Variant::NIL)
-		pinfo.type=typed;
+	pinfo.name = p_idx == 0 ? "A" : "B";
+	pinfo.type = port_types[op][p_idx];
+	if (pinfo.type == Variant::NIL)
+		pinfo.type = typed;
 	return pinfo;
 }
-PropertyInfo VisualScriptOperator::get_output_value_port_info(int p_idx) const{
-	static const Variant::Type port_types[Variant::OP_MAX]={
+PropertyInfo VisualScriptOperator::get_output_value_port_info(int p_idx) const {
+	static const Variant::Type port_types[Variant::OP_MAX] = {
 		//comparation
 		Variant::BOOL, //OP_EQUAL,
 		Variant::BOOL, //OP_NOT_EQUAL,
@@ -453,15 +430,14 @@ PropertyInfo VisualScriptOperator::get_output_value_port_info(int p_idx) const{
 	};
 
 	PropertyInfo pinfo;
-	pinfo.name="";
-	pinfo.type=port_types[op];
-	if (pinfo.type==Variant::NIL)
-		pinfo.type=typed;
+	pinfo.name = "";
+	pinfo.type = port_types[op];
+	if (pinfo.type == Variant::NIL)
+		pinfo.type = typed;
 	return pinfo;
-
 }
 
-static const char* op_names[]={
+static const char *op_names[] = {
 	//comparation
 	"Equal", //OP_EQUAL,
 	"NotEqual", //OP_NOT_EQUAL,
@@ -496,14 +472,12 @@ static const char* op_names[]={
 
 String VisualScriptOperator::get_caption() const {
 
-
-
 	return op_names[op];
 }
 
 String VisualScriptOperator::get_text() const {
 
-	static const wchar_t* op_names[]={
+	static const wchar_t *op_names[] = {
 		//comparation
 		L"A = B", //OP_EQUAL,
 		L"A \u2260 B", //OP_NOT_EQUAL,
@@ -539,24 +513,23 @@ String VisualScriptOperator::get_text() const {
 
 void VisualScriptOperator::set_operator(Variant::Operator p_op) {
 
-	if (op==p_op)
+	if (op == p_op)
 		return;
-	op=p_op;
+	op = p_op;
 	ports_changed_notify();
-
 }
 
-Variant::Operator VisualScriptOperator::get_operator() const{
+Variant::Operator VisualScriptOperator::get_operator() const {
 
 	return op;
 }
 
 void VisualScriptOperator::set_typed(Variant::Type p_op) {
 
-	if (typed==p_op)
+	if (typed == p_op)
 		return;
 
-	typed=p_op;
+	typed = p_op;
 	ports_changed_notify();
 }
 
@@ -565,87 +538,80 @@ Variant::Type VisualScriptOperator::get_typed() const {
 	return typed;
 }
 
-
 void VisualScriptOperator::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_operator","op"),&VisualScriptOperator::set_operator);
-	ClassDB::bind_method(D_METHOD("get_operator"),&VisualScriptOperator::get_operator);
+	ClassDB::bind_method(D_METHOD("set_operator", "op"), &VisualScriptOperator::set_operator);
+	ClassDB::bind_method(D_METHOD("get_operator"), &VisualScriptOperator::get_operator);
 
-	ClassDB::bind_method(D_METHOD("set_typed","type"),&VisualScriptOperator::set_typed);
-	ClassDB::bind_method(D_METHOD("get_typed"),&VisualScriptOperator::get_typed);
+	ClassDB::bind_method(D_METHOD("set_typed", "type"), &VisualScriptOperator::set_typed);
+	ClassDB::bind_method(D_METHOD("get_typed"), &VisualScriptOperator::get_typed);
 
 	String types;
-	for(int i=0;i<Variant::OP_MAX;i++) {
-		if (i>0)
-			types+=",";
-		types+=op_names[i];
+	for (int i = 0; i < Variant::OP_MAX; i++) {
+		if (i > 0)
+			types += ",";
+		types += op_names[i];
 	}
 
-	String argt="Any";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	String argt = "Any";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"operator_value/type",PROPERTY_HINT_ENUM,types),"set_operator","get_operator");
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"typed_value/typed",PROPERTY_HINT_ENUM,argt),"set_typed","get_typed");
-
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "operator_value/type", PROPERTY_HINT_ENUM, types), "set_operator", "get_operator");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "typed_value/typed", PROPERTY_HINT_ENUM, argt), "set_typed", "get_typed");
 }
 
 class VisualScriptNodeInstanceOperator : public VisualScriptNodeInstance {
 public:
-
 	bool unary;
 	Variant::Operator op;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		bool valid;
 		if (unary) {
 
-			Variant::evaluate(op,*p_inputs[0],Variant(),*p_outputs[0],valid);
+			Variant::evaluate(op, *p_inputs[0], Variant(), *p_outputs[0], valid);
 		} else {
-			Variant::evaluate(op,*p_inputs[0],*p_inputs[1],*p_outputs[0],valid);
+			Variant::evaluate(op, *p_inputs[0], *p_inputs[1], *p_outputs[0], valid);
 		}
 
 		if (!valid) {
 
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			if (p_outputs[0]->get_type()==Variant::STRING) {
-				r_error_str=*p_outputs[0];
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			if (p_outputs[0]->get_type() == Variant::STRING) {
+				r_error_str = *p_outputs[0];
 			} else {
 				if (unary)
-					r_error_str=String(op_names[op])+RTR(": Invalid argument of type: ")+Variant::get_type_name(p_inputs[0]->get_type());
+					r_error_str = String(op_names[op]) + RTR(": Invalid argument of type: ") + Variant::get_type_name(p_inputs[0]->get_type());
 				else
-					r_error_str=String(op_names[op])+RTR(": Invalid arguments: ")+"A: "+Variant::get_type_name(p_inputs[0]->get_type())+"  B: "+Variant::get_type_name(p_inputs[1]->get_type());
+					r_error_str = String(op_names[op]) + RTR(": Invalid arguments: ") + "A: " + Variant::get_type_name(p_inputs[0]->get_type()) + "  B: " + Variant::get_type_name(p_inputs[1]->get_type());
 			}
 		}
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptOperator::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptOperator::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceOperator * instance = memnew(VisualScriptNodeInstanceOperator );
-	instance->unary=get_input_value_port_count()==1;
-	instance->op=op;
+	VisualScriptNodeInstanceOperator *instance = memnew(VisualScriptNodeInstanceOperator);
+	instance->unary = get_input_value_port_count() == 1;
+	instance->op = op;
 	return instance;
 }
 
 VisualScriptOperator::VisualScriptOperator() {
 
-	op=Variant::OP_ADD;
-	typed=Variant::NIL;
+	op = Variant::OP_ADD;
+	typed = Variant::NIL;
 }
 
-
-
-template<Variant::Operator OP>
-static Ref<VisualScriptNode> create_op_node(const String& p_name) {
+template <Variant::Operator OP>
+static Ref<VisualScriptNode> create_op_node(const String &p_name) {
 
 	Ref<VisualScriptOperator> node;
 	node.instance();
@@ -662,16 +628,16 @@ int VisualScriptVariableGet::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptVariableGet::has_input_sequence_port() const{
+bool VisualScriptVariableGet::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptVariableGet::get_input_value_port_count() const{
+int VisualScriptVariableGet::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptVariableGet::get_output_value_port_count() const{
+int VisualScriptVariableGet::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -681,25 +647,24 @@ String VisualScriptVariableGet::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptVariableGet::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptVariableGet::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptVariableGet::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptVariableGet::get_output_value_port_info(int p_idx) const {
 
 	PropertyInfo pinfo;
-	pinfo.name="value";
+	pinfo.name = "value";
 	if (get_visual_script().is_valid() && get_visual_script()->has_variable(variable)) {
 		PropertyInfo vinfo = get_visual_script()->get_variable_info(variable);
-		pinfo.type=vinfo.type;
-		pinfo.hint=vinfo.hint;
-		pinfo.hint_string=vinfo.hint_string;
+		pinfo.type = vinfo.type;
+		pinfo.hint = vinfo.hint;
+		pinfo.hint_string = vinfo.hint_string;
 	}
 	return pinfo;
 }
 
-
 String VisualScriptVariableGet::get_caption() const {
 
 	return "Variable";
@@ -712,83 +677,73 @@ String VisualScriptVariableGet::get_text() const {
 
 void VisualScriptVariableGet::set_variable(StringName p_variable) {
 
-	if (variable==p_variable)
+	if (variable == p_variable)
 		return;
-	variable=p_variable;
+	variable = p_variable;
 	ports_changed_notify();
-
 }
 
-StringName VisualScriptVariableGet::get_variable() const{
+StringName VisualScriptVariableGet::get_variable() const {
 
 	return variable;
 }
 
-void VisualScriptVariableGet::_validate_property(PropertyInfo& property) const {
+void VisualScriptVariableGet::_validate_property(PropertyInfo &property) const {
 
-	if (property.name=="variable/name" && get_visual_script().is_valid()) {
+	if (property.name == "variable/name" && get_visual_script().is_valid()) {
 		Ref<VisualScript> vs = get_visual_script();
 		List<StringName> vars;
 		vs->get_variable_list(&vars);
 
 		String vhint;
-		for (List<StringName>::Element *E=vars.front();E;E=E->next()) {
-			if (vhint!=String())
-				vhint+=",";
+		for (List<StringName>::Element *E = vars.front(); E; E = E->next()) {
+			if (vhint != String())
+				vhint += ",";
 
-			vhint+=E->get().operator String();
+			vhint += E->get().operator String();
 		}
 
-		property.hint=PROPERTY_HINT_ENUM;
-		property.hint_string=vhint;
+		property.hint = PROPERTY_HINT_ENUM;
+		property.hint_string = vhint;
 	}
 }
 
 void VisualScriptVariableGet::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_variable","name"),&VisualScriptVariableGet::set_variable);
-	ClassDB::bind_method(D_METHOD("get_variable"),&VisualScriptVariableGet::get_variable);
-
-
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"variable/name"),"set_variable","get_variable");
+	ClassDB::bind_method(D_METHOD("set_variable", "name"), &VisualScriptVariableGet::set_variable);
+	ClassDB::bind_method(D_METHOD("get_variable"), &VisualScriptVariableGet::get_variable);
 
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "variable/name"), "set_variable", "get_variable");
 }
 
 class VisualScriptNodeInstanceVariableGet : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptVariableGet *node;
 	VisualScriptInstance *instance;
 	StringName variable;
 
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
-
-		if (instance->get_variable(variable,p_outputs[0])==false) {
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			r_error_str=RTR("VariableGet not found in script: ")+"'"+String(variable)+"'";
+		if (instance->get_variable(variable, p_outputs[0]) == false) {
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = RTR("VariableGet not found in script: ") + "'" + String(variable) + "'";
 			return false;
 		}
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptVariableGet::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptVariableGet::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceVariableGet * instance = memnew(VisualScriptNodeInstanceVariableGet );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->variable=variable;
+	VisualScriptNodeInstanceVariableGet *instance = memnew(VisualScriptNodeInstanceVariableGet);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->variable = variable;
 	return instance;
 }
 VisualScriptVariableGet::VisualScriptVariableGet() {
-
-
 }
 
-
 //////////////////////////////////////////
 ////////////////VARIABLE SET//////////////////
 //////////////////////////////////////////
@@ -798,16 +753,16 @@ int VisualScriptVariableSet::get_output_sequence_port_count() const {
 	return 1;
 }
 
-bool VisualScriptVariableSet::has_input_sequence_port() const{
+bool VisualScriptVariableSet::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptVariableSet::get_input_value_port_count() const{
+int VisualScriptVariableSet::get_input_value_port_count() const {
 
 	return 1;
 }
-int VisualScriptVariableSet::get_output_value_port_count() const{
+int VisualScriptVariableSet::get_output_value_port_count() const {
 
 	return 0;
 }
@@ -817,25 +772,24 @@ String VisualScriptVariableSet::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptVariableSet::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptVariableSet::get_input_value_port_info(int p_idx) const {
 
 	PropertyInfo pinfo;
-	pinfo.name="set";
+	pinfo.name = "set";
 	if (get_visual_script().is_valid() && get_visual_script()->has_variable(variable)) {
 		PropertyInfo vinfo = get_visual_script()->get_variable_info(variable);
-		pinfo.type=vinfo.type;
-		pinfo.hint=vinfo.hint;
-		pinfo.hint_string=vinfo.hint_string;
+		pinfo.type = vinfo.type;
+		pinfo.hint = vinfo.hint;
+		pinfo.hint_string = vinfo.hint_string;
 	}
 	return pinfo;
 }
 
-PropertyInfo VisualScriptVariableSet::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptVariableSet::get_output_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-
 String VisualScriptVariableSet::get_caption() const {
 
 	return "VariableSet";
@@ -848,87 +802,76 @@ String VisualScriptVariableSet::get_text() const {
 
 void VisualScriptVariableSet::set_variable(StringName p_variable) {
 
-	if (variable==p_variable)
+	if (variable == p_variable)
 		return;
-	variable=p_variable;
+	variable = p_variable;
 	ports_changed_notify();
-
 }
 
-StringName VisualScriptVariableSet::get_variable() const{
+StringName VisualScriptVariableSet::get_variable() const {
 
 	return variable;
 }
 
-void VisualScriptVariableSet::_validate_property(PropertyInfo& property) const {
+void VisualScriptVariableSet::_validate_property(PropertyInfo &property) const {
 
-	if (property.name=="variable/name" && get_visual_script().is_valid()) {
+	if (property.name == "variable/name" && get_visual_script().is_valid()) {
 		Ref<VisualScript> vs = get_visual_script();
 		List<StringName> vars;
 		vs->get_variable_list(&vars);
 
 		String vhint;
-		for (List<StringName>::Element *E=vars.front();E;E=E->next()) {
-			if (vhint!=String())
-				vhint+=",";
+		for (List<StringName>::Element *E = vars.front(); E; E = E->next()) {
+			if (vhint != String())
+				vhint += ",";
 
-			vhint+=E->get().operator String();
+			vhint += E->get().operator String();
 		}
 
-		property.hint=PROPERTY_HINT_ENUM;
-		property.hint_string=vhint;
+		property.hint = PROPERTY_HINT_ENUM;
+		property.hint_string = vhint;
 	}
 }
 
 void VisualScriptVariableSet::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_variable","name"),&VisualScriptVariableSet::set_variable);
-	ClassDB::bind_method(D_METHOD("get_variable"),&VisualScriptVariableSet::get_variable);
-
-
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"variable/name"),"set_variable","get_variable");
+	ClassDB::bind_method(D_METHOD("set_variable", "name"), &VisualScriptVariableSet::set_variable);
+	ClassDB::bind_method(D_METHOD("get_variable"), &VisualScriptVariableSet::get_variable);
 
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "variable/name"), "set_variable", "get_variable");
 }
 
 class VisualScriptNodeInstanceVariableSet : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptVariableSet *node;
 	VisualScriptInstance *instance;
 	StringName variable;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
-
-		if (instance->set_variable(variable,*p_inputs[0])==false) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
+		if (instance->set_variable(variable, *p_inputs[0]) == false) {
 
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			r_error_str=RTR("VariableSet not found in script: ")+"'"+String(variable)+"'";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = RTR("VariableSet not found in script: ") + "'" + String(variable) + "'";
 		}
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptVariableSet::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptVariableSet::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceVariableSet * instance = memnew(VisualScriptNodeInstanceVariableSet );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->variable=variable;
+	VisualScriptNodeInstanceVariableSet *instance = memnew(VisualScriptNodeInstanceVariableSet);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->variable = variable;
 	return instance;
 }
 VisualScriptVariableSet::VisualScriptVariableSet() {
-
-
 }
 
-
-
 //////////////////////////////////////////
 ////////////////CONSTANT//////////////////
 //////////////////////////////////////////
@@ -938,16 +881,16 @@ int VisualScriptConstant::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptConstant::has_input_sequence_port() const{
+bool VisualScriptConstant::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptConstant::get_input_value_port_count() const{
+int VisualScriptConstant::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptConstant::get_output_value_port_count() const{
+int VisualScriptConstant::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -957,20 +900,19 @@ String VisualScriptConstant::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptConstant::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptConstant::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptConstant::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptConstant::get_output_value_port_info(int p_idx) const {
 
 	PropertyInfo pinfo;
-	pinfo.name="get";
-	pinfo.type=type;
+	pinfo.name = "get";
+	pinfo.type = type;
 	return pinfo;
 }
 
-
 String VisualScriptConstant::get_caption() const {
 
 	return "Constant";
@@ -983,90 +925,82 @@ String VisualScriptConstant::get_text() const {
 
 void VisualScriptConstant::set_constant_type(Variant::Type p_type) {
 
-	if (type==p_type)
+	if (type == p_type)
 		return;
 
-	type=p_type;
+	type = p_type;
 	ports_changed_notify();
 	Variant::CallError ce;
-	value=Variant::construct(type,NULL,0,ce);
+	value = Variant::construct(type, NULL, 0, ce);
 	_change_notify();
-
 }
 
-Variant::Type VisualScriptConstant::get_constant_type() const{
+Variant::Type VisualScriptConstant::get_constant_type() const {
 
 	return type;
 }
 
-void VisualScriptConstant::set_constant_value(Variant p_value){
+void VisualScriptConstant::set_constant_value(Variant p_value) {
 
-	if (value==p_value)
+	if (value == p_value)
 		return;
 
-	value=p_value;
+	value = p_value;
 	ports_changed_notify();
 }
-Variant VisualScriptConstant::get_constant_value() const{
+Variant VisualScriptConstant::get_constant_value() const {
 
 	return value;
 }
 
-void VisualScriptConstant::_validate_property(PropertyInfo& property) const {
-
+void VisualScriptConstant::_validate_property(PropertyInfo &property) const {
 
-	if (property.name=="constant/value") {
-		property.type=type;
-		if (type==Variant::NIL)
-			property.usage=0; //do not save if nil
+	if (property.name == "constant/value") {
+		property.type = type;
+		if (type == Variant::NIL)
+			property.usage = 0; //do not save if nil
 	}
 }
 
 void VisualScriptConstant::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_constant_type","type"),&VisualScriptConstant::set_constant_type);
-	ClassDB::bind_method(D_METHOD("get_constant_type"),&VisualScriptConstant::get_constant_type);
+	ClassDB::bind_method(D_METHOD("set_constant_type", "type"), &VisualScriptConstant::set_constant_type);
+	ClassDB::bind_method(D_METHOD("get_constant_type"), &VisualScriptConstant::get_constant_type);
 
-	ClassDB::bind_method(D_METHOD("set_constant_value","value"),&VisualScriptConstant::set_constant_value);
-	ClassDB::bind_method(D_METHOD("get_constant_value"),&VisualScriptConstant::get_constant_value);
+	ClassDB::bind_method(D_METHOD("set_constant_value", "value"), &VisualScriptConstant::set_constant_value);
+	ClassDB::bind_method(D_METHOD("get_constant_value"), &VisualScriptConstant::get_constant_value);
 
-	String argt="Null";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	String argt = "Null";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"constant/type",PROPERTY_HINT_ENUM,argt),"set_constant_type","get_constant_type");
-	ADD_PROPERTY(PropertyInfo(Variant::NIL,"constant/value"),"set_constant_value","get_constant_value");
-
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "constant/type", PROPERTY_HINT_ENUM, argt), "set_constant_type", "get_constant_type");
+	ADD_PROPERTY(PropertyInfo(Variant::NIL, "constant/value"), "set_constant_value", "get_constant_value");
 }
 
 class VisualScriptNodeInstanceConstant : public VisualScriptNodeInstance {
 public:
-
 	Variant constant;
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		*p_outputs[0]=constant;
+		*p_outputs[0] = constant;
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptConstant::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptConstant::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceConstant * instance = memnew(VisualScriptNodeInstanceConstant );
-	instance->constant=value;
+	VisualScriptNodeInstanceConstant *instance = memnew(VisualScriptNodeInstanceConstant);
+	instance->constant = value;
 	return instance;
 }
 
 VisualScriptConstant::VisualScriptConstant() {
 
-	type=Variant::NIL;
-
+	type = Variant::NIL;
 }
 
 //////////////////////////////////////////
@@ -1078,16 +1012,16 @@ int VisualScriptPreload::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptPreload::has_input_sequence_port() const{
+bool VisualScriptPreload::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptPreload::get_input_value_port_count() const{
+int VisualScriptPreload::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptPreload::get_output_value_port_count() const{
+int VisualScriptPreload::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -1097,23 +1031,22 @@ String VisualScriptPreload::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptPreload::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptPreload::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptPreload::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptPreload::get_output_value_port_info(int p_idx) const {
 
-	PropertyInfo pinfo=PropertyInfo(Variant::OBJECT,"res");
+	PropertyInfo pinfo = PropertyInfo(Variant::OBJECT, "res");
 	if (preload.is_valid()) {
-		pinfo.hint=PROPERTY_HINT_RESOURCE_TYPE;
-		pinfo.hint_string=preload->get_class();
+		pinfo.hint = PROPERTY_HINT_RESOURCE_TYPE;
+		pinfo.hint_string = preload->get_class();
 	}
 
 	return pinfo;
 }
 
-
 String VisualScriptPreload::get_caption() const {
 
 	return "Preload";
@@ -1124,7 +1057,7 @@ String VisualScriptPreload::get_text() const {
 	if (preload.is_valid()) {
 		if (preload->get_path().is_resource_file()) {
 			return preload->get_path();
-		} else if (preload->get_name()!=String()) {
+		} else if (preload->get_name() != String()) {
 			return preload->get_name();
 		} else {
 			return preload->get_class();
@@ -1134,61 +1067,49 @@ String VisualScriptPreload::get_text() const {
 	}
 }
 
+void VisualScriptPreload::set_preload(const Ref<Resource> &p_preload) {
 
-void VisualScriptPreload::set_preload(const Ref<Resource>& p_preload){
-
-	if (preload==p_preload)
+	if (preload == p_preload)
 		return;
 
-	preload=p_preload;
+	preload = p_preload;
 	ports_changed_notify();
 }
-Ref<Resource> VisualScriptPreload::get_preload() const{
+Ref<Resource> VisualScriptPreload::get_preload() const {
 
 	return preload;
 }
 
-
 void VisualScriptPreload::_bind_methods() {
 
+	ClassDB::bind_method(D_METHOD("set_preload", "resource"), &VisualScriptPreload::set_preload);
+	ClassDB::bind_method(D_METHOD("get_preload"), &VisualScriptPreload::get_preload);
 
-	ClassDB::bind_method(D_METHOD("set_preload","resource"),&VisualScriptPreload::set_preload);
-	ClassDB::bind_method(D_METHOD("get_preload"),&VisualScriptPreload::get_preload);
-
-
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT,"resource",PROPERTY_HINT_RESOURCE_TYPE,"Resource"),"set_preload","get_preload");
-
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "resource", PROPERTY_HINT_RESOURCE_TYPE, "Resource"), "set_preload", "get_preload");
 }
 
 class VisualScriptNodeInstancePreload : public VisualScriptNodeInstance {
 public:
-
 	Ref<Resource> preload;
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		*p_outputs[0]=preload;
+		*p_outputs[0] = preload;
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptPreload::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptPreload::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstancePreload * instance = memnew(VisualScriptNodeInstancePreload );
-	instance->preload=preload;
+	VisualScriptNodeInstancePreload *instance = memnew(VisualScriptNodeInstancePreload);
+	instance->preload = preload;
 	return instance;
 }
 
 VisualScriptPreload::VisualScriptPreload() {
-
 }
 
-
-
-
 //////////////////////////////////////////
 ////////////////INDEX////////////////////
 //////////////////////////////////////////
@@ -1198,16 +1119,16 @@ int VisualScriptIndexGet::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptIndexGet::has_input_sequence_port() const{
+bool VisualScriptIndexGet::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptIndexGet::get_input_value_port_count() const{
+int VisualScriptIndexGet::get_input_value_port_count() const {
 
 	return 2;
 }
-int VisualScriptIndexGet::get_output_value_port_count() const{
+int VisualScriptIndexGet::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -1217,22 +1138,20 @@ String VisualScriptIndexGet::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptIndexGet::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptIndexGet::get_input_value_port_info(int p_idx) const {
 
-	if (p_idx==0) {
-		return PropertyInfo(Variant::NIL,"base");
+	if (p_idx == 0) {
+		return PropertyInfo(Variant::NIL, "base");
 	} else {
-		return PropertyInfo(Variant::NIL,"index");
-
+		return PropertyInfo(Variant::NIL, "index");
 	}
 }
 
-PropertyInfo VisualScriptIndexGet::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptIndexGet::get_output_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-
 String VisualScriptIndexGet::get_caption() const {
 
 	return "IndexGet";
@@ -1243,37 +1162,29 @@ String VisualScriptIndexGet::get_text() const {
 	return String("get");
 }
 
-
 class VisualScriptNodeInstanceIndexGet : public VisualScriptNodeInstance {
 public:
-
-
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		bool valid;
-		*p_outputs[0] = p_inputs[0]->get(*p_inputs[1],&valid);
+		*p_outputs[0] = p_inputs[0]->get(*p_inputs[1], &valid);
 
 		if (!valid) {
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			r_error_str="Invalid get: "+p_inputs[0]->get_construct_string();
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Invalid get: " + p_inputs[0]->get_construct_string();
 		}
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptIndexGet::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptIndexGet::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceIndexGet * instance = memnew(VisualScriptNodeInstanceIndexGet );
+	VisualScriptNodeInstanceIndexGet *instance = memnew(VisualScriptNodeInstanceIndexGet);
 	return instance;
 }
 VisualScriptIndexGet::VisualScriptIndexGet() {
-
-
-
 }
 
 //////////////////////////////////////////
@@ -1285,16 +1196,16 @@ int VisualScriptIndexSet::get_output_sequence_port_count() const {
 	return 1;
 }
 
-bool VisualScriptIndexSet::has_input_sequence_port() const{
+bool VisualScriptIndexSet::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptIndexSet::get_input_value_port_count() const{
+int VisualScriptIndexSet::get_input_value_port_count() const {
 
 	return 3;
 }
-int VisualScriptIndexSet::get_output_value_port_count() const{
+int VisualScriptIndexSet::get_output_value_port_count() const {
 
 	return 0;
 }
@@ -1304,25 +1215,23 @@ String VisualScriptIndexSet::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptIndexSet::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptIndexSet::get_input_value_port_info(int p_idx) const {
 
-	if (p_idx==0) {
-		return PropertyInfo(Variant::NIL,"base");
-	} else if (p_idx==1){
-		return PropertyInfo(Variant::NIL,"index");
+	if (p_idx == 0) {
+		return PropertyInfo(Variant::NIL, "base");
+	} else if (p_idx == 1) {
+		return PropertyInfo(Variant::NIL, "index");
 
 	} else {
-		return PropertyInfo(Variant::NIL,"value");
-
+		return PropertyInfo(Variant::NIL, "value");
 	}
 }
 
-PropertyInfo VisualScriptIndexSet::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptIndexSet::get_output_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-
 String VisualScriptIndexSet::get_caption() const {
 
 	return "IndexSet";
@@ -1333,41 +1242,32 @@ String VisualScriptIndexSet::get_text() const {
 	return String("set");
 }
 
-
 class VisualScriptNodeInstanceIndexSet : public VisualScriptNodeInstance {
 public:
-
-
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		bool valid;
-		*p_outputs[0]=*p_inputs[0];
-		p_outputs[0]->set(*p_inputs[1],*p_inputs[2],&valid);
+		*p_outputs[0] = *p_inputs[0];
+		p_outputs[0]->set(*p_inputs[1], *p_inputs[2], &valid);
 
 		if (!valid) {
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			r_error_str="Invalid set: "+p_inputs[1]->get_construct_string();
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Invalid set: " + p_inputs[1]->get_construct_string();
 		}
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptIndexSet::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptIndexSet::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceIndexSet * instance = memnew(VisualScriptNodeInstanceIndexSet );
+	VisualScriptNodeInstanceIndexSet *instance = memnew(VisualScriptNodeInstanceIndexSet);
 	return instance;
 }
 VisualScriptIndexSet::VisualScriptIndexSet() {
-
-
-
 }
 
-
 //////////////////////////////////////////
 ////////////////GLOBALCONSTANT///////////
 //////////////////////////////////////////
@@ -1377,16 +1277,16 @@ int VisualScriptGlobalConstant::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptGlobalConstant::has_input_sequence_port() const{
+bool VisualScriptGlobalConstant::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptGlobalConstant::get_input_value_port_count() const{
+int VisualScriptGlobalConstant::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptGlobalConstant::get_output_value_port_count() const{
+int VisualScriptGlobalConstant::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -1396,17 +1296,16 @@ String VisualScriptGlobalConstant::get_output_sequence_port_text(int p_port) con
 	return String();
 }
 
-PropertyInfo VisualScriptGlobalConstant::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptGlobalConstant::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptGlobalConstant::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptGlobalConstant::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::REAL,"value");
+	return PropertyInfo(Variant::REAL, "value");
 }
 
-
 String VisualScriptGlobalConstant::get_caption() const {
 
 	return "GlobalConst";
@@ -1419,7 +1318,7 @@ String VisualScriptGlobalConstant::get_text() const {
 
 void VisualScriptGlobalConstant::set_global_constant(int p_which) {
 
-	index=p_which;
+	index = p_which;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -1428,49 +1327,44 @@ int VisualScriptGlobalConstant::get_global_constant() {
 	return index;
 }
 
-
 class VisualScriptNodeInstanceGlobalConstant : public VisualScriptNodeInstance {
 public:
-
 	int index;
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
-
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		*p_outputs[0] = GlobalConstants::get_global_constant_value(index);
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptGlobalConstant::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptGlobalConstant::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceGlobalConstant * instance = memnew(VisualScriptNodeInstanceGlobalConstant );
-	instance->index=index;
+	VisualScriptNodeInstanceGlobalConstant *instance = memnew(VisualScriptNodeInstanceGlobalConstant);
+	instance->index = index;
 	return instance;
 }
 
 void VisualScriptGlobalConstant::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_global_constant","index"),&VisualScriptGlobalConstant::set_global_constant);
-	ClassDB::bind_method(D_METHOD("get_global_constant"),&VisualScriptGlobalConstant::get_global_constant);
+	ClassDB::bind_method(D_METHOD("set_global_constant", "index"), &VisualScriptGlobalConstant::set_global_constant);
+	ClassDB::bind_method(D_METHOD("get_global_constant"), &VisualScriptGlobalConstant::get_global_constant);
 
 	String cc;
 
-	for(int i=0;i<GlobalConstants::get_global_constant_count();i++) {
+	for (int i = 0; i < GlobalConstants::get_global_constant_count(); i++) {
 
-		if (i>0)
-			cc+=",";
-		cc+=GlobalConstants::get_global_constant_name(i);
+		if (i > 0)
+			cc += ",";
+		cc += GlobalConstants::get_global_constant_name(i);
 	}
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"constant",PROPERTY_HINT_ENUM,cc),"set_global_constant","get_global_constant");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "constant", PROPERTY_HINT_ENUM, cc), "set_global_constant", "get_global_constant");
 }
 
 VisualScriptGlobalConstant::VisualScriptGlobalConstant() {
 
-	index=0;
+	index = 0;
 }
 
 //////////////////////////////////////////
@@ -1482,16 +1376,16 @@ int VisualScriptClassConstant::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptClassConstant::has_input_sequence_port() const{
+bool VisualScriptClassConstant::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptClassConstant::get_input_value_port_count() const{
+int VisualScriptClassConstant::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptClassConstant::get_output_value_port_count() const{
+int VisualScriptClassConstant::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -1501,17 +1395,16 @@ String VisualScriptClassConstant::get_output_sequence_port_text(int p_port) cons
 	return String();
 }
 
-PropertyInfo VisualScriptClassConstant::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptClassConstant::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptClassConstant::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptClassConstant::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::INT,"value");
+	return PropertyInfo(Variant::INT, "value");
 }
 
-
 String VisualScriptClassConstant::get_caption() const {
 
 	return "ClassConst";
@@ -1519,12 +1412,12 @@ String VisualScriptClassConstant::get_caption() const {
 
 String VisualScriptClassConstant::get_text() const {
 
-	return String(base_type)+"."+String(name);
+	return String(base_type) + "." + String(name);
 }
 
-void VisualScriptClassConstant::set_class_constant(const StringName& p_which) {
+void VisualScriptClassConstant::set_class_constant(const StringName &p_which) {
 
-	name=p_which;
+	name = p_which;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -1533,10 +1426,9 @@ StringName VisualScriptClassConstant::get_class_constant() {
 	return name;
 }
 
+void VisualScriptClassConstant::set_base_type(const StringName &p_which) {
 
-void VisualScriptClassConstant::set_base_type(const StringName& p_which) {
-
-	base_type=p_which;
+	base_type = p_which;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -1547,67 +1439,63 @@ StringName VisualScriptClassConstant::get_base_type() {
 
 class VisualScriptNodeInstanceClassConstant : public VisualScriptNodeInstance {
 public:
-
 	int value;
 	bool valid;
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		if (!valid) {
-			r_error_str="Invalid constant name, pick a valid class constant.";
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Invalid constant name, pick a valid class constant.";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 		}
 
 		*p_outputs[0] = value;
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptClassConstant::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptClassConstant::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceClassConstant * instance = memnew(VisualScriptNodeInstanceClassConstant );
-	instance->value=ClassDB::get_integer_constant(base_type,name,&instance->valid);
+	VisualScriptNodeInstanceClassConstant *instance = memnew(VisualScriptNodeInstanceClassConstant);
+	instance->value = ClassDB::get_integer_constant(base_type, name, &instance->valid);
 	return instance;
 }
 
-void VisualScriptClassConstant::_validate_property(PropertyInfo& property) const {
+void VisualScriptClassConstant::_validate_property(PropertyInfo &property) const {
 
-	if (property.name=="constant") {
+	if (property.name == "constant") {
 
 		List<String> constants;
-		ClassDB::get_integer_constant_list(base_type,&constants,true);
+		ClassDB::get_integer_constant_list(base_type, &constants, true);
 
-		property.hint_string="";
-		for(List<String>::Element *E=constants.front();E;E=E->next()) {
-			if (property.hint_string!=String()) {
-				property.hint_string+=",";
+		property.hint_string = "";
+		for (List<String>::Element *E = constants.front(); E; E = E->next()) {
+			if (property.hint_string != String()) {
+				property.hint_string += ",";
 			}
-			property.hint_string+=E->get();
+			property.hint_string += E->get();
 		}
 	}
 }
 
 void VisualScriptClassConstant::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_class_constant","name"),&VisualScriptClassConstant::set_class_constant);
-	ClassDB::bind_method(D_METHOD("get_class_constant"),&VisualScriptClassConstant::get_class_constant);
+	ClassDB::bind_method(D_METHOD("set_class_constant", "name"), &VisualScriptClassConstant::set_class_constant);
+	ClassDB::bind_method(D_METHOD("get_class_constant"), &VisualScriptClassConstant::get_class_constant);
 
-	ClassDB::bind_method(D_METHOD("set_base_type","name"),&VisualScriptClassConstant::set_base_type);
-	ClassDB::bind_method(D_METHOD("get_base_type"),&VisualScriptClassConstant::get_base_type);
+	ClassDB::bind_method(D_METHOD("set_base_type", "name"), &VisualScriptClassConstant::set_base_type);
+	ClassDB::bind_method(D_METHOD("get_base_type"), &VisualScriptClassConstant::get_base_type);
 
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"base_type",PROPERTY_HINT_TYPE_STRING,"Object"),"set_base_type","get_base_type");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"constant",PROPERTY_HINT_ENUM,""),"set_class_constant","get_class_constant");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "base_type", PROPERTY_HINT_TYPE_STRING, "Object"), "set_base_type", "get_base_type");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant", PROPERTY_HINT_ENUM, ""), "set_class_constant", "get_class_constant");
 }
 
 VisualScriptClassConstant::VisualScriptClassConstant() {
 
-	base_type="Object";
+	base_type = "Object";
 }
 
-
 //////////////////////////////////////////
 ////////////////BASICTYPECONSTANT///////////
 //////////////////////////////////////////
@@ -1617,16 +1505,16 @@ int VisualScriptBasicTypeConstant::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptBasicTypeConstant::has_input_sequence_port() const{
+bool VisualScriptBasicTypeConstant::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptBasicTypeConstant::get_input_value_port_count() const{
+int VisualScriptBasicTypeConstant::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptBasicTypeConstant::get_output_value_port_count() const{
+int VisualScriptBasicTypeConstant::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -1636,17 +1524,16 @@ String VisualScriptBasicTypeConstant::get_output_sequence_port_text(int p_port)
 	return String();
 }
 
-PropertyInfo VisualScriptBasicTypeConstant::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptBasicTypeConstant::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptBasicTypeConstant::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptBasicTypeConstant::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::INT,"value");
+	return PropertyInfo(Variant::INT, "value");
 }
 
-
 String VisualScriptBasicTypeConstant::get_caption() const {
 
 	return "BasicConst";
@@ -1654,12 +1541,12 @@ String VisualScriptBasicTypeConstant::get_caption() const {
 
 String VisualScriptBasicTypeConstant::get_text() const {
 
-	return Variant::get_type_name(type)+"."+String(name);
+	return Variant::get_type_name(type) + "." + String(name);
 }
 
-void VisualScriptBasicTypeConstant::set_basic_type_constant(const StringName& p_which) {
+void VisualScriptBasicTypeConstant::set_basic_type_constant(const StringName &p_which) {
 
-	name=p_which;
+	name = p_which;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -1668,10 +1555,9 @@ StringName VisualScriptBasicTypeConstant::get_basic_type_constant() const {
 	return name;
 }
 
-
 void VisualScriptBasicTypeConstant::set_basic_type(Variant::Type p_which) {
 
-	type=p_which;
+	type = p_which;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -1682,85 +1568,77 @@ Variant::Type VisualScriptBasicTypeConstant::get_basic_type() const {
 
 class VisualScriptNodeInstanceBasicTypeConstant : public VisualScriptNodeInstance {
 public:
-
 	int value;
 	bool valid;
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		if (!valid) {
-			r_error_str="Invalid constant name, pick a valid basic type constant.";
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Invalid constant name, pick a valid basic type constant.";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 		}
 
 		*p_outputs[0] = value;
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptBasicTypeConstant::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptBasicTypeConstant::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceBasicTypeConstant * instance = memnew(VisualScriptNodeInstanceBasicTypeConstant );
-	instance->value=Variant::get_numeric_constant_value(type,name,&instance->valid);
+	VisualScriptNodeInstanceBasicTypeConstant *instance = memnew(VisualScriptNodeInstanceBasicTypeConstant);
+	instance->value = Variant::get_numeric_constant_value(type, name, &instance->valid);
 	return instance;
 }
 
-void VisualScriptBasicTypeConstant::_validate_property(PropertyInfo& property) const {
+void VisualScriptBasicTypeConstant::_validate_property(PropertyInfo &property) const {
 
-	if (property.name=="constant") {
+	if (property.name == "constant") {
 
 		List<StringName> constants;
-		Variant::get_numeric_constants_for_type(type,&constants);
+		Variant::get_numeric_constants_for_type(type, &constants);
 
-		if (constants.size()==0) {
-			property.usage=0;
+		if (constants.size() == 0) {
+			property.usage = 0;
 			return;
 		}
-		property.hint_string="";
-		for(List<StringName>::Element *E=constants.front();E;E=E->next()) {
-			if (property.hint_string!=String()) {
-				property.hint_string+=",";
+		property.hint_string = "";
+		for (List<StringName>::Element *E = constants.front(); E; E = E->next()) {
+			if (property.hint_string != String()) {
+				property.hint_string += ",";
 			}
-			property.hint_string+=String(E->get());
+			property.hint_string += String(E->get());
 		}
-
 	}
 }
 
 void VisualScriptBasicTypeConstant::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_basic_type","name"),&VisualScriptBasicTypeConstant::set_basic_type);
-	ClassDB::bind_method(D_METHOD("get_basic_type"),&VisualScriptBasicTypeConstant::get_basic_type);
-
-	ClassDB::bind_method(D_METHOD("set_basic_type_constant","name"),&VisualScriptBasicTypeConstant::set_basic_type_constant);
-	ClassDB::bind_method(D_METHOD("get_basic_type_constant"),&VisualScriptBasicTypeConstant::get_basic_type_constant);
+	ClassDB::bind_method(D_METHOD("set_basic_type", "name"), &VisualScriptBasicTypeConstant::set_basic_type);
+	ClassDB::bind_method(D_METHOD("get_basic_type"), &VisualScriptBasicTypeConstant::get_basic_type);
 
+	ClassDB::bind_method(D_METHOD("set_basic_type_constant", "name"), &VisualScriptBasicTypeConstant::set_basic_type_constant);
+	ClassDB::bind_method(D_METHOD("get_basic_type_constant"), &VisualScriptBasicTypeConstant::get_basic_type_constant);
 
-	String argt="Null";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	String argt = "Null";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"basic_type",PROPERTY_HINT_ENUM,argt),"set_basic_type","get_basic_type");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"constant",PROPERTY_HINT_ENUM,""),"set_basic_type_constant","get_basic_type_constant");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "basic_type", PROPERTY_HINT_ENUM, argt), "set_basic_type", "get_basic_type");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant", PROPERTY_HINT_ENUM, ""), "set_basic_type_constant", "get_basic_type_constant");
 }
 
 VisualScriptBasicTypeConstant::VisualScriptBasicTypeConstant() {
 
-	type=Variant::NIL;
+	type = Variant::NIL;
 }
 
-
-
 //////////////////////////////////////////
 ////////////////MATHCONSTANT///////////
 //////////////////////////////////////////
 
-
-const char* VisualScriptMathConstant::const_name[MATH_CONSTANT_MAX]={
+const char *VisualScriptMathConstant::const_name[MATH_CONSTANT_MAX] = {
 	"One",
 	"PI",
 	"PIx2",
@@ -1771,33 +1649,32 @@ const char* VisualScriptMathConstant::const_name[MATH_CONSTANT_MAX]={
 	"NAN"
 };
 
-double VisualScriptMathConstant::const_value[MATH_CONSTANT_MAX]={
+double VisualScriptMathConstant::const_value[MATH_CONSTANT_MAX] = {
 	1.0,
 	Math_PI,
-	Math_PI*2,
-	Math_PI*0.5,
+	Math_PI * 2,
+	Math_PI * 0.5,
 	2.71828182845904523536,
 	Math::sqrt(2.0),
 	Math_INF,
 	Math_NAN
 };
 
-
 int VisualScriptMathConstant::get_output_sequence_port_count() const {
 
 	return 0;
 }
 
-bool VisualScriptMathConstant::has_input_sequence_port() const{
+bool VisualScriptMathConstant::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptMathConstant::get_input_value_port_count() const{
+int VisualScriptMathConstant::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptMathConstant::get_output_value_port_count() const{
+int VisualScriptMathConstant::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -1807,17 +1684,16 @@ String VisualScriptMathConstant::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptMathConstant::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptMathConstant::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptMathConstant::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptMathConstant::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::REAL,"value");
+	return PropertyInfo(Variant::REAL, "value");
 }
 
-
 String VisualScriptMathConstant::get_caption() const {
 
 	return "MathConst";
@@ -1830,7 +1706,7 @@ String VisualScriptMathConstant::get_text() const {
 
 void VisualScriptMathConstant::set_math_constant(MathConstant p_which) {
 
-	constant=p_which;
+	constant = p_which;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -1841,50 +1717,44 @@ VisualScriptMathConstant::MathConstant VisualScriptMathConstant::get_math_consta
 
 class VisualScriptNodeInstanceMathConstant : public VisualScriptNodeInstance {
 public:
-
 	float value;
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		*p_outputs[0]=value;
+		*p_outputs[0] = value;
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptMathConstant::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptMathConstant::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceMathConstant * instance = memnew(VisualScriptNodeInstanceMathConstant );
-	instance->value=const_value[constant];
+	VisualScriptNodeInstanceMathConstant *instance = memnew(VisualScriptNodeInstanceMathConstant);
+	instance->value = const_value[constant];
 	return instance;
 }
 
-
 void VisualScriptMathConstant::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_math_constant","which"),&VisualScriptMathConstant::set_math_constant);
-	ClassDB::bind_method(D_METHOD("get_math_constant"),&VisualScriptMathConstant::get_math_constant);
+	ClassDB::bind_method(D_METHOD("set_math_constant", "which"), &VisualScriptMathConstant::set_math_constant);
+	ClassDB::bind_method(D_METHOD("get_math_constant"), &VisualScriptMathConstant::get_math_constant);
 
 	String cc;
 
-	for(int i=0;i<MATH_CONSTANT_MAX;i++) {
+	for (int i = 0; i < MATH_CONSTANT_MAX; i++) {
 
-		if (i>0)
-			cc+=",";
-		cc+=const_name[i];
+		if (i > 0)
+			cc += ",";
+		cc += const_name[i];
 	}
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"constant",PROPERTY_HINT_ENUM,cc),"set_math_constant","get_math_constant");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "constant", PROPERTY_HINT_ENUM, cc), "set_math_constant", "get_math_constant");
 }
 
 VisualScriptMathConstant::VisualScriptMathConstant() {
 
-	constant=MATH_CONSTANT_ONE;
+	constant = MATH_CONSTANT_ONE;
 }
 
-
-
 //////////////////////////////////////////
 ////////////////GLOBALSINGLETON///////////
 //////////////////////////////////////////
@@ -1894,16 +1764,16 @@ int VisualScriptEngineSingleton::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptEngineSingleton::has_input_sequence_port() const{
+bool VisualScriptEngineSingleton::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptEngineSingleton::get_input_value_port_count() const{
+int VisualScriptEngineSingleton::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptEngineSingleton::get_output_value_port_count() const{
+int VisualScriptEngineSingleton::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -1913,17 +1783,16 @@ String VisualScriptEngineSingleton::get_output_sequence_port_text(int p_port) co
 	return String();
 }
 
-PropertyInfo VisualScriptEngineSingleton::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptEngineSingleton::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptEngineSingleton::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptEngineSingleton::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::OBJECT,"instance");
+	return PropertyInfo(Variant::OBJECT, "instance");
 }
 
-
 String VisualScriptEngineSingleton::get_caption() const {
 
 	return "EngineSingleton";
@@ -1934,9 +1803,9 @@ String VisualScriptEngineSingleton::get_text() const {
 	return singleton;
 }
 
-void VisualScriptEngineSingleton::set_singleton(const String& p_string) {
+void VisualScriptEngineSingleton::set_singleton(const String &p_string) {
 
-	singleton=p_string;
+	singleton = p_string;
 
 	_change_notify();
 	ports_changed_notify();
@@ -1946,48 +1815,43 @@ String VisualScriptEngineSingleton::get_singleton() {
 	return singleton;
 }
 
-
-
 class VisualScriptNodeInstanceEngineSingleton : public VisualScriptNodeInstance {
 public:
-
-	Object* singleton;
+	Object *singleton;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		*p_outputs[0]=singleton;
+		*p_outputs[0] = singleton;
 		return 0;
 	}
-
 };
 
-VisualScriptNodeInstance* VisualScriptEngineSingleton::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptEngineSingleton::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceEngineSingleton * instance = memnew(VisualScriptNodeInstanceEngineSingleton );
-	instance->singleton=GlobalConfig::get_singleton()->get_singleton_object(singleton);
+	VisualScriptNodeInstanceEngineSingleton *instance = memnew(VisualScriptNodeInstanceEngineSingleton);
+	instance->singleton = GlobalConfig::get_singleton()->get_singleton_object(singleton);
 	return instance;
 }
 
-VisualScriptEngineSingleton::TypeGuess VisualScriptEngineSingleton::guess_output_type(TypeGuess* p_inputs, int p_output) const {
+VisualScriptEngineSingleton::TypeGuess VisualScriptEngineSingleton::guess_output_type(TypeGuess *p_inputs, int p_output) const {
 
-	Object *obj=GlobalConfig::get_singleton()->get_singleton_object(singleton);
+	Object *obj = GlobalConfig::get_singleton()->get_singleton_object(singleton);
 	TypeGuess tg;
-	tg.type=Variant::OBJECT;
+	tg.type = Variant::OBJECT;
 	if (obj) {
-		tg.GDCLASS=obj->get_class();
-		tg.script=obj->get_script();
+		tg.GDCLASS = obj->get_class();
+		tg.script = obj->get_script();
 	}
 
 	return tg;
 }
 
-
 void VisualScriptEngineSingleton::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_singleton","name"),&VisualScriptEngineSingleton::set_singleton);
-	ClassDB::bind_method(D_METHOD("get_singleton"),&VisualScriptEngineSingleton::get_singleton);
+	ClassDB::bind_method(D_METHOD("set_singleton", "name"), &VisualScriptEngineSingleton::set_singleton);
+	ClassDB::bind_method(D_METHOD("get_singleton"), &VisualScriptEngineSingleton::get_singleton);
 
 	String cc;
 
@@ -1995,25 +1859,23 @@ void VisualScriptEngineSingleton::_bind_methods() {
 
 	GlobalConfig::get_singleton()->get_singletons(&singletons);
 
-	for (List<GlobalConfig::Singleton>::Element *E=singletons.front();E;E=E->next()) {
-		if (E->get().name=="VS" || E->get().name=="PS" || E->get().name=="PS2D" || E->get().name=="AS" || E->get().name=="TS" || E->get().name=="SS" || E->get().name=="SS2D")
+	for (List<GlobalConfig::Singleton>::Element *E = singletons.front(); E; E = E->next()) {
+		if (E->get().name == "VS" || E->get().name == "PS" || E->get().name == "PS2D" || E->get().name == "AS" || E->get().name == "TS" || E->get().name == "SS" || E->get().name == "SS2D")
 			continue; //skip these, too simple named
 
-		if (cc!=String())
-			cc+=",";
-		cc+=E->get().name;
+		if (cc != String())
+			cc += ",";
+		cc += E->get().name;
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"constant",PROPERTY_HINT_ENUM,cc),"set_singleton","get_singleton");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant", PROPERTY_HINT_ENUM, cc), "set_singleton", "get_singleton");
 }
 
 VisualScriptEngineSingleton::VisualScriptEngineSingleton() {
 
-	singleton=String();
+	singleton = String();
 }
 
-
-
 //////////////////////////////////////////
 ////////////////GETNODE///////////
 //////////////////////////////////////////
@@ -2023,16 +1885,16 @@ int VisualScriptSceneNode::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptSceneNode::has_input_sequence_port() const{
+bool VisualScriptSceneNode::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptSceneNode::get_input_value_port_count() const{
+int VisualScriptSceneNode::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptSceneNode::get_output_value_port_count() const{
+int VisualScriptSceneNode::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -2042,17 +1904,16 @@ String VisualScriptSceneNode::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptSceneNode::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSceneNode::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptSceneNode::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSceneNode::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::OBJECT,"node");
+	return PropertyInfo(Variant::OBJECT, "node");
 }
 
-
 String VisualScriptSceneNode::get_caption() const {
 
 	return "SceneNode";
@@ -2063,9 +1924,9 @@ String VisualScriptSceneNode::get_text() const {
 	return path.simplified();
 }
 
-void VisualScriptSceneNode::set_node_path(const NodePath& p_path) {
+void VisualScriptSceneNode::set_node_path(const NodePath &p_path) {
 
-	path=p_path;
+	path = p_path;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -2074,68 +1935,59 @@ NodePath VisualScriptSceneNode::get_node_path() {
 	return path;
 }
 
-
 class VisualScriptNodeInstanceSceneNode : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptSceneNode *node;
 	VisualScriptInstance *instance;
 	NodePath path;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		Node* node = instance->get_owner_ptr()->cast_to<Node>();
+		Node *node = instance->get_owner_ptr()->cast_to<Node>();
 		if (!node) {
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			r_error_str="Base object is not a Node!";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Base object is not a Node!";
 			return 0;
 		}
 
-
-
-		Node* another = node->get_node(path);
+		Node *another = node->get_node(path);
 		if (!node) {
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			r_error_str="Path does not lead Node!";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Path does not lead Node!";
 			return 0;
 		}
 
-		*p_outputs[0]=another;
+		*p_outputs[0] = another;
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptSceneNode::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptSceneNode::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceSceneNode * instance = memnew(VisualScriptNodeInstanceSceneNode );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->path=path;
+	VisualScriptNodeInstanceSceneNode *instance = memnew(VisualScriptNodeInstanceSceneNode);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->path = path;
 	return instance;
 }
 
-
-
-
 #ifdef TOOLS_ENABLED
 
-static Node* _find_script_node(Node* p_edited_scene,Node* p_current_node,const Ref<Script> &script) {
+static Node *_find_script_node(Node *p_edited_scene, Node *p_current_node, const Ref<Script> &script) {
 
-	if (p_edited_scene!=p_current_node && p_current_node->get_owner()!=p_edited_scene)
+	if (p_edited_scene != p_current_node && p_current_node->get_owner() != p_edited_scene)
 		return NULL;
 
 	Ref<Script> scr = p_current_node->get_script();
 
-	if (scr.is_valid() && scr==script)
+	if (scr.is_valid() && scr == script)
 		return p_current_node;
 
-	for(int i=0;i<p_current_node->get_child_count();i++) {
-		Node *n = _find_script_node(p_edited_scene,p_current_node->get_child(i),script);
+	for (int i = 0; i < p_current_node->get_child_count(); i++) {
+		Node *n = _find_script_node(p_edited_scene, p_current_node->get_child(i), script);
 		if (n)
 			return n;
 	}
@@ -2145,19 +1997,18 @@ static Node* _find_script_node(Node* p_edited_scene,Node* p_current_node,const R
 
 #endif
 
-VisualScriptSceneNode::TypeGuess VisualScriptSceneNode::guess_output_type(TypeGuess* p_inputs, int p_output) const {
-
+VisualScriptSceneNode::TypeGuess VisualScriptSceneNode::guess_output_type(TypeGuess *p_inputs, int p_output) const {
 
 	VisualScriptSceneNode::TypeGuess tg;
-	tg.type=Variant::OBJECT;
-	tg.GDCLASS="Node";
+	tg.type = Variant::OBJECT;
+	tg.GDCLASS = "Node";
 
 #ifdef TOOLS_ENABLED
 	Ref<Script> script = get_visual_script();
 	if (!script.is_valid())
 		return tg;
 
-	MainLoop * main_loop = OS::get_singleton()->get_main_loop();
+	MainLoop *main_loop = OS::get_singleton()->get_main_loop();
 	if (!main_loop)
 		return tg;
 
@@ -2171,33 +2022,31 @@ VisualScriptSceneNode::TypeGuess VisualScriptSceneNode::guess_output_type(TypeGu
 	if (!edited_scene)
 		return tg;
 
-	Node* script_node = _find_script_node(edited_scene,edited_scene,script);
+	Node *script_node = _find_script_node(edited_scene, edited_scene, script);
 
 	if (!script_node)
 		return tg;
 
-	Node* another = script_node->get_node(path);
+	Node *another = script_node->get_node(path);
 
 	if (another) {
-		tg.GDCLASS=another->get_class();
-		tg.script=another->get_script();
+		tg.GDCLASS = another->get_class();
+		tg.script = another->get_script();
 	}
 #endif
 	return tg;
-
 }
 
-
-void VisualScriptSceneNode::_validate_property(PropertyInfo& property) const {
+void VisualScriptSceneNode::_validate_property(PropertyInfo &property) const {
 
 #ifdef TOOLS_ENABLED
-	if (property.name=="node_path") {
+	if (property.name == "node_path") {
 
 		Ref<Script> script = get_visual_script();
 		if (!script.is_valid())
 			return;
 
-		MainLoop * main_loop = OS::get_singleton()->get_main_loop();
+		MainLoop *main_loop = OS::get_singleton()->get_main_loop();
 		if (!main_loop)
 			return;
 
@@ -2211,30 +2060,29 @@ void VisualScriptSceneNode::_validate_property(PropertyInfo& property) const {
 		if (!edited_scene)
 			return;
 
-		Node* script_node = _find_script_node(edited_scene,edited_scene,script);
+		Node *script_node = _find_script_node(edited_scene, edited_scene, script);
 
 		if (!script_node)
 			return;
 
-		property.hint_string=script_node->get_path();
+		property.hint_string = script_node->get_path();
 	}
 #endif
 }
 
 void VisualScriptSceneNode::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_node_path","path"),&VisualScriptSceneNode::set_node_path);
-	ClassDB::bind_method(D_METHOD("get_node_path"),&VisualScriptSceneNode::get_node_path);
+	ClassDB::bind_method(D_METHOD("set_node_path", "path"), &VisualScriptSceneNode::set_node_path);
+	ClassDB::bind_method(D_METHOD("get_node_path"), &VisualScriptSceneNode::get_node_path);
 
-	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"node_path",PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE),"set_node_path","get_node_path");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_path", PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE), "set_node_path", "get_node_path");
 }
 
 VisualScriptSceneNode::VisualScriptSceneNode() {
 
-	path=String(".");
+	path = String(".");
 }
 
-
 //////////////////////////////////////////
 ////////////////SceneTree///////////
 //////////////////////////////////////////
@@ -2244,16 +2092,16 @@ int VisualScriptSceneTree::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptSceneTree::has_input_sequence_port() const{
+bool VisualScriptSceneTree::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptSceneTree::get_input_value_port_count() const{
+int VisualScriptSceneTree::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptSceneTree::get_output_value_port_count() const{
+int VisualScriptSceneTree::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -2263,17 +2111,16 @@ String VisualScriptSceneTree::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptSceneTree::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSceneTree::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptSceneTree::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSceneTree::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::OBJECT,"instance");
+	return PropertyInfo(Variant::OBJECT, "instance");
 }
 
-
 String VisualScriptSceneTree::get_caption() const {
 
 	return "SceneTree";
@@ -2284,68 +2131,60 @@ String VisualScriptSceneTree::get_text() const {
 	return "";
 }
 
-
 class VisualScriptNodeInstanceSceneTree : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptSceneTree *node;
 	VisualScriptInstance *instance;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		Node* node = instance->get_owner_ptr()->cast_to<Node>();
+		Node *node = instance->get_owner_ptr()->cast_to<Node>();
 		if (!node) {
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			r_error_str="Base object is not a Node!";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Base object is not a Node!";
 			return 0;
 		}
 
-		SceneTree* tree = node->get_tree();
+		SceneTree *tree = node->get_tree();
 		if (!tree) {
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-			r_error_str="Attempt to get SceneTree while node is not in the active tree.";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Attempt to get SceneTree while node is not in the active tree.";
 			return 0;
 		}
 
-		*p_outputs[0]=tree;
+		*p_outputs[0] = tree;
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptSceneTree::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptSceneTree::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceSceneTree * instance = memnew(VisualScriptNodeInstanceSceneTree );
-	instance->node=this;
-	instance->instance=p_instance;
+	VisualScriptNodeInstanceSceneTree *instance = memnew(VisualScriptNodeInstanceSceneTree);
+	instance->node = this;
+	instance->instance = p_instance;
 	return instance;
 }
 
-VisualScriptSceneTree::TypeGuess VisualScriptSceneTree::guess_output_type(TypeGuess* p_inputs, int p_output) const {
+VisualScriptSceneTree::TypeGuess VisualScriptSceneTree::guess_output_type(TypeGuess *p_inputs, int p_output) const {
 
 	TypeGuess tg;
-	tg.type=Variant::OBJECT;
-	tg.GDCLASS="SceneTree";
+	tg.type = Variant::OBJECT;
+	tg.GDCLASS = "SceneTree";
 	return tg;
 }
 
-void VisualScriptSceneTree::_validate_property(PropertyInfo& property) const {
-
+void VisualScriptSceneTree::_validate_property(PropertyInfo &property) const {
 }
 
 void VisualScriptSceneTree::_bind_methods() {
-
 }
 
 VisualScriptSceneTree::VisualScriptSceneTree() {
-
 }
 
-
 //////////////////////////////////////////
 ////////////////RESPATH///////////
 //////////////////////////////////////////
@@ -2355,16 +2194,16 @@ int VisualScriptResourcePath::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptResourcePath::has_input_sequence_port() const{
+bool VisualScriptResourcePath::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptResourcePath::get_input_value_port_count() const{
+int VisualScriptResourcePath::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptResourcePath::get_output_value_port_count() const{
+int VisualScriptResourcePath::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -2374,17 +2213,16 @@ String VisualScriptResourcePath::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptResourcePath::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptResourcePath::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptResourcePath::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptResourcePath::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::STRING,"path");
+	return PropertyInfo(Variant::STRING, "path");
 }
 
-
 String VisualScriptResourcePath::get_caption() const {
 
 	return "ResourcePath";
@@ -2395,9 +2233,9 @@ String VisualScriptResourcePath::get_text() const {
 	return path;
 }
 
-void VisualScriptResourcePath::set_resource_path(const String& p_path) {
+void VisualScriptResourcePath::set_resource_path(const String &p_path) {
 
-	path=p_path;
+	path = p_path;
 	_change_notify();
 	ports_changed_notify();
 }
@@ -2406,47 +2244,39 @@ String VisualScriptResourcePath::get_resource_path() {
 	return path;
 }
 
-
 class VisualScriptNodeInstanceResourcePath : public VisualScriptNodeInstance {
 public:
-
 	String path;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		*p_outputs[0] = path;
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptResourcePath::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptResourcePath::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceResourcePath * instance = memnew(VisualScriptNodeInstanceResourcePath );
-	instance->path=path;
+	VisualScriptNodeInstanceResourcePath *instance = memnew(VisualScriptNodeInstanceResourcePath);
+	instance->path = path;
 	return instance;
 }
 
-
-
 void VisualScriptResourcePath::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_resource_path","path"),&VisualScriptResourcePath::set_resource_path);
-	ClassDB::bind_method(D_METHOD("get_resource_path"),&VisualScriptResourcePath::get_resource_path);
+	ClassDB::bind_method(D_METHOD("set_resource_path", "path"), &VisualScriptResourcePath::set_resource_path);
+	ClassDB::bind_method(D_METHOD("get_resource_path"), &VisualScriptResourcePath::get_resource_path);
 
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"path",PROPERTY_HINT_FILE),"set_resource_path","get_resource_path");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "path", PROPERTY_HINT_FILE), "set_resource_path", "get_resource_path");
 }
 
 VisualScriptResourcePath::VisualScriptResourcePath() {
 
-	path="";
+	path = "";
 }
 
-
-
 //////////////////////////////////////////
 ////////////////SELF///////////
 //////////////////////////////////////////
@@ -2456,16 +2286,16 @@ int VisualScriptSelf::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptSelf::has_input_sequence_port() const{
+bool VisualScriptSelf::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptSelf::get_input_value_port_count() const{
+int VisualScriptSelf::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptSelf::get_output_value_port_count() const{
+int VisualScriptSelf::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -2475,17 +2305,16 @@ String VisualScriptSelf::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptSelf::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSelf::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptSelf::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSelf::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::OBJECT,"instance");
+	return PropertyInfo(Variant::OBJECT, "instance");
 }
 
-
 String VisualScriptSelf::get_caption() const {
 
 	return "Self";
@@ -2499,56 +2328,46 @@ String VisualScriptSelf::get_text() const {
 		return "";
 }
 
-
 class VisualScriptNodeInstanceSelf : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		*p_outputs[0] = instance->get_owner_ptr();
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptSelf::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptSelf::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceSelf * instance = memnew(VisualScriptNodeInstanceSelf );
-	instance->instance=p_instance;
+	VisualScriptNodeInstanceSelf *instance = memnew(VisualScriptNodeInstanceSelf);
+	instance->instance = p_instance;
 	return instance;
 }
 
-VisualScriptSelf::TypeGuess VisualScriptSelf::guess_output_type(TypeGuess* p_inputs, int p_output) const {
+VisualScriptSelf::TypeGuess VisualScriptSelf::guess_output_type(TypeGuess *p_inputs, int p_output) const {
 
 	VisualScriptSceneNode::TypeGuess tg;
-	tg.type=Variant::OBJECT;
-	tg.GDCLASS="Object";
+	tg.type = Variant::OBJECT;
+	tg.GDCLASS = "Object";
 
 	Ref<Script> script = get_visual_script();
 	if (!script.is_valid())
 		return tg;
 
-	tg.GDCLASS=script->get_instance_base_type();
-	tg.script=script;
+	tg.GDCLASS = script->get_instance_base_type();
+	tg.script = script;
 
 	return tg;
-
-
 }
 
-
 void VisualScriptSelf::_bind_methods() {
-
 }
 
 VisualScriptSelf::VisualScriptSelf() {
-
-
 }
 
 //////////////////////////////////////////
@@ -2563,7 +2382,7 @@ int VisualScriptCustomNode::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptCustomNode::has_input_sequence_port() const{
+bool VisualScriptCustomNode::has_input_sequence_port() const {
 
 	if (get_script_instance() && get_script_instance()->has_method("_has_input_sequence_port")) {
 		return get_script_instance()->call("_has_input_sequence_port");
@@ -2571,14 +2390,14 @@ bool VisualScriptCustomNode::has_input_sequence_port() const{
 	return false;
 }
 
-int VisualScriptCustomNode::get_input_value_port_count() const{
+int VisualScriptCustomNode::get_input_value_port_count() const {
 
 	if (get_script_instance() && get_script_instance()->has_method("_get_input_value_port_count")) {
 		return get_script_instance()->call("_get_input_value_port_count");
 	}
 	return 0;
 }
-int VisualScriptCustomNode::get_output_value_port_count() const{
+int VisualScriptCustomNode::get_output_value_port_count() const {
 
 	if (get_script_instance() && get_script_instance()->has_method("_get_output_value_port_count")) {
 		return get_script_instance()->call("_get_output_value_port_count");
@@ -2589,37 +2408,36 @@ int VisualScriptCustomNode::get_output_value_port_count() const{
 String VisualScriptCustomNode::get_output_sequence_port_text(int p_port) const {
 
 	if (get_script_instance() && get_script_instance()->has_method("_get_output_sequence_port_text")) {
-		return get_script_instance()->call("_get_output_sequence_port_text",p_port);
+		return get_script_instance()->call("_get_output_sequence_port_text", p_port);
 	}
 
 	return String();
 }
 
-PropertyInfo VisualScriptCustomNode::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptCustomNode::get_input_value_port_info(int p_idx) const {
 
 	PropertyInfo info;
 	if (get_script_instance() && get_script_instance()->has_method("_get_input_value_port_type")) {
-		info.type=Variant::Type(int(get_script_instance()->call("_get_input_value_port_type",p_idx)));
+		info.type = Variant::Type(int(get_script_instance()->call("_get_input_value_port_type", p_idx)));
 	}
 	if (get_script_instance() && get_script_instance()->has_method("_get_input_value_port_name")) {
-		info.name=get_script_instance()->call("_get_input_value_port_name",p_idx);
+		info.name = get_script_instance()->call("_get_input_value_port_name", p_idx);
 	}
 	return info;
 }
 
-PropertyInfo VisualScriptCustomNode::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptCustomNode::get_output_value_port_info(int p_idx) const {
 
 	PropertyInfo info;
 	if (get_script_instance() && get_script_instance()->has_method("_get_output_value_port_type")) {
-		info.type=Variant::Type(int(get_script_instance()->call("_get_output_value_port_type",p_idx)));
+		info.type = Variant::Type(int(get_script_instance()->call("_get_output_value_port_type", p_idx)));
 	}
 	if (get_script_instance() && get_script_instance()->has_method("_get_output_value_port_name")) {
-		info.name=get_script_instance()->call("_get_output_value_port_name",p_idx);
+		info.name = get_script_instance()->call("_get_output_value_port_name", p_idx);
 	}
 	return info;
 }
 
-
 String VisualScriptCustomNode::get_caption() const {
 
 	if (get_script_instance() && get_script_instance()->has_method("_get_caption")) {
@@ -2646,21 +2464,20 @@ String VisualScriptCustomNode::get_category() const {
 
 class VisualScriptNodeInstanceCustomNode : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	VisualScriptCustomNode *node;
 	int in_count;
 	int out_count;
 	int work_mem_size;
 
 	virtual int get_working_memory_size() const { return work_mem_size; }
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		if (node->get_script_instance()) {
 #ifdef DEBUG_ENABLED
 			if (!node->get_script_instance()->has_method(VisualScriptLanguage::singleton->_step)) {
-				r_error_str=RTR("Custom node has no _step() method, can't process graph.");
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				r_error_str = RTR("Custom node has no _step() method, can't process graph.");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 				return 0;
 			}
 #endif
@@ -2670,111 +2487,102 @@ public:
 
 			in_values.resize(in_count);
 
-			for(int i=0;i<in_count;i++) {
-				in_values[i]=p_inputs[i];
+			for (int i = 0; i < in_count; i++) {
+				in_values[i] = p_inputs[i];
 			}
 
 			out_values.resize(in_count);
 
 			work_mem.resize(work_mem_size);
 
-			for(int i=0;i<work_mem_size;i++) {
-				work_mem[i]=p_working_mem[i];
+			for (int i = 0; i < work_mem_size; i++) {
+				work_mem[i] = p_working_mem[i];
 			}
 
 			int ret_out;
 
-			Variant ret = node->get_script_instance()->call(VisualScriptLanguage::singleton->_step,in_values,out_values,p_start_mode,work_mem);
-			if (ret.get_type()==Variant::STRING) {
-				r_error_str=ret;
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			Variant ret = node->get_script_instance()->call(VisualScriptLanguage::singleton->_step, in_values, out_values, p_start_mode, work_mem);
+			if (ret.get_type() == Variant::STRING) {
+				r_error_str = ret;
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 				return 0;
 			} else if (ret.is_num()) {
-				ret_out=ret;
+				ret_out = ret;
 			} else {
-				r_error_str=RTR("Invalid return value from _step(), must be integer (seq out), or string (error).");
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				r_error_str = RTR("Invalid return value from _step(), must be integer (seq out), or string (error).");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 				return 0;
 			}
 
-			for(int i=0;i<out_count;i++) {
-				if (i<out_values.size()) {
-					*p_outputs[i]=out_values[i];
+			for (int i = 0; i < out_count; i++) {
+				if (i < out_values.size()) {
+					*p_outputs[i] = out_values[i];
 				}
 			}
 
-			for(int i=0;i<work_mem_size;i++) {
-				if (i<work_mem.size()) {
-					p_working_mem[i]=work_mem[i];
+			for (int i = 0; i < work_mem_size; i++) {
+				if (i < work_mem.size()) {
+					p_working_mem[i] = work_mem[i];
 				}
 			}
 
 			return ret_out;
-
 		}
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptCustomNode::instance(VisualScriptInstance* p_instance) {
-
-	VisualScriptNodeInstanceCustomNode * instance = memnew(VisualScriptNodeInstanceCustomNode );
-	instance->instance=p_instance;
-	instance->in_count=get_input_value_port_count();
-	instance->out_count=get_output_value_port_count();
+VisualScriptNodeInstance *VisualScriptCustomNode::instance(VisualScriptInstance *p_instance) {
 
+	VisualScriptNodeInstanceCustomNode *instance = memnew(VisualScriptNodeInstanceCustomNode);
+	instance->instance = p_instance;
+	instance->in_count = get_input_value_port_count();
+	instance->out_count = get_output_value_port_count();
 
 	if (get_script_instance() && get_script_instance()->has_method("_get_working_memory_size")) {
 		instance->work_mem_size = get_script_instance()->call("_get_working_memory_size");
 	} else {
-		instance->work_mem_size=0;
+		instance->work_mem_size = 0;
 	}
 
 	return instance;
 }
 
-
-
 void VisualScriptCustomNode::_bind_methods() {
 
-	BIND_VMETHOD( MethodInfo(Variant::INT,"_get_output_sequence_port_count") );
-	BIND_VMETHOD( MethodInfo(Variant::BOOL,"_has_input_sequence_port") );
+	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_output_sequence_port_count"));
+	BIND_VMETHOD(MethodInfo(Variant::BOOL, "_has_input_sequence_port"));
 
-	BIND_VMETHOD( MethodInfo(Variant::STRING,"_get_output_sequence_port_text",PropertyInfo(Variant::INT,"idx")) );
-	BIND_VMETHOD( MethodInfo(Variant::INT,"_get_input_value_port_count") );
-	BIND_VMETHOD( MethodInfo(Variant::INT,"_get_output_value_port_count") );
+	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_output_sequence_port_text", PropertyInfo(Variant::INT, "idx")));
+	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_input_value_port_count"));
+	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_output_value_port_count"));
 
-	BIND_VMETHOD( MethodInfo(Variant::INT,"_get_input_value_port_type",PropertyInfo(Variant::INT,"idx")) );
-	BIND_VMETHOD( MethodInfo(Variant::STRING,"_get_input_value_port_name",PropertyInfo(Variant::INT,"idx")) );
+	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_input_value_port_type", PropertyInfo(Variant::INT, "idx")));
+	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_input_value_port_name", PropertyInfo(Variant::INT, "idx")));
 
-	BIND_VMETHOD( MethodInfo(Variant::INT,"_get_output_value_port_type",PropertyInfo(Variant::INT,"idx")) );
-	BIND_VMETHOD( MethodInfo(Variant::STRING,"_get_output_value_port_name",PropertyInfo(Variant::INT,"idx")) );
+	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_output_value_port_type", PropertyInfo(Variant::INT, "idx")));
+	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_output_value_port_name", PropertyInfo(Variant::INT, "idx")));
 
-	BIND_VMETHOD( MethodInfo(Variant::STRING,"_get_caption") );
-	BIND_VMETHOD( MethodInfo(Variant::STRING,"_get_text") );
-	BIND_VMETHOD( MethodInfo(Variant::STRING,"_get_category") );
+	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_caption"));
+	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_text"));
+	BIND_VMETHOD(MethodInfo(Variant::STRING, "_get_category"));
 
-	BIND_VMETHOD( MethodInfo(Variant::INT,"_get_working_memory_size") );
-	BIND_VMETHOD( MethodInfo(Variant::NIL,"_step:Variant",PropertyInfo(Variant::ARRAY,"inputs"),PropertyInfo(Variant::ARRAY,"outputs"),PropertyInfo(Variant::INT,"start_mode"),PropertyInfo(Variant::ARRAY,"working_mem")) );
+	BIND_VMETHOD(MethodInfo(Variant::INT, "_get_working_memory_size"));
+	BIND_VMETHOD(MethodInfo(Variant::NIL, "_step:Variant", PropertyInfo(Variant::ARRAY, "inputs"), PropertyInfo(Variant::ARRAY, "outputs"), PropertyInfo(Variant::INT, "start_mode"), PropertyInfo(Variant::ARRAY, "working_mem")));
 
-	BIND_CONSTANT( START_MODE_BEGIN_SEQUENCE );
-	BIND_CONSTANT( START_MODE_CONTINUE_SEQUENCE );
-	BIND_CONSTANT( START_MODE_RESUME_YIELD );
-
-	BIND_CONSTANT( STEP_PUSH_STACK_BIT );
-	BIND_CONSTANT( STEP_GO_BACK_BIT );
-	BIND_CONSTANT( STEP_NO_ADVANCE_BIT );
-	BIND_CONSTANT( STEP_EXIT_FUNCTION_BIT );
-	BIND_CONSTANT( STEP_YIELD_BIT );
+	BIND_CONSTANT(START_MODE_BEGIN_SEQUENCE);
+	BIND_CONSTANT(START_MODE_CONTINUE_SEQUENCE);
+	BIND_CONSTANT(START_MODE_RESUME_YIELD);
 
+	BIND_CONSTANT(STEP_PUSH_STACK_BIT);
+	BIND_CONSTANT(STEP_GO_BACK_BIT);
+	BIND_CONSTANT(STEP_NO_ADVANCE_BIT);
+	BIND_CONSTANT(STEP_EXIT_FUNCTION_BIT);
+	BIND_CONSTANT(STEP_YIELD_BIT);
 }
 
 VisualScriptCustomNode::VisualScriptCustomNode() {
-
-
 }
 
 //////////////////////////////////////////
@@ -2786,12 +2594,12 @@ int VisualScriptSubCall::get_output_sequence_port_count() const {
 	return 1;
 }
 
-bool VisualScriptSubCall::has_input_sequence_port() const{
+bool VisualScriptSubCall::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptSubCall::get_input_value_port_count() const{
+int VisualScriptSubCall::get_input_value_port_count() const {
 
 	Ref<Script> script = get_script();
 
@@ -2803,7 +2611,7 @@ int VisualScriptSubCall::get_input_value_port_count() const{
 
 	return 0;
 }
-int VisualScriptSubCall::get_output_value_port_count() const{
+int VisualScriptSubCall::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -2813,7 +2621,7 @@ String VisualScriptSubCall::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptSubCall::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSubCall::get_input_value_port_info(int p_idx) const {
 
 	Ref<Script> script = get_script();
 	if (script.is_valid() && script->has_method(VisualScriptLanguage::singleton->_subcall)) {
@@ -2825,7 +2633,7 @@ PropertyInfo VisualScriptSubCall::get_input_value_port_info(int p_idx) const{
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptSubCall::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptSubCall::get_output_value_port_info(int p_idx) const {
 
 	Ref<Script> script = get_script();
 	if (script.is_valid() && script->has_method(VisualScriptLanguage::singleton->_subcall)) {
@@ -2835,18 +2643,16 @@ PropertyInfo VisualScriptSubCall::get_output_value_port_info(int p_idx) const{
 	return PropertyInfo();
 }
 
-
 String VisualScriptSubCall::get_caption() const {
 
 	return "SubCall";
 }
 
-
 String VisualScriptSubCall::get_text() const {
 
 	Ref<Script> script = get_script();
 	if (script.is_valid()) {
-		if (script->get_name()!=String())
+		if (script->get_name() != String())
 			return script->get_name();
 		if (script->get_path().is_resource_file())
 			return script->get_path().get_file();
@@ -2862,53 +2668,45 @@ String VisualScriptSubCall::get_category() const {
 
 class VisualScriptNodeInstanceSubCall : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	VisualScriptSubCall *subcall;
 	int input_args;
 	bool valid;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		if (!valid) {
-			r_error_str="Node requires a script with a _subcall(<args>) method to work.";
-			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+			r_error_str = "Node requires a script with a _subcall(<args>) method to work.";
+			r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 			return 0;
 		}
-		*p_outputs[0]=subcall->call(VisualScriptLanguage::singleton->_subcall,p_inputs,input_args,r_error_str);
+		*p_outputs[0] = subcall->call(VisualScriptLanguage::singleton->_subcall, p_inputs, input_args, r_error_str);
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptSubCall::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptSubCall::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceSubCall * instance = memnew(VisualScriptNodeInstanceSubCall );
-	instance->instance=p_instance;
+	VisualScriptNodeInstanceSubCall *instance = memnew(VisualScriptNodeInstanceSubCall);
+	instance->instance = p_instance;
 	Ref<Script> script = get_script();
 	if (script.is_valid() && script->has_method(VisualScriptLanguage::singleton->_subcall)) {
-		instance->valid=true;
-		instance->input_args=get_input_value_port_count();
+		instance->valid = true;
+		instance->input_args = get_input_value_port_count();
 	} else {
-		instance->valid=false;
+		instance->valid = false;
 	}
 	return instance;
 }
 
-
-
 void VisualScriptSubCall::_bind_methods() {
 
-	BIND_VMETHOD( MethodInfo(Variant::NIL,"_subcall",PropertyInfo(Variant::NIL,"arguments:Variant")) );
-
+	BIND_VMETHOD(MethodInfo(Variant::NIL, "_subcall", PropertyInfo(Variant::NIL, "arguments:Variant")));
 }
 
 VisualScriptSubCall::VisualScriptSubCall() {
-
-
 }
 
 //////////////////////////////////////////
@@ -2920,15 +2718,15 @@ int VisualScriptComment::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptComment::has_input_sequence_port() const{
+bool VisualScriptComment::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptComment::get_input_value_port_count() const{
+int VisualScriptComment::get_input_value_port_count() const {
 	return 0;
 }
-int VisualScriptComment::get_output_value_port_count() const{
+int VisualScriptComment::get_output_value_port_count() const {
 
 	return 0;
 }
@@ -2938,69 +2736,63 @@ String VisualScriptComment::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptComment::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptComment::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptComment::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptComment::get_output_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-
 String VisualScriptComment::get_caption() const {
 
 	return title;
 }
 
-
 String VisualScriptComment::get_text() const {
 
 	return description;
 }
 
-void VisualScriptComment::set_title(const String& p_title) {
-
+void VisualScriptComment::set_title(const String &p_title) {
 
-	if (title==p_title)
+	if (title == p_title)
 		return;
-	title=p_title;
+	title = p_title;
 	ports_changed_notify();
 }
 
-String VisualScriptComment::get_title() const{
+String VisualScriptComment::get_title() const {
 
 	return title;
 }
 
-void VisualScriptComment::set_description(const String& p_description){
+void VisualScriptComment::set_description(const String &p_description) {
 
-	if (description==p_description)
+	if (description == p_description)
 		return;
-	description=p_description;
+	description = p_description;
 	ports_changed_notify();
-
 }
-String VisualScriptComment::get_description() const{
+String VisualScriptComment::get_description() const {
 
 	return description;
 }
 
-void VisualScriptComment::set_size(const Size2& p_size){
+void VisualScriptComment::set_size(const Size2 &p_size) {
 
-	if (size==p_size)
+	if (size == p_size)
 		return;
-	size=p_size;
+	size = p_size;
 	ports_changed_notify();
-
 }
-Size2 VisualScriptComment::get_size() const{
+Size2 VisualScriptComment::get_size() const {
 
 	return size;
 }
 
-
 String VisualScriptComment::get_category() const {
 
 	return "data";
@@ -3008,54 +2800,45 @@ String VisualScriptComment::get_category() const {
 
 class VisualScriptNodeInstanceComment : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
-
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptComment::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptComment::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceComment * instance = memnew(VisualScriptNodeInstanceComment );
-	instance->instance=p_instance;
+	VisualScriptNodeInstanceComment *instance = memnew(VisualScriptNodeInstanceComment);
+	instance->instance = p_instance;
 	return instance;
 }
 
-
-
 void VisualScriptComment::_bind_methods() {
 
+	ClassDB::bind_method(D_METHOD("set_title", "title"), &VisualScriptComment::set_title);
+	ClassDB::bind_method(D_METHOD("get_title"), &VisualScriptComment::get_title);
 
-	ClassDB::bind_method(D_METHOD("set_title","title"),&VisualScriptComment::set_title);
-	ClassDB::bind_method(D_METHOD("get_title"),&VisualScriptComment::get_title);
+	ClassDB::bind_method(D_METHOD("set_description", "description"), &VisualScriptComment::set_description);
+	ClassDB::bind_method(D_METHOD("get_description"), &VisualScriptComment::get_description);
 
-	ClassDB::bind_method(D_METHOD("set_description","description"),&VisualScriptComment::set_description);
-	ClassDB::bind_method(D_METHOD("get_description"),&VisualScriptComment::get_description);
-
-	ClassDB::bind_method(D_METHOD("set_size","size"),&VisualScriptComment::set_size);
-	ClassDB::bind_method(D_METHOD("get_size"),&VisualScriptComment::get_size);
-
-	ADD_PROPERTY( PropertyInfo(Variant::STRING,"title"),"set_title","get_title");
-	ADD_PROPERTY( PropertyInfo(Variant::STRING,"description",PROPERTY_HINT_MULTILINE_TEXT),"set_description","get_description");
-	ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"size"),"set_size","get_size");
+	ClassDB::bind_method(D_METHOD("set_size", "size"), &VisualScriptComment::set_size);
+	ClassDB::bind_method(D_METHOD("get_size"), &VisualScriptComment::get_size);
 
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "title"), "set_title", "get_title");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "description", PROPERTY_HINT_MULTILINE_TEXT), "set_description", "get_description");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
 }
 
 VisualScriptComment::VisualScriptComment() {
 
-	title="Comment";
-	size=Size2(150,150);
+	title = "Comment";
+	size = Size2(150, 150);
 }
 
-
 //////////////////////////////////////////
 ////////////////Constructor///////////
 //////////////////////////////////////////
@@ -3065,15 +2848,15 @@ int VisualScriptConstructor::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptConstructor::has_input_sequence_port() const{
+bool VisualScriptConstructor::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptConstructor::get_input_value_port_count() const{
+int VisualScriptConstructor::get_input_value_port_count() const {
 	return constructor.arguments.size();
 }
-int VisualScriptConstructor::get_output_value_port_count() const{
+int VisualScriptConstructor::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -3083,29 +2866,26 @@ String VisualScriptConstructor::get_output_sequence_port_text(int p_port) const
 	return "";
 }
 
-PropertyInfo VisualScriptConstructor::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptConstructor::get_input_value_port_info(int p_idx) const {
 
 	return constructor.arguments[p_idx];
 }
 
-PropertyInfo VisualScriptConstructor::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptConstructor::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(type,"value");
+	return PropertyInfo(type, "value");
 }
 
-
 String VisualScriptConstructor::get_caption() const {
 
 	return "Construct";
 }
 
-
 String VisualScriptConstructor::get_text() const {
 
-	return "new "+Variant::get_type_name(type)+"()";
+	return "new " + Variant::get_type_name(type) + "()";
 }
 
-
 String VisualScriptConstructor::get_category() const {
 
 	return "functions";
@@ -3113,10 +2893,10 @@ String VisualScriptConstructor::get_category() const {
 
 void VisualScriptConstructor::set_constructor_type(Variant::Type p_type) {
 
-	if (type==p_type)
+	if (type == p_type)
 		return;
 
-	type=p_type;
+	type = p_type;
 	ports_changed_notify();
 }
 
@@ -3125,9 +2905,9 @@ Variant::Type VisualScriptConstructor::get_constructor_type() const {
 	return type;
 }
 
-void VisualScriptConstructor::set_constructor(const Dictionary& p_info) {
+void VisualScriptConstructor::set_constructor(const Dictionary &p_info) {
 
-	constructor=MethodInfo::from_dict(p_info);
+	constructor = MethodInfo::from_dict(p_info);
 	ports_changed_notify();
 }
 
@@ -3136,65 +2916,57 @@ Dictionary VisualScriptConstructor::get_constructor() const {
 	return constructor;
 }
 
-
 class VisualScriptNodeInstanceConstructor : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	Variant::Type type;
 	int argcount;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
 		Variant::CallError ce;
-		*p_outputs[0]=Variant::construct(type,p_inputs,argcount,ce);
-		if (ce.error!=Variant::CallError::CALL_OK) {
-			r_error_str="Invalid arguments for constructor";
+		*p_outputs[0] = Variant::construct(type, p_inputs, argcount, ce);
+		if (ce.error != Variant::CallError::CALL_OK) {
+			r_error_str = "Invalid arguments for constructor";
 		}
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptConstructor::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptConstructor::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceConstructor * instance = memnew(VisualScriptNodeInstanceConstructor );
-	instance->instance=p_instance;
-	instance->type=type;
-	instance->argcount=constructor.arguments.size();
+	VisualScriptNodeInstanceConstructor *instance = memnew(VisualScriptNodeInstanceConstructor);
+	instance->instance = p_instance;
+	instance->type = type;
+	instance->argcount = constructor.arguments.size();
 	return instance;
 }
 
-
-
 void VisualScriptConstructor::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_constructor_type","type"),&VisualScriptConstructor::set_constructor_type);
-	ClassDB::bind_method(D_METHOD("get_constructor_type"),&VisualScriptConstructor::get_constructor_type);
-
-	ClassDB::bind_method(D_METHOD("set_constructor","constructor"),&VisualScriptConstructor::set_constructor);
-	ClassDB::bind_method(D_METHOD("get_constructor"),&VisualScriptConstructor::get_constructor);
+	ClassDB::bind_method(D_METHOD("set_constructor_type", "type"), &VisualScriptConstructor::set_constructor_type);
+	ClassDB::bind_method(D_METHOD("get_constructor_type"), &VisualScriptConstructor::get_constructor_type);
 
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"type",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"set_constructor_type","get_constructor_type");
-	ADD_PROPERTY( PropertyInfo(Variant::DICTIONARY,"constructor",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"set_constructor","get_constructor");
+	ClassDB::bind_method(D_METHOD("set_constructor", "constructor"), &VisualScriptConstructor::set_constructor);
+	ClassDB::bind_method(D_METHOD("get_constructor"), &VisualScriptConstructor::get_constructor);
 
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_constructor_type", "get_constructor_type");
+	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "constructor", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_constructor", "get_constructor");
 }
 
 VisualScriptConstructor::VisualScriptConstructor() {
 
-	type=Variant::NIL;
-
+	type = Variant::NIL;
 }
 
-static Map<String,Pair<Variant::Type,MethodInfo>  > constructor_map;
+static Map<String, Pair<Variant::Type, MethodInfo> > constructor_map;
 
-static Ref<VisualScriptNode> create_constructor_node(const String& p_name) {
+static Ref<VisualScriptNode> create_constructor_node(const String &p_name) {
 
-	ERR_FAIL_COND_V(!constructor_map.has(p_name),Ref<VisualScriptNode>());
+	ERR_FAIL_COND_V(!constructor_map.has(p_name), Ref<VisualScriptNode>());
 
 	Ref<VisualScriptConstructor> vsc;
 	vsc.instance();
@@ -3213,15 +2985,15 @@ int VisualScriptLocalVar::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptLocalVar::has_input_sequence_port() const{
+bool VisualScriptLocalVar::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptLocalVar::get_input_value_port_count() const{
+int VisualScriptLocalVar::get_input_value_port_count() const {
 	return 0;
 }
-int VisualScriptLocalVar::get_output_value_port_count() const{
+int VisualScriptLocalVar::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -3231,42 +3003,37 @@ String VisualScriptLocalVar::get_output_sequence_port_text(int p_port) const {
 	return "";
 }
 
-PropertyInfo VisualScriptLocalVar::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptLocalVar::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
-PropertyInfo VisualScriptLocalVar::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptLocalVar::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(type,"get");
+	return PropertyInfo(type, "get");
 }
 
-
 String VisualScriptLocalVar::get_caption() const {
 
 	return "LocalVarGet";
 }
 
-
 String VisualScriptLocalVar::get_text() const {
 
 	return name;
 }
 
-
 String VisualScriptLocalVar::get_category() const {
 
 	return "data";
 }
 
+void VisualScriptLocalVar::set_var_name(const StringName &p_name) {
 
-void VisualScriptLocalVar::set_var_name(const StringName& p_name) {
-
-	if (name==p_name)
+	if (name == p_name)
 		return;
 
-	name=p_name;
+	name = p_name;
 	ports_changed_notify();
-
 }
 
 StringName VisualScriptLocalVar::get_var_name() const {
@@ -3276,7 +3043,7 @@ StringName VisualScriptLocalVar::get_var_name() const {
 
 void VisualScriptLocalVar::set_var_type(Variant::Type p_type) {
 
-	type=p_type;
+	type = p_type;
 	ports_changed_notify();
 }
 
@@ -3285,59 +3052,49 @@ Variant::Type VisualScriptLocalVar::get_var_type() const {
 	return type;
 }
 
-
 class VisualScriptNodeInstanceLocalVar : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	StringName name;
 
-
 	virtual int get_working_memory_size() const { return 1; }
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		*p_outputs[0]=*p_working_mem;
+		*p_outputs[0] = *p_working_mem;
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptLocalVar::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptLocalVar::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceLocalVar * instance = memnew(VisualScriptNodeInstanceLocalVar );
-	instance->instance=p_instance;
-	instance->name=name;
+	VisualScriptNodeInstanceLocalVar *instance = memnew(VisualScriptNodeInstanceLocalVar);
+	instance->instance = p_instance;
+	instance->name = name;
 
 	return instance;
 }
 
-
-
 void VisualScriptLocalVar::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_var_name","name"),&VisualScriptLocalVar::set_var_name);
-	ClassDB::bind_method(D_METHOD("get_var_name"),&VisualScriptLocalVar::get_var_name);
+	ClassDB::bind_method(D_METHOD("set_var_name", "name"), &VisualScriptLocalVar::set_var_name);
+	ClassDB::bind_method(D_METHOD("get_var_name"), &VisualScriptLocalVar::get_var_name);
 
-	ClassDB::bind_method(D_METHOD("set_var_type","type"),&VisualScriptLocalVar::set_var_type);
-	ClassDB::bind_method(D_METHOD("get_var_type"),&VisualScriptLocalVar::get_var_type);
+	ClassDB::bind_method(D_METHOD("set_var_type", "type"), &VisualScriptLocalVar::set_var_type);
+	ClassDB::bind_method(D_METHOD("get_var_type"), &VisualScriptLocalVar::get_var_type);
 
-	String argt="Any";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	String argt = "Any";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-	ADD_PROPERTY( PropertyInfo(Variant::STRING,"variable/name"),"set_var_name","get_var_name");
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"variable/type",PROPERTY_HINT_ENUM,argt),"set_var_type","get_var_type");
-
-
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "variable/name"), "set_var_name", "get_var_name");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "variable/type", PROPERTY_HINT_ENUM, argt), "set_var_type", "get_var_type");
 }
 
 VisualScriptLocalVar::VisualScriptLocalVar() {
 
-	name="new_local";
-	type=Variant::NIL;
-
+	name = "new_local";
+	type = Variant::NIL;
 }
 
 //////////////////////////////////////////
@@ -3349,15 +3106,15 @@ int VisualScriptLocalVarSet::get_output_sequence_port_count() const {
 	return 1;
 }
 
-bool VisualScriptLocalVarSet::has_input_sequence_port() const{
+bool VisualScriptLocalVarSet::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptLocalVarSet::get_input_value_port_count() const{
+int VisualScriptLocalVarSet::get_input_value_port_count() const {
 	return 1;
 }
-int VisualScriptLocalVarSet::get_output_value_port_count() const{
+int VisualScriptLocalVarSet::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -3367,42 +3124,37 @@ String VisualScriptLocalVarSet::get_output_sequence_port_text(int p_port) const
 	return "";
 }
 
-PropertyInfo VisualScriptLocalVarSet::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptLocalVarSet::get_input_value_port_info(int p_idx) const {
 
-	return PropertyInfo(type,"set");
+	return PropertyInfo(type, "set");
 }
-PropertyInfo VisualScriptLocalVarSet::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptLocalVarSet::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(type,"get");
+	return PropertyInfo(type, "get");
 }
 
-
 String VisualScriptLocalVarSet::get_caption() const {
 
 	return "LocalVarSet";
 }
 
-
 String VisualScriptLocalVarSet::get_text() const {
 
 	return name;
 }
 
-
 String VisualScriptLocalVarSet::get_category() const {
 
 	return "data";
 }
 
+void VisualScriptLocalVarSet::set_var_name(const StringName &p_name) {
 
-void VisualScriptLocalVarSet::set_var_name(const StringName& p_name) {
-
-	if (name==p_name)
+	if (name == p_name)
 		return;
 
-	name=p_name;
+	name = p_name;
 	ports_changed_notify();
-
 }
 
 StringName VisualScriptLocalVarSet::get_var_name() const {
@@ -3412,7 +3164,7 @@ StringName VisualScriptLocalVarSet::get_var_name() const {
 
 void VisualScriptLocalVarSet::set_var_type(Variant::Type p_type) {
 
-	type=p_type;
+	type = p_type;
 	ports_changed_notify();
 }
 
@@ -3421,63 +3173,52 @@ Variant::Type VisualScriptLocalVarSet::get_var_type() const {
 	return type;
 }
 
-
 class VisualScriptNodeInstanceLocalVarSet : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	StringName name;
 
-
 	virtual int get_working_memory_size() const { return 1; }
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		*p_working_mem=*p_inputs[0];
-		*p_outputs[0]=*p_working_mem;
+		*p_working_mem = *p_inputs[0];
+		*p_outputs[0] = *p_working_mem;
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptLocalVarSet::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptLocalVarSet::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceLocalVarSet * instance = memnew(VisualScriptNodeInstanceLocalVarSet );
-	instance->instance=p_instance;
-	instance->name=name;
+	VisualScriptNodeInstanceLocalVarSet *instance = memnew(VisualScriptNodeInstanceLocalVarSet);
+	instance->instance = p_instance;
+	instance->name = name;
 
 	return instance;
 }
 
-
-
 void VisualScriptLocalVarSet::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_var_name","name"),&VisualScriptLocalVarSet::set_var_name);
-	ClassDB::bind_method(D_METHOD("get_var_name"),&VisualScriptLocalVarSet::get_var_name);
+	ClassDB::bind_method(D_METHOD("set_var_name", "name"), &VisualScriptLocalVarSet::set_var_name);
+	ClassDB::bind_method(D_METHOD("get_var_name"), &VisualScriptLocalVarSet::get_var_name);
 
-	ClassDB::bind_method(D_METHOD("set_var_type","type"),&VisualScriptLocalVarSet::set_var_type);
-	ClassDB::bind_method(D_METHOD("get_var_type"),&VisualScriptLocalVarSet::get_var_type);
+	ClassDB::bind_method(D_METHOD("set_var_type", "type"), &VisualScriptLocalVarSet::set_var_type);
+	ClassDB::bind_method(D_METHOD("get_var_type"), &VisualScriptLocalVarSet::get_var_type);
 
-	String argt="Any";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	String argt = "Any";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-	ADD_PROPERTY( PropertyInfo(Variant::STRING,"variable/name"),"set_var_name","get_var_name");
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"variable/type",PROPERTY_HINT_ENUM,argt),"set_var_type","get_var_type");
-
-
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "variable/name"), "set_var_name", "get_var_name");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "variable/type", PROPERTY_HINT_ENUM, argt), "set_var_type", "get_var_type");
 }
 
 VisualScriptLocalVarSet::VisualScriptLocalVarSet() {
 
-	name="new_local";
-	type=Variant::NIL;
-
+	name = "new_local";
+	type = Variant::NIL;
 }
 
-
 //////////////////////////////////////////
 ////////////////LocalVar///////////
 //////////////////////////////////////////
@@ -3487,15 +3228,15 @@ int VisualScriptInputAction::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptInputAction::has_input_sequence_port() const{
+bool VisualScriptInputAction::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptInputAction::get_input_value_port_count() const{
+int VisualScriptInputAction::get_input_value_port_count() const {
 	return 0;
 }
-int VisualScriptInputAction::get_output_value_port_count() const{
+int VisualScriptInputAction::get_output_value_port_count() const {
 
 	return 1;
 }
@@ -3505,58 +3246,52 @@ String VisualScriptInputAction::get_output_sequence_port_text(int p_port) const
 	return "";
 }
 
-PropertyInfo VisualScriptInputAction::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptInputAction::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
-PropertyInfo VisualScriptInputAction::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptInputAction::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(Variant::BOOL,"pressed");
+	return PropertyInfo(Variant::BOOL, "pressed");
 }
 
-
 String VisualScriptInputAction::get_caption() const {
 
-
 	return "Action";
 }
 
-
 String VisualScriptInputAction::get_text() const {
 
-	switch(mode) {
+	switch (mode) {
 		case MODE_PRESSED: {
 			return name;
 		} break;
 		case MODE_RELEASED: {
-			return "not "+name;
+			return "not " + name;
 		} break;
 		case MODE_JUST_PRESSED: {
-			return String(name)+" "+TTR("just pressed");
+			return String(name) + " " + TTR("just pressed");
 		} break;
 		case MODE_JUST_RELEASED: {
-			return String(name)+" "+TTR("just released");
+			return String(name) + " " + TTR("just released");
 		} break;
 	}
 
 	return String();
 }
 
-
 String VisualScriptInputAction::get_category() const {
 
 	return "data";
 }
 
+void VisualScriptInputAction::set_action_name(const StringName &p_name) {
 
-void VisualScriptInputAction::set_action_name(const StringName& p_name) {
-
-	if (name==p_name)
+	if (name == p_name)
 		return;
 
-	name=p_name;
+	name = p_name;
 	ports_changed_notify();
-
 }
 
 StringName VisualScriptInputAction::get_action_name() const {
@@ -3566,119 +3301,106 @@ StringName VisualScriptInputAction::get_action_name() const {
 
 void VisualScriptInputAction::set_action_mode(Mode p_mode) {
 
-	if (mode==p_mode)
+	if (mode == p_mode)
 		return;
 
-	mode=p_mode;
+	mode = p_mode;
 	ports_changed_notify();
-
 }
 VisualScriptInputAction::Mode VisualScriptInputAction::get_action_mode() const {
 
 	return mode;
 }
 
-
 class VisualScriptNodeInstanceInputAction : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	StringName action;
 	VisualScriptInputAction::Mode mode;
 
-
 	virtual int get_working_memory_size() const { return 1; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		switch(mode) {
+		switch (mode) {
 			case VisualScriptInputAction::MODE_PRESSED: {
-				*p_outputs[0]=Input::get_singleton()->is_action_pressed(action);
+				*p_outputs[0] = Input::get_singleton()->is_action_pressed(action);
 			} break;
 			case VisualScriptInputAction::MODE_RELEASED: {
-				*p_outputs[0]=!Input::get_singleton()->is_action_pressed(action);
+				*p_outputs[0] = !Input::get_singleton()->is_action_pressed(action);
 			} break;
 			case VisualScriptInputAction::MODE_JUST_PRESSED: {
-				*p_outputs[0]=Input::get_singleton()->is_action_just_pressed(action);
+				*p_outputs[0] = Input::get_singleton()->is_action_just_pressed(action);
 			} break;
-			case VisualScriptInputAction:: MODE_JUST_RELEASED: {
-				*p_outputs[0]=Input::get_singleton()->is_action_just_released(action);
+			case VisualScriptInputAction::MODE_JUST_RELEASED: {
+				*p_outputs[0] = Input::get_singleton()->is_action_just_released(action);
 			} break;
-
 		}
 
-
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptInputAction::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptInputAction::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceInputAction * instance = memnew(VisualScriptNodeInstanceInputAction );
-	instance->instance=p_instance;
-	instance->action=name;
-	instance->mode=mode;
+	VisualScriptNodeInstanceInputAction *instance = memnew(VisualScriptNodeInstanceInputAction);
+	instance->instance = p_instance;
+	instance->action = name;
+	instance->mode = mode;
 
 	return instance;
 }
 
-void VisualScriptInputAction::_validate_property(PropertyInfo& property) const {
+void VisualScriptInputAction::_validate_property(PropertyInfo &property) const {
 
+	if (property.name == "action") {
 
-	if (property.name=="action") {
-
-		property.hint=PROPERTY_HINT_ENUM;
+		property.hint = PROPERTY_HINT_ENUM;
 		String actions;
 
 		List<PropertyInfo> pinfo;
 		GlobalConfig::get_singleton()->get_property_list(&pinfo);
 		Vector<String> al;
 
-		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());
-
+			String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length());
 
 			al.push_back(name);
 		}
 
 		al.sort();
 
-		for(int i=0;i<al.size();i++) {
-			if (actions!=String())
-				actions+=",";
-			actions+=al[i];
+		for (int i = 0; i < al.size(); i++) {
+			if (actions != String())
+				actions += ",";
+			actions += al[i];
 		}
 
-		property.hint_string=actions;
+		property.hint_string = actions;
 	}
 }
 
-
 void VisualScriptInputAction::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_action_name","name"),&VisualScriptInputAction::set_action_name);
-	ClassDB::bind_method(D_METHOD("get_action_name"),&VisualScriptInputAction::get_action_name);
-
-	ClassDB::bind_method(D_METHOD("set_action_mode","mode"),&VisualScriptInputAction::set_action_mode);
-	ClassDB::bind_method(D_METHOD("get_action_mode"),&VisualScriptInputAction::get_action_mode);
+	ClassDB::bind_method(D_METHOD("set_action_name", "name"), &VisualScriptInputAction::set_action_name);
+	ClassDB::bind_method(D_METHOD("get_action_name"), &VisualScriptInputAction::get_action_name);
 
-	ADD_PROPERTY( PropertyInfo(Variant::STRING,"action"),"set_action_name","get_action_name");
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"mode",PROPERTY_HINT_ENUM,"Pressed,Released,JustPressed,JustReleased"),"set_action_mode","get_action_mode");
+	ClassDB::bind_method(D_METHOD("set_action_mode", "mode"), &VisualScriptInputAction::set_action_mode);
+	ClassDB::bind_method(D_METHOD("get_action_mode"), &VisualScriptInputAction::get_action_mode);
 
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "action"), "set_action_name", "get_action_name");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Pressed,Released,JustPressed,JustReleased"), "set_action_mode", "get_action_mode");
 }
 
 VisualScriptInputAction::VisualScriptInputAction() {
 
-	name="";
-	mode=MODE_PRESSED;
-
+	name = "";
+	mode = MODE_PRESSED;
 }
 
 //////////////////////////////////////////
@@ -3690,15 +3412,15 @@ int VisualScriptDeconstruct::get_output_sequence_port_count() const {
 	return 0;
 }
 
-bool VisualScriptDeconstruct::has_input_sequence_port() const{
+bool VisualScriptDeconstruct::has_input_sequence_port() const {
 
 	return false;
 }
 
-int VisualScriptDeconstruct::get_input_value_port_count() const{
+int VisualScriptDeconstruct::get_input_value_port_count() const {
 	return 1;
 }
-int VisualScriptDeconstruct::get_output_value_port_count() const{
+int VisualScriptDeconstruct::get_output_value_port_count() const {
 
 	return elements.size();
 }
@@ -3708,29 +3430,26 @@ String VisualScriptDeconstruct::get_output_sequence_port_text(int p_port) const
 	return "";
 }
 
-PropertyInfo VisualScriptDeconstruct::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptDeconstruct::get_input_value_port_info(int p_idx) const {
 
-	return PropertyInfo(type,"value");
+	return PropertyInfo(type, "value");
 }
 
-PropertyInfo VisualScriptDeconstruct::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptDeconstruct::get_output_value_port_info(int p_idx) const {
 
-	return PropertyInfo(elements[p_idx].type,elements[p_idx].name);
+	return PropertyInfo(elements[p_idx].type, elements[p_idx].name);
 }
 
-
 String VisualScriptDeconstruct::get_caption() const {
 
 	return "Deconstruct";
 }
 
-
 String VisualScriptDeconstruct::get_text() const {
 
-	return "from "+Variant::get_type_name(type)+":";
+	return "from " + Variant::get_type_name(type) + ":";
 }
 
-
 String VisualScriptDeconstruct::get_category() const {
 
 	return "functions";
@@ -3740,33 +3459,33 @@ void VisualScriptDeconstruct::_update_elements() {
 
 	elements.clear();
 	Variant v;
-	if (type==Variant::INPUT_EVENT) {
+	if (type == Variant::INPUT_EVENT) {
 		InputEvent ie;
-		ie.type=input_type;
-		v=ie;
+		ie.type = input_type;
+		v = ie;
 	} else {
 		Variant::CallError ce;
-		v = Variant::construct(type,NULL,0,ce);
+		v = Variant::construct(type, NULL, 0, ce);
 	}
 
 	List<PropertyInfo> pinfo;
 	v.get_property_list(&pinfo);
 
-	for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
+	for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
 
 		Element e;
-		e.name=E->get().name;
-		e.type=E->get().type;
+		e.name = E->get().name;
+		e.type = E->get().type;
 		elements.push_back(e);
 	}
 }
 
 void VisualScriptDeconstruct::set_deconstruct_type(Variant::Type p_type) {
 
-	if (type==p_type)
+	if (type == p_type)
 		return;
 
-	type=p_type;
+	type = p_type;
 	_update_elements();
 	ports_changed_notify();
 	_change_notify(); //to make input appear/disappear
@@ -3779,10 +3498,10 @@ Variant::Type VisualScriptDeconstruct::get_deconstruct_type() const {
 
 void VisualScriptDeconstruct::set_deconstruct_input_type(InputEvent::Type p_input_type) {
 
-	if (input_type==p_input_type)
+	if (input_type == p_input_type)
 		return;
 
-	input_type=p_input_type;
+	input_type = p_input_type;
 	_update_elements();
 	ports_changed_notify();
 }
@@ -3792,20 +3511,20 @@ InputEvent::Type VisualScriptDeconstruct::get_deconstruct_input_type() const {
 	return input_type;
 }
 
-void VisualScriptDeconstruct::_set_elem_cache(const Array& p_elements) {
+void VisualScriptDeconstruct::_set_elem_cache(const Array &p_elements) {
 
-	ERR_FAIL_COND(p_elements.size()%2==1);
-	elements.resize(p_elements.size()/2);
-	for(int i=0;i<elements.size();i++) {
-		elements[i].name=p_elements[i*2+0];
-		elements[i].type=Variant::Type(int(p_elements[i*2+1]));
+	ERR_FAIL_COND(p_elements.size() % 2 == 1);
+	elements.resize(p_elements.size() / 2);
+	for (int i = 0; i < elements.size(); i++) {
+		elements[i].name = p_elements[i * 2 + 0];
+		elements[i].type = Variant::Type(int(p_elements[i * 2 + 1]));
 	}
 }
 
 Array VisualScriptDeconstruct::_get_elem_cache() const {
 
 	Array ret;
-	for(int i=0;i<elements.size();i++) {
+	for (int i = 0; i < elements.size(); i++) {
 		ret.push_back(elements[i].name);
 		ret.push_back(elements[i].type);
 	}
@@ -3814,183 +3533,168 @@ Array VisualScriptDeconstruct::_get_elem_cache() const {
 
 class VisualScriptNodeInstanceDeconstruct : public VisualScriptNodeInstance {
 public:
-
-	VisualScriptInstance* instance;
+	VisualScriptInstance *instance;
 	Vector<StringName> outputs;
 
 	//virtual int get_working_memory_size() const { return 0; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		Variant in=*p_inputs[0];
+		Variant in = *p_inputs[0];
 
-		for(int i=0;i<outputs.size();i++) {
+		for (int i = 0; i < outputs.size(); i++) {
 			bool valid;
-			*p_outputs[i]=in.get(outputs[i],&valid);
+			*p_outputs[i] = in.get(outputs[i], &valid);
 			if (!valid) {
-				r_error_str="Can't obtain element '"+String(outputs[i])+"' from "+Variant::get_type_name(in.get_type());
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				r_error_str = "Can't obtain element '" + String(outputs[i]) + "' from " + Variant::get_type_name(in.get_type());
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 				return 0;
 			}
-
 		}
 
 		return 0;
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptDeconstruct::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptDeconstruct::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceDeconstruct * instance = memnew(VisualScriptNodeInstanceDeconstruct );
-	instance->instance=p_instance;
+	VisualScriptNodeInstanceDeconstruct *instance = memnew(VisualScriptNodeInstanceDeconstruct);
+	instance->instance = p_instance;
 	instance->outputs.resize(elements.size());
-	for(int i=0;i<elements.size();i++) {
-		instance->outputs[i]=elements[i].name;
+	for (int i = 0; i < elements.size(); i++) {
+		instance->outputs[i] = elements[i].name;
 	}
 
 	return instance;
 }
 
+void VisualScriptDeconstruct::_validate_property(PropertyInfo &property) const {
 
-
-void VisualScriptDeconstruct::_validate_property(PropertyInfo& property) const {
-
-	if (property.name=="input_type") {
-		if (type!=Variant::INPUT_EVENT) {
-			property.usage=0;
+	if (property.name == "input_type") {
+		if (type != Variant::INPUT_EVENT) {
+			property.usage = 0;
 		}
 	}
 }
 
-
 void VisualScriptDeconstruct::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_deconstruct_type","type"),&VisualScriptDeconstruct::set_deconstruct_type);
-	ClassDB::bind_method(D_METHOD("get_deconstruct_type"),&VisualScriptDeconstruct::get_deconstruct_type);
+	ClassDB::bind_method(D_METHOD("set_deconstruct_type", "type"), &VisualScriptDeconstruct::set_deconstruct_type);
+	ClassDB::bind_method(D_METHOD("get_deconstruct_type"), &VisualScriptDeconstruct::get_deconstruct_type);
 
-	ClassDB::bind_method(D_METHOD("set_deconstruct_input_type","input_type"),&VisualScriptDeconstruct::set_deconstruct_input_type);
-	ClassDB::bind_method(D_METHOD("get_deconstruct_input_type"),&VisualScriptDeconstruct::get_deconstruct_input_type);
+	ClassDB::bind_method(D_METHOD("set_deconstruct_input_type", "input_type"), &VisualScriptDeconstruct::set_deconstruct_input_type);
+	ClassDB::bind_method(D_METHOD("get_deconstruct_input_type"), &VisualScriptDeconstruct::get_deconstruct_input_type);
 
-	ClassDB::bind_method(D_METHOD("_set_elem_cache","_cache"),&VisualScriptDeconstruct::_set_elem_cache);
-	ClassDB::bind_method(D_METHOD("_get_elem_cache"),&VisualScriptDeconstruct::_get_elem_cache);
+	ClassDB::bind_method(D_METHOD("_set_elem_cache", "_cache"), &VisualScriptDeconstruct::_set_elem_cache);
+	ClassDB::bind_method(D_METHOD("_get_elem_cache"), &VisualScriptDeconstruct::_get_elem_cache);
 
-	String argt="Any";
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
-		argt+=","+Variant::get_type_name(Variant::Type(i));
+	String argt = "Any";
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
+		argt += "," + Variant::get_type_name(Variant::Type(i));
 	}
 
-	String iet="None,Key,MouseMotion,MouseButton,JoypadMotion,JoypadButton,ScreenTouch,ScreenDrag,Action";
-
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"type",PROPERTY_HINT_ENUM,argt),"set_deconstruct_type","get_deconstruct_type");
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"input_type",PROPERTY_HINT_ENUM,iet),"set_deconstruct_input_type","get_deconstruct_input_type");
-	ADD_PROPERTY( PropertyInfo(Variant::ARRAY,"elem_cache",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),"_set_elem_cache","_get_elem_cache");
+	String iet = "None,Key,MouseMotion,MouseButton,JoypadMotion,JoypadButton,ScreenTouch,ScreenDrag,Action";
 
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt), "set_deconstruct_type", "get_deconstruct_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "input_type", PROPERTY_HINT_ENUM, iet), "set_deconstruct_input_type", "get_deconstruct_input_type");
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "elem_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_elem_cache", "_get_elem_cache");
 }
 
 VisualScriptDeconstruct::VisualScriptDeconstruct() {
 
-	type=Variant::NIL;
-	input_type=InputEvent::NONE;
-
+	type = Variant::NIL;
+	input_type = InputEvent::NONE;
 }
 
-
 void register_visual_script_nodes() {
 
-	VisualScriptLanguage::singleton->add_register_func("data/set_variable",create_node_generic<VisualScriptVariableSet>);
-	VisualScriptLanguage::singleton->add_register_func("data/get_variable",create_node_generic<VisualScriptVariableGet>);
-	VisualScriptLanguage::singleton->add_register_func("data/engine_singleton",create_node_generic<VisualScriptEngineSingleton>);
-	VisualScriptLanguage::singleton->add_register_func("data/scene_node",create_node_generic<VisualScriptSceneNode>);
-	VisualScriptLanguage::singleton->add_register_func("data/scene_tree",create_node_generic<VisualScriptSceneTree>);
-	VisualScriptLanguage::singleton->add_register_func("data/resource_path",create_node_generic<VisualScriptResourcePath>);
-	VisualScriptLanguage::singleton->add_register_func("data/self",create_node_generic<VisualScriptSelf>);
-	VisualScriptLanguage::singleton->add_register_func("data/comment",create_node_generic<VisualScriptComment>);
-	VisualScriptLanguage::singleton->add_register_func("data/get_local_variable",create_node_generic<VisualScriptLocalVar>);
-	VisualScriptLanguage::singleton->add_register_func("data/set_local_variable",create_node_generic<VisualScriptLocalVarSet>);
-	VisualScriptLanguage::singleton->add_register_func("data/preload",create_node_generic<VisualScriptPreload>);
-	VisualScriptLanguage::singleton->add_register_func("data/action",create_node_generic<VisualScriptInputAction>);
-
-	VisualScriptLanguage::singleton->add_register_func("constants/constant",create_node_generic<VisualScriptConstant>);
-	VisualScriptLanguage::singleton->add_register_func("constants/math_constant",create_node_generic<VisualScriptMathConstant>);
-	VisualScriptLanguage::singleton->add_register_func("constants/class_constant",create_node_generic<VisualScriptClassConstant>);
-	VisualScriptLanguage::singleton->add_register_func("constants/global_constant",create_node_generic<VisualScriptGlobalConstant>);
-	VisualScriptLanguage::singleton->add_register_func("constants/basic_type_constant",create_node_generic<VisualScriptBasicTypeConstant>);
-
-	VisualScriptLanguage::singleton->add_register_func("custom/custom_node",create_node_generic<VisualScriptCustomNode>);
-	VisualScriptLanguage::singleton->add_register_func("custom/sub_call",create_node_generic<VisualScriptSubCall>);
-
-	VisualScriptLanguage::singleton->add_register_func("index/get_index",create_node_generic<VisualScriptIndexGet>);
-	VisualScriptLanguage::singleton->add_register_func("index/set_index",create_node_generic<VisualScriptIndexSet>);
-
-
-	VisualScriptLanguage::singleton->add_register_func("operators/compare/equal",create_op_node<Variant::OP_EQUAL>);
-	VisualScriptLanguage::singleton->add_register_func("operators/compare/not_equal",create_op_node<Variant::OP_NOT_EQUAL>);
-	VisualScriptLanguage::singleton->add_register_func("operators/compare/less",create_op_node<Variant::OP_LESS>);
-	VisualScriptLanguage::singleton->add_register_func("operators/compare/less_equal",create_op_node<Variant::OP_LESS_EQUAL>);
-	VisualScriptLanguage::singleton->add_register_func("operators/compare/greater",create_op_node<Variant::OP_GREATER>);
-	VisualScriptLanguage::singleton->add_register_func("operators/compare/greater_equal",create_op_node<Variant::OP_GREATER_EQUAL>);
+	VisualScriptLanguage::singleton->add_register_func("data/set_variable", create_node_generic<VisualScriptVariableSet>);
+	VisualScriptLanguage::singleton->add_register_func("data/get_variable", create_node_generic<VisualScriptVariableGet>);
+	VisualScriptLanguage::singleton->add_register_func("data/engine_singleton", create_node_generic<VisualScriptEngineSingleton>);
+	VisualScriptLanguage::singleton->add_register_func("data/scene_node", create_node_generic<VisualScriptSceneNode>);
+	VisualScriptLanguage::singleton->add_register_func("data/scene_tree", create_node_generic<VisualScriptSceneTree>);
+	VisualScriptLanguage::singleton->add_register_func("data/resource_path", create_node_generic<VisualScriptResourcePath>);
+	VisualScriptLanguage::singleton->add_register_func("data/self", create_node_generic<VisualScriptSelf>);
+	VisualScriptLanguage::singleton->add_register_func("data/comment", create_node_generic<VisualScriptComment>);
+	VisualScriptLanguage::singleton->add_register_func("data/get_local_variable", create_node_generic<VisualScriptLocalVar>);
+	VisualScriptLanguage::singleton->add_register_func("data/set_local_variable", create_node_generic<VisualScriptLocalVarSet>);
+	VisualScriptLanguage::singleton->add_register_func("data/preload", create_node_generic<VisualScriptPreload>);
+	VisualScriptLanguage::singleton->add_register_func("data/action", create_node_generic<VisualScriptInputAction>);
+
+	VisualScriptLanguage::singleton->add_register_func("constants/constant", create_node_generic<VisualScriptConstant>);
+	VisualScriptLanguage::singleton->add_register_func("constants/math_constant", create_node_generic<VisualScriptMathConstant>);
+	VisualScriptLanguage::singleton->add_register_func("constants/class_constant", create_node_generic<VisualScriptClassConstant>);
+	VisualScriptLanguage::singleton->add_register_func("constants/global_constant", create_node_generic<VisualScriptGlobalConstant>);
+	VisualScriptLanguage::singleton->add_register_func("constants/basic_type_constant", create_node_generic<VisualScriptBasicTypeConstant>);
+
+	VisualScriptLanguage::singleton->add_register_func("custom/custom_node", create_node_generic<VisualScriptCustomNode>);
+	VisualScriptLanguage::singleton->add_register_func("custom/sub_call", create_node_generic<VisualScriptSubCall>);
+
+	VisualScriptLanguage::singleton->add_register_func("index/get_index", create_node_generic<VisualScriptIndexGet>);
+	VisualScriptLanguage::singleton->add_register_func("index/set_index", create_node_generic<VisualScriptIndexSet>);
+
+	VisualScriptLanguage::singleton->add_register_func("operators/compare/equal", create_op_node<Variant::OP_EQUAL>);
+	VisualScriptLanguage::singleton->add_register_func("operators/compare/not_equal", create_op_node<Variant::OP_NOT_EQUAL>);
+	VisualScriptLanguage::singleton->add_register_func("operators/compare/less", create_op_node<Variant::OP_LESS>);
+	VisualScriptLanguage::singleton->add_register_func("operators/compare/less_equal", create_op_node<Variant::OP_LESS_EQUAL>);
+	VisualScriptLanguage::singleton->add_register_func("operators/compare/greater", create_op_node<Variant::OP_GREATER>);
+	VisualScriptLanguage::singleton->add_register_func("operators/compare/greater_equal", create_op_node<Variant::OP_GREATER_EQUAL>);
 	//mathematic
-	VisualScriptLanguage::singleton->add_register_func("operators/math/add",create_op_node<Variant::OP_ADD>);
-	VisualScriptLanguage::singleton->add_register_func("operators/math/subtract",create_op_node<Variant::OP_SUBSTRACT>);
-	VisualScriptLanguage::singleton->add_register_func("operators/math/multiply",create_op_node<Variant::OP_MULTIPLY>);
-	VisualScriptLanguage::singleton->add_register_func("operators/math/divide",create_op_node<Variant::OP_DIVIDE>);
-	VisualScriptLanguage::singleton->add_register_func("operators/math/negate",create_op_node<Variant::OP_NEGATE>);
-	VisualScriptLanguage::singleton->add_register_func("operators/math/positive",create_op_node<Variant::OP_POSITIVE>);
-	VisualScriptLanguage::singleton->add_register_func("operators/math/remainder",create_op_node<Variant::OP_MODULE>);
-	VisualScriptLanguage::singleton->add_register_func("operators/math/string_concat",create_op_node<Variant::OP_STRING_CONCAT>);
+	VisualScriptLanguage::singleton->add_register_func("operators/math/add", create_op_node<Variant::OP_ADD>);
+	VisualScriptLanguage::singleton->add_register_func("operators/math/subtract", create_op_node<Variant::OP_SUBSTRACT>);
+	VisualScriptLanguage::singleton->add_register_func("operators/math/multiply", create_op_node<Variant::OP_MULTIPLY>);
+	VisualScriptLanguage::singleton->add_register_func("operators/math/divide", create_op_node<Variant::OP_DIVIDE>);
+	VisualScriptLanguage::singleton->add_register_func("operators/math/negate", create_op_node<Variant::OP_NEGATE>);
+	VisualScriptLanguage::singleton->add_register_func("operators/math/positive", create_op_node<Variant::OP_POSITIVE>);
+	VisualScriptLanguage::singleton->add_register_func("operators/math/remainder", create_op_node<Variant::OP_MODULE>);
+	VisualScriptLanguage::singleton->add_register_func("operators/math/string_concat", create_op_node<Variant::OP_STRING_CONCAT>);
 	//bitwise
-	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/shift_left",create_op_node<Variant::OP_SHIFT_LEFT>);
-	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/shift_right",create_op_node<Variant::OP_SHIFT_RIGHT>);
-	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/bit_and",create_op_node<Variant::OP_BIT_AND>);
-	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/bit_or",create_op_node<Variant::OP_BIT_OR>);
-	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/bit_xor",create_op_node<Variant::OP_BIT_XOR>);
-	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/bit_negate",create_op_node<Variant::OP_BIT_NEGATE>);
+	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/shift_left", create_op_node<Variant::OP_SHIFT_LEFT>);
+	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/shift_right", create_op_node<Variant::OP_SHIFT_RIGHT>);
+	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/bit_and", create_op_node<Variant::OP_BIT_AND>);
+	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/bit_or", create_op_node<Variant::OP_BIT_OR>);
+	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/bit_xor", create_op_node<Variant::OP_BIT_XOR>);
+	VisualScriptLanguage::singleton->add_register_func("operators/bitwise/bit_negate", create_op_node<Variant::OP_BIT_NEGATE>);
 	//logic
-	VisualScriptLanguage::singleton->add_register_func("operators/logic/and",create_op_node<Variant::OP_AND>);
-	VisualScriptLanguage::singleton->add_register_func("operators/logic/or",create_op_node<Variant::OP_OR>);
-	VisualScriptLanguage::singleton->add_register_func("operators/logic/xor",create_op_node<Variant::OP_XOR>);
-	VisualScriptLanguage::singleton->add_register_func("operators/logic/not",create_op_node<Variant::OP_NOT>);
-	VisualScriptLanguage::singleton->add_register_func("operators/logic/in",create_op_node<Variant::OP_IN>);
+	VisualScriptLanguage::singleton->add_register_func("operators/logic/and", create_op_node<Variant::OP_AND>);
+	VisualScriptLanguage::singleton->add_register_func("operators/logic/or", create_op_node<Variant::OP_OR>);
+	VisualScriptLanguage::singleton->add_register_func("operators/logic/xor", create_op_node<Variant::OP_XOR>);
+	VisualScriptLanguage::singleton->add_register_func("operators/logic/not", create_op_node<Variant::OP_NOT>);
+	VisualScriptLanguage::singleton->add_register_func("operators/logic/in", create_op_node<Variant::OP_IN>);
 
-	VisualScriptLanguage::singleton->add_register_func("functions/deconstruct",create_node_generic<VisualScriptDeconstruct>);
+	VisualScriptLanguage::singleton->add_register_func("functions/deconstruct", create_node_generic<VisualScriptDeconstruct>);
 
-	for(int i=1;i<Variant::VARIANT_MAX;i++) {
+	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
 
 		List<MethodInfo> constructors;
-		Variant::get_constructor_list(Variant::Type(i),&constructors);
+		Variant::get_constructor_list(Variant::Type(i), &constructors);
 
-		for(List<MethodInfo>::Element *E=constructors.front();E;E=E->next()) {
+		for (List<MethodInfo>::Element *E = constructors.front(); E; E = E->next()) {
 
-			if  (E->get().arguments.size()>0) {
+			if (E->get().arguments.size() > 0) {
 
-
-				String name = "functions/constructors/"+Variant::get_type_name(Variant::Type(i))+" ( ";
-				for(int j=0;j<E->get().arguments.size();j++) {
-					if (j>0)
-						name+=", ";
-					if (E->get().arguments.size()==1)
-						name+=Variant::get_type_name(E->get().arguments[j].type);
+				String name = "functions/constructors/" + Variant::get_type_name(Variant::Type(i)) + " ( ";
+				for (int j = 0; j < E->get().arguments.size(); j++) {
+					if (j > 0)
+						name += ", ";
+					if (E->get().arguments.size() == 1)
+						name += Variant::get_type_name(E->get().arguments[j].type);
 					else
-						name+=E->get().arguments[j].name;
+						name += E->get().arguments[j].name;
 				}
-				name+=") ";
+				name += ") ";
 
-				VisualScriptLanguage::singleton->add_register_func(name,create_constructor_node);
-				Pair<Variant::Type,MethodInfo> pair;
-				pair.first=Variant::Type(i);
-				pair.second=E->get();
-				constructor_map[name]=pair;
+				VisualScriptLanguage::singleton->add_register_func(name, create_constructor_node);
+				Pair<Variant::Type, MethodInfo> pair;
+				pair.first = Variant::Type(i);
+				pair.second = E->get();
+				constructor_map[name] = pair;
 			}
 		}
 	}
 }
 
-
-
 void unregister_visual_script_nodes() {
 
 	constructor_map.clear();
 }
-
diff --git a/modules/visual_script/visual_script_nodes.h b/modules/visual_script/visual_script_nodes.h
index 2e7fb0536c..b2fc115660 100644
--- a/modules/visual_script/visual_script_nodes.h
+++ b/modules/visual_script/visual_script_nodes.h
@@ -33,8 +33,7 @@
 
 class VisualScriptFunction : public VisualScriptNode {
 
-	GDCLASS(VisualScriptFunction,VisualScriptNode)
-
+	GDCLASS(VisualScriptFunction, VisualScriptNode)
 
 	struct Argument {
 		String name;
@@ -47,26 +46,20 @@ class VisualScriptFunction : public VisualScriptNode {
 	int stack_size;
 	ScriptInstance::RPCMode rpc_mode;
 
-
 protected:
-
-	bool _set(const StringName& p_name, const Variant& p_value);
-	bool _get(const StringName& p_name,Variant &r_ret) const;
-	void _get_property_list( List<PropertyInfo> *p_list) const;
+	bool _set(const StringName &p_name, const Variant &p_value);
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	void _get_property_list(List<PropertyInfo> *p_list) const;
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -74,15 +67,14 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "flow_control"; }
 
-	void add_argument(Variant::Type p_type,const String& p_name,int p_index=-1);
-	void set_argument_type(int p_argidx,Variant::Type p_type);
+	void add_argument(Variant::Type p_type, const String &p_name, int p_index = -1);
+	void set_argument_type(int p_argidx, Variant::Type p_type);
 	Variant::Type get_argument_type(int p_argidx) const;
-	void set_argument_name(int p_argidx,const String& p_name);
+	void set_argument_name(int p_argidx, const String &p_name);
 	String get_argument_name(int p_argidx) const;
 	void remove_argument(int p_argidx);
 	int get_argument_count() const;
 
-
 	void set_stack_less(bool p_enable);
 	bool is_stack_less() const;
 
@@ -92,35 +84,30 @@ public:
 	void set_rpc_mode(ScriptInstance::RPCMode p_mode);
 	ScriptInstance::RPCMode get_rpc_mode() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptFunction();
 };
 
-
 class VisualScriptOperator : public VisualScriptNode {
 
-	GDCLASS(VisualScriptOperator,VisualScriptNode)
-
+	GDCLASS(VisualScriptOperator, VisualScriptNode)
 
 	Variant::Type typed;
 	Variant::Operator op;
-protected:
 
+protected:
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -134,35 +121,30 @@ public:
 	void set_typed(Variant::Type p_op);
 	Variant::Type get_typed() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptOperator();
 };
 
-
 class VisualScriptVariableGet : public VisualScriptNode {
 
-	GDCLASS(VisualScriptVariableGet,VisualScriptNode)
-
+	GDCLASS(VisualScriptVariableGet, VisualScriptNode)
 
 	StringName variable;
-protected:
 
-	virtual void _validate_property(PropertyInfo& property) const;
+protected:
+	virtual void _validate_property(PropertyInfo &property) const;
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -173,35 +155,30 @@ public:
 	void set_variable(StringName p_var);
 	StringName get_variable() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptVariableGet();
 };
 
-
 class VisualScriptVariableSet : public VisualScriptNode {
 
-	GDCLASS(VisualScriptVariableSet,VisualScriptNode)
-
+	GDCLASS(VisualScriptVariableSet, VisualScriptNode)
 
 	StringName variable;
-protected:
 
-	virtual void _validate_property(PropertyInfo& property) const;
+protected:
+	virtual void _validate_property(PropertyInfo &property) const;
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -212,36 +189,31 @@ public:
 	void set_variable(StringName p_var);
 	StringName get_variable() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptVariableSet();
 };
 
-
 class VisualScriptConstant : public VisualScriptNode {
 
-	GDCLASS(VisualScriptConstant,VisualScriptNode)
-
+	GDCLASS(VisualScriptConstant, VisualScriptNode)
 
 	Variant::Type type;
 	Variant value;
+
 protected:
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 	static void _bind_methods();
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -255,36 +227,29 @@ public:
 	void set_constant_value(Variant p_value);
 	Variant get_constant_value() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptConstant();
 };
 
-
-
 class VisualScriptPreload : public VisualScriptNode {
 
-	GDCLASS(VisualScriptPreload,VisualScriptNode)
-
+	GDCLASS(VisualScriptPreload, VisualScriptNode)
 
 	Ref<Resource> preload;
-protected:
 
+protected:
 	static void _bind_methods();
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -292,32 +257,27 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "data"; }
 
-	void set_preload(const Ref<Resource>& p_value);
+	void set_preload(const Ref<Resource> &p_value);
 	Ref<Resource> get_preload() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptPreload();
 };
 
 class VisualScriptIndexGet : public VisualScriptNode {
 
-	GDCLASS(VisualScriptIndexGet,VisualScriptNode)
-
+	GDCLASS(VisualScriptIndexGet, VisualScriptNode)
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -325,30 +285,24 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "operators"; }
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptIndexGet();
 };
 
-
 class VisualScriptIndexSet : public VisualScriptNode {
 
-	GDCLASS(VisualScriptIndexSet,VisualScriptNode)
-
+	GDCLASS(VisualScriptIndexSet, VisualScriptNode)
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -356,33 +310,28 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "operators"; }
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptIndexSet();
 };
 
-
-
 class VisualScriptGlobalConstant : public VisualScriptNode {
 
-	GDCLASS(VisualScriptGlobalConstant,VisualScriptNode)
+	GDCLASS(VisualScriptGlobalConstant, VisualScriptNode)
 
 	int index;
 
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -393,35 +342,31 @@ public:
 	void set_global_constant(int p_which);
 	int get_global_constant();
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptGlobalConstant();
 };
 
-
 class VisualScriptClassConstant : public VisualScriptNode {
 
-	GDCLASS(VisualScriptClassConstant,VisualScriptNode)
+	GDCLASS(VisualScriptClassConstant, VisualScriptNode)
 
 	StringName base_type;
 	StringName name;
+
 protected:
 	static void _bind_methods();
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -429,40 +374,37 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "constants"; }
 
-	void set_class_constant(const StringName& p_which);
+	void set_class_constant(const StringName &p_which);
 	StringName get_class_constant();
 
-	void set_base_type(const StringName& p_which);
+	void set_base_type(const StringName &p_which);
 	StringName get_base_type();
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptClassConstant();
 };
 
 class VisualScriptBasicTypeConstant : public VisualScriptNode {
 
-	GDCLASS(VisualScriptBasicTypeConstant,VisualScriptNode)
+	GDCLASS(VisualScriptBasicTypeConstant, VisualScriptNode)
 
 	Variant::Type type;
 	StringName name;
+
 protected:
 	static void _bind_methods();
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -470,24 +412,21 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "constants"; }
 
-	void set_basic_type_constant(const StringName& p_which);
+	void set_basic_type_constant(const StringName &p_which);
 	StringName get_basic_type_constant() const;
 
 	void set_basic_type(Variant::Type p_which);
 	Variant::Type get_basic_type() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptBasicTypeConstant();
 };
 
-
-
 class VisualScriptMathConstant : public VisualScriptNode {
 
-	GDCLASS(VisualScriptMathConstant,VisualScriptNode)
+	GDCLASS(VisualScriptMathConstant, VisualScriptNode)
 public:
-
 	enum MathConstant {
 		MATH_CONSTANT_ONE,
 		MATH_CONSTANT_PI,
@@ -501,24 +440,22 @@ public:
 	};
 
 private:
-	static const char* const_name[MATH_CONSTANT_MAX];
+	static const char *const_name[MATH_CONSTANT_MAX];
 	static double const_value[MATH_CONSTANT_MAX];
 	MathConstant constant;
+
 protected:
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -529,33 +466,30 @@ public:
 	void set_math_constant(MathConstant p_which);
 	MathConstant get_math_constant();
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptMathConstant();
 };
 
-VARIANT_ENUM_CAST( VisualScriptMathConstant::MathConstant )
+VARIANT_ENUM_CAST(VisualScriptMathConstant::MathConstant)
 
 class VisualScriptEngineSingleton : public VisualScriptNode {
 
-	GDCLASS(VisualScriptEngineSingleton,VisualScriptNode)
+	GDCLASS(VisualScriptEngineSingleton, VisualScriptNode)
 
 	String singleton;
 
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -566,38 +500,32 @@ public:
 	void set_singleton(const String &p_string);
 	String get_singleton();
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
-
-	virtual TypeGuess guess_output_type(TypeGuess* p_inputs, int p_output) const;
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
+	virtual TypeGuess guess_output_type(TypeGuess *p_inputs, int p_output) const;
 
 	VisualScriptEngineSingleton();
 };
 
-
-
-
 class VisualScriptSceneNode : public VisualScriptNode {
 
-	GDCLASS(VisualScriptSceneNode,VisualScriptNode)
+	GDCLASS(VisualScriptSceneNode, VisualScriptNode)
 
 	NodePath path;
+
 protected:
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -608,37 +536,30 @@ public:
 	void set_node_path(const NodePath &p_path);
 	NodePath get_node_path();
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
-	virtual TypeGuess guess_output_type(TypeGuess* p_inputs, int p_output) const;
+	virtual TypeGuess guess_output_type(TypeGuess *p_inputs, int p_output) const;
 
 	VisualScriptSceneNode();
 };
 
-
-
-
 class VisualScriptSceneTree : public VisualScriptNode {
 
-	GDCLASS(VisualScriptSceneTree,VisualScriptNode)
-
+	GDCLASS(VisualScriptSceneTree, VisualScriptNode)
 
 protected:
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -646,36 +567,31 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "data"; }
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
-	virtual TypeGuess guess_output_type(TypeGuess* p_inputs, int p_output) const;
+	virtual TypeGuess guess_output_type(TypeGuess *p_inputs, int p_output) const;
 
 	VisualScriptSceneTree();
 };
 
-
-
 class VisualScriptResourcePath : public VisualScriptNode {
 
-	GDCLASS(VisualScriptResourcePath,VisualScriptNode)
+	GDCLASS(VisualScriptResourcePath, VisualScriptNode)
 
 	String path;
-protected:
 
+protected:
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -686,33 +602,27 @@ public:
 	void set_resource_path(const String &p_path);
 	String get_resource_path();
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptResourcePath();
 };
 
-
 class VisualScriptSelf : public VisualScriptNode {
 
-	GDCLASS(VisualScriptSelf,VisualScriptNode)
-
+	GDCLASS(VisualScriptSelf, VisualScriptNode)
 
 protected:
-
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -720,25 +630,21 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "data"; }
 
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
-
-	virtual TypeGuess guess_output_type(TypeGuess* p_inputs, int p_output) const;
+	virtual TypeGuess guess_output_type(TypeGuess *p_inputs, int p_output) const;
 
 	VisualScriptSelf();
 };
 
+class VisualScriptCustomNode : public VisualScriptNode {
 
-class VisualScriptCustomNode: public VisualScriptNode {
-
-	GDCLASS(VisualScriptCustomNode,VisualScriptNode)
-
+	GDCLASS(VisualScriptCustomNode, VisualScriptNode)
 
 protected:
-
 	static void _bind_methods();
-public:
 
+public:
 	enum StartMode { //replicated for step
 		START_MODE_BEGIN_SEQUENCE,
 		START_MODE_CONTINUE_SEQUENCE,
@@ -746,26 +652,23 @@ public:
 	};
 
 	enum { //replicated for step
-		STEP_SHIFT=1<<24,
-		STEP_MASK=STEP_SHIFT-1,
-		STEP_PUSH_STACK_BIT=STEP_SHIFT, //push bit to stack
-		STEP_GO_BACK_BIT=STEP_SHIFT<<1, //go back to previous node
-		STEP_NO_ADVANCE_BIT=STEP_SHIFT<<2, //do not advance past this node
-		STEP_EXIT_FUNCTION_BIT=STEP_SHIFT<<3, //return from function
-		STEP_YIELD_BIT=STEP_SHIFT<<4, //yield (will find VisualScriptFunctionState state in first working memory)
+		STEP_SHIFT = 1 << 24,
+		STEP_MASK = STEP_SHIFT - 1,
+		STEP_PUSH_STACK_BIT = STEP_SHIFT, //push bit to stack
+		STEP_GO_BACK_BIT = STEP_SHIFT << 1, //go back to previous node
+		STEP_NO_ADVANCE_BIT = STEP_SHIFT << 2, //do not advance past this node
+		STEP_EXIT_FUNCTION_BIT = STEP_SHIFT << 3, //return from function
+		STEP_YIELD_BIT = STEP_SHIFT << 4, //yield (will find VisualScriptFunctionState state in first working memory)
 	};
 
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -773,32 +676,27 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptCustomNode();
 };
 
-class VisualScriptSubCall: public VisualScriptNode {
-
-	GDCLASS(VisualScriptSubCall,VisualScriptNode)
+class VisualScriptSubCall : public VisualScriptNode {
 
+	GDCLASS(VisualScriptSubCall, VisualScriptNode)
 
 protected:
-
-
 	static void _bind_methods();
+
 public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -806,34 +704,31 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptSubCall();
 };
 
-class VisualScriptComment: public VisualScriptNode {
-
-	GDCLASS(VisualScriptComment,VisualScriptNode)
+class VisualScriptComment : public VisualScriptNode {
 
+	GDCLASS(VisualScriptComment, VisualScriptNode)
 
 	String title;
 	String description;
 	Size2 size;
-protected:
 
+protected:
 	static void _bind_methods();
+
 public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -841,44 +736,39 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const;
 
-	void set_title(const String& p_title);
+	void set_title(const String &p_title);
 	String get_title() const;
 
-	void set_description(const String& p_description);
+	void set_description(const String &p_description);
 	String get_description() const;
 
-	void set_size(const Size2& p_size);
+	void set_size(const Size2 &p_size);
 	Size2 get_size() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptComment();
 };
 
-class VisualScriptConstructor: public VisualScriptNode {
-
-	GDCLASS(VisualScriptConstructor,VisualScriptNode)
+class VisualScriptConstructor : public VisualScriptNode {
 
+	GDCLASS(VisualScriptConstructor, VisualScriptNode)
 
 	Variant::Type type;
 	MethodInfo constructor;
 
 protected:
-
-
 	static void _bind_methods();
+
 public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -889,39 +779,33 @@ public:
 	void set_constructor_type(Variant::Type p_type);
 	Variant::Type get_constructor_type() const;
 
-	void set_constructor(const Dictionary& p_info);
+	void set_constructor(const Dictionary &p_info);
 	Dictionary get_constructor() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptConstructor();
 };
 
+class VisualScriptLocalVar : public VisualScriptNode {
 
-
-
-class VisualScriptLocalVar: public VisualScriptNode {
-
-	GDCLASS(VisualScriptLocalVar,VisualScriptNode)
+	GDCLASS(VisualScriptLocalVar, VisualScriptNode)
 
 	StringName name;
 	Variant::Type type;
 
 protected:
-
 	static void _bind_methods();
+
 public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -929,39 +813,36 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const;
 
-	void set_var_name(const StringName& p_name);
+	void set_var_name(const StringName &p_name);
 	StringName get_var_name() const;
 
 	void set_var_type(Variant::Type p_type);
 	Variant::Type get_var_type() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptLocalVar();
 };
 
-class VisualScriptLocalVarSet: public VisualScriptNode {
+class VisualScriptLocalVarSet : public VisualScriptNode {
 
-	GDCLASS(VisualScriptLocalVarSet,VisualScriptNode)
+	GDCLASS(VisualScriptLocalVarSet, VisualScriptNode)
 
 	StringName name;
 	Variant::Type type;
 
 protected:
-
 	static void _bind_methods();
+
 public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -969,22 +850,20 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const;
 
-	void set_var_name(const StringName& p_name);
+	void set_var_name(const StringName &p_name);
 	StringName get_var_name() const;
 
 	void set_var_type(Variant::Type p_type);
 	Variant::Type get_var_type() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptLocalVarSet();
 };
 
+class VisualScriptInputAction : public VisualScriptNode {
 
-
-class VisualScriptInputAction: public VisualScriptNode {
-
-	GDCLASS(VisualScriptInputAction,VisualScriptNode)
+	GDCLASS(VisualScriptInputAction, VisualScriptNode)
 public:
 	enum Mode {
 		MODE_PRESSED,
@@ -997,22 +876,19 @@ public:
 	Mode mode;
 
 protected:
-
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 	static void _bind_methods();
+
 public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -1020,57 +896,51 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const;
 
-	void set_action_name(const StringName& p_name);
+	void set_action_name(const StringName &p_name);
 	StringName get_action_name() const;
 
 	void set_action_mode(Mode p_mode);
 	Mode get_action_mode() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptInputAction();
 };
 
-VARIANT_ENUM_CAST( VisualScriptInputAction::Mode )
-
-class VisualScriptDeconstruct: public VisualScriptNode {
+VARIANT_ENUM_CAST(VisualScriptInputAction::Mode)
 
-	GDCLASS(VisualScriptDeconstruct,VisualScriptNode)
+class VisualScriptDeconstruct : public VisualScriptNode {
 
+	GDCLASS(VisualScriptDeconstruct, VisualScriptNode)
 
 	struct Element {
 		StringName name;
 		Variant::Type type;
 	};
 
-
 	Vector<Element> elements;
 
 	void _update_elements();
 	Variant::Type type;
 	InputEvent::Type input_type;
 
-	void _set_elem_cache(const Array& p_elements);
+	void _set_elem_cache(const Array &p_elements);
 	Array _get_elem_cache() const;
 
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 protected:
-
-
 	static void _bind_methods();
+
 public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -1084,12 +954,11 @@ public:
 	void set_deconstruct_input_type(InputEvent::Type p_input_type);
 	InputEvent::Type get_deconstruct_input_type() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptDeconstruct();
 };
 
-
 void register_visual_script_nodes();
 void unregister_visual_script_nodes();
 
diff --git a/modules/visual_script/visual_script_yield_nodes.cpp b/modules/visual_script/visual_script_yield_nodes.cpp
index 35335fd9bc..919ced74b9 100644
--- a/modules/visual_script/visual_script_yield_nodes.cpp
+++ b/modules/visual_script/visual_script_yield_nodes.cpp
@@ -28,9 +28,9 @@
 /*************************************************************************/
 #include "visual_script_yield_nodes.h"
 
-#include "scene/main/scene_main_loop.h"
 #include "os/os.h"
 #include "scene/main/node.h"
+#include "scene/main/scene_main_loop.h"
 #include "visual_script_nodes.h"
 
 //////////////////////////////////////////
@@ -42,16 +42,16 @@ int VisualScriptYield::get_output_sequence_port_count() const {
 	return 1;
 }
 
-bool VisualScriptYield::has_input_sequence_port() const{
+bool VisualScriptYield::has_input_sequence_port() const {
 
 	return true;
 }
 
-int VisualScriptYield::get_input_value_port_count() const{
+int VisualScriptYield::get_input_value_port_count() const {
 
 	return 0;
 }
-int VisualScriptYield::get_output_value_port_count() const{
+int VisualScriptYield::get_output_value_port_count() const {
 
 	return 0;
 }
@@ -61,20 +61,19 @@ String VisualScriptYield::get_output_sequence_port_text(int p_port) const {
 	return String();
 }
 
-PropertyInfo VisualScriptYield::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptYield::get_input_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-PropertyInfo VisualScriptYield::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptYield::get_output_value_port_info(int p_idx) const {
 
 	return PropertyInfo();
 }
 
-
 String VisualScriptYield::get_caption() const {
 
-	return yield_mode==YIELD_RETURN?"Yield":"Wait";
+	return yield_mode == YIELD_RETURN ? "Yield" : "Wait";
 }
 
 String VisualScriptYield::get_text() const {
@@ -82,17 +81,15 @@ String VisualScriptYield::get_text() const {
 	switch (yield_mode) {
 		case YIELD_RETURN: return ""; break;
 		case YIELD_FRAME: return "Next Frame"; break;
-		case YIELD_FIXED_FRAME:  return "Next Fixed Frame"; break;
-		case YIELD_WAIT:  return rtos(wait_time)+" sec(s)"; break;
+		case YIELD_FIXED_FRAME: return "Next Fixed Frame"; break;
+		case YIELD_WAIT: return rtos(wait_time) + " sec(s)"; break;
 	}
 
 	return String();
 }
 
-
 class VisualScriptNodeInstanceYield : public VisualScriptNodeInstance {
 public:
-
 	VisualScriptYield::YieldMode mode;
 	float wait_time;
 
@@ -100,18 +97,17 @@ public:
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return false; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		if (p_start_mode==START_MODE_RESUME_YIELD) {
+		if (p_start_mode == START_MODE_RESUME_YIELD) {
 			return 0; //resuming yield
 		} else {
 			//yield
 
-
 			SceneTree *tree = OS::get_singleton()->get_main_loop()->cast_to<SceneTree>();
 			if (!tree) {
-				r_error_str="Main Loop is not SceneTree";
-				r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				r_error_str = "Main Loop is not SceneTree";
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 				return 0;
 			}
 
@@ -119,99 +115,92 @@ public:
 			state.instance();
 
 			int ret = STEP_YIELD_BIT;
-			switch(mode) {
-
-				case VisualScriptYield::YIELD_RETURN:  ret=STEP_EXIT_FUNCTION_BIT; break; //return the yield
-				case VisualScriptYield::YIELD_FRAME: state->connect_to_signal(tree,"idle_frame",Array()); break;
-				case VisualScriptYield::YIELD_FIXED_FRAME:  state->connect_to_signal(tree,"fixed_frame",Array()); break;
-				case VisualScriptYield::YIELD_WAIT:  state->connect_to_signal(tree->create_timer(wait_time).ptr(),"timeout",Array()); break;
-
+			switch (mode) {
+
+				case VisualScriptYield::YIELD_RETURN:
+					ret = STEP_EXIT_FUNCTION_BIT;
+					break; //return the yield
+				case VisualScriptYield::YIELD_FRAME: state->connect_to_signal(tree, "idle_frame", Array()); break;
+				case VisualScriptYield::YIELD_FIXED_FRAME: state->connect_to_signal(tree, "fixed_frame", Array()); break;
+				case VisualScriptYield::YIELD_WAIT: state->connect_to_signal(tree->create_timer(wait_time).ptr(), "timeout", Array()); break;
 			}
 
-			*p_working_mem=state;
+			*p_working_mem = state;
 
 			return ret;
 		}
 	}
-
 };
 
-VisualScriptNodeInstance* VisualScriptYield::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptYield::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceYield * instance = memnew(VisualScriptNodeInstanceYield );
+	VisualScriptNodeInstanceYield *instance = memnew(VisualScriptNodeInstanceYield);
 	//instance->instance=p_instance;
-	instance->mode=yield_mode;
-	instance->wait_time=wait_time;
+	instance->mode = yield_mode;
+	instance->wait_time = wait_time;
 	return instance;
 }
 
 void VisualScriptYield::set_yield_mode(YieldMode p_mode) {
 
-	if (yield_mode==p_mode)
+	if (yield_mode == p_mode)
 		return;
-	yield_mode=p_mode;
+	yield_mode = p_mode;
 	ports_changed_notify();
 	_change_notify();
 }
 
-VisualScriptYield::YieldMode VisualScriptYield::get_yield_mode(){
+VisualScriptYield::YieldMode VisualScriptYield::get_yield_mode() {
 
 	return yield_mode;
 }
 
 void VisualScriptYield::set_wait_time(float p_time) {
 
-	if (wait_time==p_time)
+	if (wait_time == p_time)
 		return;
-	wait_time=p_time;
+	wait_time = p_time;
 	ports_changed_notify();
-
 }
 
-float VisualScriptYield::get_wait_time(){
+float VisualScriptYield::get_wait_time() {
 
 	return wait_time;
 }
 
+void VisualScriptYield::_validate_property(PropertyInfo &property) const {
 
-void VisualScriptYield::_validate_property(PropertyInfo& property) const {
-
-
-	if (property.name=="wait_time") {
-		if (yield_mode!=YIELD_WAIT) {
-			property.usage=0;
+	if (property.name == "wait_time") {
+		if (yield_mode != YIELD_WAIT) {
+			property.usage = 0;
 		}
 	}
 }
 
 void VisualScriptYield::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_yield_mode","mode"),&VisualScriptYield::set_yield_mode);
-	ClassDB::bind_method(D_METHOD("get_yield_mode"),&VisualScriptYield::get_yield_mode);
-
-	ClassDB::bind_method(D_METHOD("set_wait_time","sec"),&VisualScriptYield::set_wait_time);
-	ClassDB::bind_method(D_METHOD("get_wait_time"),&VisualScriptYield::get_wait_time);
+	ClassDB::bind_method(D_METHOD("set_yield_mode", "mode"), &VisualScriptYield::set_yield_mode);
+	ClassDB::bind_method(D_METHOD("get_yield_mode"), &VisualScriptYield::get_yield_mode);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"mode",PROPERTY_HINT_ENUM,"Frame,FixedFrame,Time",PROPERTY_USAGE_NOEDITOR),"set_yield_mode","get_yield_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::REAL,"wait_time"),"set_wait_time","get_wait_time");
+	ClassDB::bind_method(D_METHOD("set_wait_time", "sec"), &VisualScriptYield::set_wait_time);
+	ClassDB::bind_method(D_METHOD("get_wait_time"), &VisualScriptYield::get_wait_time);
 
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM, "Frame,FixedFrame,Time", PROPERTY_USAGE_NOEDITOR), "set_yield_mode", "get_yield_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "wait_time"), "set_wait_time", "get_wait_time");
 
-	BIND_CONSTANT( YIELD_FRAME );
-	BIND_CONSTANT( YIELD_FIXED_FRAME );
-	BIND_CONSTANT( YIELD_WAIT );
-
+	BIND_CONSTANT(YIELD_FRAME);
+	BIND_CONSTANT(YIELD_FIXED_FRAME);
+	BIND_CONSTANT(YIELD_WAIT);
 }
 
 VisualScriptYield::VisualScriptYield() {
 
-	yield_mode=YIELD_FRAME;
-	wait_time=1;
-
+	yield_mode = YIELD_FRAME;
+	wait_time = 1;
 }
 
-
-template<VisualScriptYield::YieldMode MODE>
-static Ref<VisualScriptNode> create_yield_node(const String& p_name) {
+template <VisualScriptYield::YieldMode MODE>
+static Ref<VisualScriptNode> create_yield_node(const String &p_name) {
 
 	Ref<VisualScriptYield> node;
 	node.instance();
@@ -228,24 +217,24 @@ int VisualScriptYieldSignal::get_output_sequence_port_count() const {
 	return 1;
 }
 
-bool VisualScriptYieldSignal::has_input_sequence_port() const{
+bool VisualScriptYieldSignal::has_input_sequence_port() const {
 
 	return true;
 }
 #ifdef TOOLS_ENABLED
 
-static Node* _find_script_node(Node* p_edited_scene,Node* p_current_node,const Ref<Script> &script) {
+static Node *_find_script_node(Node *p_edited_scene, Node *p_current_node, const Ref<Script> &script) {
 
-	if (p_edited_scene!=p_current_node && p_current_node->get_owner()!=p_edited_scene)
+	if (p_edited_scene != p_current_node && p_current_node->get_owner() != p_edited_scene)
 		return NULL;
 
 	Ref<Script> scr = p_current_node->get_script();
 
-	if (scr.is_valid() && scr==script)
+	if (scr.is_valid() && scr == script)
 		return p_current_node;
 
-	for(int i=0;i<p_current_node->get_child_count();i++) {
-		Node *n = _find_script_node(p_edited_scene,p_current_node->get_child(i),script);
+	for (int i = 0; i < p_current_node->get_child_count(); i++) {
+		Node *n = _find_script_node(p_edited_scene, p_current_node->get_child(i), script);
 		if (n)
 			return n;
 	}
@@ -261,7 +250,7 @@ Node *VisualScriptYieldSignal::_get_base_node() const {
 	if (!script.is_valid())
 		return NULL;
 
-	MainLoop * main_loop = OS::get_singleton()->get_main_loop();
+	MainLoop *main_loop = OS::get_singleton()->get_main_loop();
 	if (!main_loop)
 		return NULL;
 
@@ -275,7 +264,7 @@ Node *VisualScriptYieldSignal::_get_base_node() const {
 	if (!edited_scene)
 		return NULL;
 
-	Node* script_node = _find_script_node(edited_scene,edited_scene,script);
+	Node *script_node = _find_script_node(edited_scene, edited_scene, script);
 
 	if (!script_node)
 		return NULL;
@@ -294,36 +283,32 @@ Node *VisualScriptYieldSignal::_get_base_node() const {
 
 StringName VisualScriptYieldSignal::_get_base_type() const {
 
-	if (call_mode==CALL_MODE_SELF && get_visual_script().is_valid())
+	if (call_mode == CALL_MODE_SELF && get_visual_script().is_valid())
 		return get_visual_script()->get_instance_base_type();
-	else if (call_mode==CALL_MODE_NODE_PATH && get_visual_script().is_valid()) {
+	else if (call_mode == CALL_MODE_NODE_PATH && get_visual_script().is_valid()) {
 		Node *path = _get_base_node();
 		if (path)
 			return path->get_class();
-
 	}
 
 	return base_type;
 }
 
-int VisualScriptYieldSignal::get_input_value_port_count() const{
+int VisualScriptYieldSignal::get_input_value_port_count() const {
 
-	if (call_mode==CALL_MODE_INSTANCE)
+	if (call_mode == CALL_MODE_INSTANCE)
 		return 1;
 	else
 		return 0;
-
 }
-int VisualScriptYieldSignal::get_output_value_port_count() const{
-
+int VisualScriptYieldSignal::get_output_value_port_count() const {
 
 	MethodInfo sr;
 
-	if (!ClassDB::get_signal(_get_base_type(),signal,&sr))
+	if (!ClassDB::get_signal(_get_base_type(), signal, &sr))
 		return 0;
 
 	return sr.arguments.size();
-
 }
 
 String VisualScriptYieldSignal::get_output_sequence_port_text(int p_port) const {
@@ -331,30 +316,27 @@ String VisualScriptYieldSignal::get_output_sequence_port_text(int p_port) const
 	return String();
 }
 
-PropertyInfo VisualScriptYieldSignal::get_input_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptYieldSignal::get_input_value_port_info(int p_idx) const {
 
-	if (call_mode==CALL_MODE_INSTANCE)
-		return PropertyInfo(Variant::OBJECT,"instance");
+	if (call_mode == CALL_MODE_INSTANCE)
+		return PropertyInfo(Variant::OBJECT, "instance");
 	else
 		return PropertyInfo();
-
 }
 
-PropertyInfo VisualScriptYieldSignal::get_output_value_port_info(int p_idx) const{
+PropertyInfo VisualScriptYieldSignal::get_output_value_port_info(int p_idx) const {
 
 	MethodInfo sr;
 
-	if (!ClassDB::get_signal(_get_base_type(),signal,&sr))
+	if (!ClassDB::get_signal(_get_base_type(), signal, &sr))
 		return PropertyInfo(); //no signal
-	ERR_FAIL_INDEX_V(p_idx,sr.arguments.size(),PropertyInfo());
+	ERR_FAIL_INDEX_V(p_idx, sr.arguments.size(), PropertyInfo());
 	return sr.arguments[p_idx];
-
 }
 
-
 String VisualScriptYieldSignal::get_caption() const {
 
-	static const char*cname[3]= {
+	static const char *cname[3] = {
 		"WaitSignal",
 		"WaitNodeSignal",
 		"WaitInstanceSigna;",
@@ -365,52 +347,49 @@ String VisualScriptYieldSignal::get_caption() const {
 
 String VisualScriptYieldSignal::get_text() const {
 
-	if (call_mode==CALL_MODE_SELF)
-		return "  "+String(signal)+"()";
+	if (call_mode == CALL_MODE_SELF)
+		return "  " + String(signal) + "()";
 	else
-		return "  "+_get_base_type()+"."+String(signal)+"()";
-
+		return "  " + _get_base_type() + "." + String(signal) + "()";
 }
 
+void VisualScriptYieldSignal::set_base_type(const StringName &p_type) {
 
-void VisualScriptYieldSignal::set_base_type(const StringName& p_type) {
-
-	if (base_type==p_type)
+	if (base_type == p_type)
 		return;
 
-	base_type=p_type;
+	base_type = p_type;
 
 	_change_notify();
 	ports_changed_notify();
 }
 
-StringName VisualScriptYieldSignal::get_base_type() const{
+StringName VisualScriptYieldSignal::get_base_type() const {
 
 	return base_type;
 }
 
-void VisualScriptYieldSignal::set_signal(const StringName& p_type){
+void VisualScriptYieldSignal::set_signal(const StringName &p_type) {
 
-	if (signal==p_type)
+	if (signal == p_type)
 		return;
 
-	signal=p_type;
+	signal = p_type;
 
 	_change_notify();
 	ports_changed_notify();
 }
 StringName VisualScriptYieldSignal::get_signal() const {
 
-
 	return signal;
 }
 
-void VisualScriptYieldSignal::set_base_path(const NodePath& p_type) {
+void VisualScriptYieldSignal::set_base_path(const NodePath &p_type) {
 
-	if (base_path==p_type)
+	if (base_path == p_type)
 		return;
 
-	base_path=p_type;
+	base_path = p_type;
 
 	_change_notify();
 	ports_changed_notify();
@@ -421,17 +400,15 @@ NodePath VisualScriptYieldSignal::get_base_path() const {
 	return base_path;
 }
 
-
 void VisualScriptYieldSignal::set_call_mode(CallMode p_mode) {
 
-	if (call_mode==p_mode)
+	if (call_mode == p_mode)
 		return;
 
-	call_mode=p_mode;
+	call_mode = p_mode;
 
 	_change_notify();
 	ports_changed_notify();
-
 }
 
 VisualScriptYieldSignal::CallMode VisualScriptYieldSignal::get_call_mode() const {
@@ -439,102 +416,89 @@ VisualScriptYieldSignal::CallMode VisualScriptYieldSignal::get_call_mode() const
 	return call_mode;
 }
 
+void VisualScriptYieldSignal::_validate_property(PropertyInfo &property) const {
 
-void VisualScriptYieldSignal::_validate_property(PropertyInfo& property) const {
-
-	if (property.name=="signal/base_type") {
-		if (call_mode!=CALL_MODE_INSTANCE) {
-			property.usage=PROPERTY_USAGE_NOEDITOR;
+	if (property.name == "signal/base_type") {
+		if (call_mode != CALL_MODE_INSTANCE) {
+			property.usage = PROPERTY_USAGE_NOEDITOR;
 		}
 	}
 
-
-	if (property.name=="signal/node_path") {
-		if (call_mode!=CALL_MODE_NODE_PATH) {
-			property.usage=0;
+	if (property.name == "signal/node_path") {
+		if (call_mode != CALL_MODE_NODE_PATH) {
+			property.usage = 0;
 		} else {
 
 			Node *bnode = _get_base_node();
 			if (bnode) {
-				property.hint_string=bnode->get_path(); //convert to loong string
+				property.hint_string = bnode->get_path(); //convert to loong string
 			} else {
-
 			}
 		}
 	}
 
-	if (property.name=="signal/signal") {
-		property.hint=PROPERTY_HINT_ENUM;
-
+	if (property.name == "signal/signal") {
+		property.hint = PROPERTY_HINT_ENUM;
 
 		List<MethodInfo> methods;
 
-		ClassDB::get_signal_list(_get_base_type(),&methods);
+		ClassDB::get_signal_list(_get_base_type(), &methods);
 
 		List<String> mstring;
-		for (List<MethodInfo>::Element *E=methods.front();E;E=E->next()) {
+		for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
 			if (E->get().name.begins_with("_"))
 				continue;
-			mstring.push_back(E->get().name.get_slice(":",0));
+			mstring.push_back(E->get().name.get_slice(":", 0));
 		}
 
 		mstring.sort();
 
 		String ml;
-		for (List<String>::Element *E=mstring.front();E;E=E->next()) {
+		for (List<String>::Element *E = mstring.front(); E; E = E->next()) {
 
-			if (ml!=String())
-				ml+=",";
-			ml+=E->get();
+			if (ml != String())
+				ml += ",";
+			ml += E->get();
 		}
 
-		property.hint_string=ml;
+		property.hint_string = ml;
 	}
-
-
 }
 
-
 void VisualScriptYieldSignal::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("set_base_type","base_type"),&VisualScriptYieldSignal::set_base_type);
-	ClassDB::bind_method(D_METHOD("get_base_type"),&VisualScriptYieldSignal::get_base_type);
-
-	ClassDB::bind_method(D_METHOD("set_signal","signal"),&VisualScriptYieldSignal::set_signal);
-	ClassDB::bind_method(D_METHOD("get_signal"),&VisualScriptYieldSignal::get_signal);
+	ClassDB::bind_method(D_METHOD("set_base_type", "base_type"), &VisualScriptYieldSignal::set_base_type);
+	ClassDB::bind_method(D_METHOD("get_base_type"), &VisualScriptYieldSignal::get_base_type);
 
-	ClassDB::bind_method(D_METHOD("set_call_mode","mode"),&VisualScriptYieldSignal::set_call_mode);
-	ClassDB::bind_method(D_METHOD("get_call_mode"),&VisualScriptYieldSignal::get_call_mode);
-
-	ClassDB::bind_method(D_METHOD("set_base_path","base_path"),&VisualScriptYieldSignal::set_base_path);
-	ClassDB::bind_method(D_METHOD("get_base_path"),&VisualScriptYieldSignal::get_base_path);
+	ClassDB::bind_method(D_METHOD("set_signal", "signal"), &VisualScriptYieldSignal::set_signal);
+	ClassDB::bind_method(D_METHOD("get_signal"), &VisualScriptYieldSignal::get_signal);
 
+	ClassDB::bind_method(D_METHOD("set_call_mode", "mode"), &VisualScriptYieldSignal::set_call_mode);
+	ClassDB::bind_method(D_METHOD("get_call_mode"), &VisualScriptYieldSignal::get_call_mode);
 
+	ClassDB::bind_method(D_METHOD("set_base_path", "base_path"), &VisualScriptYieldSignal::set_base_path);
+	ClassDB::bind_method(D_METHOD("get_base_path"), &VisualScriptYieldSignal::get_base_path);
 
 	String bt;
-	for(int i=0;i<Variant::VARIANT_MAX;i++) {
-		if (i>0)
-			bt+=",";
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		if (i > 0)
+			bt += ",";
 
-		bt+=Variant::get_type_name(Variant::Type(i));
+		bt += Variant::get_type_name(Variant::Type(i));
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"signal/call_mode",PROPERTY_HINT_ENUM,"Self,Node Path,Instance"),"set_call_mode","get_call_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"signal/base_type",PROPERTY_HINT_TYPE_STRING,"Object"),"set_base_type","get_base_type");
-	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"signal/node_path",PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE),"set_base_path","get_base_path");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING,"signal/signal"),"set_signal","get_signal");
-
-
-	BIND_CONSTANT( CALL_MODE_SELF );
-	BIND_CONSTANT( CALL_MODE_NODE_PATH);
-	BIND_CONSTANT( CALL_MODE_INSTANCE);
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "signal/call_mode", PROPERTY_HINT_ENUM, "Self,Node Path,Instance"), "set_call_mode", "get_call_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "signal/base_type", PROPERTY_HINT_TYPE_STRING, "Object"), "set_base_type", "get_base_type");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "signal/node_path", PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE), "set_base_path", "get_base_path");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "signal/signal"), "set_signal", "get_signal");
 
+	BIND_CONSTANT(CALL_MODE_SELF);
+	BIND_CONSTANT(CALL_MODE_NODE_PATH);
+	BIND_CONSTANT(CALL_MODE_INSTANCE);
 }
 
 class VisualScriptNodeInstanceYieldSignal : public VisualScriptNodeInstance {
 public:
-
-
 	VisualScriptYieldSignal::CallMode call_mode;
 	NodePath node_path;
 	int output_args;
@@ -543,97 +507,88 @@ public:
 	VisualScriptYieldSignal *node;
 	VisualScriptInstance *instance;
 
-
-
 	virtual int get_working_memory_size() const { return 1; }
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
 	//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
 
-	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+	virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
 
-		if (p_start_mode==START_MODE_RESUME_YIELD) {
+		if (p_start_mode == START_MODE_RESUME_YIELD) {
 			return 0; //resuming yield
 		} else {
 			//yield
 
-			Object * object;
+			Object *object;
 
-			switch(call_mode) {
+			switch (call_mode) {
 
 				case VisualScriptYieldSignal::CALL_MODE_SELF: {
 
-					object=instance->get_owner_ptr();
+					object = instance->get_owner_ptr();
 
 				} break;
 				case VisualScriptYieldSignal::CALL_MODE_NODE_PATH: {
 
-					Node* node = instance->get_owner_ptr()->cast_to<Node>();
+					Node *node = instance->get_owner_ptr()->cast_to<Node>();
 					if (!node) {
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-						r_error_str="Base object is not a Node!";
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_error_str = "Base object is not a Node!";
 						return 0;
 					}
 
-					Node* another = node->get_node(node_path);
+					Node *another = node->get_node(node_path);
 					if (!node) {
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-						r_error_str="Path does not lead Node!";
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_error_str = "Path does not lead Node!";
 						return 0;
 					}
 
-					object=another;
+					object = another;
 
 				} break;
 				case VisualScriptYieldSignal::CALL_MODE_INSTANCE: {
 
 					object = *p_inputs[0];
 					if (!object) {
-						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-						r_error_str="Supplied instance input is null.";
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_error_str = "Supplied instance input is null.";
 						return 0;
-
 					}
 
 				} break;
-
 			}
 
 			Ref<VisualScriptFunctionState> state;
 			state.instance();
 
-			state->connect_to_signal(object,signal,Array());
+			state->connect_to_signal(object, signal, Array());
 
-			*p_working_mem=state;
+			*p_working_mem = state;
 
 			return STEP_YIELD_BIT;
 		}
-
-
 	}
-
-
 };
 
-VisualScriptNodeInstance* VisualScriptYieldSignal::instance(VisualScriptInstance* p_instance) {
+VisualScriptNodeInstance *VisualScriptYieldSignal::instance(VisualScriptInstance *p_instance) {
 
-	VisualScriptNodeInstanceYieldSignal * instance = memnew(VisualScriptNodeInstanceYieldSignal );
-	instance->node=this;
-	instance->instance=p_instance;
-	instance->signal=signal;
-	instance->call_mode=call_mode;
-	instance->node_path=base_path;
+	VisualScriptNodeInstanceYieldSignal *instance = memnew(VisualScriptNodeInstanceYieldSignal);
+	instance->node = this;
+	instance->instance = p_instance;
+	instance->signal = signal;
+	instance->call_mode = call_mode;
+	instance->node_path = base_path;
 	instance->output_args = get_output_value_port_count();
 	return instance;
 }
 VisualScriptYieldSignal::VisualScriptYieldSignal() {
 
-	call_mode=CALL_MODE_SELF;
-	base_type="Object";
-
+	call_mode = CALL_MODE_SELF;
+	base_type = "Object";
 }
 
-template<VisualScriptYieldSignal::CallMode cmode>
-static Ref<VisualScriptNode> create_yield_signal_node(const String& p_name) {
+template <VisualScriptYieldSignal::CallMode cmode>
+static Ref<VisualScriptNode> create_yield_signal_node(const String &p_name) {
 
 	Ref<VisualScriptYieldSignal> node;
 	node.instance();
@@ -643,12 +598,10 @@ static Ref<VisualScriptNode> create_yield_signal_node(const String& p_name) {
 
 void register_visual_script_yield_nodes() {
 
-	VisualScriptLanguage::singleton->add_register_func("functions/wait/wait_frame",create_yield_node<VisualScriptYield::YIELD_FRAME>);
-	VisualScriptLanguage::singleton->add_register_func("functions/wait/wait_fixed_frame",create_yield_node<VisualScriptYield::YIELD_FIXED_FRAME>);
-	VisualScriptLanguage::singleton->add_register_func("functions/wait/wait_time",create_yield_node<VisualScriptYield::YIELD_WAIT>);
-
-
-	VisualScriptLanguage::singleton->add_register_func("functions/yield",create_yield_node<VisualScriptYield::YIELD_RETURN>);
-	VisualScriptLanguage::singleton->add_register_func("functions/yield_signal",create_node_generic<VisualScriptYieldSignal>);
+	VisualScriptLanguage::singleton->add_register_func("functions/wait/wait_frame", create_yield_node<VisualScriptYield::YIELD_FRAME>);
+	VisualScriptLanguage::singleton->add_register_func("functions/wait/wait_fixed_frame", create_yield_node<VisualScriptYield::YIELD_FIXED_FRAME>);
+	VisualScriptLanguage::singleton->add_register_func("functions/wait/wait_time", create_yield_node<VisualScriptYield::YIELD_WAIT>);
 
+	VisualScriptLanguage::singleton->add_register_func("functions/yield", create_yield_node<VisualScriptYield::YIELD_RETURN>);
+	VisualScriptLanguage::singleton->add_register_func("functions/yield_signal", create_node_generic<VisualScriptYieldSignal>);
 }
diff --git a/modules/visual_script/visual_script_yield_nodes.h b/modules/visual_script/visual_script_yield_nodes.h
index 80ac879aad..35f72cdfad 100644
--- a/modules/visual_script/visual_script_yield_nodes.h
+++ b/modules/visual_script/visual_script_yield_nodes.h
@@ -33,9 +33,8 @@
 
 class VisualScriptYield : public VisualScriptNode {
 
-	GDCLASS(VisualScriptYield,VisualScriptNode)
+	GDCLASS(VisualScriptYield, VisualScriptNode)
 public:
-
 	enum YieldMode {
 		YIELD_RETURN,
 		YIELD_FRAME,
@@ -43,30 +42,25 @@ public:
 		YIELD_WAIT
 
 	};
-private:
 
+private:
 	YieldMode yield_mode;
 	float wait_time;
 
-
 protected:
-
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 	static void _bind_methods();
-public:
 
+public:
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -80,15 +74,15 @@ public:
 	void set_wait_time(float p_time);
 	float get_wait_time();
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptYield();
 };
-VARIANT_ENUM_CAST( VisualScriptYield::YieldMode )
+VARIANT_ENUM_CAST(VisualScriptYield::YieldMode)
 
 class VisualScriptYieldSignal : public VisualScriptNode {
 
-	GDCLASS(VisualScriptYieldSignal,VisualScriptNode)
+	GDCLASS(VisualScriptYieldSignal, VisualScriptNode)
 public:
 	enum CallMode {
 		CALL_MODE_SELF,
@@ -96,8 +90,8 @@ public:
 		CALL_MODE_INSTANCE,
 
 	};
-private:
 
+private:
 	CallMode call_mode;
 	StringName base_type;
 	NodePath base_path;
@@ -106,25 +100,20 @@ private:
 	Node *_get_base_node() const;
 	StringName _get_base_type() const;
 
-
 protected:
-	virtual void _validate_property(PropertyInfo& property) const;
+	virtual void _validate_property(PropertyInfo &property) const;
 
 	static void _bind_methods();
 
 public:
-
 	virtual int get_output_sequence_port_count() const;
 	virtual bool has_input_sequence_port() const;
 
-
 	virtual String get_output_sequence_port_text(int p_port) const;
 
-
 	virtual int get_input_value_port_count() const;
 	virtual int get_output_value_port_count() const;
 
-
 	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
 	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
 
@@ -132,24 +121,24 @@ public:
 	virtual String get_text() const;
 	virtual String get_category() const { return "functions"; }
 
-	void set_base_type(const StringName& p_type);
+	void set_base_type(const StringName &p_type);
 	StringName get_base_type() const;
 
-	void set_signal(const StringName& p_type);
+	void set_signal(const StringName &p_type);
 	StringName get_signal() const;
 
-	void set_base_path(const NodePath& p_type);
+	void set_base_path(const NodePath &p_type);
 	NodePath get_base_path() const;
 
 	void set_call_mode(CallMode p_mode);
 	CallMode get_call_mode() const;
 
-	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+	virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance);
 
 	VisualScriptYieldSignal();
 };
 
-VARIANT_ENUM_CAST(VisualScriptYieldSignal::CallMode );
+VARIANT_ENUM_CAST(VisualScriptYieldSignal::CallMode);
 
 void register_visual_script_yield_nodes();
 
diff --git a/modules/vorbis/audio_stream_ogg_vorbis.cpp b/modules/vorbis/audio_stream_ogg_vorbis.cpp
index 98920954a4..88c8ecc0df 100644
--- a/modules/vorbis/audio_stream_ogg_vorbis.cpp
+++ b/modules/vorbis/audio_stream_ogg_vorbis.cpp
@@ -28,60 +28,57 @@
 /*************************************************************************/
 #include "audio_stream_ogg_vorbis.h"
 
-
-
-size_t AudioStreamPlaybackOGGVorbis::_ov_read_func(void *p_dst,size_t p_data, size_t p_count, void *_f) {
+size_t AudioStreamPlaybackOGGVorbis::_ov_read_func(void *p_dst, size_t p_data, size_t p_count, void *_f) {
 
 	//printf("read to %p, %i bytes, %i nmemb, %p\n",p_dst,p_data,p_count,_f);
-	FileAccess *fa=(FileAccess*)_f;
-	size_t read_total = p_data*p_count;
+	FileAccess *fa = (FileAccess *)_f;
+	size_t read_total = p_data * p_count;
 
 	if (fa->eof_reached())
 		return 0;
 
-	uint8_t *dst=(uint8_t*)p_dst;
+	uint8_t *dst = (uint8_t *)p_dst;
 
 	int read = fa->get_buffer(dst, read_total);
 
 	return read;
 }
 
-int AudioStreamPlaybackOGGVorbis::_ov_seek_func(void *_f,ogg_int64_t offs, int whence) {
+int AudioStreamPlaybackOGGVorbis::_ov_seek_func(void *_f, ogg_int64_t offs, int whence) {
 
-	//printf("seek to %p, offs %i, whence %i\n",_f,(int)offs,whence);
+//printf("seek to %p, offs %i, whence %i\n",_f,(int)offs,whence);
 
 #ifdef SEEK_SET
 	//printf("seek set defined\n");
-	FileAccess *fa=(FileAccess*)_f;
+	FileAccess *fa = (FileAccess *)_f;
 
-	if (whence==SEEK_SET) {
+	if (whence == SEEK_SET) {
 
 		fa->seek(offs);
-	} else if (whence==SEEK_CUR) {
+	} else if (whence == SEEK_CUR) {
 
-		fa->seek(fa->get_pos()+offs);
-	} else if (whence==SEEK_END) {
+		fa->seek(fa->get_pos() + offs);
+	} else if (whence == SEEK_END) {
 
 		fa->seek_end(offs);
 	} else {
 
 		ERR_PRINT("BUG, wtf was whence set to?\n");
 	}
-	int ret=fa->eof_reached()?-1:0;
+	int ret = fa->eof_reached() ? -1 : 0;
 	//printf("returning %i\n",ret);
 	return ret;
 
 #else
 	return -1; // no seeking
 #endif
-
 }
 int AudioStreamPlaybackOGGVorbis::_ov_close_func(void *_f) {
 
 	//printf("close %p\n",_f);
 	if (!_f)
 		return 0;
-	FileAccess *fa=(FileAccess*)_f;
+	FileAccess *fa = (FileAccess *)_f;
 	if (fa->is_open())
 		fa->close();
 	return 0;
@@ -90,40 +87,38 @@ long AudioStreamPlaybackOGGVorbis::_ov_tell_func(void *_f) {
 
 	//printf("close %p\n",_f);
 
-	FileAccess *fa=(FileAccess*)_f;
+	FileAccess *fa = (FileAccess *)_f;
 	return fa->get_pos();
 }
 
-
-
-int AudioStreamPlaybackOGGVorbis::mix(int16_t* p_bufer,int p_frames) {
+int AudioStreamPlaybackOGGVorbis::mix(int16_t *p_bufer, int p_frames) {
 
 	if (!playing)
 		return 0;
 
-	int total=p_frames;
+	int total = p_frames;
 	while (true) {
 
 		int todo = p_frames;
 
-		if (todo==0 || todo<MIN_MIX) {
+		if (todo == 0 || todo < MIN_MIX) {
 			break;
 		}
 
-		//printf("to mix %i - mix me %i bytes\n",to_mix,to_mix*stream_channels*sizeof(int16_t));
+//printf("to mix %i - mix me %i bytes\n",to_mix,to_mix*stream_channels*sizeof(int16_t));
 
-		#ifdef BIG_ENDIAN_ENABLED
-		long ret=ov_read(&vf,(char*)p_bufer,todo*stream_channels*sizeof(int16_t), 1, 2, 1, &current_section);
-		#else
-		long ret=ov_read(&vf,(char*)p_bufer,todo*stream_channels*sizeof(int16_t), 0, 2, 1, &current_section);
-		#endif
+#ifdef BIG_ENDIAN_ENABLED
+		long ret = ov_read(&vf, (char *)p_bufer, todo * stream_channels * sizeof(int16_t), 1, 2, 1, &current_section);
+#else
+		long ret = ov_read(&vf, (char *)p_bufer, todo * stream_channels * sizeof(int16_t), 0, 2, 1, &current_section);
+#endif
 
-		if (ret<0) {
+		if (ret < 0) {
 
 			playing = false;
-			ERR_EXPLAIN("Error reading OGG Vorbis File: "+file);
-			ERR_BREAK(ret<0);
-		} else if (ret==0) { // end of song, reload?
+			ERR_EXPLAIN("Error reading OGG Vorbis File: " + file);
+			ERR_BREAK(ret < 0);
+		} else if (ret == 0) { // end of song, reload?
 
 			ov_clear(&vf);
 
@@ -131,65 +126,59 @@ int AudioStreamPlaybackOGGVorbis::mix(int16_t* p_bufer,int p_frames) {
 
 			if (!has_loop()) {
 
-				playing=false;
-				repeats=1;
+				playing = false;
+				repeats = 1;
 				break;
 			}
 
-			f=FileAccess::open(file,FileAccess::READ);
+			f = FileAccess::open(file, FileAccess::READ);
 
-			int errv = ov_open_callbacks(f,&vf,NULL,0,_ov_callbacks);
-			if (errv!=0) {
-				playing=false;
+			int errv = ov_open_callbacks(f, &vf, NULL, 0, _ov_callbacks);
+			if (errv != 0) {
+				playing = false;
 				break; // :(
 			}
 
 			if (loop_restart_time) {
-				bool ok = ov_time_seek(&vf,loop_restart_time)==0;
+				bool ok = ov_time_seek(&vf, loop_restart_time) == 0;
 				if (!ok) {
-					playing=false;
+					playing = false;
 					//ERR_EXPLAIN("loop restart time rejected");
 					ERR_PRINT("loop restart time rejected")
 				}
 
-				frames_mixed=stream_srate*loop_restart_time;
+				frames_mixed = stream_srate * loop_restart_time;
 			} else {
 
-				frames_mixed=0;
+				frames_mixed = 0;
 			}
 			repeats++;
 			continue;
-
 		}
 
-		ret/=stream_channels;
-		ret/=sizeof(int16_t);
-
-		frames_mixed+=ret;
+		ret /= stream_channels;
+		ret /= sizeof(int16_t);
 
-		p_bufer+=ret*stream_channels;
-		p_frames-=ret;
+		frames_mixed += ret;
 
+		p_bufer += ret * stream_channels;
+		p_frames -= ret;
 	}
 
-	return total-p_frames;
-
+	return total - p_frames;
 }
 
-
-
 void AudioStreamPlaybackOGGVorbis::play(float p_from) {
 
 	if (playing)
 		stop();
 
-	if (_load_stream()!=OK)
+	if (_load_stream() != OK)
 		return;
 
-
-	frames_mixed=0;
-	playing=true;
-	if (p_from>0) {
+	frames_mixed = 0;
+	playing = true;
+	if (p_from > 0) {
 		seek_pos(p_from);
 	}
 }
@@ -199,7 +188,7 @@ void AudioStreamPlaybackOGGVorbis::_close_file() {
 	if (f) {
 
 		memdelete(f);
-		f=NULL;
+		f = NULL;
 	}
 }
 
@@ -209,39 +198,35 @@ bool AudioStreamPlaybackOGGVorbis::is_playing() const {
 void AudioStreamPlaybackOGGVorbis::stop() {
 
 	_clear_stream();
-	playing=false;
+	playing = false;
 	//_clear();
 }
 
-
-
 float AudioStreamPlaybackOGGVorbis::get_pos() const {
 
 	int32_t frames = int32_t(frames_mixed);
 	if (frames < 0)
-		frames=0;
+		frames = 0;
 	return double(frames) / stream_srate;
 }
 
 void AudioStreamPlaybackOGGVorbis::seek_pos(float p_time) {
 
-
-
 	if (!playing)
 		return;
-	bool ok = ov_time_seek(&vf,p_time)==0;
+	bool ok = ov_time_seek(&vf, p_time) == 0;
 	ERR_FAIL_COND(!ok);
-	frames_mixed=stream_srate*p_time;
+	frames_mixed = stream_srate * p_time;
 }
 
-String AudioStreamPlaybackOGGVorbis::get_stream_name() const  {
+String AudioStreamPlaybackOGGVorbis::get_stream_name() const {
 
 	return "";
 }
 
 void AudioStreamPlaybackOGGVorbis::set_loop(bool p_enable) {
 
-	loops=p_enable;
+	loops = p_enable;
 }
 
 bool AudioStreamPlaybackOGGVorbis::has_loop() const {
@@ -253,99 +238,103 @@ int AudioStreamPlaybackOGGVorbis::get_loop_count() const {
 	return repeats;
 }
 
+Error AudioStreamPlaybackOGGVorbis::set_file(const String &p_file) {
 
-Error AudioStreamPlaybackOGGVorbis::set_file(const String& p_file) {
-
-	file=p_file;
-	stream_valid=false;
+	file = p_file;
+	stream_valid = false;
 	Error err;
-	f=FileAccess::open(file,FileAccess::READ,&err);
+	f = FileAccess::open(file, FileAccess::READ, &err);
 
 	if (err) {
-		ERR_FAIL_COND_V( err, err );
+		ERR_FAIL_COND_V(err, err);
 	}
 
-	int errv = ov_open_callbacks(f,&vf,NULL,0,_ov_callbacks);
-	switch(errv) {
+	int errv = ov_open_callbacks(f, &vf, NULL, 0, _ov_callbacks);
+	switch (errv) {
 
 		case OV_EREAD: { // - A read from media returned an error.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_CANT_READ );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_CANT_READ);
 		} break;
-		case OV_EVERSION:  // - Vorbis version mismatch.
+		case OV_EVERSION: // - Vorbis version mismatch.
 		case OV_ENOTVORBIS: { // - Bitstream is not Vorbis data.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_UNRECOGNIZED );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_UNRECOGNIZED);
 		} break;
 		case OV_EBADHEADER: { // - Invalid Vorbis bitstream header.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_CORRUPT );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_CORRUPT);
 		} break;
 		case OV_EFAULT: { // - Internal logic fault; indicates a bug or heap/stack corruption.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_BUG );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_BUG);
 		} break;
 	}
-	const vorbis_info *vinfo=ov_info(&vf,-1);
-	stream_channels=vinfo->channels;
-	stream_srate=vinfo->rate;
-	length = ov_time_total(&vf,-1);
+	const vorbis_info *vinfo = ov_info(&vf, -1);
+	stream_channels = vinfo->channels;
+	stream_srate = vinfo->rate;
+	length = ov_time_total(&vf, -1);
 	ov_clear(&vf);
 	memdelete(f);
-	f=NULL;
-	stream_valid=true;
-
+	f = NULL;
+	stream_valid = true;
 
 	return OK;
 }
 
-Error AudioStreamPlaybackOGGVorbis::_load_stream()  {
+Error AudioStreamPlaybackOGGVorbis::_load_stream() {
 
-	ERR_FAIL_COND_V(!stream_valid,ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(!stream_valid, ERR_UNCONFIGURED);
 
 	_clear_stream();
-	if (file=="")
+	if (file == "")
 		return ERR_INVALID_DATA;
 
 	Error err;
-	f=FileAccess::open(file,FileAccess::READ,&err);
+	f = FileAccess::open(file, FileAccess::READ, &err);
 	if (err) {
-		ERR_FAIL_COND_V( err, err );
+		ERR_FAIL_COND_V(err, err);
 	}
 
-	int errv = ov_open_callbacks(f,&vf,NULL,0,_ov_callbacks);
-	switch(errv) {
+	int errv = ov_open_callbacks(f, &vf, NULL, 0, _ov_callbacks);
+	switch (errv) {
 
 		case OV_EREAD: { // - A read from media returned an error.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_CANT_READ );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_CANT_READ);
 		} break;
-		case OV_EVERSION:  // - Vorbis version mismatch.
+		case OV_EVERSION: // - Vorbis version mismatch.
 		case OV_ENOTVORBIS: { // - Bitstream is not Vorbis data.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_UNRECOGNIZED );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_UNRECOGNIZED);
 		} break;
 		case OV_EBADHEADER: { // - Invalid Vorbis bitstream header.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_FILE_CORRUPT );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_FILE_CORRUPT);
 		} break;
 		case OV_EFAULT: { // - Internal logic fault; indicates a bug or heap/stack corruption.
-			memdelete(f); f=NULL;
-			ERR_FAIL_V( ERR_BUG );
+			memdelete(f);
+			f = NULL;
+			ERR_FAIL_V(ERR_BUG);
 		} break;
 	}
-	repeats=0;
-	stream_loaded=true;
-
+	repeats = 0;
+	stream_loaded = true;
 
 	return OK;
 }
 
-
 float AudioStreamPlaybackOGGVorbis::get_length() const {
 
 	if (!stream_loaded) {
-		if (const_cast<AudioStreamPlaybackOGGVorbis*>(this)->_load_stream()!=OK)
+		if (const_cast<AudioStreamPlaybackOGGVorbis *>(this)->_load_stream() != OK)
 			return 0;
 	}
 	return length;
@@ -359,14 +348,14 @@ void AudioStreamPlaybackOGGVorbis::_clear_stream() {
 	ov_clear(&vf);
 	_close_file();
 
-	stream_loaded=false;
+	stream_loaded = false;
 	//stream_channels=1;
-	playing=false;
+	playing = false;
 }
 
 void AudioStreamPlaybackOGGVorbis::set_paused(bool p_paused) {
 
-	paused=p_paused;
+	paused = p_paused;
 }
 
 bool AudioStreamPlaybackOGGVorbis::is_paused(bool p_paused) const {
@@ -374,39 +363,34 @@ bool AudioStreamPlaybackOGGVorbis::is_paused(bool p_paused) const {
 	return paused;
 }
 
-
 AudioStreamPlaybackOGGVorbis::AudioStreamPlaybackOGGVorbis() {
 
-	loops=false;
-	playing=false;
-	_ov_callbacks.read_func=_ov_read_func;
-	_ov_callbacks.seek_func=_ov_seek_func;
-	_ov_callbacks.close_func=_ov_close_func;
-	_ov_callbacks.tell_func=_ov_tell_func;
+	loops = false;
+	playing = false;
+	_ov_callbacks.read_func = _ov_read_func;
+	_ov_callbacks.seek_func = _ov_seek_func;
+	_ov_callbacks.close_func = _ov_close_func;
+	_ov_callbacks.tell_func = _ov_tell_func;
 	f = NULL;
-	stream_loaded=false;
-	stream_valid=false;
-	repeats=0;	
-	paused=true;
-	stream_channels=0;
-	stream_srate=0;
-	current_section=0;
-	length=0;
-	loop_restart_time=0;
+	stream_loaded = false;
+	stream_valid = false;
+	repeats = 0;
+	paused = true;
+	stream_channels = 0;
+	stream_srate = 0;
+	current_section = 0;
+	length = 0;
+	loop_restart_time = 0;
 }
 
-
 AudioStreamPlaybackOGGVorbis::~AudioStreamPlaybackOGGVorbis() {
 
 	_clear_stream();
-
 }
 
-
-
-RES ResourceFormatLoaderAudioStreamOGGVorbis::load(const String &p_path, const String& p_original_path, Error *r_error) {
+RES ResourceFormatLoaderAudioStreamOGGVorbis::load(const String &p_path, const String &p_original_path, Error *r_error) {
 	if (r_error)
-		*r_error=OK;
+		*r_error = OK;
 
 	AudioStreamOGGVorbis *ogg_stream = memnew(AudioStreamOGGVorbis);
 	ogg_stream->set_file(p_path);
@@ -419,12 +403,11 @@ void ResourceFormatLoaderAudioStreamOGGVorbis::get_recognized_extensions(List<St
 }
 String ResourceFormatLoaderAudioStreamOGGVorbis::get_resource_type(const String &p_path) const {
 
-	if (p_path.get_extension().to_lower()=="ogg")
+	if (p_path.get_extension().to_lower() == "ogg")
 		return "AudioStreamOGGVorbis";
 	return "";
 }
 
-bool ResourceFormatLoaderAudioStreamOGGVorbis::handles_type(const String& p_type) const {
-	return (p_type=="AudioStream" || p_type=="AudioStreamOGG" || p_type=="AudioStreamOGGVorbis");
+bool ResourceFormatLoaderAudioStreamOGGVorbis::handles_type(const String &p_type) const {
+	return (p_type == "AudioStream" || p_type == "AudioStreamOGG" || p_type == "AudioStreamOGGVorbis");
 }
-
diff --git a/modules/vorbis/audio_stream_ogg_vorbis.h b/modules/vorbis/audio_stream_ogg_vorbis.h
index bc2bfa2ae6..a13e934f2a 100644
--- a/modules/vorbis/audio_stream_ogg_vorbis.h
+++ b/modules/vorbis/audio_stream_ogg_vorbis.h
@@ -38,18 +38,18 @@
 
 class AudioStreamPlaybackOGGVorbis : public AudioStreamPlayback {
 
-	GDCLASS(AudioStreamPlaybackOGGVorbis,AudioStreamPlayback);
+	GDCLASS(AudioStreamPlaybackOGGVorbis, AudioStreamPlayback);
 
 	enum {
-		MIN_MIX=1024
+		MIN_MIX = 1024
 	};
 
 	FileAccess *f;
 
 	ov_callbacks _ov_callbacks;
 	float length;
-	static size_t _ov_read_func(void *p_dst,size_t p_data, size_t p_count, void *_f);
-	static int _ov_seek_func(void *_f,ogg_int64_t offs, int whence);
+	static size_t _ov_read_func(void *p_dst, size_t p_data, size_t p_count, void *_f);
+	static int _ov_seek_func(void *_f, ogg_int64_t offs, int whence);
 	static int _ov_close_func(void *_f);
 	static long _ov_tell_func(void *_f);
 
@@ -63,7 +63,6 @@ class AudioStreamPlaybackOGGVorbis : public AudioStreamPlayback {
 	int stream_srate;
 	int current_section;
 
-
 	bool paused;
 	bool loops;
 	int repeats;
@@ -75,17 +74,14 @@ class AudioStreamPlaybackOGGVorbis : public AudioStreamPlayback {
 	bool stream_valid;
 	float loop_restart_time;
 
-
 public:
+	Error set_file(const String &p_file);
 
-
-	Error set_file(const String& p_file);
-
-	virtual void play(float p_from=0);
+	virtual void play(float p_from = 0);
 	virtual void stop();
 	virtual bool is_playing() const;
 
-	virtual void set_loop_restart_time(float p_time) { loop_restart_time=p_time; }
+	virtual void set_loop_restart_time(float p_time) { loop_restart_time = p_time; }
 
 	virtual void set_paused(bool p_paused);
 	virtual bool is_paused(bool p_paused) const;
@@ -106,37 +102,34 @@ public:
 	virtual int get_mix_rate() const { return stream_srate; }
 
 	virtual int get_minimum_buffer_size() const { return 0; }
-	virtual int mix(int16_t* p_bufer,int p_frames);
+	virtual int mix(int16_t *p_bufer, int p_frames);
 
 	AudioStreamPlaybackOGGVorbis();
 	~AudioStreamPlaybackOGGVorbis();
 };
 
-
 class AudioStreamOGGVorbis : public AudioStream {
 
-	GDCLASS(AudioStreamOGGVorbis,AudioStream);
+	GDCLASS(AudioStreamOGGVorbis, AudioStream);
 
 	String file;
-public:
 
+public:
 	Ref<AudioStreamPlayback> instance_playback() {
-		Ref<AudioStreamPlaybackOGGVorbis> pb = memnew( AudioStreamPlaybackOGGVorbis );
+		Ref<AudioStreamPlaybackOGGVorbis> pb = memnew(AudioStreamPlaybackOGGVorbis);
 		pb->set_file(file);
 		return pb;
 	}
 
-	void set_file(const String& p_file) { file=p_file; }
-
+	void set_file(const String &p_file) { file = p_file; }
 };
 
 class ResourceFormatLoaderAudioStreamOGGVorbis : public ResourceFormatLoader {
 public:
-	virtual RES load(const String &p_path,const String& p_original_path="",Error *r_error=NULL);
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual bool handles_type(const String& p_type) const;
+	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;
 };
 
-
 #endif // AUDIO_STREAM_OGG_H
diff --git a/modules/vorbis/register_types.cpp b/modules/vorbis/register_types.cpp
index de929d9350..b405acd16b 100644
--- a/modules/vorbis/register_types.cpp
+++ b/modules/vorbis/register_types.cpp
@@ -34,12 +34,12 @@ static ResourceFormatLoaderAudioStreamOGGVorbis *vorbis_stream_loader = NULL;
 
 void register_vorbis_types() {
 
-	vorbis_stream_loader = memnew( ResourceFormatLoaderAudioStreamOGGVorbis );
+	vorbis_stream_loader = memnew(ResourceFormatLoaderAudioStreamOGGVorbis);
 	ResourceLoader::add_resource_format_loader(vorbis_stream_loader);
 	ClassDB::register_class<AudioStreamOGGVorbis>();
 }
 
 void unregister_vorbis_types() {
 
-	memdelete( vorbis_stream_loader );
+	memdelete(vorbis_stream_loader);
 }
diff --git a/modules/webm/video_stream_webm.cpp b/modules/webm/video_stream_webm.cpp
index d4995ad798..8d6fbdfe75 100644
--- a/modules/webm/video_stream_webm.cpp
+++ b/modules/webm/video_stream_webm.cpp
@@ -28,14 +28,14 @@
 /*************************************************************************/
 #include "video_stream_webm.h"
 
-#include "VPXDecoder.hpp"
 #include "OpusVorbisDecoder.hpp"
+#include "VPXDecoder.hpp"
 
-#include "mkvparser/mkvparser.h"
 #include "../theora/yuv2rgb.h"
+#include "mkvparser/mkvparser.h"
 
-#include "os/file_access.h"
 #include "global_config.h"
+#include "os/file_access.h"
 
 #include <string.h>
 
@@ -85,22 +85,21 @@ private:
 
 /**/
 
-VideoStreamPlaybackWebm::VideoStreamPlaybackWebm() :
-	audio_track(0),
-	webm(NULL),
-	video(NULL),
-	audio(NULL),
-	video_frames(NULL), audio_frame(NULL),
-	video_frames_pos(0), video_frames_capacity(0),
-	num_decoded_samples(0), samples_offset(-1),
-	mix_callback(NULL),
-	mix_udata(NULL),
-	playing(false), paused(false),
-	delay_compensation(0.0),
-	time(0.0), video_frame_delay(0.0), video_pos(0.0),
-	texture(memnew(ImageTexture)),
-	pcm(NULL)
-{}
+VideoStreamPlaybackWebm::VideoStreamPlaybackWebm()
+	: audio_track(0),
+	  webm(NULL),
+	  video(NULL),
+	  audio(NULL),
+	  video_frames(NULL), audio_frame(NULL),
+	  video_frames_pos(0), video_frames_capacity(0),
+	  num_decoded_samples(0), samples_offset(-1),
+	  mix_callback(NULL),
+	  mix_udata(NULL),
+	  playing(false), paused(false),
+	  delay_compensation(0.0),
+	  time(0.0), video_frame_delay(0.0), video_pos(0.0),
+	  texture(memnew(ImageTexture)),
+	  pcm(NULL) {}
 VideoStreamPlaybackWebm::~VideoStreamPlaybackWebm() {
 
 	delete_pointers();
@@ -299,22 +298,22 @@ void VideoStreamPlaybackWebm::update(float p_delta) {
 							if (image.chromaShiftW == 1 && image.chromaShiftH == 1) {
 
 								yuv420_2_rgb8888(w.ptr(), image.planes[0], image.planes[2], image.planes[1], image.w, image.h, image.linesize[0], image.linesize[1], image.w << 2, 0);
-// 								libyuv::I420ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
+								// 								libyuv::I420ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
 								converted = true;
 							} else if (image.chromaShiftW == 1 && image.chromaShiftH == 0) {
 
 								yuv422_2_rgb8888(w.ptr(), image.planes[0], image.planes[2], image.planes[1], image.w, image.h, image.linesize[0], image.linesize[1], image.w << 2, 0);
-// 								libyuv::I422ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
+								// 								libyuv::I422ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
 								converted = true;
 							} else if (image.chromaShiftW == 0 && image.chromaShiftH == 0) {
 
 								yuv444_2_rgb8888(w.ptr(), image.planes[0], image.planes[2], image.planes[1], image.w, image.h, image.linesize[0], image.linesize[1], image.w << 2, 0);
-// 								libyuv::I444ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
+								// 								libyuv::I444ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
 								converted = true;
 							} else if (image.chromaShiftW == 2 && image.chromaShiftH == 0) {
 
-// 								libyuv::I411ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
-// 								converted = true;
+								// 								libyuv::I411ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
+								// 								converted = true;
 							}
 
 							if (converted)
@@ -361,8 +360,7 @@ int VideoStreamPlaybackWebm::get_mix_rate() const {
 	return 0;
 }
 
-inline bool VideoStreamPlaybackWebm::has_enough_video_frames() const
-{
+inline bool VideoStreamPlaybackWebm::has_enough_video_frames() const {
 	if (video_frames_pos > 0) {
 
 		const double audio_delay = AudioServer::get_singleton()->get_output_delay();
@@ -423,9 +421,8 @@ String ResourceFormatLoaderVideoStreamWebm::get_resource_type(const String &p_pa
 
 /**/
 
-VideoStreamWebm::VideoStreamWebm() :
-	audio_track(0)
-{}
+VideoStreamWebm::VideoStreamWebm()
+	: audio_track(0) {}
 
 Ref<VideoStreamPlayback> VideoStreamWebm::instance_playback() {
 
diff --git a/modules/webm/video_stream_webm.h b/modules/webm/video_stream_webm.h
index cb4ef53f6d..2b62cf48b6 100644
--- a/modules/webm/video_stream_webm.h
+++ b/modules/webm/video_stream_webm.h
@@ -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 "scene/resources/video_stream.h"
 #include "io/resource_loader.h"
+#include "scene/resources/video_stream.h"
 
 class WebMFrame;
 class WebMDemuxer;
diff --git a/modules/webp/image_loader_webp.cpp b/modules/webp/image_loader_webp.cpp
index 3508c6a663..829e77873a 100644
--- a/modules/webp/image_loader_webp.cpp
+++ b/modules/webp/image_loader_webp.cpp
@@ -29,59 +29,59 @@
 #include "image_loader_webp.h"
 
 #include "io/marshalls.h"
-#include "print_string.h"
 #include "os/os.h"
+#include "print_string.h"
 
 #include <stdlib.h>
 #include <webp/decode.h>
 #include <webp/encode.h>
 
-static PoolVector<uint8_t> _webp_lossy_pack(const Image& p_image,float p_quality) {
+static PoolVector<uint8_t> _webp_lossy_pack(const Image &p_image, float p_quality) {
 
-	ERR_FAIL_COND_V(p_image.empty(),PoolVector<uint8_t>());
+	ERR_FAIL_COND_V(p_image.empty(), PoolVector<uint8_t>());
 
-	Image img=p_image;
+	Image img = p_image;
 	if (img.detect_alpha())
 		img.convert(Image::FORMAT_RGBA8);
 	else
 		img.convert(Image::FORMAT_RGB8);
 
-	Size2 s(img.get_width(),img.get_height());
+	Size2 s(img.get_width(), img.get_height());
 	PoolVector<uint8_t> data = img.get_data();
 	PoolVector<uint8_t>::Read r = data.read();
 
-	uint8_t *dst_buff=NULL;
-	size_t dst_size=0;
-	if (img.get_format()==Image::FORMAT_RGB8) {
+	uint8_t *dst_buff = NULL;
+	size_t dst_size = 0;
+	if (img.get_format() == Image::FORMAT_RGB8) {
 
-		dst_size = WebPEncodeRGB(r.ptr(),s.width,s.height,3*s.width,CLAMP(p_quality*100.0,0,100.0),&dst_buff);
+		dst_size = WebPEncodeRGB(r.ptr(), s.width, s.height, 3 * s.width, CLAMP(p_quality * 100.0, 0, 100.0), &dst_buff);
 	} else {
-		dst_size = WebPEncodeRGBA(r.ptr(),s.width,s.height,4*s.width,CLAMP(p_quality*100.0,0,100.0),&dst_buff);
+		dst_size = WebPEncodeRGBA(r.ptr(), s.width, s.height, 4 * s.width, CLAMP(p_quality * 100.0, 0, 100.0), &dst_buff);
 	}
 
-	ERR_FAIL_COND_V(dst_size==0,PoolVector<uint8_t>());
+	ERR_FAIL_COND_V(dst_size == 0, PoolVector<uint8_t>());
 	PoolVector<uint8_t> dst;
-	dst.resize(4+dst_size);
+	dst.resize(4 + dst_size);
 	PoolVector<uint8_t>::Write w = dst.write();
-	w[0]='W';
-	w[1]='E';
-	w[2]='B';
-	w[3]='P';
-	copymem(&w[4],dst_buff,dst_size);
+	w[0] = 'W';
+	w[1] = 'E';
+	w[2] = 'B';
+	w[3] = 'P';
+	copymem(&w[4], dst_buff, dst_size);
 	free(dst_buff);
-	w=PoolVector<uint8_t>::Write();
+	w = PoolVector<uint8_t>::Write();
 	return dst;
 }
 
-static Image _webp_lossy_unpack(const PoolVector<uint8_t>& p_buffer) {
+static Image _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) {
 
-	int size = p_buffer.size()-4;
-	ERR_FAIL_COND_V(size<=0,Image());
+	int size = p_buffer.size() - 4;
+	ERR_FAIL_COND_V(size <= 0, Image());
 	PoolVector<uint8_t>::Read r = p_buffer.read();
 
-	ERR_FAIL_COND_V(r[0]!='W' || r[1]!='E' || r[2]!='B' || r[3]!='P',Image());
+	ERR_FAIL_COND_V(r[0] != 'W' || r[1] != 'E' || r[2] != 'B' || r[3] != 'P', Image());
 	WebPBitstreamFeatures features;
-	if (WebPGetFeatures(&r[4],size,&features)!=VP8_STATUS_OK) {
+	if (WebPGetFeatures(&r[4], size, &features) != VP8_STATUS_OK) {
 		ERR_EXPLAIN("Error unpacking WEBP image:");
 		ERR_FAIL_V(Image());
 	}
@@ -91,31 +91,27 @@ static Image _webp_lossy_unpack(const PoolVector<uint8_t>& p_buffer) {
 	//print_line("alpha: "+itos(features.has_alpha));
 
 	PoolVector<uint8_t> dst_image;
-	int datasize = features.width*features.height*(features.has_alpha?4:3);
+	int datasize = features.width * features.height * (features.has_alpha ? 4 : 3);
 	dst_image.resize(datasize);
 
 	PoolVector<uint8_t>::Write dst_w = dst_image.write();
 
-	bool errdec=false;
-	if (features.has_alpha)	 {
-		errdec = WebPDecodeRGBAInto(&r[4],size,dst_w.ptr(),datasize,4*features.width)==NULL;
+	bool errdec = false;
+	if (features.has_alpha) {
+		errdec = WebPDecodeRGBAInto(&r[4], size, dst_w.ptr(), datasize, 4 * features.width) == NULL;
 	} else {
-		errdec = WebPDecodeRGBInto(&r[4],size,dst_w.ptr(),datasize,3*features.width)==NULL;
-
+		errdec = WebPDecodeRGBInto(&r[4], size, dst_w.ptr(), datasize, 3 * features.width) == NULL;
 	}
 
 	//ERR_EXPLAIN("Error decoding webp! - "+p_file);
-	ERR_FAIL_COND_V(errdec,Image());
+	ERR_FAIL_COND_V(errdec, Image());
 
 	dst_w = PoolVector<uint8_t>::Write();
 
-	return Image(features.width,features.height,0,features.has_alpha?Image::FORMAT_RGBA8:Image::FORMAT_RGB8,dst_image);
-
+	return Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image);
 }
 
-
-Error ImageLoaderWEBP::load_image(Image *p_image,FileAccess *f) {
-
+Error ImageLoaderWEBP::load_image(Image *p_image, FileAccess *f) {
 
 	uint32_t size = f->get_len();
 	PoolVector<uint8_t> src_image;
@@ -124,60 +120,53 @@ Error ImageLoaderWEBP::load_image(Image *p_image,FileAccess *f) {
 	WebPBitstreamFeatures features;
 
 	PoolVector<uint8_t>::Write src_w = src_image.write();
-	f->get_buffer(src_w.ptr(),size);
+	f->get_buffer(src_w.ptr(), size);
 	ERR_FAIL_COND_V(f->eof_reached(), ERR_FILE_EOF);
 
-	if (WebPGetFeatures(src_w.ptr(),size,&features)!=VP8_STATUS_OK) {
+	if (WebPGetFeatures(src_w.ptr(), size, &features) != VP8_STATUS_OK) {
 		f->close();
 		//ERR_EXPLAIN("Error decoding WEBP image: "+p_file);
 		ERR_FAIL_V(ERR_FILE_CORRUPT);
 	}
 
-	print_line("width: "+itos(features.width));
-	print_line("height: "+itos(features.height));
-	print_line("alpha: "+itos(features.has_alpha));
+	print_line("width: " + itos(features.width));
+	print_line("height: " + itos(features.height));
+	print_line("alpha: " + itos(features.has_alpha));
 
 	src_w = PoolVector<uint8_t>::Write();
 
 	PoolVector<uint8_t> dst_image;
-	int datasize = features.width*features.height*(features.has_alpha?4:3);
+	int datasize = features.width * features.height * (features.has_alpha ? 4 : 3);
 	dst_image.resize(datasize);
 
 	PoolVector<uint8_t>::Read src_r = src_image.read();
 	PoolVector<uint8_t>::Write dst_w = dst_image.write();
 
-
-	bool errdec=false;
-	if (features.has_alpha)	 {
-		errdec = WebPDecodeRGBAInto(src_r.ptr(),size,dst_w.ptr(),datasize,4*features.width)==NULL;
+	bool errdec = false;
+	if (features.has_alpha) {
+		errdec = WebPDecodeRGBAInto(src_r.ptr(), size, dst_w.ptr(), datasize, 4 * features.width) == NULL;
 	} else {
-		errdec = WebPDecodeRGBInto(src_r.ptr(),size,dst_w.ptr(),datasize,3*features.width)==NULL;
-
+		errdec = WebPDecodeRGBInto(src_r.ptr(), size, dst_w.ptr(), datasize, 3 * features.width) == NULL;
 	}
 
 	//ERR_EXPLAIN("Error decoding webp! - "+p_file);
-	ERR_FAIL_COND_V(errdec,ERR_FILE_CORRUPT);
+	ERR_FAIL_COND_V(errdec, ERR_FILE_CORRUPT);
 
 	src_r = PoolVector<uint8_t>::Read();
 	dst_w = PoolVector<uint8_t>::Write();
 
-	*p_image = Image(features.width,features.height,0,features.has_alpha?Image::FORMAT_RGBA8:Image::FORMAT_RGB8,dst_image);
-
+	*p_image = Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image);
 
 	return OK;
-
 }
 
 void ImageLoaderWEBP::get_recognized_extensions(List<String> *p_extensions) const {
-	
+
 	p_extensions->push_back("webp");
 }
 
-
 ImageLoaderWEBP::ImageLoaderWEBP() {
 
-	Image::lossy_packer=_webp_lossy_pack;
-	Image::lossy_unpacker=_webp_lossy_unpack;
+	Image::lossy_packer = _webp_lossy_pack;
+	Image::lossy_unpacker = _webp_lossy_unpack;
 }
-
-
diff --git a/modules/webp/image_loader_webp.h b/modules/webp/image_loader_webp.h
index eb1b32ac95..ccf22bae13 100644
--- a/modules/webp/image_loader_webp.h
+++ b/modules/webp/image_loader_webp.h
@@ -36,14 +36,10 @@
 */
 class ImageLoaderWEBP : public ImageFormatLoader {
 
-
 public:
-
-	virtual Error load_image(Image *p_image,FileAccess *f);
-	virtual void get_recognized_extensions(List<String> *p_extensions) const;	
+	virtual Error load_image(Image *p_image, FileAccess *f);
+	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	ImageLoaderWEBP();
 };
 
-
-
 #endif
diff --git a/modules/webp/register_types.cpp b/modules/webp/register_types.cpp
index 7a4e35dc4c..8a708aae6a 100644
--- a/modules/webp/register_types.cpp
+++ b/modules/webp/register_types.cpp
@@ -34,11 +34,11 @@ static ImageLoaderWEBP *image_loader_webp = NULL;
 
 void register_webp_types() {
 
-	image_loader_webp = memnew( ImageLoaderWEBP );
+	image_loader_webp = memnew(ImageLoaderWEBP);
 	ImageLoader::add_image_format_loader(image_loader_webp);
 }
 
 void unregister_webp_types() {
 
-	memdelete( image_loader_webp );
+	memdelete(image_loader_webp);
 }
author	Rémi Verschelde <rverschelde@gmail.com>	2017-03-05 16:44:50 +0100
committer	Rémi Verschelde <rverschelde@gmail.com>	2017-03-05 16:44:50 +0100
commit	5dbf1809c6e3e905b94b8764e99491e608122261 (patch)
tree	5e5a5360db15d86d59ec8c6e4f7eb511388c5a9a /modules
parent	45438e9918d421b244bfd7776a30e67dc7f2d3e3 (diff)