Rim/gsc-tool
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 3 Wiki Activity
gsc-tool/src/gsc/context.cpp

661 lines
19 KiB
C++
Raw Blame History

// Copyright 2023 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
#include "stdinc.hpp"
#include "context.hpp"
namespace xsk::gsc
{
read_cb_type read_callback = nullptr;
std::unordered_map<std::string, buffer> header_files;
std::set<std::string_view> includes;
std::unordered_map<std::string, std::vector<std::string>> include_cache;
std::set<std::string> new_func_map;
std::set<std::string> new_meth_map;
context::context(gsc::props props, gsc::engine engine, gsc::endian endian, gsc::system system, u32 str_count)
: props_{ props }, engine_{ engine }, endian_{ endian }, system_{ system }, str_count_{ str_count },
source_{ this }, assembler_{ this }, disassembler_{ this }, compiler_{ this }, decompiler_{ this }
{
}
auto context::init(gsc::build build, read_cb_type callback) -> void
{
build_ = build;
read_callback = callback;
}
auto context::cleanup() -> void
{
header_files.clear();
include_cache.clear();
includes.clear();
}
auto context::opcode_size(opcode op) const -> u32
{
switch (op)
{
case opcode::OP_CastFieldObject:
case opcode::OP_plus:
case opcode::OP_GetGameRef:
case opcode::OP_GetThisthread:
case opcode::OP_greater:
case opcode::OP_shift_right:
case opcode::OP_dec:
case opcode::OP_bit_or:
case opcode::OP_equality:
case opcode::OP_ClearLocalVariableFieldCached0:
case opcode::OP_notify:
case opcode::OP_PreScriptCall:
case opcode::OP_GetUndefined:
case opcode::OP_SetLocalVariableFieldCached0:
case opcode::OP_GetLevel:
case opcode::OP_size:
case opcode::OP_AddArray:
case opcode::OP_endon:
case opcode::OP_shift_left:
case opcode::OP_EvalLocalArrayRefCached0:
case opcode::OP_Return:
case opcode::OP_SafeSetVariableFieldCached0:
case opcode::OP_GetSelfObject:
case opcode::OP_GetGame:
case opcode::OP_EvalArray:
case opcode::OP_GetSelf:
case opcode::OP_End:
case opcode::OP_less_equal:
case opcode::OP_EvalLocalVariableCached0:
case opcode::OP_EvalLocalVariableCached1:
case opcode::OP_EvalLocalVariableCached2:
case opcode::OP_EvalLocalVariableCached3:
case opcode::OP_EvalLocalVariableCached4:
case opcode::OP_EvalLocalVariableCached5:
case opcode::OP_ScriptMethodCallPointer:
case opcode::OP_checkclearparams:
case opcode::OP_waittillmatch2:
case opcode::OP_minus:
case opcode::OP_greater_equal:
case opcode::OP_vector:
case opcode::OP_ClearArray:
case opcode::OP_DecTop:
case opcode::OP_CastBool:
case opcode::OP_EvalArrayRef:
case opcode::OP_GetZero:
case opcode::OP_wait:
case opcode::OP_waittill:
case opcode::OP_GetAnimObject:
case opcode::OP_mod:
case opcode::OP_clearparams:
case opcode::OP_ScriptFunctionCallPointer:
case opcode::OP_EmptyArray:
case opcode::OP_BoolComplement:
case opcode::OP_less:
case opcode::OP_BoolNot:
case opcode::OP_waittillFrameEnd:
case opcode::OP_waitframe:
case opcode::OP_GetLevelObject:
case opcode::OP_inc:
case opcode::OP_GetAnim:
case opcode::OP_SetVariableField:
case opcode::OP_divide:
case opcode::OP_multiply:
case opcode::OP_EvalLocalVariableRefCached0:
case opcode::OP_bit_and:
case opcode::OP_voidCodepos:
case opcode::OP_inequality:
case opcode::OP_bit_ex_or:
case opcode::OP_BoolNotAfterAnd:
case opcode::OP_IsDefined:
case opcode::OP_IsTrue:
return 1;
case opcode::OP_SetLocalVariableFieldCached:
case opcode::OP_RemoveLocalVariables:
case opcode::OP_waittillmatch:
case opcode::OP_ScriptMethodChildThreadCallPointer:
case opcode::OP_GetByte:
case opcode::OP_SafeSetWaittillVariableFieldCached:
case opcode::OP_CallBuiltinMethodPointer:
case opcode::OP_EvalLocalVariableCached:
case opcode::OP_ScriptChildThreadCallPointer:
case opcode::OP_EvalLocalVariableObjectCached:
case opcode::OP_GetNegByte:
case opcode::OP_GetAnimTree:
case opcode::OP_EvalLocalArrayCached:
case opcode::OP_ScriptMethodThreadCallPointer:
case opcode::OP_SafeSetVariableFieldCached:
case opcode::OP_EvalLocalVariableRefCached:
case opcode::OP_ScriptThreadCallPointer:
case opcode::OP_ClearLocalVariableFieldCached:
case opcode::OP_EvalLocalArrayRefCached:
case opcode::OP_CallBuiltinPointer:
case opcode::OP_FormalParams:
return 2;
case opcode::OP_JumpOnTrue:
case opcode::OP_JumpOnFalseExpr:
case opcode::OP_jumpback:
case opcode::OP_JumpOnTrueExpr:
case opcode::OP_CallBuiltin0:
case opcode::OP_CallBuiltin1:
case opcode::OP_CallBuiltin2:
case opcode::OP_CallBuiltin3:
case opcode::OP_CallBuiltin4:
case opcode::OP_CallBuiltin5:
case opcode::OP_GetBuiltinFunction:
case opcode::OP_GetNegUnsignedShort:
case opcode::OP_GetBuiltinMethod:
case opcode::OP_endswitch:
case opcode::OP_GetUnsignedShort:
case opcode::OP_JumpOnFalse:
case opcode::OP_CallBuiltinMethod0:
case opcode::OP_CallBuiltinMethod1:
case opcode::OP_CallBuiltinMethod2:
case opcode::OP_CallBuiltinMethod3:
case opcode::OP_CallBuiltinMethod4:
case opcode::OP_CallBuiltinMethod5:
return 3;
case opcode::OP_CallBuiltin:
case opcode::OP_ScriptLocalMethodCall:
case opcode::OP_ScriptLocalFunctionCall2:
case opcode::OP_ScriptFarFunctionCall2:
case opcode::OP_CallBuiltinMethod:
case opcode::OP_GetLocalFunction:
case opcode::OP_ScriptLocalFunctionCall:
return 4;
case opcode::OP_ScriptLocalMethodThreadCall:
case opcode::OP_ScriptLocalChildThreadCall:
case opcode::OP_ScriptLocalThreadCall:
case opcode::OP_GetInteger:
case opcode::OP_ScriptLocalMethodChildThreadCall:
case opcode::OP_GetFloat:
case opcode::OP_switch:
case opcode::OP_jump:
case opcode::OP_GetUnkxHash:
case opcode::OP_GetUnsignedInt:
case opcode::OP_GetNegUnsignedInt:
return 5;
case opcode::OP_GetStatHash:
case opcode::OP_GetEnumHash:
case opcode::OP_GetDvarHash:
case opcode::OP_GetInteger64:
return 9;
case opcode::OP_GetFarFunction:
case opcode::OP_ScriptFarFunctionCall:
case opcode::OP_ScriptFarMethodCall:
return (props_ & props::farcall) ? 5 : 4;
case opcode::OP_ScriptFarThreadCall:
case opcode::OP_ScriptFarChildThreadCall:
case opcode::OP_ScriptFarMethodThreadCall:
case opcode::OP_ScriptFarMethodChildThreadCall:
return (props_ & props::farcall) ? 6 : 5;
case opcode::OP_CreateLocalVariable:
case opcode::OP_EvalNewLocalArrayRefCached0:
case opcode::OP_SafeCreateVariableFieldCached:
case opcode::OP_SetNewLocalVariableFieldCached0:
return (props_ & props::hash) ? 9 : 2;
case opcode::OP_EvalSelfFieldVariableRef:
case opcode::OP_EvalAnimFieldVariable:
case opcode::OP_EvalLevelFieldVariableRef:
case opcode::OP_SetSelfFieldVariableField:
case opcode::OP_ClearFieldVariable:
case opcode::OP_EvalFieldVariable:
case opcode::OP_SetAnimFieldVariableField:
case opcode::OP_SetLevelFieldVariableField:
case opcode::OP_EvalSelfFieldVariable:
case opcode::OP_EvalFieldVariableRef:
case opcode::OP_EvalLevelFieldVariable:
case opcode::OP_EvalAnimFieldVariableRef:
return (props_ & props::hash) ? 9 : (props_ & props::tok4) ? 5 : 3;
case opcode::OP_GetString:
case opcode::OP_GetIString:
return (props_ & props::str4) ? 5 : 3;
case opcode::OP_GetAnimation:
return (props_ & props::str4) ? 9 : 5;
case opcode::OP_GetVector:
return 13;
case opcode::OP_ClearVariableField:
case opcode::OP_EvalNewLocalVariableRefCached0:
case opcode::OP_NOP:
case opcode::OP_abort:
case opcode::OP_object:
case opcode::OP_thread_object:
case opcode::OP_EvalLocalVariable:
case opcode::OP_EvalLocalVariableRef:
case opcode::OP_breakpoint:
case opcode::OP_assignmentBreakpoint:
case opcode::OP_manualAndAssignmentBreakpoint:
case opcode::OP_prof_begin:
case opcode::OP_prof_end:
case opcode::OP_NativeGetLocalFunction:
case opcode::OP_NativeLocalFunctionCall:
case opcode::OP_NativeLocalFunctionCall2:
case opcode::OP_NativeLocalMethodCall:
case opcode::OP_NativeGetFarFunction:
case opcode::OP_NativeFarFunctionCall:
case opcode::OP_NativeFarFunctionCall2:
case opcode::OP_NativeFarMethodCall:
case opcode::OP_NativeLocalFunctionThreadCall:
case opcode::OP_NativeLocalMethodThreadCall:
case opcode::OP_NativeLocalFunctionChildThreadCall:
case opcode::OP_NativeLocalMethodChildThreadCall:
case opcode::OP_NativeFarFunctionThreadCall:
case opcode::OP_NativeFarMethodThreadCall:
case opcode::OP_NativeFarFunctionChildThreadCall:
case opcode::OP_NativeFarMethodChildThreadCall:
case opcode::OP_EvalNewLocalArrayRefCached0_Precompiled:
case opcode::OP_SetNewLocalVariableFieldCached0_Precompiled:
case opcode::OP_CreateLocalVariable_Precompiled:
case opcode::OP_SafeCreateVariableFieldCached_Precompiled:
case opcode::OP_FormalParams_Precompiled:
case opcode::OP_iw9_139:
case opcode::OP_iw9_140:
case opcode::OP_iw9_141:
case opcode::OP_iw9_142:
case opcode::OP_iw9_143:
case opcode::OP_iw9_144:
case opcode::OP_iw9_166:
default:
throw error(fmt::format("couldn't resolve instruction size for '{}'", opcode_name(op)));
}
}
auto context::opcode_id(opcode op) const -> u8
{
auto const itr = code_map_rev_.find(op);
if (itr != code_map_rev_.end())
{
return itr->second;
}
throw error(fmt::format("couldn't resolve opcode id for '{}'", opcode_name(op)));
}
auto context::opcode_enum(u8 id) const -> opcode
{
auto const itr = code_map_.find(id);
if (itr != code_map_.end())
{
return itr->second;
}
throw error(fmt::format("couldn't resolve opcode enum for '{:02X}'", id));
}
auto context::func_id(std::string const& name) const -> u16
{
if (name.starts_with("_func_"))
{
return static_cast<u16>(std::stoul(name.substr(6), nullptr, 16));
}
auto const itr = func_map_rev_.find(name);
if (itr != func_map_rev_.end())
{
return itr->second;
}
throw error(fmt::format("couldn't resolve builtin function id for {}", name));
}
auto context::func_name(u16 id) const -> std::string
{
auto const itr = func_map_.find(id);
if (itr != func_map_.end())
{
return std::string{ itr->second };
}
return fmt::format("_func_{:04X}", id);
}
auto context::func_exists(std::string const& name) const -> bool
{
if (name.starts_with("_func_")) return true;
auto const itr = func_map_rev_.find(name);
if (itr != func_map_rev_.end())
{
return true;
}
return false;
}
auto context::func_add(std::string const& name, u16 id) -> void
{
auto const itr = func_map_rev_.find(name);
if (itr != func_map_rev_.end())
{
throw error(fmt::format("builtin function '{}' already defined", name));
}
auto const str = new_func_map.find(name);
if (str != new_func_map.end())
{
func_map_.insert({ id, *str });
func_map_rev_.insert({ *str, id });
}
else
{
auto ins = new_func_map.insert(name);
if (ins.second)
{
func_map_.insert({ id, *ins.first });
func_map_rev_.insert({ *ins.first, id });
}
}
}
auto context::meth_id(std::string const& name) const -> u16
{
if (name.starts_with("_meth_"))
{
return static_cast<u16>(std::stoul(name.substr(6), nullptr, 16));
}
auto const itr = meth_map_rev_.find(name);
if (itr != meth_map_rev_.end())
{
return itr->second;
}
throw error(fmt::format("couldn't resolve builtin method id for {}", name));
}
auto context::meth_name(u16 id) const -> std::string
{
auto const itr = meth_map_.find(id);
if (itr != meth_map_.end())
{
return std::string{ itr->second };
}
return fmt::format("_meth_{:04X}", id);
}
auto context::meth_exists(std::string const& name) const -> bool
{
if (name.starts_with("_meth_")) return true;
auto const itr = meth_map_rev_.find(name);
if (itr != meth_map_rev_.end())
{
return true;
}
return false;
}
auto context::meth_add(std::string const& name, u16 id) -> void
{
auto const itr = meth_map_rev_.find(name);
if (itr != meth_map_rev_.end())
{
throw error(fmt::format("builtin method '{}' already defined", name));
}
auto const str = new_meth_map.find(name);
if (str != new_meth_map.end())
{
meth_map_.insert({ id, *str });
meth_map_rev_.insert({ *str, id });
}
else
{
auto ins = new_meth_map.insert(name);
if (ins.second)
{
meth_map_.insert({ id, *ins.first });
meth_map_rev_.insert({ *ins.first, id });
}
}
}
auto context::token_id(std::string const& name) const -> u32
{
if (name.starts_with("_id_"))
{
return static_cast<u32>(std::stoul(name.substr(4), nullptr, 16));
}
auto const itr = token_map_rev_.find(name);
if (itr != token_map_rev_.end())
{
return itr->second;
}
return 0;
}
auto context::token_name(u32 id) const -> std::string
{
auto const itr = token_map_.find(id);
if (itr != token_map_.end())
{
return std::string{ itr->second };
}
return fmt::format("_id_{:04X}", id);
}
auto context::path_id(std::string const& name) const -> u64
{
if (name.starts_with("_id_"))
{
return static_cast<u64>(std::stoull(name.substr(4), nullptr, 16));
}
char const* str = name.data();
u64 hash = 0x47F5817A5EF961BA;
while ( *str )
{
u8 byte = *str++;
if (byte == '\\')
{
byte = '/';
}
else if (static_cast<u8>(byte - 65) <= 25)
{
byte += 32;
}
hash = (u64)0x100000001B3 * ((u64)byte ^ hash);
}
return hash & 0x7FFFFFFFFFFFFFFF;
}
auto context::path_name(u64 id) const -> std::string
{
auto const itr = path_map_.find(id);
if (itr != path_map_.end())
{
return std::string{ itr->second };
}
return fmt::format("_id_{:016X}", id);
}
auto context::hash_id(std::string const& name) const -> u64
{
if (name.starts_with("_id_"))
{
return static_cast<u64>(std::stoull(name.substr(4), nullptr, 16));
}
char const* str = name.data();
u64 hash = 0x79D6530B0BB9B5D1;
while ( *str )
{
u8 byte = *str++;
if (static_cast<u8>(byte - 65) <= 25)
{
byte += 32;
}
hash = (u64)0x10000000233 * ((u64)byte ^ hash);
}
return hash;
}
auto context::hash_name(u64 id) const -> std::string
{
auto const itr = hash_map_.find(id);
if (itr != hash_map_.end())
{
return std::string{ itr->second };
}
return fmt::format("_id_{:016X}", id);
}
auto context::make_token(std::string_view str) const -> std::string
{
if (str.starts_with("_id_") || str.starts_with("_func_") || str.starts_with("_meth_"))
{
return std::string{ str };
}
auto data = std::string{ str.begin(), str.end() };
for (auto i = 0u; i < data.size(); i++)
{
data[i] = static_cast<char>(std::tolower(static_cast<unsigned char>(str[i])));
if (data[i] == '\\') data[i] = '/';
}
return data;
}
auto context::header_file_data(std::string const& name) const -> std::tuple<std::string const*, char const*, usize>
{
auto const itr = header_files.find(name);
if (itr != header_files.end())
{
return { &itr->first, reinterpret_cast<char const*>(itr->second.data), itr->second.size };
}
auto data = read_callback(name);
if (data.first.data != nullptr && data.first.size != 0 && data.second.data == nullptr && data.second.size == 0)
{
auto const res = header_files.insert({ name, data.first });
if (res.second)
{
return { &res.first->first, reinterpret_cast<char const*>(res.first->second.data), res.first->second.size };
}
}
throw error(fmt::format("couldn't open gsh file '{}'", name));
}
auto context::load_include(std::string const& name) -> bool
{
try
{
if (includes.contains(name))
{
return false;
}
includes.insert(name);
if (include_cache.contains(name))
return true;
auto file = read_callback(name);
if (file.first.data == nullptr && file.first.size == 0)
throw std::runtime_error("empty file");
if (file.second.data == nullptr && file.second.size == 0)
{
// process RawFile
auto prog = source_.parse_program(name, file.first);
auto funcs = std::vector<std::string>{};
for (auto const& dec : prog->declarations)
{
if (dec == node::decl_function)
{
funcs.push_back(dec.as_function->name->value);
}
}
include_cache.insert({ name, std::move(funcs) });
}
else
{
// process ScriptFile
auto data = disassembler_.disassemble(file.first, file.second);
auto funcs = std::vector<std::string>{};
for (auto const& fun : data->functions)
{
funcs.push_back(fun->name);
}
include_cache.insert({ name, std::move(funcs) });
}
return true;
}
catch (std::exception const& e)
{
throw error(fmt::format("parsing include file '{}': {}", name, e.what()));
}
}
auto context::init_includes() -> void
{
includes.clear();
}
auto context::is_includecall(std::string const& name, std::string& path) -> bool
{
for (auto const& inc : includes)
{
for (auto const& fun : include_cache.at(std::string{ inc }))
{
if (name == fun)
{
path = inc;
return true;
}
}
}
return false;
}
} // namespace xsk::gsc
Reference in New Issue View Git Blame Copy Permalink