text: /*************************************************************************/
  /*  gdscript_function.h                                                  */
  /*************************************************************************/
  /*                       This file is part of:                           */
  /*                           GODOT ENGINE                                */
  /*                      https://godotengine.org                          */
  /*************************************************************************/
  /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
  /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
  /*                                                                       */
  /* 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.                */
  /*************************************************************************/
  
  #ifndef GDSCRIPT_FUNCTION_H
  #define GDSCRIPT_FUNCTION_H
  
  #include "core/os/thread.h"
  #include "core/pair.h"
  #include "core/reference.h"
  #include "core/script_language.h"
  #include "core/self_list.h"
  #include "core/string_name.h"
  #include "core/variant.h"
  
  class GDScriptInstance;
  class GDScript;
  
  struct GDScriptDataType {
  	enum Kind {
  		UNINITIALIZED,
  		BUILTIN,
  		NATIVE,
  		SCRIPT,
  		GDSCRIPT,
  	};
  
  	Kind kind = UNINITIALIZED;
  
  	bool has_type = false;
  	Variant::Type builtin_type = Variant::NIL;
  	StringName native_type;
  	Ref<Script> script_type;
  
  	bool is_type(const Variant &p_variant, bool p_allow_implicit_conversion = false) const {
  		if (!has_type) {
  			return true; // Can't type check
  		}
  
  		switch (kind) {
  			case UNINITIALIZED:
  				break;
  			case BUILTIN: {
  				Variant::Type var_type = p_variant.get_type();
  				bool valid = builtin_type == var_type;
  				if (!valid && p_allow_implicit_conversion) {
  					valid = Variant::can_convert_strict(var_type, builtin_type);
  				}
  				return valid;
  			} break;
  			case NATIVE: {
  				if (p_variant.get_type() == Variant::NIL) {
  					return true;
  				}
  				if (p_variant.get_type() != Variant::OBJECT) {
  					return false;
  				}
  
  				Object *obj = p_variant.get_validated_object();
  				if (!obj) {
  					return false;
  				}
  
  				if (!ClassDB::is_parent_class(obj->get_class_name(), native_type)) {
  					// Try with underscore prefix
  					StringName underscore_native_type = "_" + native_type;
  					if (!ClassDB::is_parent_class(obj->get_class_name(), underscore_native_type)) {
  						return false;
  					}
  				}
  				return true;
  			} break;
  			case SCRIPT:
  			case GDSCRIPT: {
  				if (p_variant.get_type() == Variant::NIL) {
  					return true;
  				}
  				if (p_variant.get_type() != Variant::OBJECT) {
  					return false;
  				}
  
  				Object *obj = p_variant.get_validated_object();
  				if (!obj) {
  					return false;
  				}
  
  				Ref<Script> base = obj && obj->get_script_instance() ? obj->get_script_instance()->get_script() : nullptr;
  				bool valid = false;
  				while (base.is_valid()) {
  					if (base == script_type) {
  						valid = true;
  						break;
  					}
  					base = base->get_base_script();
  				}
  				return valid;
  			} break;
  		}
  		return false;
  	}
  
  	operator PropertyInfo() const {
  		PropertyInfo info;
  		if (has_type) {
  			switch (kind) {
  				case UNINITIALIZED:
  					break;
  				case BUILTIN: {
  					info.type = builtin_type;
  				} break;
  				case NATIVE: {
  					info.type = Variant::OBJECT;
  					info.class_name = native_type;
  				} break;
  				case SCRIPT:
  				case GDSCRIPT: {
  					info.type = Variant::OBJECT;
  					info.class_name = script_type->get_instance_base_type();
  				} break;
  			}
  		} else {
  			info.type = Variant::NIL;
  			info.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
  		}
  		return info;
  	}
  
  	GDScriptDataType() {}
  };
  
  class GDScriptFunction {
  public:
  	enum Opcode {
  		OPCODE_OPERATOR,
  		OPCODE_EXTENDS_TEST,
  		OPCODE_IS_BUILTIN,
  		OPCODE_SET,
  		OPCODE_GET,
  		OPCODE_SET_NAMED,
  		OPCODE_GET_NAMED,
  		OPCODE_SET_MEMBER,
  		OPCODE_GET_MEMBER,
  		OPCODE_ASSIGN,
  		OPCODE_ASSIGN_TRUE,
  		OPCODE_ASSIGN_FALSE,
  		OPCODE_ASSIGN_TYPED_BUILTIN,
  		OPCODE_ASSIGN_TYPED_NATIVE,
  		OPCODE_ASSIGN_TYPED_SCRIPT,
  		OPCODE_CAST_TO_BUILTIN,
  		OPCODE_CAST_TO_NATIVE,
  		OPCODE_CAST_TO_SCRIPT,
  		OPCODE_CONSTRUCT, //only for basic types!!
  		OPCODE_CONSTRUCT_ARRAY,
  		OPCODE_CONSTRUCT_DICTIONARY,
  		OPCODE_CALL,
  		OPCODE_CALL_RETURN,
  		OPCODE_CALL_ASYNC,
  		OPCODE_CALL_BUILT_IN,
  		OPCODE_CALL_SELF_BASE,
  		OPCODE_AWAIT,
  		OPCODE_AWAIT_RESUME,
  		OPCODE_JUMP,
  		OPCODE_JUMP_IF,
  		OPCODE_JUMP_IF_NOT,
  		OPCODE_JUMP_TO_DEF_ARGUMENT,
  		OPCODE_RETURN,
  		OPCODE_ITERATE_BEGIN,
  		OPCODE_ITERATE,
  		OPCODE_ASSERT,
  		OPCODE_BREAKPOINT,
  		OPCODE_LINE,
  		OPCODE_END
  	};
  
  	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_NAMED_GLOBAL = 8,
  		ADDR_TYPE_NIL = 9
  	};
  
  	struct StackDebug {
  		int line;
  		int pos;
  		bool added;
  		StringName identifier;
  	};
  
  private:
  	friend class GDScriptCompiler;
  	friend class GDScriptByteCodeGenerator;
  
  	StringName source;
  
  	mutable Variant nil;
  	mutable Variant *_constants_ptr;
  	int _constant_count;
  	const StringName *_global_names_ptr;
  	int _global_names_count;
  	const int *_default_arg_ptr;
  	int _default_arg_count;
  	const int *_code_ptr;
  	int _code_size;
  	int _argument_count;
  	int _stack_size;
  	int _call_size;
  	int _initial_line;
  	bool _static;
  	MultiplayerAPI::RPCMode rpc_mode;
  
  	GDScript *_script;
  
  	StringName name;
  	Vector<Variant> constants;
  	Vector<StringName> global_names;
  	Vector<int> default_arguments;
  	Vector<int> code;
  	Vector<GDScriptDataType> argument_types;
  	GDScriptDataType return_type;
  
  #ifdef TOOLS_ENABLED
  	Vector<StringName> arg_names;
  #endif
  
  	List<StackDebug> stack_debug;
  
  	_FORCE_INLINE_ Variant *_get_variant(int p_address, GDScriptInstance *p_instance, GDScript *p_script, Variant &self, Variant &static_ref, Variant *p_stack, String &r_error) const;
  	_FORCE_INLINE_ String _get_call_error(const Callable::CallError &p_err, const String &p_where, const Variant **argptrs) const;
  
  	friend class GDScriptLanguage;
  
  	SelfList<GDScriptFunction> function_list;
  #ifdef DEBUG_ENABLED
  	CharString func_cname;
  	const char *_func_cname;
  
  	struct Profile {
  		StringName signature;
  		uint64_t call_count;
  		uint64_t self_time;
  		uint64_t total_time;
  		uint64_t frame_call_count;
  		uint64_t frame_self_time;
  		uint64_t frame_total_time;
  		uint64_t last_frame_call_count;
  		uint64_t last_frame_self_time;
  		uint64_t last_frame_total_time;
  	} profile;
  
  #endif
  
  public:
  	struct CallState {
  		GDScript *script;
  		GDScriptInstance *instance;
  #ifdef DEBUG_ENABLED
  		StringName function_name;
  		String script_path;
  #endif
  		Vector<uint8_t> stack;
  		int stack_size;
  		Variant self;
  		uint32_t alloca_size;
  		int ip;
  		int line;
  		int defarg;
  		Variant result;
  	};
  
  	_FORCE_INLINE_ bool is_static() const { return _static; }
  
  	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;
  	StringName get_name() const;
  	int get_max_stack_size() const;
  	int get_default_argument_count() const;
  	int get_default_argument_addr(int p_idx) const;
  	GDScriptDataType get_return_type() const;
  	GDScriptDataType get_argument_type(int p_idx) const;
  	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;
  
  	_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());
  		return arg_names[p_idx];
  #else
  		return StringName();
  #endif
  	}
  	Variant get_default_argument(int p_idx) const {
  		ERR_FAIL_INDEX_V(p_idx, default_arguments.size(), Variant());
  		return default_arguments[p_idx];
  	}
  
  	Variant call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Callable::CallError &r_err, CallState *p_state = nullptr);
  
  #ifdef DEBUG_ENABLED
  	void disassemble(const Vector<String> &p_code_lines) const;
  #endif
  
  	_FORCE_INLINE_ MultiplayerAPI::RPCMode get_rpc_mode() const { return rpc_mode; }
  	GDScriptFunction();
  	~GDScriptFunction();
  };
  
  class GDScriptFunctionState : public Reference {
  	GDCLASS(GDScriptFunctionState, Reference);
  	friend class GDScriptFunction;
  	GDScriptFunction *function;
  	GDScriptFunction::CallState state;
  	Variant _signal_callback(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
  	Ref<GDScriptFunctionState> first_state;
  
  	SelfList<GDScriptFunctionState> scripts_list;
  	SelfList<GDScriptFunctionState> instances_list;
  
  protected:
  	static void _bind_methods();
  
  public:
  	bool is_valid(bool p_extended_check = false) const;
  	Variant resume(const Variant &p_arg = Variant());
  
  	void _clear_stack();
  
  	GDScriptFunctionState();
  	~GDScriptFunctionState();
  };
  
  #endif // GDSCRIPT_FUNCTION_H
  