ShuriZma
/
project64
mirror of https://github.com/project64/project64.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
project64/Source/Project64/UserInterface/Debugger/ScriptInstance.cpp

1462 lines
31 KiB
C++
Raw Blame History

#include <stdafx.h>
#include "ScriptInstance.h"
#include "ScriptSystem.h"
#include "ScriptHook.h"
#include "Breakpoints.h"
static BOOL ConnectEx(SOCKET s, const SOCKADDR* name, int namelen, PVOID lpSendBuffer,
DWORD dwSendDataLength, LPDWORD lpdwBytesSent, LPOVERLAPPED lpOverlapped);
vector<CScriptInstance*> CScriptInstance::Cache;
void CScriptInstance::CacheInstance(CScriptInstance* _this)
{
Cache.push_back(_this);
}
void CScriptInstance::UncacheInstance(CScriptInstance* _this)
{
for (size_t i = 0; i < Cache.size(); i++)
{
if (Cache[i] == _this)
{
Cache.erase(Cache.begin() + i);
break;
}
}
}
CScriptInstance* CScriptInstance::FetchInstance(duk_context* ctx)
{
for (size_t i = 0; i < Cache.size(); i++)
{
if (Cache[i]->DukContext() == ctx)
{
return Cache[i];
}
}
}
CScriptInstance::CScriptInstance(CDebuggerUI* debugger)
{
m_Debugger = debugger;
m_Ctx = duk_create_heap_default();
m_ScriptSystem = m_Debugger->ScriptSystem();
m_NextListenerId = 0;
m_hIOCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
InitializeCriticalSection(&m_CriticalSection);
CacheInstance(this);
}
CScriptInstance::~CScriptInstance()
{
UncacheInstance(this);
//TerminateThread(m_hThread, 0);
//CloseHandle(m_hThread);
DeleteCriticalSection(&m_CriticalSection);
duk_destroy_heap(m_Ctx);
}
void CScriptInstance::Start(char* path)
{
m_TempPath = path;
CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)StartThread, this, 0, NULL);
}
void CScriptInstance::ForceStop()
{
// Close all files and delete all hooked callbacks
EnterCriticalSection(&m_CriticalSection);
m_ScriptSystem->ClearCallbacksForInstance(this);
CloseAllFiles();
LeaveCriticalSection(&m_CriticalSection);
SetState(STATE_STOPPED);
}
duk_context* CScriptInstance::DukContext()
{
return m_Ctx;
}
INSTANCE_STATE CScriptInstance::GetState()
{
return m_State;
}
void CScriptInstance::SetState(INSTANCE_STATE state)
{
m_State = state;
StateChanged();
}
void CScriptInstance::StateChanged()
{
// todo mutex might be needed here
m_Debugger->Debug_RefreshScriptsWindow();
m_ScriptSystem->DeleteStoppedInstances();
}
DWORD CALLBACK CScriptInstance::StartThread(CScriptInstance* _this)
{
_this->StartScriptProc();
return 0;
}
void CScriptInstance::StartScriptProc()
{
m_hThread = GetCurrentThread();
SetState(STATE_STARTED);
bool bWasUnpaused = false;
if (!g_Settings->LoadBool(GameRunning_CPU_Paused) && g_MMU)
{
// Pause CPU during startup phase
bWasUnpaused = true;
g_System->ExternalEvent(SysEvent_PauseCPU_AppLostFocus);
}
duk_context* ctx = m_Ctx;
duk_push_object(ctx);
duk_put_global_string(ctx, "_native");
duk_get_global_string(ctx, "_native");
duk_put_function_list(ctx, -1, NativeFunctions);
duk_pop(ctx);
const char* apiScript = m_ScriptSystem->APIScript();
duk_int_t apiresult = duk_peval_string(ctx, apiScript);
if (apiresult != 0)
{
MessageBox(NULL, duk_safe_to_string(ctx, -1), "API Script Error", MB_OK | MB_ICONERROR);
return;
}
if (m_TempPath)
{
stdstr fullPath = stdstr_f("Scripts/%s", m_TempPath);
duk_int_t scriptresult = duk_peval_file(ctx, fullPath.c_str());
m_TempPath = NULL;
if (scriptresult != 0)
{
const char* errorText = duk_safe_to_string(ctx, -1);
//MessageBox(NULL, duk_safe_to_string(ctx, -1), "Script error", MB_OK | MB_ICONWARNING);
m_Debugger->Debug_LogScriptsWindow(errorText);
m_Debugger->Debug_LogScriptsWindow("\r\n");
SetState(STATE_STOPPED);
return;
}
}
if (bWasUnpaused)
{
g_System->ExternalEvent(SysEvent_ResumeCPU_AppGainedFocus);
}
if (HaveEvents())
{
StartEventLoop();
}
else
{
SetState(STATE_STOPPED);
}
}
void CScriptInstance::StartEventLoop()
{
SetState(STATE_RUNNING);
// Todo interrupt with an apc when an event is removed and event count is 0
while (HaveEvents())
{
IOLISTENER* lpListener;
EVENT_STATUS status = WaitForEvent(&lpListener);
if (status == EVENT_STATUS_INTERRUPTED)
{
continue;
}
if (status == EVENT_STATUS_ERROR)
{
break;
}
InvokeListenerCallback(lpListener);
RemoveListener(lpListener);
}
SetState(STATE_STOPPED);
}
CScriptInstance::EVENT_STATUS
CScriptInstance::WaitForEvent(IOLISTENER** lpListener)
{
DWORD nBytesTransferred;
ULONG_PTR completionKey;
OVERLAPPED* lpUsedOverlap;
BOOL status = GetQueuedCompletionStatus(
m_hIOCompletionPort,
&nBytesTransferred,
&completionKey,
&lpUsedOverlap,
INFINITE
);
if (!status)
{
*lpListener = NULL;
DWORD errorCode = GetLastError();
if (errorCode == STATUS_USER_APC)
{
return EVENT_STATUS_INTERRUPTED;
}
return EVENT_STATUS_ERROR;
}
*lpListener = (IOLISTENER*)lpUsedOverlap;
(*lpListener)->dataLen = nBytesTransferred;
return EVENT_STATUS_OK;
}
bool CScriptInstance::HaveEvents()
{
return
(m_Listeners.size() > 0) ||
m_ScriptSystem->HasCallbacksForInstance(this);
}
void CScriptInstance::AddFile(HANDLE fd, bool bSocket)
{
IOFD iofd;
iofd.fd = fd;
iofd.iocp = CreateIoCompletionPort(fd, m_hIOCompletionPort, (ULONG_PTR)fd, 0);
iofd.bSocket = bSocket;
m_Files.push_back(iofd);
}
void CScriptInstance::CloseFile(HANDLE fd)
{
// Causes EVT_READ with length 0
// Not safe to remove listeners until then
for (uint32_t i = 0; i < m_Files.size(); i++)
{
IOFD iofd = m_Files[i];
if (iofd.fd != fd)
{
continue;
}
// Close file handle
if (iofd.bSocket)
{
closesocket((SOCKET)iofd.fd);
}
else
{
CloseHandle(iofd.fd);
}
break;
}
}
void CScriptInstance::CloseAllFiles()
{
// Causes EVT_READ with length 0
// Not safe to remove listeners until then
for (uint32_t i = 0; i < m_Files.size(); i++)
{
IOFD iofd = m_Files[i];
// Close file handle
if (iofd.bSocket)
{
closesocket((SOCKET)iofd.fd);
}
else
{
CloseHandle(iofd.fd);
}
}
}
void CScriptInstance::RemoveFile(HANDLE fd)
{
// Stop tracking an fd and remove all of its listeners
for (uint32_t i = 0; i < m_Files.size(); i++)
{
IOFD iofd = m_Files[i];
if (iofd.fd != fd)
{
continue;
}
m_Files.erase(m_Files.begin() + i);
RemoveListenersByFd(fd);
break;
}
}
HANDLE CScriptInstance::CreateSocket()
{
HANDLE fd = (HANDLE)WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
AddFile(fd, true);
return fd;
}
CScriptInstance::IOLISTENER*
CScriptInstance::AddListener(HANDLE fd, IOEVENTTYPE evt, void* callback, void* data, int dataLen)
{
IOLISTENER* lpListener = (IOLISTENER*)malloc(sizeof(IOLISTENER));
memset(lpListener, 0x00, sizeof(IOLISTENER));
lpListener->id = m_NextListenerId++;
lpListener->eventType = evt;
lpListener->fd = fd;
lpListener->callback = callback;
lpListener->data = data;
lpListener->dataLen = dataLen;
m_Listeners.push_back(lpListener);
return lpListener;
}
void CScriptInstance::RemoveListenerByIndex(UINT index)
{
IOLISTENER* lpListener = m_Listeners[index];
if (lpListener->data != NULL)
{
free(lpListener->data);
}
CancelIoEx(lpListener->fd, (LPOVERLAPPED)lpListener);
free(lpListener);
m_Listeners.erase(m_Listeners.begin() + index);
}
// Free listener & its buffer, remove from list
void CScriptInstance::RemoveListener(IOLISTENER* lpListener)
{
for (UINT i = 0; i < m_Listeners.size(); i++)
{
if (m_Listeners[i] == lpListener)
{
RemoveListenerByIndex(i);
break;
}
}
}
void CScriptInstance::RemoveListenersByFd(HANDLE fd)
{
for (UINT i = 0; i < m_Listeners.size(); i++)
{
if (m_Listeners[i]->fd == fd)
{
RemoveListenerByIndex(i);
}
}
}
void CScriptInstance::InvokeListenerCallback(IOLISTENER* lpListener)
{
if (lpListener->callback == NULL)
{
return;
}
EnterCriticalSection(&m_CriticalSection);
duk_push_heapptr(m_Ctx, lpListener->callback);
int nargs = 0;
switch (lpListener->eventType)
{
case EVENT_READ:
nargs = 1;
if (lpListener->dataLen > 0)
{
void* data = duk_push_buffer(m_Ctx, lpListener->dataLen, false);
memcpy(data, lpListener->data, lpListener->dataLen);
}
else
{
// handle must have closed, safe to untrack fd and remove all associated listeners
RemoveFile(lpListener->fd);
// pass null to callback
duk_push_null(m_Ctx);
}
break;
case EVENT_WRITE:
nargs = 1;
duk_push_uint(m_Ctx, lpListener->dataLen); // num bytes written
break;
case EVENT_ACCEPT:
// pass client socket fd to callback
nargs = 1;
duk_push_uint(m_Ctx, (UINT)lpListener->childFd);
break;
case EVENT_CONNECT:
nargs = 0;
break;
}
duk_int_t status = duk_pcall(m_Ctx, nargs);
if (status != DUK_EXEC_SUCCESS)
{
const char* msg = duk_safe_to_string(m_Ctx, -1);
MessageBox(NULL, msg, "Script error", MB_OK | MB_ICONWARNING);
}
LeaveCriticalSection(&m_CriticalSection);
}
const char* CScriptInstance::Eval(const char* jsCode)
{
int result = duk_peval_string(m_Ctx, jsCode);
const char* msg = duk_safe_to_string(m_Ctx, -1);
if (result != 0)
{
MessageBox(NULL, msg, "Script error", MB_OK | MB_ICONWARNING);
}
duk_pop(m_Ctx);
return msg;
}
class PendingEval {
char* m_CodeCopy;
CScriptInstance* m_ScriptInstance;
public:
PendingEval(CScriptInstance* instance, const char* jsCode)
{
m_CodeCopy = (char*)malloc(strlen(jsCode));
m_ScriptInstance = instance;
MessageBox(NULL, "pending eval created", "", MB_OK);
}
~PendingEval()
{
MessageBox(NULL, "pending eval deleted", "", MB_OK);
free(m_CodeCopy);
}
void Run()
{
MessageBox(NULL, "pending eval invoked", "", MB_OK);
m_ScriptInstance->Eval(m_CodeCopy);
}
};
void CScriptInstance::EvalAsync(const char* jsCode)
{
PendingEval* pendingEval = new PendingEval(this, jsCode);
QueueAPC(EvalAsyncCallback, (ULONG_PTR)pendingEval);
}
void CALLBACK CScriptInstance::EvalAsyncCallback(ULONG_PTR _pendingEval)
{
PendingEval* evalWait = (PendingEval*)_pendingEval;
evalWait->Run();
delete evalWait;
}
const char* CScriptInstance::EvalFile(const char* jsPath)
{
int result = duk_peval_file(m_Ctx, jsPath);
const char* msg = duk_safe_to_string(m_Ctx, -1);
if (result != 0)
{
MessageBox(NULL, msg, jsPath, MB_OK | MB_ICONWARNING);
}
duk_pop(m_Ctx);
return msg;
}
void CScriptInstance::Invoke(void* heapptr, uint32_t param)
{
EnterCriticalSection(&m_CriticalSection);
duk_push_heapptr(m_Ctx, heapptr);
duk_push_uint(m_Ctx, param);
duk_int_t status = duk_pcall(m_Ctx, 1);
if (status != DUK_EXEC_SUCCESS)
{
const char* errorText = duk_safe_to_string(m_Ctx, -1);
m_Debugger->Debug_LogScriptsWindow(errorText);
m_Debugger->Debug_LogScriptsWindow("\r\n");
}
duk_pop(m_Ctx);
LeaveCriticalSection(&m_CriticalSection);
}
void CScriptInstance::QueueAPC(PAPCFUNC userProc, ULONG_PTR param)
{
if (m_hThread != NULL)
{
MessageBox(NULL, "apc queued", "", MB_OK);
QueueUserAPC(userProc, m_hThread, param);
}
}
/****************************/
duk_ret_t CScriptInstance::js_ioSockConnect(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
HANDLE fd = (HANDLE)duk_get_uint(ctx, 0);
const char* ipStr = duk_to_string(ctx, 1);
USHORT port = (USHORT)duk_get_uint(ctx, 2);
void* callback = duk_get_heapptr(ctx, 3);
char ipBytes[sizeof(uint32_t)];
sscanf(ipStr, "%hhu.%hhu.%hhu.%hhu", &ipBytes[0], &ipBytes[1], &ipBytes[2], &ipBytes[3]);
SOCKADDR_IN serverAddr;
serverAddr.sin_addr.s_addr = *(uint32_t*)ipBytes;
serverAddr.sin_port = htons(port);
serverAddr.sin_family = AF_INET;
SOCKADDR_IN clientAddr;
clientAddr.sin_addr.s_addr = INADDR_ANY;
clientAddr.sin_port = 0;
clientAddr.sin_family = AF_INET;
::bind((SOCKET)fd, (SOCKADDR*)&clientAddr, sizeof(SOCKADDR));
IOLISTENER* lpListener = _this->AddListener(fd, EVENT_CONNECT, callback);
ConnectEx((SOCKET)fd, (SOCKADDR*)&serverAddr, sizeof(SOCKADDR), NULL, 0, NULL, (LPOVERLAPPED)lpListener);
duk_pop_n(ctx, 4);
return 1;
}
duk_ret_t CScriptInstance::js_ioClose(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
HANDLE fd = (HANDLE)duk_get_uint(ctx, 0);
duk_pop(ctx);
_this->CloseFile(fd);
return 1;
}
duk_ret_t CScriptInstance::js_ioSockCreate(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
HANDLE fd = _this->CreateSocket();
duk_pop_n(ctx, duk_get_top(ctx));
duk_push_int(ctx, (int)fd);
return 1;
}
duk_ret_t CScriptInstance::js_ioSockListen(duk_context* ctx)
{
HANDLE fd = (HANDLE)duk_get_uint(ctx, 0);
USHORT port = (USHORT)duk_get_uint(ctx, 1);
duk_pop_n(ctx, 2);
SOCKADDR_IN serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = INADDR_ANY;
serverAddr.sin_port = htons(port);
if (::bind((SOCKET)fd, (SOCKADDR*)&serverAddr, sizeof(serverAddr)))
{
duk_push_boolean(ctx, false);
return 1;
}
bool listenOkay = listen((SOCKET)fd, 3) == 0;
duk_push_boolean(ctx, listenOkay);
return 1;
}
duk_ret_t CScriptInstance::js_ioSockAccept(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
HANDLE fd = (HANDLE)duk_get_uint(ctx, 0);
void* jsCallback = duk_get_heapptr(ctx, 1);
void* data = malloc(sizeof(SOCKADDR) * 4); // issue?
IOLISTENER* lpListener = _this->AddListener(fd, EVENT_ACCEPT, jsCallback, data, 0);
lpListener->childFd = _this->CreateSocket();
AcceptEx(
(SOCKET)fd,
(SOCKET)lpListener->childFd,
lpListener->data, // local and remote SOCKADDR
0,
sizeof(SOCKADDR_IN) + 16,
sizeof(SOCKADDR_IN) + 16,
NULL,
(LPOVERLAPPED)lpListener
);
duk_pop_n(ctx, 2);
return 1;
}
duk_ret_t CScriptInstance::js_ioRead(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
// (fd, bufferSize, callback)
HANDLE fd = (HANDLE)duk_get_uint(ctx, 0);
size_t bufferSize = duk_get_uint(ctx, 1);
void* jsCallback = duk_get_heapptr(ctx, 2);
void* data = malloc(bufferSize); // freed after event is fired
IOLISTENER* lpListener = _this->AddListener(fd, EVENT_READ, jsCallback, data, bufferSize);
BOOL status = ReadFile(fd, lpListener->data, lpListener->dataLen, NULL, (LPOVERLAPPED)lpListener);
if (status == false && GetLastError() != ERROR_IO_PENDING)
{
MessageBox(NULL, "readex error", "", MB_OK);
}
duk_pop_n(ctx, 3);
return 1;
}
duk_ret_t CScriptInstance::js_ioWrite(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
HANDLE fd = (HANDLE)duk_get_uint(ctx, 0);
duk_size_t dataLen;
void* jsData = duk_to_buffer(ctx, 1, &dataLen);
void* jsCallback = duk_get_heapptr(ctx, 2);
char* data = (char*)malloc(dataLen + 1); // freed after event is fired
memcpy(data, jsData, dataLen);
data[dataLen] = '\0';
IOLISTENER* lpListener = _this->AddListener(fd, EVENT_WRITE, jsCallback, data, dataLen);
WriteFile(fd, lpListener->data, lpListener->dataLen, NULL, (LPOVERLAPPED)lpListener);
duk_pop_n(ctx, 3);
return 1;
}
duk_ret_t CScriptInstance::js_AddCallback(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
const char* hookId;
void* heapptr;
uint32_t param = 0;
uint32_t param2 = 0;
bool bOnce = false;
int argc = duk_get_top(ctx);
hookId = duk_get_string(ctx, 0);
heapptr = duk_get_heapptr(ctx, 1);
if (argc >= 3)
{
param = duk_get_uint(ctx, 2);
if (argc > 3)
{
param2 = duk_get_uint(ctx, 3);
if (argc > 4)
{
bOnce = duk_get_boolean(ctx, 4) != 0;
}
}
}
int callbackId = -1;
CScriptHook* hook = _this->m_ScriptSystem->GetHook(hookId);
if (hook != NULL)
{
callbackId = hook->Add(_this, heapptr, param, param2, bOnce);
}
duk_pop_n(ctx, argc);
duk_push_int(ctx, callbackId);
return 1;
}
duk_ret_t CScriptInstance::js_RemoveCallback(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
int callbackId = duk_get_int(ctx, 0);
_this->m_ScriptSystem->RemoveCallbackById(callbackId);
duk_pop(ctx);
return 1;
}
duk_ret_t CScriptInstance::js_GetPCVal(duk_context* ctx)
{
duk_push_uint(ctx, g_Reg->m_PROGRAM_COUNTER);
return 1;
}
duk_ret_t CScriptInstance::js_SetPCVal(duk_context* ctx)
{
uint32_t val = duk_to_uint32(ctx, 0);
g_Reg->m_PROGRAM_COUNTER = val;
duk_pop_n(ctx, 1);
return 1;
}
duk_ret_t CScriptInstance::js_GetLOVal(duk_context* ctx)
{
bool bUpper = duk_get_boolean(ctx, 0) != 0;
duk_pop_n(ctx, 1);
if (!bUpper)
{
duk_push_uint(ctx, g_Reg->m_LO.UW[0]);
}
else
{
duk_push_uint(ctx, g_Reg->m_LO.UW[1]);
}
return 1;
}
duk_ret_t CScriptInstance::js_SetLOVal(duk_context* ctx)
{
bool bUpper = duk_get_boolean(ctx, 0) != 0;
uint32_t val = duk_to_uint32(ctx, 1);
duk_pop_n(ctx, 2);
if (!bUpper)
{
g_Reg->m_LO.UW[0] = val;
}
else
{
g_Reg->m_LO.UW[1] = val;
}
return 1;
}
duk_ret_t CScriptInstance::js_GetHIVal(duk_context* ctx)
{
bool bUpper = duk_get_boolean(ctx, 0) != 0;
duk_pop_n(ctx, 1);
if (!bUpper)
{
duk_push_uint(ctx, g_Reg->m_HI.UW[0]);
}
else
{
duk_push_uint(ctx, g_Reg->m_HI.UW[1]);
}
return 1;
}
duk_ret_t CScriptInstance::js_SetHIVal(duk_context* ctx)
{
bool bUpper = duk_get_boolean(ctx, 0) != 0;
uint32_t val = duk_to_uint32(ctx, 1);
duk_pop_n(ctx, 2);
if (!bUpper)
{
g_Reg->m_HI.UW[0] = val;
}
else
{
g_Reg->m_HI.UW[1] = val;
}
return 1;
}
duk_ret_t CScriptInstance::js_GetGPRVal(duk_context* ctx)
{
int nargs = duk_get_top(ctx);
int regnum = duk_to_int(ctx, 0);
bool bUpper = false;
if (nargs > 1)
{
bUpper = duk_to_boolean(ctx, 1) != 0;
}
duk_pop_n(ctx, nargs);
if (!bUpper)
{
duk_push_uint(ctx, g_Reg->m_GPR[regnum].UW[0]);
}
else
{
duk_push_uint(ctx, g_Reg->m_GPR[regnum].UW[1]);
}
return 1;
}
duk_ret_t CScriptInstance::js_SetGPRVal(duk_context* ctx)
{
int regnum = duk_to_int(ctx, 0);
bool bUpper = duk_to_boolean(ctx, 1) != 0;
uint32_t val = duk_to_uint32(ctx, 2);
if (!bUpper)
{
g_Reg->m_GPR[regnum].UW[0] = val;
}
else
{
g_Reg->m_GPR[regnum].UW[1] = val;
}
duk_pop_n(ctx, 3);
return 1;
}
duk_ret_t CScriptInstance::js_GetFPRVal(duk_context* ctx)
{
int nargs = duk_get_top(ctx);
int regnum = duk_to_int(ctx, 0);
bool bDouble = false;
if (nargs > 1)
{
bDouble = duk_get_boolean(ctx, 1) != 0;
}
duk_pop_n(ctx, nargs);
if (!bDouble)
{
duk_push_number(ctx, (duk_double_t)*g_Reg->m_FPR_S[regnum]);
}
else
{
duk_push_number(ctx, (duk_double_t)*g_Reg->m_FPR_D[regnum & 0x1E]);
}
return 1;
}
duk_ret_t CScriptInstance::js_SetFPRVal(duk_context* ctx)
{
int regnum = duk_to_int(ctx, 0);
bool bDouble = duk_to_boolean(ctx, 1) != 0;
duk_double_t val = duk_to_number(ctx, 2);
if (!bDouble)
{
*g_Reg->m_FPR_S[regnum] = (float)val;
}
else
{
*g_Reg->m_FPR_D[regnum & 0x1E] = val;
}
duk_pop_n(ctx, 3);
return 1;
}
duk_ret_t CScriptInstance::js_GetROMInt(duk_context* ctx)
{
uint32_t address = duk_to_uint32(ctx, 0) & 0x0FFFFFFF;
int bitwidth = duk_to_int(ctx, 1);
duk_bool_t bSigned = duk_to_boolean(ctx, 2);
duk_pop_n(ctx, 3);
if (g_Rom == NULL)
{
goto return_err;
}
uint8_t* rom = g_Rom->GetRomAddress(); // little endian
uint32_t romSize = g_Rom->GetRomSize();
if (address > romSize)
{
goto return_err;
}
DWORD retval;
switch (bitwidth)
{
case 8:
{
uint8_t val = rom[address ^ 0b11];
retval = bSigned ? (char)val : val;
break;
}
case 16:
{
uint16_t val = *(uint16_t*)&rom[address ^ 0b10];
retval = bSigned ? (short)val : val;
break;
}
case 32:
{
uint32_t val = *(uint32_t*)&rom[address];
retval = bSigned ? (int)val : val;
break;
}
default:
goto return_err;
}
if (bSigned)
{
duk_push_int(ctx, retval);
}
else
{
duk_push_uint(ctx, retval);
}
return 1;
return_err:
duk_push_boolean(ctx, false);
return 1;
}
duk_ret_t CScriptInstance::js_GetROMFloat(duk_context* ctx)
{
int argc = duk_get_top(ctx);
uint32_t address = duk_to_uint32(ctx, 0);
duk_bool_t bDouble = false;
if (argc > 1)
{
bDouble = duk_get_boolean(ctx, 1);
}
duk_pop_n(ctx, argc);
if (g_Rom == NULL)
{
goto return_err;
}
uint8_t* rom = g_Rom->GetRomAddress(); // little endian
uint32_t romSize = g_Rom->GetRomSize();
if (address > romSize)
{
goto return_err;
}
if (!bDouble)
{
float value = *(float*)&rom[address];
duk_push_number(ctx, (double)value);
return 1;
}
uint8_t raw[8];
memcpy(&raw[0], &rom[address + 4], 4);
memcpy(&raw[4], &rom[address], 4);
double value;
memcpy(&value, raw, 8);
duk_push_number(ctx, value);
return 1;
return_err:
duk_push_boolean(ctx, false);
return 1;
}
duk_ret_t CScriptInstance::js_GetRDRAMInt(duk_context* ctx)
{
uint32_t address = duk_to_uint32(ctx, 0);
int bitwidth = duk_to_int(ctx, 1);
duk_bool_t bSigned = duk_to_boolean(ctx, 2);
duk_pop_n(ctx, 3);
if (g_MMU == NULL)
{
goto return_err;
}
DWORD retval;
switch (bitwidth)
{
case 8:
{
uint8_t val;
if (!g_MMU->LB_VAddr(address, val))
{
goto return_err;
}
retval = bSigned ? (char)val : val;
break;
}
case 16:
{
uint16_t val;
if (!g_MMU->LH_VAddr(address, val))
{
goto return_err;
}
retval = bSigned ? (short)val : val;
break;
}
case 32:
{
uint32_t val;
if (!g_MMU->LW_VAddr(address, val))
{
goto return_err;
}
retval = bSigned ? (int)val : val;
break;
}
default:
goto return_err;
}
if (bSigned)
{
duk_push_int(ctx, retval);
}
else
{
duk_push_uint(ctx, retval);
}
return 1;
return_err:
duk_push_boolean(ctx, false);
return 1;
}
duk_ret_t CScriptInstance::js_SetRDRAMInt(duk_context* ctx)
{
uint32_t address = duk_to_uint32(ctx, 0);
int bitwidth = duk_to_int(ctx, 1);
DWORD newValue = duk_to_uint32(ctx, 2);
duk_pop_n(ctx, 3);
if (g_MMU == NULL)
{
goto return_err;
}
switch (bitwidth)
{
case 8:
if (!g_MMU->SB_VAddr(address, (uint8_t)newValue))
{
goto return_err;
}
goto return_ok;
case 16:
if (!g_MMU->SH_VAddr(address, (uint16_t)newValue))
{
goto return_err;
}
goto return_ok;
case 32:
if (!g_MMU->SW_VAddr(address, (uint32_t)newValue))
{
goto return_err;
}
goto return_ok;
default:
goto return_err;
}
return_ok:
duk_push_boolean(ctx, true);
return 1;
return_err:
duk_push_boolean(ctx, false);
return 1;
}
duk_ret_t CScriptInstance::js_GetRDRAMFloat(duk_context* ctx)
{
int argc = duk_get_top(ctx);
uint32_t address = duk_to_uint32(ctx, 0);
duk_bool_t bDouble = false;
if (argc > 1)
{
bDouble = duk_get_boolean(ctx, 1);
}
duk_pop_n(ctx, argc);
if (g_MMU == NULL)
{
goto return_err;
}
if (!bDouble)
{
uint32_t rawValue;
if (!g_MMU->LW_VAddr(address, rawValue))
{
goto return_err;
}
float floatValue;
memcpy(&floatValue, &rawValue, sizeof(float));
duk_push_number(ctx, (double)floatValue);
return 1;
}
uint64_t rawValue;
if (!g_MMU->LD_VAddr(address, rawValue))
{
goto return_err;
}
double floatValue;
memcpy(&floatValue, &rawValue, sizeof(double));
duk_push_number(ctx, floatValue);
return 1;
return_err:
duk_push_boolean(ctx, false);
return 1;
}
duk_ret_t CScriptInstance::js_SetRDRAMFloat(duk_context* ctx)
{
int argc = duk_get_top(ctx);
uint32_t address = duk_to_uint32(ctx, 0);
double value = duk_get_number(ctx, 1);
duk_bool_t bDouble = false;
if (argc > 2)
{
bDouble = duk_get_boolean(ctx, 2);
}
duk_pop_n(ctx, argc);
if (g_MMU == NULL)
{
goto return_err;
}
if (!bDouble)
{
float floatValue = (float)value;
uint32_t rawValue;
memcpy(&rawValue, &floatValue, sizeof(float));
if (!g_MMU->SW_VAddr(address, rawValue))
{
goto return_err;
}
}
else
{
double floatValue = (double)value;
uint64_t rawValue;
memcpy(&rawValue, &floatValue, sizeof(double));
if (!g_MMU->SD_VAddr(address, rawValue))
{
goto return_err;
}
}
duk_push_boolean(ctx, true);
return 1;
return_err:
duk_push_boolean(ctx, false);
return 1;
}
duk_ret_t CScriptInstance::js_GetRDRAMBlock(duk_context* ctx)
{
uint32_t address = duk_get_uint(ctx, 0);
uint32_t size = duk_get_uint(ctx, 1);
duk_pop_n(ctx, 2);
uint8_t* block = (uint8_t*)duk_push_buffer(ctx, size, false);
for (uint32_t i = 0; i < size; i++)
{
g_MMU->LB_VAddr(address + i, block[i]);
}
return 1;
}
duk_ret_t CScriptInstance::js_MsgBox(duk_context* ctx)
{
int argc = duk_get_top(ctx);
const char* msg = duk_to_string(ctx, 0);
const char* caption = "";
if (argc > 1)
{
caption = duk_to_string(ctx, 1);
}
MessageBox(NULL, msg, caption, MB_OK);
duk_pop_n(ctx, argc);
duk_push_boolean(ctx, 1);
return 1;
}
// Return zero-terminated string from ram
duk_ret_t CScriptInstance::js_GetRDRAMString(duk_context* ctx)
{
// (address[, maxLen])
int nargs = duk_get_top(ctx);
uint32_t address = duk_get_uint(ctx, 0);
int maxLen = INT_MAX;
if (nargs > 1)
{
maxLen = duk_get_int(ctx, 1);
if (maxLen == 0)
{
maxLen = INT_MAX;
}
}
uint8_t test = 0xFF;
int len = 0;
// determine length of string
while (len < maxLen && g_MMU->LB_VAddr(address + len, test) && test != 0) // todo protect from ram overrun
{
if ((address & 0xFFFFFF) + len >= g_MMU->RdramSize())
{
break;
}
len++;
}
uint8_t* str = (uint8_t*)malloc(len + 1);
for (int i = 0; i < len; i++)
{
g_MMU->LB_VAddr(address + i, str[i]);
}
str[len] = '\0';
duk_pop_n(ctx, nargs);
duk_push_string(ctx, (char*)str);
free(str); // duk creates internal copy
return 1;
}
// Return zero-terminated string from rom
duk_ret_t CScriptInstance::js_GetROMString(duk_context* ctx)
{
// (address[, maxLen])
int nargs = duk_get_top(ctx);
uint32_t address = duk_get_uint(ctx, 0);
int maxLen = INT_MAX;
if (nargs > 1)
{
maxLen = duk_get_int(ctx, 1);
if (maxLen == 0)
{
maxLen = INT_MAX;
}
}
char* rom = (char*)g_Rom->GetRomAddress();
uint32_t romSize = g_Rom->GetRomSize();
int len = 0;
while (len < maxLen)
{
if (address + len >= romSize)
{
break;
}
if (rom[address + len] == 0)
{
break;
}
len++;
}
char* str = (char*)malloc(len + 1);
for (int i = 0; i < len; i++)
{
str[i] = rom[(address + i) ^ 3];
}
str[len] = '\0';
duk_pop(ctx);
duk_push_string(ctx, str);
free(str); // duk creates internal copy
return 1;
}
// Return zero-terminated string from rom
duk_ret_t CScriptInstance::js_GetROMBlock(duk_context* ctx)
{
uint32_t address = duk_get_uint(ctx, 0);
uint32_t size = duk_get_uint(ctx, 1);
duk_pop_n(ctx, 2);
uint8_t* block = (uint8_t*)duk_push_buffer(ctx, size, false);
uint8_t* rom = g_Rom->GetRomAddress();
memcpy(block, &rom[address], size);
return 1;
}
duk_ret_t CScriptInstance::js_ConsolePrint(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
const char* text = duk_to_string(ctx, 0);
_this->m_Debugger->Debug_LogScriptsWindow(text);
duk_pop_n(ctx, 1);
return 1;
}
duk_ret_t CScriptInstance::js_ConsoleClear(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
_this->m_Debugger->Debug_ClearScriptsWindow();
return 1;
}
duk_ret_t CScriptInstance::js_Pause(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
CBreakpoints* breakpoints = _this->m_Debugger->Breakpoints();
breakpoints->Pause();
return 1;
}
duk_ret_t CScriptInstance::js_ShowCommands(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
int nargs = duk_get_top(ctx);
uint32_t address = 0x80000000;
if (nargs == 1)
{
address = duk_get_uint(ctx, 0);
}
duk_pop_n(ctx, nargs);
_this->m_Debugger->Debug_ShowCommandsLocation(address, false);
return 1;
}
duk_ret_t CScriptInstance::js_ScreenPrint(duk_context* ctx)
{
CScriptInstance* _this = FetchInstance(ctx);
HDC hdc = _this->m_ScriptSystem->GetScreenDC();
int nargs = duk_get_top(ctx);
if (nargs != 3)
{
duk_pop_n(ctx, nargs);
return 1;
}
int x = duk_to_int(ctx, 0);
int y = duk_to_int(ctx, 1);
const char* text = duk_to_string(ctx, 2);
int nChars = strlen(text);
TextOut(hdc, x, y, text, nChars);
duk_pop_n(ctx, nargs);
return 1;
}
////////////
static BOOL ConnectEx(SOCKET s, const SOCKADDR* name, int namelen, PVOID lpSendBuffer,
DWORD dwSendDataLength, LPDWORD lpdwBytesSent, LPOVERLAPPED lpOverlapped)
{
LPFN_CONNECTEX ConnectExPtr = NULL;
DWORD nBytes;
GUID guid = WSAID_CONNECTEX;
int fetched = WSAIoctl(
s,
SIO_GET_EXTENSION_FUNCTION_POINTER,
(void*)&guid,
sizeof(GUID),
&ConnectExPtr,
sizeof(LPFN_CONNECTEX),
&nBytes,
NULL,
NULL
);
if (fetched == 0 && ConnectExPtr != NULL)
{
ConnectExPtr(s, name, namelen, lpSendBuffer, dwSendDataLength, lpdwBytesSent, lpOverlapped);
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink