starmen1265/AncientCivil
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d79dbe71dc76ad90b4eddbb3dbdc7e5b692fd3cf
AncientCivil/Plugins/Puerts/Source/JsEnv/Private/FFIBinding.cpp
T
starmen1265 1e0c4b8d8c Init
2025-02-10 00:44:11 +08:00

610 lines
21 KiB
C++
Raw Blame History

/*
* Tencent is pleased to support the open source community by making Puerts available.
* Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
* Puerts is licensed under the BSD 3-Clause License, except for the third-party components listed in the file 'LICENSE' which may
* be subject to their corresponding license terms. This file is subject to the terms and conditions defined in file 'LICENSE',
* which is part of this source code package.
*/
#include "FFIBinding.h"
#ifdef WITH_FFI
#include "JSClassRegister.h"
#include "V8Utils.h"
#if _MSC_VER
#define FFI_BUILDING
#endif
#if PLATFORM_ANDROID_ARM
#include "armeabi-v7a/ffi.h"
#elif PLATFORM_ANDROID_ARM64
#include "arm64-v8a/ffi.h"
#else
#include "ffi.h"
#endif
static FuncPtr* GFuncArray = nullptr;
static uint32_t GFuncArrayLength = 0;
void SetFunctionArray(FuncPtr* FuncArray, uint32_t FuncArrayLength)
{
GFuncArray = FuncArray;
GFuncArrayLength = FuncArrayLength;
}
static v8::Local<v8::Uint8Array> WrapPointer(v8::Isolate* Isolate, void* Ptr, size_t Length)
{
v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(Isolate, Ptr, Length);
return v8::Uint8Array::New(ab, 0, Length);
}
static v8::Local<v8::Uint8Array> WrapPointer(v8::Isolate* Isolate, void* Ptr)
{
return WrapPointer(Isolate, Ptr, 0);
}
static char* ArrayBufferData(v8::Local<v8::Value> Val)
{
if (!Val->IsArrayBufferView())
return nullptr;
auto ui = Val.As<v8::ArrayBufferView>();
auto ab_c = ui->Buffer()->GetContents();
return static_cast<char*>(ab_c.Data()) + ui->ByteOffset();
}
static size_t ArrayBufferLength(v8::Local<v8::Value> Val)
{
if (!Val->IsArrayBufferView())
return 0;
auto ui = Val.As<v8::ArrayBufferView>();
return ui->ByteLength();
}
static bool IsArrayBuffer(v8::Local<v8::Value> Val)
{
return Val->IsArrayBufferView();
}
inline int64_t GetInt64(v8::Local<v8::Value> Val)
{
return Val->IsNumber() ? (Val->IsBigInt() ? Val.As<v8::BigInt>()->Int64Value() : (int64_t) Val.As<v8::Number>()->Value()) : 0;
}
static void FFIPrepCif(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
unsigned int Nargs;
char *Cif, *ArgTypes, *RetType;
ffi_status Status;
ffi_abi Abi;
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (Info.Length() != 5 || !IsArrayBuffer(Info[0]) || !IsArrayBuffer(Info[3]) || !IsArrayBuffer(Info[4]))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "Bad parameters.");
return;
}
Cif = ArrayBufferData(Info[0]);
Abi = (ffi_abi) Info[1]->Uint32Value(Context).ToChecked();
Nargs = Info[2]->Uint32Value(Context).ToChecked();
RetType = ArrayBufferData(Info[3]);
ArgTypes = ArrayBufferData(Info[4]);
Status = ffi_prep_cif(
reinterpret_cast<ffi_cif*>(Cif), Abi, Nargs, reinterpret_cast<ffi_type*>(RetType), reinterpret_cast<ffi_type**>(ArgTypes));
Info.GetReturnValue().Set(v8::Integer::New(Isolate, Status));
}
static void FFIPrepCifVar(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
unsigned int FixArgs, TotoalArgs;
char *Cif, *ArgTypes, *RetType;
ffi_status Status;
ffi_abi Abi;
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (Info.Length() != 6 || !IsArrayBuffer(Info[0]) || !IsArrayBuffer(Info[4]) || !IsArrayBuffer(Info[5]))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "Bad parameters.");
return;
}
Cif = ArrayBufferData(Info[0]);
Abi = (ffi_abi) Info[1]->Uint32Value(Context).ToChecked();
FixArgs = Info[2]->Uint32Value(Context).ToChecked();
TotoalArgs = Info[3]->Uint32Value(Context).ToChecked();
RetType = ArrayBufferData(Info[4]);
ArgTypes = ArrayBufferData(Info[5]);
Status = ffi_prep_cif_var(reinterpret_cast<ffi_cif*>(Cif), Abi, FixArgs, TotoalArgs, reinterpret_cast<ffi_type*>(RetType),
reinterpret_cast<ffi_type**>(ArgTypes));
Info.GetReturnValue().Set(v8::Integer::New(Isolate, Status));
}
class ClosureInfo
{
public:
ClosureInfo(v8::Isolate* InIsolate, v8::Local<v8::Context> InContext, v8::Local<v8::Function> InFunction, void* InCodeLoc,
ffi_closure* InClosure, size_t InRetSize)
: CodeLoc(InCodeLoc)
, Isolate(InIsolate)
, Context(InIsolate, InContext)
, Function(InIsolate, InFunction)
, Closure(InClosure)
, RetSize(InRetSize)
{
}
void* CodeLoc;
v8::Isolate* Isolate;
v8::Global<v8::Context> Context;
v8::Global<v8::Function> Function;
ffi_closure* Closure;
size_t RetSize;
v8::Global<v8::ArrayBuffer> Buffer;
};
static void ClosureWrap(ffi_cif* Cif, void* Ret, void** Args, void* UserData)
{
ClosureInfo* CI = reinterpret_cast<ClosureInfo*>(UserData);
v8::Isolate* Isolate = CI->Isolate;
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = CI->Context.Get(Isolate);
v8::Context::Scope ContextScope(Context);
v8::Local<v8::Value> Argv[2] = {WrapPointer(Isolate, Ret, CI->RetSize), WrapPointer(Isolate, Args, 0)};
CI->Function.Get(CI->Isolate)->Call(Context, Context->Global(), 2, Argv);
}
static void FFIAllocClosure(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (!IsArrayBuffer(Info[0]))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_alloc_closure: Uint32Array expected as #1 argument");
return;
}
if (!Info[1]->IsFunction())
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_alloc_closure: function expected as #2 argument");
return;
}
if (!Info[2]->IsNumber())
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_alloc_closure: number expected as #3 argument");
return;
}
ffi_cif* Cif = reinterpret_cast<ffi_cif*>(ArrayBufferData(Info[0]));
v8::Local<v8::Function> Callback = v8::Local<v8::Function>::Cast(Info[1]);
size_t RetSize = Info[2]->Uint32Value(Context).ToChecked();
void* CodeLoc;
ffi_closure* Closure = reinterpret_cast<ffi_closure*>(ffi_closure_alloc(sizeof(ffi_closure), &CodeLoc));
if (!Closure)
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_alloc_closure: alloc closure fail!");
return;
}
v8::Local<v8::ArrayBuffer> AB = v8::ArrayBuffer::New(Isolate, sizeof(ClosureInfo));
ClosureInfo* CI = new (AB->GetContents().Data()) ClosureInfo(Isolate, Context, Callback, CodeLoc, Closure, RetSize);
ffi_status status = ffi_prep_closure_loc(Closure, Cif, ClosureWrap, CI, CodeLoc);
if (status != FFI_OK)
{
ffi_closure_free(Closure);
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_alloc_closure: ffi_prep_closure_loc fail!");
return;
}
Info.GetReturnValue().Set(v8::Uint8Array::New(AB, 0, sizeof(ClosureInfo)));
}
static void FFIFreeClosure(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (!IsArrayBuffer(Info[0]))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_free_closure: invalid type for #1 argument");
return;
}
if (ArrayBufferLength(Info[0]) != sizeof(ClosureInfo))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_free_closure: #1 argument length not match");
return;
}
ClosureInfo* CI = reinterpret_cast<ClosureInfo*>(ArrayBufferData(Info[0]));
ffi_closure_free(CI->Closure);
CI->~ClosureInfo();
}
static void FFICall(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (Info.Length() != 4)
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_call(): requires 4 arguments!");
return;
}
if (!IsArrayBuffer(Info[0]))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_call(): Uint32Array expected as #1 argument");
return;
}
if (Info[1]->IsNumber())
{
if (Info[1]->Uint32Value(Context).ToChecked() >= GFuncArrayLength)
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_call(): function index out of range!");
return;
}
}
char* Cif = ArrayBufferData(Info[0]);
char* FuncPtr = Info[1]->IsNumber() ? reinterpret_cast<char*>(GFuncArray[Info[1]->Uint32Value(Context).ToChecked()])
: ArrayBufferData(Info[1]);
char* ReturnPtr = ArrayBufferData(Info[2]);
char* ArgsPtr = ArrayBufferData(Info[3]);
#if __OBJC__ || __OBJC2__
// @try {
#endif
ffi_call(
reinterpret_cast<ffi_cif*>(Cif), FFI_FN(FuncPtr), reinterpret_cast<void*>(ReturnPtr), reinterpret_cast<void**>(ArgsPtr));
#if __OBJC__ || __OBJC2__
// } @catch (id ex) {
// PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ffi_call() throw exeption!");
// return;
// }
#endif
Info.GetReturnValue().SetUndefined();
}
static void WritePointer(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (!IsArrayBuffer(Info[0]))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "writePointer: Uint32Array expected as #1 argument");
return;
}
auto Value = Info[1];
if (!(Value->IsNull() || IsArrayBuffer(Value)))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "writePointer: Uint32Array expected as #3 argument");
return;
}
int64_t Offset = GetInt64(Info[2]);
char* Ptr = ArrayBufferData(Info[0]) + Offset;
if (Value->IsNull())
{
*reinterpret_cast<char**>(Ptr) = NULL;
}
else
{
char* ValuePtr = ArrayBufferData(Value);
if (Info.Length() >= 4 && Info[3]->IsNumber())
{
ValuePtr += GetInt64(Info[3]);
}
*reinterpret_cast<char**>(Ptr) = ValuePtr;
}
Info.GetReturnValue().SetUndefined();
}
static void ReadPointer(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (!IsArrayBuffer(Info[0]))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "readPointer: Uint32Array expected as #1 argument");
return;
}
int64_t Offset = GetInt64(Info[1]);
char* Ptr = ArrayBufferData(Info[0]) + Offset;
char* Val = *reinterpret_cast<char**>(Ptr);
size_t Size = !Info[2]->IsNull() ? Info[2]->Uint32Value(Context).ToChecked() : 0;
Info.GetReturnValue().Set(WrapPointer(Isolate, Val, Size));
}
static void WriteUTF8String(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (!IsArrayBuffer(Info[0]))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "WriteString: Uint32Array expected as #1 argument");
return;
}
if (!Info[1]->IsString())
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "WriteString: string expected as #2 argument");
return;
}
v8::String::Utf8Value utf8Str(Isolate, Info[1]);
int64_t Offset = GetInt64(Info[2]);
if (utf8Str.length() >= ArrayBufferLength(Info[0]) - Offset)
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "WriteString: no enough space");
return;
}
char* Ptr = ArrayBufferData(Info[0]) + Offset;
memcpy(Ptr, *utf8Str, utf8Str.length() + 1);
}
static void ReadUTF8String(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (!IsArrayBuffer(Info[0]))
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "ReadCString: Uint32Array expected as #1 argument");
return;
}
int64_t Offset = GetInt64(Info[1]);
char* Ptr = ArrayBufferData(Info[0]) + Offset;
Info.GetReturnValue().Set(PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, Ptr));
}
static void UTF8Length(const v8::FunctionCallbackInfo<v8::Value>& Info)
{
v8::Isolate* Isolate = Info.GetIsolate();
v8::Isolate::Scope IsolateScope(Isolate);
v8::HandleScope HandleScope(Isolate);
v8::Local<v8::Context> Context = Isolate->GetCurrentContext();
v8::Context::Scope ContextScope(Context);
if (!Info[0]->IsString())
{
PUERTS_NAMESPACE::FV8Utils::ThrowException(Isolate, "WriteString: string expected as #2 argument");
return;
}
v8::String::Utf8Value utf8Str(Isolate, Info[0]);
Info.GetReturnValue().Set(utf8Str.length());
}
static void Init(v8::Local<v8::Context> Context, v8::Local<v8::Object> Exports)
{
v8::Isolate* Isolate = Context->GetIsolate();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "ffi_prep_cif"),
v8::FunctionTemplate::New(Isolate, FFIPrepCif)->GetFunction(Context).ToLocalChecked())
.Check();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "ffi_prep_cif_var"),
v8::FunctionTemplate::New(Isolate, FFIPrepCifVar)->GetFunction(Context).ToLocalChecked())
.Check();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "ffi_call"),
v8::FunctionTemplate::New(Isolate, FFICall)->GetFunction(Context).ToLocalChecked())
.Check();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "writePointer"),
v8::FunctionTemplate::New(Isolate, WritePointer)->GetFunction(Context).ToLocalChecked())
.Check();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "readPointer"),
v8::FunctionTemplate::New(Isolate, ReadPointer)->GetFunction(Context).ToLocalChecked())
.Check();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "writeUTF8String"),
v8::FunctionTemplate::New(Isolate, WriteUTF8String)->GetFunction(Context).ToLocalChecked())
.Check();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "readUTF8String"),
v8::FunctionTemplate::New(Isolate, ReadUTF8String)->GetFunction(Context).ToLocalChecked())
.Check();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "UTF8Length"),
v8::FunctionTemplate::New(Isolate, UTF8Length)->GetFunction(Context).ToLocalChecked())
.Check();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "ffi_alloc_closure"),
v8::FunctionTemplate::New(Isolate, FFIAllocClosure)->GetFunction(Context).ToLocalChecked())
.Check();
Exports
->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "ffi_free_closure"),
v8::FunctionTemplate::New(Isolate, FFIFreeClosure)->GetFunction(Context).ToLocalChecked())
.Check();
#define SET_FFI_ENUM(value) \
Exports->DefineOwnProperty(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, #value), \
v8::Integer::New(Isolate, (uint32_t) (value)), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete))
SET_FFI_ENUM(FFI_OK);
SET_FFI_ENUM(FFI_BAD_TYPEDEF);
SET_FFI_ENUM(FFI_BAD_ABI);
SET_FFI_ENUM(FFI_DEFAULT_ABI);
SET_FFI_ENUM(FFI_FIRST_ABI);
SET_FFI_ENUM(FFI_LAST_ABI);
SET_FFI_ENUM(FFI_TYPE_STRUCT);
#undef SET_FFI_ENUM
auto Types = v8::Object::New(Isolate);
#define SET_FFI_TYPE(key, value) \
Types->DefineOwnProperty(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, key), \
WrapPointer(Isolate, reinterpret_cast<char*>(&value)), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete))
SET_FFI_TYPE("void", ffi_type_void);
SET_FFI_TYPE("uint8", ffi_type_uint8);
SET_FFI_TYPE("int8", ffi_type_sint8);
SET_FFI_TYPE("uint16", ffi_type_uint16);
SET_FFI_TYPE("int16", ffi_type_sint16);
SET_FFI_TYPE("uint32", ffi_type_uint32);
SET_FFI_TYPE("int32", ffi_type_sint32);
SET_FFI_TYPE("uint64", ffi_type_uint64);
SET_FFI_TYPE("int64", ffi_type_sint64);
SET_FFI_TYPE("float", ffi_type_float);
SET_FFI_TYPE("double", ffi_type_double);
SET_FFI_TYPE("pointer", ffi_type_pointer);
#undef SET_FFI_TYPE
Exports->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "FFI_TYPES"), Types).Check();
auto SizeOf = v8::Object::New(Isolate);
#define SET_SIZEOF(key, type) \
SizeOf->DefineOwnProperty(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, key), \
v8::Integer::New(Isolate, static_cast<uint32_t>(sizeof(type))), \
static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete))
SET_SIZEOF("uint8", uint8_t);
SET_SIZEOF("int8", int8_t);
SET_SIZEOF("uint16", uint16_t);
SET_SIZEOF("int16", int16_t);
SET_SIZEOF("uint32", uint32_t);
SET_SIZEOF("int32", int32_t);
SET_SIZEOF("uint64", uint64_t);
SET_SIZEOF("int64", int64_t);
SET_SIZEOF("float", float);
SET_SIZEOF("double", double);
SET_SIZEOF("pointer", char*);
#undef SET_SIZEOF
Exports->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "sizeof"), SizeOf).Check();
auto AlignOf = v8::Object::New(Isolate);
#if _MSC_VER
#define SET_ALIGNOF(name, type) \
struct s_##name \
{ \
type a; \
}; \
AlignOf->DefineOwnProperty(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, #name), \
v8::Integer::New(Isolate, static_cast<uint32_t>(alignof(struct s_##name))), \
static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete))
#else
#define SET_ALIGNOF(name, type) \
struct s_##name \
{ \
type a; \
}; \
AlignOf->DefineOwnProperty(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, #name), \
v8::Integer::New(Isolate, static_cast<uint32_t>(__alignof__(struct s_##name))), \
static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete))
#endif
SET_ALIGNOF(uint8, uint8_t);
SET_ALIGNOF(int8, int8_t);
SET_ALIGNOF(uint16, uint16_t);
SET_ALIGNOF(int16, int16_t);
SET_ALIGNOF(uint32, uint32_t);
SET_ALIGNOF(int32, int32_t);
SET_ALIGNOF(uint64, uint64_t);
SET_ALIGNOF(int64, int64_t);
SET_ALIGNOF(float, float);
SET_ALIGNOF(double, double);
SET_ALIGNOF(pointer, char*);
#undef SET_ALIGNOF
Exports->Set(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, "alignof"), AlignOf).Check();
#define SET_Property(key, value) \
Exports->DefineOwnProperty(Context, PUERTS_NAMESPACE::FV8Utils::ToV8String(Isolate, key), \
v8::Integer::New(Isolate, (uint32_t) (value)), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete))
SET_Property("FFI_ARG_SIZE", sizeof(ffi_arg));
SET_Property("FFI_SARG_SIZE", sizeof(ffi_sarg));
SET_Property("FFI_TYPE_SIZE", sizeof(ffi_type));
SET_Property("FFI_CIF_SIZE", sizeof(ffi_cif));
SET_Property("POINTER_SIZE", sizeof(char*));
#undef SET_Property
}
PUERTS_MODULE(ffi_bindings, Init);
#else
void SetFunctionArray(FuncPtr* FuncArray, uint32_t FuncArrayLength)
{
}
#endif
Reference in New Issue View Git Blame Copy Permalink