2022-07-12 12:20:34 +02:00
/*************************************************************************/
/* gdscript.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 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. */
/*************************************************************************/
# include "cscript.h"
# include "core/core_string_names.h"
# include "core/engine.h"
# include "core/global_constants.h"
# include "core/io/file_access_encrypted.h"
# include "core/os/file_access.h"
# include "core/os/os.h"
# include "core/project_settings.h"
# include "cscript_compiler.h"
///////////////////////////
2022-07-12 19:55:21 +02:00
CScriptNativeClass : : CScriptNativeClass ( const StringName & p_name ) {
2022-07-12 12:20:34 +02:00
name = p_name ;
}
2022-07-12 19:55:21 +02:00
bool CScriptNativeClass : : _get ( const StringName & p_name , Variant & r_ret ) const {
2022-07-12 12:20:34 +02:00
bool ok ;
int v = ClassDB : : get_integer_constant ( name , p_name , & ok ) ;
if ( ok ) {
r_ret = v ;
return true ;
} else {
return false ;
}
}
2022-07-12 19:55:21 +02:00
void CScriptNativeClass : : _bind_methods ( ) {
ClassDB : : bind_method ( D_METHOD ( " new " ) , & CScriptNativeClass : : _new ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
Variant CScriptNativeClass : : _new ( ) {
2022-07-12 12:20:34 +02:00
Object * o = instance ( ) ;
ERR_FAIL_COND_V_MSG ( ! o , Variant ( ) , " Class type: ' " + String ( name ) + " ' is not instantiable. " ) ;
Reference * ref = Object : : cast_to < Reference > ( o ) ;
if ( ref ) {
return REF ( ref ) ;
} else {
return o ;
}
}
2022-07-12 19:55:21 +02:00
Object * CScriptNativeClass : : instance ( ) {
2022-07-12 12:20:34 +02:00
return ClassDB : : instance ( name ) ;
}
2022-07-12 19:55:21 +02:00
void CScript : : _clear_pending_func_states ( ) {
CScriptLanguage : : get_singleton ( ) - > lock . lock ( ) ;
while ( SelfList < CScriptFunctionState > * E = pending_func_states . first ( ) ) {
2022-07-12 12:20:34 +02:00
// Order matters since clearing the stack may already cause
2022-07-12 19:55:21 +02:00
// the CSCriptFunctionState to be destroyed and thus removed from the list.
2022-07-12 12:20:34 +02:00
pending_func_states . remove ( E ) ;
E - > self ( ) - > _clear_stack ( ) ;
}
2022-07-12 19:55:21 +02:00
CScriptLanguage : : get_singleton ( ) - > lock . unlock ( ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
CScriptInstance * CScript : : _create_instance ( const Variant * * p_args , int p_argcount , Object * p_owner , bool p_isref , Variant : : CallError & r_error ) {
2022-07-12 12:20:34 +02:00
/* STEP 1, CREATE */
2022-07-12 19:55:21 +02:00
CScriptInstance * instance = memnew ( CScriptInstance ) ;
2022-07-12 12:20:34 +02:00
instance - > base_ref = p_isref ;
instance - > members . resize ( member_indices . size ( ) ) ;
2022-07-12 19:55:21 +02:00
instance - > script = Ref < CScript > ( this ) ;
2022-07-12 12:20:34 +02:00
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 ;
}
# endif
instance - > owner - > set_script_instance ( instance ) ;
/* STEP 2, INITIALIZE AND CONSTRUCT */
2022-07-12 19:55:21 +02:00
CScriptLanguage : : singleton - > lock . lock ( ) ;
2022-07-12 12:20:34 +02:00
instances . insert ( instance - > owner ) ;
2022-07-12 19:55:21 +02:00
CScriptLanguage : : singleton - > lock . unlock ( ) ;
2022-07-12 12:20:34 +02:00
initializer - > call ( instance , p_args , p_argcount , r_error ) ;
if ( r_error . error ! = Variant : : CallError : : CALL_OK ) {
2022-07-12 19:55:21 +02:00
instance - > script = Ref < CScript > ( ) ;
2022-07-12 12:20:34 +02:00
instance - > owner - > set_script_instance ( nullptr ) ;
# ifndef NO_THREADS
2022-07-12 19:55:21 +02:00
CScriptLanguage : : singleton - > lock . lock ( ) ;
2022-07-12 12:20:34 +02:00
# endif
instances . erase ( p_owner ) ;
# ifndef NO_THREADS
2022-07-12 19:55:21 +02:00
CScriptLanguage : : singleton - > lock . unlock ( ) ;
2022-07-12 12:20:34 +02:00
# endif
ERR_FAIL_COND_V ( r_error . error ! = Variant : : CallError : : CALL_OK , nullptr ) ; //error constructing
}
//@TODO make thread safe
return instance ;
}
2022-07-12 19:55:21 +02:00
Variant CScript : : _new ( const Variant * * p_args , int p_argcount , Variant : : CallError & r_error ) {
2022-07-12 12:20:34 +02:00
/* STEP 1, CREATE */
if ( ! valid ) {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_METHOD ;
return Variant ( ) ;
}
r_error . error = Variant : : CallError : : CALL_OK ;
REF ref ;
Object * owner = nullptr ;
2022-07-12 19:55:21 +02:00
CScript * _baseptr = this ;
2022-07-12 12:20:34 +02:00
while ( _baseptr - > _base ) {
_baseptr = _baseptr - > _base ;
}
ERR_FAIL_COND_V ( _baseptr - > native . is_null ( ) , Variant ( ) ) ;
if ( _baseptr - > native . ptr ( ) ) {
owner = _baseptr - > native - > instance ( ) ;
} else {
owner = memnew ( Reference ) ; //by default, no base means use reference
}
ERR_FAIL_COND_V_MSG ( ! owner , Variant ( ) , " Can't inherit from a virtual class. " ) ;
Reference * r = Object : : cast_to < Reference > ( owner ) ;
if ( r ) {
ref = REF ( r ) ;
}
2022-07-12 19:55:21 +02:00
CScriptInstance * instance = _create_instance ( p_args , p_argcount , owner , r ! = nullptr , r_error ) ;
2022-07-12 12:20:34 +02:00
if ( ! instance ) {
if ( ref . is_null ( ) ) {
memdelete ( owner ) ; //no owner, sorry
}
return Variant ( ) ;
}
if ( ref . is_valid ( ) ) {
return ref ;
} else {
return owner ;
}
}
2022-07-12 19:55:21 +02:00
bool CScript : : can_instance ( ) const {
2022-07-12 12:20:34 +02:00
# ifdef TOOLS_ENABLED
return valid & & ( tool | | ScriptServer : : is_scripting_enabled ( ) ) ;
# else
return valid ;
# endif
}
2022-07-12 19:55:21 +02:00
Ref < Script > CScript : : get_base_script ( ) const {
2022-07-12 12:20:34 +02:00
if ( _base ) {
2022-07-12 19:55:21 +02:00
return Ref < CScript > ( _base ) ;
2022-07-12 12:20:34 +02:00
} else {
return Ref < Script > ( ) ;
}
}
2022-07-12 19:55:21 +02:00
StringName CScript : : get_instance_base_type ( ) const {
2022-07-12 12:20:34 +02:00
if ( native . is_valid ( ) ) {
return native - > get_name ( ) ;
}
if ( base . is_valid ( ) & & base - > is_valid ( ) ) {
return base - > get_instance_base_type ( ) ;
}
return StringName ( ) ;
}
2022-07-12 19:55:21 +02:00
struct _CScriptMemberSort {
2022-07-12 12:20:34 +02:00
int index ;
StringName name ;
2022-07-12 19:55:21 +02:00
_FORCE_INLINE_ bool operator < ( const _CScriptMemberSort & p_member ) const { return index < p_member . index ; }
2022-07-12 12:20:34 +02:00
} ;
# ifdef TOOLS_ENABLED
2022-07-12 19:55:21 +02:00
void CScript : : _placeholder_erased ( PlaceHolderScriptInstance * p_placeholder ) {
2022-07-12 12:20:34 +02:00
placeholders . erase ( p_placeholder ) ;
}
# endif
2022-07-12 19:55:21 +02:00
void CScript : : get_script_method_list ( List < MethodInfo > * p_list ) const {
const CScript * current = this ;
2022-07-12 12:20:34 +02:00
while ( current ) {
2022-07-12 19:55:21 +02:00
for ( const Map < StringName , CScriptFunction * > : : Element * E = current - > member_functions . front ( ) ; E ; E = E - > next ( ) ) {
CScriptFunction * func = E - > get ( ) ;
2022-07-12 12:20:34 +02:00
MethodInfo mi ;
mi . name = E - > key ( ) ;
for ( int i = 0 ; i < func - > get_argument_count ( ) ; i + + ) {
mi . arguments . push_back ( func - > get_argument_type ( i ) ) ;
}
mi . return_val = func - > get_return_type ( ) ;
p_list - > push_back ( mi ) ;
}
current = current - > _base ;
}
}
2022-07-12 19:55:21 +02:00
void CScript : : get_script_property_list ( List < PropertyInfo > * p_list ) const {
const CScript * sptr = this ;
2022-07-12 12:20:34 +02:00
List < PropertyInfo > props ;
while ( sptr ) {
2022-07-12 19:55:21 +02:00
Vector < _CScriptMemberSort > msort ;
2022-07-12 12:20:34 +02:00
for ( Map < StringName , PropertyInfo > : : Element * E = sptr - > member_info . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 19:55:21 +02:00
_CScriptMemberSort ms ;
2022-07-12 12:20:34 +02:00
ERR_CONTINUE ( ! sptr - > member_indices . has ( 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 + + ) {
props . push_front ( sptr - > member_info [ msort [ i ] . name ] ) ;
}
sptr = sptr - > _base ;
}
for ( List < PropertyInfo > : : Element * E = props . front ( ) ; E ; E = E - > next ( ) ) {
p_list - > push_back ( E - > get ( ) ) ;
}
}
2022-07-12 19:55:21 +02:00
bool CScript : : has_method ( const StringName & p_method ) const {
2022-07-12 12:20:34 +02:00
return member_functions . has ( p_method ) ;
}
2022-07-12 19:55:21 +02:00
MethodInfo CScript : : get_method_info ( const StringName & p_method ) const {
const Map < StringName , CScriptFunction * > : : Element * E = member_functions . find ( p_method ) ;
2022-07-12 12:20:34 +02:00
if ( ! E ) {
return MethodInfo ( ) ;
}
2022-07-12 19:55:21 +02:00
CScriptFunction * func = E - > get ( ) ;
2022-07-12 12:20:34 +02:00
MethodInfo mi ;
mi . name = E - > key ( ) ;
for ( int i = 0 ; i < func - > get_argument_count ( ) ; i + + ) {
mi . arguments . push_back ( func - > get_argument_type ( i ) ) ;
}
mi . return_val = func - > get_return_type ( ) ;
return mi ;
}
2022-07-12 19:55:21 +02:00
bool CScript : : get_property_default_value ( const StringName & p_property , Variant & r_value ) const {
2022-07-12 12:20:34 +02:00
# ifdef TOOLS_ENABLED
const Map < StringName , Variant > : : Element * E = member_default_values_cache . find ( p_property ) ;
if ( E ) {
r_value = E - > get ( ) ;
return true ;
}
if ( base_cache . is_valid ( ) ) {
return base_cache - > get_property_default_value ( p_property , r_value ) ;
}
# endif
return false ;
}
2022-07-12 19:55:21 +02:00
ScriptInstance * CScript : : instance_create ( Object * p_this ) {
CScript * top = this ;
2022-07-12 12:20:34 +02:00
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 ( ScriptDebugger : : get_singleton ( ) ) {
2022-07-12 19:55:21 +02:00
CScriptLanguage : : get_singleton ( ) - > debug_break_parse ( _get_debug_path ( ) , 1 , " Script inherits from native type ' " + String ( top - > native - > get_name ( ) ) + " ', so it can't be instanced in object of type: ' " + p_this - > get_class ( ) + " ' " ) ;
2022-07-12 12:20:34 +02:00
}
ERR_FAIL_V_MSG ( nullptr , " Script inherits from native type ' " + String ( top - > native - > get_name ( ) ) + " ', so it can't be instanced in object of type ' " + p_this - > get_class ( ) + " ' " + " . " ) ;
}
}
Variant : : CallError unchecked_error ;
return _create_instance ( nullptr , 0 , p_this , Object : : cast_to < Reference > ( p_this ) ! = nullptr , unchecked_error ) ;
}
2022-07-12 19:55:21 +02:00
PlaceHolderScriptInstance * CScript : : placeholder_instance_create ( Object * p_this ) {
2022-07-12 12:20:34 +02:00
# ifdef TOOLS_ENABLED
2022-07-12 19:55:21 +02:00
PlaceHolderScriptInstance * si = memnew ( PlaceHolderScriptInstance ( CScriptLanguage : : get_singleton ( ) , Ref < Script > ( this ) , p_this ) ) ;
2022-07-12 12:20:34 +02:00
placeholders . insert ( si ) ;
_update_exports ( nullptr , false , si ) ;
return si ;
# else
return NULL ;
# endif
}
2022-07-12 19:55:21 +02:00
bool CScript : : instance_has ( const Object * p_this ) const {
CScriptLanguage : : singleton - > lock . lock ( ) ;
2022-07-12 12:20:34 +02:00
bool hasit = instances . has ( ( Object * ) p_this ) ;
2022-07-12 19:55:21 +02:00
CScriptLanguage : : singleton - > lock . unlock ( ) ;
2022-07-12 12:20:34 +02:00
return hasit ;
}
2022-07-12 19:55:21 +02:00
bool CScript : : has_source_code ( ) const {
2022-07-12 12:20:34 +02:00
return source ! = " " ;
}
2022-07-12 19:55:21 +02:00
String CScript : : get_source_code ( ) const {
2022-07-12 12:20:34 +02:00
return source ;
}
2022-07-12 19:55:21 +02:00
void CScript : : set_source_code ( const String & p_code ) {
2022-07-12 12:20:34 +02:00
if ( source = = p_code ) {
return ;
}
source = p_code ;
# ifdef TOOLS_ENABLED
source_changed_cache = true ;
# endif
}
# ifdef TOOLS_ENABLED
2022-07-12 19:55:21 +02:00
void CScript : : _update_exports_values ( Map < StringName , Variant > & values , List < PropertyInfo > & propnames ) {
2022-07-12 12:20:34 +02:00
if ( base_cache . is_valid ( ) ) {
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 ( List < PropertyInfo > : : Element * E = members_cache . front ( ) ; E ; E = E - > next ( ) ) {
propnames . push_back ( E - > get ( ) ) ;
}
}
# endif
2022-07-12 19:55:21 +02:00
bool CScript : : _update_exports ( bool * r_err , bool p_recursive_call , PlaceHolderScriptInstance * p_instance_to_update ) {
2022-07-12 12:20:34 +02:00
# ifdef TOOLS_ENABLED
2022-07-12 19:55:21 +02:00
static Vector < CScript * > base_caches ;
2022-07-12 12:20:34 +02:00
if ( ! p_recursive_call ) {
base_caches . clear ( ) ;
}
base_caches . push_back ( this ) ;
bool changed = false ;
if ( source_changed_cache ) {
source_changed_cache = false ;
changed = true ;
String basedir = path ;
if ( basedir = = " " ) {
basedir = get_path ( ) ;
}
if ( basedir ! = " " ) {
basedir = basedir . get_base_dir ( ) ;
}
2022-07-12 19:55:21 +02:00
CScriptParser parser ;
2022-07-12 12:20:34 +02:00
Error err = parser . parse ( source , basedir , true , path ) ;
if ( err = = OK ) {
2022-07-12 19:55:21 +02:00
const CScriptParser : : Node * root = parser . get_parse_tree ( ) ;
ERR_FAIL_COND_V ( root - > type ! = CScriptParser : : Node : : TYPE_CLASS , false ) ;
2022-07-12 12:20:34 +02:00
2022-07-12 19:55:21 +02:00
const CScriptParser : : ClassNode * c = static_cast < const CScriptParser : : ClassNode * > ( root ) ;
2022-07-12 12:20:34 +02:00
if ( base_cache . is_valid ( ) ) {
base_cache - > inheriters_cache . erase ( get_instance_id ( ) ) ;
2022-07-12 19:55:21 +02:00
base_cache = Ref < CScript > ( ) ;
2022-07-12 12:20:34 +02:00
}
if ( c - > extends_used ) {
String path = " " ;
if ( String ( c - > extends_file ) ! = " " & & String ( c - > extends_file ) ! = get_path ( ) ) {
path = c - > extends_file ;
if ( path . is_rel_path ( ) ) {
String base = get_path ( ) ;
if ( base = = " " | | base . is_rel_path ( ) ) {
ERR_PRINT ( ( " Could not resolve relative path for parent class: " + path ) . utf8 ( ) . get_data ( ) ) ;
} else {
path = base . get_base_dir ( ) . plus_file ( path ) ;
}
}
} else if ( c - > extends_class . size ( ) ! = 0 ) {
String base = c - > extends_class [ 0 ] ;
if ( ScriptServer : : is_global_class ( base ) ) {
path = ScriptServer : : get_global_class_path ( base ) ;
}
}
if ( path ! = " " ) {
if ( path ! = get_path ( ) ) {
2022-07-12 19:55:21 +02:00
Ref < CScript > bf = ResourceLoader : : load ( path ) ;
2022-07-12 12:20:34 +02:00
if ( bf . is_valid ( ) ) {
base_cache = bf ;
bf - > inheriters_cache . insert ( get_instance_id ( ) ) ;
}
} else {
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 ) {
continue ;
}
members_cache . push_back ( c - > variables [ i ] . _export ) ;
Variant : : Type default_value_type = c - > variables [ i ] . default_value . get_type ( ) ;
Variant : : Type export_type = c - > variables [ i ] . _export . type ;
// Convert the default value to the export type to avoid issues with the property editor and scene serialization.
// This is done only in the export side, the script itself will use the default value with no type change.
if ( default_value_type ! = Variant : : NIL & & default_value_type ! = export_type ) {
Variant : : CallError ce ;
const Variant * args = & c - > variables [ i ] . default_value ;
member_default_values_cache [ c - > variables [ i ] . identifier ] = Variant : : construct ( export_type , & args , 1 , ce ) ;
} else {
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 ;
}
} else {
placeholder_fallback_enabled = true ;
return false ;
}
} else if ( placeholder_fallback_enabled ) {
return false ;
}
placeholder_fallback_enabled = false ;
if ( base_cache . is_valid ( ) & & base_cache - > is_valid ( ) ) {
for ( int i = 0 ; i < base_caches . size ( ) ; i + + ) {
if ( base_caches [ i ] = = base_cache . ptr ( ) ) {
if ( r_err ) {
* r_err = true ;
}
valid = false ; // to show error in the editor
base_cache - > valid = false ;
base_cache - > inheriters_cache . clear ( ) ; // to prevent future stackoverflows
base_cache . unref ( ) ;
base . unref ( ) ;
_base = nullptr ;
ERR_FAIL_V_MSG ( false , " Cyclic inheritance in script class. " ) ;
}
}
if ( base_cache - > _update_exports ( r_err , true ) ) {
if ( r_err & & * r_err ) {
return false ;
}
changed = true ;
}
}
if ( ( changed | | p_instance_to_update ) & & placeholders . size ( ) ) { //hm :(
// update placeholders if any
Map < StringName , Variant > values ;
List < PropertyInfo > propnames ;
_update_exports_values ( values , propnames ) ;
if ( changed ) {
for ( Set < PlaceHolderScriptInstance * > : : Element * E = placeholders . front ( ) ; E ; E = E - > next ( ) ) {
E - > get ( ) - > update ( propnames , values ) ;
}
} else {
p_instance_to_update - > update ( propnames , values ) ;
}
}
return changed ;
# else
return false ;
# endif
}
2022-07-12 19:55:21 +02:00
void CScript : : update_exports ( ) {
2022-07-12 12:20:34 +02:00
# ifdef TOOLS_ENABLED
bool cyclic_error = false ;
_update_exports ( & cyclic_error ) ;
if ( cyclic_error ) {
return ;
}
Set < ObjectID > copy = inheriters_cache ; //might get modified
for ( Set < ObjectID > : : Element * E = copy . front ( ) ; E ; E = E - > next ( ) ) {
Object * id = ObjectDB : : get_instance ( E - > get ( ) ) ;
2022-07-12 19:55:21 +02:00
CScript * s = Object : : cast_to < CScript > ( id ) ;
2022-07-12 12:20:34 +02:00
if ( ! s ) {
continue ;
}
s - > update_exports ( ) ;
}
# endif
}
2022-07-12 19:55:21 +02:00
void CScript : : _set_subclass_path ( Ref < CScript > & p_sc , const String & p_path ) {
2022-07-12 12:20:34 +02:00
p_sc - > path = p_path ;
2022-07-12 19:55:21 +02:00
for ( Map < StringName , Ref < CScript > > : : Element * E = p_sc - > subclasses . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
_set_subclass_path ( E - > get ( ) , p_path ) ;
}
}
2022-07-12 19:55:21 +02:00
String CScript : : _get_debug_path ( ) const {
2022-07-12 12:20:34 +02:00
if ( ( get_path ( ) . empty ( ) | | get_path ( ) . find ( " :: " ) ! = - 1 ) & & ! get_name ( ) . empty ( ) ) {
return get_name ( ) + " ( " + get_path ( ) . get_slice ( " :: " , 0 ) + " ) " ;
} else {
return get_path ( ) ;
}
}
2022-07-12 19:55:21 +02:00
Error CScript : : reload ( bool p_keep_state ) {
CScriptLanguage : : singleton - > lock . lock ( ) ;
2022-07-12 12:20:34 +02:00
bool has_instances = instances . size ( ) ;
2022-07-12 19:55:21 +02:00
CScriptLanguage : : singleton - > lock . unlock ( ) ;
2022-07-12 12:20:34 +02:00
ERR_FAIL_COND_V ( ! p_keep_state & & has_instances , ERR_ALREADY_IN_USE ) ;
String basedir = path ;
if ( basedir = = " " ) {
basedir = get_path ( ) ;
}
if ( basedir ! = " " ) {
basedir = basedir . get_base_dir ( ) ;
}
if ( source . find ( " %BASE% " ) ! = - 1 ) {
//loading a template, don't parse
return OK ;
}
valid = false ;
2022-07-12 19:55:21 +02:00
CScriptParser parser ;
2022-07-12 12:20:34 +02:00
Error err = parser . parse ( source , basedir , false , path ) ;
if ( err ) {
if ( ScriptDebugger : : get_singleton ( ) ) {
2022-07-12 19:55:21 +02:00
CScriptLanguage : : get_singleton ( ) - > debug_break_parse ( _get_debug_path ( ) , parser . get_error_line ( ) , " Parser Error: " + parser . get_error ( ) ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
_err_print_error ( " CScript::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 ) ;
2022-07-12 12:20:34 +02:00
ERR_FAIL_V ( ERR_PARSE_ERROR ) ;
}
bool can_run = ScriptServer : : is_scripting_enabled ( ) | | parser . is_tool_script ( ) ;
2022-07-12 19:55:21 +02:00
CScriptCompiler compiler ;
2022-07-12 12:20:34 +02:00
err = compiler . compile ( & parser , this , p_keep_state ) ;
if ( err ) {
if ( can_run ) {
if ( ScriptDebugger : : get_singleton ( ) ) {
2022-07-12 19:55:21 +02:00
CScriptLanguage : : get_singleton ( ) - > debug_break_parse ( _get_debug_path ( ) , compiler . get_error_line ( ) , " Parser Error: " + compiler . get_error ( ) ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
_err_print_error ( " CScript::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 ) ;
2022-07-12 12:20:34 +02:00
ERR_FAIL_V ( ERR_COMPILATION_FAILED ) ;
} else {
return err ;
}
}
# ifdef DEBUG_ENABLED
2022-07-12 19:55:21 +02:00
for ( const List < CScriptWarning > : : Element * E = parser . get_warnings ( ) . front ( ) ; E ; E = E - > next ( ) ) {
const CScriptWarning & warning = E - > get ( ) ;
2022-07-12 12:20:34 +02:00
if ( ScriptDebugger : : get_singleton ( ) ) {
Vector < ScriptLanguage : : StackInfo > si ;
ScriptDebugger : : get_singleton ( ) - > send_error ( " " , get_path ( ) , warning . line , warning . get_name ( ) , warning . get_message ( ) , ERR_HANDLER_WARNING , si ) ;
}
}
# endif
valid = true ;
2022-07-12 19:55:21 +02:00
for ( Map < StringName , Ref < CScript > > : : Element * E = subclasses . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
_set_subclass_path ( E - > get ( ) , path ) ;
}
_clear_pending_func_states ( ) ;
return OK ;
}
2022-07-12 19:55:21 +02:00
ScriptLanguage * CScript : : get_language ( ) const {
return CScriptLanguage : : get_singleton ( ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
void CScript : : get_constants ( Map < StringName , Variant > * p_constants ) {
2022-07-12 12:20:34 +02:00
if ( p_constants ) {
for ( Map < StringName , Variant > : : Element * E = constants . front ( ) ; E ; E = E - > next ( ) ) {
( * p_constants ) [ E - > key ( ) ] = E - > value ( ) ;
}
}
}
2022-07-12 19:55:21 +02:00
void CScript : : get_members ( Set < StringName > * p_members ) {
2022-07-12 12:20:34 +02:00
if ( p_members ) {
for ( Set < StringName > : : Element * E = members . front ( ) ; E ; E = E - > next ( ) ) {
p_members - > insert ( E - > get ( ) ) ;
}
}
}
2022-07-12 19:55:21 +02:00
Variant CScript : : call ( const StringName & p_method , const Variant * * p_args , int p_argcount , Variant : : CallError & r_error ) {
CScript * top = this ;
2022-07-12 12:20:34 +02:00
while ( top ) {
2022-07-12 19:55:21 +02:00
Map < StringName , CScriptFunction * > : : Element * E = top - > member_functions . find ( p_method ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
ERR_FAIL_COND_V_MSG ( ! E - > get ( ) - > is_static ( ) , Variant ( ) , " Can't call non-static function ' " + String ( p_method ) + " ' in script. " ) ;
return E - > get ( ) - > call ( nullptr , p_args , p_argcount , r_error ) ;
}
top = top - > _base ;
}
//none found, regular
return Script : : call ( p_method , p_args , p_argcount , r_error ) ;
}
2022-07-12 19:55:21 +02:00
bool CScript : : _get ( const StringName & p_name , Variant & r_ret ) const {
2022-07-12 12:20:34 +02:00
{
2022-07-12 19:55:21 +02:00
const CScript * top = this ;
2022-07-12 12:20:34 +02:00
while ( top ) {
{
const Map < StringName , Variant > : : Element * E = top - > constants . find ( p_name ) ;
if ( E ) {
r_ret = E - > get ( ) ;
return true ;
}
}
{
2022-07-12 19:55:21 +02:00
const Map < StringName , Ref < CScript > > : : Element * E = subclasses . find ( p_name ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
r_ret = E - > get ( ) ;
return true ;
}
}
top = top - > _base ;
}
2022-07-12 19:55:21 +02:00
if ( p_name = = CScriptLanguage : : get_singleton ( ) - > strings . _script_source ) {
2022-07-12 12:20:34 +02:00
r_ret = get_source_code ( ) ;
return true ;
}
}
return false ;
}
2022-07-12 19:55:21 +02:00
bool CScript : : _set ( const StringName & p_name , const Variant & p_value ) {
if ( p_name = = CScriptLanguage : : get_singleton ( ) - > strings . _script_source ) {
2022-07-12 12:20:34 +02:00
set_source_code ( p_value ) ;
reload ( ) ;
} else {
return false ;
}
return true ;
}
2022-07-12 19:55:21 +02:00
void CScript : : _get_property_list ( List < PropertyInfo > * p_properties ) const {
2022-07-12 12:20:34 +02:00
p_properties - > push_back ( PropertyInfo ( Variant : : STRING , " script/source " , PROPERTY_HINT_NONE , " " , PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL ) ) ;
}
2022-07-12 19:55:21 +02:00
void CScript : : _bind_methods ( ) {
ClassDB : : bind_vararg_method ( METHOD_FLAGS_DEFAULT , " new " , & CScript : : _new , MethodInfo ( " new " ) ) ;
2022-07-12 12:20:34 +02:00
2022-07-12 19:55:21 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_as_byte_code " ) , & CScript : : get_as_byte_code ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
Vector < uint8_t > CScript : : get_as_byte_code ( ) const {
CScriptTokenizerBuffer tokenizer ;
2022-07-12 12:20:34 +02:00
return tokenizer . parse_code_string ( source ) ;
} ;
2022-07-12 19:55:21 +02:00
Error CScript : : load_byte_code ( const String & p_path ) {
2022-07-12 12:20:34 +02:00
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 ) ;
Vector < uint8_t > key ;
key . resize ( 32 ) ;
for ( int i = 0 ; i < key . size ( ) ; i + + ) {
key . write [ i ] = script_encryption_key [ i ] ;
}
Error err = fae - > open_and_parse ( fa , key , FileAccessEncrypted : : MODE_READ ) ;
if ( err ) {
fa - > close ( ) ;
memdelete ( fa ) ;
memdelete ( fae ) ;
ERR_FAIL_COND_V ( err , err ) ;
}
bytecode . resize ( fae - > get_len ( ) ) ;
fae - > get_buffer ( bytecode . ptrw ( ) , bytecode . size ( ) ) ;
fae - > close ( ) ;
memdelete ( fae ) ;
} else {
bytecode = FileAccess : : get_file_as_array ( p_path ) ;
}
ERR_FAIL_COND_V ( bytecode . size ( ) = = 0 , ERR_PARSE_ERROR ) ;
path = p_path ;
String basedir = path ;
if ( basedir = = " " ) {
basedir = get_path ( ) ;
}
if ( basedir ! = " " ) {
basedir = basedir . get_base_dir ( ) ;
}
valid = false ;
2022-07-12 19:55:21 +02:00
CScriptParser parser ;
2022-07-12 12:20:34 +02:00
Error err = parser . parse_bytecode ( bytecode , basedir , get_path ( ) ) ;
if ( err ) {
2022-07-12 19:55:21 +02:00
_err_print_error ( " CScript::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 ) ;
2022-07-12 12:20:34 +02:00
ERR_FAIL_V ( ERR_PARSE_ERROR ) ;
}
2022-07-12 19:55:21 +02:00
CScriptCompiler compiler ;
2022-07-12 12:20:34 +02:00
err = compiler . compile ( & parser , this ) ;
if ( err ) {
2022-07-12 19:55:21 +02:00
_err_print_error ( " CScript::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 ) ;
2022-07-12 12:20:34 +02:00
ERR_FAIL_V ( ERR_COMPILATION_FAILED ) ;
}
valid = true ;
2022-07-12 19:55:21 +02:00
for ( Map < StringName , Ref < CScript > > : : Element * E = subclasses . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
_set_subclass_path ( E - > get ( ) , path ) ;
}
return OK ;
}
2022-07-12 19:55:21 +02:00
Error CScript : : load_source_code ( const String & p_path ) {
2022-07-12 12:20:34 +02:00
PoolVector < uint8_t > sourcef ;
Error err ;
FileAccess * f = FileAccess : : open ( p_path , FileAccess : : READ , & err ) ;
if ( err ) {
ERR_FAIL_COND_V ( err , err ) ;
}
uint64_t len = f - > get_len ( ) ;
sourcef . resize ( len + 1 ) ;
PoolVector < uint8_t > : : Write w = sourcef . write ( ) ;
uint64_t r = f - > get_buffer ( w . ptr ( ) , len ) ;
f - > close ( ) ;
memdelete ( f ) ;
ERR_FAIL_COND_V ( r ! = len , ERR_CANT_OPEN ) ;
w [ len ] = 0 ;
String s ;
if ( s . parse_utf8 ( ( const char * ) w . ptr ( ) ) ) {
ERR_FAIL_V_MSG ( ERR_INVALID_DATA , " Script ' " + p_path + " ' contains invalid unicode (UTF-8), so it was not loaded. Please ensure that scripts are saved in valid UTF-8 unicode. " ) ;
}
source = s ;
# ifdef TOOLS_ENABLED
source_changed_cache = true ;
# endif
path = p_path ;
return OK ;
}
2022-07-12 19:55:21 +02:00
const Map < StringName , CScriptFunction * > & CScript : : debug_get_member_functions ( ) const {
2022-07-12 12:20:34 +02:00
return member_functions ;
}
2022-07-12 19:55:21 +02:00
StringName CScript : : debug_get_member_by_index ( int p_idx ) const {
2022-07-12 12:20:34 +02:00
for ( const Map < StringName , MemberInfo > : : Element * E = member_indices . front ( ) ; E ; E = E - > next ( ) ) {
if ( E - > get ( ) . index = = p_idx ) {
return E - > key ( ) ;
}
}
return " <error> " ;
}
2022-07-12 19:55:21 +02:00
Ref < CScript > CScript : : get_base ( ) const {
2022-07-12 12:20:34 +02:00
return base ;
}
2022-07-12 19:55:21 +02:00
bool CScript : : inherits_script ( const Ref < Script > & p_script ) const {
Ref < CScript > gd = p_script ;
2022-07-12 12:20:34 +02:00
if ( gd . is_null ( ) ) {
return false ;
}
2022-07-12 19:55:21 +02:00
const CScript * s = this ;
2022-07-12 12:20:34 +02:00
while ( s ) {
if ( s = = p_script . ptr ( ) ) {
return true ;
}
s = s - > _base ;
}
return false ;
}
2022-07-12 19:55:21 +02:00
bool CScript : : has_script_signal ( const StringName & p_signal ) const {
2022-07-12 12:20:34 +02:00
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 ( ) ) {
return base_cache - > has_script_signal ( p_signal ) ;
}
# endif
return false ;
}
2022-07-12 19:55:21 +02:00
void CScript : : get_script_signal_list ( List < MethodInfo > * r_signals ) const {
2022-07-12 12:20:34 +02:00
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 + + ) {
PropertyInfo arg ;
arg . name = E - > get ( ) [ i ] ;
mi . arguments . push_back ( arg ) ;
}
r_signals - > push_back ( mi ) ;
}
if ( base . is_valid ( ) ) {
base - > get_script_signal_list ( r_signals ) ;
}
# ifdef TOOLS_ENABLED
else if ( base_cache . is_valid ( ) ) {
base_cache - > get_script_signal_list ( r_signals ) ;
}
# endif
}
2022-07-12 19:55:21 +02:00
CScript : : CScript ( ) :
2022-07-12 12:20:34 +02:00
script_list ( this ) {
valid = false ;
subclass_count = 0 ;
initializer = nullptr ;
_base = nullptr ;
_owner = nullptr ;
tool = false ;
# ifdef TOOLS_ENABLED
source_changed_cache = false ;
placeholder_fallback_enabled = false ;
# endif
# ifdef DEBUG_ENABLED
2022-07-12 19:55:21 +02:00
CScriptLanguage : : get_singleton ( ) - > lock . lock ( ) ;
CScriptLanguage : : get_singleton ( ) - > script_list . add ( & script_list ) ;
CScriptLanguage : : get_singleton ( ) - > lock . unlock ( ) ;
2022-07-12 12:20:34 +02:00
# endif
}
2022-07-12 19:55:21 +02:00
void CScript : : _save_orphaned_subclasses ( ) {
2022-07-12 12:20:34 +02:00
struct ClassRefWithName {
ObjectID id ;
String fully_qualified_name ;
} ;
Vector < ClassRefWithName > weak_subclasses ;
// collect subclasses ObjectID and name
2022-07-12 19:55:21 +02:00
for ( Map < StringName , Ref < CScript > > : : Element * E = subclasses . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
E - > get ( ) - > _owner = nullptr ; //bye, you are no longer owned cause I died
ClassRefWithName subclass ;
subclass . id = E - > get ( ) - > get_instance_id ( ) ;
subclass . fully_qualified_name = E - > get ( ) - > fully_qualified_name ;
weak_subclasses . push_back ( subclass ) ;
}
// clear subclasses to allow unused subclasses to be deleted
subclasses . clear ( ) ;
// subclasses are also held by constants, clear those as well
constants . clear ( ) ;
// keep orphan subclass only for subclasses that are still in use
for ( int i = 0 ; i < weak_subclasses . size ( ) ; i + + ) {
ClassRefWithName subclass = weak_subclasses [ i ] ;
Object * obj = ObjectDB : : get_instance ( subclass . id ) ;
if ( ! obj ) {
continue ;
}
// subclass is not released
2022-07-12 19:55:21 +02:00
CScriptLanguage : : get_singleton ( ) - > add_orphan_subclass ( subclass . fully_qualified_name , subclass . id ) ;
2022-07-12 12:20:34 +02:00
}
}
2022-07-12 19:55:21 +02:00
CScript : : ~ CScript ( ) {
2022-07-12 12:20:34 +02:00
_clear_pending_func_states ( ) ;
2022-07-12 19:55:21 +02:00
for ( Map < StringName , CScriptFunction * > : : Element * E = member_functions . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
memdelete ( E - > get ( ) ) ;
}
_save_orphaned_subclasses ( ) ;
# ifdef DEBUG_ENABLED
2022-07-12 19:55:21 +02:00
CScriptLanguage : : get_singleton ( ) - > lock . lock ( ) ;
CScriptLanguage : : get_singleton ( ) - > script_list . remove ( & script_list ) ;
CScriptLanguage : : get_singleton ( ) - > lock . unlock ( ) ;
2022-07-12 12:20:34 +02:00
# endif
}
//////////////////////////////
// INSTANCE //
//////////////////////////////
2022-07-12 19:55:21 +02:00
bool CScriptInstance : : set ( const StringName & p_name , const Variant & p_value ) {
2022-07-12 12:20:34 +02:00
//member
{
2022-07-12 19:55:21 +02:00
const Map < StringName , CScript : : MemberInfo > : : Element * E = script - > member_indices . find ( p_name ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
2022-07-12 19:55:21 +02:00
const CScript : : MemberInfo * member = & E - > get ( ) ;
2022-07-12 12:20:34 +02:00
if ( member - > setter ) {
const Variant * val = & p_value ;
Variant : : CallError err ;
call ( member - > setter , & val , 1 , err ) ;
if ( err . error = = Variant : : CallError : : CALL_OK ) {
return true ; //function exists, call was successful
} else {
return false ;
}
} else {
if ( ! member - > data_type . is_type ( p_value ) ) {
// Try conversion
Variant : : CallError ce ;
const Variant * value = & p_value ;
Variant converted = Variant : : construct ( member - > data_type . builtin_type , & value , 1 , ce ) ;
if ( ce . error = = Variant : : CallError : : CALL_OK ) {
members . write [ member - > index ] = converted ;
return true ;
} else {
return false ;
}
} else {
members . write [ member - > index ] = p_value ;
}
}
return true ;
}
}
2022-07-12 19:55:21 +02:00
CScript * sptr = script . ptr ( ) ;
2022-07-12 12:20:34 +02:00
while ( sptr ) {
2022-07-12 19:55:21 +02:00
Map < StringName , CScriptFunction * > : : Element * E = sptr - > member_functions . find ( CScriptLanguage : : get_singleton ( ) - > strings . _set ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
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 ( ) ) {
return true ;
}
}
sptr = sptr - > _base ;
}
return false ;
}
2022-07-12 19:55:21 +02:00
bool CScriptInstance : : get ( const StringName & p_name , Variant & r_ret ) const {
const CScript * sptr = script . ptr ( ) ;
2022-07-12 12:20:34 +02:00
while ( sptr ) {
{
2022-07-12 19:55:21 +02:00
const Map < StringName , CScript : : MemberInfo > : : Element * E = script - > member_indices . find ( p_name ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
if ( E - > get ( ) . getter ) {
Variant : : CallError err ;
2022-07-12 19:55:21 +02:00
r_ret = const_cast < CScriptInstance * > ( this ) - > call ( E - > get ( ) . getter , nullptr , 0 , err ) ;
2022-07-12 12:20:34 +02:00
if ( err . error = = Variant : : CallError : : CALL_OK ) {
return true ;
}
}
r_ret = members [ E - > get ( ) . index ] ;
return true ; //index found
}
}
{
2022-07-12 19:55:21 +02:00
const CScript * sl = sptr ;
2022-07-12 12:20:34 +02:00
while ( sl ) {
const Map < StringName , Variant > : : Element * E = sl - > constants . find ( p_name ) ;
if ( E ) {
r_ret = E - > get ( ) ;
return true ; //index found
}
sl = sl - > _base ;
}
}
{
2022-07-12 19:55:21 +02:00
const Map < StringName , CScriptFunction * > : : Element * E = sptr - > member_functions . find ( CScriptLanguage : : get_singleton ( ) - > strings . _get ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
Variant name = p_name ;
const Variant * args [ 1 ] = { & name } ;
Variant : : CallError err ;
2022-07-12 19:55:21 +02:00
Variant ret = const_cast < CScriptFunction * > ( E - > get ( ) ) - > call ( const_cast < CScriptInstance * > ( this ) , ( const Variant * * ) args , 1 , err ) ;
2022-07-12 12:20:34 +02:00
if ( err . error = = Variant : : CallError : : CALL_OK & & ret . get_type ( ) ! = Variant : : NIL ) {
r_ret = ret ;
return true ;
}
}
}
sptr = sptr - > _base ;
}
return false ;
}
2022-07-12 19:55:21 +02:00
Variant : : Type CScriptInstance : : get_property_type ( const StringName & p_name , bool * r_is_valid ) const {
const CScript * sptr = script . ptr ( ) ;
2022-07-12 12:20:34 +02:00
while ( sptr ) {
if ( sptr - > member_info . has ( p_name ) ) {
if ( r_is_valid ) {
* r_is_valid = true ;
}
return sptr - > member_info [ p_name ] . type ;
}
sptr = sptr - > _base ;
}
if ( r_is_valid ) {
* r_is_valid = false ;
}
return Variant : : NIL ;
}
2022-07-12 19:55:21 +02:00
void CScriptInstance : : get_property_list ( List < PropertyInfo > * p_properties ) const {
2022-07-12 12:20:34 +02:00
// exported members, not done yet!
2022-07-12 19:55:21 +02:00
const CScript * sptr = script . ptr ( ) ;
2022-07-12 12:20:34 +02:00
List < PropertyInfo > props ;
while ( sptr ) {
2022-07-12 19:55:21 +02:00
const Map < StringName , CScriptFunction * > : : Element * E = sptr - > member_functions . find ( CScriptLanguage : : get_singleton ( ) - > strings . _get_property_list ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
Variant : : CallError err ;
2022-07-12 19:55:21 +02:00
Variant ret = const_cast < CScriptFunction * > ( E - > get ( ) ) - > call ( const_cast < CScriptInstance * > ( this ) , nullptr , 0 , err ) ;
2022-07-12 12:20:34 +02:00
if ( err . error = = Variant : : CallError : : CALL_OK ) {
ERR_FAIL_COND_MSG ( ret . get_type ( ) ! = Variant : : ARRAY , " Wrong type for _get_property_list, must be an array of dictionaries. " ) ;
Array arr = ret ;
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 . name = d [ " name " ] ;
ERR_CONTINUE ( pinfo . name = = " " ) ;
if ( d . has ( " hint " ) ) {
pinfo . hint = PropertyHint ( d [ " hint " ] . operator int ( ) ) ;
}
if ( d . has ( " hint_string " ) ) {
pinfo . hint_string = d [ " hint_string " ] ;
}
if ( d . has ( " usage " ) ) {
pinfo . usage = d [ " usage " ] ;
}
props . push_back ( pinfo ) ;
}
}
}
//instance a fake script for editing the values
2022-07-12 19:55:21 +02:00
Vector < _CScriptMemberSort > msort ;
2022-07-12 12:20:34 +02:00
for ( Map < StringName , PropertyInfo > : : Element * F = sptr - > member_info . front ( ) ; F ; F = F - > next ( ) ) {
2022-07-12 19:55:21 +02:00
_CScriptMemberSort ms ;
2022-07-12 12:20:34 +02:00
ERR_CONTINUE ( ! sptr - > member_indices . has ( F - > key ( ) ) ) ;
ms . index = sptr - > member_indices [ F - > key ( ) ] . index ;
ms . name = F - > key ( ) ;
msort . push_back ( ms ) ;
}
msort . sort ( ) ;
msort . invert ( ) ;
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 ( ) ) {
p_properties - > push_back ( E - > get ( ) ) ;
}
}
2022-07-12 19:55:21 +02:00
void CScriptInstance : : get_method_list ( List < MethodInfo > * p_list ) const {
const CScript * sptr = script . ptr ( ) ;
2022-07-12 12:20:34 +02:00
while ( sptr ) {
2022-07-12 19:55:21 +02:00
for ( Map < StringName , CScriptFunction * > : : Element * E = sptr - > member_functions . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
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 ) ) ) ;
}
p_list - > push_back ( mi ) ;
}
sptr = sptr - > _base ;
}
}
2022-07-12 19:55:21 +02:00
bool CScriptInstance : : has_method ( const StringName & p_method ) const {
const CScript * sptr = script . ptr ( ) ;
2022-07-12 12:20:34 +02:00
while ( sptr ) {
2022-07-12 19:55:21 +02:00
const Map < StringName , CScriptFunction * > : : Element * E = sptr - > member_functions . find ( p_method ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
return true ;
}
sptr = sptr - > _base ;
}
return false ;
}
2022-07-12 19:55:21 +02:00
Variant CScriptInstance : : call ( const StringName & p_method , const Variant * * p_args , int p_argcount , Variant : : CallError & r_error ) {
CScript * sptr = script . ptr ( ) ;
2022-07-12 12:20:34 +02:00
while ( sptr ) {
2022-07-12 19:55:21 +02:00
Map < StringName , CScriptFunction * > : : Element * E = sptr - > member_functions . find ( p_method ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
return E - > get ( ) - > call ( this , p_args , p_argcount , r_error ) ;
}
sptr = sptr - > _base ;
}
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_METHOD ;
return Variant ( ) ;
}
2022-07-12 19:55:21 +02:00
void CScriptInstance : : call_multilevel ( const StringName & p_method , const Variant * * p_args , int p_argcount ) {
CScript * sptr = script . ptr ( ) ;
2022-07-12 12:20:34 +02:00
Variant : : CallError ce ;
while ( sptr ) {
2022-07-12 19:55:21 +02:00
Map < StringName , CScriptFunction * > : : Element * E = sptr - > member_functions . find ( p_method ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
E - > get ( ) - > call ( this , p_args , p_argcount , ce ) ;
}
sptr = sptr - > _base ;
}
}
2022-07-12 19:55:21 +02:00
void CScriptInstance : : _ml_call_reversed ( CScript * sptr , const StringName & p_method , const Variant * * p_args , int p_argcount ) {
2022-07-12 12:20:34 +02:00
if ( sptr - > _base ) {
_ml_call_reversed ( sptr - > _base , p_method , p_args , p_argcount ) ;
}
Variant : : CallError ce ;
2022-07-12 19:55:21 +02:00
Map < StringName , CScriptFunction * > : : Element * E = sptr - > member_functions . find ( p_method ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
E - > get ( ) - > call ( this , p_args , p_argcount , ce ) ;
}
}
2022-07-12 19:55:21 +02:00
void CScriptInstance : : call_multilevel_reversed ( const StringName & p_method , const Variant * * p_args , int p_argcount ) {
2022-07-12 12:20:34 +02:00
if ( script . ptr ( ) ) {
_ml_call_reversed ( script . ptr ( ) , p_method , p_args , p_argcount ) ;
}
}
2022-07-12 19:55:21 +02:00
void CScriptInstance : : notification ( int p_notification ) {
2022-07-12 12:20:34 +02:00
//notification is not virtual, it gets called at ALL levels just like in C.
Variant value = p_notification ;
const Variant * args [ 1 ] = { & value } ;
2022-07-12 19:55:21 +02:00
CScript * sptr = script . ptr ( ) ;
2022-07-12 12:20:34 +02:00
while ( sptr ) {
2022-07-12 19:55:21 +02:00
Map < StringName , CScriptFunction * > : : Element * E = sptr - > member_functions . find ( CScriptLanguage : : get_singleton ( ) - > strings . _notification ) ;
2022-07-12 12:20:34 +02:00
if ( E ) {
Variant : : CallError err ;
E - > get ( ) - > call ( this , args , 1 , err ) ;
if ( err . error ! = Variant : : CallError : : CALL_OK ) {
//print error about notification call
}
}
sptr = sptr - > _base ;
}
}
2022-07-12 19:55:21 +02:00
String CScriptInstance : : to_string ( bool * r_valid ) {
2022-07-12 12:20:34 +02:00
if ( has_method ( CoreStringNames : : get_singleton ( ) - > _to_string ) ) {
Variant : : CallError ce ;
Variant ret = call ( CoreStringNames : : get_singleton ( ) - > _to_string , nullptr , 0 , ce ) ;
if ( ce . error = = Variant : : CallError : : CALL_OK ) {
if ( ret . get_type ( ) ! = Variant : : STRING ) {
if ( r_valid ) {
* r_valid = false ;
}
ERR_FAIL_V_MSG ( String ( ) , " Wrong type for " + CoreStringNames : : get_singleton ( ) - > _to_string + " , must be a String. " ) ;
}
if ( r_valid ) {
* r_valid = true ;
}
return ret . operator String ( ) ;
}
}
if ( r_valid ) {
* r_valid = false ;
}
return String ( ) ;
}
2022-07-12 19:55:21 +02:00
Ref < Script > CScriptInstance : : get_script ( ) const {
2022-07-12 12:20:34 +02:00
return script ;
}
2022-07-12 19:55:21 +02:00
ScriptLanguage * CScriptInstance : : get_language ( ) {
return CScriptLanguage : : get_singleton ( ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
MultiplayerAPI : : RPCMode CScriptInstance : : get_rpc_mode ( const StringName & p_method ) const {
2022-07-13 00:07:10 +02:00
//note that methods set up using rpc_config should still work, even if they are declared in scripts.
2022-07-12 12:20:34 +02:00
return MultiplayerAPI : : RPC_MODE_DISABLED ;
}
2022-07-12 19:55:21 +02:00
MultiplayerAPI : : RPCMode CScriptInstance : : get_rset_mode ( const StringName & p_variable ) const {
2022-07-12 12:20:34 +02:00
return MultiplayerAPI : : RPC_MODE_DISABLED ;
}
2022-07-12 19:55:21 +02:00
void CScriptInstance : : reload_members ( ) {
2022-07-12 12:20:34 +02:00
# ifdef DEBUG_ENABLED
members . resize ( script - > member_indices . size ( ) ) ; //resize
Vector < Variant > new_members ;
new_members . resize ( script - > member_indices . size ( ) ) ;
//pass the values to the new indices
2022-07-12 19:55:21 +02:00
for ( Map < StringName , CScript : : MemberInfo > : : Element * E = script - > member_indices . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
if ( member_indices_cache . has ( E - > key ( ) ) ) {
Variant value = members [ member_indices_cache [ E - > key ( ) ] ] ;
new_members . write [ E - > get ( ) . index ] = value ;
}
}
//apply
members = new_members ;
//pass the values to the new indices
member_indices_cache . clear ( ) ;
2022-07-12 19:55:21 +02:00
for ( Map < StringName , CScript : : MemberInfo > : : Element * E = script - > member_indices . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
member_indices_cache [ E - > key ( ) ] = E - > get ( ) . index ;
}
# endif
}
2022-07-12 19:55:21 +02:00
CScriptInstance : : CScriptInstance ( ) {
2022-07-12 12:20:34 +02:00
owner = nullptr ;
base_ref = false ;
}
2022-07-12 19:55:21 +02:00
CScriptInstance : : ~ CScriptInstance ( ) {
CScriptLanguage : : singleton - > lock . lock ( ) ;
2022-07-12 12:20:34 +02:00
2022-07-12 19:55:21 +02:00
while ( SelfList < CScriptFunctionState > * E = pending_func_states . first ( ) ) {
2022-07-12 12:20:34 +02:00
// Order matters since clearing the stack may already cause
2022-07-12 19:55:21 +02:00
// the CSCriptFunctionState to be destroyed and thus removed from the list.
2022-07-12 12:20:34 +02:00
pending_func_states . remove ( E ) ;
E - > self ( ) - > _clear_stack ( ) ;
}
if ( script . is_valid ( ) & & owner ) {
script - > instances . erase ( owner ) ;
}
2022-07-12 19:55:21 +02:00
CScriptLanguage : : singleton - > lock . unlock ( ) ;
2022-07-12 12:20:34 +02:00
}
/************* SCRIPT LANGUAGE **************/
2022-07-12 19:55:21 +02:00
CScriptLanguage * CScriptLanguage : : singleton = nullptr ;
2022-07-12 12:20:34 +02:00
2022-07-12 19:55:21 +02:00
String CScriptLanguage : : get_name ( ) const {
return " CScript " ;
2022-07-12 12:20:34 +02:00
}
/* LANGUAGE FUNCTIONS */
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : _add_global ( const StringName & p_name , const Variant & p_value ) {
2022-07-12 12:20:34 +02:00
if ( globals . has ( p_name ) ) {
//overwrite existing
global_array . write [ globals [ p_name ] ] = p_value ;
return ;
}
globals [ p_name ] = global_array . size ( ) ;
global_array . push_back ( p_value ) ;
_global_array = global_array . ptrw ( ) ;
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : add_global_constant ( const StringName & p_variable , const Variant & p_value ) {
2022-07-12 12:20:34 +02:00
_add_global ( p_variable , p_value ) ;
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : add_named_global_constant ( const StringName & p_name , const Variant & p_value ) {
2022-07-12 12:20:34 +02:00
named_globals [ p_name ] = p_value ;
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : remove_named_global_constant ( const StringName & p_name ) {
2022-07-12 12:20:34 +02:00
ERR_FAIL_COND ( ! named_globals . has ( p_name ) ) ;
named_globals . erase ( p_name ) ;
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : init ( ) {
2022-07-12 12:20:34 +02:00
//populate global constants
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 ( " PI " ) , Math_PI ) ;
_add_global ( StaticCString : : create ( " TAU " ) , Math_TAU ) ;
_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 ( ) ) {
StringName n = E - > get ( ) ;
String s = String ( n ) ;
if ( s . begins_with ( " _ " ) ) {
n = s . substr ( 1 , s . length ( ) ) ;
}
if ( globals . has ( n ) ) {
continue ;
}
2022-07-12 19:55:21 +02:00
Ref < CScriptNativeClass > nc = memnew ( CScriptNativeClass ( E - > get ( ) ) ) ;
2022-07-12 12:20:34 +02:00
_add_global ( n , nc ) ;
}
//populate singletons
List < Engine : : Singleton > singletons ;
Engine : : get_singleton ( ) - > get_singletons ( & singletons ) ;
for ( List < Engine : : Singleton > : : Element * E = singletons . front ( ) ; E ; E = E - > next ( ) ) {
_add_global ( E - > get ( ) . name , E - > get ( ) . ptr ) ;
}
}
2022-07-12 19:55:21 +02:00
String CScriptLanguage : : get_type ( ) const {
return " CScript " ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
String CScriptLanguage : : get_extension ( ) const {
2022-07-12 21:38:17 +02:00
return " cpps " ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
Error CScriptLanguage : : execute_file ( const String & p_path ) {
2022-07-12 12:20:34 +02:00
// ??
return OK ;
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : finish ( ) {
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : profiling_start ( ) {
2022-07-12 12:20:34 +02:00
# ifdef DEBUG_ENABLED
lock . lock ( ) ;
2022-07-12 19:55:21 +02:00
SelfList < CScriptFunction > * elem = function_list . first ( ) ;
2022-07-12 12:20:34 +02:00
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 ;
lock . unlock ( ) ;
# endif
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : profiling_stop ( ) {
2022-07-12 12:20:34 +02:00
# ifdef DEBUG_ENABLED
lock . lock ( ) ;
profiling = false ;
lock . unlock ( ) ;
# endif
}
2022-07-12 19:55:21 +02:00
int CScriptLanguage : : profiling_get_accumulated_data ( ProfilingInfo * p_info_arr , int p_info_max ) {
2022-07-12 12:20:34 +02:00
int current = 0 ;
# ifdef DEBUG_ENABLED
lock . lock ( ) ;
2022-07-12 19:55:21 +02:00
SelfList < CScriptFunction > * elem = function_list . first ( ) ;
2022-07-12 12:20:34 +02:00
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 ( ) ;
current + + ;
}
lock . unlock ( ) ;
# endif
return current ;
}
2022-07-12 19:55:21 +02:00
int CScriptLanguage : : profiling_get_frame_data ( ProfilingInfo * p_info_arr , int p_info_max ) {
2022-07-12 12:20:34 +02:00
int current = 0 ;
# ifdef DEBUG_ENABLED
lock . lock ( ) ;
2022-07-12 19:55:21 +02:00
SelfList < CScriptFunction > * elem = function_list . first ( ) ;
2022-07-12 12:20:34 +02:00
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 ;
current + + ;
}
elem = elem - > next ( ) ;
}
lock . unlock ( ) ;
# endif
return current ;
}
2022-07-12 19:55:21 +02:00
struct CScriptDepSort {
2022-07-12 12:20:34 +02:00
//must support sorting so inheritance works properly (parent must be reloaded first)
2022-07-12 19:55:21 +02:00
bool operator ( ) ( const Ref < CScript > & A , const Ref < CScript > & B ) const {
2022-07-12 12:20:34 +02:00
if ( A = = B ) {
return false ; //shouldn't happen but..
}
2022-07-12 19:55:21 +02:00
const CScript * I = B - > get_base ( ) . ptr ( ) ;
2022-07-12 12:20:34 +02:00
while ( I ) {
if ( I = = A . ptr ( ) ) {
// A is a base of B
return true ;
}
I = I - > get_base ( ) . ptr ( ) ;
}
return false ; //not a base
}
} ;
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : reload_all_scripts ( ) {
2022-07-12 12:20:34 +02:00
# ifdef DEBUG_ENABLED
2022-07-12 19:55:21 +02:00
print_verbose ( " CScript: Reloading all scripts " ) ;
2022-07-12 12:20:34 +02:00
lock . lock ( ) ;
2022-07-12 19:55:21 +02:00
List < Ref < CScript > > scripts ;
2022-07-12 12:20:34 +02:00
2022-07-12 19:55:21 +02:00
SelfList < CScript > * elem = script_list . first ( ) ;
2022-07-12 12:20:34 +02:00
while ( elem ) {
if ( elem - > self ( ) - > get_path ( ) . is_resource_file ( ) ) {
2022-07-12 19:55:21 +02:00
print_verbose ( " CScript: Found: " + elem - > self ( ) - > get_path ( ) ) ;
scripts . push_back ( Ref < CScript > ( elem - > self ( ) ) ) ; //cast to gdscript to avoid being erased by accident
2022-07-12 12:20:34 +02:00
}
elem = elem - > next ( ) ;
}
lock . unlock ( ) ;
//as scripts are going to be reloaded, must proceed without locking here
2022-07-12 19:55:21 +02:00
scripts . sort_custom < CScriptDepSort > ( ) ; //update in inheritance dependency order
2022-07-12 12:20:34 +02:00
2022-07-12 19:55:21 +02:00
for ( List < Ref < CScript > > : : Element * E = scripts . front ( ) ; E ; E = E - > next ( ) ) {
print_verbose ( " CScript: Reloading: " + E - > get ( ) - > get_path ( ) ) ;
2022-07-12 12:20:34 +02:00
E - > get ( ) - > load_source_code ( E - > get ( ) - > get_path ( ) ) ;
E - > get ( ) - > reload ( true ) ;
}
# endif
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : reload_tool_script ( const Ref < Script > & p_script , bool p_soft_reload ) {
2022-07-12 12:20:34 +02:00
# ifdef DEBUG_ENABLED
lock . lock ( ) ;
2022-07-12 19:55:21 +02:00
List < Ref < CScript > > scripts ;
2022-07-12 12:20:34 +02:00
2022-07-12 19:55:21 +02:00
SelfList < CScript > * elem = script_list . first ( ) ;
2022-07-12 12:20:34 +02:00
while ( elem ) {
if ( elem - > self ( ) - > get_path ( ) . is_resource_file ( ) ) {
2022-07-12 19:55:21 +02:00
scripts . push_back ( Ref < CScript > ( elem - > self ( ) ) ) ; //cast to gdscript to avoid being erased by accident
2022-07-12 12:20:34 +02:00
}
elem = elem - > next ( ) ;
}
lock . unlock ( ) ;
//when someone asks you why dynamically typed languages are easier to write....
2022-07-12 19:55:21 +02:00
Map < Ref < CScript > , Map < ObjectID , List < Pair < StringName , Variant > > > > to_reload ;
2022-07-12 12:20:34 +02:00
//as scripts are going to be reloaded, must proceed without locking here
2022-07-12 19:55:21 +02:00
scripts . sort_custom < CScriptDepSort > ( ) ; //update in inheritance dependency order
2022-07-12 12:20:34 +02:00
2022-07-12 19:55:21 +02:00
for ( List < Ref < CScript > > : : Element * E = scripts . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
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 > > > ( ) ) ;
if ( ! p_soft_reload ) {
//save state and remove script from instances
Map < ObjectID , List < Pair < StringName , Variant > > > & map = to_reload [ E - > get ( ) ] ;
while ( E - > get ( ) - > instances . front ( ) ) {
Object * obj = E - > get ( ) - > instances . front ( ) - > get ( ) ;
//save instance info
List < Pair < StringName , Variant > > state ;
if ( obj - > get_script_instance ( ) ) {
obj - > get_script_instance ( ) - > get_property_state ( state ) ;
map [ obj - > get_instance_id ( ) ] = state ;
obj - > set_script ( RefPtr ( ) ) ;
}
}
//same thing for placeholders
# ifdef TOOLS_ENABLED
while ( E - > get ( ) - > placeholders . size ( ) ) {
Object * obj = E - > get ( ) - > placeholders . front ( ) - > get ( ) - > get_owner ( ) ;
//save instance info
if ( obj - > get_script_instance ( ) ) {
map . insert ( obj - > get_instance_id ( ) , List < Pair < StringName , Variant > > ( ) ) ;
List < Pair < StringName , Variant > > & state = map [ obj - > get_instance_id ( ) ] ;
obj - > get_script_instance ( ) - > get_property_state ( state ) ;
obj - > set_script ( RefPtr ( ) ) ;
} else {
// no instance found. Let's remove it so we don't loop forever
E - > get ( ) - > placeholders . erase ( E - > get ( ) - > placeholders . front ( ) - > get ( ) ) ;
}
}
# 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
}
}
}
2022-07-12 19:55:21 +02:00
for ( Map < Ref < CScript > , Map < ObjectID , List < Pair < StringName , Variant > > > > : : Element * E = to_reload . front ( ) ; E ; E = E - > next ( ) ) {
Ref < CScript > scr = E - > key ( ) ;
2022-07-12 12:20:34 +02:00
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 ( ) ) {
List < Pair < StringName , Variant > > & saved_state = F - > get ( ) ;
Object * obj = ObjectDB : : get_instance ( F - > key ( ) ) ;
if ( ! obj ) {
continue ;
}
if ( ! p_soft_reload ) {
//clear it just in case (may be a pending reload state)
obj - > set_script ( RefPtr ( ) ) ;
}
obj - > set_script ( scr . get_ref_ptr ( ) ) ;
ScriptInstance * script_instance = obj - > get_script_instance ( ) ;
if ( ! 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 ( ) ] = saved_state ;
}
continue ;
}
if ( script_instance - > is_placeholder ( ) & & scr - > is_placeholder_fallback_enabled ( ) ) {
PlaceHolderScriptInstance * placeholder = static_cast < PlaceHolderScriptInstance * > ( script_instance ) ;
for ( List < Pair < StringName , Variant > > : : Element * G = saved_state . front ( ) ; G ; G = G - > next ( ) ) {
placeholder - > property_set_fallback ( G - > get ( ) . first , G - > get ( ) . second ) ;
}
} else {
for ( List < Pair < StringName , Variant > > : : Element * G = saved_state . front ( ) ; G ; G = G - > next ( ) ) {
script_instance - > set ( G - > get ( ) . first , G - > get ( ) . second ) ;
}
}
scr - > pending_reload_state . erase ( obj - > get_instance_id ( ) ) ; //as it reloaded, remove pending state
}
//if instance states were saved, set them!
}
# endif
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : frame ( ) {
2022-07-12 12:20:34 +02:00
calls = 0 ;
# ifdef DEBUG_ENABLED
if ( profiling ) {
lock . lock ( ) ;
2022-07-12 19:55:21 +02:00
SelfList < CScriptFunction > * elem = function_list . first ( ) ;
2022-07-12 12:20:34 +02:00
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 ( ) ;
}
lock . unlock ( ) ;
}
# endif
}
/* EDITOR FUNCTIONS */
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : get_reserved_words ( List < String > * p_words ) const {
2022-07-12 12:20:34 +02:00
static const char * _reserved_words [ ] = {
// operators
" and " ,
" in " ,
" not " ,
" or " ,
// types and values
" false " ,
" float " ,
" int " ,
" bool " ,
" null " ,
" PI " ,
" TAU " ,
" INF " ,
" NAN " ,
" self " ,
" true " ,
" void " ,
// functions
" as " ,
" assert " ,
" breakpoint " ,
" class " ,
" class_name " ,
" extends " ,
" is " ,
" func " ,
" preload " ,
" setget " ,
" signal " ,
" tool " ,
" yield " ,
// var
" const " ,
" enum " ,
" export " ,
" onready " ,
" static " ,
" var " ,
// control flow
" break " ,
" continue " ,
" if " ,
" elif " ,
" else " ,
" for " ,
" pass " ,
" return " ,
" match " ,
" while " ,
nullptr
} ;
const char * * w = _reserved_words ;
while ( * w ) {
p_words - > push_back ( * w ) ;
w + + ;
}
2022-07-12 19:55:21 +02:00
for ( int i = 0 ; i < CScriptFunctions : : FUNC_MAX ; i + + ) {
p_words - > push_back ( CScriptFunctions : : get_func_name ( CScriptFunctions : : Function ( i ) ) ) ;
2022-07-12 12:20:34 +02:00
}
}
2022-07-12 19:55:21 +02:00
bool CScriptLanguage : : is_control_flow_keyword ( String p_keyword ) const {
2022-07-12 12:20:34 +02:00
return p_keyword = = " break " | |
p_keyword = = " continue " | |
p_keyword = = " elif " | |
p_keyword = = " else " | |
p_keyword = = " if " | |
p_keyword = = " for " | |
p_keyword = = " match " | |
p_keyword = = " pass " | |
p_keyword = = " return " | |
p_keyword = = " while " ;
}
2022-07-12 19:55:21 +02:00
bool CScriptLanguage : : handles_global_class_type ( const String & p_type ) const {
return p_type = = " CScript " ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
String CScriptLanguage : : get_global_class_name ( const String & p_path , String * r_base_type , String * r_icon_path ) const {
2022-07-12 12:20:34 +02:00
PoolVector < uint8_t > sourcef ;
Error err ;
FileAccessRef f = FileAccess : : open ( p_path , FileAccess : : READ , & err ) ;
if ( err ) {
return String ( ) ;
}
String source = f - > get_as_utf8_string ( ) ;
2022-07-12 19:55:21 +02:00
CScriptParser parser ;
2022-07-12 12:20:34 +02:00
parser . parse ( source , p_path . get_base_dir ( ) , true , p_path , false , nullptr , true ) ;
2022-07-12 19:55:21 +02:00
if ( parser . get_parse_tree ( ) & & parser . get_parse_tree ( ) - > type = = CScriptParser : : Node : : TYPE_CLASS ) {
const CScriptParser : : ClassNode * c = static_cast < const CScriptParser : : ClassNode * > ( parser . get_parse_tree ( ) ) ;
2022-07-12 12:20:34 +02:00
if ( r_icon_path ) {
if ( c - > icon_path . empty ( ) | | c - > icon_path . is_abs_path ( ) ) {
* r_icon_path = c - > icon_path ;
} else if ( c - > icon_path . is_rel_path ( ) ) {
* r_icon_path = p_path . get_base_dir ( ) . plus_file ( c - > icon_path ) . simplify_path ( ) ;
}
}
if ( r_base_type ) {
2022-07-12 19:55:21 +02:00
const CScriptParser : : ClassNode * subclass = c ;
2022-07-12 12:20:34 +02:00
String path = p_path ;
2022-07-12 19:55:21 +02:00
CScriptParser subparser ;
2022-07-12 12:20:34 +02:00
while ( subclass ) {
if ( subclass - > extends_used ) {
if ( subclass - > extends_file ) {
if ( subclass - > extends_class . size ( ) = = 0 ) {
get_global_class_name ( subclass - > extends_file , r_base_type ) ;
subclass = nullptr ;
break ;
} else {
Vector < StringName > extend_classes = subclass - > extends_class ;
FileAccessRef subfile = FileAccess : : open ( subclass - > extends_file , FileAccess : : READ ) ;
if ( ! subfile ) {
break ;
}
String subsource = subfile - > get_as_utf8_string ( ) ;
if ( subsource . empty ( ) ) {
break ;
}
String subpath = subclass - > extends_file ;
if ( subpath . is_rel_path ( ) ) {
subpath = path . get_base_dir ( ) . plus_file ( subpath ) . simplify_path ( ) ;
}
if ( OK ! = subparser . parse ( subsource , subpath . get_base_dir ( ) , true , subpath , false , nullptr , true ) ) {
break ;
}
path = subpath ;
2022-07-12 19:55:21 +02:00
if ( ! subparser . get_parse_tree ( ) | | subparser . get_parse_tree ( ) - > type ! = CScriptParser : : Node : : TYPE_CLASS ) {
2022-07-12 12:20:34 +02:00
break ;
}
2022-07-12 19:55:21 +02:00
subclass = static_cast < const CScriptParser : : ClassNode * > ( subparser . get_parse_tree ( ) ) ;
2022-07-12 12:20:34 +02:00
while ( extend_classes . size ( ) > 0 ) {
bool found = false ;
for ( int i = 0 ; i < subclass - > subclasses . size ( ) ; i + + ) {
2022-07-12 19:55:21 +02:00
const CScriptParser : : ClassNode * inner_class = subclass - > subclasses [ i ] ;
2022-07-12 12:20:34 +02:00
if ( inner_class - > name = = extend_classes [ 0 ] ) {
extend_classes . remove ( 0 ) ;
found = true ;
subclass = inner_class ;
break ;
}
}
if ( ! found ) {
subclass = nullptr ;
break ;
}
}
}
} else if ( subclass - > extends_class . size ( ) = = 1 ) {
* r_base_type = subclass - > extends_class [ 0 ] ;
subclass = nullptr ;
} else {
break ;
}
} else {
* r_base_type = " Reference " ;
subclass = nullptr ;
}
}
}
return c - > name ;
}
return String ( ) ;
}
# ifdef DEBUG_ENABLED
2022-07-12 19:55:21 +02:00
String CScriptWarning : : get_message ( ) const {
2022-07-12 12:20:34 +02:00
# define CHECK_SYMBOLS(m_amount) ERR_FAIL_COND_V(symbols.size() < m_amount, String());
switch ( code ) {
case UNASSIGNED_VARIABLE_OP_ASSIGN : {
CHECK_SYMBOLS ( 1 ) ;
return " Using assignment with operation but the variable ' " + symbols [ 0 ] + " ' was not previously assigned a value. " ;
} break ;
case UNASSIGNED_VARIABLE : {
CHECK_SYMBOLS ( 1 ) ;
return " The variable ' " + symbols [ 0 ] + " ' was used but never assigned a value. " ;
} break ;
case UNUSED_VARIABLE : {
CHECK_SYMBOLS ( 1 ) ;
return " The local variable ' " + symbols [ 0 ] + " ' is declared but never used in the block. If this is intended, prefix it with an underscore: '_ " + symbols [ 0 ] + " ' " ;
} break ;
case SHADOWED_VARIABLE : {
CHECK_SYMBOLS ( 2 ) ;
return " The local variable ' " + symbols [ 0 ] + " ' is shadowing an already-defined variable at line " + symbols [ 1 ] + " . " ;
} break ;
case UNUSED_CLASS_VARIABLE : {
CHECK_SYMBOLS ( 1 ) ;
return " The class variable ' " + symbols [ 0 ] + " ' is declared but never used in the script. " ;
} break ;
case UNUSED_ARGUMENT : {
CHECK_SYMBOLS ( 2 ) ;
return " The argument ' " + symbols [ 1 ] + " ' is never used in the function ' " + symbols [ 0 ] + " '. If this is intended, prefix it with an underscore: '_ " + symbols [ 1 ] + " ' " ;
} break ;
case UNREACHABLE_CODE : {
CHECK_SYMBOLS ( 1 ) ;
return " Unreachable code (statement after return) in function ' " + symbols [ 0 ] + " ()'. " ;
} break ;
case STANDALONE_EXPRESSION : {
return " Standalone expression (the line has no effect). " ;
} break ;
case VOID_ASSIGNMENT : {
CHECK_SYMBOLS ( 1 ) ;
return " Assignment operation, but the function ' " + symbols [ 0 ] + " ()' returns void. " ;
} break ;
case NARROWING_CONVERSION : {
return " Narrowing conversion (float is converted to int and loses precision). " ;
} break ;
case FUNCTION_MAY_YIELD : {
CHECK_SYMBOLS ( 1 ) ;
2022-07-12 19:55:21 +02:00
return " Assigned variable is typed but the function ' " + symbols [ 0 ] + " ()' may yield and return a CScriptFunctionState instead. " ;
2022-07-12 12:20:34 +02:00
} break ;
case VARIABLE_CONFLICTS_FUNCTION : {
CHECK_SYMBOLS ( 1 ) ;
return " Variable declaration of ' " + symbols [ 0 ] + " ' conflicts with a function of the same name. " ;
} break ;
case FUNCTION_CONFLICTS_VARIABLE : {
CHECK_SYMBOLS ( 1 ) ;
return " Function declaration of ' " + symbols [ 0 ] + " ()' conflicts with a variable of the same name. " ;
} break ;
case FUNCTION_CONFLICTS_CONSTANT : {
CHECK_SYMBOLS ( 1 ) ;
return " Function declaration of ' " + symbols [ 0 ] + " ()' conflicts with a constant of the same name. " ;
} break ;
case INCOMPATIBLE_TERNARY : {
return " Values of the ternary conditional are not mutually compatible. " ;
} break ;
case UNUSED_SIGNAL : {
CHECK_SYMBOLS ( 1 ) ;
return " The signal ' " + symbols [ 0 ] + " ' is declared but never emitted. " ;
} break ;
case RETURN_VALUE_DISCARDED : {
CHECK_SYMBOLS ( 1 ) ;
return " The function ' " + symbols [ 0 ] + " ()' returns a value, but this value is never used. " ;
} break ;
case PROPERTY_USED_AS_FUNCTION : {
CHECK_SYMBOLS ( 2 ) ;
return " The method ' " + symbols [ 0 ] + " ()' was not found in base ' " + symbols [ 1 ] + " ' but there's a property with the same name. Did you mean to access it? " ;
} break ;
case CONSTANT_USED_AS_FUNCTION : {
CHECK_SYMBOLS ( 2 ) ;
return " The method ' " + symbols [ 0 ] + " ()' was not found in base ' " + symbols [ 1 ] + " ' but there's a constant with the same name. Did you mean to access it? " ;
} break ;
case FUNCTION_USED_AS_PROPERTY : {
CHECK_SYMBOLS ( 2 ) ;
return " The property ' " + symbols [ 0 ] + " ' was not found in base ' " + symbols [ 1 ] + " ' but there's a method with the same name. Did you mean to call it? " ;
} break ;
case INTEGER_DIVISION : {
return " Integer division, decimal part will be discarded. " ;
} break ;
case UNSAFE_PROPERTY_ACCESS : {
CHECK_SYMBOLS ( 2 ) ;
return " The property ' " + symbols [ 0 ] + " ' is not present on the inferred type ' " + symbols [ 1 ] + " ' (but may be present on a subtype). " ;
} break ;
case UNSAFE_METHOD_ACCESS : {
CHECK_SYMBOLS ( 2 ) ;
return " The method ' " + symbols [ 0 ] + " ' is not present on the inferred type ' " + symbols [ 1 ] + " ' (but may be present on a subtype). " ;
} break ;
case UNSAFE_CAST : {
CHECK_SYMBOLS ( 1 ) ;
return " The value is cast to ' " + symbols [ 0 ] + " ' but has an unknown type. " ;
} break ;
case UNSAFE_CALL_ARGUMENT : {
CHECK_SYMBOLS ( 4 ) ;
return " The argument ' " + symbols [ 0 ] + " ' of the function ' " + symbols [ 1 ] + " ' requires a the subtype ' " + symbols [ 2 ] + " ' but the supertype ' " + symbols [ 3 ] + " ' was provided " ;
} break ;
case DEPRECATED_KEYWORD : {
CHECK_SYMBOLS ( 2 ) ;
return " The ' " + symbols [ 0 ] + " ' keyword is deprecated and will be removed in a future release, please replace its uses by ' " + symbols [ 1 ] + " '. " ;
} break ;
case STANDALONE_TERNARY : {
return " Standalone ternary conditional operator: the return value is being discarded. " ;
}
case EXPORT_HINT_TYPE_MISTMATCH : {
CHECK_SYMBOLS ( 2 ) ;
return vformat ( " The type of the default value (%s) doesn ' t match the type of the export hint ( % s ) . The type won ' t be coerced . " , symbols[0], symbols[1]) ;
}
case WARNING_MAX :
break ; // Can't happen, but silences warning
}
2022-07-12 19:55:21 +02:00
ERR_FAIL_V_MSG ( String ( ) , " Invalid CScript warning code: " + get_name_from_code ( code ) + " . " ) ;
2022-07-12 12:20:34 +02:00
# undef CHECK_SYMBOLS
}
2022-07-12 19:55:21 +02:00
String CScriptWarning : : get_name ( ) const {
2022-07-12 12:20:34 +02:00
return get_name_from_code ( code ) ;
}
2022-07-12 19:55:21 +02:00
String CScriptWarning : : get_name_from_code ( Code p_code ) {
2022-07-12 12:20:34 +02:00
ERR_FAIL_COND_V ( p_code < 0 | | p_code > = WARNING_MAX , String ( ) ) ;
static const char * names [ ] = {
" UNASSIGNED_VARIABLE " ,
" UNASSIGNED_VARIABLE_OP_ASSIGN " ,
" UNUSED_VARIABLE " ,
" SHADOWED_VARIABLE " ,
" UNUSED_CLASS_VARIABLE " ,
" UNUSED_ARGUMENT " ,
" UNREACHABLE_CODE " ,
" STANDALONE_EXPRESSION " ,
" VOID_ASSIGNMENT " ,
" NARROWING_CONVERSION " ,
" FUNCTION_MAY_YIELD " ,
" VARIABLE_CONFLICTS_FUNCTION " ,
" FUNCTION_CONFLICTS_VARIABLE " ,
" FUNCTION_CONFLICTS_CONSTANT " ,
" INCOMPATIBLE_TERNARY " ,
" UNUSED_SIGNAL " ,
" RETURN_VALUE_DISCARDED " ,
" PROPERTY_USED_AS_FUNCTION " ,
" CONSTANT_USED_AS_FUNCTION " ,
" FUNCTION_USED_AS_PROPERTY " ,
" INTEGER_DIVISION " ,
" UNSAFE_PROPERTY_ACCESS " ,
" UNSAFE_METHOD_ACCESS " ,
" UNSAFE_CAST " ,
" UNSAFE_CALL_ARGUMENT " ,
" DEPRECATED_KEYWORD " ,
" STANDALONE_TERNARY " ,
" EXPORT_HINT_TYPE_MISTMATCH " ,
nullptr
} ;
return names [ ( int ) p_code ] ;
}
2022-07-12 19:55:21 +02:00
CScriptWarning : : Code CScriptWarning : : get_code_from_name ( const String & p_name ) {
2022-07-12 12:20:34 +02:00
for ( int i = 0 ; i < WARNING_MAX ; i + + ) {
if ( get_name_from_code ( ( Code ) i ) = = p_name ) {
return ( Code ) i ;
}
}
2022-07-12 19:55:21 +02:00
ERR_FAIL_V_MSG ( WARNING_MAX , " Invalid CScript warning name: " + p_name ) ;
2022-07-12 12:20:34 +02:00
}
# endif // DEBUG_ENABLED
2022-07-12 19:55:21 +02:00
CScriptLanguage : : CScriptLanguage ( ) {
2022-07-12 12:20:34 +02:00
calls = 0 ;
ERR_FAIL_COND ( singleton ) ;
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 = " " ;
profiling = false ;
script_frame_time = 0 ;
_debug_call_stack_pos = 0 ;
2022-07-12 21:38:17 +02:00
int dmcs = GLOBAL_DEF ( " debug/settings/cscript/max_call_stack " , 1024 ) ;
ProjectSettings : : get_singleton ( ) - > set_custom_property_info ( " debug/settings/cscript/max_call_stack " , PropertyInfo ( Variant : : INT , " debug/settings/cscript/max_call_stack " , PROPERTY_HINT_RANGE , " 1024,4096,1,or_greater " ) ) ; //minimum is 1024
2022-07-12 12:20:34 +02:00
if ( ScriptDebugger : : get_singleton ( ) ) {
//debugging enabled!
_debug_max_call_stack = dmcs ;
_call_stack = memnew_arr ( CallLevel , _debug_max_call_stack + 1 ) ;
} else {
_debug_max_call_stack = 0 ;
_call_stack = nullptr ;
}
# ifdef DEBUG_ENABLED
2022-07-12 21:38:17 +02:00
GLOBAL_DEF ( " debug/cscript/warnings/enable " , true ) ;
GLOBAL_DEF ( " debug/cscript/warnings/treat_warnings_as_errors " , false ) ;
GLOBAL_DEF ( " debug/cscript/warnings/exclude_addons " , true ) ;
GLOBAL_DEF ( " debug/cscript/completion/autocomplete_setters_and_getters " , false ) ;
2022-07-12 19:55:21 +02:00
for ( int i = 0 ; i < ( int ) CScriptWarning : : WARNING_MAX ; i + + ) {
String warning = CScriptWarning : : get_name_from_code ( ( CScriptWarning : : Code ) i ) . to_lower ( ) ;
bool default_enabled = ! warning . begins_with ( " unsafe_ " ) & & i ! = CScriptWarning : : UNUSED_CLASS_VARIABLE ;
2022-07-12 21:38:17 +02:00
GLOBAL_DEF ( " debug/cscript/warnings/ " + warning , default_enabled ) ;
2022-07-12 12:20:34 +02:00
}
# endif // DEBUG_ENABLED
}
2022-07-12 19:55:21 +02:00
CScriptLanguage : : ~ CScriptLanguage ( ) {
2022-07-12 12:20:34 +02:00
if ( _call_stack ) {
memdelete_arr ( _call_stack ) ;
}
// Clear dependencies between scripts, to ensure cyclic references are broken (to avoid leaks at exit).
2022-07-12 19:55:21 +02:00
SelfList < CScript > * s = script_list . first ( ) ;
2022-07-12 12:20:34 +02:00
while ( s ) {
2022-07-12 19:55:21 +02:00
CScript * script = s - > self ( ) ;
2022-07-12 12:20:34 +02:00
// This ensures the current script is not released before we can check what's the next one
// in the list (we can't get the next upfront because we don't know if the reference breaking
// will cause it -or any other after it, for that matter- to be released so the next one
// is not the same as before).
script - > reference ( ) ;
2022-07-12 19:55:21 +02:00
for ( Map < StringName , CScriptFunction * > : : Element * E = script - > member_functions . front ( ) ; E ; E = E - > next ( ) ) {
CScriptFunction * func = E - > get ( ) ;
2022-07-12 12:20:34 +02:00
for ( int i = 0 ; i < func - > argument_types . size ( ) ; i + + ) {
func - > argument_types . write [ i ] . script_type_ref = Ref < Script > ( ) ;
}
func - > return_type . script_type_ref = Ref < Script > ( ) ;
}
2022-07-12 19:55:21 +02:00
for ( Map < StringName , CScript : : MemberInfo > : : Element * E = script - > member_indices . front ( ) ; E ; E = E - > next ( ) ) {
2022-07-12 12:20:34 +02:00
E - > get ( ) . data_type . script_type_ref = Ref < Script > ( ) ;
}
s = s - > next ( ) ;
script - > unreference ( ) ;
}
singleton = nullptr ;
}
2022-07-12 19:55:21 +02:00
void CScriptLanguage : : add_orphan_subclass ( const String & p_qualified_name , const ObjectID & p_subclass ) {
2022-07-12 12:20:34 +02:00
orphan_subclasses [ p_qualified_name ] = p_subclass ;
}
2022-07-12 19:55:21 +02:00
Ref < CScript > CScriptLanguage : : get_orphan_subclass ( const String & p_qualified_name ) {
2022-07-12 12:20:34 +02:00
Map < String , ObjectID > : : Element * orphan_subclass_element = orphan_subclasses . find ( p_qualified_name ) ;
if ( ! orphan_subclass_element ) {
2022-07-12 19:55:21 +02:00
return Ref < CScript > ( ) ;
2022-07-12 12:20:34 +02:00
}
ObjectID orphan_subclass = orphan_subclass_element - > get ( ) ;
Object * obj = ObjectDB : : get_instance ( orphan_subclass ) ;
orphan_subclasses . erase ( orphan_subclass_element ) ;
if ( ! obj ) {
2022-07-12 19:55:21 +02:00
return Ref < CScript > ( ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
return Ref < CScript > ( Object : : cast_to < CScript > ( obj ) ) ;
2022-07-12 12:20:34 +02:00
}
/*************** RESOURCE ***************/
2022-07-12 19:55:21 +02:00
RES ResourceFormatLoaderCScript : : load ( const String & p_path , const String & p_original_path , Error * r_error ) {
2022-07-12 12:20:34 +02:00
if ( r_error ) {
* r_error = ERR_FILE_CANT_OPEN ;
}
2022-07-12 19:55:21 +02:00
CScript * script = memnew ( CScript ) ;
2022-07-12 12:20:34 +02:00
2022-07-12 19:55:21 +02:00
Ref < CScript > scriptres ( script ) ;
2022-07-12 12:20:34 +02:00
2022-07-12 21:38:17 +02:00
if ( p_path . ends_with ( " .cppse " ) | | p_path . ends_with ( " .cppsc " ) ) {
2022-07-12 12:20:34 +02:00
script - > set_script_path ( p_original_path ) ; // script needs this.
script - > set_path ( p_original_path , true ) ;
Error err = script - > load_byte_code ( p_path ) ;
ERR_FAIL_COND_V_MSG ( err ! = OK , RES ( ) , " Cannot load byte code from file ' " + p_path + " '. " ) ;
} else {
Error err = script - > load_source_code ( p_path ) ;
ERR_FAIL_COND_V_MSG ( err ! = OK , RES ( ) , " Cannot load source code from file ' " + p_path + " '. " ) ;
script - > set_script_path ( p_original_path ) ; // script needs this.
script - > set_path ( p_original_path , true ) ;
script - > reload ( ) ;
}
if ( r_error ) {
* r_error = OK ;
}
return scriptres ;
}
2022-07-12 19:55:21 +02:00
void ResourceFormatLoaderCScript : : get_recognized_extensions ( List < String > * p_extensions ) const {
2022-07-12 21:38:17 +02:00
p_extensions - > push_back ( " cpps " ) ;
p_extensions - > push_back ( " cppsc " ) ;
p_extensions - > push_back ( " cppse " ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
bool ResourceFormatLoaderCScript : : handles_type ( const String & p_type ) const {
return ( p_type = = " Script " | | p_type = = " CScript " ) ;
2022-07-12 12:20:34 +02:00
}
2022-07-12 19:55:21 +02:00
String ResourceFormatLoaderCScript : : get_resource_type ( const String & p_path ) const {
2022-07-12 12:20:34 +02:00
String el = p_path . get_extension ( ) . to_lower ( ) ;
2022-07-12 21:38:17 +02:00
if ( el = = " cpps " | | el = = " cppsc " | | el = = " cppse " ) {
2022-07-12 19:55:21 +02:00
return " CScript " ;
2022-07-12 12:20:34 +02:00
}
return " " ;
}
2022-07-12 19:55:21 +02:00
void ResourceFormatLoaderCScript : : get_dependencies ( const String & p_path , List < String > * p_dependencies , bool p_add_types ) {
2022-07-12 12:20:34 +02:00
FileAccessRef file = FileAccess : : open ( p_path , FileAccess : : READ ) ;
ERR_FAIL_COND_MSG ( ! file , " Cannot open file ' " + p_path + " '. " ) ;
String source = file - > get_as_utf8_string ( ) ;
if ( source . empty ( ) ) {
return ;
}
2022-07-12 19:55:21 +02:00
CScriptParser parser ;
2022-07-12 12:20:34 +02:00
if ( OK ! = parser . parse ( source , p_path . get_base_dir ( ) , true , p_path , false , nullptr , true ) ) {
return ;
}
for ( const List < String > : : Element * E = parser . get_dependencies ( ) . front ( ) ; E ; E = E - > next ( ) ) {
p_dependencies - > push_back ( E - > get ( ) ) ;
}
}
2022-07-12 19:55:21 +02:00
Error ResourceFormatSaverCScript : : save ( const String & p_path , const RES & p_resource , uint32_t p_flags ) {
Ref < CScript > sqscr = p_resource ;
2022-07-12 12:20:34 +02:00
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 ) ;
2022-07-12 19:55:21 +02:00
ERR_FAIL_COND_V_MSG ( err , err , " Cannot save CScript file ' " + p_path + " '. " ) ;
2022-07-12 12:20:34 +02:00
file - > store_string ( source ) ;
if ( file - > get_error ( ) ! = OK & & file - > get_error ( ) ! = ERR_FILE_EOF ) {
memdelete ( file ) ;
return ERR_CANT_CREATE ;
}
file - > close ( ) ;
memdelete ( file ) ;
if ( ScriptServer : : is_reload_scripts_on_save_enabled ( ) ) {
2022-07-12 19:55:21 +02:00
CScriptLanguage : : get_singleton ( ) - > reload_tool_script ( p_resource , false ) ;
2022-07-12 12:20:34 +02:00
}
return OK ;
}
2022-07-12 19:55:21 +02:00
void ResourceFormatSaverCScript : : get_recognized_extensions ( const RES & p_resource , List < String > * p_extensions ) const {
if ( Object : : cast_to < CScript > ( * p_resource ) ) {
2022-07-12 21:38:17 +02:00
p_extensions - > push_back ( " cpps " ) ;
2022-07-12 12:20:34 +02:00
}
}
2022-07-12 19:55:21 +02:00
bool ResourceFormatSaverCScript : : recognize ( const RES & p_resource ) const {
return Object : : cast_to < CScript > ( * p_resource ) ! = nullptr ;
2022-07-12 12:20:34 +02:00
}