GODOT IS OPEN SOURCE

1 files changed, 1201 insertions, 0 deletions

diff --git a/script/gdscript/gd_functions.cpp b/script/gdscript/gd_functions.cpp
new file mode 100644
index 0000000000..4fc45eda9e
--- /dev/null
+++ b/script/gdscript/gd_functions.cpp
@@ -0,0 +1,1201 @@
+/*************************************************************************/
+/*  gd_functions.cpp                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "gd_functions.h"
+#include "math_funcs.h"
+#include "object_type_db.h"
+#include "reference.h"
+#include "gd_script.h"
+#include "os/os.h"
+
+const char *GDFunctions::get_func_name(Function p_func) {
+
+	ERR_FAIL_INDEX_V(p_func,FUNC_MAX,"");
+
+	static const char *_names[FUNC_MAX]={
+		"sin",
+		"cos",
+		"tan",
+		"sinh",
+		"cosh",
+		"tanh",
+		"asin",
+		"acos",
+		"atan",
+		"atan2",
+		"sqrt",
+		"fmod",
+		"fposmod",
+		"floor",
+		"ceil",
+		"round",
+		"abs",
+		"sign",
+		"pow",
+		"log",
+		"exp",
+		"is_nan",
+		"is_inf",
+		"ease",
+		"decimals",
+		"stepify",
+		"lerp",
+		"dectime",
+		"randomize",
+		"randi",
+		"randf",
+		"rand_range",
+		"rand_seed",
+		"deg2rad",
+		"rad2deg",
+		"linear2db",
+		"db2linear",
+		"max",
+		"min",
+		"clamp",
+		"nearest_po2",
+		"weakref",
+		"convert",
+		"typeof",
+		"str",
+		"print",
+		"printt",
+		"printerr",
+		"printraw",
+		"range",
+		"inst2dict",
+		"dict2inst",
+		"print_stack",
+	};
+
+	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) {
+
+	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;\
+		return;\
+	}\
+	if (p_arg_count>m_count) {\
+		r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;\
+		r_error.argument=m_count;\
+		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;\
+		return;\
+	}
+
+#else
+
+#define VALIDATE_ARG_COUNT(m_count)
+#define VALIDATE_ARG_NUM(m_arg)
+#endif
+
+	//using a switch, so the compiler generates a jumptable
+
+	switch(p_func) {
+
+		case MATH_SIN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::sin(*p_args[0]);
+		} break;
+		case MATH_COS: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::cos(*p_args[0]);
+		} break;
+		case MATH_TAN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::tan(*p_args[0]);
+		} break;
+		case MATH_SINH: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::sinh(*p_args[0]);
+		} break;
+		case MATH_COSH: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::cosh(*p_args[0]);
+		} break;
+		case MATH_TANH: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::tanh(*p_args[0]);
+		} break;
+		case MATH_ASIN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::asin(*p_args[0]);
+		} break;
+		case MATH_ACOS: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::acos(*p_args[0]);
+		} break;
+		case MATH_ATAN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::atan(*p_args[0]);
+		} break;
+		case MATH_ATAN2: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret=Math::atan2(*p_args[0],*p_args[1]);
+		} break;
+		case MATH_SQRT: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::sqrt(*p_args[0]);
+		} break;
+		case MATH_FMOD: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret=Math::fmod(*p_args[0],*p_args[1]);
+		} break;
+		case MATH_FPOSMOD: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret=Math::fposmod(*p_args[0],*p_args[1]);
+		} break;
+		case MATH_FLOOR: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::floor(*p_args[0]);
+		  } break;
+		case MATH_CEIL: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::ceil(*p_args[0]);
+		} break;
+		case MATH_ROUND: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::round(*p_args[0]);
+		} break;
+		case MATH_ABS: {
+			VALIDATE_ARG_COUNT(1);
+			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) {
+
+				real_t r = *p_args[0];
+				r_ret=Math::abs(r);
+			} else {
+
+				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument=0;
+				r_error.expected=Variant::REAL;
+			}
+		} break;
+		case MATH_SIGN: {
+				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) {
+
+					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;
+				}
+		} break;
+		case MATH_POW: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret=Math::pow(*p_args[0],*p_args[1]);
+		} break;
+		case MATH_LOG: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::log(*p_args[0]);
+		} break;
+		case MATH_EXP: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::exp(*p_args[0]);
+		} break;
+		case MATH_ISNAN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::is_nan(*p_args[0]);
+		} break;
+		case MATH_ISINF: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::is_inf(*p_args[0]);
+		} break;
+		case MATH_EASE: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret=Math::ease(*p_args[0],*p_args[1]);
+		} break;
+		case MATH_DECIMALS: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::decimals(*p_args[0]);
+		} break;
+		case MATH_STEPIFY: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret=Math::stepify(*p_args[0],*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(*p_args[0],*p_args[1],*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(*p_args[0],*p_args[1],*p_args[2]);
+		} break;
+		case MATH_RANDOMIZE: {
+			Math::randomize();
+			r_ret=Variant();
+		} break;
+		case MATH_RAND: {
+			r_ret=Math::rand();
+		} break;
+		case 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(*p_args[0],*p_args[1]);
+		} break;
+		case MATH_RANDSEED: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			uint32_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;
+
+		} break;
+		case MATH_DEG2RAD: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::deg2rad(*p_args[0]);
+		} break;
+		case MATH_RAD2DEG: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::rad2deg(*p_args[0]);
+		} break;
+		case MATH_LINEAR2DB: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::linear2db(*p_args[0]);
+		} break;
+		case MATH_DB2LINEAR: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret=Math::db2linear(*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) {
+
+				int64_t a = *p_args[0];
+				int64_t b = *p_args[1];
+				r_ret=MAX(a,b);
+			} else {
+				VALIDATE_ARG_NUM(0);
+				VALIDATE_ARG_NUM(1);
+
+				real_t a = *p_args[0];
+				real_t b = *p_args[1];
+
+				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) {
+
+				int64_t a = *p_args[0];
+				int64_t b = *p_args[1];
+				r_ret=MIN(a,b);
+			} else {
+				VALIDATE_ARG_NUM(0);
+				VALIDATE_ARG_NUM(1);
+
+				real_t a = *p_args[0];
+				real_t b = *p_args[1];
+
+				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) {
+
+				int64_t a = *p_args[0];
+				int64_t b = *p_args[1];
+				int64_t c = *p_args[2];
+				r_ret=CLAMP(a,b,c);
+			} else {
+				VALIDATE_ARG_NUM(0);
+				VALIDATE_ARG_NUM(1);
+				VALIDATE_ARG_NUM(2);
+
+				real_t a = *p_args[0];
+				real_t b = *p_args[1];
+				real_t c = *p_args[2];
+
+				r_ret=CLAMP(a,b,c);
+			}
+		} break;
+		case LOGIC_NEAREST_PO2: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			int64_t num = *p_args[0];
+			r_ret = nearest_power_of_2(num);
+		} break;
+		case OBJ_WEAKREF: {
+			VALIDATE_ARG_COUNT(1);
+			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;
+				return;
+
+			}
+
+			if (p_args[0]->is_ref()) {
+
+				REF r = *p_args[0];
+				if (!r.is_valid()) {
+					r_ret=Variant();
+					return;
+				}
+
+				Ref<WeakRef> wref = memnew( WeakRef );
+				wref->set_ref(r);
+				r_ret=wref;
+			} else {
+				Object *obj = *p_args[0];
+				if (!obj) {
+					r_ret=Variant();
+					return;
+				}
+				Ref<WeakRef> wref = memnew( WeakRef );
+				wref->set_obj(obj);
+				r_ret=wref;
+			}
+
+
+
+
+		} break;
+		case TYPE_CONVERT: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(1);
+			int type=*p_args[1];
+			if (type<0 || type>=Variant::VARIANT_MAX) {
+
+				ERR_PRINT("Invalid type argument to convert()");
+				r_ret=Variant::NIL;
+
+			} else {
+
+
+				r_ret=Variant::construct(Variant::Type(type),p_args,1,r_error);
+			}
+		} break;
+		case TYPE_OF: {
+
+			VALIDATE_ARG_COUNT(1);
+			r_ret = p_args[0]->get_type();
+
+		} break;
+		case TEXT_STR: {
+
+			String str;
+			for(int i=0;i<p_arg_count;i++) {
+
+				String os = p_args[i]->operator String();;
+				if (i==0)
+					str=os;
+				else
+					str+=os;
+			}
+
+			r_ret=str;
+
+		} break;
+		case TEXT_PRINT: {
+
+			String str;
+			for(int i=0;i<p_arg_count;i++) {
+
+				str+=p_args[i]->operator String();
+			}
+
+			//str+="\n";
+			print_line(str);
+			r_ret=Variant();
+
+
+		} break;
+		case TEXT_PRINT_TABBED: {
+
+			String str;
+			for(int i=0;i<p_arg_count;i++) {
+
+				if (i)
+					str+="\t";
+				str+=p_args[i]->operator String();
+			}
+
+			//str+="\n";
+			print_line(str);
+			r_ret=Variant();
+
+
+		} break;
+
+		case TEXT_PRINTERR: {
+
+			String str;
+			for(int i=0;i<p_arg_count;i++) {
+
+				str+=p_args[i]->operator String();
+			}
+
+			//str+="\n";
+			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++) {
+
+				str+=p_args[i]->operator String();
+			}
+
+			//str+="\n";
+			OS::get_singleton()->print("%s\n",str.utf8().get_data());
+			r_ret=Variant();
+
+		} break;
+		case GEN_RANGE: {
+
+
+
+			switch(p_arg_count) {
+
+				case 0: {
+
+					r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+					r_error.argument=1;
+
+				} break;
+				case 1: {
+
+					VALIDATE_ARG_NUM(0);
+					int count=*p_args[0];
+					Array arr(true);
+					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();
+						return;
+					}
+
+					for(int i=0;i<count;i++) {
+						arr[i]=i;
+					}
+
+					r_ret=arr;
+				} break;
+				case 2: {
+
+					VALIDATE_ARG_NUM(0);
+					VALIDATE_ARG_NUM(1);
+
+					int from=*p_args[0];
+					int to=*p_args[1];
+
+					Array arr(true);
+					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();
+						return;
+					}
+					for(int i=from;i<to;i++)
+						arr[i-from]=i;
+					r_ret=arr;
+				} break;
+				case 3: {
+
+					VALIDATE_ARG_NUM(0);
+					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) {
+
+						ERR_EXPLAIN("step argument is zero!");
+						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						ERR_FAIL();
+					}
+
+					Array arr(true);
+					if (from>=to && incr>0) {
+						r_ret=arr;
+						return;
+					}
+					if (from<=to && incr<0) {
+						r_ret=arr;
+						return;
+					}
+
+					//calculate how many
+					int count=0;
+					if (incr>0) {
+
+						count=((to-from-1)/incr)+1;
+					} else {
+
+						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();
+						return;
+					}
+
+					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;
+						}
+					}
+
+					r_ret=arr;
+				} break;
+				default: {
+
+					r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+					r_error.argument=3;
+				} break;
+			}
+
+		} break;
+		case INST2DICT: {
+
+			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();
+			} else {
+
+				Object *obj = *p_args[0];
+				if (!obj) {
+					r_ret=Variant();
+
+				} 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;
+					ERR_PRINT("Not a script with an instance");
+
+				} else {
+
+					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;
+						ERR_PRINT("Not based on a script");
+						return;
+
+					}
+
+
+					GDScript *p = base.ptr();
+					Vector<StringName> sname;
+
+					while(p->_owner) {
+
+						sname.push_back(p->name);
+						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;
+						print_line("PATH: "+p->path);
+						ERR_PRINT("Not based on a resource file");
+
+						return;
+					}
+
+					NodePath cp(sname,Vector<StringName>(),false);
+
+					Dictionary d(true);
+					d["@subpath"]=cp;
+					d["@path"]=p->path;
+
+
+					p = base.ptr();
+
+					while(p) {
+
+						for(Set<StringName>::Element *E=p->members.front();E;E=E->next()) {
+
+							Variant value;
+							if (ins->get(E->get(),value)) {
+
+								String k = E->get();
+								if (!d.has(k)) {
+									d[k]=value;
+								}
+							}
+						}
+
+						p=p->_base;
+					}
+
+					r_ret=d;
+
+				}
+			}
+
+		} break;
+		case DICT2INST: {
+
+			VALIDATE_ARG_COUNT(1);
+
+			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;
+				return;
+			}
+
+			Dictionary d = *p_args[0];
+
+			if (!d.has("@path")) {
+
+				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument=0;
+				r_error.expected=Variant::OBJECT;
+				return;
+			}
+
+			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;
+				return;
+			}
+
+			Ref<GDScript> gdscr = scr;
+
+			if (!gdscr.is_valid()) {
+
+				r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument=0;
+				r_error.expected=Variant::OBJECT;
+				return;
+			}
+
+			NodePath sub;
+			if (d.has("@subpath")) {
+				sub=d["@subpath"];
+			}
+
+			for(int i=0;i<sub.get_name_count();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;
+					return;
+				}
+			}
+
+
+			r_ret = gdscr->_new(NULL,0,r_error);
+
+		} break;
+
+		case PRINT_STACK: {
+
+			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)+"'");
+			};
+		} break;
+
+		case FUNC_MAX: {
+
+			ERR_FAIL_V();
+		} break;
+
+	}
+
+}
+
+bool GDFunctions::is_deterministic(Function p_func) {
+
+	//man i couldn't have chosen a worse function name,
+	//way too controversial..
+
+	switch(p_func) {
+
+		case MATH_SIN:
+		case MATH_COS:
+		case MATH_TAN:
+		case MATH_SINH:
+		case MATH_COSH:
+		case MATH_TANH:
+		case MATH_ASIN:
+		case MATH_ACOS:
+		case MATH_ATAN:
+		case MATH_ATAN2:
+		case MATH_SQRT:
+		case MATH_FMOD:
+		case MATH_FPOSMOD:
+		case MATH_FLOOR:
+		case MATH_CEIL:
+		case MATH_ROUND:
+		case MATH_ABS:
+		case MATH_SIGN:
+		case MATH_POW:
+		case MATH_LOG:
+		case MATH_EXP:
+		case MATH_ISNAN:
+		case MATH_ISINF:
+		case MATH_EASE:
+		case MATH_DECIMALS:
+		case MATH_STEPIFY:
+		case MATH_LERP:
+		case MATH_DECTIME:
+		case MATH_DEG2RAD:
+		case MATH_RAD2DEG:
+		case MATH_LINEAR2DB:
+		case MATH_DB2LINEAR:
+		case LOGIC_MAX:
+		case LOGIC_MIN:
+		case LOGIC_CLAMP:
+		case LOGIC_NEAREST_PO2:
+		case TYPE_CONVERT:
+		case TYPE_OF:
+		case TEXT_STR:
+// enable for debug only, otherwise not desirable - case GEN_RANGE:
+			return true;
+		default:
+			return false;
+
+	}
+
+	return false;
+
+
+}
+
+MethodInfo GDFunctions::get_info(Function p_func) {
+
+#ifdef TOOLS_ENABLED
+	//using a switch, so the compiler generates a jumptable
+
+	switch(p_func) {
+
+		case MATH_SIN: {
+			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;
+			return mi;
+		} break;
+		case MATH_TAN: {
+			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;
+			return mi;
+		} break;
+		case MATH_COSH: {
+			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;
+			return mi;
+		} break;
+		case MATH_ASIN: {
+			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;
+			return mi;
+		} break;
+		case MATH_ATAN: {
+			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;
+			return mi;
+		} break;
+		case MATH_SQRT: {
+			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;
+			return mi;
+		} break;
+		case MATH_FPOSMOD: {
+			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;
+			return mi;
+		  } break;
+		case MATH_CEIL: {
+			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;
+			return mi;
+		} break;
+		case MATH_ABS: {
+			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;
+			return mi;
+		} break;
+		case MATH_POW: {
+			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;
+			return mi;
+		} break;
+		case MATH_EXP: {
+			MethodInfo mi("exp",PropertyInfo(Variant::REAL,"s"));
+			mi.return_val.type=Variant::REAL;
+			return mi;
+		} break;
+		case MATH_ISNAN: {
+			MethodInfo mi("isnan",PropertyInfo(Variant::REAL,"s"));
+			mi.return_val.type=Variant::REAL;
+			return mi;
+		} break;
+		case MATH_ISINF: {
+			MethodInfo mi("isinf",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;
+			return mi;
+		} break;
+		case MATH_DECIMALS: {
+			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;
+			return mi;
+		} break;
+		case MATH_LERP: {
+			MethodInfo mi("lerp",PropertyInfo(Variant::REAL,"a"),PropertyInfo(Variant::REAL,"b"), PropertyInfo(Variant::REAL,"c"));
+			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;
+			return mi;
+		} break;
+		case MATH_RANDOMIZE: {
+			MethodInfo mi("randomize");
+			mi.return_val.type=Variant::NIL;
+			return mi;
+		} break;
+		case MATH_RAND: {
+			MethodInfo mi("rand");
+			mi.return_val.type=Variant::INT;
+			return mi;
+		} break;
+		case MATH_RANDF: {
+			MethodInfo mi("randf");
+			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;
+			return mi;
+		} break;
+		case MATH_RANDSEED: {
+			MethodInfo mi("rand_seed",PropertyInfo(Variant::REAL,"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;
+			return mi;
+		} break;
+		case MATH_RAD2DEG: {
+			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;
+			return mi;
+		} break;
+		case MATH_DB2LINEAR: {
+			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;
+			return mi;
+
+		} break;
+		case LOGIC_MIN: {
+			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;
+			return mi;
+		} break;
+		case LOGIC_NEAREST_PO2: {
+			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;
+			return mi;
+
+		} break;
+		case TYPE_CONVERT: {
+
+			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;
+		};
+		case TEXT_STR: {
+
+			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;
+			return mi;
+
+		} break;
+		case TEXT_PRINT_TABBED: {
+
+			MethodInfo mi("printt",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;
+			return mi;
+
+		} break;
+		case TEXT_PRINTRAW: {
+
+			MethodInfo mi("printraw",PropertyInfo(Variant::NIL,"what"),PropertyInfo(Variant::NIL,"..."));
+			mi.return_val.type=Variant::NIL;
+			return mi;
+
+		} break;
+		case GEN_RANGE: {
+
+			MethodInfo mi("range",PropertyInfo(Variant::NIL,"..."));
+			mi.return_val.type=Variant::ARRAY;
+			return mi;
+		} break;
+		case INST2DICT: {
+
+			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;
+			return mi;
+		} break;
+
+		case PRINT_STACK: {
+			MethodInfo mi("print_stack");
+			mi.return_val.type=Variant::NIL;
+			return mi;
+		} break;
+
+		case FUNC_MAX: {
+
+			ERR_FAIL_V(MethodInfo());
+		} break;
+
+	}
+#endif
+
+	return MethodInfo();
+}