| #include <napi.h> |
| #include <vector> |
| #include <type_traits> |
| #include <utility> |
| #include <sys/mman.h> |
| #include <unistd.h> |
| #include <cstring> |
| #include <stdexcept> |
|
|
| |
| |
| template<class T, class = void> struct HasOverload : std::false_type {}; |
| template<class T> struct HasOverload<T, std::void_t<decltype(T::New( |
| std::declval<napi_env>(), std::declval<napi_value>(), |
| std::declval<std::vector<napi_value>&>(), |
| std::declval<std::vector<napi_value>&>()))>> : std::true_type {}; |
| template<class T, class = void> struct HasPointerOverload : std::false_type {}; |
| template<class T> struct HasPointerOverload<T, std::void_t<decltype(T::New( |
| std::declval<napi_env>(), std::declval<napi_value>(), |
| std::declval<const napi_value*>(), std::declval<const napi_value*>(), |
| std::declval<size_t>()))>> : std::true_type {}; |
| template<class T> Napi::Object Wrapped(napi_env env, napi_value proto, |
| std::vector<napi_value>& names, std::vector<napi_value>& values) { |
| if constexpr (HasPointerOverload<T>::value) { |
| const napi_value* n=names.data(); const napi_value* v=values.data(); |
| return T::New(env, proto, n, v, names.size()); |
| } else if constexpr (HasOverload<T>::value) return T::New(env, proto, names, values); |
| else throw Napi::Error::New(env, "public object construction overload unavailable"); |
| } |
| template<class F> napi_status ReadOnly(F fn, napi_env env, napi_value proto, |
| const napi_value* names, const napi_value* values, size_t n, napi_value* out) { |
| if constexpr (std::is_invocable_r_v<napi_status,F,napi_env,napi_value, |
| const napi_value*,const napi_value*,size_t,napi_value*>) |
| return fn(env, proto, names, values, n, out); |
| else throw Napi::Error::New(env, "public C API rejects read-only arrays"); |
| } |
| struct ReadOnlyStorage { |
| void* memory = nullptr; size_t bytes = 0; |
| explicit ReadOnlyStorage(const std::vector<napi_value>& values) { |
| if (values.empty()) return; |
| size_t page = static_cast<size_t>(sysconf(_SC_PAGESIZE)); |
| bytes = ((values.size()*sizeof(napi_value)+page-1)/page)*page; |
| memory = mmap(nullptr, bytes, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS,-1,0); |
| if (memory == MAP_FAILED) throw std::runtime_error("mmap failed"); |
| std::memcpy(memory, values.data(), values.size()*sizeof(napi_value)); |
| if (mprotect(memory,bytes,PROT_READ)!=0) throw std::runtime_error("mprotect failed"); |
| } |
| ~ReadOnlyStorage() {if(memory && memory!=MAP_FAILED) munmap(memory,bytes);} |
| const napi_value* data() const {return static_cast<const napi_value*>(memory);} |
| }; |
| std::vector<napi_value> Handles(Napi::Array a) { |
| std::vector<napi_value> result; |
| for(uint32_t i=0;i<a.Length();i++) result.push_back(a.Get(i)); |
| return result; |
| } |
| Napi::Value Construct(const Napi::CallbackInfo& info) { |
| auto env=info.Env(); |
| auto mode=info[0].As<Napi::String>().Utf8Value(); |
| napi_value proto=info[1].IsUndefined()?nullptr:static_cast<napi_value>(info[1]); |
| auto names=Handles(info[2].As<Napi::Array>()), values=Handles(info[3].As<Napi::Array>()); |
| const auto beforeNames=names,beforeValues=values; |
| napi_value output=nullptr; napi_status status=napi_ok; |
| try { |
| if(mode=="wrapper") output=Wrapped<Napi::Object>(env,proto,names,values); |
| else { |
| if(names.size()!=values.size()) throw Napi::Error::New(env,"fixture raw length mismatch"); |
| if(mode=="readonly") { |
| ReadOnlyStorage n(names),v(values); |
| status=ReadOnly(&node_api_create_object_with_properties,env,proto,n.data(),v.data(),names.size(),&output); |
| } else if(mode=="mutable") { |
| status=node_api_create_object_with_properties(env,proto,names.data(),values.data(),names.size(),&output); |
| } else throw Napi::Error::New(env,"unknown fixture mode"); |
| } |
| } catch (...) { |
| if(names!=beforeNames||values!=beforeValues) |
| throw Napi::Error::New(env,"caller handle arrays mutated on error"); |
| throw; |
| } |
| if(names!=beforeNames||values!=beforeValues) |
| throw Napi::Error::New(env,"caller handle arrays mutated"); |
| if(status!=napi_ok) throw Napi::Error::New(env,"native construction rejected input"); |
| return Napi::Value(env,output); |
| } |
| Napi::Value Ordinary(const Napi::CallbackInfo& info) { |
| auto env=info.Env();auto a=Napi::Object::New(env); |
| a.Set("value",info[0]);a.Set("answer",Napi::Number::New(env,42)); |
| return a; |
| } |
| Napi::Object Init(Napi::Env env,Napi::Object exports) { |
| exports.Set("construct",Napi::Function::New(env,Construct)); |
| exports.Set("ordinary",Napi::Function::New(env,Ordinary)); |
| exports.Set("wrapperAvailable",Napi::Boolean::New(env,(HasOverload<Napi::Object>::value||HasPointerOverload<Napi::Object>::value))); |
| return exports; |
| } |
| NODE_API_MODULE(object_contract,Init) |
|
|
