From d57945fece1e2a8833d8a8f71f6d21d1e7a8d31e Mon Sep 17 00:00:00 2001 From: ineed bots Date: Fri, 8 Sep 2023 12:55:24 -0600 Subject: [PATCH] Added compiler wrappers and detours --- .../decomp/clientscript/re_cscr_compiler.cpp | 3329 +++++++++++++++++ src/game/clientscript/clientscript_public.hpp | 5 +- .../clientscript/clientscript_public_w.cpp | 17 - src/game/clientscript/cscr_compiler.hpp | 265 ++ src/game/clientscript/cscr_compiler_w.cpp | 1482 ++++++++ 5 files changed, 5078 insertions(+), 20 deletions(-) create mode 100644 src/component/decomp/clientscript/re_cscr_compiler.cpp create mode 100644 src/game/clientscript/cscr_compiler.hpp create mode 100644 src/game/clientscript/cscr_compiler_w.cpp diff --git a/src/component/decomp/clientscript/re_cscr_compiler.cpp b/src/component/decomp/clientscript/re_cscr_compiler.cpp new file mode 100644 index 0000000..35d21c2 --- /dev/null +++ b/src/component/decomp/clientscript/re_cscr_compiler.cpp @@ -0,0 +1,3329 @@ +#include +#include "loader/component_loader.hpp" +#include "utils/hook.hpp" +//#include "codsrc/clientscript/cscr_compiler.hpp" + +#define RE_CSCR_COMPILER_USE_WRAPPERS + +namespace re_cscr_compiler +{ + utils::hook::detour RemoveRefToValue_hook; + utils::hook::detour Scr_CompileRemoveRefToString_hook; + utils::hook::detour EmitCanonicalString_hook; + utils::hook::detour CompileTransferRefToString_hook; + utils::hook::detour EmitOpcode_hook; + utils::hook::detour EmitEnd_hook; + utils::hook::detour EmitReturn_hook; + utils::hook::detour EmitCodepos_hook; + utils::hook::detour EmitShort_hook; + utils::hook::detour EmitByte_hook; + utils::hook::detour EmitGetInteger_hook; + utils::hook::detour EmitGetFloat_hook; + utils::hook::detour EmitAnimTree_hook; + utils::hook::detour Scr_FindLocalVarIndex_hook; + utils::hook::detour EmitCreateLocalVars_hook; + utils::hook::detour EmitRemoveLocalVars_hook; + utils::hook::detour EmitNOP2_hook; + utils::hook::detour Scr_InitFromChildBlocks_hook; + utils::hook::detour Scr_AppendChildBlocks_hook; + utils::hook::detour Scr_MergeChildBlocks_hook; + utils::hook::detour Scr_TransferBlock_hook; + utils::hook::detour EmitSafeSetVariableField_hook; + utils::hook::detour EmitSafeSetWaittillVariableField_hook; + utils::hook::detour EmitGetString_hook; + utils::hook::detour EmitGetIString_hook; + utils::hook::detour EmitGetVector_hook; + utils::hook::detour EmitValue_hook; + utils::hook::detour Scr_PushValue_hook; + utils::hook::detour EmitCastBool_hook; + utils::hook::detour EmitBoolNot_hook; + utils::hook::detour EmitBoolComplement_hook; + utils::hook::detour EmitSize_hook; + utils::hook::detour EmitSelf_hook; + utils::hook::detour EmitLevel_hook; + utils::hook::detour EmitGame_hook; + utils::hook::detour EmitAnim_hook; + utils::hook::detour EmitSelfObject_hook; + utils::hook::detour EmitLevelObject_hook; + utils::hook::detour EmitAnimObject_hook; + utils::hook::detour EmitLocalVariable_hook; + utils::hook::detour EmitLocalVariableRef_hook; + utils::hook::detour Scr_RegisterLocalVar_hook; + utils::hook::detour EmitGameRef_hook; + utils::hook::detour EmitClearArray_hook; + utils::hook::detour EmitEmptyArray_hook; + utils::hook::detour EmitAnimation_hook; + utils::hook::detour EmitFieldVariable_hook; + utils::hook::detour EmitFieldVariableRef_hook; + utils::hook::detour EmitObject_hook; + utils::hook::detour EmitDecTop_hook; + utils::hook::detour EmitCastFieldObject_hook; + utils::hook::detour EmitArrayVariable_hook; + utils::hook::detour EmitArrayVariableRef_hook; + utils::hook::detour EmitClearArrayVariable_hook; + utils::hook::detour EmitVariableExpression_hook; + utils::hook::detour EmitExpressionList_hook; + utils::hook::detour AddExpressionListOpcodePos_hook; + utils::hook::detour AddFilePrecache_hook; + utils::hook::detour EmitFunction_hook; + utils::hook::detour EmitGetFunction_hook; + utils::hook::detour AddFunction_hook; + utils::hook::detour EmitPostScriptFunction_hook; + utils::hook::detour EmitPostScriptFunctionPointer_hook; + utils::hook::detour EmitPostScriptThread_hook; + utils::hook::detour EmitPostScriptThreadPointer_hook; + utils::hook::detour EmitPostScriptFunctionCall_hook; + utils::hook::detour EmitPostScriptThreadCall_hook; + utils::hook::detour EmitPreFunctionCall_hook; + utils::hook::detour EmitPostFunctionCall_hook; + utils::hook::detour Scr_BeginDevScript_hook; + utils::hook::detour Scr_EndDevScript_hook; + utils::hook::detour EmitCallBuiltinOpcode_hook; + utils::hook::detour EmitCallBuiltinMethodOpcode_hook; + utils::hook::detour EmitCall_hook; + utils::hook::detour EmitMethod_hook; + utils::hook::detour LinkThread_hook; + utils::hook::detour LinkFile_hook; + utils::hook::detour CheckThreadPosition_hook; + utils::hook::detour EmitCallExpression_hook; + utils::hook::detour EmitCallExpressionFieldObject_hook; + utils::hook::detour Scr_CreateVector_hook; + utils::hook::detour EvalPrimitiveExpressionList_hook; + utils::hook::detour EmitOrEvalPrimitiveExpressionList_hook; + utils::hook::detour EmitExpressionListFieldObject_hook; + utils::hook::detour EvalPrimitiveExpression_hook; + utils::hook::detour EmitOrEvalPrimitiveExpression_hook; + utils::hook::detour EmitBoolOrExpression_hook; + utils::hook::detour EmitBoolAndExpression_hook; + utils::hook::detour EvalBinaryOperatorExpression_hook; + utils::hook::detour EmitOrEvalBinaryOperatorExpression_hook; + utils::hook::detour EmitBinaryEqualsOperatorExpression_hook; + utils::hook::detour Scr_CalcLocalVarsVariableExpressionRef_hook; + utils::hook::detour EvalExpression_hook; + utils::hook::detour EmitOrEvalExpression_hook; + utils::hook::detour EmitExpression_hook; + utils::hook::detour EmitVariableExpressionRef_hook; + utils::hook::detour EmitArrayPrimitiveExpressionRef_hook; + utils::hook::detour Scr_CalcLocalVarsArrayVariableRef_hook; + utils::hook::detour EmitPrimitiveExpressionFieldObject_hook; + utils::hook::detour ConnectBreakStatements_hook; + utils::hook::detour ConnectContinueStatements_hook; + utils::hook::detour EmitClearVariableExpression_hook; + utils::hook::detour EmitAssignmentStatement_hook; + utils::hook::detour EmitCallExpressionStatement_hook; + utils::hook::detour EmitReturnStatement_hook; + utils::hook::detour EmitWaitStatement_hook; + utils::hook::detour EmitWaittillFrameEnd_hook; + utils::hook::detour EmitIfStatement_hook; + utils::hook::detour Scr_CalcLocalVarsIfStatement_hook; + utils::hook::detour EmitIfElseStatement_hook; + utils::hook::detour Scr_CalcLocalVarsIfElseStatement_hook; + utils::hook::detour Scr_AddBreakBlock_hook; + utils::hook::detour Scr_AddContinueBlock_hook; + utils::hook::detour EmitWhileStatement_hook; + utils::hook::detour Scr_CalcLocalVarsWhileStatement_hook; + utils::hook::detour EmitForStatement_hook; + utils::hook::detour Scr_CalcLocalVarsForStatement_hook; + utils::hook::detour EmitIncStatement_hook; + utils::hook::detour EmitDecStatement_hook; + utils::hook::detour Scr_CalcLocalVarsFormalParameterListInternal_hook; + utils::hook::detour EmitWaittillStatement_hook; + utils::hook::detour EmitWaittillmatchStatement_hook; + utils::hook::detour EmitNotifyStatement_hook; + utils::hook::detour EmitEndOnStatement_hook; + utils::hook::detour CompareCaseInfo_hook; + utils::hook::detour EmitCaseStatement_hook; + utils::hook::detour EmitSwitchStatementList_hook; + utils::hook::detour Scr_CalcLocalVarsSwitchStatement_hook; + utils::hook::detour EmitSwitchStatement_hook; + utils::hook::detour EmitCaseStatementInfo_hook; + utils::hook::detour EmitBreakStatement_hook; + utils::hook::detour EmitContinueStatement_hook; + utils::hook::detour EmitProfStatement_hook; + utils::hook::detour EmitStatement_hook; + utils::hook::detour Scr_CalcLocalVarsStatement_hook; + utils::hook::detour EmitStatementList_hook; + utils::hook::detour Scr_CalcLocalVarsStatementList_hook; + utils::hook::detour Scr_CalcLocalVarsDeveloperStatementList_hook; + utils::hook::detour EmitDeveloperStatementList_hook; + utils::hook::detour EmitFormalParameterList_hook; + utils::hook::detour SpecifyThread_hook; + utils::hook::detour EmitThreadInternal_hook; + utils::hook::detour Scr_CalcLocalVarsThread_hook; + utils::hook::detour InitThread_hook; + utils::hook::detour EmitNormalThread_hook; + utils::hook::detour EmitDeveloperThread_hook; + utils::hook::detour EmitThread_hook; + utils::hook::detour EmitThreadList_hook; + utils::hook::detour EmitInclude_hook; + utils::hook::detour ScriptCompile_hook; + + void* RemoveRefToValue_original; + void* Scr_CompileRemoveRefToString_original; + void* EmitCanonicalString_original; + void* CompileTransferRefToString_original; + void* EmitOpcode_original; + void* EmitEnd_original; + void* EmitReturn_original; + void* EmitCodepos_original; + void* EmitShort_original; + void* EmitByte_original; + void* EmitGetInteger_original; + void* EmitGetFloat_original; + void* EmitAnimTree_original; + void* Scr_FindLocalVarIndex_original; + void* EmitCreateLocalVars_original; + void* EmitRemoveLocalVars_original; + void* EmitNOP2_original; + void* Scr_InitFromChildBlocks_original; + void* Scr_AppendChildBlocks_original; + void* Scr_MergeChildBlocks_original; + void* Scr_TransferBlock_original; + void* EmitSafeSetVariableField_original; + void* EmitSafeSetWaittillVariableField_original; + void* EmitGetString_original; + void* EmitGetIString_original; + void* EmitGetVector_original; + void* EmitValue_original; + void* Scr_PushValue_original; + void* EmitCastBool_original; + void* EmitBoolNot_original; + void* EmitBoolComplement_original; + void* EmitSize_original; + void* EmitSelf_original; + void* EmitLevel_original; + void* EmitGame_original; + void* EmitAnim_original; + void* EmitSelfObject_original; + void* EmitLevelObject_original; + void* EmitAnimObject_original; + void* EmitLocalVariable_original; + void* EmitLocalVariableRef_original; + void* Scr_RegisterLocalVar_original; + void* EmitGameRef_original; + void* EmitClearArray_original; + void* EmitEmptyArray_original; + void* EmitAnimation_original; + void* EmitFieldVariable_original; + void* EmitFieldVariableRef_original; + void* EmitObject_original; + void* EmitDecTop_original; + void* EmitCastFieldObject_original; + void* EmitArrayVariable_original; + void* EmitArrayVariableRef_original; + void* EmitClearArrayVariable_original; + void* EmitVariableExpression_original; + void* EmitExpressionList_original; + void* AddExpressionListOpcodePos_original; + void* AddFilePrecache_original; + void* EmitFunction_original; + void* EmitGetFunction_original; + void* AddFunction_original; + void* EmitPostScriptFunction_original; + void* EmitPostScriptFunctionPointer_original; + void* EmitPostScriptThread_original; + void* EmitPostScriptThreadPointer_original; + void* EmitPostScriptFunctionCall_original; + void* EmitPostScriptThreadCall_original; + void* EmitPreFunctionCall_original; + void* EmitPostFunctionCall_original; + void* Scr_BeginDevScript_original; + void* Scr_EndDevScript_original; + void* EmitCallBuiltinOpcode_original; + void* EmitCallBuiltinMethodOpcode_original; + void* EmitCall_original; + void* EmitMethod_original; + void* LinkThread_original; + void* LinkFile_original; + void* CheckThreadPosition_original; + void* EmitCallExpression_original; + void* EmitCallExpressionFieldObject_original; + void* Scr_CreateVector_original; + void* EvalPrimitiveExpressionList_original; + void* EmitOrEvalPrimitiveExpressionList_original; + void* EmitExpressionListFieldObject_original; + void* EvalPrimitiveExpression_original; + void* EmitOrEvalPrimitiveExpression_original; + void* EmitBoolOrExpression_original; + void* EmitBoolAndExpression_original; + void* EvalBinaryOperatorExpression_original; + void* EmitOrEvalBinaryOperatorExpression_original; + void* EmitBinaryEqualsOperatorExpression_original; + void* Scr_CalcLocalVarsVariableExpressionRef_original; + void* EvalExpression_original; + void* EmitOrEvalExpression_original; + void* EmitExpression_original; + void* EmitVariableExpressionRef_original; + void* EmitArrayPrimitiveExpressionRef_original; + void* Scr_CalcLocalVarsArrayVariableRef_original; + void* EmitPrimitiveExpressionFieldObject_original; + void* ConnectBreakStatements_original; + void* ConnectContinueStatements_original; + void* EmitClearVariableExpression_original; + void* EmitAssignmentStatement_original; + void* EmitCallExpressionStatement_original; + void* EmitReturnStatement_original; + void* EmitWaitStatement_original; + void* EmitWaittillFrameEnd_original; + void* EmitIfStatement_original; + void* Scr_CalcLocalVarsIfStatement_original; + void* EmitIfElseStatement_original; + void* Scr_CalcLocalVarsIfElseStatement_original; + void* Scr_AddBreakBlock_original; + void* Scr_AddContinueBlock_original; + void* EmitWhileStatement_original; + void* Scr_CalcLocalVarsWhileStatement_original; + void* EmitForStatement_original; + void* Scr_CalcLocalVarsForStatement_original; + void* EmitIncStatement_original; + void* EmitDecStatement_original; + void* Scr_CalcLocalVarsFormalParameterListInternal_original; + void* EmitWaittillStatement_original; + void* EmitWaittillmatchStatement_original; + void* EmitNotifyStatement_original; + void* EmitEndOnStatement_original; + void* CompareCaseInfo_original; + void* EmitCaseStatement_original; + void* EmitSwitchStatementList_original; + void* Scr_CalcLocalVarsSwitchStatement_original; + void* EmitSwitchStatement_original; + void* EmitCaseStatementInfo_original; + void* EmitBreakStatement_original; + void* EmitContinueStatement_original; + void* EmitProfStatement_original; + void* EmitStatement_original; + void* Scr_CalcLocalVarsStatement_original; + void* EmitStatementList_original; + void* Scr_CalcLocalVarsStatementList_original; + void* Scr_CalcLocalVarsDeveloperStatementList_original; + void* EmitDeveloperStatementList_original; + void* EmitFormalParameterList_original; + void* SpecifyThread_original; + void* EmitThreadInternal_original; + void* Scr_CalcLocalVarsThread_original; + void* InitThread_original; + void* EmitNormalThread_original; + void* EmitDeveloperThread_original; + void* EmitThread_original; + void* EmitThreadList_original; + void* EmitInclude_original; + void* ScriptCompile_original; + + namespace + { + + void RemoveRefToValue_stub(game::scriptInstance_t inst, game::VariableValue* value) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + RemoveRefToValue_hook.invoke(inst, value); +#else + cscr_compiler::RemoveRefToValue(inst, value); +#endif + } + + void Scr_CompileRemoveRefToString_call(game::scriptInstance_t inst, unsigned int stringVal, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_CompileRemoveRefToString(inst, stringVal, Scr_CompileRemoveRefToString_original); +#else + cscr_compiler::Scr_CompileRemoveRefToString(inst, stringVal); +#endif + } + + // void __usercall Scr_CompileRemoveRefToString(game::scriptInstance_t inst@, unsigned int stringVal@) + NAKED void Scr_CompileRemoveRefToString_stub() + { + _asm + { + push edx; + push eax; + call Scr_CompileRemoveRefToString_call; + add esp, 0x8; + ret; + } + } + + void EmitCanonicalString_call(game::scriptInstance_t inst, unsigned int stringVal, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCanonicalString(inst, stringVal, EmitCanonicalString_original); +#else + cscr_compiler::EmitCanonicalString(inst, stringVal); +#endif + } + + // void __usercall EmitCanonicalString(game::scriptInstance_t inst@, unsigned int stringVal@) + NAKED void EmitCanonicalString_stub() + { + _asm + { + push eax; + push ecx; + call EmitCanonicalString_call; + add esp, 0x8; + ret; + } + } + + void CompileTransferRefToString_call(unsigned int stringValue, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int user) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::CompileTransferRefToString(stringValue, inst, user, CompileTransferRefToString_original); +#else + cscr_compiler::CompileTransferRefToString(stringValue, inst, user); +#endif + } + + // void __usercall CompileTransferRefToString(unsigned int stringValue@, game::scriptInstance_t inst@, unsigned int user) + NAKED void CompileTransferRefToString_stub() + { + _asm + { + push ecx; + push eax; + call CompileTransferRefToString_call; + add esp, 0x8; + ret; + } + } + + void EmitOpcode_stub(game::scriptInstance_t inst, game::OpcodeVM op, int offset, int callType) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitOpcode_hook.invoke(inst, op, offset, callType); +#else + cscr_compiler::EmitOpcode(inst, op, offset, callType); +#endif + } + + void EmitEnd_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitEnd(inst, EmitEnd_original); +#else + cscr_compiler::EmitEnd(inst); +#endif + } + + // void __usercall EmitEnd(game::scriptInstance_t inst@) + NAKED void EmitEnd_stub() + { + _asm + { + push eax; + call EmitEnd_call; + add esp, 0x4; + ret; + } + } + + void EmitReturn_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitReturn(inst, EmitReturn_original); +#else + cscr_compiler::EmitReturn(inst); +#endif + } + + // void __usercall EmitReturn(game::scriptInstance_t inst@) + NAKED void EmitReturn_stub() + { + _asm + { + push eax; + call EmitReturn_call; + add esp, 0x4; + ret; + } + } + + void EmitCodepos_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int codepos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCodepos(inst, codepos, EmitCodepos_original); +#else + cscr_compiler::EmitCodepos(inst, codepos); +#endif + } + + // void __usercall EmitCodepos(game::scriptInstance_t inst@, int codepos) + NAKED void EmitCodepos_stub() + { + _asm + { + push eax; + call EmitCodepos_call; + add esp, 0x4; + ret; + } + } + + void EmitShort_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int value) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitShort(inst, value, EmitShort_original); +#else + cscr_compiler::EmitShort(inst, value); +#endif + } + + // void __usercall EmitShort(game::scriptInstance_t inst@, int value) + NAKED void EmitShort_stub() + { + _asm + { + push eax; + call EmitShort_call; + add esp, 0x4; + ret; + } + } + + void EmitByte_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int value) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitByte(inst, value, EmitByte_original); +#else + cscr_compiler::EmitByte(inst, value); +#endif + } + + // void __usercall EmitByte(game::scriptInstance_t inst@, int value) + NAKED void EmitByte_stub() + { + _asm + { + push eax; + call EmitByte_call; + add esp, 0x4; + ret; + } + } + + void EmitGetInteger_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int value, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitGetInteger(inst, value, sourcePos, EmitGetInteger_original); +#else + cscr_compiler::EmitGetInteger(inst, value, sourcePos); +#endif + } + + // void __usercall EmitGetInteger(game::scriptInstance_t inst@, int value, game::sval_u sourcePos) + NAKED void EmitGetInteger_stub() + { + _asm + { + push eax; + call EmitGetInteger_call; + add esp, 0x4; + ret; + } + } + + void EmitGetFloat_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, float value, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitGetFloat(inst, value, sourcePos, EmitGetFloat_original); +#else + cscr_compiler::EmitGetFloat(inst, value, sourcePos); +#endif + } + + // void __usercall EmitGetFloat(game::scriptInstance_t inst@, float value, game::sval_u sourcePos) + NAKED void EmitGetFloat_stub() + { + _asm + { + push eax; + call EmitGetFloat_call; + add esp, 0x4; + ret; + } + } + + void EmitAnimTree_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitAnimTree(inst, sourcePos, EmitAnimTree_original); +#else + cscr_compiler::EmitAnimTree(inst, sourcePos); +#endif + } + + // void __usercall EmitAnimTree(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitAnimTree_stub() + { + _asm + { + push eax; + call EmitAnimTree_call; + add esp, 0x4; + ret; + } + } + + int Scr_FindLocalVarIndex_stub(game::scriptInstance_t inst, unsigned int name, game::sval_u sourcePos, int create, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return Scr_FindLocalVarIndex_hook.invoke(inst, name, sourcePos, create, block); +#else + return cscr_compiler::Scr_FindLocalVarIndex(inst, name, sourcePos, create, block); +#endif + } + + void EmitCreateLocalVars_stub(game::scriptInstance_t inst, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitCreateLocalVars_hook.invoke(inst, block); +#else + cscr_compiler::EmitCreateLocalVars(inst, block); +#endif + } + + void EmitRemoveLocalVars_call(game::scriptInstance_t inst, game::scr_block_s* outerBlock, [[maybe_unused]] void* caller_addr, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitRemoveLocalVars(inst, outerBlock, block, EmitRemoveLocalVars_original); +#else + cscr_compiler::EmitRemoveLocalVars(inst, outerBlock, block); +#endif + } + + // void __usercall EmitRemoveLocalVars(game::scriptInstance_t inst@, game::scr_block_s *outerBlock@, game::scr_block_s *block) + NAKED void EmitRemoveLocalVars_stub() + { + _asm + { + push ecx; + push eax; + call EmitRemoveLocalVars_call; + add esp, 0x8; + ret; + } + } + + void EmitNOP2_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int lastStatement, unsigned int endSourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitNOP2(block, inst, lastStatement, endSourcePos, EmitNOP2_original); +#else + cscr_compiler::EmitNOP2(block, inst, lastStatement, endSourcePos); +#endif + } + + // void __usercall EmitNOP2(game::scr_block_s *block@, game::scriptInstance_t inst@, int lastStatement, unsigned int endSourcePos) + NAKED void EmitNOP2_stub() + { + _asm + { + push edi; + push ecx; + call EmitNOP2_call; + add esp, 0x8; + ret; + } + } + + void Scr_InitFromChildBlocks_stub(game::scr_block_s** childBlocks, int childCount, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_InitFromChildBlocks_hook.invoke(childBlocks, childCount, block); +#else + cscr_compiler::Scr_InitFromChildBlocks(childBlocks, childCount, block); +#endif + } + + void Scr_AppendChildBlocks_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::scr_block_s** childBlocks, int childCount) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_AppendChildBlocks(block, childBlocks, childCount, Scr_AppendChildBlocks_original); +#else + cscr_compiler::Scr_AppendChildBlocks(block, childBlocks, childCount); +#endif + } + + // void __usercall Scr_AppendChildBlocks(game::scr_block_s *block@, game::scr_block_s **childBlocks, int childCount) + NAKED void Scr_AppendChildBlocks_stub() + { + _asm + { + push edi; + call Scr_AppendChildBlocks_call; + add esp, 0x4; + ret; + } + } + + void Scr_MergeChildBlocks_stub(game::scr_block_s** childBlocks, int childCount, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_MergeChildBlocks_hook.invoke(childBlocks, childCount, block); +#else + cscr_compiler::Scr_MergeChildBlocks(childBlocks, childCount, block); +#endif + } + + void Scr_TransferBlock_call(game::scr_block_s* to, [[maybe_unused]] void* caller_addr, game::scr_block_s* from) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_TransferBlock(to, from, Scr_TransferBlock_original); +#else + cscr_compiler::Scr_TransferBlock(to, from); +#endif + } + + // void __usercall Scr_TransferBlock(game::scr_block_s *to@, game::scr_block_s *from) + NAKED void Scr_TransferBlock_stub() + { + _asm + { + push esi; + call Scr_TransferBlock_call; + add esp, 0x4; + ret; + } + } + + void EmitSafeSetVariableField_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitSafeSetVariableField(block, inst, expr, sourcePos, EmitSafeSetVariableField_original); +#else + cscr_compiler::EmitSafeSetVariableField(block, inst, expr, sourcePos); +#endif + } + + // void __usercall EmitSafeSetVariableField(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitSafeSetVariableField_stub() + { + _asm + { + push esi; + push eax; + call EmitSafeSetVariableField_call; + add esp, 0x8; + ret; + } + } + + void EmitSafeSetWaittillVariableField_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitSafeSetWaittillVariableField(block, inst, expr, sourcePos, EmitSafeSetWaittillVariableField_original); +#else + cscr_compiler::EmitSafeSetWaittillVariableField(block, inst, expr, sourcePos); +#endif + } + + // void __usercall EmitSafeSetWaittillVariableField(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitSafeSetWaittillVariableField_stub() + { + _asm + { + push edi; + push eax; + call EmitSafeSetWaittillVariableField_call; + add esp, 0x8; + ret; + } + } + + void EmitGetString_call(unsigned int value, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitGetString(value, inst, sourcePos, EmitGetString_original); +#else + cscr_compiler::EmitGetString(value, inst, sourcePos); +#endif + } + + // void __usercall EmitGetString(unsigned int value@, game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitGetString_stub() + { + _asm + { + push esi; + push edi; + call EmitGetString_call; + add esp, 0x8; + ret; + } + } + + void EmitGetIString_call(unsigned int value, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitGetIString(value, inst, sourcePos, EmitGetIString_original); +#else + cscr_compiler::EmitGetIString(value, inst, sourcePos); +#endif + } + + // void __usercall EmitGetIString(unsigned int value@, game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitGetIString_stub() + { + _asm + { + push esi; + push edi; + call EmitGetIString_call; + add esp, 0x8; + ret; + } + } + + void EmitGetVector_call(const float* value, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitGetVector(value, inst, sourcePos, EmitGetVector_original); +#else + cscr_compiler::EmitGetVector(value, inst, sourcePos); +#endif + } + + // void __usercall EmitGetVector(const float *value@, game::scriptInstance_t inst, game::sval_u sourcePos) + NAKED void EmitGetVector_stub() + { + _asm + { + push eax; + call EmitGetVector_call; + add esp, 0x4; + ret; + } + } + + void EmitValue_stub(game::scriptInstance_t inst, game::VariableCompileValue* constValue) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitValue_hook.invoke(inst, constValue); +#else + cscr_compiler::EmitValue(inst, constValue); +#endif + } + + void Scr_PushValue_call(game::scriptInstance_t inst, game::VariableCompileValue* constValue, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_PushValue(inst, constValue, Scr_PushValue_original); +#else + cscr_compiler::Scr_PushValue(inst, constValue); +#endif + } + + // void __usercall Scr_PushValue(game::scriptInstance_t inst@, game::VariableCompileValue *constValue@) + NAKED void Scr_PushValue_stub() + { + _asm + { + push esi; + push eax; + call Scr_PushValue_call; + add esp, 0x8; + ret; + } + } + + void EmitCastBool_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCastBool(inst, sourcePos, EmitCastBool_original); +#else + cscr_compiler::EmitCastBool(inst, sourcePos); +#endif + } + + // void __usercall EmitCastBool(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitCastBool_stub() + { + _asm + { + push edi; + call EmitCastBool_call; + add esp, 0x4; + ret; + } + } + + void EmitBoolNot_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitBoolNot(inst, sourcePos, EmitBoolNot_original); +#else + cscr_compiler::EmitBoolNot(inst, sourcePos); +#endif + } + + // void __usercall EmitBoolNot(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitBoolNot_stub() + { + _asm + { + push edi; + call EmitBoolNot_call; + add esp, 0x4; + ret; + } + } + + void EmitBoolComplement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitBoolComplement(inst, sourcePos, EmitBoolComplement_original); +#else + cscr_compiler::EmitBoolComplement(inst, sourcePos); +#endif + } + + // void __usercall EmitBoolComplement(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitBoolComplement_stub() + { + _asm + { + push edi; + call EmitBoolComplement_call; + add esp, 0x4; + ret; + } + } + + void EmitSize_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitSize(block, inst, expr, sourcePos, EmitSize_original); +#else + cscr_compiler::EmitSize(block, inst, expr, sourcePos); +#endif + } + + // void __usercall EmitSize(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitSize_stub() + { + _asm + { + push edi; + push eax; + call EmitSize_call; + add esp, 0x8; + ret; + } + } + + void EmitSelf_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitSelf(inst, sourcePos, EmitSelf_original); +#else + cscr_compiler::EmitSelf(inst, sourcePos); +#endif + } + + // void __usercall EmitSelf(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitSelf_stub() + { + _asm + { + push edi; + call EmitSelf_call; + add esp, 0x4; + ret; + } + } + + void EmitLevel_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitLevel(inst, sourcePos, EmitLevel_original); +#else + cscr_compiler::EmitLevel(inst, sourcePos); +#endif + } + + // void __usercall EmitLevel(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitLevel_stub() + { + _asm + { + push edi; + call EmitLevel_call; + add esp, 0x4; + ret; + } + } + + void EmitGame_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitGame(inst, sourcePos, EmitGame_original); +#else + cscr_compiler::EmitGame(inst, sourcePos); +#endif + } + + // void __usercall EmitGame(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitGame_stub() + { + _asm + { + push edi; + call EmitGame_call; + add esp, 0x4; + ret; + } + } + + void EmitAnim_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitAnim(inst, sourcePos, EmitAnim_original); +#else + cscr_compiler::EmitAnim(inst, sourcePos); +#endif + } + + // void __usercall EmitAnim(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitAnim_stub() + { + _asm + { + push edi; + call EmitAnim_call; + add esp, 0x4; + ret; + } + } + + void EmitSelfObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitSelfObject(inst, sourcePos, EmitSelfObject_original); +#else + cscr_compiler::EmitSelfObject(inst, sourcePos); +#endif + } + + // void __usercall EmitSelfObject(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitSelfObject_stub() + { + _asm + { + push edi; + call EmitSelfObject_call; + add esp, 0x4; + ret; + } + } + + void EmitLevelObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitLevelObject(inst, sourcePos, EmitLevelObject_original); +#else + cscr_compiler::EmitLevelObject(inst, sourcePos); +#endif + } + + // void __usercall EmitLevelObject(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitLevelObject_stub() + { + _asm + { + push edi; + call EmitLevelObject_call; + add esp, 0x4; + ret; + } + } + + void EmitAnimObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitAnimObject(inst, sourcePos, EmitAnimObject_original); +#else + cscr_compiler::EmitAnimObject(inst, sourcePos); +#endif + } + + // void __usercall EmitAnimObject(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitAnimObject_stub() + { + _asm + { + push edi; + call EmitAnimObject_call; + add esp, 0x4; + ret; + } + } + + void EmitLocalVariable_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitLocalVariable(block, inst, expr, sourcePos, EmitLocalVariable_original); +#else + cscr_compiler::EmitLocalVariable(block, inst, expr, sourcePos); +#endif + } + + // void __usercall EmitLocalVariable(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitLocalVariable_stub() + { + _asm + { + push esi; + push eax; + call EmitLocalVariable_call; + add esp, 0x8; + ret; + } + } + + void EmitLocalVariableRef_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitLocalVariableRef(block, inst, expr, sourcePos, EmitLocalVariableRef_original); +#else + cscr_compiler::EmitLocalVariableRef(block, inst, expr, sourcePos); +#endif + } + + // void __usercall EmitLocalVariableRef(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitLocalVariableRef_stub() + { + _asm + { + push esi; + push eax; + call EmitLocalVariableRef_call; + add esp, 0x8; + ret; + } + } + + void Scr_RegisterLocalVar_stub(unsigned int name, game::sval_u sourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_RegisterLocalVar_hook.invoke(name, sourcePos, block); +#else + cscr_compiler::Scr_RegisterLocalVar(name, sourcePos, block); +#endif + } + + void EmitGameRef_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitGameRef(inst, sourcePos, EmitGameRef_original); +#else + cscr_compiler::EmitGameRef(inst, sourcePos); +#endif + } + + // void __usercall EmitGameRef(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitGameRef_stub() + { + _asm + { + push edi; + call EmitGameRef_call; + add esp, 0x4; + ret; + } + } + + void EmitClearArray_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos, game::sval_u indexSourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitClearArray(inst, sourcePos, indexSourcePos, EmitClearArray_original); +#else + cscr_compiler::EmitClearArray(inst, sourcePos, indexSourcePos); +#endif + } + + // void __usercall EmitClearArray(game::scriptInstance_t inst@, game::sval_u sourcePos, game::sval_u indexSourcePos) + NAKED void EmitClearArray_stub() + { + _asm + { + push edi; + call EmitClearArray_call; + add esp, 0x4; + ret; + } + } + + void EmitEmptyArray_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitEmptyArray(inst, sourcePos, EmitEmptyArray_original); +#else + cscr_compiler::EmitEmptyArray(inst, sourcePos); +#endif + } + + // void __usercall EmitEmptyArray(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitEmptyArray_stub() + { + _asm + { + push edi; + call EmitEmptyArray_call; + add esp, 0x4; + ret; + } + } + + void EmitAnimation_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u anim, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitAnimation(inst, anim, sourcePos, EmitAnimation_original); +#else + cscr_compiler::EmitAnimation(inst, anim, sourcePos); +#endif + } + + // void __usercall EmitAnimation(game::scriptInstance_t inst@, game::sval_u anim, game::sval_u sourcePos) + NAKED void EmitAnimation_stub() + { + _asm + { + push eax; + call EmitAnimation_call; + add esp, 0x4; + ret; + } + } + + void EmitFieldVariable_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u field, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitFieldVariable(block, inst, expr, field, sourcePos, EmitFieldVariable_original); +#else + cscr_compiler::EmitFieldVariable(block, inst, expr, field, sourcePos); +#endif + } + + // void __usercall EmitFieldVariable(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u field, game::sval_u sourcePos) + NAKED void EmitFieldVariable_stub() + { + _asm + { + push esi; + push eax; + call EmitFieldVariable_call; + add esp, 0x8; + ret; + } + } + + void EmitFieldVariableRef_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u field, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitFieldVariableRef(block, inst, expr, field, sourcePos, EmitFieldVariableRef_original); +#else + cscr_compiler::EmitFieldVariableRef(block, inst, expr, field, sourcePos); +#endif + } + + // void __usercall EmitFieldVariableRef(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u field, game::sval_u sourcePos) + NAKED void EmitFieldVariableRef_stub() + { + _asm + { + push esi; + push eax; + call EmitFieldVariableRef_call; + add esp, 0x8; + ret; + } + } + + void EmitObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitObject(inst, expr, sourcePos, EmitObject_original); +#else + cscr_compiler::EmitObject(inst, expr, sourcePos); +#endif + } + + // void __usercall EmitObject(game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitObject_stub() + { + _asm + { + push edi; + call EmitObject_call; + add esp, 0x4; + ret; + } + } + + void EmitDecTop_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitDecTop(inst, EmitDecTop_original); +#else + cscr_compiler::EmitDecTop(inst); +#endif + } + + // void __usercall EmitDecTop(game::scriptInstance_t inst@) + NAKED void EmitDecTop_stub() + { + _asm + { + push eax; + call EmitDecTop_call; + add esp, 0x4; + ret; + } + } + + void EmitCastFieldObject_stub(game::scriptInstance_t inst, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitCastFieldObject_hook.invoke(inst, sourcePos); +#else + cscr_compiler::EmitCastFieldObject(inst, sourcePos); +#endif + } + + void EmitArrayVariable_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u index, game::sval_u sourcePos, game::sval_u indexSourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos, EmitArrayVariable_original); +#else + cscr_compiler::EmitArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos); +#endif + } + + // void __usercall EmitArrayVariable(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u index, game::sval_u sourcePos, game::sval_u indexSourcePos) + NAKED void EmitArrayVariable_stub() + { + _asm + { + push esi; + push edi; + call EmitArrayVariable_call; + add esp, 0x8; + ret; + } + } + + void EmitArrayVariableRef_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u index, game::sval_u sourcePos, game::sval_u indexSourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitArrayVariableRef(block, inst, expr, index, sourcePos, indexSourcePos, EmitArrayVariableRef_original); +#else + cscr_compiler::EmitArrayVariableRef(block, inst, expr, index, sourcePos, indexSourcePos); +#endif + } + + // void __usercall EmitArrayVariableRef(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u index, game::sval_u sourcePos, game::sval_u indexSourcePos) + NAKED void EmitArrayVariableRef_stub() + { + _asm + { + push esi; + push eax; + call EmitArrayVariableRef_call; + add esp, 0x8; + ret; + } + } + + void EmitClearArrayVariable_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u index, game::sval_u sourcePos, game::sval_u indexSourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitClearArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos, EmitClearArrayVariable_original); +#else + cscr_compiler::EmitClearArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos); +#endif + } + + // void __usercall EmitClearArrayVariable(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u index, game::sval_u sourcePos, game::sval_u indexSourcePos) + NAKED void EmitClearArrayVariable_stub() + { + _asm + { + push ecx; + push eax; + call EmitClearArrayVariable_call; + add esp, 0x8; + ret; + } + } + + void EmitVariableExpression_stub(game::scriptInstance_t inst, game::sval_u expr, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitVariableExpression_hook.invoke(inst, expr, block); +#else + cscr_compiler::EmitVariableExpression(inst, expr, block); +#endif + } + + int EmitExpressionList_stub(game::scriptInstance_t inst, game::sval_u exprlist, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return EmitExpressionList_hook.invoke(inst, exprlist, block); +#else + return cscr_compiler::EmitExpressionList(inst, exprlist, block); +#endif + } + + void AddExpressionListOpcodePos_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u exprlist) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::AddExpressionListOpcodePos(inst, exprlist, AddExpressionListOpcodePos_original); +#else + cscr_compiler::AddExpressionListOpcodePos(inst, exprlist); +#endif + } + + // void __usercall AddExpressionListOpcodePos(game::scriptInstance_t inst@, game::sval_u exprlist) + NAKED void AddExpressionListOpcodePos_stub() + { + _asm + { + push edi; + call AddExpressionListOpcodePos_call; + add esp, 0x4; + ret; + } + } + + void AddFilePrecache_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int filename, unsigned int sourcePos, int include, unsigned int* filePosId, unsigned int* fileCountId) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::AddFilePrecache(inst, filename, sourcePos, include, filePosId, fileCountId, AddFilePrecache_original); +#else + cscr_compiler::AddFilePrecache(inst, filename, sourcePos, include, filePosId, fileCountId); +#endif + } + + // void __usercall AddFilePrecache(game::scriptInstance_t inst@, unsigned int filename, unsigned int sourcePos, bool include, unsigned int *filePosId, unsigned int *fileCountId) + NAKED void AddFilePrecache_stub() + { + _asm + { + push eax; + call AddFilePrecache_call; + add esp, 0x4; + ret; + } + } + + void EmitFunction_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u func, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitFunction(inst, func, sourcePos, EmitFunction_original); +#else + cscr_compiler::EmitFunction(inst, func, sourcePos); +#endif + } + + // void __usercall EmitFunction(game::scriptInstance_t inst@, game::sval_u func, game::sval_u sourcePos) + NAKED void EmitFunction_stub() + { + _asm + { + push eax; + call EmitFunction_call; + add esp, 0x4; + ret; + } + } + + void EmitGetFunction_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u func, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitGetFunction(inst, func, sourcePos, EmitGetFunction_original); +#else + cscr_compiler::EmitGetFunction(inst, func, sourcePos); +#endif + } + + // void __usercall EmitGetFunction(game::scriptInstance_t inst@, game::sval_u func, game::sval_u sourcePos) + NAKED void EmitGetFunction_stub() + { + _asm + { + push edi; + call EmitGetFunction_call; + add esp, 0x4; + ret; + } + } + + int AddFunction_stub(game::scriptInstance_t inst, int func) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return AddFunction_hook.invoke(inst, func); +#else + return cscr_compiler::AddFunction(inst, func); +#endif + } + + void EmitPostScriptFunction_stub(game::scriptInstance_t inst, game::sval_u func, int param_count, int bMethod, game::sval_u nameSourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitPostScriptFunction_hook.invoke(inst, func, param_count, bMethod, nameSourcePos); +#else + cscr_compiler::EmitPostScriptFunction(inst, func, param_count, bMethod, nameSourcePos); +#endif + } + + void EmitPostScriptFunctionPointer_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, int param_count, int bMethod, game::sval_u nameSourcePos, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitPostScriptFunctionPointer(block, inst, expr, param_count, bMethod, nameSourcePos, sourcePos, EmitPostScriptFunctionPointer_original); +#else + cscr_compiler::EmitPostScriptFunctionPointer(block, inst, expr, param_count, bMethod, nameSourcePos, sourcePos); +#endif + } + + // void __usercall EmitPostScriptFunctionPointer(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, int param_count, int bMethod, game::sval_u nameSourcePos, game::sval_u sourcePos) + NAKED void EmitPostScriptFunctionPointer_stub() + { + _asm + { + push edi; + push eax; + call EmitPostScriptFunctionPointer_call; + add esp, 0x8; + ret; + } + } + + void EmitPostScriptThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u func, int param_count, int bMethod, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitPostScriptThread(inst, func, param_count, bMethod, sourcePos, EmitPostScriptThread_original); +#else + cscr_compiler::EmitPostScriptThread(inst, func, param_count, bMethod, sourcePos); +#endif + } + + // void __usercall EmitPostScriptThread(game::scriptInstance_t inst@, game::sval_u func, int param_count, int bMethod, game::sval_u sourcePos) + NAKED void EmitPostScriptThread_stub() + { + _asm + { + push edi; + call EmitPostScriptThread_call; + add esp, 0x4; + ret; + } + } + + void EmitPostScriptThreadPointer_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, int param_count, int bMethod, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitPostScriptThreadPointer(block, inst, expr, param_count, bMethod, sourcePos, EmitPostScriptThreadPointer_original); +#else + cscr_compiler::EmitPostScriptThreadPointer(block, inst, expr, param_count, bMethod, sourcePos); +#endif + } + + // void __usercall EmitPostScriptThreadPointer(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, int param_count, int bMethod, game::sval_u sourcePos) + NAKED void EmitPostScriptThreadPointer_stub() + { + _asm + { + push edi; + push eax; + call EmitPostScriptThreadPointer_call; + add esp, 0x8; + ret; + } + } + + void EmitPostScriptFunctionCall_call(game::scriptInstance_t inst, int bMethod, int param_count, [[maybe_unused]] void* caller_addr, game::sval_u func_name, game::sval_u nameSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitPostScriptFunctionCall(inst, bMethod, param_count, func_name, nameSourcePos, block, EmitPostScriptFunctionCall_original); +#else + cscr_compiler::EmitPostScriptFunctionCall(inst, bMethod, param_count, func_name, nameSourcePos, block); +#endif + } + + // void __usercall EmitPostScriptFunctionCall(game::scriptInstance_t inst@, char bMethod@
, int param_count@, game::sval_u func_name, game::sval_u nameSourcePos, game::scr_block_s *block) + NAKED void EmitPostScriptFunctionCall_stub() + { + _asm + { + push esi; + push edx; + push eax; + call EmitPostScriptFunctionCall_call; + add esp, 0xC; + ret; + } + } + + void EmitPostScriptThreadCall_call(game::scriptInstance_t inst, int isMethod, int param_count, [[maybe_unused]] void* caller_addr, game::sval_u func_name, game::sval_u sourcePos, game::sval_u nameSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitPostScriptThreadCall(inst, isMethod, param_count, func_name, sourcePos, nameSourcePos, block, EmitPostScriptThreadCall_original); +#else + cscr_compiler::EmitPostScriptThreadCall(inst, isMethod, param_count, func_name, sourcePos, nameSourcePos, block); +#endif + } + + // void __usercall EmitPostScriptThreadCall(game::scriptInstance_t inst@, char isMethod@
, int param_count@, game::sval_u func_name, game::sval_u sourcePos, game::sval_u nameSourcePos, game::scr_block_s *block) + NAKED void EmitPostScriptThreadCall_stub() + { + _asm + { + push esi; + push edx; + push eax; + call EmitPostScriptThreadCall_call; + add esp, 0xC; + ret; + } + } + + void EmitPreFunctionCall_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitPreFunctionCall(inst, EmitPreFunctionCall_original); +#else + cscr_compiler::EmitPreFunctionCall(inst); +#endif + } + + // void __usercall EmitPreFunctionCall(game::scriptInstance_t inst@) + NAKED void EmitPreFunctionCall_stub() + { + _asm + { + push eax; + call EmitPreFunctionCall_call; + add esp, 0x4; + ret; + } + } + + void EmitPostFunctionCall_call(game::scriptInstance_t inst, int bMethod, [[maybe_unused]] void* caller_addr, game::sval_u func_name, int param_count, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitPostFunctionCall(inst, bMethod, func_name, param_count, block, EmitPostFunctionCall_original); +#else + cscr_compiler::EmitPostFunctionCall(inst, bMethod, func_name, param_count, block); +#endif + } + + // void __usercall EmitPostFunctionCall(game::scriptInstance_t inst@, char bMethod@
, game::sval_u func_name, int param_count, game::scr_block_s *block) + NAKED void EmitPostFunctionCall_stub() + { + _asm + { + push edx; + push eax; + call EmitPostFunctionCall_call; + add esp, 0x8; + ret; + } + } + + void Scr_BeginDevScript_call(game::scriptInstance_t isnt, int* type_, [[maybe_unused]] void* caller_addr, char** savedPos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_BeginDevScript(isnt, type_, savedPos, Scr_BeginDevScript_original); +#else + cscr_compiler::Scr_BeginDevScript(isnt, type_, savedPos); +#endif + } + + // void __usercall Scr_BeginDevScript(game::scriptInstance_t isnt@, int *type@, char **savedPos) + NAKED void Scr_BeginDevScript_stub() + { + _asm + { + push edi; + push eax; + call Scr_BeginDevScript_call; + add esp, 0x8; + ret; + } + } + + void Scr_EndDevScript_call(game::scriptInstance_t inst, char** savedPos, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_EndDevScript(inst, savedPos, Scr_EndDevScript_original); +#else + cscr_compiler::Scr_EndDevScript(inst, savedPos); +#endif + } + + // void __usercall Scr_EndDevScript(game::scriptInstance_t inst@, char **savedPos@) + NAKED void Scr_EndDevScript_stub() + { + _asm + { + push edx; + push eax; + call Scr_EndDevScript_call; + add esp, 0x8; + ret; + } + } + + void EmitCallBuiltinOpcode_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int param_count, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCallBuiltinOpcode(inst, param_count, sourcePos, EmitCallBuiltinOpcode_original); +#else + cscr_compiler::EmitCallBuiltinOpcode(inst, param_count, sourcePos); +#endif + } + + // void __usercall EmitCallBuiltinOpcode(game::scriptInstance_t inst@, int param_count, game::sval_u sourcePos) + NAKED void EmitCallBuiltinOpcode_stub() + { + _asm + { + push eax; + call EmitCallBuiltinOpcode_call; + add esp, 0x4; + ret; + } + } + + void EmitCallBuiltinMethodOpcode_call(int inst, [[maybe_unused]] void* caller_addr, int param_count, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCallBuiltinMethodOpcode(inst, param_count, sourcePos, EmitCallBuiltinMethodOpcode_original); +#else + cscr_compiler::EmitCallBuiltinMethodOpcode(inst, param_count, sourcePos); +#endif + } + + // void __usercall EmitCallBuiltinMethodOpcode(int inst@, int param_count, game::sval_u sourcePos) + NAKED void EmitCallBuiltinMethodOpcode_stub() + { + _asm + { + push eax; + call EmitCallBuiltinMethodOpcode_call; + add esp, 0x4; + ret; + } + } + + void EmitCall_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u func_name, game::sval_u params, int bStatement, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCall(inst, func_name, params, bStatement, block, EmitCall_original); +#else + cscr_compiler::EmitCall(inst, func_name, params, bStatement, block); +#endif + } + + // void __usercall EmitCall(game::scriptInstance_t inst@, game::sval_u func_name, game::sval_u params, int bStatement, game::scr_block_s *block) + NAKED void EmitCall_stub() + { + _asm + { + push eax; + call EmitCall_call; + add esp, 0x4; + ret; + } + } + + void EmitMethod_stub(game::scriptInstance_t inst, game::sval_u expr, game::sval_u func_name, game::sval_u params, game::sval_u methodSourcePos, int bStatement, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitMethod_hook.invoke(inst, expr, func_name, params, methodSourcePos, bStatement, block); +#else + cscr_compiler::EmitMethod(inst, expr, func_name, params, methodSourcePos, bStatement, block); +#endif + } + + void LinkThread_call(game::scriptInstance_t inst, unsigned int threadCountId, [[maybe_unused]] void* caller_addr, game::VariableValue* pos, int allowFarCall) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::LinkThread(inst, threadCountId, pos, allowFarCall, LinkThread_original); +#else + cscr_compiler::LinkThread(inst, threadCountId, pos, allowFarCall); +#endif + } + + // void __usercall LinkThread(game::scriptInstance_t inst@, unsigned int threadCountId@, game::VariableValue *pos, int allowFarCall) + NAKED void LinkThread_stub() + { + _asm + { + push eax; + push ecx; + call LinkThread_call; + add esp, 0x8; + ret; + } + } + + void LinkFile_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int filePosId, unsigned int fileCountId) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::LinkFile(inst, filePosId, fileCountId, LinkFile_original); +#else + cscr_compiler::LinkFile(inst, filePosId, fileCountId); +#endif + } + + // void __usercall LinkFile(game::scriptInstance_t inst@, unsigned int filePosId, unsigned int fileCountId) + NAKED void LinkFile_stub() + { + _asm + { + push eax; + call LinkFile_call; + add esp, 0x4; + ret; + } + } + + void CheckThreadPosition_stub(game::scriptInstance_t inst, unsigned int posId, unsigned int name, unsigned int sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + CheckThreadPosition_hook.invoke(inst, posId, name, sourcePos); +#else + cscr_compiler::CheckThreadPosition(inst, posId, name, sourcePos); +#endif + } + + void EmitCallExpression_call(game::scriptInstance_t inst, game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::sval_u expr, int bStatement) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCallExpression(inst, block, expr, bStatement, EmitCallExpression_original); +#else + cscr_compiler::EmitCallExpression(inst, block, expr, bStatement); +#endif + } + + // void __usercall EmitCallExpression(game::scriptInstance_t inst@, game::scr_block_s *block@, game::sval_u expr, int bStatement) + NAKED void EmitCallExpression_stub() + { + _asm + { + push esi; + push eax; + call EmitCallExpression_call; + add esp, 0x8; + ret; + } + } + + void EmitCallExpressionFieldObject_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCallExpressionFieldObject(block, inst, expr, EmitCallExpressionFieldObject_original); +#else + cscr_compiler::EmitCallExpressionFieldObject(block, inst, expr); +#endif + } + + // void __usercall EmitCallExpressionFieldObject(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr) + NAKED void EmitCallExpressionFieldObject_stub() + { + _asm + { + push edi; + push ecx; + call EmitCallExpressionFieldObject_call; + add esp, 0x8; + ret; + } + } + + void Scr_CreateVector_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::VariableCompileValue* constValue, game::VariableCompileValue* value) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_CreateVector(inst, constValue, value, Scr_CreateVector_original); +#else + cscr_compiler::Scr_CreateVector(inst, constValue, value); +#endif + } + + // void __usercall Scr_CreateVector(game::scriptInstance_t inst@, game::VariableCompileValue *constValue, game::VariableCompileValue *value) + NAKED void Scr_CreateVector_stub() + { + _asm + { + push eax; + call Scr_CreateVector_call; + add esp, 0x4; + ret; + } + } + + bool EvalPrimitiveExpressionList_stub(game::scriptInstance_t inst, game::sval_u exprlist, game::sval_u sourcePos, game::VariableCompileValue* constValue) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return EvalPrimitiveExpressionList_hook.invoke(inst, exprlist, sourcePos, constValue); +#else + return cscr_compiler::EvalPrimitiveExpressionList(inst, exprlist, sourcePos, constValue); +#endif + } + + bool EmitOrEvalPrimitiveExpressionList_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u exprlist, game::sval_u sourcePos, game::VariableCompileValue* constValue, game::scr_block_s* a5) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return game::EmitOrEvalPrimitiveExpressionList(inst, exprlist, sourcePos, constValue, a5, EmitOrEvalPrimitiveExpressionList_original); +#else + return cscr_compiler::EmitOrEvalPrimitiveExpressionList(inst, exprlist, sourcePos, constValue, a5); +#endif + } + + // bool __usercall EmitOrEvalPrimitiveExpressionList@(game::scriptInstance_t inst@, game::sval_u exprlist, game::sval_u sourcePos, game::VariableCompileValue *constValue, game::scr_block_s *a5) + NAKED bool EmitOrEvalPrimitiveExpressionList_stub() + { + _asm + { + push eax; + call EmitOrEvalPrimitiveExpressionList_call; + add esp, 0x4; + ret; + } + } + + void EmitExpressionListFieldObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u exprlist, game::sval_u sourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitExpressionListFieldObject(inst, exprlist, sourcePos, block, EmitExpressionListFieldObject_original); +#else + cscr_compiler::EmitExpressionListFieldObject(inst, exprlist, sourcePos, block); +#endif + } + + // void __usercall EmitExpressionListFieldObject(game::scriptInstance_t inst@, game::sval_u exprlist, game::sval_u sourcePos, game::scr_block_s *block) + NAKED void EmitExpressionListFieldObject_stub() + { + _asm + { + push edx; + call EmitExpressionListFieldObject_call; + add esp, 0x4; + ret; + } + } + + bool EvalPrimitiveExpression_stub(game::scriptInstance_t inst, game::sval_u expr, game::VariableCompileValue* constValue) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return EvalPrimitiveExpression_hook.invoke(inst, expr, constValue); +#else + return cscr_compiler::EvalPrimitiveExpression(inst, expr, constValue); +#endif + } + + bool EmitOrEvalPrimitiveExpression_stub(game::scriptInstance_t inst, game::sval_u expr, game::VariableCompileValue* constValue, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return EmitOrEvalPrimitiveExpression_hook.invoke(inst, expr, constValue, block); +#else + return cscr_compiler::EmitOrEvalPrimitiveExpression(inst, expr, constValue, block); +#endif + } + + void EmitBoolOrExpression_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr1, game::sval_u expr2, game::sval_u expr1sourcePos, game::sval_u expr2sourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitBoolOrExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, block, EmitBoolOrExpression_original); +#else + cscr_compiler::EmitBoolOrExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, block); +#endif + } + + // void __usercall EmitBoolOrExpression(game::scriptInstance_t inst@, game::sval_u expr1, game::sval_u expr2, game::sval_u expr1sourcePos, game::sval_u expr2sourcePos, game::scr_block_s *block) + NAKED void EmitBoolOrExpression_stub() + { + _asm + { + push eax; + call EmitBoolOrExpression_call; + add esp, 0x4; + ret; + } + } + + void EmitBoolAndExpression_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr1, game::sval_u expr2, game::sval_u expr1sourcePos, game::sval_u expr2sourcePos, game::scr_block_s* a6) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitBoolAndExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, a6, EmitBoolAndExpression_original); +#else + cscr_compiler::EmitBoolAndExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, a6); +#endif + } + + // void __usercall EmitBoolAndExpression(game::scriptInstance_t inst@, game::sval_u expr1, game::sval_u expr2, game::sval_u expr1sourcePos, game::sval_u expr2sourcePos, game::scr_block_s *a6) + NAKED void EmitBoolAndExpression_stub() + { + _asm + { + push eax; + call EmitBoolAndExpression_call; + add esp, 0x4; + ret; + } + } + + bool EvalBinaryOperatorExpression_stub(game::scriptInstance_t inst, game::sval_u expr1, game::sval_u expr2, game::sval_u opcode, game::sval_u sourcePos, game::VariableCompileValue* constValue) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return EvalBinaryOperatorExpression_hook.invoke(inst, expr1, expr2, opcode, sourcePos, constValue); +#else + return cscr_compiler::EvalBinaryOperatorExpression(inst, expr1, expr2, opcode, sourcePos, constValue); +#endif + } + + bool EmitOrEvalBinaryOperatorExpression_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr1, game::sval_u expr2, game::sval_u opcode, game::sval_u sourcePos, game::VariableCompileValue* constValue, game::scr_block_s* a8) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return game::EmitOrEvalBinaryOperatorExpression(inst, expr1, expr2, opcode, sourcePos, constValue, a8, EmitOrEvalBinaryOperatorExpression_original); +#else + return cscr_compiler::EmitOrEvalBinaryOperatorExpression(inst, expr1, expr2, opcode, sourcePos, constValue, a8); +#endif + } + + // bool __usercall EmitOrEvalBinaryOperatorExpression@(game::scriptInstance_t inst@, game::sval_u expr1, game::sval_u expr2, game::sval_u opcode, game::sval_u sourcePos, game::VariableCompileValue *constValue, game::scr_block_s *a8) + NAKED bool EmitOrEvalBinaryOperatorExpression_stub() + { + _asm + { + push edi; + call EmitOrEvalBinaryOperatorExpression_call; + add esp, 0x4; + ret; + } + } + + void EmitBinaryEqualsOperatorExpression_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u lhs, game::sval_u rhs, game::sval_u opcode, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitBinaryEqualsOperatorExpression(block, inst, lhs, rhs, opcode, sourcePos, EmitBinaryEqualsOperatorExpression_original); +#else + cscr_compiler::EmitBinaryEqualsOperatorExpression(block, inst, lhs, rhs, opcode, sourcePos); +#endif + } + + // void __usercall EmitBinaryEqualsOperatorExpression(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u lhs, game::sval_u rhs, game::sval_u opcode, game::sval_u sourcePos) + NAKED void EmitBinaryEqualsOperatorExpression_stub() + { + _asm + { + push esi; + push edi; + call EmitBinaryEqualsOperatorExpression_call; + add esp, 0x8; + ret; + } + } + + void Scr_CalcLocalVarsVariableExpressionRef_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::sval_u expr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_CalcLocalVarsVariableExpressionRef(block, expr, Scr_CalcLocalVarsVariableExpressionRef_original); +#else + cscr_compiler::Scr_CalcLocalVarsVariableExpressionRef(block, expr); +#endif + } + + // void __usercall Scr_CalcLocalVarsVariableExpressionRef(game::scr_block_s *block@, game::sval_u expr) + NAKED void Scr_CalcLocalVarsVariableExpressionRef_stub() + { + _asm + { + push edx; + call Scr_CalcLocalVarsVariableExpressionRef_call; + add esp, 0x4; + ret; + } + } + + bool EvalExpression_call(game::VariableCompileValue* constValue, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return game::EvalExpression(constValue, inst, expr, EvalExpression_original); +#else + return cscr_compiler::EvalExpression(constValue, inst, expr); +#endif + } + + // bool __usercall EvalExpression@(game::VariableCompileValue *constValue@, game::scriptInstance_t inst@, game::sval_u expr) + NAKED bool EvalExpression_stub() + { + _asm + { + push esi; + push edx; + call EvalExpression_call; + add esp, 0x8; + ret; + } + } + + bool EmitOrEvalExpression_stub(game::scriptInstance_t inst, game::sval_u expr, game::VariableCompileValue* constValue, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return EmitOrEvalExpression_hook.invoke(inst, expr, constValue, block); +#else + return cscr_compiler::EmitOrEvalExpression(inst, expr, constValue, block); +#endif + } + + void EmitExpression_stub(game::scriptInstance_t inst, game::sval_u expr, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitExpression_hook.invoke(inst, expr, block); +#else + cscr_compiler::EmitExpression(inst, expr, block); +#endif + } + + void EmitVariableExpressionRef_stub(game::scriptInstance_t inst, game::sval_u expr, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitVariableExpressionRef_hook.invoke(inst, expr, block); +#else + cscr_compiler::EmitVariableExpressionRef(inst, expr, block); +#endif + } + + void EmitArrayPrimitiveExpressionRef_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitArrayPrimitiveExpressionRef(inst, expr, sourcePos, block, EmitArrayPrimitiveExpressionRef_original); +#else + cscr_compiler::EmitArrayPrimitiveExpressionRef(inst, expr, sourcePos, block); +#endif + } + + // void __usercall EmitArrayPrimitiveExpressionRef(game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos, game::scr_block_s *block) + NAKED void EmitArrayPrimitiveExpressionRef_stub() + { + _asm + { + push eax; + call EmitArrayPrimitiveExpressionRef_call; + add esp, 0x4; + ret; + } + } + + void Scr_CalcLocalVarsArrayVariableRef_stub(game::sval_u expr, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_CalcLocalVarsArrayVariableRef_hook.invoke(expr, block); +#else + cscr_compiler::Scr_CalcLocalVarsArrayVariableRef(expr, block); +#endif + } + + void EmitPrimitiveExpressionFieldObject_stub(game::scriptInstance_t inst, game::sval_u expr, game::sval_u sourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitPrimitiveExpressionFieldObject_hook.invoke(inst, expr, sourcePos, block); +#else + cscr_compiler::EmitPrimitiveExpressionFieldObject(inst, expr, sourcePos, block); +#endif + } + + void ConnectBreakStatements_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::ConnectBreakStatements(inst, ConnectBreakStatements_original); +#else + cscr_compiler::ConnectBreakStatements(inst); +#endif + } + + // void __usercall ConnectBreakStatements(game::scriptInstance_t inst@) + NAKED void ConnectBreakStatements_stub() + { + _asm + { + push eax; + call ConnectBreakStatements_call; + add esp, 0x4; + ret; + } + } + + void ConnectContinueStatements_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::ConnectContinueStatements(inst, ConnectContinueStatements_original); +#else + cscr_compiler::ConnectContinueStatements(inst); +#endif + } + + // void __usercall ConnectContinueStatements(game::scriptInstance_t inst@) + NAKED void ConnectContinueStatements_stub() + { + _asm + { + push eax; + call ConnectContinueStatements_call; + add esp, 0x4; + ret; + } + } + + bool EmitClearVariableExpression_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u rhsSourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return game::EmitClearVariableExpression(block, inst, expr, rhsSourcePos, EmitClearVariableExpression_original); +#else + return cscr_compiler::EmitClearVariableExpression(block, inst, expr, rhsSourcePos); +#endif + } + + // bool __usercall EmitClearVariableExpression@(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u rhsSourcePos) + NAKED bool EmitClearVariableExpression_stub() + { + _asm + { + push ecx; + push eax; + call EmitClearVariableExpression_call; + add esp, 0x8; + ret; + } + } + + void EmitAssignmentStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u lhs, game::sval_u rhs, game::sval_u sourcePos, game::sval_u rhsSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitAssignmentStatement(inst, lhs, rhs, sourcePos, rhsSourcePos, block, EmitAssignmentStatement_original); +#else + cscr_compiler::EmitAssignmentStatement(inst, lhs, rhs, sourcePos, rhsSourcePos, block); +#endif + } + + // void __usercall EmitAssignmentStatement(game::scriptInstance_t inst@, game::sval_u lhs, game::sval_u rhs, game::sval_u sourcePos, game::sval_u rhsSourcePos, game::scr_block_s *block) + NAKED void EmitAssignmentStatement_stub() + { + _asm + { + push esi; + call EmitAssignmentStatement_call; + add esp, 0x4; + ret; + } + } + + void EmitCallExpressionStatement_call(game::scriptInstance_t inst, game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::sval_u expr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCallExpressionStatement(inst, block, expr, EmitCallExpressionStatement_original); +#else + cscr_compiler::EmitCallExpressionStatement(inst, block, expr); +#endif + } + + // void __usercall EmitCallExpressionStatement(game::scriptInstance_t inst@, game::scr_block_s *block@, game::sval_u expr) + NAKED void EmitCallExpressionStatement_stub() + { + _asm + { + push esi; + push eax; + call EmitCallExpressionStatement_call; + add esp, 0x8; + ret; + } + } + + void EmitReturnStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitReturnStatement(block, inst, expr, sourcePos, EmitReturnStatement_original); +#else + cscr_compiler::EmitReturnStatement(block, inst, expr, sourcePos); +#endif + } + + // void __usercall EmitReturnStatement(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitReturnStatement_stub() + { + _asm + { + push esi; + push eax; + call EmitReturnStatement_call; + add esp, 0x8; + ret; + } + } + + void EmitWaitStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos, game::sval_u waitSourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitWaitStatement(block, inst, expr, sourcePos, waitSourcePos, EmitWaitStatement_original); +#else + cscr_compiler::EmitWaitStatement(block, inst, expr, sourcePos, waitSourcePos); +#endif + } + + // void __usercall EmitWaitStatement(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos, game::sval_u waitSourcePos) + NAKED void EmitWaitStatement_stub() + { + _asm + { + push edi; + push eax; + call EmitWaitStatement_call; + add esp, 0x8; + ret; + } + } + + void EmitWaittillFrameEnd_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitWaittillFrameEnd(inst, sourcePos, EmitWaittillFrameEnd_original); +#else + cscr_compiler::EmitWaittillFrameEnd(inst, sourcePos); +#endif + } + + // void __usercall EmitWaittillFrameEnd(game::scriptInstance_t inst@, game::sval_u sourcePos) + NAKED void EmitWaittillFrameEnd_stub() + { + _asm + { + push edi; + call EmitWaittillFrameEnd_call; + add esp, 0x4; + ret; + } + } + + void EmitIfStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u stmt, game::sval_u sourcePos, int lastStatement, unsigned int endSourcePos, game::scr_block_s* block, game::sval_u* ifStatBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitIfStatement(inst, expr, stmt, sourcePos, lastStatement, endSourcePos, block, ifStatBlock, EmitIfStatement_original); +#else + cscr_compiler::EmitIfStatement(inst, expr, stmt, sourcePos, lastStatement, endSourcePos, block, ifStatBlock); +#endif + } + + // void __usercall EmitIfStatement(game::scriptInstance_t inst@, game::sval_u expr, game::sval_u stmt, game::sval_u sourcePos, int lastStatement, unsigned int endSourcePos, game::scr_block_s *block, game::sval_u *ifStatBlock) + NAKED void EmitIfStatement_stub() + { + _asm + { + push eax; + call EmitIfStatement_call; + add esp, 0x4; + ret; + } + } + + void Scr_CalcLocalVarsIfStatement_stub(game::scriptInstance_t inst, game::sval_u stmt, game::scr_block_s* block, game::sval_u* ifStatBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_CalcLocalVarsIfStatement_hook.invoke(inst, stmt, block, ifStatBlock); +#else + cscr_compiler::Scr_CalcLocalVarsIfStatement(inst, stmt, block, ifStatBlock); +#endif + } + + void EmitIfElseStatement_stub(game::scriptInstance_t inst, game::sval_u expr, game::sval_u stmt1, game::sval_u stmt2, game::sval_u sourcePos, game::sval_u elseSourcePos, int lastStatement, unsigned int endSourcePos, game::scr_block_s* block, game::sval_u* ifStatBlock, game::sval_u* elseStatBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitIfElseStatement_hook.invoke(inst, expr, stmt1, stmt2, sourcePos, elseSourcePos, lastStatement, endSourcePos, block, ifStatBlock, elseStatBlock); +#else + cscr_compiler::EmitIfElseStatement(inst, expr, stmt1, stmt2, sourcePos, elseSourcePos, lastStatement, endSourcePos, block, ifStatBlock, elseStatBlock); +#endif + } + + void Scr_CalcLocalVarsIfElseStatement_stub(game::scriptInstance_t inst, game::sval_u stmt1, game::sval_u stmt2, game::scr_block_s* block, game::sval_u* ifStatBlock, game::sval_u* elseStatBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_CalcLocalVarsIfElseStatement_hook.invoke(inst, stmt1, stmt2, block, ifStatBlock, elseStatBlock); +#else + cscr_compiler::Scr_CalcLocalVarsIfElseStatement(inst, stmt1, stmt2, block, ifStatBlock, elseStatBlock); +#endif + } + + void Scr_AddBreakBlock_call(game::scriptInstance_t inst, game::scr_block_s* block, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_AddBreakBlock(inst, block, Scr_AddBreakBlock_original); +#else + cscr_compiler::Scr_AddBreakBlock(inst, block); +#endif + } + + // void __usercall Scr_AddBreakBlock(game::scriptInstance_t inst@, game::scr_block_s *block@) + NAKED void Scr_AddBreakBlock_stub() + { + _asm + { + push edi; + push eax; + call Scr_AddBreakBlock_call; + add esp, 0x8; + ret; + } + } + + void Scr_AddContinueBlock_call(game::scriptInstance_t inst, game::scr_block_s* block, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_AddContinueBlock(inst, block, Scr_AddContinueBlock_original); +#else + cscr_compiler::Scr_AddContinueBlock(inst, block); +#endif + } + + // void __usercall Scr_AddContinueBlock(game::scriptInstance_t inst@, game::scr_block_s *block@) + NAKED void Scr_AddContinueBlock_stub() + { + _asm + { + push edi; + push eax; + call Scr_AddContinueBlock_call; + add esp, 0x8; + ret; + } + } + + void EmitWhileStatement_stub(game::scriptInstance_t inst, game::sval_u expr, game::sval_u stmt, game::sval_u sourcePos, game::sval_u whileSourcePos, game::scr_block_s* block, game::sval_u* whileStatBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitWhileStatement_hook.invoke(inst, expr, stmt, sourcePos, whileSourcePos, block, whileStatBlock); +#else + cscr_compiler::EmitWhileStatement(inst, expr, stmt, sourcePos, whileSourcePos, block, whileStatBlock); +#endif + } + + void Scr_CalcLocalVarsWhileStatement_stub(game::scriptInstance_t inst, game::sval_u expr, game::sval_u stmt, game::scr_block_s* block, game::sval_u* whileStatBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_CalcLocalVarsWhileStatement_hook.invoke(inst, expr, stmt, block, whileStatBlock); +#else + cscr_compiler::Scr_CalcLocalVarsWhileStatement(inst, expr, stmt, block, whileStatBlock); +#endif + } + + void EmitForStatement_stub(game::scriptInstance_t inst, game::sval_u stmt1, game::sval_u expr, game::sval_u stmt2, game::sval_u stmt, game::sval_u sourcePos, game::sval_u forSourcePos, game::scr_block_s* block, game::sval_u* forStatBlock, game::sval_u* forStatPostBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitForStatement_hook.invoke(inst, stmt1, expr, stmt2, stmt, sourcePos, forSourcePos, block, forStatBlock, forStatPostBlock); +#else + cscr_compiler::EmitForStatement(inst, stmt1, expr, stmt2, stmt, sourcePos, forSourcePos, block, forStatBlock, forStatPostBlock); +#endif + } + + void Scr_CalcLocalVarsForStatement_stub(game::scriptInstance_t inst, game::sval_u stmt1, game::sval_u expr, game::sval_u stmt2, game::sval_u stmt, game::scr_block_s* block, game::sval_u* forStatBlock, game::sval_u* forStatPostBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_CalcLocalVarsForStatement_hook.invoke(inst, stmt1, expr, stmt2, stmt, block, forStatBlock, forStatPostBlock); +#else + cscr_compiler::Scr_CalcLocalVarsForStatement(inst, stmt1, expr, stmt2, stmt, block, forStatBlock, forStatPostBlock); +#endif + } + + void EmitIncStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitIncStatement(block, inst, expr, sourcePos, EmitIncStatement_original); +#else + cscr_compiler::EmitIncStatement(block, inst, expr, sourcePos); +#endif + } + + // void __usercall EmitIncStatement(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitIncStatement_stub() + { + _asm + { + push edi; + push eax; + call EmitIncStatement_call; + add esp, 0x8; + ret; + } + } + + void EmitDecStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitDecStatement(block, inst, expr, sourcePos, EmitDecStatement_original); +#else + cscr_compiler::EmitDecStatement(block, inst, expr, sourcePos); +#endif + } + + // void __usercall EmitDecStatement(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitDecStatement_stub() + { + _asm + { + push edi; + push eax; + call EmitDecStatement_call; + add esp, 0x8; + ret; + } + } + + void Scr_CalcLocalVarsFormalParameterListInternal_call(game::sval_u* node, game::scr_block_s* block, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_CalcLocalVarsFormalParameterListInternal(node, block, Scr_CalcLocalVarsFormalParameterListInternal_original); +#else + cscr_compiler::Scr_CalcLocalVarsFormalParameterListInternal(node, block); +#endif + } + + // void __usercall Scr_CalcLocalVarsFormalParameterListInternal(game::sval_u *node@, game::scr_block_s *block@) + NAKED void Scr_CalcLocalVarsFormalParameterListInternal_stub() + { + _asm + { + push esi; + push eax; + call Scr_CalcLocalVarsFormalParameterListInternal_call; + add esp, 0x8; + ret; + } + } + + void EmitWaittillStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u obj, game::sval_u exprlist, game::sval_u sourcePos, game::sval_u waitSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitWaittillStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block, EmitWaittillStatement_original); +#else + cscr_compiler::EmitWaittillStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block); +#endif + } + + // void __usercall EmitWaittillStatement(game::scriptInstance_t inst@, game::sval_u obj, game::sval_u exprlist, game::sval_u sourcePos, game::sval_u waitSourcePos, game::scr_block_s *block) + NAKED void EmitWaittillStatement_stub() + { + _asm + { + push eax; + call EmitWaittillStatement_call; + add esp, 0x4; + ret; + } + } + + void EmitWaittillmatchStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u obj, game::sval_u exprlist, game::sval_u sourcePos, game::sval_u waitSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitWaittillmatchStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block, EmitWaittillmatchStatement_original); +#else + cscr_compiler::EmitWaittillmatchStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block); +#endif + } + + // void __usercall EmitWaittillmatchStatement(game::scriptInstance_t inst@, game::sval_u obj, game::sval_u exprlist, game::sval_u sourcePos, game::sval_u waitSourcePos, game::scr_block_s *block) + NAKED void EmitWaittillmatchStatement_stub() + { + _asm + { + push edi; + call EmitWaittillmatchStatement_call; + add esp, 0x4; + ret; + } + } + + void EmitNotifyStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u obj, game::sval_u exprlist, game::sval_u sourcePos, game::sval_u notifySourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitNotifyStatement(inst, obj, exprlist, sourcePos, notifySourcePos, block, EmitNotifyStatement_original); +#else + cscr_compiler::EmitNotifyStatement(inst, obj, exprlist, sourcePos, notifySourcePos, block); +#endif + } + + // void __usercall EmitNotifyStatement(game::scriptInstance_t inst@, game::sval_u obj, game::sval_u exprlist, game::sval_u sourcePos, game::sval_u notifySourcePos, game::scr_block_s *block) + NAKED void EmitNotifyStatement_stub() + { + _asm + { + push edi; + call EmitNotifyStatement_call; + add esp, 0x4; + ret; + } + } + + void EmitEndOnStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u obj, game::sval_u expr, game::sval_u sourcePos, game::sval_u exprSourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitEndOnStatement(block, inst, obj, expr, sourcePos, exprSourcePos, EmitEndOnStatement_original); +#else + cscr_compiler::EmitEndOnStatement(block, inst, obj, expr, sourcePos, exprSourcePos); +#endif + } + + // void __usercall EmitEndOnStatement(game::scr_block_s *block@, game::scriptInstance_t inst@, game::sval_u obj, game::sval_u expr, game::sval_u sourcePos, game::sval_u exprSourcePos) + NAKED void EmitEndOnStatement_stub() + { + _asm + { + push edi; + push eax; + call EmitEndOnStatement_call; + add esp, 0x8; + ret; + } + } + + int CompareCaseInfo_stub(const void* elem1, const void* elem2) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + return CompareCaseInfo_hook.invoke(elem1, elem2); +#else + return cscr_compiler::CompareCaseInfo(elem1, elem2); +#endif + } + + void EmitCaseStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCaseStatement(inst, expr, sourcePos, EmitCaseStatement_original); +#else + cscr_compiler::EmitCaseStatement(inst, expr, sourcePos); +#endif + } + + // void __usercall EmitCaseStatement(game::scriptInstance_t inst@, game::sval_u expr, game::sval_u sourcePos) + NAKED void EmitCaseStatement_stub() + { + _asm + { + push edi; + call EmitCaseStatement_call; + add esp, 0x4; + ret; + } + } + + void EmitSwitchStatementList_stub(game::scriptInstance_t inst, game::sval_u val, int lastStatement, unsigned int endSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitSwitchStatementList_hook.invoke(inst, val, lastStatement, endSourcePos, block); +#else + cscr_compiler::EmitSwitchStatementList(inst, val, lastStatement, endSourcePos, block); +#endif + } + + void Scr_CalcLocalVarsSwitchStatement_stub(game::scriptInstance_t inst, game::sval_u stmtlist, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_CalcLocalVarsSwitchStatement_hook.invoke(inst, stmtlist, block); +#else + cscr_compiler::Scr_CalcLocalVarsSwitchStatement(inst, stmtlist, block); +#endif + } + + void EmitSwitchStatement_stub(game::scriptInstance_t inst, game::sval_u expr, game::sval_u stmtlist, game::sval_u sourcePos, int lastStatement, unsigned int endSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitSwitchStatement_hook.invoke(inst, expr, stmtlist, sourcePos, lastStatement, endSourcePos, block); +#else + cscr_compiler::EmitSwitchStatement(inst, expr, stmtlist, sourcePos, lastStatement, endSourcePos, block); +#endif + } + + void EmitCaseStatementInfo_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int name, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitCaseStatementInfo(inst, name, sourcePos, EmitCaseStatementInfo_original); +#else + cscr_compiler::EmitCaseStatementInfo(inst, name, sourcePos); +#endif + } + + // void __usercall EmitCaseStatementInfo(game::scriptInstance_t inst@, unsigned int name, game::sval_u sourcePos) + NAKED void EmitCaseStatementInfo_stub() + { + _asm + { + push eax; + call EmitCaseStatementInfo_call; + add esp, 0x4; + ret; + } + } + + void EmitBreakStatement_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitBreakStatement(block, inst, sourcePos, EmitBreakStatement_original); +#else + cscr_compiler::EmitBreakStatement(block, inst, sourcePos); +#endif + } + + // void __usercall EmitBreakStatement(game::scr_block_s *block@, game::scriptInstance_t inst, game::sval_u sourcePos) + NAKED void EmitBreakStatement_stub() + { + _asm + { + push eax; + call EmitBreakStatement_call; + add esp, 0x4; + ret; + } + } + + void EmitContinueStatement_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u sourcePos) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitContinueStatement(block, inst, sourcePos, EmitContinueStatement_original); +#else + cscr_compiler::EmitContinueStatement(block, inst, sourcePos); +#endif + } + + // void __usercall EmitContinueStatement(game::scr_block_s *block@, game::scriptInstance_t inst, game::sval_u sourcePos) + NAKED void EmitContinueStatement_stub() + { + _asm + { + push eax; + call EmitContinueStatement_call; + add esp, 0x4; + ret; + } + } + + void EmitProfStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u profileName, game::sval_u sourcePos, game::OpcodeVM op) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitProfStatement(inst, profileName, sourcePos, op, EmitProfStatement_original); +#else + cscr_compiler::EmitProfStatement(inst, profileName, sourcePos, op); +#endif + } + + // void __usercall EmitProfStatement(game::scriptInstance_t inst@, game::sval_u profileName, game::sval_u sourcePos, game::OpcodeVM op) + NAKED void EmitProfStatement_stub() + { + _asm + { + push eax; + call EmitProfStatement_call; + add esp, 0x4; + ret; + } + } + + void EmitStatement_stub(game::scriptInstance_t inst, game::sval_u val, int lastStatement, unsigned int endSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitStatement_hook.invoke(inst, val, lastStatement, endSourcePos, block); +#else + cscr_compiler::EmitStatement(inst, val, lastStatement, endSourcePos, block); +#endif + } + + void Scr_CalcLocalVarsStatement_stub(game::scriptInstance_t inst, game::sval_u val, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_CalcLocalVarsStatement_hook.invoke(inst, val, block); +#else + cscr_compiler::Scr_CalcLocalVarsStatement(inst, val, block); +#endif + } + + void EmitStatementList_stub(game::scriptInstance_t inst, game::sval_u val, int lastStatement, unsigned int endSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitStatementList_hook.invoke(inst, val, lastStatement, endSourcePos, block); +#else + cscr_compiler::EmitStatementList(inst, val, lastStatement, endSourcePos, block); +#endif + } + + void Scr_CalcLocalVarsStatementList_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u val) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_CalcLocalVarsStatementList(block, inst, val, Scr_CalcLocalVarsStatementList_original); +#else + cscr_compiler::Scr_CalcLocalVarsStatementList(block, inst, val); +#endif + } + + // void __usercall Scr_CalcLocalVarsStatementList(game::scr_block_s *block@, game::scriptInstance_t inst, game::sval_u val) + NAKED void Scr_CalcLocalVarsStatementList_stub() + { + _asm + { + push edi; + call Scr_CalcLocalVarsStatementList_call; + add esp, 0x4; + ret; + } + } + + void Scr_CalcLocalVarsDeveloperStatementList_stub(game::scriptInstance_t inst, game::sval_u val, game::scr_block_s* block, game::sval_u* devStatBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + Scr_CalcLocalVarsDeveloperStatementList_hook.invoke(inst, val, block, devStatBlock); +#else + cscr_compiler::Scr_CalcLocalVarsDeveloperStatementList(inst, val, block, devStatBlock); +#endif + } + + void EmitDeveloperStatementList_stub(game::scriptInstance_t inst, game::sval_u val, game::sval_u sourcePos, game::scr_block_s* block, game::sval_u* devStatBlock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitDeveloperStatementList_hook.invoke(inst, val, sourcePos, block, devStatBlock); +#else + cscr_compiler::EmitDeveloperStatementList(inst, val, sourcePos, block, devStatBlock); +#endif + } + + void EmitFormalParameterList_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u exprlist, game::sval_u sourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitFormalParameterList(inst, exprlist, sourcePos, block, EmitFormalParameterList_original); +#else + cscr_compiler::EmitFormalParameterList(inst, exprlist, sourcePos, block); +#endif + } + + // void __usercall EmitFormalParameterList(game::scriptInstance_t inst@, game::sval_u exprlist, game::sval_u sourcePos, game::scr_block_s *block) + NAKED void EmitFormalParameterList_stub() + { + _asm + { + push eax; + call EmitFormalParameterList_call; + add esp, 0x4; + ret; + } + } + + void SpecifyThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::SpecifyThread(inst, val, SpecifyThread_original); +#else + cscr_compiler::SpecifyThread(inst, val); +#endif + } + + // void __usercall SpecifyThread(game::scriptInstance_t inst@, game::sval_u val) + NAKED void SpecifyThread_stub() + { + _asm + { + push eax; + call SpecifyThread_call; + add esp, 0x4; + ret; + } + } + + void EmitThreadInternal_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val, game::sval_u sourcePos, game::sval_u endSourcePos, game::scr_block_s* block) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitThreadInternal(inst, val, sourcePos, endSourcePos, block, EmitThreadInternal_original); +#else + cscr_compiler::EmitThreadInternal(inst, val, sourcePos, endSourcePos, block); +#endif + } + + // void __usercall EmitThreadInternal(game::scriptInstance_t inst@, game::sval_u val, game::sval_u sourcePos, game::sval_u endSourcePos, game::scr_block_s *block) + NAKED void EmitThreadInternal_stub() + { + _asm + { + push esi; + call EmitThreadInternal_call; + add esp, 0x4; + ret; + } + } + + void Scr_CalcLocalVarsThread_call(game::sval_u* stmttblock, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u exprlist, game::sval_u stmtlist) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::Scr_CalcLocalVarsThread(stmttblock, inst, exprlist, stmtlist, Scr_CalcLocalVarsThread_original); +#else + cscr_compiler::Scr_CalcLocalVarsThread(stmttblock, inst, exprlist, stmtlist); +#endif + } + + // void __usercall Scr_CalcLocalVarsThread(game::sval_u *stmttblock@, game::scriptInstance_t inst, game::sval_u exprlist, game::sval_u stmtlist) + NAKED void Scr_CalcLocalVarsThread_stub() + { + _asm + { + push eax; + call Scr_CalcLocalVarsThread_call; + add esp, 0x4; + ret; + } + } + + void InitThread_call(int type_, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::InitThread(type_, inst, InitThread_original); +#else + cscr_compiler::InitThread(type_, inst); +#endif + } + + // void __usercall InitThread(int type@, game::scriptInstance_t inst@) + NAKED void InitThread_stub() + { + _asm + { + push esi; + push ecx; + call InitThread_call; + add esp, 0x8; + ret; + } + } + + void EmitNormalThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val, game::sval_u* stmttblock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitNormalThread(inst, val, stmttblock, EmitNormalThread_original); +#else + cscr_compiler::EmitNormalThread(inst, val, stmttblock); +#endif + } + + // void __usercall EmitNormalThread(game::scriptInstance_t inst@, game::sval_u val, game::sval_u *stmttblock) + NAKED void EmitNormalThread_stub() + { + _asm + { + push eax; + call EmitNormalThread_call; + add esp, 0x4; + ret; + } + } + + void EmitDeveloperThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val, game::sval_u* stmttblock) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitDeveloperThread(inst, val, stmttblock, EmitDeveloperThread_original); +#else + cscr_compiler::EmitDeveloperThread(inst, val, stmttblock); +#endif + } + + // void __usercall EmitDeveloperThread(game::scriptInstance_t inst@, game::sval_u val, game::sval_u *stmttblock) + NAKED void EmitDeveloperThread_stub() + { + _asm + { + push eax; + call EmitDeveloperThread_call; + add esp, 0x4; + ret; + } + } + + void EmitThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitThread(inst, val, EmitThread_original); +#else + cscr_compiler::EmitThread(inst, val); +#endif + } + + // void __usercall EmitThread(game::scriptInstance_t inst@, game::sval_u val) + NAKED void EmitThread_stub() + { + _asm + { + push eax; + call EmitThread_call; + add esp, 0x4; + ret; + } + } + + void EmitThreadList_stub(game::scriptInstance_t inst, game::sval_u val) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + EmitThreadList_hook.invoke(inst, val); +#else + cscr_compiler::EmitThreadList(inst, val); +#endif + } + + void EmitInclude_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::EmitInclude(inst, val, EmitInclude_original); +#else + cscr_compiler::EmitInclude(inst, val); +#endif + } + + // void __usercall EmitInclude(game::scriptInstance_t inst@, game::sval_u val) + NAKED void EmitInclude_stub() + { + _asm + { + push eax; + call EmitInclude_call; + add esp, 0x4; + ret; + } + } + + void ScriptCompile_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, game::PrecacheEntry* entries, int entriesCount) + { +#ifdef RE_CSCR_COMPILER_USE_WRAPPERS + game::ScriptCompile(inst, val, filePosId, fileCountId, scriptId, entries, entriesCount, ScriptCompile_original); +#else + cscr_compiler::ScriptCompile(inst, val, filePosId, fileCountId, scriptId, entries, entriesCount); +#endif + } + + // void __usercall ScriptCompile(game::scriptInstance_t inst@, game::sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, game::PrecacheEntry *entries, int entriesCount) + NAKED void ScriptCompile_stub() + { + _asm + { + push eax; + call ScriptCompile_call; + add esp, 0x4; + ret; + } + } + } + + class component final : public component_interface + { + public: + void post_unpack() override + { + RemoveRefToValue_hook.create(game::RemoveRefToValue.get(), RemoveRefToValue_stub); + Scr_CompileRemoveRefToString_hook.create(game::Scr_CompileRemoveRefToString_ADDR(), Scr_CompileRemoveRefToString_stub); + EmitCanonicalString_hook.create(game::EmitCanonicalString_ADDR(), EmitCanonicalString_stub); + CompileTransferRefToString_hook.create(game::CompileTransferRefToString_ADDR(), CompileTransferRefToString_stub); + EmitOpcode_hook.create(game::EmitOpcode.get(), EmitOpcode_stub); + EmitEnd_hook.create(game::EmitEnd_ADDR(), EmitEnd_stub); + EmitReturn_hook.create(game::EmitReturn_ADDR(), EmitReturn_stub); + EmitCodepos_hook.create(game::EmitCodepos_ADDR(), EmitCodepos_stub); + EmitShort_hook.create(game::EmitShort_ADDR(), EmitShort_stub); + EmitByte_hook.create(game::EmitByte_ADDR(), EmitByte_stub); + EmitGetInteger_hook.create(game::EmitGetInteger_ADDR(), EmitGetInteger_stub); + EmitGetFloat_hook.create(game::EmitGetFloat_ADDR(), EmitGetFloat_stub); + EmitAnimTree_hook.create(game::EmitAnimTree_ADDR(), EmitAnimTree_stub); + Scr_FindLocalVarIndex_hook.create(game::Scr_FindLocalVarIndex.get(), Scr_FindLocalVarIndex_stub); + EmitCreateLocalVars_hook.create(game::EmitCreateLocalVars.get(), EmitCreateLocalVars_stub); + EmitRemoveLocalVars_hook.create(game::EmitRemoveLocalVars_ADDR(), EmitRemoveLocalVars_stub); + EmitNOP2_hook.create(game::EmitNOP2_ADDR(), EmitNOP2_stub); + Scr_InitFromChildBlocks_hook.create(game::Scr_InitFromChildBlocks.get(), Scr_InitFromChildBlocks_stub); + Scr_AppendChildBlocks_hook.create(game::Scr_AppendChildBlocks_ADDR(), Scr_AppendChildBlocks_stub); + Scr_MergeChildBlocks_hook.create(game::Scr_MergeChildBlocks.get(), Scr_MergeChildBlocks_stub); + Scr_TransferBlock_hook.create(game::Scr_TransferBlock_ADDR(), Scr_TransferBlock_stub); + EmitSafeSetVariableField_hook.create(game::EmitSafeSetVariableField_ADDR(), EmitSafeSetVariableField_stub); + EmitSafeSetWaittillVariableField_hook.create(game::EmitSafeSetWaittillVariableField_ADDR(), EmitSafeSetWaittillVariableField_stub); + EmitGetString_hook.create(game::EmitGetString_ADDR(), EmitGetString_stub); + EmitGetIString_hook.create(game::EmitGetIString_ADDR(), EmitGetIString_stub); + EmitGetVector_hook.create(game::EmitGetVector_ADDR(), EmitGetVector_stub); + EmitValue_hook.create(game::EmitValue.get(), EmitValue_stub); + Scr_PushValue_hook.create(game::Scr_PushValue_ADDR(), Scr_PushValue_stub); + EmitCastBool_hook.create(game::EmitCastBool_ADDR(), EmitCastBool_stub); + EmitBoolNot_hook.create(game::EmitBoolNot_ADDR(), EmitBoolNot_stub); + EmitBoolComplement_hook.create(game::EmitBoolComplement_ADDR(), EmitBoolComplement_stub); + EmitSize_hook.create(game::EmitSize_ADDR(), EmitSize_stub); + EmitSelf_hook.create(game::EmitSelf_ADDR(), EmitSelf_stub); + EmitLevel_hook.create(game::EmitLevel_ADDR(), EmitLevel_stub); + EmitGame_hook.create(game::EmitGame_ADDR(), EmitGame_stub); + EmitAnim_hook.create(game::EmitAnim_ADDR(), EmitAnim_stub); + EmitSelfObject_hook.create(game::EmitSelfObject_ADDR(), EmitSelfObject_stub); + EmitLevelObject_hook.create(game::EmitLevelObject_ADDR(), EmitLevelObject_stub); + EmitAnimObject_hook.create(game::EmitAnimObject_ADDR(), EmitAnimObject_stub); + EmitLocalVariable_hook.create(game::EmitLocalVariable_ADDR(), EmitLocalVariable_stub); + EmitLocalVariableRef_hook.create(game::EmitLocalVariableRef_ADDR(), EmitLocalVariableRef_stub); + Scr_RegisterLocalVar_hook.create(game::Scr_RegisterLocalVar.get(), Scr_RegisterLocalVar_stub); + EmitGameRef_hook.create(game::EmitGameRef_ADDR(), EmitGameRef_stub); + EmitClearArray_hook.create(game::EmitClearArray_ADDR(), EmitClearArray_stub); + EmitEmptyArray_hook.create(game::EmitEmptyArray_ADDR(), EmitEmptyArray_stub); + EmitAnimation_hook.create(game::EmitAnimation_ADDR(), EmitAnimation_stub); + EmitFieldVariable_hook.create(game::EmitFieldVariable_ADDR(), EmitFieldVariable_stub); + EmitFieldVariableRef_hook.create(game::EmitFieldVariableRef_ADDR(), EmitFieldVariableRef_stub); + EmitObject_hook.create(game::EmitObject_ADDR(), EmitObject_stub); + EmitDecTop_hook.create(game::EmitDecTop_ADDR(), EmitDecTop_stub); + EmitCastFieldObject_hook.create(game::EmitCastFieldObject.get(), EmitCastFieldObject_stub); + EmitArrayVariable_hook.create(game::EmitArrayVariable_ADDR(), EmitArrayVariable_stub); + EmitArrayVariableRef_hook.create(game::EmitArrayVariableRef_ADDR(), EmitArrayVariableRef_stub); + EmitClearArrayVariable_hook.create(game::EmitClearArrayVariable_ADDR(), EmitClearArrayVariable_stub); + EmitVariableExpression_hook.create(game::EmitVariableExpression.get(), EmitVariableExpression_stub); + EmitExpressionList_hook.create(game::EmitExpressionList.get(), EmitExpressionList_stub); + AddExpressionListOpcodePos_hook.create(game::AddExpressionListOpcodePos_ADDR(), AddExpressionListOpcodePos_stub); + AddFilePrecache_hook.create(game::AddFilePrecache_ADDR(), AddFilePrecache_stub); + EmitFunction_hook.create(game::EmitFunction_ADDR(), EmitFunction_stub); + EmitGetFunction_hook.create(game::EmitGetFunction_ADDR(), EmitGetFunction_stub); + AddFunction_hook.create(game::AddFunction.get(), AddFunction_stub); + EmitPostScriptFunction_hook.create(game::EmitPostScriptFunction.get(), EmitPostScriptFunction_stub); + EmitPostScriptFunctionPointer_hook.create(game::EmitPostScriptFunctionPointer_ADDR(), EmitPostScriptFunctionPointer_stub); + EmitPostScriptThread_hook.create(game::EmitPostScriptThread_ADDR(), EmitPostScriptThread_stub); + EmitPostScriptThreadPointer_hook.create(game::EmitPostScriptThreadPointer_ADDR(), EmitPostScriptThreadPointer_stub); + EmitPostScriptFunctionCall_hook.create(game::EmitPostScriptFunctionCall_ADDR(), EmitPostScriptFunctionCall_stub); + EmitPostScriptThreadCall_hook.create(game::EmitPostScriptThreadCall_ADDR(), EmitPostScriptThreadCall_stub); + EmitPreFunctionCall_hook.create(game::EmitPreFunctionCall_ADDR(), EmitPreFunctionCall_stub); + EmitPostFunctionCall_hook.create(game::EmitPostFunctionCall_ADDR(), EmitPostFunctionCall_stub); + Scr_BeginDevScript_hook.create(game::Scr_BeginDevScript_ADDR(), Scr_BeginDevScript_stub); + Scr_EndDevScript_hook.create(game::Scr_EndDevScript_ADDR(), Scr_EndDevScript_stub); + EmitCallBuiltinOpcode_hook.create(game::EmitCallBuiltinOpcode_ADDR(), EmitCallBuiltinOpcode_stub); + EmitCallBuiltinMethodOpcode_hook.create(game::EmitCallBuiltinMethodOpcode_ADDR(), EmitCallBuiltinMethodOpcode_stub); + EmitCall_hook.create(game::EmitCall_ADDR(), EmitCall_stub); + EmitMethod_hook.create(game::EmitMethod.get(), EmitMethod_stub); + LinkThread_hook.create(game::LinkThread_ADDR(), LinkThread_stub); + LinkFile_hook.create(game::LinkFile_ADDR(), LinkFile_stub); + CheckThreadPosition_hook.create(game::CheckThreadPosition.get(), CheckThreadPosition_stub); + EmitCallExpression_hook.create(game::EmitCallExpression_ADDR(), EmitCallExpression_stub); + EmitCallExpressionFieldObject_hook.create(game::EmitCallExpressionFieldObject_ADDR(), EmitCallExpressionFieldObject_stub); + Scr_CreateVector_hook.create(game::Scr_CreateVector_ADDR(), Scr_CreateVector_stub); + EvalPrimitiveExpressionList_hook.create(game::EvalPrimitiveExpressionList.get(), EvalPrimitiveExpressionList_stub); + EmitOrEvalPrimitiveExpressionList_hook.create(game::EmitOrEvalPrimitiveExpressionList_ADDR(), EmitOrEvalPrimitiveExpressionList_stub); + EmitExpressionListFieldObject_hook.create(game::EmitExpressionListFieldObject_ADDR(), EmitExpressionListFieldObject_stub); + EvalPrimitiveExpression_hook.create(game::EvalPrimitiveExpression.get(), EvalPrimitiveExpression_stub); + EmitOrEvalPrimitiveExpression_hook.create(game::EmitOrEvalPrimitiveExpression.get(), EmitOrEvalPrimitiveExpression_stub); + EmitBoolOrExpression_hook.create(game::EmitBoolOrExpression_ADDR(), EmitBoolOrExpression_stub); + EmitBoolAndExpression_hook.create(game::EmitBoolAndExpression_ADDR(), EmitBoolAndExpression_stub); + EvalBinaryOperatorExpression_hook.create(game::EvalBinaryOperatorExpression.get(), EvalBinaryOperatorExpression_stub); + EmitOrEvalBinaryOperatorExpression_hook.create(game::EmitOrEvalBinaryOperatorExpression_ADDR(), EmitOrEvalBinaryOperatorExpression_stub); + EmitBinaryEqualsOperatorExpression_hook.create(game::EmitBinaryEqualsOperatorExpression_ADDR(), EmitBinaryEqualsOperatorExpression_stub); + Scr_CalcLocalVarsVariableExpressionRef_hook.create(game::Scr_CalcLocalVarsVariableExpressionRef_ADDR(), Scr_CalcLocalVarsVariableExpressionRef_stub); + EvalExpression_hook.create(game::EvalExpression_ADDR(), EvalExpression_stub); + EmitOrEvalExpression_hook.create(game::EmitOrEvalExpression.get(), EmitOrEvalExpression_stub); + EmitExpression_hook.create(game::EmitExpression.get(), EmitExpression_stub); + EmitVariableExpressionRef_hook.create(game::EmitVariableExpressionRef.get(), EmitVariableExpressionRef_stub); + EmitArrayPrimitiveExpressionRef_hook.create(game::EmitArrayPrimitiveExpressionRef_ADDR(), EmitArrayPrimitiveExpressionRef_stub); + Scr_CalcLocalVarsArrayVariableRef_hook.create(game::Scr_CalcLocalVarsArrayVariableRef.get(), Scr_CalcLocalVarsArrayVariableRef_stub); + EmitPrimitiveExpressionFieldObject_hook.create(game::EmitPrimitiveExpressionFieldObject.get(), EmitPrimitiveExpressionFieldObject_stub); + ConnectBreakStatements_hook.create(game::ConnectBreakStatements_ADDR(), ConnectBreakStatements_stub); + ConnectContinueStatements_hook.create(game::ConnectContinueStatements_ADDR(), ConnectContinueStatements_stub); + EmitClearVariableExpression_hook.create(game::EmitClearVariableExpression_ADDR(), EmitClearVariableExpression_stub); + EmitAssignmentStatement_hook.create(game::EmitAssignmentStatement_ADDR(), EmitAssignmentStatement_stub); + EmitCallExpressionStatement_hook.create(game::EmitCallExpressionStatement_ADDR(), EmitCallExpressionStatement_stub); + EmitReturnStatement_hook.create(game::EmitReturnStatement_ADDR(), EmitReturnStatement_stub); + EmitWaitStatement_hook.create(game::EmitWaitStatement_ADDR(), EmitWaitStatement_stub); + EmitWaittillFrameEnd_hook.create(game::EmitWaittillFrameEnd_ADDR(), EmitWaittillFrameEnd_stub); + EmitIfStatement_hook.create(game::EmitIfStatement_ADDR(), EmitIfStatement_stub); + Scr_CalcLocalVarsIfStatement_hook.create(game::Scr_CalcLocalVarsIfStatement.get(), Scr_CalcLocalVarsIfStatement_stub); + EmitIfElseStatement_hook.create(game::EmitIfElseStatement.get(), EmitIfElseStatement_stub); + Scr_CalcLocalVarsIfElseStatement_hook.create(game::Scr_CalcLocalVarsIfElseStatement.get(), Scr_CalcLocalVarsIfElseStatement_stub); + Scr_AddBreakBlock_hook.create(game::Scr_AddBreakBlock_ADDR(), Scr_AddBreakBlock_stub); + Scr_AddContinueBlock_hook.create(game::Scr_AddContinueBlock_ADDR(), Scr_AddContinueBlock_stub); + EmitWhileStatement_hook.create(game::EmitWhileStatement.get(), EmitWhileStatement_stub); + Scr_CalcLocalVarsWhileStatement_hook.create(game::Scr_CalcLocalVarsWhileStatement.get(), Scr_CalcLocalVarsWhileStatement_stub); + EmitForStatement_hook.create(game::EmitForStatement.get(), EmitForStatement_stub); + Scr_CalcLocalVarsForStatement_hook.create(game::Scr_CalcLocalVarsForStatement.get(), Scr_CalcLocalVarsForStatement_stub); + EmitIncStatement_hook.create(game::EmitIncStatement_ADDR(), EmitIncStatement_stub); + EmitDecStatement_hook.create(game::EmitDecStatement_ADDR(), EmitDecStatement_stub); + Scr_CalcLocalVarsFormalParameterListInternal_hook.create(game::Scr_CalcLocalVarsFormalParameterListInternal_ADDR(), Scr_CalcLocalVarsFormalParameterListInternal_stub); + EmitWaittillStatement_hook.create(game::EmitWaittillStatement_ADDR(), EmitWaittillStatement_stub); + EmitWaittillmatchStatement_hook.create(game::EmitWaittillmatchStatement_ADDR(), EmitWaittillmatchStatement_stub); + EmitNotifyStatement_hook.create(game::EmitNotifyStatement_ADDR(), EmitNotifyStatement_stub); + EmitEndOnStatement_hook.create(game::EmitEndOnStatement_ADDR(), EmitEndOnStatement_stub); + CompareCaseInfo_hook.create(game::CompareCaseInfo.get(), CompareCaseInfo_stub); + EmitCaseStatement_hook.create(game::EmitCaseStatement_ADDR(), EmitCaseStatement_stub); + EmitSwitchStatementList_hook.create(game::EmitSwitchStatementList.get(), EmitSwitchStatementList_stub); + Scr_CalcLocalVarsSwitchStatement_hook.create(game::Scr_CalcLocalVarsSwitchStatement.get(), Scr_CalcLocalVarsSwitchStatement_stub); + EmitSwitchStatement_hook.create(game::EmitSwitchStatement.get(), EmitSwitchStatement_stub); + EmitCaseStatementInfo_hook.create(game::EmitCaseStatementInfo_ADDR(), EmitCaseStatementInfo_stub); + EmitBreakStatement_hook.create(game::EmitBreakStatement_ADDR(), EmitBreakStatement_stub); + EmitContinueStatement_hook.create(game::EmitContinueStatement_ADDR(), EmitContinueStatement_stub); + EmitProfStatement_hook.create(game::EmitProfStatement_ADDR(), EmitProfStatement_stub); + EmitStatement_hook.create(game::EmitStatement.get(), EmitStatement_stub); + Scr_CalcLocalVarsStatement_hook.create(game::Scr_CalcLocalVarsStatement.get(), Scr_CalcLocalVarsStatement_stub); + EmitStatementList_hook.create(game::EmitStatementList.get(), EmitStatementList_stub); + Scr_CalcLocalVarsStatementList_hook.create(game::Scr_CalcLocalVarsStatementList_ADDR(), Scr_CalcLocalVarsStatementList_stub); + Scr_CalcLocalVarsDeveloperStatementList_hook.create(game::Scr_CalcLocalVarsDeveloperStatementList.get(), Scr_CalcLocalVarsDeveloperStatementList_stub); + EmitDeveloperStatementList_hook.create(game::EmitDeveloperStatementList.get(), EmitDeveloperStatementList_stub); + EmitFormalParameterList_hook.create(game::EmitFormalParameterList_ADDR(), EmitFormalParameterList_stub); + SpecifyThread_hook.create(game::SpecifyThread_ADDR(), SpecifyThread_stub); + EmitThreadInternal_hook.create(game::EmitThreadInternal_ADDR(), EmitThreadInternal_stub); + Scr_CalcLocalVarsThread_hook.create(game::Scr_CalcLocalVarsThread_ADDR(), Scr_CalcLocalVarsThread_stub); + InitThread_hook.create(game::InitThread_ADDR(), InitThread_stub); + EmitNormalThread_hook.create(game::EmitNormalThread_ADDR(), EmitNormalThread_stub); + EmitDeveloperThread_hook.create(game::EmitDeveloperThread_ADDR(), EmitDeveloperThread_stub); + EmitThread_hook.create(game::EmitThread_ADDR(), EmitThread_stub); + EmitThreadList_hook.create(game::EmitThreadList.get(), EmitThreadList_stub); + EmitInclude_hook.create(game::EmitInclude_ADDR(), EmitInclude_stub); + ScriptCompile_hook.create(game::ScriptCompile_ADDR(), ScriptCompile_stub); + + //Original hook function addresses + RemoveRefToValue_original = RemoveRefToValue_hook.get_original(); + Scr_CompileRemoveRefToString_original = Scr_CompileRemoveRefToString_hook.get_original(); + EmitCanonicalString_original = EmitCanonicalString_hook.get_original(); + CompileTransferRefToString_original = CompileTransferRefToString_hook.get_original(); + EmitOpcode_original = EmitOpcode_hook.get_original(); + EmitEnd_original = EmitEnd_hook.get_original(); + EmitReturn_original = EmitReturn_hook.get_original(); + EmitCodepos_original = EmitCodepos_hook.get_original(); + EmitShort_original = EmitShort_hook.get_original(); + EmitByte_original = EmitByte_hook.get_original(); + EmitGetInteger_original = EmitGetInteger_hook.get_original(); + EmitGetFloat_original = EmitGetFloat_hook.get_original(); + EmitAnimTree_original = EmitAnimTree_hook.get_original(); + Scr_FindLocalVarIndex_original = Scr_FindLocalVarIndex_hook.get_original(); + EmitCreateLocalVars_original = EmitCreateLocalVars_hook.get_original(); + EmitRemoveLocalVars_original = EmitRemoveLocalVars_hook.get_original(); + EmitNOP2_original = EmitNOP2_hook.get_original(); + Scr_InitFromChildBlocks_original = Scr_InitFromChildBlocks_hook.get_original(); + Scr_AppendChildBlocks_original = Scr_AppendChildBlocks_hook.get_original(); + Scr_MergeChildBlocks_original = Scr_MergeChildBlocks_hook.get_original(); + Scr_TransferBlock_original = Scr_TransferBlock_hook.get_original(); + EmitSafeSetVariableField_original = EmitSafeSetVariableField_hook.get_original(); + EmitSafeSetWaittillVariableField_original = EmitSafeSetWaittillVariableField_hook.get_original(); + EmitGetString_original = EmitGetString_hook.get_original(); + EmitGetIString_original = EmitGetIString_hook.get_original(); + EmitGetVector_original = EmitGetVector_hook.get_original(); + EmitValue_original = EmitValue_hook.get_original(); + Scr_PushValue_original = Scr_PushValue_hook.get_original(); + EmitCastBool_original = EmitCastBool_hook.get_original(); + EmitBoolNot_original = EmitBoolNot_hook.get_original(); + EmitBoolComplement_original = EmitBoolComplement_hook.get_original(); + EmitSize_original = EmitSize_hook.get_original(); + EmitSelf_original = EmitSelf_hook.get_original(); + EmitLevel_original = EmitLevel_hook.get_original(); + EmitGame_original = EmitGame_hook.get_original(); + EmitAnim_original = EmitAnim_hook.get_original(); + EmitSelfObject_original = EmitSelfObject_hook.get_original(); + EmitLevelObject_original = EmitLevelObject_hook.get_original(); + EmitAnimObject_original = EmitAnimObject_hook.get_original(); + EmitLocalVariable_original = EmitLocalVariable_hook.get_original(); + EmitLocalVariableRef_original = EmitLocalVariableRef_hook.get_original(); + Scr_RegisterLocalVar_original = Scr_RegisterLocalVar_hook.get_original(); + EmitGameRef_original = EmitGameRef_hook.get_original(); + EmitClearArray_original = EmitClearArray_hook.get_original(); + EmitEmptyArray_original = EmitEmptyArray_hook.get_original(); + EmitAnimation_original = EmitAnimation_hook.get_original(); + EmitFieldVariable_original = EmitFieldVariable_hook.get_original(); + EmitFieldVariableRef_original = EmitFieldVariableRef_hook.get_original(); + EmitObject_original = EmitObject_hook.get_original(); + EmitDecTop_original = EmitDecTop_hook.get_original(); + EmitCastFieldObject_original = EmitCastFieldObject_hook.get_original(); + EmitArrayVariable_original = EmitArrayVariable_hook.get_original(); + EmitArrayVariableRef_original = EmitArrayVariableRef_hook.get_original(); + EmitClearArrayVariable_original = EmitClearArrayVariable_hook.get_original(); + EmitVariableExpression_original = EmitVariableExpression_hook.get_original(); + EmitExpressionList_original = EmitExpressionList_hook.get_original(); + AddExpressionListOpcodePos_original = AddExpressionListOpcodePos_hook.get_original(); + AddFilePrecache_original = AddFilePrecache_hook.get_original(); + EmitFunction_original = EmitFunction_hook.get_original(); + EmitGetFunction_original = EmitGetFunction_hook.get_original(); + AddFunction_original = AddFunction_hook.get_original(); + EmitPostScriptFunction_original = EmitPostScriptFunction_hook.get_original(); + EmitPostScriptFunctionPointer_original = EmitPostScriptFunctionPointer_hook.get_original(); + EmitPostScriptThread_original = EmitPostScriptThread_hook.get_original(); + EmitPostScriptThreadPointer_original = EmitPostScriptThreadPointer_hook.get_original(); + EmitPostScriptFunctionCall_original = EmitPostScriptFunctionCall_hook.get_original(); + EmitPostScriptThreadCall_original = EmitPostScriptThreadCall_hook.get_original(); + EmitPreFunctionCall_original = EmitPreFunctionCall_hook.get_original(); + EmitPostFunctionCall_original = EmitPostFunctionCall_hook.get_original(); + Scr_BeginDevScript_original = Scr_BeginDevScript_hook.get_original(); + Scr_EndDevScript_original = Scr_EndDevScript_hook.get_original(); + EmitCallBuiltinOpcode_original = EmitCallBuiltinOpcode_hook.get_original(); + EmitCallBuiltinMethodOpcode_original = EmitCallBuiltinMethodOpcode_hook.get_original(); + EmitCall_original = EmitCall_hook.get_original(); + EmitMethod_original = EmitMethod_hook.get_original(); + LinkThread_original = LinkThread_hook.get_original(); + LinkFile_original = LinkFile_hook.get_original(); + CheckThreadPosition_original = CheckThreadPosition_hook.get_original(); + EmitCallExpression_original = EmitCallExpression_hook.get_original(); + EmitCallExpressionFieldObject_original = EmitCallExpressionFieldObject_hook.get_original(); + Scr_CreateVector_original = Scr_CreateVector_hook.get_original(); + EvalPrimitiveExpressionList_original = EvalPrimitiveExpressionList_hook.get_original(); + EmitOrEvalPrimitiveExpressionList_original = EmitOrEvalPrimitiveExpressionList_hook.get_original(); + EmitExpressionListFieldObject_original = EmitExpressionListFieldObject_hook.get_original(); + EvalPrimitiveExpression_original = EvalPrimitiveExpression_hook.get_original(); + EmitOrEvalPrimitiveExpression_original = EmitOrEvalPrimitiveExpression_hook.get_original(); + EmitBoolOrExpression_original = EmitBoolOrExpression_hook.get_original(); + EmitBoolAndExpression_original = EmitBoolAndExpression_hook.get_original(); + EvalBinaryOperatorExpression_original = EvalBinaryOperatorExpression_hook.get_original(); + EmitOrEvalBinaryOperatorExpression_original = EmitOrEvalBinaryOperatorExpression_hook.get_original(); + EmitBinaryEqualsOperatorExpression_original = EmitBinaryEqualsOperatorExpression_hook.get_original(); + Scr_CalcLocalVarsVariableExpressionRef_original = Scr_CalcLocalVarsVariableExpressionRef_hook.get_original(); + EvalExpression_original = EvalExpression_hook.get_original(); + EmitOrEvalExpression_original = EmitOrEvalExpression_hook.get_original(); + EmitExpression_original = EmitExpression_hook.get_original(); + EmitVariableExpressionRef_original = EmitVariableExpressionRef_hook.get_original(); + EmitArrayPrimitiveExpressionRef_original = EmitArrayPrimitiveExpressionRef_hook.get_original(); + Scr_CalcLocalVarsArrayVariableRef_original = Scr_CalcLocalVarsArrayVariableRef_hook.get_original(); + EmitPrimitiveExpressionFieldObject_original = EmitPrimitiveExpressionFieldObject_hook.get_original(); + ConnectBreakStatements_original = ConnectBreakStatements_hook.get_original(); + ConnectContinueStatements_original = ConnectContinueStatements_hook.get_original(); + EmitClearVariableExpression_original = EmitClearVariableExpression_hook.get_original(); + EmitAssignmentStatement_original = EmitAssignmentStatement_hook.get_original(); + EmitCallExpressionStatement_original = EmitCallExpressionStatement_hook.get_original(); + EmitReturnStatement_original = EmitReturnStatement_hook.get_original(); + EmitWaitStatement_original = EmitWaitStatement_hook.get_original(); + EmitWaittillFrameEnd_original = EmitWaittillFrameEnd_hook.get_original(); + EmitIfStatement_original = EmitIfStatement_hook.get_original(); + Scr_CalcLocalVarsIfStatement_original = Scr_CalcLocalVarsIfStatement_hook.get_original(); + EmitIfElseStatement_original = EmitIfElseStatement_hook.get_original(); + Scr_CalcLocalVarsIfElseStatement_original = Scr_CalcLocalVarsIfElseStatement_hook.get_original(); + Scr_AddBreakBlock_original = Scr_AddBreakBlock_hook.get_original(); + Scr_AddContinueBlock_original = Scr_AddContinueBlock_hook.get_original(); + EmitWhileStatement_original = EmitWhileStatement_hook.get_original(); + Scr_CalcLocalVarsWhileStatement_original = Scr_CalcLocalVarsWhileStatement_hook.get_original(); + EmitForStatement_original = EmitForStatement_hook.get_original(); + Scr_CalcLocalVarsForStatement_original = Scr_CalcLocalVarsForStatement_hook.get_original(); + EmitIncStatement_original = EmitIncStatement_hook.get_original(); + EmitDecStatement_original = EmitDecStatement_hook.get_original(); + Scr_CalcLocalVarsFormalParameterListInternal_original = Scr_CalcLocalVarsFormalParameterListInternal_hook.get_original(); + EmitWaittillStatement_original = EmitWaittillStatement_hook.get_original(); + EmitWaittillmatchStatement_original = EmitWaittillmatchStatement_hook.get_original(); + EmitNotifyStatement_original = EmitNotifyStatement_hook.get_original(); + EmitEndOnStatement_original = EmitEndOnStatement_hook.get_original(); + CompareCaseInfo_original = CompareCaseInfo_hook.get_original(); + EmitCaseStatement_original = EmitCaseStatement_hook.get_original(); + EmitSwitchStatementList_original = EmitSwitchStatementList_hook.get_original(); + Scr_CalcLocalVarsSwitchStatement_original = Scr_CalcLocalVarsSwitchStatement_hook.get_original(); + EmitSwitchStatement_original = EmitSwitchStatement_hook.get_original(); + EmitCaseStatementInfo_original = EmitCaseStatementInfo_hook.get_original(); + EmitBreakStatement_original = EmitBreakStatement_hook.get_original(); + EmitContinueStatement_original = EmitContinueStatement_hook.get_original(); + EmitProfStatement_original = EmitProfStatement_hook.get_original(); + EmitStatement_original = EmitStatement_hook.get_original(); + Scr_CalcLocalVarsStatement_original = Scr_CalcLocalVarsStatement_hook.get_original(); + EmitStatementList_original = EmitStatementList_hook.get_original(); + Scr_CalcLocalVarsStatementList_original = Scr_CalcLocalVarsStatementList_hook.get_original(); + Scr_CalcLocalVarsDeveloperStatementList_original = Scr_CalcLocalVarsDeveloperStatementList_hook.get_original(); + EmitDeveloperStatementList_original = EmitDeveloperStatementList_hook.get_original(); + EmitFormalParameterList_original = EmitFormalParameterList_hook.get_original(); + SpecifyThread_original = SpecifyThread_hook.get_original(); + EmitThreadInternal_original = EmitThreadInternal_hook.get_original(); + Scr_CalcLocalVarsThread_original = Scr_CalcLocalVarsThread_hook.get_original(); + InitThread_original = InitThread_hook.get_original(); + EmitNormalThread_original = EmitNormalThread_hook.get_original(); + EmitDeveloperThread_original = EmitDeveloperThread_hook.get_original(); + EmitThread_original = EmitThread_hook.get_original(); + EmitThreadList_original = EmitThreadList_hook.get_original(); + EmitInclude_original = EmitInclude_hook.get_original(); + ScriptCompile_original = ScriptCompile_hook.get_original(); + } + + private: + }; +} +REGISTER_COMPONENT(re_cscr_compiler::component) diff --git a/src/game/clientscript/clientscript_public.hpp b/src/game/clientscript/clientscript_public.hpp index d934a3e..b8755b8 100644 --- a/src/game/clientscript/clientscript_public.hpp +++ b/src/game/clientscript/clientscript_public.hpp @@ -2253,6 +2253,7 @@ namespace game WEAK symbol loadedImpureScript{ 0x0, 0x22C1352 }; WEAK symbol sv_clientside{ 0x0, 0x3882B6C }; WEAK symbol error_message_buff{ 0x0, 0x3BE1E30 }; + WEAK symbol gScrCompileGlob{ 0x0, 0x3701FE0 }; WEAK symbol g_parse_user{ 0x0, 0x234F72E }; WEAK symbol gInst{ 0x0, 0x3BE624C }; @@ -2294,14 +2295,11 @@ namespace game #pragma endregion #pragma region "functions" - WEAK symbolRemoveRefToValue{ 0x0, 0x67EB70 }; WEAK symbol_setjmp3{ 0x0, 0x7E1894 }; WEAK symbollongjmp{ 0x0, 0x7AD57C }; inline void* ScriptParse_ADDR() { return CALL_ADDR(0x0, 0x69D710); } void ScriptParse(scriptInstance_t inst, sval_u* parseData, void* call_addr = ScriptParse_ADDR()); - inline void* ScriptCompile_ADDR() { return CALL_ADDR(0x0, 0x688E70); } - void ScriptCompile(scriptInstance_t inst, sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry * entries, int entriesCount, void* call_addr = ScriptCompile_ADDR()); inline void* Scr_LoadAnimTreeAtIndex_ADDR() { return CALL_ADDR(0x0, 0x67E7D0); } void Scr_LoadAnimTreeAtIndex(scriptInstance_t inst, int user, unsigned int index, void* (__cdecl* Alloc)(int), int modCheckSum, void* call_addr = Scr_LoadAnimTreeAtIndex_ADDR()); @@ -2325,4 +2323,5 @@ namespace game #include "cscr_tempmemory.hpp" #include "cscr_variable.hpp" #include "cscr_vm.hpp" +#include "cscr_compiler.hpp" #endif diff --git a/src/game/clientscript/clientscript_public_w.cpp b/src/game/clientscript/clientscript_public_w.cpp index 27e228e..6fd0242 100644 --- a/src/game/clientscript/clientscript_public_w.cpp +++ b/src/game/clientscript/clientscript_public_w.cpp @@ -14,23 +14,6 @@ namespace game } } - // void __usercall ScriptCompile(scriptInstance_t inst@, sval_u a2, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry *entries, int entriesCount) - void ScriptCompile(scriptInstance_t inst, sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry * entries, int entriesCount, void* call_addr) - { - __asm - { - push entriesCount; - push entries; - push scriptId; - push fileCountId; - push filePosId; - push val; - mov eax, inst; - call call_addr; - add esp, 0x18; - } - } - // void __usercall Scr_LoadAnimTreeAtIndex(scriptInstance_t inst@, int a2@, int a3, int (__cdecl *a4)(int), int a5) void Scr_LoadAnimTreeAtIndex(scriptInstance_t inst, int user, unsigned int index, void* (__cdecl* Alloc)(int), int modCheckSum, void* call_addr) { diff --git a/src/game/clientscript/cscr_compiler.hpp b/src/game/clientscript/cscr_compiler.hpp new file mode 100644 index 0000000..2e1768f --- /dev/null +++ b/src/game/clientscript/cscr_compiler.hpp @@ -0,0 +1,265 @@ +#pragma once + +namespace game +{ + WEAK symbolRemoveRefToValue{ 0x0, 0x67EB70 }; + WEAK symbolEmitOpcode{ 0x0, 0x67ECA0 }; + WEAK symbolScr_FindLocalVarIndex{ 0x0, 0x67F500 }; + WEAK symbolEmitCreateLocalVars{ 0x0, 0x67F730 }; + WEAK symbolScr_InitFromChildBlocks{ 0x0, 0x67FA00 }; + WEAK symbolScr_MergeChildBlocks{ 0x0, 0x67FB80 }; + WEAK symbolEmitValue{ 0x0, 0x680050 }; + WEAK symbolScr_RegisterLocalVar{ 0x0, 0x680D10 }; + WEAK symbolEmitCastFieldObject{ 0x0, 0x681720 }; + WEAK symbolEmitVariableExpression{ 0x0, 0x681990 }; + WEAK symbolEmitExpressionList{ 0x0, 0x681AD0 }; + WEAK symbolAddFunction{ 0x0, 0x682040 }; + WEAK symbolEmitPostScriptFunction{ 0x0, 0x6820B0 }; + WEAK symbolEmitMethod{ 0x0, 0x682F40 }; + WEAK symbolCheckThreadPosition{ 0x0, 0x683580 }; + WEAK symbolEvalPrimitiveExpressionList{ 0x0, 0x6837C0 }; + WEAK symbolEvalPrimitiveExpression{ 0x0, 0x683B50 }; + WEAK symbolEmitOrEvalPrimitiveExpression{ 0x0, 0x683CF0 }; + WEAK symbolEvalBinaryOperatorExpression{ 0x0, 0x684220 }; + WEAK symbolEmitOrEvalExpression{ 0x0, 0x684590 }; + WEAK symbolEmitExpression{ 0x0, 0x684750 }; + WEAK symbolScr_CalcLocalVarsArrayVariableRef{ 0x0, 0x684950 }; + WEAK symbolEmitPrimitiveExpressionFieldObject{ 0x0, 0x6849A0 }; + WEAK symbolScr_CalcLocalVarsIfStatement{ 0x0, 0x685170 }; + WEAK symbolEmitIfElseStatement{ 0x0, 0x6851D0 }; + WEAK symbolScr_CalcLocalVarsIfElseStatement{ 0x0, 0x685590 }; + WEAK symbolEmitWhileStatement{ 0x0, 0x685760 }; + WEAK symbolScr_CalcLocalVarsWhileStatement{ 0x0, 0x685C30 }; + WEAK symbolEmitForStatement{ 0x0, 0x685DF0 }; + WEAK symbolScr_CalcLocalVarsForStatement{ 0x0, 0x686330 }; + WEAK symbolCompareCaseInfo{ 0x0, 0x6870E0 }; + WEAK symbolEmitSwitchStatementList{ 0x0, 0x6871A0 }; + WEAK symbolScr_CalcLocalVarsSwitchStatement{ 0x0, 0x6873D0 }; + WEAK symbolEmitSwitchStatement{ 0x0, 0x6875F0 }; + WEAK symbolEmitStatement{ 0x0, 0x687DB0 }; + WEAK symbolScr_CalcLocalVarsStatement{ 0x0, 0x688210 }; + WEAK symbolEmitStatementList{ 0x0, 0x688470 }; + WEAK symbolScr_CalcLocalVarsDeveloperStatementList{ 0x0, 0x688530 }; + WEAK symbolEmitDeveloperStatementList{ 0x0, 0x6885A0 }; + WEAK symbolEmitThreadList{ 0x0, 0x688D40 }; + WEAK symbolEmitVariableExpressionRef{ 0x0, 0x684790 }; + + inline void* Scr_CompileRemoveRefToString_ADDR() { return CALL_ADDR(0x0, 0x67EB90); } + void Scr_CompileRemoveRefToString(scriptInstance_t inst, unsigned int stringVal, void* call_addr = Scr_CompileRemoveRefToString_ADDR()); + inline void* EmitCanonicalString_ADDR() { return CALL_ADDR(0x0, 0x67EBB0); } + void EmitCanonicalString(scriptInstance_t inst, unsigned int stringVal, void* call_addr = EmitCanonicalString_ADDR()); + inline void* CompileTransferRefToString_ADDR() { return CALL_ADDR(0x0, 0x67EC30); } + void CompileTransferRefToString(unsigned int stringValue, scriptInstance_t inst, unsigned int user, void* call_addr = CompileTransferRefToString_ADDR()); + inline void* EmitEnd_ADDR() { return CALL_ADDR(0x0, 0x67F0C0); } + void EmitEnd(scriptInstance_t inst, void* call_addr = EmitEnd_ADDR()); + inline void* EmitReturn_ADDR() { return CALL_ADDR(0x0, 0x67F1A0); } + void EmitReturn(scriptInstance_t inst, void* call_addr = EmitReturn_ADDR()); + inline void* EmitCodepos_ADDR() { return CALL_ADDR(0x0, 0x67F290); } + void EmitCodepos(scriptInstance_t inst, int codepos, void* call_addr = EmitCodepos_ADDR()); + inline void* EmitShort_ADDR() { return CALL_ADDR(0x0, 0x67F2C0); } + void EmitShort(scriptInstance_t inst, int value, void* call_addr = EmitShort_ADDR()); + inline void* EmitByte_ADDR() { return CALL_ADDR(0x0, 0x67F2F0); } + void EmitByte(scriptInstance_t inst, int value, void* call_addr = EmitByte_ADDR()); + inline void* EmitGetInteger_ADDR() { return CALL_ADDR(0x0, 0x67F320); } + void EmitGetInteger(scriptInstance_t inst, int value, sval_u sourcePos, void* call_addr = EmitGetInteger_ADDR()); + inline void* EmitGetFloat_ADDR() { return CALL_ADDR(0x0, 0x67F470); } + void EmitGetFloat(scriptInstance_t inst, float value, sval_u sourcePos, void* call_addr = EmitGetFloat_ADDR()); + inline void* EmitAnimTree_ADDR() { return CALL_ADDR(0x0, 0x67F4C0); } + void EmitAnimTree(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitAnimTree_ADDR()); + inline void* EmitRemoveLocalVars_ADDR() { return CALL_ADDR(0x0, 0x67F880); } + void EmitRemoveLocalVars(scriptInstance_t inst, scr_block_s* outerBlock, scr_block_s* block, void* call_addr = EmitRemoveLocalVars_ADDR()); + inline void* EmitNOP2_ADDR() { return CALL_ADDR(0x0, 0x67F9A0); } + void EmitNOP2(scr_block_s* block, scriptInstance_t inst, int lastStatement, unsigned int endSourcePos, void* call_addr = EmitNOP2_ADDR()); + inline void* Scr_AppendChildBlocks_ADDR() { return CALL_ADDR(0x0, 0x67FAA0); } + void Scr_AppendChildBlocks(scr_block_s* block, scr_block_s** childBlocks, int childCount, void* call_addr = Scr_AppendChildBlocks_ADDR()); + inline void* Scr_TransferBlock_ADDR() { return CALL_ADDR(0x0, 0x67FC60); } + void Scr_TransferBlock(scr_block_s* to, scr_block_s* from, void* call_addr = Scr_TransferBlock_ADDR()); + inline void* EmitSafeSetVariableField_ADDR() { return CALL_ADDR(0x0, 0x67FD50); } + void EmitSafeSetVariableField(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitSafeSetVariableField_ADDR()); + inline void* EmitSafeSetWaittillVariableField_ADDR() { return CALL_ADDR(0x0, 0x67FDC0); } + void EmitSafeSetWaittillVariableField(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitSafeSetWaittillVariableField_ADDR()); + inline void* EmitGetString_ADDR() { return CALL_ADDR(0x0, 0x67FEE0); } + void EmitGetString(unsigned int value, scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitGetString_ADDR()); + inline void* EmitGetIString_ADDR() { return CALL_ADDR(0x0, 0x67FF30); } + void EmitGetIString(unsigned int value, scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitGetIString_ADDR()); + inline void* EmitGetVector_ADDR() { return CALL_ADDR(0x0, 0x67FF80); } + void EmitGetVector(const float* value, scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitGetVector_ADDR()); + inline void* Scr_PushValue_ADDR() { return CALL_ADDR(0x0, 0x680120); } + void Scr_PushValue(scriptInstance_t inst, VariableCompileValue* constValue, void* call_addr = Scr_PushValue_ADDR()); + inline void* EmitCastBool_ADDR() { return CALL_ADDR(0x0, 0x680180); } + void EmitCastBool(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitCastBool_ADDR()); + inline void* EmitBoolNot_ADDR() { return CALL_ADDR(0x0, 0x680270); } + void EmitBoolNot(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitBoolNot_ADDR()); + inline void* EmitBoolComplement_ADDR() { return CALL_ADDR(0x0, 0x680360); } + void EmitBoolComplement(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitBoolComplement_ADDR()); + inline void* EmitSize_ADDR() { return CALL_ADDR(0x0, 0x680450); } + void EmitSize(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitSize_ADDR()); + inline void* EmitSelf_ADDR() { return CALL_ADDR(0x0, 0x680560); } + void EmitSelf(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitSelf_ADDR()); + inline void* EmitLevel_ADDR() { return CALL_ADDR(0x0, 0x680660); } + void EmitLevel(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitLevel_ADDR()); + inline void* EmitGame_ADDR() { return CALL_ADDR(0x0, 0x680760); } + void EmitGame(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitGame_ADDR()); + inline void* EmitAnim_ADDR() { return CALL_ADDR(0x0, 0x680860); } + void EmitAnim(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitAnim_ADDR()); + inline void* EmitSelfObject_ADDR() { return CALL_ADDR(0x0, 0x680960); } + void EmitSelfObject(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitSelfObject_ADDR()); + inline void* EmitLevelObject_ADDR() { return CALL_ADDR(0x0, 0x680A50); } + void EmitLevelObject(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitLevelObject_ADDR()); + inline void* EmitAnimObject_ADDR() { return CALL_ADDR(0x0, 0x680B40); } + void EmitAnimObject(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitAnimObject_ADDR()); + inline void* EmitLocalVariable_ADDR() { return CALL_ADDR(0x0, 0x680C30); } + void EmitLocalVariable(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitLocalVariable_ADDR()); + inline void* EmitLocalVariableRef_ADDR() { return CALL_ADDR(0x0, 0x680CA0); } + void EmitLocalVariableRef(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitLocalVariableRef_ADDR()); + inline void* EmitGameRef_ADDR() { return CALL_ADDR(0x0, 0x680D60); } + void EmitGameRef(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitGameRef_ADDR()); + inline void* EmitClearArray_ADDR() { return CALL_ADDR(0x0, 0x680E50); } + void EmitClearArray(scriptInstance_t inst, sval_u sourcePos, sval_u indexSourcePos, void* call_addr = EmitClearArray_ADDR()); + inline void* EmitEmptyArray_ADDR() { return CALL_ADDR(0x0, 0x680F50); } + void EmitEmptyArray(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitEmptyArray_ADDR()); + inline void* EmitAnimation_ADDR() { return CALL_ADDR(0x0, 0x681050); } + void EmitAnimation(scriptInstance_t inst, sval_u anim, sval_u sourcePos, void* call_addr = EmitAnimation_ADDR()); + inline void* EmitFieldVariable_ADDR() { return CALL_ADDR(0x0, 0x6811C0); } + void EmitFieldVariable(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u field, sval_u sourcePos, void* call_addr = EmitFieldVariable_ADDR()); + inline void* EmitFieldVariableRef_ADDR() { return CALL_ADDR(0x0, 0x681200); } + void EmitFieldVariableRef(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u field, sval_u sourcePos, void* call_addr = EmitFieldVariableRef_ADDR()); + inline void* EmitObject_ADDR() { return CALL_ADDR(0x0, 0x681310); } + void EmitObject(scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitObject_ADDR()); + inline void* EmitDecTop_ADDR() { return CALL_ADDR(0x0, 0x681630); } + void EmitDecTop(scriptInstance_t inst, void* call_addr = EmitDecTop_ADDR()); + inline void* EmitArrayVariable_ADDR() { return CALL_ADDR(0x0, 0x681840); } + void EmitArrayVariable(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u index, sval_u sourcePos, sval_u indexSourcePos, void* call_addr = EmitArrayVariable_ADDR()); + inline void* EmitArrayVariableRef_ADDR() { return CALL_ADDR(0x0, 0x6818C0); } + void EmitArrayVariableRef(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u index, sval_u sourcePos, sval_u indexSourcePos, void* call_addr = EmitArrayVariableRef_ADDR()); + inline void* EmitClearArrayVariable_ADDR() { return CALL_ADDR(0x0, 0x681930); } + void EmitClearArrayVariable(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u index, sval_u sourcePos, sval_u indexSourcePos, void* call_addr = EmitClearArrayVariable_ADDR()); + inline void* AddExpressionListOpcodePos_ADDR() { return CALL_ADDR(0x0, 0x681B30); } + void AddExpressionListOpcodePos(scriptInstance_t inst, sval_u exprlist, void* call_addr = AddExpressionListOpcodePos_ADDR()); + inline void* AddFilePrecache_ADDR() { return CALL_ADDR(0x0, 0x681B70); } + void AddFilePrecache(scriptInstance_t inst, unsigned int filename, unsigned int sourcePos, int include, unsigned int* filePosId, unsigned int* fileCountId, void* call_addr = AddFilePrecache_ADDR()); + inline void* EmitFunction_ADDR() { return CALL_ADDR(0x0, 0x681C30); } + void EmitFunction(scriptInstance_t inst, sval_u func, sval_u sourcePos, void* call_addr = EmitFunction_ADDR()); + inline void* EmitGetFunction_ADDR() { return CALL_ADDR(0x0, 0x681F30); } + void EmitGetFunction(scriptInstance_t inst, sval_u func, sval_u sourcePos, void* call_addr = EmitGetFunction_ADDR()); + inline void* EmitPostScriptFunctionPointer_ADDR() { return CALL_ADDR(0x0, 0x6822F0); } + void EmitPostScriptFunctionPointer(scr_block_s* block, scriptInstance_t inst, sval_u expr, int param_count, int bMethod, sval_u nameSourcePos, sval_u sourcePos, void* call_addr = EmitPostScriptFunctionPointer_ADDR()); + inline void* EmitPostScriptThread_ADDR() { return CALL_ADDR(0x0, 0x682500); } + void EmitPostScriptThread(scriptInstance_t inst, sval_u func, int param_count, int bMethod, sval_u sourcePos, void* call_addr = EmitPostScriptThread_ADDR()); + inline void* EmitPostScriptThreadPointer_ADDR() { return CALL_ADDR(0x0, 0x682730); } + void EmitPostScriptThreadPointer(scr_block_s* block, scriptInstance_t inst, sval_u expr, int param_count, int bMethod, sval_u sourcePos, void* call_addr = EmitPostScriptThreadPointer_ADDR()); + inline void* EmitPostScriptFunctionCall_ADDR() { return CALL_ADDR(0x0, 0x682950); } + void EmitPostScriptFunctionCall(scriptInstance_t inst, int bMethod, int param_count, sval_u func_name, sval_u nameSourcePos, scr_block_s* block, void* call_addr = EmitPostScriptFunctionCall_ADDR()); + inline void* EmitPostScriptThreadCall_ADDR() { return CALL_ADDR(0x0, 0x6829A0); } + void EmitPostScriptThreadCall(scriptInstance_t inst, int isMethod, int param_count, sval_u func_name, sval_u sourcePos, sval_u nameSourcePos, scr_block_s* block, void* call_addr = EmitPostScriptThreadCall_ADDR()); + inline void* EmitPreFunctionCall_ADDR() { return CALL_ADDR(0x0, 0x6829F0); } + void EmitPreFunctionCall(scriptInstance_t inst, void* call_addr = EmitPreFunctionCall_ADDR()); + inline void* EmitPostFunctionCall_ADDR() { return CALL_ADDR(0x0, 0x682AE0); } + void EmitPostFunctionCall(scriptInstance_t inst, int bMethod, sval_u func_name, int param_count, scr_block_s* block, void* call_addr = EmitPostFunctionCall_ADDR()); + inline void* Scr_BeginDevScript_ADDR() { return CALL_ADDR(0x0, 0x682B30); } + void Scr_BeginDevScript(scriptInstance_t isnt, int* type_, char** savedPos, void* call_addr = Scr_BeginDevScript_ADDR()); + inline void* Scr_EndDevScript_ADDR() { return CALL_ADDR(0x0, 0x682BA0); } + void Scr_EndDevScript(scriptInstance_t inst, char** savedPos, void* call_addr = Scr_EndDevScript_ADDR()); + inline void* EmitCallBuiltinOpcode_ADDR() { return CALL_ADDR(0x0, 0x682BD0); } + void EmitCallBuiltinOpcode(scriptInstance_t inst, int param_count, sval_u sourcePos, void* call_addr = EmitCallBuiltinOpcode_ADDR()); + inline void* EmitCallBuiltinMethodOpcode_ADDR() { return CALL_ADDR(0x0, 0x682C40); } + void EmitCallBuiltinMethodOpcode(int inst, int param_count, sval_u sourcePos, void* call_addr = EmitCallBuiltinMethodOpcode_ADDR()); + inline void* EmitCall_ADDR() { return CALL_ADDR(0x0, 0x682CA0); } + void EmitCall(scriptInstance_t inst, sval_u func_name, sval_u params, int bStatement, scr_block_s* block, void* call_addr = EmitCall_ADDR()); + inline void* LinkThread_ADDR() { return CALL_ADDR(0x0, 0x683250); } + void LinkThread(scriptInstance_t inst, unsigned int threadCountId, VariableValue* pos, int allowFarCall, void* call_addr = LinkThread_ADDR()); + inline void* LinkFile_ADDR() { return CALL_ADDR(0x0, 0x6833F0); } + void LinkFile(scriptInstance_t inst, unsigned int filePosId, unsigned int fileCountId, void* call_addr = LinkFile_ADDR()); + inline void* EmitCallExpression_ADDR() { return CALL_ADDR(0x0, 0x683640); } + void EmitCallExpression(scriptInstance_t inst, scr_block_s* block, sval_u expr, int bStatement, void* call_addr = EmitCallExpression_ADDR()); + inline void* EmitCallExpressionFieldObject_ADDR() { return CALL_ADDR(0x0, 0x683690); } + void EmitCallExpressionFieldObject(scr_block_s* block, scriptInstance_t inst, sval_u expr, void* call_addr = EmitCallExpressionFieldObject_ADDR()); + inline void* Scr_CreateVector_ADDR() { return CALL_ADDR(0x0, 0x6836F0); } + void Scr_CreateVector(scriptInstance_t inst, VariableCompileValue* constValue, VariableCompileValue* value, void* call_addr = Scr_CreateVector_ADDR()); + inline void* EmitOrEvalPrimitiveExpressionList_ADDR() { return CALL_ADDR(0x0, 0x6838D0); } + bool EmitOrEvalPrimitiveExpressionList(scriptInstance_t inst, sval_u exprlist, sval_u sourcePos, VariableCompileValue* constValue, scr_block_s* a5, void* call_addr = EmitOrEvalPrimitiveExpressionList_ADDR()); + inline void* EmitExpressionListFieldObject_ADDR() { return CALL_ADDR(0x0, 0x683AF0); } + void EmitExpressionListFieldObject(scriptInstance_t inst, sval_u exprlist, sval_u sourcePos, scr_block_s* block, void* call_addr = EmitExpressionListFieldObject_ADDR()); + inline void* EmitBoolOrExpression_ADDR() { return CALL_ADDR(0x0, 0x683F00); } + void EmitBoolOrExpression(scriptInstance_t inst, sval_u expr1, sval_u expr2, sval_u expr1sourcePos, sval_u expr2sourcePos, scr_block_s* block, void* call_addr = EmitBoolOrExpression_ADDR()); + inline void* EmitBoolAndExpression_ADDR() { return CALL_ADDR(0x0, 0x684090); } + void EmitBoolAndExpression(scriptInstance_t inst, sval_u expr1, sval_u expr2, sval_u expr1sourcePos, sval_u expr2sourcePos, scr_block_s* a6, void* call_addr = EmitBoolAndExpression_ADDR()); + inline void* EmitOrEvalBinaryOperatorExpression_ADDR() { return CALL_ADDR(0x0, 0x684350); } + bool EmitOrEvalBinaryOperatorExpression(scriptInstance_t inst, sval_u expr1, sval_u expr2, sval_u opcode, sval_u sourcePos, VariableCompileValue* constValue, scr_block_s* a8, void* call_addr = EmitOrEvalBinaryOperatorExpression_ADDR()); + inline void* EmitBinaryEqualsOperatorExpression_ADDR() { return CALL_ADDR(0x0, 0x684460); } + void EmitBinaryEqualsOperatorExpression(scr_block_s* block, scriptInstance_t inst, sval_u lhs, sval_u rhs, sval_u opcode, sval_u sourcePos, void* call_addr = EmitBinaryEqualsOperatorExpression_ADDR()); + inline void* Scr_CalcLocalVarsVariableExpressionRef_ADDR() { return CALL_ADDR(0x0, 0x684500); } + void Scr_CalcLocalVarsVariableExpressionRef(scr_block_s* block, sval_u expr, void* call_addr = Scr_CalcLocalVarsVariableExpressionRef_ADDR()); + inline void* EvalExpression_ADDR() { return CALL_ADDR(0x0, 0x684540); } + bool EvalExpression(VariableCompileValue* constValue, scriptInstance_t inst, sval_u expr, void* call_addr = EvalExpression_ADDR()); + inline void* EmitArrayPrimitiveExpressionRef_ADDR() { return CALL_ADDR(0x0, 0x684900); } + void EmitArrayPrimitiveExpressionRef(scriptInstance_t inst, sval_u expr, sval_u sourcePos, scr_block_s* block, void* call_addr = EmitArrayPrimitiveExpressionRef_ADDR()); + inline void* ConnectBreakStatements_ADDR() { return CALL_ADDR(0x0, 0x684AC0); } + void ConnectBreakStatements(scriptInstance_t inst, void* call_addr = ConnectBreakStatements_ADDR()); + inline void* ConnectContinueStatements_ADDR() { return CALL_ADDR(0x0, 0x684B00); } + void ConnectContinueStatements(scriptInstance_t inst, void* call_addr = ConnectContinueStatements_ADDR()); + inline void* EmitClearVariableExpression_ADDR() { return CALL_ADDR(0x0, 0x684B40); } + bool EmitClearVariableExpression(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u rhsSourcePos, void* call_addr = EmitClearVariableExpression_ADDR()); + inline void* EmitAssignmentStatement_ADDR() { return CALL_ADDR(0x0, 0x684C40); } + void EmitAssignmentStatement(scriptInstance_t inst, sval_u lhs, sval_u rhs, sval_u sourcePos, sval_u rhsSourcePos, scr_block_s* block, void* call_addr = EmitAssignmentStatement_ADDR()); + inline void* EmitCallExpressionStatement_ADDR() { return CALL_ADDR(0x0, 0x684CD0); } + void EmitCallExpressionStatement(scriptInstance_t inst, scr_block_s* block, sval_u expr, void* call_addr = EmitCallExpressionStatement_ADDR()); + inline void* EmitReturnStatement_ADDR() { return CALL_ADDR(0x0, 0x684D20); } + void EmitReturnStatement(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitReturnStatement_ADDR()); + inline void* EmitWaitStatement_ADDR() { return CALL_ADDR(0x0, 0x684D80); } + void EmitWaitStatement(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, sval_u waitSourcePos, void* call_addr = EmitWaitStatement_ADDR()); + inline void* EmitWaittillFrameEnd_ADDR() { return CALL_ADDR(0x0, 0x684EB0); } + void EmitWaittillFrameEnd(scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitWaittillFrameEnd_ADDR()); + inline void* EmitIfStatement_ADDR() { return CALL_ADDR(0x0, 0x684FB0); } + void EmitIfStatement(scriptInstance_t inst, sval_u expr, sval_u stmt, sval_u sourcePos, int lastStatement, unsigned int endSourcePos, scr_block_s* block, sval_u* ifStatBlock, void* call_addr = EmitIfStatement_ADDR()); + inline void* Scr_AddBreakBlock_ADDR() { return CALL_ADDR(0x0, 0x6856A0); } + void Scr_AddBreakBlock(scriptInstance_t inst, scr_block_s* block, void* call_addr = Scr_AddBreakBlock_ADDR()); + inline void* Scr_AddContinueBlock_ADDR() { return CALL_ADDR(0x0, 0x685700); } + void Scr_AddContinueBlock(scriptInstance_t inst, scr_block_s* block, void* call_addr = Scr_AddContinueBlock_ADDR()); + inline void* EmitIncStatement_ADDR() { return CALL_ADDR(0x0, 0x686570); } + void EmitIncStatement(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitIncStatement_ADDR()); + inline void* EmitDecStatement_ADDR() { return CALL_ADDR(0x0, 0x686690); } + void EmitDecStatement(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitDecStatement_ADDR()); + inline void* Scr_CalcLocalVarsFormalParameterListInternal_ADDR() { return CALL_ADDR(0x0, 0x6867B0); } + void Scr_CalcLocalVarsFormalParameterListInternal(sval_u* node, scr_block_s* block, void* call_addr = Scr_CalcLocalVarsFormalParameterListInternal_ADDR()); + inline void* EmitWaittillStatement_ADDR() { return CALL_ADDR(0x0, 0x686810); } + void EmitWaittillStatement(scriptInstance_t inst, sval_u obj, sval_u exprlist, sval_u sourcePos, sval_u waitSourcePos, scr_block_s* block, void* call_addr = EmitWaittillStatement_ADDR()); + inline void* EmitWaittillmatchStatement_ADDR() { return CALL_ADDR(0x0, 0x686A60); } + void EmitWaittillmatchStatement(scriptInstance_t inst, sval_u obj, sval_u exprlist, sval_u sourcePos, sval_u waitSourcePos, scr_block_s* block, void* call_addr = EmitWaittillmatchStatement_ADDR()); + inline void* EmitNotifyStatement_ADDR() { return CALL_ADDR(0x0, 0x686D30); } + void EmitNotifyStatement(scriptInstance_t inst, sval_u obj, sval_u exprlist, sval_u sourcePos, sval_u notifySourcePos, scr_block_s* block, void* call_addr = EmitNotifyStatement_ADDR()); + inline void* EmitEndOnStatement_ADDR() { return CALL_ADDR(0x0, 0x686F90); } + void EmitEndOnStatement(scr_block_s* block, scriptInstance_t inst, sval_u obj, sval_u expr, sval_u sourcePos, sval_u exprSourcePos, void* call_addr = EmitEndOnStatement_ADDR()); + inline void* EmitCaseStatement_ADDR() { return CALL_ADDR(0x0, 0x687100); } + void EmitCaseStatement(scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr = EmitCaseStatement_ADDR()); + inline void* EmitCaseStatementInfo_ADDR() { return CALL_ADDR(0x0, 0x687990); } + void EmitCaseStatementInfo(scriptInstance_t inst, unsigned int name, sval_u sourcePos, void* call_addr = EmitCaseStatementInfo_ADDR()); + inline void* EmitBreakStatement_ADDR() { return CALL_ADDR(0x0, 0x6879F0); } + void EmitBreakStatement(scr_block_s* block, scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitBreakStatement_ADDR()); + inline void* EmitContinueStatement_ADDR() { return CALL_ADDR(0x0, 0x687B90); } + void EmitContinueStatement(scr_block_s* block, scriptInstance_t inst, sval_u sourcePos, void* call_addr = EmitContinueStatement_ADDR()); + inline void* EmitProfStatement_ADDR() { return CALL_ADDR(0x0, 0x687D30); } + void EmitProfStatement(scriptInstance_t inst, sval_u profileName, sval_u sourcePos, OpcodeVM op, void* call_addr = EmitProfStatement_ADDR()); + inline void* Scr_CalcLocalVarsStatementList_ADDR() { return CALL_ADDR(0x0, 0x6884F0); } + void Scr_CalcLocalVarsStatementList(scr_block_s* block, scriptInstance_t inst, sval_u val, void* call_addr = Scr_CalcLocalVarsStatementList_ADDR()); + inline void* EmitFormalParameterList_ADDR() { return CALL_ADDR(0x0, 0x6886A0); } + void EmitFormalParameterList(scriptInstance_t inst, sval_u exprlist, sval_u sourcePos, scr_block_s* block, void* call_addr = EmitFormalParameterList_ADDR()); + inline void* SpecifyThread_ADDR() { return CALL_ADDR(0x0, 0x6887C0); } + void SpecifyThread(scriptInstance_t inst, sval_u val, void* call_addr = SpecifyThread_ADDR()); + inline void* EmitThreadInternal_ADDR() { return CALL_ADDR(0x0, 0x6888D0); } + void EmitThreadInternal(scriptInstance_t inst, sval_u val, sval_u sourcePos, sval_u endSourcePos, scr_block_s* block, void* call_addr = EmitThreadInternal_ADDR()); + inline void* Scr_CalcLocalVarsThread_ADDR() { return CALL_ADDR(0x0, 0x688990); } + void Scr_CalcLocalVarsThread(sval_u* stmttblock, scriptInstance_t inst, sval_u exprlist, sval_u stmtlist, void* call_addr = Scr_CalcLocalVarsThread_ADDR()); + inline void* InitThread_ADDR() { return CALL_ADDR(0x0, 0x688A00); } + void InitThread(int type_, scriptInstance_t inst, void* call_addr = InitThread_ADDR()); + inline void* EmitNormalThread_ADDR() { return CALL_ADDR(0x0, 0x688A70); } + void EmitNormalThread(scriptInstance_t inst, sval_u val, sval_u* stmttblock, void* call_addr = EmitNormalThread_ADDR()); + inline void* EmitDeveloperThread_ADDR() { return CALL_ADDR(0x0, 0x688B00); } + void EmitDeveloperThread(scriptInstance_t inst, sval_u val, sval_u* stmttblock, void* call_addr = EmitDeveloperThread_ADDR()); + inline void* EmitThread_ADDR() { return CALL_ADDR(0x0, 0x688C40); } + void EmitThread(scriptInstance_t inst, sval_u val, void* call_addr = EmitThread_ADDR()); + inline void* EmitInclude_ADDR() { return CALL_ADDR(0x0, 0x688DD0); } + void EmitInclude(scriptInstance_t inst, sval_u val, void* call_addr = EmitInclude_ADDR()); + inline void* ScriptCompile_ADDR() { return CALL_ADDR(0x0, 0x688E70); } + void ScriptCompile(scriptInstance_t inst, sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry* entries, int entriesCount, void* call_addr = ScriptCompile_ADDR()); +} \ No newline at end of file diff --git a/src/game/clientscript/cscr_compiler_w.cpp b/src/game/clientscript/cscr_compiler_w.cpp new file mode 100644 index 0000000..289e439 --- /dev/null +++ b/src/game/clientscript/cscr_compiler_w.cpp @@ -0,0 +1,1482 @@ +#include +//#include "codsrc/clientscript/cscr_compiler.hpp" + +namespace game +{ + // void __usercall Scr_CompileRemoveRefToString(scriptInstance_t inst@, unsigned int stringVal@) + void Scr_CompileRemoveRefToString(scriptInstance_t inst, unsigned int stringVal, void* call_addr) + { + __asm + { + mov eax, inst; + mov edx, stringVal; + call call_addr; + } + } + + // void __usercall EmitCanonicalString(scriptInstance_t inst@, unsigned int stringVal@) + void EmitCanonicalString(scriptInstance_t inst, unsigned int stringVal, void* call_addr) + { + __asm + { + mov ecx, inst; + mov eax, stringVal; + call call_addr; + } + } + + // void __usercall CompileTransferRefToString(unsigned int stringValue@, scriptInstance_t inst@, unsigned int user) + void CompileTransferRefToString(unsigned int stringValue, scriptInstance_t inst, unsigned int user, void* call_addr) + { + __asm + { + push user; + mov eax, stringValue; + mov ecx, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitEnd(scriptInstance_t inst@) + void EmitEnd(scriptInstance_t inst, void* call_addr) + { + __asm + { + mov eax, inst; + call call_addr; + } + } + + // void __usercall EmitReturn(scriptInstance_t inst@) + void EmitReturn(scriptInstance_t inst, void* call_addr) + { + __asm + { + mov eax, inst; + call call_addr; + } + } + + // void __usercall EmitCodepos(scriptInstance_t inst@, int codepos) + void EmitCodepos(scriptInstance_t inst, int codepos, void* call_addr) + { + __asm + { + push codepos; + mov eax, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitShort(scriptInstance_t inst@, int value) + void EmitShort(scriptInstance_t inst, int value, void* call_addr) + { + __asm + { + push value; + mov eax, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitByte(scriptInstance_t inst@, int value) + void EmitByte(scriptInstance_t inst, int value, void* call_addr) + { + __asm + { + push value; + mov eax, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitGetInteger(scriptInstance_t inst@, int value, sval_u sourcePos) + void EmitGetInteger(scriptInstance_t inst, int value, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push value; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitGetFloat(scriptInstance_t inst@, float value, sval_u sourcePos) + void EmitGetFloat(scriptInstance_t inst, float value, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push value; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitAnimTree(scriptInstance_t inst@, sval_u sourcePos) + void EmitAnimTree(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov eax, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitRemoveLocalVars(scriptInstance_t inst@, scr_block_s *outerBlock@, scr_block_s *block) + void EmitRemoveLocalVars(scriptInstance_t inst, scr_block_s* outerBlock, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + mov eax, inst; + mov ecx, outerBlock; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitNOP2(scr_block_s *block@, scriptInstance_t inst@, int lastStatement, unsigned int endSourcePos) + void EmitNOP2(scr_block_s* block, scriptInstance_t inst, int lastStatement, unsigned int endSourcePos, void* call_addr) + { + __asm + { + push endSourcePos; + push lastStatement; + mov ecx, block; + mov edi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall Scr_AppendChildBlocks(scr_block_s *block@, scr_block_s **childBlocks, int childCount) + void Scr_AppendChildBlocks(scr_block_s* block, scr_block_s** childBlocks, int childCount, void* call_addr) + { + __asm + { + push childCount; + push childBlocks; + mov edi, block; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall Scr_TransferBlock(scr_block_s *to@, scr_block_s *from) + void Scr_TransferBlock(scr_block_s* to, scr_block_s* from, void* call_addr) + { + __asm + { + push from; + mov esi, to; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitSafeSetVariableField(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitSafeSetVariableField(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov eax, block; + mov esi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitSafeSetWaittillVariableField(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitSafeSetWaittillVariableField(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov eax, block; + mov edi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitGetString(unsigned int value@, scriptInstance_t inst@, sval_u sourcePos) + void EmitGetString(unsigned int value, scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, value; + mov esi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitGetIString(unsigned int value@, scriptInstance_t inst@, sval_u sourcePos) + void EmitGetIString(unsigned int value, scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, value; + mov esi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitGetVector(const float *value@, scriptInstance_t inst, sval_u sourcePos) + void EmitGetVector(const float* value, scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push inst; + mov eax, value; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall Scr_PushValue(scriptInstance_t inst@, VariableCompileValue *constValue@) + void Scr_PushValue(scriptInstance_t inst, VariableCompileValue* constValue, void* call_addr) + { + __asm + { + mov eax, inst; + mov esi, constValue; + call call_addr; + } + } + + // void __usercall EmitCastBool(scriptInstance_t inst@, sval_u sourcePos) + void EmitCastBool(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitBoolNot(scriptInstance_t inst@, sval_u sourcePos) + void EmitBoolNot(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitBoolComplement(scriptInstance_t inst@, sval_u sourcePos) + void EmitBoolComplement(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitSize(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitSize(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov eax, block; + mov edi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitSelf(scriptInstance_t inst@, sval_u sourcePos) + void EmitSelf(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitLevel(scriptInstance_t inst@, sval_u sourcePos) + void EmitLevel(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitGame(scriptInstance_t inst@, sval_u sourcePos) + void EmitGame(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitAnim(scriptInstance_t inst@, sval_u sourcePos) + void EmitAnim(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitSelfObject(scriptInstance_t inst@, sval_u sourcePos) + void EmitSelfObject(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitLevelObject(scriptInstance_t inst@, sval_u sourcePos) + void EmitLevelObject(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitAnimObject(scriptInstance_t inst@, sval_u sourcePos) + void EmitAnimObject(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitLocalVariable(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitLocalVariable(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov eax, block; + mov esi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitLocalVariableRef(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitLocalVariableRef(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov eax, block; + mov esi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitGameRef(scriptInstance_t inst@, sval_u sourcePos) + void EmitGameRef(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitClearArray(scriptInstance_t inst@, sval_u sourcePos, sval_u indexSourcePos) + void EmitClearArray(scriptInstance_t inst, sval_u sourcePos, sval_u indexSourcePos, void* call_addr) + { + __asm + { + push indexSourcePos; + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitEmptyArray(scriptInstance_t inst@, sval_u sourcePos) + void EmitEmptyArray(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitAnimation(scriptInstance_t inst@, sval_u anim, sval_u sourcePos) + void EmitAnimation(scriptInstance_t inst, sval_u anim, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push anim; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitFieldVariable(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u field, sval_u sourcePos) + void EmitFieldVariable(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u field, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push field; + push expr; + mov eax, block; + mov esi, inst; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall EmitFieldVariableRef(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u field, sval_u sourcePos) + void EmitFieldVariableRef(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u field, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push field; + push expr; + mov eax, block; + mov esi, inst; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall EmitObject(scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitObject(scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov edi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitDecTop(scriptInstance_t inst@) + void EmitDecTop(scriptInstance_t inst, void* call_addr) + { + __asm + { + mov eax, inst; + call call_addr; + } + } + + // void __usercall EmitArrayVariable(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u index, sval_u sourcePos, sval_u indexSourcePos) + void EmitArrayVariable(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u index, sval_u sourcePos, sval_u indexSourcePos, void* call_addr) + { + __asm + { + push indexSourcePos; + push sourcePos; + push index; + push expr; + mov edi, block; + mov esi, inst; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall EmitArrayVariableRef(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u index, sval_u sourcePos, sval_u indexSourcePos) + void EmitArrayVariableRef(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u index, sval_u sourcePos, sval_u indexSourcePos, void* call_addr) + { + __asm + { + push indexSourcePos; + push sourcePos; + push index; + push expr; + mov eax, block; + mov esi, inst; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall EmitClearArrayVariable(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u index, sval_u sourcePos, sval_u indexSourcePos) + void EmitClearArrayVariable(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u index, sval_u sourcePos, sval_u indexSourcePos, void* call_addr) + { + __asm + { + push indexSourcePos; + push sourcePos; + push index; + push expr; + mov eax, block; + mov ecx, inst; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall AddExpressionListOpcodePos(scriptInstance_t inst@, sval_u exprlist) + void AddExpressionListOpcodePos(scriptInstance_t inst, sval_u exprlist, void* call_addr) + { + __asm + { + push exprlist; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall AddFilePrecache(scriptInstance_t inst@, unsigned int filename, unsigned int sourcePos, bool include, unsigned int *filePosId, unsigned int *fileCountId) + void AddFilePrecache(scriptInstance_t inst, unsigned int filename, unsigned int sourcePos, int include, unsigned int* filePosId, unsigned int* fileCountId, void* call_addr) + { + __asm + { + push fileCountId; + push filePosId; + push include; + push sourcePos; + push filename; + mov eax, inst; + call call_addr; + add esp, 0x14; + } + } + + // void __usercall EmitFunction(scriptInstance_t inst@, sval_u func, sval_u sourcePos) + void EmitFunction(scriptInstance_t inst, sval_u func, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push func; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitGetFunction(scriptInstance_t inst@, sval_u func, sval_u sourcePos) + void EmitGetFunction(scriptInstance_t inst, sval_u func, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push func; + mov edi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitPostScriptFunctionPointer(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, int param_count, int bMethod, sval_u nameSourcePos, sval_u sourcePos) + void EmitPostScriptFunctionPointer(scr_block_s* block, scriptInstance_t inst, sval_u expr, int param_count, int bMethod, sval_u nameSourcePos, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push nameSourcePos; + push bMethod; + push param_count; + push expr; + mov eax, block; + mov edi, inst; + call call_addr; + add esp, 0x14; + } + } + + // void __usercall EmitPostScriptThread(scriptInstance_t inst@, sval_u func, int param_count, int bMethod, sval_u sourcePos) + void EmitPostScriptThread(scriptInstance_t inst, sval_u func, int param_count, int bMethod, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push bMethod; + push param_count; + push func; + mov edi, inst; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall EmitPostScriptThreadPointer(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, int param_count, int bMethod, sval_u sourcePos) + void EmitPostScriptThreadPointer(scr_block_s* block, scriptInstance_t inst, sval_u expr, int param_count, int bMethod, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push bMethod; + push param_count; + push expr; + mov eax, block; + mov edi, inst; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall EmitPostScriptFunctionCall(scriptInstance_t inst@, char bMethod@
, int param_count@, sval_u func_name, sval_u nameSourcePos, scr_block_s *block) + void EmitPostScriptFunctionCall(scriptInstance_t inst, int bMethod, int param_count, sval_u func_name, sval_u nameSourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push nameSourcePos; + push func_name; + mov eax, inst; + mov edx, bMethod; + mov esi, param_count; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall EmitPostScriptThreadCall(scriptInstance_t inst@, char isMethod@
, int param_count@, sval_u func_name, sval_u sourcePos, sval_u nameSourcePos, scr_block_s *block) + void EmitPostScriptThreadCall(scriptInstance_t inst, int isMethod, int param_count, sval_u func_name, sval_u sourcePos, sval_u nameSourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push nameSourcePos; + push sourcePos; + push func_name; + mov eax, inst; + mov edx, isMethod; + mov esi, param_count; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall EmitPreFunctionCall(scriptInstance_t inst@) + void EmitPreFunctionCall(scriptInstance_t inst, void* call_addr) + { + __asm + { + mov eax, inst; + call call_addr; + } + } + + // void __usercall EmitPostFunctionCall(scriptInstance_t inst@, char bMethod@
, sval_u func_name, int param_count, scr_block_s *block) + void EmitPostFunctionCall(scriptInstance_t inst, int bMethod, sval_u func_name, int param_count, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push param_count; + push func_name; + mov eax, inst; + mov edx, bMethod; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall Scr_BeginDevScript(scriptInstance_t isnt@, int *type@, char **savedPos) + void Scr_BeginDevScript(scriptInstance_t isnt, int* type_, char** savedPos, void* call_addr) + { + __asm + { + push savedPos; + mov eax, isnt; + mov edi, type_; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall Scr_EndDevScript(scriptInstance_t inst@, char **savedPos@) + void Scr_EndDevScript(scriptInstance_t inst, char** savedPos, void* call_addr) + { + __asm + { + mov eax, inst; + mov edx, savedPos; + call call_addr; + } + } + + // void __usercall EmitCallBuiltinOpcode(scriptInstance_t inst@, int param_count, sval_u sourcePos) + void EmitCallBuiltinOpcode(scriptInstance_t inst, int param_count, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push param_count; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitCallBuiltinMethodOpcode(int inst@, int param_count, sval_u sourcePos) + void EmitCallBuiltinMethodOpcode(int inst, int param_count, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push param_count; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitCall(scriptInstance_t inst@, sval_u func_name, sval_u params, int bStatement, scr_block_s *block) + void EmitCall(scriptInstance_t inst, sval_u func_name, sval_u params, int bStatement, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push bStatement; + push params; + push func_name; + mov eax, inst; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall LinkThread(scriptInstance_t inst@, unsigned int threadCountId@, VariableValue *pos, int allowFarCall) + void LinkThread(scriptInstance_t inst, unsigned int threadCountId, VariableValue* pos, int allowFarCall, void* call_addr) + { + __asm + { + push allowFarCall; + push pos; + mov ecx, inst; + mov eax, threadCountId; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall LinkFile(scriptInstance_t inst@, unsigned int filePosId, unsigned int fileCountId) + void LinkFile(scriptInstance_t inst, unsigned int filePosId, unsigned int fileCountId, void* call_addr) + { + __asm + { + push fileCountId; + push filePosId; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitCallExpression(scriptInstance_t inst@, scr_block_s *block@, sval_u expr, int bStatement) + void EmitCallExpression(scriptInstance_t inst, scr_block_s* block, sval_u expr, int bStatement, void* call_addr) + { + __asm + { + push bStatement; + push expr; + mov eax, inst; + mov esi, block; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitCallExpressionFieldObject(scr_block_s *block@, scriptInstance_t inst@, sval_u expr) + void EmitCallExpressionFieldObject(scr_block_s* block, scriptInstance_t inst, sval_u expr, void* call_addr) + { + __asm + { + push expr; + mov ecx, block; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall Scr_CreateVector(scriptInstance_t inst@, VariableCompileValue *constValue, VariableCompileValue *value) + void Scr_CreateVector(scriptInstance_t inst, VariableCompileValue* constValue, VariableCompileValue* value, void* call_addr) + { + __asm + { + push value; + push constValue; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // bool __usercall EmitOrEvalPrimitiveExpressionList@(scriptInstance_t inst@, sval_u exprlist, sval_u sourcePos, VariableCompileValue *constValue, scr_block_s *a5) + bool EmitOrEvalPrimitiveExpressionList(scriptInstance_t inst, sval_u exprlist, sval_u sourcePos, VariableCompileValue* constValue, scr_block_s* a5, void* call_addr) + { + bool answer; + + __asm + { + push a5; + push constValue; + push sourcePos; + push exprlist; + mov eax, inst; + call call_addr; + mov answer, al; + add esp, 0x10; + } + + return answer; + } + + // void __usercall EmitExpressionListFieldObject(scriptInstance_t inst@, sval_u exprlist, sval_u sourcePos, scr_block_s *block) + void EmitExpressionListFieldObject(scriptInstance_t inst, sval_u exprlist, sval_u sourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push sourcePos; + push exprlist; + mov edx, inst; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall EmitBoolOrExpression(scriptInstance_t inst@, sval_u expr1, sval_u expr2, sval_u expr1sourcePos, sval_u expr2sourcePos, scr_block_s *block) + void EmitBoolOrExpression(scriptInstance_t inst, sval_u expr1, sval_u expr2, sval_u expr1sourcePos, sval_u expr2sourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push expr2sourcePos; + push expr1sourcePos; + push expr2; + push expr1; + mov eax, inst; + call call_addr; + add esp, 0x14; + } + } + + // void __usercall EmitBoolAndExpression(scriptInstance_t inst@, sval_u expr1, sval_u expr2, sval_u expr1sourcePos, sval_u expr2sourcePos, scr_block_s *a6) + void EmitBoolAndExpression(scriptInstance_t inst, sval_u expr1, sval_u expr2, sval_u expr1sourcePos, sval_u expr2sourcePos, scr_block_s* a6, void* call_addr) + { + __asm + { + push a6; + push expr2sourcePos; + push expr1sourcePos; + push expr2; + push expr1; + mov eax, inst; + call call_addr; + add esp, 0x14; + } + } + + // bool __usercall EmitOrEvalBinaryOperatorExpression@(scriptInstance_t inst@, sval_u expr1, sval_u expr2, sval_u opcode, sval_u sourcePos, VariableCompileValue *constValue, scr_block_s *a8) + bool EmitOrEvalBinaryOperatorExpression(scriptInstance_t inst, sval_u expr1, sval_u expr2, sval_u opcode, sval_u sourcePos, VariableCompileValue* constValue, scr_block_s* a8, void* call_addr) + { + bool answer; + + __asm + { + push a8; + push constValue; + push sourcePos; + push opcode; + push expr2; + push expr1; + mov edi, inst; + call call_addr; + mov answer, al; + add esp, 0x18; + } + + return answer; + } + + // void __usercall EmitBinaryEqualsOperatorExpression(scr_block_s *block@, scriptInstance_t inst@, sval_u lhs, sval_u rhs, sval_u opcode, sval_u sourcePos) + void EmitBinaryEqualsOperatorExpression(scr_block_s* block, scriptInstance_t inst, sval_u lhs, sval_u rhs, sval_u opcode, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push opcode; + push rhs; + push lhs; + mov edi, block; + mov esi, inst; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall Scr_CalcLocalVarsVariableExpressionRef(scr_block_s *block@, sval_u expr) + void Scr_CalcLocalVarsVariableExpressionRef(scr_block_s* block, sval_u expr, void* call_addr) + { + __asm + { + push expr; + mov edx, block; + call call_addr; + add esp, 0x4; + } + } + + // bool __usercall EvalExpression@(VariableCompileValue *constValue@, scriptInstance_t inst@, sval_u expr) + bool EvalExpression(VariableCompileValue* constValue, scriptInstance_t inst, sval_u expr, void* call_addr) + { + bool answer; + + __asm + { + push expr; + mov edx, constValue; + mov esi, inst; + call call_addr; + mov answer, al; + add esp, 0x4; + } + + return answer; + } + + // void __usercall EmitArrayPrimitiveExpressionRef(scriptInstance_t inst@, sval_u expr, sval_u sourcePos, scr_block_s *block) + void EmitArrayPrimitiveExpressionRef(scriptInstance_t inst, sval_u expr, sval_u sourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push sourcePos; + push expr; + mov eax, inst; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall ConnectBreakStatements(scriptInstance_t inst@) + void ConnectBreakStatements(scriptInstance_t inst, void* call_addr) + { + __asm + { + mov eax, inst; + call call_addr; + } + } + + // void __usercall ConnectContinueStatements(scriptInstance_t inst@) + void ConnectContinueStatements(scriptInstance_t inst, void* call_addr) + { + __asm + { + mov eax, inst; + call call_addr; + } + } + + // bool __usercall EmitClearVariableExpression@(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u rhsSourcePos) + bool EmitClearVariableExpression(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u rhsSourcePos, void* call_addr) + { + bool answer; + + __asm + { + push rhsSourcePos; + push expr; + mov eax, block; + mov ecx, inst; + call call_addr; + mov answer, al; + add esp, 0x8; + } + + return answer; + } + + // void __usercall EmitAssignmentStatement(scriptInstance_t inst@, sval_u lhs, sval_u rhs, sval_u sourcePos, sval_u rhsSourcePos, scr_block_s *block) + void EmitAssignmentStatement(scriptInstance_t inst, sval_u lhs, sval_u rhs, sval_u sourcePos, sval_u rhsSourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push rhsSourcePos; + push sourcePos; + push rhs; + push lhs; + mov esi, inst; + call call_addr; + add esp, 0x14; + } + } + + // void __usercall EmitCallExpressionStatement(scriptInstance_t inst@, scr_block_s *block@, sval_u expr) + void EmitCallExpressionStatement(scriptInstance_t inst, scr_block_s* block, sval_u expr, void* call_addr) + { + __asm + { + push expr; + mov eax, inst; + mov esi, block; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitReturnStatement(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitReturnStatement(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov eax, block; + mov esi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitWaitStatement(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u sourcePos, sval_u waitSourcePos) + void EmitWaitStatement(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, sval_u waitSourcePos, void* call_addr) + { + __asm + { + push waitSourcePos; + push sourcePos; + push expr; + mov eax, block; + mov edi, inst; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall EmitWaittillFrameEnd(scriptInstance_t inst@, sval_u sourcePos) + void EmitWaittillFrameEnd(scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + mov edi, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitIfStatement(scriptInstance_t inst@, sval_u expr, sval_u stmt, sval_u sourcePos, int lastStatement, unsigned int endSourcePos, scr_block_s *block, sval_u *ifStatBlock) + void EmitIfStatement(scriptInstance_t inst, sval_u expr, sval_u stmt, sval_u sourcePos, int lastStatement, unsigned int endSourcePos, scr_block_s* block, sval_u* ifStatBlock, void* call_addr) + { + __asm + { + push ifStatBlock; + push block; + push endSourcePos; + push lastStatement; + push sourcePos; + push stmt; + push expr; + mov eax, inst; + call call_addr; + add esp, 0x1C; + } + } + + // void __usercall Scr_AddBreakBlock(scriptInstance_t inst@, scr_block_s *block@) + void Scr_AddBreakBlock(scriptInstance_t inst, scr_block_s* block, void* call_addr) + { + __asm + { + mov eax, inst; + mov edi, block; + call call_addr; + } + } + + // void __usercall Scr_AddContinueBlock(scriptInstance_t inst@, scr_block_s *block@) + void Scr_AddContinueBlock(scriptInstance_t inst, scr_block_s* block, void* call_addr) + { + __asm + { + mov eax, inst; + mov edi, block; + call call_addr; + } + } + + // void __usercall EmitIncStatement(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitIncStatement(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov eax, block; + mov edi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitDecStatement(scr_block_s *block@, scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitDecStatement(scr_block_s* block, scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov eax, block; + mov edi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall Scr_CalcLocalVarsFormalParameterListInternal(sval_u *node@, scr_block_s *block@) + void Scr_CalcLocalVarsFormalParameterListInternal(sval_u* node, scr_block_s* block, void* call_addr) + { + __asm + { + mov eax, node; + mov esi, block; + call call_addr; + } + } + + // void __usercall EmitWaittillStatement(scriptInstance_t inst@, sval_u obj, sval_u exprlist, sval_u sourcePos, sval_u waitSourcePos, scr_block_s *block) + void EmitWaittillStatement(scriptInstance_t inst, sval_u obj, sval_u exprlist, sval_u sourcePos, sval_u waitSourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push waitSourcePos; + push sourcePos; + push exprlist; + push obj; + mov eax, inst; + call call_addr; + add esp, 0x14; + } + } + + // void __usercall EmitWaittillmatchStatement(scriptInstance_t inst@, sval_u obj, sval_u exprlist, sval_u sourcePos, sval_u waitSourcePos, scr_block_s *block) + void EmitWaittillmatchStatement(scriptInstance_t inst, sval_u obj, sval_u exprlist, sval_u sourcePos, sval_u waitSourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push waitSourcePos; + push sourcePos; + push exprlist; + push obj; + mov edi, inst; + call call_addr; + add esp, 0x14; + } + } + + // void __usercall EmitNotifyStatement(scriptInstance_t inst@, sval_u obj, sval_u exprlist, sval_u sourcePos, sval_u notifySourcePos, scr_block_s *block) + void EmitNotifyStatement(scriptInstance_t inst, sval_u obj, sval_u exprlist, sval_u sourcePos, sval_u notifySourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push notifySourcePos; + push sourcePos; + push exprlist; + push obj; + mov edi, inst; + call call_addr; + add esp, 0x14; + } + } + + // void __usercall EmitEndOnStatement(scr_block_s *block@, scriptInstance_t inst@, sval_u obj, sval_u expr, sval_u sourcePos, sval_u exprSourcePos) + void EmitEndOnStatement(scr_block_s* block, scriptInstance_t inst, sval_u obj, sval_u expr, sval_u sourcePos, sval_u exprSourcePos, void* call_addr) + { + __asm + { + push exprSourcePos; + push sourcePos; + push expr; + push obj; + mov eax, block; + mov edi, inst; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall EmitCaseStatement(scriptInstance_t inst@, sval_u expr, sval_u sourcePos) + void EmitCaseStatement(scriptInstance_t inst, sval_u expr, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push expr; + mov edi, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitCaseStatementInfo(scriptInstance_t inst@, unsigned int name, sval_u sourcePos) + void EmitCaseStatementInfo(scriptInstance_t inst, unsigned int name, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push name; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitBreakStatement(scr_block_s *block@, scriptInstance_t inst, sval_u sourcePos) + void EmitBreakStatement(scr_block_s* block, scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push inst; + mov eax, block; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitContinueStatement(scr_block_s *block@, scriptInstance_t inst, sval_u sourcePos) + void EmitContinueStatement(scr_block_s* block, scriptInstance_t inst, sval_u sourcePos, void* call_addr) + { + __asm + { + push sourcePos; + push inst; + mov eax, block; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitProfStatement(scriptInstance_t inst@, sval_u profileName, sval_u sourcePos, OpcodeVM op) + void EmitProfStatement(scriptInstance_t inst, sval_u profileName, sval_u sourcePos, OpcodeVM op, void* call_addr) + { + __asm + { + push op; + push sourcePos; + push profileName; + mov eax, inst; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall Scr_CalcLocalVarsStatementList(scr_block_s *block@, scriptInstance_t inst, sval_u val) + void Scr_CalcLocalVarsStatementList(scr_block_s* block, scriptInstance_t inst, sval_u val, void* call_addr) + { + __asm + { + push val; + push inst; + mov edi, block; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitFormalParameterList(scriptInstance_t inst@, sval_u exprlist, sval_u sourcePos, scr_block_s *block) + void EmitFormalParameterList(scriptInstance_t inst, sval_u exprlist, sval_u sourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push sourcePos; + push exprlist; + mov eax, inst; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall SpecifyThread(scriptInstance_t inst@, sval_u val) + void SpecifyThread(scriptInstance_t inst, sval_u val, void* call_addr) + { + __asm + { + push val; + mov eax, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitThreadInternal(scriptInstance_t inst@, sval_u val, sval_u sourcePos, sval_u endSourcePos, scr_block_s *block) + void EmitThreadInternal(scriptInstance_t inst, sval_u val, sval_u sourcePos, sval_u endSourcePos, scr_block_s* block, void* call_addr) + { + __asm + { + push block; + push endSourcePos; + push sourcePos; + push val; + mov esi, inst; + call call_addr; + add esp, 0x10; + } + } + + // void __usercall Scr_CalcLocalVarsThread(sval_u *stmttblock@, scriptInstance_t inst, sval_u exprlist, sval_u stmtlist) + void Scr_CalcLocalVarsThread(sval_u* stmttblock, scriptInstance_t inst, sval_u exprlist, sval_u stmtlist, void* call_addr) + { + __asm + { + push stmtlist; + push exprlist; + push inst; + mov eax, stmttblock; + call call_addr; + add esp, 0xC; + } + } + + // void __usercall InitThread(int type@, scriptInstance_t inst@) + void InitThread(int type_, scriptInstance_t inst, void* call_addr) + { + __asm + { + mov ecx, type_; + mov esi, inst; + call call_addr; + } + } + + // void __usercall EmitNormalThread(scriptInstance_t inst@, sval_u val, sval_u *stmttblock) + void EmitNormalThread(scriptInstance_t inst, sval_u val, sval_u* stmttblock, void* call_addr) + { + __asm + { + push stmttblock; + push val; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitDeveloperThread(scriptInstance_t inst@, sval_u val, sval_u *stmttblock) + void EmitDeveloperThread(scriptInstance_t inst, sval_u val, sval_u* stmttblock, void* call_addr) + { + __asm + { + push stmttblock; + push val; + mov eax, inst; + call call_addr; + add esp, 0x8; + } + } + + // void __usercall EmitThread(scriptInstance_t inst@, sval_u val) + void EmitThread(scriptInstance_t inst, sval_u val, void* call_addr) + { + __asm + { + push val; + mov eax, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall EmitInclude(scriptInstance_t inst@, sval_u val) + void EmitInclude(scriptInstance_t inst, sval_u val, void* call_addr) + { + __asm + { + push val; + mov eax, inst; + call call_addr; + add esp, 0x4; + } + } + + // void __usercall ScriptCompile(scriptInstance_t inst@, sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry *entries, int entriesCount) + void ScriptCompile(scriptInstance_t inst, sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry* entries, int entriesCount, void* call_addr) + { + __asm + { + push entriesCount; + push entries; + push scriptId; + push fileCountId; + push filePosId; + push val; + mov eax, inst; + call call_addr; + add esp, 0x18; + } + } + +}