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/ScriptAPI/ScriptAPI.cpp

1034 lines
30 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "N64Image.h"
#include "ScriptAPI.h"
#include <dwrite.h>
#pragma warning(disable : 4702) // disable unreachable code warning
void ScriptAPI::InitEnvironment(duk_context * ctx, CScriptInstance * inst)
{
duk_push_global_object(ctx);
duk_push_string(ctx, "global");
duk_dup(ctx, -2);
duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_ENUMERABLE);
duk_pop(ctx);
duk_push_global_object(ctx);
duk_push_string(ctx, "PJ64_JSAPI_VERSION");
duk_push_string(ctx, PJ64_JSAPI_VERSION);
duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_ENUMERABLE);
duk_pop(ctx);
duk_module_duktape_init(ctx);
duk_get_global_string(ctx, "Duktape");
duk_push_c_function(ctx, js_Duktape_modSearch, 4);
duk_put_prop_string(ctx, -2, "modSearch");
duk_pop(ctx);
duk_push_pointer(ctx, inst);
duk_put_global_string(ctx, HS_gInstancePtr);
duk_push_object(ctx); // callbackId => { hookId, callbackId, function }
duk_put_global_string(ctx, HS_gAppCallbacks);
duk_push_object(ctx); // fd => { fp }
duk_put_global_string(ctx, HS_gOpenFileDescriptors);
duk_push_array(ctx); // [{modPtr: hModule}, ...]
duk_put_global_string(ctx, HS_gNativeModules);
duk_push_int(ctx, 0);
duk_put_global_string(ctx, HS_gNextObjectRefId);
duk_push_object(ctx); // { refId: object, ... }
duk_put_global_string(ctx, HS_gObjectRefs);
duk_push_int(ctx, 0);
duk_put_global_string(ctx, HS_gNextInvervalId);
duk_push_object(ctx); // { intervalId: { func, worker }, ... }
duk_put_global_string(ctx, HS_gIntervals);
Define_asm(ctx);
Define_console(ctx);
Define_cpu(ctx);
Define_debug(ctx);
Define_events(ctx);
Define_fs(ctx);
Define_mem(ctx);
Define_pj64(ctx);
Define_script(ctx);
Define_alert(ctx);
Define_exec(ctx);
Define_interval(ctx);
Define_AddressRange(ctx);
Define_N64Image(ctx);
Define_Server(ctx);
Define_Socket(ctx);
Define_Number_prototype_hex(ctx);
DefineGlobalConstants(ctx);
if (duk_get_top(ctx) > 0)
{
inst->System()->ConsoleLog("[SCRIPTSYS]: warning: duktape stack is dirty after API init");
}
}
void ScriptAPI::DefineGlobalClass(duk_context * ctx, const char * className,
duk_c_function constructorFunc,
const DukPropListEntry * prototypeProps,
const DukPropListEntry * staticProps)
{
duk_push_global_object(ctx);
duk_push_string(ctx, className);
duk_push_c_function(ctx, constructorFunc, DUK_VARARGS);
duk_push_string(ctx, "name");
duk_push_string(ctx, className);
duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE);
if (staticProps != nullptr)
{
DukPutPropList(ctx, -1, staticProps);
}
duk_push_object(ctx); // prototype
duk_push_string(ctx, className);
duk_put_prop_string(ctx, -2, DUK_WELLKNOWN_SYMBOL("Symbol.toStringTag"));
if (prototypeProps != nullptr)
{
DukPutPropList(ctx, -1, prototypeProps);
}
duk_freeze(ctx, -1);
duk_put_prop_string(ctx, -2, "prototype");
duk_freeze(ctx, -1);
duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_ENUMERABLE);
duk_pop(ctx);
}
void ScriptAPI::DefineGlobalInterface(duk_context * ctx, const char * name, const DukPropListEntry * props)
{
duk_push_global_object(ctx);
duk_push_string(ctx, name);
duk_push_object(ctx);
DukPutPropList(ctx, -1, props);
duk_freeze(ctx, -1);
duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_ENUMERABLE);
duk_pop(ctx);
}
void ScriptAPI::DefineGlobalFunction(duk_context * ctx, const char * name, duk_c_function func)
{
duk_push_global_object(ctx);
duk_push_string(ctx, name);
duk_push_c_function(ctx, func, DUK_VARARGS);
duk_freeze(ctx, -1);
duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_ENUMERABLE);
duk_pop(ctx);
}
void ScriptAPI::DefineGlobalConstants(duk_context * ctx)
{
const duk_number_list_entry numbers[] = {
{"u8", U8},
{"u16", U16},
{"u32", U32},
{"s8", S8},
{"s16", S16},
{"s32", S32},
{"f32", F32},
{"f64", F64},
{"s64", S64},
{"u64", U64},
{"GPR_R0", GPR_R0},
{"GPR_AT", GPR_AT},
{"GPR_V0", GPR_V0},
{"GPR_V1", GPR_V1},
{"GPR_A0", GPR_A0},
{"GPR_A1", GPR_A1},
{"GPR_A2", GPR_A2},
{"GPR_A3", GPR_A3},
{"GPR_T0", GPR_T0},
{"GPR_T1", GPR_T1},
{"GPR_T2", GPR_T2},
{"GPR_T3", GPR_T3},
{"GPR_T4", GPR_T4},
{"GPR_T5", GPR_T5},
{"GPR_T6", GPR_T6},
{"GPR_T7", GPR_T7},
{"GPR_S0", GPR_S0},
{"GPR_S1", GPR_S1},
{"GPR_S2", GPR_S2},
{"GPR_S3", GPR_S3},
{"GPR_S4", GPR_S4},
{"GPR_S5", GPR_S5},
{"GPR_S6", GPR_S6},
{"GPR_S7", GPR_S7},
{"GPR_T8", GPR_T8},
{"GPR_T9", GPR_T9},
{"GPR_K0", GPR_K0},
{"GPR_K1", GPR_K1},
{"GPR_GP", GPR_GP},
{"GPR_SP", GPR_SP},
{"GPR_FP", GPR_FP},
{"GPR_RA", GPR_RA},
//{ "GPR_S8", GPR_S8 },
{"GPR_ANY", 0xFFFFFFFF},
{"RDRAM_CONFIG_REG", 0xA3F00000},
{"RDRAM_DEVICE_TYPE_REG", 0xA3F00000},
{"RDRAM_DEVICE_ID_REG", 0xA3F00004},
{"RDRAM_DELAY_REG", 0xA3F00008},
{"RDRAM_MODE_REG", 0xA3F0000C},
{"RDRAM_REF_INTERVAL_REG", 0xA3F00010},
{"RDRAM_REF_ROW_REG", 0xA3F00014},
{"RDRAM_RAS_INTERVAL_REG", 0xA3F00018},
{"RDRAM_MIN_INTERVAL_REG", 0xA3F0001C},
{"RDRAM_ADDR_SELECT_REG", 0xA3F00020},
{"RDRAM_DEVICE_MANUF_REG", 0xA3F00024},
{"SP_MEM_ADDR_REG", 0xA4040000},
{"SP_DRAM_ADDR_REG", 0xA4040004},
{"SP_RD_LEN_REG", 0xA4040008},
{"SP_WR_LEN_REG", 0xA404000C},
{"SP_STATUS_REG", 0xA4040010},
{"SP_DMA_FULL_REG", 0xA4040014},
{"SP_DMA_BUSY_REG", 0xA4040018},
{"SP_SEMAPHORE_REG", 0xA404001C},
{"SP_PC_REG", 0xA4080000},
{"SP_IBIST_REG", 0xA4080004},
{"DPC_START_REG", 0xA4100000},
{"DPC_END_REG", 0xA4100004},
{"DPC_CURRENT_REG", 0xA4100008},
{"DPC_STATUS_REG", 0xA410000C},
{"DPC_CLOCK_REG", 0xA4100010},
{"DPC_BUFBUSY_REG", 0xA4100014},
{"DPC_PIPEBUSY_REG", 0xA4100018},
{"DPC_TMEM_REG", 0xA410001C},
{"DPS_TBIST_REG", 0xA4200000},
{"DPS_TEST_MODE_REG", 0xA4200004},
{"DPS_BUFTEST_ADDR_REG", 0xA4200008},
{"DPS_BUFTEST_DATA_REG", 0xA420000C},
{"MI_INIT_MODE_REG", 0xA4300000},
{"MI_MODE_REG", 0xA4300000},
{"MI_VERSION_REG", 0xA4300004},
{"MI_NOOP_REG", 0xA4300004},
{"MI_INTR_REG", 0xA4300008},
{"MI_INTR_MASK_REG", 0xA430000C},
{"VI_STATUS_REG", 0xA4400000},
{"VI_CONTROL_REG", 0xA4400000},
{"VI_ORIGIN_REG", 0xA4400004},
{"VI_DRAM_ADDR_REG", 0xA4400004},
{"VI_WIDTH_REG", 0xA4400008},
{"VI_H_WIDTH_REG", 0xA4400008},
{"VI_INTR_REG", 0xA440000C},
{"VI_V_INTR_REG", 0xA440000C},
{"VI_CURRENT_REG", 0xA4400010},
{"VI_V_CURRENT_LINE_REG", 0xA4400010},
{"VI_BURST_REG", 0xA4400014},
{"VI_TIMING_REG", 0xA4400014},
{"VI_V_SYNC_REG", 0xA4400018},
{"VI_H_SYNC_REG", 0xA440001C},
{"VI_LEAP_REG", 0xA4400020},
{"VI_H_SYNC_LEAP_REG", 0xA4400020},
{"VI_H_START_REG", 0xA4400024},
{"VI_H_VIDEO_REG", 0xA4400024},
{"VI_V_START_REG", 0xA4400028},
{"VI_V_VIDEO_REG", 0xA4400028},
{"VI_V_BURST_REG", 0xA440002C},
{"VI_X_SCALE_REG", 0xA4400030},
{"VI_Y_SCALE_REG", 0xA4400034},
{"AI_DRAM_ADDR_REG", 0xA4500000},
{"AI_LEN_REG", 0xA4500004},
{"AI_CONTROL_REG", 0xA4500008},
{"AI_STATUS_REG", 0xA450000C},
{"AI_DACRATE_REG", 0xA4500010},
{"AI_BITRATE_REG", 0xA4500014},
{"PI_DRAM_ADDR_REG", 0xA4600000},
{"PI_CART_ADDR_REG", 0xA4600004},
{"PI_RD_LEN_REG", 0xA4600008},
{"PI_WR_LEN_REG", 0xA460000C},
{"PI_STATUS_REG", 0xA4600010},
{"PI_BSD_DOM1_LAT_REG", 0xA4600014},
{"PI_BSD_DOM1_PWD_REG", 0xA4600018},
{"PI_BSD_DOM1_PGS_REG", 0xA460001C},
{"PI_BSD_DOM1_RLS_REG", 0xA4600020},
{"PI_BSD_DOM2_LAT_REG", 0xA4600024},
{"PI_BSD_DOM2_PWD_REG", 0xA4600028},
{"PI_BSD_DOM2_PGS_REG", 0xA460002C},
{"PI_BSD_DOM2_RLS_REG", 0xA4600030},
{"RI_MODE_REG", 0xA4700000},
{"RI_CONFIG_REG", 0xA4700004},
{"RI_CURRENT_LOAD_REG", 0xA4700008},
{"RI_SELECT_REG", 0xA470000C},
{"RI_REFRESH_REG", 0xA4700010},
{"RI_COUNT_REG", 0xA4700010},
{"RI_LATENCY_REG", 0xA4700014},
{"RI_RERROR_REG", 0xA4700018},
{"RI_WERROR_REG", 0xA470001C},
{"SI_DRAM_ADDR_REG", 0xA4800000},
{"SI_PIF_ADDR_RD64B_REG", 0xA4800004},
{"SI_PIF_ADDR_WR64B_REG", 0xA4800010},
{"SI_STATUS_REG", 0xA4800018},
{"PIF_ROM_START", 0xBFC00000},
{"PIF_RAM_START", 0xBFC007C0},
{"SP_DMEM_START", 0xA4000000},
{"SP_IMEM_START", 0xA4001000},
{"KUBASE", 0x00000000},
{"K0BASE", 0x80000000},
{"K1BASE", 0xA0000000},
{"K2BASE", 0xC0000000},
{"UT_VEC", 0x80000000},
{"R_VEC", 0xBFC00000},
{"XUT_VEC", 0x80000080},
{"ECC_VEC", 0x80000100},
{"E_VEC", 0x80000180},
{"M_GFXTASK", 1},
{"M_AUDTASK", 2},
{"OS_READ", 0},
{"OS_WRITE", 1},
{"COLOR_BLACK", 0x000000FF},
{"COLOR_WHITE", 0xFFFFFFFF},
{"COLOR_GRAY", 0x808080FF},
{"COLOR_RED", 0xFF0000FF},
{"COLOR_GREEN", 0x00FF00FF},
{"COLOR_BLUE", 0x0000FFFF},
{"COLOR_YELLOW", 0xFFFF00FF},
{"COLOR_CYAN", 0x00FFFFFF},
{"COLOR_MAGENTA", 0xFF00FFFF},
{"EMU_STARTED", JS_EMU_STARTED},
{"EMU_STOPPED", JS_EMU_STOPPED},
{"EMU_PAUSED", JS_EMU_PAUSED},
{"EMU_RESUMED", JS_EMU_RESUMED},
{"EMU_RESETTING", JS_EMU_RESETTING},
{"EMU_RESET", JS_EMU_RESET},
{"EMU_LOADED_ROM", JS_EMU_LOADED_ROM},
{"EMU_LOADED_STATE", JS_EMU_LOADED_STATE},
{"EMU_DEBUG_PAUSED", JS_EMU_DEBUG_PAUSED},
{"EMU_DEBUG_RESUMED", JS_EMU_DEBUG_RESUMED},
{"IMG_I4", IMG_I4},
{"IMG_I8", IMG_I8},
{"IMG_IA4", IMG_IA4},
{"IMG_IA8", IMG_IA8},
{"IMG_IA16", IMG_IA16},
{"IMG_RGBA16", IMG_RGBA16},
{"IMG_RGBA32", IMG_RGBA32},
{"IMG_CI8_RGBA16", IMG_CI8_RGBA16},
{"IMG_CI4_RGBA16", IMG_CI4_RGBA16},
{"IMG_CI8_IA16", IMG_CI8_IA16},
{"IMG_CI4_IA16", IMG_CI4_IA16},
{"G_IM_FMT_RGBA", G_IM_FMT_RGBA},
{"G_IM_FMT_YUV", G_IM_FMT_YUV},
{"G_IM_FMT_CI", G_IM_FMT_CI},
{"G_IM_FMT_IA", G_IM_FMT_IA},
{"G_IM_FMT_I", G_IM_FMT_I},
{"G_IM_SIZ_4b", G_IM_SIZ_4b},
{"G_IM_SIZ_8b", G_IM_SIZ_8b},
{"G_IM_SIZ_16b", G_IM_SIZ_16b},
{"G_IM_SIZ_32b", G_IM_SIZ_32b},
{"G_TT_NONE", G_TT_NONE},
{"G_TT_RGBA16", G_TT_RGBA16},
{"G_TT_IA16", G_TT_IA16},
{nullptr, 0},
};
duk_push_global_object(ctx);
duk_put_number_list(ctx, -1, numbers);
duk_pop(ctx);
}
CScriptInstance * ScriptAPI::GetInstance(duk_context * ctx)
{
duk_get_global_string(ctx, HS_gInstancePtr);
CScriptInstance * instance = (CScriptInstance *)duk_get_pointer(ctx, -1);
duk_pop(ctx);
return instance;
}
JSAppCallbackID ScriptAPI::AddAppCallback(duk_context * ctx, duk_idx_t callbackIdx, JSAppHookID hookId,
JSDukArgSetupFunc argSetupFunc, JSAppCallbackCondFunc conditionFunc, JSAppCallbackCleanupFunc cleanupFunc)
{
void * dukFuncHeapPtr = duk_get_heapptr(ctx, callbackIdx);
JSAppCallback cb(GetInstance(ctx), dukFuncHeapPtr, conditionFunc, argSetupFunc, cleanupFunc);
return AddAppCallback(ctx, hookId, cb);
}
JSAppCallbackID ScriptAPI::AddAppCallback(duk_context * ctx, JSAppHookID hookId, JSAppCallback & callback)
{
CScriptInstance * inst = GetInstance(ctx);
JSAppCallbackID callbackId = inst->System()->RawAddAppCallback(hookId, callback);
if (callbackId == JS_INVALID_CALLBACK)
{
inst->System()->ConsoleLog("[SCRIPTSYS]: error: callback was not added");
return JS_INVALID_CALLBACK;
}
duk_get_global_string(ctx, HS_gAppCallbacks);
duk_push_object(ctx);
duk_push_number(ctx, hookId);
duk_put_prop_string(ctx, -2, "hookId");
duk_push_number(ctx, callbackId);
duk_put_prop_string(ctx, -2, "callbackId");
duk_push_heapptr(ctx, callback.m_DukFuncHeapPtr);
duk_put_prop_string(ctx, -2, "func");
duk_push_c_function(ctx, js__AppCallbackFinalizer, 1);
duk_set_finalizer(ctx, -2);
duk_put_prop_index(ctx, -2, callbackId);
duk_pop(ctx);
return callbackId;
}
bool ScriptAPI::RemoveAppCallback(duk_context * ctx, JSAppCallbackID callbackId)
{
duk_get_global_string(ctx, HS_gAppCallbacks);
duk_bool_t bExists = duk_has_prop_index(ctx, -1, callbackId);
if (bExists)
{
// will invoke CallbackFinalizer
duk_del_prop_index(ctx, -1, callbackId);
}
duk_pop(ctx);
return bExists != 0;
}
duk_ret_t ScriptAPI::js__AppCallbackFinalizer(duk_context * ctx)
{
CScriptInstance * inst = ScriptAPI::GetInstance(ctx);
duk_get_prop_string(ctx, 0, "hookId");
duk_get_prop_string(ctx, 0, "callbackId");
JSAppHookID hookId = (JSAppHookID)duk_get_uint(ctx, -2);
JSAppCallbackID callbackId = (JSAppCallbackID)duk_get_uint(ctx, -1);
duk_pop_n(ctx, 2);
inst->System()->RawRemoveAppCallback(hookId, callbackId);
return 0;
}
void ScriptAPI::RefObject(duk_context * ctx, duk_idx_t idx)
{
idx = duk_normalize_index(ctx, idx);
CScriptInstance * inst = GetInstance(ctx);
if (duk_has_prop_string(ctx, idx, HS_objectRefId))
{
return;
}
duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, HS_gNextObjectRefId);
int curObjectId = duk_get_int(ctx, -1);
duk_pop(ctx);
duk_push_int(ctx, curObjectId + 1);
duk_put_prop_string(ctx, -2, HS_gNextObjectRefId);
duk_push_int(ctx, curObjectId);
duk_put_prop_string(ctx, idx, HS_objectRefId);
duk_get_prop_string(ctx, -1, HS_gObjectRefs);
duk_dup(ctx, idx);
duk_put_prop_index(ctx, -2, curObjectId);
duk_pop_n(ctx, 2);
inst->IncRefCount();
}
void ScriptAPI::UnrefObject(duk_context * ctx, duk_idx_t idx)
{
idx = duk_normalize_index(ctx, idx);
CScriptInstance * inst = GetInstance(ctx);
if (!duk_has_prop_string(ctx, idx, HS_objectRefId))
{
return;
}
duk_get_prop_string(ctx, idx, HS_objectRefId);
int objectId = duk_get_int(ctx, -1);
duk_del_prop_string(ctx, idx, HS_objectRefId);
duk_pop(ctx);
duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, HS_gObjectRefs);
duk_del_prop_index(ctx, -1, objectId);
duk_pop_n(ctx, 2);
inst->DecRefCount();
}
// PostCMethodCall variant
duk_ret_t ScriptAPI::js__UnrefObject(duk_context * ctx)
{
duk_push_this(ctx);
UnrefObject(ctx, -1);
return 0;
}
void ScriptAPI::InitEmitter(duk_context * ctx, duk_idx_t obj_idx, const std::vector<std::string> & eventNames)
{
obj_idx = duk_normalize_index(ctx, obj_idx);
duk_push_object(ctx);
std::vector<std::string>::const_iterator it;
for (it = eventNames.begin(); it != eventNames.end(); it++)
{
duk_push_object(ctx);
duk_put_prop_string(ctx, -2, (*it).c_str());
}
duk_put_prop_string(ctx, obj_idx, HS_emitterListeners);
duk_push_int(ctx, 0);
duk_put_prop_string(ctx, obj_idx, HS_emitterNextListenerId);
}
duk_ret_t ScriptAPI::js__Emitter_emit(duk_context * ctx)
{
const char * eventName = duk_get_string(ctx, 0);
duk_idx_t numListenerArgs = duk_get_top(ctx) - 1;
duk_push_this(ctx);
duk_get_prop_string(ctx, -1, HS_emitterListeners);
if (!duk_has_prop_string(ctx, -1, eventName))
{
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "emit: invalid event name '%s'", eventName);
return duk_throw(ctx);
}
duk_get_prop_string(ctx, -1, eventName);
duk_enum(ctx, -1, 0);
int count = 0;
while (duk_next(ctx, -1, (duk_bool_t) true))
{
duk_push_this(ctx);
for (duk_idx_t nArg = 0; nArg < numListenerArgs; nArg++)
{
duk_dup(ctx, 1 + nArg);
}
// [ listenerFunc this args... ] -> [ retval ]
if (duk_pcall_method(ctx, numListenerArgs) != 0)
{
duk_throw(ctx);
}
duk_pop_n(ctx, 2);
count++;
}
// throw if there are no listeners for error event
if (count == 0 && strcmp("error", eventName) == 0)
{
duk_dup(ctx, 1);
duk_throw(ctx);
}
return 0;
}
duk_ret_t ScriptAPI::js__Emitter_on(duk_context * ctx)
{
CheckArgs(ctx, {Arg_String, Arg_Function});
const char * eventName = duk_get_string(ctx, 0);
duk_push_this(ctx);
duk_get_prop_string(ctx, -1, HS_emitterListeners);
if (!duk_has_prop_string(ctx, -1, eventName))
{
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "invalid event name");
return duk_throw(ctx);
}
duk_get_prop_string(ctx, -2, HS_emitterNextListenerId);
duk_size_t nextIdx = duk_get_int(ctx, -1);
duk_pop(ctx);
duk_push_int(ctx, nextIdx + 1);
duk_put_prop_string(ctx, -3, HS_emitterNextListenerId);
duk_get_prop_string(ctx, -1, eventName);
duk_pull(ctx, 1);
duk_put_prop_index(ctx, -2, nextIdx);
duk_push_this(ctx);
return 1;
}
duk_ret_t ScriptAPI::js__Emitter_off(duk_context * ctx)
{
CheckArgs(ctx, {Arg_String, Arg_Function});
const char * eventName = duk_get_string(ctx, 0);
duk_push_this(ctx);
duk_get_prop_string(ctx, -1, HS_emitterListeners);
if (!duk_has_prop_string(ctx, -1, eventName))
{
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "invalid event name");
return duk_throw(ctx);
}
duk_get_prop_string(ctx, -1, eventName);
duk_enum(ctx, -1, 0);
while (duk_next(ctx, -1, (duk_bool_t) true))
{
if (duk_equals(ctx, 1, -1))
{
duk_pop(ctx);
duk_del_prop(ctx, -3);
}
else
{
duk_pop_n(ctx, 2);
}
}
duk_push_this(ctx);
return 1;
}
duk_ret_t ScriptAPI::js_Duktape_modSearch(duk_context * ctx)
{
if (!duk_is_string(ctx, 0))
{
return ThrowInvalidArgsError(ctx);
}
const char * id = duk_get_string(ctx, 0);
stdstr strPath = GetInstance(ctx)->System()->ModulesDirPath() + id;
CPath path(strPath);
if (path.GetExtension() == "dll")
{
HMODULE hModule = LoadLibraryA(strPath.c_str());
if (hModule == nullptr)
{
duk_push_error_object(ctx, DUK_ERR_ERROR,
"failed to load native module (\"%s\")", strPath.c_str());
return duk_throw(ctx);
}
stdstr strProcName = stdstr_f("dukopen_%s", path.GetName().c_str());
duk_c_function fnEntryPoint = (duk_c_function)GetProcAddress(hModule, strProcName.c_str());
if (fnEntryPoint == nullptr)
{
FreeLibrary(hModule);
duk_push_error_object(ctx, DUK_ERR_ERROR,
"failed to locate module entry-point (\"%s\")", strProcName.c_str());
return duk_throw(ctx);
}
duk_push_c_function(ctx, fnEntryPoint, 0);
if (duk_pcall(ctx, 0) != 0)
{
FreeLibrary(hModule);
return duk_throw(ctx);
}
RegisterNativeModule(ctx, hModule);
duk_put_prop_string(ctx, 3, "exports");
return 0;
}
CFile file(strPath.c_str(), CFile::modeRead);
if (!file.IsOpen())
{
return 0;
}
uint32_t length = file.GetLength();
char * sourceCode = new char[length + 1];
sourceCode[length] = '\0';
if (file.Read(sourceCode, length) != length)
{
delete[] sourceCode;
return 0;
}
duk_push_string(ctx, sourceCode);
delete[] sourceCode;
return 1;
}
void ScriptAPI::RegisterNativeModule(duk_context * ctx, HMODULE hModule)
{
duk_get_global_string(ctx, HS_gNativeModules);
duk_size_t index = duk_get_length(ctx, -1);
duk_push_object(ctx);
duk_push_pointer(ctx, hModule);
duk_put_prop_string(ctx, -2, "modPtr");
duk_push_c_function(ctx, js__NativeModuleFinalizer, 1);
duk_set_finalizer(ctx, -2);
duk_put_prop_index(ctx, -2, index);
duk_pop(ctx);
}
duk_ret_t ScriptAPI::js__NativeModuleFinalizer(duk_context * ctx)
{
duk_get_prop_string(ctx, 0, "modPtr");
HMODULE hModule = (HMODULE)duk_get_pointer(ctx, -1);
FreeLibrary(hModule);
return 0;
}
duk_ret_t ScriptAPI::ThrowInvalidArgsError(duk_context * ctx)
{
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "invalid argument(s)");
return duk_throw(ctx);
}
duk_ret_t ScriptAPI::ThrowInvalidArgError(duk_context * ctx, duk_idx_t idx, ArgType wantType)
{
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "argument %d invalid, expected %s", idx, ArgTypeName(wantType));
return duk_throw(ctx);
}
duk_ret_t ScriptAPI::ThrowTooManyArgsError(duk_context * ctx)
{
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "too many arguments");
return duk_throw(ctx);
}
duk_ret_t ScriptAPI::ThrowInvalidAssignmentError(duk_context * ctx, ArgType wantType)
{
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "invalid assignment, expected %s", ArgTypeName(wantType));
return duk_throw(ctx);
}
duk_ret_t ScriptAPI::ThrowNotCallableError(duk_context * ctx)
{
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "not callable");
return duk_throw(ctx);
}
void ScriptAPI::DebugStack(duk_context * ctx, const char * file, int line)
{
duk_push_context_dump(ctx);
GetInstance(ctx)->System()->ConsoleLog("[SCRIPTSYS] <%s:%d> %s", file, line, duk_to_string(ctx, -1));
duk_pop(ctx);
}
void ScriptAPI::AllowPrivateCall(duk_context * ctx, bool bAllow)
{
duk_push_boolean(ctx, (duk_bool_t)bAllow);
duk_put_global_string(ctx, HS_gPrivateCallEnabled);
}
bool ScriptAPI::PrivateCallAllowed(duk_context * ctx)
{
if (!duk_get_global_string(ctx, HS_gPrivateCallEnabled))
{
duk_pop(ctx);
return false;
}
bool bAllowed = duk_get_boolean(ctx, -1);
duk_pop(ctx);
return bAllowed;
}
duk_ret_t ScriptAPI::js_DummyConstructor(duk_context * ctx)
{
return ThrowNotCallableError(ctx);
}
void ScriptAPI::PushNewDummyConstructor(duk_context * ctx, bool bFrozen)
{
duk_push_c_function(ctx, js_DummyConstructor, 0);
duk_push_object(ctx);
duk_put_prop_string(ctx, -2, "prototype");
if (bFrozen)
{
duk_freeze(ctx, -1);
}
}
void ScriptAPI::DefineGlobalDummyConstructors(duk_context * ctx, const char * constructorNames[], bool bFreeze)
{
duk_push_global_object(ctx);
for (size_t i = 0;; i++)
{
if (constructorNames[i] == nullptr)
{
break;
}
duk_push_string(ctx, constructorNames[i]);
PushNewDummyConstructor(ctx, bFreeze);
duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_ENUMERABLE);
}
duk_pop(ctx);
}
void ScriptAPI::SetDummyConstructor(duk_context * ctx, duk_idx_t obj_idx, const char * globalConstructorName)
{
obj_idx = duk_normalize_index(ctx, obj_idx);
duk_get_global_string(ctx, globalConstructorName);
duk_get_prop_string(ctx, -1, "prototype");
duk_set_prototype(ctx, obj_idx);
duk_pop(ctx);
}
void ScriptAPI::DukPutPropList(duk_context * ctx, duk_idx_t obj_idx, const DukPropListEntry * props)
{
obj_idx = duk_normalize_index(ctx, obj_idx);
for (size_t i = 0;; i++)
{
const DukPropListEntry & prop = props[i];
if (prop.key == nullptr)
{
break;
}
duk_uint_t propFlags = 0;
bool bHiddenSymbol = (prop.key[0] == '\xFF');
if (!bHiddenSymbol)
{
propFlags |= prop.writable ? DUK_DEFPROP_SET_WRITABLE : 0;
propFlags |= prop.enumerable ? DUK_DEFPROP_SET_ENUMERABLE : 0;
}
else
{
if (prop.typeId == Type_DukGetter || prop.typeId == Type_DukGetterSetter)
{
// not compatible
g_Notify->BreakPoint(__FILE__, __LINE__);
}
}
duk_push_string(ctx, prop.key);
switch (prop.typeId)
{
case Type_DukNumber:
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_push_number(ctx, prop.value.dukNumber.value);
break;
case Type_DukInt:
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_push_int(ctx, prop.value.dukInt.value);
break;
case Type_DukUInt:
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_push_uint(ctx, prop.value.dukUInt.value);
break;
case Type_DukBoolean:
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_push_boolean(ctx, prop.value.dukBoolean.value);
break;
case Type_DukString:
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_push_string(ctx, prop.value.dukString.value);
break;
case Type_DukPointer:
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_push_pointer(ctx, prop.value.dukPointer.value);
break;
case Type_DukCFunction:
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_push_c_function(ctx, prop.value.dukCFunction.func, prop.value.dukCFunction.nargs);
break;
case Type_DukDupIndex:
{
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_idx_t fixedDupIndex = prop.value.dukDupIndex.value;
if (fixedDupIndex < 0)
{
// -1 to account for prop.key push above
fixedDupIndex = duk_normalize_index(ctx, fixedDupIndex - 1);
}
duk_dup(ctx, fixedDupIndex);
}
break;
case Type_DukGetter:
propFlags |= DUK_DEFPROP_HAVE_GETTER;
duk_push_c_function(ctx, prop.value.dukGetter.value, 0);
break;
case Type_DukGetterSetter:
propFlags |= DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER;
duk_push_c_function(ctx, prop.value.dukGetterSetter.getter, 0);
duk_push_c_function(ctx, prop.value.dukGetterSetter.setter, 1);
break;
case Type_DukObject:
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_push_object(ctx);
if (prop.value.dukObject.props != nullptr)
{
DukPutPropList(ctx, -1, prop.value.dukObject.props);
}
break;
case Type_DukProxy:
propFlags |= DUK_DEFPROP_HAVE_VALUE;
duk_push_object(ctx); // empty target
duk_push_object(ctx); // handler
duk_push_c_function(ctx, prop.value.dukProxy.getter, 2);
duk_put_prop_string(ctx, -2, "get");
duk_push_c_function(ctx, prop.value.dukProxy.setter, 3);
duk_put_prop_string(ctx, -2, "set");
duk_push_proxy(ctx, 0);
break;
default:
g_Notify->BreakPoint(__FILE__, __LINE__);
break;
}
if (bHiddenSymbol)
{
duk_put_prop(ctx, obj_idx);
}
else
{
duk_def_prop(ctx, obj_idx, propFlags);
}
}
}
duk_bool_t ScriptAPI::ArgTypeMatches(duk_context * ctx, duk_idx_t idx, ArgType wantType)
{
ArgType argType = (ArgType)(wantType & (~ArgAttrs));
switch (argType)
{
case Arg_Any:
return true;
case Arg_Number:
return duk_is_number(ctx, idx);
case Arg_BufferData:
return duk_is_buffer_data(ctx, idx);
case Arg_String:
return duk_is_string(ctx, idx);
case Arg_Function:
return duk_is_function(ctx, idx);
case Arg_Object:
return duk_is_object(ctx, idx);
case Arg_Array:
return duk_is_array(ctx, idx);
case Arg_Boolean:
return duk_is_boolean(ctx, idx);
default:
g_Notify->BreakPoint(__FILE__, __LINE__);
return false;
}
return false;
}
const char * ScriptAPI::ArgTypeName(ArgType argType)
{
static const std::map<ArgType, std::string> argTypeNames = {
{Arg_Any, "any"},
{Arg_Number, "number"},
{Arg_BufferData, "bufferdata"},
{Arg_String, "string"},
{Arg_Function, "function"},
{Arg_Object, "object"},
{Arg_Array, "array"},
{Arg_Boolean, "boolean"}};
if (argTypeNames.count(argType) == 0)
{
g_Notify->BreakPoint(__FILE__, __LINE__);
}
return argTypeNames.at(argType).c_str();
}
duk_ret_t ScriptAPI::CheckSetterAssignment(duk_context * ctx, ArgType wantType)
{
if (!ArgTypeMatches(ctx, 0, wantType))
{
return ThrowInvalidAssignmentError(ctx, wantType);
}
return 0;
}
duk_ret_t ScriptAPI::CheckArgs(duk_context * ctx, const std::vector<ArgType> & argTypes)
{
duk_idx_t nargs = duk_get_top(ctx);
if ((size_t)nargs > argTypes.size())
{
return ThrowTooManyArgsError(ctx);
}
duk_idx_t idx = 0;
std::vector<ArgType>::const_iterator it;
for (it = argTypes.begin(); it != argTypes.end(); it++)
{
bool bOptional = (*it & ArgAttr_Optional) != 0;
ArgType argType = (ArgType)(*it & (~ArgAttrs));
if (idx >= nargs)
{
if (bOptional)
{
return 0;
}
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "argument(s) missing", idx);
return duk_throw(ctx);
}
if (!ArgTypeMatches(ctx, idx, argType))
{
return ThrowInvalidArgError(ctx, idx, argType);
}
idx++;
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink