void CScriptEngine::register_script_classes()
{
#ifdef DBG_DISABLE_SCRIPTS
return;
#endif
string_path S;
FS.update_path(S, "$game_config$", "script.ltx");
CInifile *l_tpIniFile = xr_new<CInifile>(S);
R_ASSERT(l_tpIniFile);
if (!l_tpIniFile->section_exist("common"))
{
xr_delete(l_tpIniFile);
return;
}
m_class_registrators = READ_IF_EXISTS(l_tpIniFile, r_string, "common", "class_registrators", "");
xr_delete(l_tpIniFile);
u32 n = _GetItemCount(*m_class_registrators);
string256 I;
for (u32 i = 0; i < n; ++i)
{
_GetItem(*m_class_registrators, i, I);
luabind::functor<void> result;
if (!functor(I, result))
{
script_log(eLuaMessageTypeError, "Cannot load class registrator %s!", I);
continue;
}
result(const_cast<CObjectFactory*>(&object_factory()));
}
}
void CScriptEngine::init ()
{
CScriptStorage::reinit ();
luabind::open (lua());
setup_callbacks ();
export_classes (lua());
setup_auto_load ();
#ifdef DEBUG
m_stack_is_ready = true;
#endif
#ifdef DEBUG
# ifdef USE_DEBUGGER
if( !debugger() || !debugger()->Active() )
# endif
lua_sethook (lua(),lua_hook_call, LUA_MASKLINE|LUA_MASKCALL|LUA_MASKRET, 0);
#endif
bool save = m_reload_modules;
m_reload_modules = true;
process_file_if_exists ("_G",false);
m_reload_modules = save;
register_script_classes ();
object_factory().register_script ();
#ifdef XRGAME_EXPORTS
load_common_scripts ();
#endif
m_stack_level = lua_gettop(lua());
}
void CScriptEngine::init()
{
#ifdef USE_LUA_STUDIO
bool lua_studio_connected = !!m_lua_studio_world;
if (lua_studio_connected)
m_lua_studio_world->remove (lua());
#endif // #ifdef USE_LUA_STUDIO
CScriptStorage::reinit();
#ifdef USE_LUA_STUDIO
if (m_lua_studio_world || strstr(Core.Params, "-lua_studio")) {
if (!lua_studio_connected)
try_connect_to_debugger ();
else {
#ifdef USE_LUAJIT_ONE
jit_command (lua(), "debug=2");
jit_command (lua(), "off");
#else
luaJIT_setmode(lua(), 0, LUAJIT_MODE_ENGINE | LUAJIT_MODE_OFF);
#endif
m_lua_studio_world->add (lua());
}
}
#endif // #ifdef USE_LUA_STUDIO
luabind::open(lua());
setup_callbacks();
export_classes(lua());
setup_auto_load();
#ifdef DEBUG
m_stack_is_ready = true;
#endif
#ifndef USE_LUA_STUDIO
# ifdef DEBUG
# if defined(USE_DEBUGGER) && !defined(USE_LUA_STUDIO)
if( !debugger() || !debugger()->Active() )
# endif // #if defined(USE_DEBUGGER) && !defined(USE_LUA_STUDIO)
lua_sethook (lua(),lua_hook_call, LUA_MASKLINE|LUA_MASKCALL|LUA_MASKRET, 0);
# endif // #ifdef DEBUG
#endif // #ifndef USE_LUA_STUDIO
// lua_sethook (lua(), lua_hook_call, LUA_MASKLINE|LUA_MASKCALL|LUA_MASKRET, 0);
bool save = m_reload_modules;
m_reload_modules = true;
process_file_if_exists("_G", false);
m_reload_modules = save;
register_script_classes();
object_factory().register_script();
#ifdef XRGAME_EXPORTS
load_common_scripts();
#endif
m_stack_level = lua_gettop(lua());
}
DLL_API DLL_Pure* __cdecl xrFactory_Create (CLASS_ID clsid)
{
DLL_Pure *object = object_factory().client_object(clsid);
#ifdef DEBUG
if (!object)
return (0);
#endif
object->CLS_ID = clsid;
return (object);
}
int CScriptIniFile::r_clsid(LPCSTR S, LPCSTR L)
{
return (object_factory().script_clsid(inherited::r_clsid(S, L)));
}
////////////////////////////////////////////////////////////////////////////
// CSE_Abstract
////////////////////////////////////////////////////////////////////////////
CSE_Abstract::CSE_Abstract (LPCSTR caSection)
{
m_editor_flags.zero ();
RespawnTime = 0;
net_Ready = FALSE;
ID = 0xffff;
ID_Parent = 0xffff;
ID_Phantom = 0xffff;
owner = 0;
s_gameid = 0;
s_RP = 0xFE; // Use supplied coords
s_flags.assign (0);
s_name = caSection;
s_name_replace = 0; //xr_strdup("");
o_Angle.set (0.f,0.f,0.f);
o_Position.set (0.f,0.f,0.f);
m_bALifeControl = false;
m_wVersion = 0;
m_script_version = 0;
m_tClassID = TEXT2CLSID(pSettings->r_string(caSection,"class"));
// m_spawn_probability = 1.f;
m_spawn_flags.zero ();
m_spawn_flags.set (flSpawnEnabled ,TRUE);
m_spawn_flags.set (flSpawnOnSurgeOnly ,TRUE);
m_spawn_flags.set (flSpawnSingleItemOnly ,TRUE);
m_spawn_flags.set (flSpawnIfDestroyedOnly ,TRUE);
m_spawn_flags.set (flSpawnInfiniteCount ,TRUE);
// m_max_spawn_count = 1;
// m_spawn_control = "";
// m_spawn_count = 0;
// m_last_spawn_time = 0;
// m_next_spawn_time = 0;
// m_min_spawn_interval = 0;
// m_max_spawn_interval = 0;
m_ini_file = 0;
if (pSettings->line_exist(caSection,"custom_data")) {
string_path file_name;
FS.update_path (file_name,"$game_config$",pSettings->r_string(caSection,"custom_data"));
if (!FS.exist(file_name)) {
Msg ("! cannot open config file %s",file_name);
}
else {
IReader *reader = FS.r_open(file_name);
VERIFY (reader);
{
int size = reader->length()*sizeof(char);
LPSTR temp = (LPSTR)_alloca(size + 1);
CopyMemory (temp,reader->pointer(),size);
temp[size] = 0;
m_ini_string = temp;
}
FS.r_close (reader);
}
}
#ifndef AI_COMPILER
m_script_clsid = object_factory().script_clsid(m_tClassID);
#endif
client_data.clear ();
}
bool java_entry_point(
symbol_tablet &symbol_table,
const irep_idt &main_class,
message_handlert &message_handler)
{
// check if the entry point is already there
if(symbol_table.symbols.find(goto_functionst::entry_point())!=
symbol_table.symbols.end())
return false; // silently ignore
messaget message(message_handler);
symbolt symbol; // main function symbol
// find main symbol
if(config.main!="")
{
// Add java:: prefix
std::string main_identifier="java::"+config.main;
symbol_tablet::symbolst::const_iterator s_it;
// Does it have a type signature? (':' suffix)
if(config.main.rfind(':')==std::string::npos)
{
std::string prefix=main_identifier+':';
std::set<irep_idt> matches;
for(const auto & s : symbol_table.symbols)
if(has_prefix(id2string(s.first), prefix) &&
s.second.type.id()==ID_code)
matches.insert(s.first);
if(matches.empty())
{
message.error() << "main symbol `" << config.main
<< "' not found" << messaget::eom;
return true;
}
else if(matches.size()==1)
{
s_it=symbol_table.symbols.find(*matches.begin());
assert(s_it!=symbol_table.symbols.end());
}
else
{
message.error() << "main symbol `" << config.main
<< "' is ambiguous:\n";
for(const auto & s : matches)
message.error() << " " << s << '\n';
message.error() << messaget::eom;
return true;
}
}
else
{
// just look it up
s_it=symbol_table.symbols.find(main_identifier);
if(s_it==symbol_table.symbols.end())
{
message.error() << "main symbol `" << config.main
<< "' not found" << messaget::eom;
return true;
}
}
// function symbol
symbol=s_it->second;
if(symbol.type.id()!=ID_code)
{
message.error() << "main symbol `" << config.main
<< "' not a function" << messaget::eom;
return true;
}
// check if it has a body
if(symbol.value.is_nil())
{
message.error() << "main method `" << main_class
<< "' has no body" << messaget::eom;
return true;
}
}
else
{
// no function given, we look for the main class
assert(config.main=="");
// are we given a main class?
if(main_class.empty())
return false; // silently ignore
std::string entry_method=
id2string(main_class)+".main";
std::string prefix="java::"+entry_method+":";
// look it up
std::set<irep_idt> matches;
for(symbol_tablet::symbolst::const_iterator
s_it=symbol_table.symbols.begin();
s_it!=symbol_table.symbols.end();
s_it++)
{
if(s_it->second.type.id()==ID_code &&
has_prefix(id2string(s_it->first), prefix))
matches.insert(s_it->first);
}
if(matches.empty())
{
// Not found, silently ignore
return false;
}
if(matches.size()>=2)
{
message.error() << "main method in `" << main_class
<< "' is ambiguous" << messaget::eom;
return true; // give up with error, no main
}
// function symbol
symbol=symbol_table.symbols.find(*matches.begin())->second;
// check if it has a body
if(symbol.value.is_nil())
{
message.error() << "main method `" << main_class
<< "' has no body" << messaget::eom;
return true; // give up with error
}
}
assert(!symbol.value.is_nil());
assert(symbol.type.id()==ID_code);
const code_typet &code_type=to_code_type(symbol.type);
create_initialize(symbol_table);
if(java_static_lifetime_init(symbol_table, symbol.location, message_handler))
return true;
code_blockt init_code;
// build call to initialization function
{
symbol_tablet::symbolst::iterator init_it=
symbol_table.symbols.find(INITIALIZE);
if(init_it==symbol_table.symbols.end())
{
message.error() << "failed to find " INITIALIZE " symbol"
<< messaget::eom;
return true; // give up with error
}
code_function_callt call_init;
call_init.lhs().make_nil();
call_init.add_source_location()=symbol.location;
call_init.function()=init_it->second.symbol_expr();
init_code.move_to_operands(call_init);
}
// build call to the main method
code_function_callt call_main;
call_main.add_source_location()=symbol.location;
call_main.function()=symbol.symbol_expr();
const code_typet::parameterst ¶meters=
code_type.parameters();
exprt::operandst main_arguments;
main_arguments.resize(parameters.size());
for(std::size_t param_number=0;
param_number<parameters.size();
param_number++)
{
bool is_this=param_number==0 &&
parameters[param_number].get_this();
bool allow_null=config.main!="" && !is_this;
main_arguments[param_number]=
object_factory(parameters[param_number].type(),
init_code, allow_null, symbol_table);
}
call_main.arguments()=main_arguments;
init_code.move_to_operands(call_main);
// add "main"
symbolt new_symbol;
code_typet main_type;
main_type.return_type()=empty_typet();
new_symbol.name=goto_functionst::entry_point();
new_symbol.type.swap(main_type);
new_symbol.value.swap(init_code);
new_symbol.mode=ID_java;
if(symbol_table.move(new_symbol))
{
message.error() << "failed to move main symbol" << messaget::eom;
return true;
}
return false;
}
void CGameObject::reload (LPCSTR section)
{
m_script_clsid = object_factory().script_clsid(CLS_ID);
}
////////////////////////////////////////////////////////////////////////////
// CSE_Abstract
////////////////////////////////////////////////////////////////////////////
CSE_Abstract::CSE_Abstract (LPCSTR caSection)
{
m_editor_flags.zero ();
RespawnTime = 0;
net_Ready = FALSE;
ID = 0xffff;
ID_Parent = 0xffff;
ID_Phantom = 0xffff;
owner = 0;
m_gameType.SetDefaults ();
//. s_gameid = 0;
s_RP = 0xFE; // Use supplied coords
s_flags.assign (0);
s_name = caSection;
s_name_replace = 0; //xr_strdup("");
o_Angle.set (0.f,0.f,0.f);
o_Position.set (0.f,0.f,0.f);
m_bALifeControl = false;
m_wVersion = 0;
m_script_version = 0;
m_tClassID = TEXT2CLSID(pSettings->r_string(caSection,"class"));
// m_spawn_probability = 1.f;
m_spawn_flags.zero ();
m_spawn_flags.set (flSpawnEnabled ,TRUE);
m_spawn_flags.set (flSpawnOnSurgeOnly ,TRUE);
m_spawn_flags.set (flSpawnSingleItemOnly ,TRUE);
m_spawn_flags.set (flSpawnIfDestroyedOnly ,TRUE);
m_spawn_flags.set (flSpawnInfiniteCount ,TRUE);
// m_max_spawn_count = 1;
// m_spawn_control = "";
// m_spawn_count = 0;
// m_last_spawn_time = 0;
// m_next_spawn_time = 0;
// m_min_spawn_interval = 0;
// m_max_spawn_interval = 0;
m_ini_file = 0;
if (pSettings->line_exist(caSection,"custom_data")) {
pcstr const raw_file_name = pSettings->r_string(caSection,"custom_data");
IReader const* config = 0;
#ifdef XRGAME_EXPORTS
if ( ai().get_alife() )
config = ai().alife().get_config( raw_file_name );
else
#endif // #ifdef XRGAME_EXPORTS
{
string_path file_name;
FS.update_path (file_name,"$game_config$", raw_file_name);
if ( FS.exist(file_name) )
config = FS.r_open(file_name);
}
if ( config ) {
int size = config->length()*sizeof(char);
LPSTR temp = (LPSTR)_alloca(size + 1);
CopyMemory (temp,config->pointer(),size);
temp[size] = 0;
m_ini_string = temp;
#ifdef XRGAME_EXPORTS
if ( NULL==ai().get_alife() )
#endif // #ifdef XRGAME_EXPORTS
{
IReader* _r = (IReader*)config;
FS.r_close(_r);
}
}
else
Msg ( "! cannot open config file %s", raw_file_name );
}
#ifndef AI_COMPILER
m_script_clsid = object_factory().script_clsid(m_tClassID);
#endif
}
bool java_static_lifetime_init(
symbol_tablet &symbol_table,
const source_locationt &source_location,
message_handlert &message_handler,
bool assume_init_pointers_not_null,
unsigned max_nondet_array_length)
{
symbolt &initialize_symbol=symbol_table.lookup(INITIALIZE);
code_blockt &code_block=to_code_block(to_code(initialize_symbol.value));
// We need to zero out all static variables, or nondet-initialize if they're
// external. Iterate over a copy of the symtab, as its iterators are
// invalidated by object_factory:
std::list<irep_idt> symbol_names;
for(const auto &entry : symbol_table.symbols)
symbol_names.push_back(entry.first);
for(const auto &symname : symbol_names)
{
const symbolt &sym=symbol_table.lookup(symname);
if(should_init_symbol(sym))
{
if(sym.value.is_nil() && sym.type!=empty_typet())
{
bool allow_null=!assume_init_pointers_not_null;
if(allow_null)
{
std::string namestr=id2string(sym.symbol_expr().get_identifier());
const std::string suffix="@class_model";
// Static '.class' fields are always non-null.
if(has_suffix(namestr, suffix))
allow_null=false;
if(allow_null && has_prefix(
namestr,
"java::java.lang.String.Literal"))
allow_null=false;
}
auto newsym=object_factory(
sym.type,
code_block,
allow_null,
symbol_table,
max_nondet_array_length,
source_location,
message_handler);
code_assignt assignment(sym.symbol_expr(), newsym);
code_block.add(assignment);
}
else if(sym.value.is_not_nil())
{
code_assignt assignment(sym.symbol_expr(), sym.value);
assignment.add_source_location()=source_location;
code_block.add(assignment);
}
}
}
// we now need to run all the <clinit> methods
for(symbol_tablet::symbolst::const_iterator
it=symbol_table.symbols.begin();
it!=symbol_table.symbols.end();
it++)
{
if(it->second.base_name=="<clinit>" &&
it->second.type.id()==ID_code &&
it->second.mode==ID_java)
{
code_function_callt function_call;
function_call.lhs()=nil_exprt();
function_call.function()=it->second.symbol_expr();
function_call.add_source_location()=source_location;
code_block.add(function_call);
}
}
return false;
}
exprt::operandst java_build_arguments(
const symbolt &function,
code_blockt &init_code,
symbol_tablet &symbol_table,
bool assume_init_pointers_not_null,
unsigned max_nondet_array_length,
message_handlert &message_handler)
{
const code_typet::parameterst ¶meters=
to_code_type(function.type).parameters();
exprt::operandst main_arguments;
main_arguments.resize(parameters.size());
for(std::size_t param_number=0;
param_number<parameters.size();
param_number++)
{
bool is_this=(param_number==0) &&
parameters[param_number].get_this();
bool is_default_entry_point(config.main.empty());
bool is_main=is_default_entry_point;
if(!is_main)
{
bool named_main=has_suffix(config.main, ".main");
const typet &string_array_type=
java_type_from_string("[Ljava.lang.String;");
bool has_correct_type=
to_code_type(function.type).return_type().id()==ID_empty &&
(!to_code_type(function.type).has_this()) &&
parameters.size()==1 &&
parameters[0].type().full_eq(string_array_type);
is_main=(named_main && has_correct_type);
}
bool allow_null=(!is_main) && (!is_this) && !assume_init_pointers_not_null;
main_arguments[param_number]=
object_factory(
parameters[param_number].type(),
init_code,
allow_null,
symbol_table,
max_nondet_array_length,
function.location,
message_handler);
const symbolt &p_symbol=
symbol_table.lookup(parameters[param_number].get_identifier());
// record as an input
codet input(ID_input);
input.operands().resize(2);
input.op0()=
address_of_exprt(
index_exprt(
string_constantt(p_symbol.base_name),
from_integer(0, index_type())));
input.op1()=main_arguments[param_number];
input.add_source_location()=function.location;
init_code.move_to_operands(input);
}
return main_arguments;
}
CSE_Abstract *F_entity_Create (LPCSTR section)
{
return (object_factory().server_object(pSettings->r_clsid(section,"class"),section));
}
