mirror of
https://github.com/JezuzLizard/T4SP-Server-Plugin.git
synced 2025-04-19 21:22:54 +00:00
419 lines
11 KiB
C++
419 lines
11 KiB
C++
#include <stdinc.hpp>
|
|
#include "codsrc/clientscript/clientscript_public.hpp"
|
|
#include <dbghelp.h>
|
|
|
|
namespace game
|
|
{
|
|
#define QUICK_TO_JSON_FIELD(j, v, membername) j[#membername] = v.membername
|
|
|
|
#define QUICK_TO_JSON_FIELD_SAFE_CSTR(j, v, membername) \
|
|
if (v.membername) \
|
|
j[#membername] = v.membername; \
|
|
else \
|
|
j[#membername] = "(NULL)"
|
|
|
|
#define QUICK_TO_JSON_FIELD_PTR_ADDR(j, v, membername) j[#membername] = reinterpret_cast<size_t>(&v.membername)
|
|
|
|
#define QUICK_TO_JSON_FIELD_ARRAY(j, v, membername) \
|
|
for (auto i = 0; i < ARRAY_COUNT(v.membername); i++) \
|
|
{ \
|
|
j[#membername][i] = v.membername[i]; \
|
|
}
|
|
|
|
#define QUICK_TO_JSON_FIELD_SL_STRING(j, v, membername) j[#membername "Str"] = SL_ConvertToStringSafe(v.membername, *gInst)
|
|
|
|
void to_json(nlohmann::json& j, const scrVarPub_t& v)
|
|
{
|
|
QUICK_TO_JSON_FIELD_SAFE_CSTR(j, v, fieldBuffer);
|
|
QUICK_TO_JSON_FIELD(j, v, canonicalStrCount);
|
|
QUICK_TO_JSON_FIELD(j, v, developer);
|
|
QUICK_TO_JSON_FIELD(j, v, developer_script);
|
|
QUICK_TO_JSON_FIELD(j, v, evaluate);
|
|
QUICK_TO_JSON_FIELD_SAFE_CSTR(j, v, error_message);
|
|
QUICK_TO_JSON_FIELD(j, v, error_index);
|
|
QUICK_TO_JSON_FIELD(j, v, time);
|
|
QUICK_TO_JSON_FIELD(j, v, timeArrayId);
|
|
QUICK_TO_JSON_FIELD(j, v, pauseArrayId);
|
|
QUICK_TO_JSON_FIELD(j, v, levelId);
|
|
QUICK_TO_JSON_FIELD(j, v, gameId);
|
|
QUICK_TO_JSON_FIELD(j, v, animId);
|
|
QUICK_TO_JSON_FIELD(j, v, freeEntList);
|
|
QUICK_TO_JSON_FIELD(j, v, tempVariable);
|
|
QUICK_TO_JSON_FIELD(j, v, bInited);
|
|
QUICK_TO_JSON_FIELD(j, v, savecount);
|
|
QUICK_TO_JSON_FIELD(j, v, checksum);
|
|
QUICK_TO_JSON_FIELD(j, v, entId);
|
|
QUICK_TO_JSON_FIELD(j, v, entFieldName);
|
|
QUICK_TO_JSON_FIELD_SL_STRING(j, v, entFieldName);
|
|
QUICK_TO_JSON_FIELD_PTR_ADDR(j, v, programHunkUser);
|
|
QUICK_TO_JSON_FIELD_PTR_ADDR(j, v, programBuffer);
|
|
QUICK_TO_JSON_FIELD_PTR_ADDR(j, v, endScriptBuffer);
|
|
QUICK_TO_JSON_FIELD_ARRAY(j, v, saveIdMap);
|
|
QUICK_TO_JSON_FIELD_ARRAY(j, v, saveIdMapRev);
|
|
}
|
|
}
|
|
|
|
// https://stackoverflow.com/questions/5693192/win32-backtrace-from-c-code
|
|
std::string build_code_stack()
|
|
{
|
|
unsigned int i;
|
|
void * stack[ 100 ];
|
|
unsigned short frames;
|
|
SYMBOL_INFO * symbol;
|
|
HANDLE process;
|
|
std::string answer{};
|
|
|
|
process = GetCurrentProcess();
|
|
|
|
SymInitialize( process, NULL, TRUE );
|
|
|
|
frames = CaptureStackBackTrace( 0, 100, stack, NULL );
|
|
symbol = ( SYMBOL_INFO * )calloc( sizeof( SYMBOL_INFO ) + 256 * sizeof( char ), 1 );
|
|
symbol->MaxNameLen = 255;
|
|
symbol->SizeOfStruct = sizeof( SYMBOL_INFO );
|
|
|
|
for( i = 0; i < frames; i++ )
|
|
{
|
|
SymFromAddr( process, ( DWORD64 )( stack[ i ] ), 0, symbol );
|
|
|
|
answer += std::format("{}: {} - 0x{:06x}\n", frames - i - 1, symbol->Name, symbol->Address);
|
|
}
|
|
|
|
free( symbol );
|
|
|
|
return answer;
|
|
}
|
|
|
|
int op_idx[game::SCRIPT_INSTANCE_MAX] = { 0, 0 };
|
|
bool op_idx_rolled_over[game::SCRIPT_INSTANCE_MAX] = { false, false };
|
|
game::OpcodeVM op_history[game::SCRIPT_INSTANCE_MAX][128] = {};
|
|
|
|
int builtin_idx[game::SCRIPT_INSTANCE_MAX] = { 0, 0 };
|
|
bool builtin_idx_rolled_over[game::SCRIPT_INSTANCE_MAX] = { false, false };
|
|
int builtin_history[game::SCRIPT_INSTANCE_MAX][128] = {};
|
|
|
|
int codepos_idx[game::SCRIPT_INSTANCE_MAX] = { 0, 0 };
|
|
bool codepos_idx_rolled_over[game::SCRIPT_INSTANCE_MAX] = { false, false };
|
|
const char* codepos_history[game::SCRIPT_INSTANCE_MAX][128] = {};
|
|
|
|
std::string build_builtin_history(game::scriptInstance_t inst)
|
|
{
|
|
std::string answer{};
|
|
|
|
int count = builtin_idx_rolled_over[inst] ? ARRAY_COUNT(builtin_history[inst]) : builtin_idx[inst];
|
|
|
|
for (auto i = 0; i < count; i++)
|
|
{
|
|
auto idx = builtin_idx[inst] - 1 - i;
|
|
if (idx < 0)
|
|
{
|
|
idx += ARRAY_COUNT(builtin_history[inst]);
|
|
}
|
|
|
|
// todo, convert to builtin name
|
|
answer += std::format("{}\n", builtin_history[inst][idx]);
|
|
}
|
|
|
|
return answer;
|
|
}
|
|
|
|
std::string build_codepos_history(game::scriptInstance_t inst)
|
|
{
|
|
std::string answer{};
|
|
int bufferIndex;
|
|
int prevSourcePos;
|
|
int col;
|
|
char line[1024];
|
|
int lineNum;
|
|
const char* fileName;
|
|
|
|
int count = codepos_idx_rolled_over[inst] ? ARRAY_COUNT(codepos_history[inst]) : codepos_idx[inst];
|
|
|
|
for (auto i = 0; i < count; i++)
|
|
{
|
|
auto idx = codepos_idx[inst] - 1 - i;
|
|
if (idx < 0)
|
|
{
|
|
idx += ARRAY_COUNT(codepos_history[inst]);
|
|
}
|
|
|
|
bufferIndex = game::Scr_GetSourceBuffer(inst, codepos_history[inst][idx]);
|
|
prevSourcePos = game::Scr_GetPrevSourcePos(inst, codepos_history[inst][idx], 0);
|
|
lineNum = game::Scr_GetLineInfo(&col, game::gScrParserPub[inst].sourceBufferLookup[bufferIndex].sourceBuf, prevSourcePos, line);
|
|
fileName = game::gScrParserPub[inst].sourceBufferLookup[bufferIndex].buf;
|
|
|
|
answer += std::format("{}({}, {}): '{}'\n", fileName, lineNum, col, line);
|
|
}
|
|
|
|
return answer;
|
|
}
|
|
|
|
std::string build_op_history(game::scriptInstance_t inst)
|
|
{
|
|
static const char* OpcodeVMToString[] = {
|
|
"OP_End",
|
|
"OP_Return",
|
|
"OP_GetUndefined",
|
|
"OP_GetZero",
|
|
"OP_GetByte",
|
|
"OP_GetNegByte",
|
|
"OP_GetUnsignedShort",
|
|
"OP_GetNegUnsignedShort",
|
|
"OP_GetInteger",
|
|
"OP_GetFloat",
|
|
"OP_GetString",
|
|
"OP_GetIString",
|
|
"OP_GetVector",
|
|
"OP_GetLevelObject",
|
|
"OP_GetAnimObject",
|
|
"OP_GetSelf",
|
|
"OP_GetLevel",
|
|
"OP_GetGame",
|
|
"OP_GetAnim",
|
|
"OP_GetAnimation",
|
|
"OP_GetGameRef",
|
|
"OP_GetFunction",
|
|
"OP_CreateLocalVariable",
|
|
"OP_RemoveLocalVariables",
|
|
"OP_EvalLocalVariableCached0",
|
|
"OP_EvalLocalVariableCached1",
|
|
"OP_EvalLocalVariableCached2",
|
|
"OP_EvalLocalVariableCached3",
|
|
"OP_EvalLocalVariableCached4",
|
|
"OP_EvalLocalVariableCached5",
|
|
"OP_EvalLocalVariableCached",
|
|
"OP_EvalLocalArrayCached",
|
|
"OP_EvalArray",
|
|
"OP_EvalLocalArrayRefCached0",
|
|
"OP_EvalLocalArrayRefCached",
|
|
"OP_EvalArrayRef",
|
|
"OP_ClearArray",
|
|
"OP_EmptyArray",
|
|
"OP_GetSelfObject",
|
|
"OP_EvalLevelFieldVariable",
|
|
"OP_EvalAnimFieldVariable",
|
|
"OP_EvalSelfFieldVariable",
|
|
"OP_EvalFieldVariable",
|
|
"OP_EvalLevelFieldVariableRef",
|
|
"OP_EvalAnimFieldVariableRef",
|
|
"OP_EvalSelfFieldVariableRef",
|
|
"OP_EvalFieldVariableRef",
|
|
"OP_ClearFieldVariable",
|
|
"OP_SafeCreateVariableFieldCached",
|
|
"OP_SafeSetVariableFieldCached0",
|
|
"OP_SafeSetVariableFieldCached",
|
|
"OP_SafeSetWaittillVariableFieldCached",
|
|
"OP_clearparams",
|
|
"OP_checkclearparams",
|
|
"OP_EvalLocalVariableRefCached0",
|
|
"OP_EvalLocalVariableRefCached",
|
|
"OP_SetLevelFieldVariableField",
|
|
"OP_SetVariableField",
|
|
"OP_SetAnimFieldVariableField",
|
|
"OP_SetSelfFieldVariableField",
|
|
"OP_SetLocalVariableFieldCached0",
|
|
"OP_SetLocalVariableFieldCached",
|
|
"OP_CallBuiltin0",
|
|
"OP_CallBuiltin1",
|
|
"OP_CallBuiltin2",
|
|
"OP_CallBuiltin3",
|
|
"OP_CallBuiltin4",
|
|
"OP_CallBuiltin5",
|
|
"OP_CallBuiltin",
|
|
"OP_CallBuiltinMethod0",
|
|
"OP_CallBuiltinMethod1",
|
|
"OP_CallBuiltinMethod2",
|
|
"OP_CallBuiltinMethod3",
|
|
"OP_CallBuiltinMethod4",
|
|
"OP_CallBuiltinMethod5",
|
|
"OP_CallBuiltinMethod",
|
|
"OP_wait",
|
|
"OP_waittillFrameEnd",
|
|
"OP_PreScriptCall",
|
|
"OP_ScriptFunctionCall2",
|
|
"OP_ScriptFunctionCall",
|
|
"OP_ScriptFunctionCallPointer",
|
|
"OP_ScriptMethodCall",
|
|
"OP_ScriptMethodCallPointer",
|
|
"OP_ScriptThreadCall",
|
|
"OP_ScriptThreadCallPointer",
|
|
"OP_ScriptMethodThreadCall",
|
|
"OP_ScriptMethodThreadCallPointer",
|
|
"OP_DecTop",
|
|
"OP_CastFieldObject",
|
|
"OP_EvalLocalVariableObjectCached",
|
|
"OP_CastBool",
|
|
"OP_BoolNot",
|
|
"OP_BoolComplement",
|
|
"OP_JumpOnFalse",
|
|
"OP_JumpOnTrue",
|
|
"OP_JumpOnFalseExpr",
|
|
"OP_JumpOnTrueExpr",
|
|
"OP_jump",
|
|
"OP_jumpback",
|
|
"OP_inc",
|
|
"OP_dec",
|
|
"OP_bit_or",
|
|
"OP_bit_ex_or",
|
|
"OP_bit_and",
|
|
"OP_equality",
|
|
"OP_inequality",
|
|
"OP_less",
|
|
"OP_greater",
|
|
"OP_less_equal",
|
|
"OP_greater_equal",
|
|
"OP_shift_left",
|
|
"OP_shift_right",
|
|
"OP_plus",
|
|
"OP_minus",
|
|
"OP_multiply",
|
|
"OP_divide",
|
|
"OP_mod",
|
|
"OP_size",
|
|
"OP_waittillmatch",
|
|
"OP_waittill",
|
|
"OP_notify",
|
|
"OP_endon",
|
|
"OP_voidCodepos",
|
|
"OP_switch",
|
|
"OP_endswitch",
|
|
"OP_vector",
|
|
"OP_NOP",
|
|
"OP_abort",
|
|
"OP_object",
|
|
"OP_thread_object",
|
|
"OP_EvalLocalVariable",
|
|
"OP_EvalLocalVariableRef",
|
|
"OP_prof_begin",
|
|
"OP_prof_end",
|
|
"OP_breakpoint",
|
|
"OP_assignmentBreakpoint",
|
|
"OP_manualAndAssignmentBreakpoint",
|
|
"OP_count"
|
|
};
|
|
|
|
std::string answer{};
|
|
|
|
int count = op_idx_rolled_over[inst] ? ARRAY_COUNT(op_history[inst]) : op_idx[inst];
|
|
|
|
for (auto i = 0; i < count; i++)
|
|
{
|
|
auto idx = op_idx[inst] - 1 - i;
|
|
if (idx < 0)
|
|
{
|
|
idx += ARRAY_COUNT(op_history[inst]);
|
|
}
|
|
|
|
if ((int)op_history[inst][idx] >= 0 && op_history[inst][idx] < game::OP_count)
|
|
{
|
|
answer += std::format("{}\n", OpcodeVMToString[op_history[inst][idx]]);
|
|
}
|
|
else
|
|
{
|
|
answer += std::format("0x{:02x}\n", (int)op_history[inst][idx]);
|
|
}
|
|
}
|
|
|
|
return answer;
|
|
}
|
|
|
|
std::string build_gsc_stack(game::scriptInstance_t inst)
|
|
{
|
|
std::string answer{};
|
|
|
|
int bufferIndex;
|
|
int prevSourcePos;
|
|
int col;
|
|
char line[1024];
|
|
int lineNum;
|
|
const char* fileName;
|
|
|
|
if (!game::gFs[inst].pos || !game::Scr_IsInOpcodeMemory(inst, game::gFs[inst].pos))
|
|
{
|
|
return answer;
|
|
}
|
|
|
|
for (auto frame = game::gScrVmPub[inst].function_frame_start;; frame++)
|
|
{
|
|
if (!frame->fs.pos || !game::Scr_IsInOpcodeMemory(inst, frame->fs.pos))
|
|
{
|
|
break;
|
|
}
|
|
|
|
bufferIndex = game::Scr_GetSourceBuffer(inst, frame->fs.pos - 1);
|
|
prevSourcePos = game::Scr_GetPrevSourcePos(inst, frame->fs.pos - 1, 0);
|
|
lineNum = game::Scr_GetLineInfo(&col, game::gScrParserPub[inst].sourceBufferLookup[bufferIndex].sourceBuf, prevSourcePos, line);
|
|
fileName = game::gScrParserPub[inst].sourceBufferLookup[bufferIndex].buf;
|
|
|
|
answer += std::format("{}({}, {}): '{}'\n", fileName, lineNum, col, line);
|
|
|
|
if (frame == game::gScrVmPub[inst].function_frame)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return answer;
|
|
}
|
|
|
|
std::string build_gsc_dump(game::scriptInstance_t inst)
|
|
{
|
|
nlohmann::json answer{};
|
|
auto t = *game::gInst;
|
|
*game::gInst = inst;
|
|
|
|
answer["inst"] = inst;
|
|
answer["gScrVarPub"] = game::gScrVarPub[inst];
|
|
answer["codeCallStack"] = build_code_stack();
|
|
answer["gscCallStack"] = build_gsc_stack(inst);
|
|
answer["opHistory"] = build_op_history(inst);
|
|
answer["builtinHistory"] = build_builtin_history(inst);
|
|
answer["codeposHistory"] = build_codepos_history(inst);
|
|
|
|
*game::gInst = t;
|
|
|
|
return answer.dump(2);
|
|
}
|
|
|
|
void push_opcode_history(game::scriptInstance_t inst, game::OpcodeVM op)
|
|
{
|
|
assert(inst == 0 || inst == 1);
|
|
//assert((int)op >= 0 && op < game::OP_count);
|
|
|
|
op_history[inst][op_idx[inst]++] = op;
|
|
|
|
if (op_idx[inst] >= ARRAY_COUNT(op_history[inst]))
|
|
{
|
|
op_idx_rolled_over[inst] = true;
|
|
op_idx[inst] = 0;
|
|
}
|
|
}
|
|
|
|
void push_builtin_history(game::scriptInstance_t inst, int idx)
|
|
{
|
|
assert(inst == 0 || inst == 1);
|
|
assert(idx >= 0 && idx < 1024);
|
|
|
|
builtin_history[inst][builtin_idx[inst]++] = idx;
|
|
|
|
if (builtin_idx[inst] >= ARRAY_COUNT(builtin_history[inst]))
|
|
{
|
|
builtin_idx_rolled_over[inst] = true;
|
|
builtin_idx[inst] = 0;
|
|
}
|
|
}
|
|
|
|
void push_codepos_history(game::scriptInstance_t inst, const char* pos)
|
|
{
|
|
assert(inst == 0 || inst == 1);
|
|
assert(game::Scr_IsInOpcodeMemory(inst, pos));
|
|
|
|
codepos_history[inst][codepos_idx[inst]++] = pos;
|
|
|
|
if (codepos_idx[inst] >= ARRAY_COUNT(codepos_history[inst]))
|
|
{
|
|
codepos_idx_rolled_over[inst] = true;
|
|
codepos_idx[inst] = 0;
|
|
}
|
|
}
|