koffi 1.1.0-beta.1 → 1.1.0-beta.4

package/src/call.hh

@@ -86,10 +86,12 @@ private:
 
     const char *PushString(const Napi::Value &value);
     const char16_t *PushString16(const Napi::Value &value);
-    bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest);
+    bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
+    bool PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
 
-    void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type);
-    Napi::Object PopObject(const uint8_t *ptr, const TypeInfo *type);
+    void PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
+    Napi::Object PopObject(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
+    Napi::Object PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
 };
 
 template <typename T>

package/src/ffi.cc

@@ -72,6 +72,8 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 
     type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
 
+    type->defn.Reset(obj, 1);
+
     type->primitive = PrimitiveKind::Record;
     type->align = 1;
 
@@ -85,6 +87,10 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         member.type = ResolveType(instance, value);
         if (!member.type)
             return env.Null();
+        if (member.type->primitive == PrimitiveKind::Void) {
+            ThrowError<Napi::TypeError>(env, "Type Void cannot be used as a member");
+            return env.Null();
+        }
 
         member.align = pad ? member.type->align : 1;
 
@@ -241,6 +247,112 @@ static Napi::Value MarkInOut(const Napi::CallbackInfo &info)
     return EncodePointerDirection(info, 3);
 }
 
+static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 2) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+    if (!info[1].IsNumber()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected integer", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+
+    const TypeInfo *ref = ResolveType(instance, info[0]);
+    int64_t len = (uint16_t)info[1].As<Napi::Number>().Int64Value();
+
+    if (!ref)
+        return env.Null();
+    if (len <= 0) {
+        ThrowError<Napi::TypeError>(env, "Array length must be non-zero positive");
+        return env.Null();
+    }
+    if (len > INT16_MAX / ref->size) {
+        ThrowError<Napi::TypeError>(env, "Array length is too high (max = %1)", INT16_MAX / ref->size);
+        return env.Null();
+    }
+
+    TypeInfo *type = instance->types.AppendDefault();
+    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
+
+    type->name = Fmt(&instance->str_alloc, "%1[%2]", ref->name, len).ptr;
+
+    type->primitive = PrimitiveKind::Array;
+    type->align = ref->align;
+    type->size = (int16_t)(len * ref->size);
+    type->ref = ref;
+
+    // If the insert succeeds, we cannot fail anymore
+    if (!instance->types_map.TrySet(type).second) {
+        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+        return env.Null();
+    }
+    err_guard.Disable();
+
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    return external;
+}
+
+static Napi::Value GetTypeSize(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(instance, info[0]);
+    if (!type)
+        return env.Null();
+
+    return Napi::Number::New(env, type->size);
+}
+
+static Napi::Value GetTypeAlign(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(instance, info[0]);
+    if (!type)
+        return env.Null();
+
+    return Napi::Number::New(env, type->align);
+}
+
+static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 1) {
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(instance, info[0]);
+    if (!type)
+        return env.Null();
+    if (type->defn.IsEmpty()) {
+        ThrowError<Napi::TypeError>(env, "Definition of type %1 is not available", type->name);
+        return env.Null();
+    }
+
+    return type->defn.Value();
+}
+
 static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
 {
     RG_ASSERT(AlignLen(size, 16) == size);
@@ -324,8 +436,9 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         param.type = ResolveType(instance, info[i], &param.directions);
         if (!param.type)
             return env.Null();
-        if (param.type->primitive == PrimitiveKind::Void) {
-            ThrowError<Napi::TypeError>(env, "Type void cannot be used as a parameter");
+        if (param.type->primitive == PrimitiveKind::Void ||
+                param.type->primitive == PrimitiveKind::Array) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", PrimitiveKindNames[(int)param.type->primitive]);
             return env.Null();
         }
 
@@ -456,6 +569,11 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
     func->ret.type = ResolveType(instance, ret);
     if (!func->ret.type)
         return false;
+    if (func->ret.type->primitive == PrimitiveKind::Array) {
+        ThrowError<Napi::Error>(env, "You are not allowed to directly return fixed-size arrays");
+        return false;
+    }
+
     if (!parameters.IsArray()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, parameters), func->name);
         return false;
@@ -478,8 +596,9 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         param.type = ResolveType(instance, parameters[j], &param.directions);
         if (!param.type)
             return false;
-        if (param.type->primitive == PrimitiveKind::Void) {
-            ThrowError<Napi::TypeError>(env, "Type void cannot be used as a parameter");
+        if (param.type->primitive == PrimitiveKind::Void ||
+                param.type->primitive == PrimitiveKind::Array) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
             return false;
         }
 
@@ -682,6 +801,8 @@ void LibraryHolder::Unref() const
 static void RegisterPrimitiveType(InstanceData *instance, const char *name, PrimitiveKind primitive,
                                   int16_t size, int16_t align)
 {
+    RG_ASSERT(align <= size);
+
     TypeInfo *type = instance->types.AppendDefault();
 
     type->name = name;
@@ -805,6 +926,10 @@ static void SetExports(Napi::Env env, Func func)
     func("pack", Napi::Function::New(env, CreatePackedStructType));
     func("handle", Napi::Function::New(env, CreateHandleType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
+    func("array", Napi::Function::New(env, CreateArrayType));
+    func("sizeof", Napi::Function::New(env, GetTypeSize));
+    func("alignof", Napi::Function::New(env, GetTypeAlign));
+    func("introspect", Napi::Function::New(env, GetTypeDefinition));
     func("load", Napi::Function::New(env, LoadSharedLibrary));
     func("in", Napi::Function::New(env, MarkIn));
     func("out", Napi::Function::New(env, MarkOut));

package/src/ffi.hh

@@ -39,6 +39,7 @@ enum class PrimitiveKind {
     String16,
     Pointer,
     Record,
+    Array,
     Float32,
     Float64
 };
@@ -57,6 +58,7 @@ static const char *const PrimitiveKindNames[] = {
     "String16",
     "Pointer",
     "Record",
+    "Array",
     "Float32",
     "Float64"
 };
@@ -68,12 +70,14 @@ struct TypeInfo {
     const char *name;
     napi_type_tag tag;
 
+    Napi::ObjectReference defn;
+
     PrimitiveKind primitive;
     int16_t size;
     int16_t align;
 
     HeapArray<RecordMember> members; // Record only
-    const TypeInfo *ref; // Pointer only
+    const TypeInfo *ref; // Pointer or array
 
     RG_HASHTABLE_HANDLER(TypeInfo, name);
 };

package/src/parser.cc

@@ -35,6 +35,10 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
     Tokenize(hold.c_str());
 
     func->ret.type = ParseType();
+    if (func->ret.type->primitive == PrimitiveKind::Array) {
+        MarkError("You are not allowed to directly return C arrays");
+        return false;
+    }
     if (Match("__cdecl")) {
         func->convention = CallConvention::Cdecl;
     } else if (Match("__stdcall")) {
@@ -65,8 +69,9 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
             }
 
             param.type = ParseType();
-            if (param.type->primitive == PrimitiveKind::Void) {
-                MarkError("Type void cannot be used as a parameter");
+            if (param.type->primitive == PrimitiveKind::Void ||
+                    param.type->primitive == PrimitiveKind::Array) {
+                MarkError("Type %1 cannot be used as a parameter", param.type->name);
                 return false;
             }
 

package/src/util.cc

@@ -126,4 +126,76 @@ bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *
     return match;
 }
 
+class HfaAnalyser {
+    uint32_t primitives;
+    Size count;
+
+public:
+    bool Analyse(const TypeInfo *type, int min, int max);
+
+private:
+    void AnalyseStruct(const TypeInfo *type);
+    void AnalyseArray(const TypeInfo *type);
+};
+
+bool HfaAnalyser::Analyse(const TypeInfo *type, int min, int max)
+{
+    primitives = 0;
+    count = 0;
+
+    if (type->primitive == PrimitiveKind::Record) {
+        AnalyseStruct(type);
+    } else if (type->primitive == PrimitiveKind::Array) {
+        AnalyseArray(type);
+    } else {
+        return false;
+    }
+
+    bool hfa = (count >= min && count <= max && PopCount(primitives) == 1);
+    return hfa;
+}
+
+void HfaAnalyser::AnalyseStruct(const TypeInfo *type)
+{
+    RG_ASSERT(type->primitive == PrimitiveKind::Record);
+
+    for (const RecordMember &member: type->members) {
+        if (member.type->primitive == PrimitiveKind::Record) {
+            AnalyseStruct(member.type);
+        } else if (member.type->primitive == PrimitiveKind::Array) {
+            AnalyseArray(member.type);
+        } else if (member.type->primitive == PrimitiveKind::Float32 ||
+                   member.type->primitive == PrimitiveKind::Float64) {
+            primitives |= 1u << (int)member.type->primitive;
+            count++;
+        } else {
+            primitives = UINT_MAX;
+            return;
+        }
+    }
+}
+
+void HfaAnalyser::AnalyseArray(const TypeInfo *type)
+{
+    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+
+    if (type->ref->primitive == PrimitiveKind::Record) {
+        AnalyseStruct(type->ref);
+    } else if (type->ref->primitive == PrimitiveKind::Array) {
+        AnalyseArray(type->ref);
+    } else if (type->ref->primitive == PrimitiveKind::Float32 ||
+               type->ref->primitive == PrimitiveKind::Float64) {
+        primitives |= 1u << (int)type->ref->primitive;
+        count += type->size / type->ref->size;;
+    } else {
+        primitives = UINT_MAX;
+    }
+}
+
+bool IsHFA(const TypeInfo *type, int min, int max)
+{
+    HfaAnalyser analyser;
+    return analyser.Analyse(type, min, max);
+}
+
 }

package/src/util.hh

@@ -89,4 +89,6 @@ T CopyNumber(const Napi::Value &value)
     RG_UNREACHABLE();
 }
 
+bool IsHFA(const TypeInfo *type, int min, int max);
+
 }

package/test/misc.c

@@ -60,8 +60,7 @@ typedef struct Float2 {
 } Float2;
 typedef struct Float3 {
     float a;
-    float b;
-    float c;
+    float b[2];
 } Float3;
 
 typedef struct Double2 {
@@ -70,8 +69,10 @@ typedef struct Double2 {
 } Double2;
 typedef struct Double3 {
     double a;
-    double b;
-    double c;
+    struct {
+        double b;
+        double c;
+    } s;
 } Double3;
 
 typedef struct IJK1 { int8_t i; int8_t j; int8_t k; } IJK1;
@@ -185,13 +186,18 @@ EXPORT Float3 PackFloat3(float a, float b, float c, Float3 *out)
     Float3 ret;
 
     ret.a = a;
-    ret.b = b;
-    ret.c = c;
+    ret.b[0] = b;
+    ret.b[1] = c;
     *out = ret;
 
     return ret;
 }
 
+EXPORT Float3 ThroughFloat3(Float3 f3)
+{
+    return f3;
+}
+
 EXPORT Double2 PackDouble2(double a, double b, Double2 *out)
 {
     Double2 ret;
@@ -208,8 +214,8 @@ EXPORT Double3 PackDouble3(double a, double b, double c, Double3 *out)
     Double3 ret;
 
     ret.a = a;
-    ret.b = b;
-    ret.c = c;
+    ret.s.b = b;
+    ret.s.c = c;
     *out = ret;
 
     return ret;

package/vendor/node-addon-api/CODE_OF_CONDUCT.md

@@ -0,0 +1,4 @@
+# Code of Conduct
+
+The Node.js Code of Conduct, which applies to this project, can be found at
+https://github.com/nodejs/admin/blob/HEAD/CODE_OF_CONDUCT.md.

package/vendor/node-addon-api/CONTRIBUTING.md

@@ -0,0 +1,93 @@
+
+# Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+ (a) The contribution was created in whole or in part by me and I
+     have the right to submit it under the open source license
+     indicated in the file; or
+
+ (b) The contribution is based upon previous work that, to the best
+     of my knowledge, is covered under an appropriate open source
+     license and I have the right under that license to submit that
+     work with modifications, whether created in whole or in part
+     by me, under the same open source license (unless I am
+     permitted to submit under a different license), as indicated
+     in the file; or
+
+ (c) The contribution was provided directly to me by some other
+     person who certified (a), (b) or (c) and I have not modified
+     it.
+
+ (d) I understand and agree that this project and the contribution
+     are public and that a record of the contribution (including all
+     personal information I submit with it, including my sign-off) is
+     maintained indefinitely and may be redistributed consistent with
+     this project or the open source license(s) involved.
+
+# **node-addon-api** Contribution Philosophy
+
+The **node-addon-api** team loves contributions. There are many ways in which you can
+contribute to **node-addon-api**:
+- Source code fixes
+- Additional tests
+- Documentation improvements
+- Joining the Node-API working group and participating in meetings
+
+## Source changes
+
+**node-addon-api** is meant to be a thin convenience wrapper around Node-API. With this
+in mind, contributions of any new APIs that wrap around a core Node-API API will
+be considered for merge. However, changes that wrap existing **node-addon-api**
+APIs are encouraged to instead be provided as an ecosystem module. The
+**node-addon-api** team is happy to link to a curated set of modules that build on
+top of **node-addon-api** if they have broad usefulness to the community and promote
+a recommended idiom or pattern.
+
+### Rationale
+
+The Node-API team considered a couple different approaches with regards to changes
+extending **node-addon-api**
+- Larger core module - Incorporate these helpers and patterns into **node-addon-api**
+- Extras package - Create a new package (strawman name '**node-addon-api**-extras')
+that contain utility classes and methods that help promote good patterns and
+idioms while writing native addons with **node-addon-api**.
+- Ecosystem - Encourage creation of a module ecosystem around **node-addon-api**
+where folks can build on top of it.
+
+#### Larger Core
+This is probably our simplest option in terms of immediate action needed. It
+would involve landing any open PRs against **node-addon-api**, and continuing to
+encourage folks to make PRs for utility helpers against the same repository.
+
+The downside of the approach is the following:
+- Less coherency for our API set
+- More maintenance burden on the Node-API WG core team.
+
+#### Extras Package
+This involves us spinning up a new package which contains the utility classes
+and methods. This has the benefit of having a separate module where helpers
+which make it easier to implement certain patterns and idioms for native addons
+easier.
+
+The downside of this approach is the following:
+- Potential for confusion - we'll need to provide clear documentation to help the
+community understand where a particular contribution should be directed to (what
+belongs in **node-addon-api** vs **node-addon-api-extras**)
+- Need to define the level of support/API guarantees
+- Unclear if the maintenance burden on the Node-API WG is reduced or not
+
+#### Ecosystem
+This doesn't require a ton of up-front work from the Node-API WG. Instead of
+accepting utility PRs into **node-addon-api** or creating and maintaining a new
+module, the WG will encourage the creation of an ecosystem of modules that
+build on top of **node-addon-api**, and provide some level of advertising for these
+modules (listing them out on the repository/wiki, using them in workshops/tutorials
+etc).
+
+The downside of this approach is the following:
+- Potential for lack of visibility - evangelism and education is hard, and module
+authors might not find right patterns and instead implement things themselves
+- There might be greater friction for the Node-API WG in evolving APIs since the
+ecosystem would have taken dependencies on the API shape of **node-addon-api**
+

package/vendor/node-addon-api/appveyor.yml

@@ -0,0 +1,37 @@
+environment:
+  # https://github.com/jasongin/nvs/blob/HEAD/doc/CI.md
+  NVS_VERSION: 1.4.2
+  matrix:
+    - NODEJS_VERSION: node/10
+    - NODEJS_VERSION: node/12
+    - NODEJS_VERSION: node/14
+    - NODEJS_VERSION: nightly
+
+os: Visual Studio 2017
+platform:
+  - x86
+  - x64
+
+install:
+  # nvs
+  - git clone --branch v%NVS_VERSION% --depth 1 https://github.com/jasongin/nvs %LOCALAPPDATA%\nvs
+  - set PATH=%LOCALAPPDATA%\nvs;%PATH%
+  - nvs --version
+  # node.js
+  - nvs add %NODEJS_VERSION%/%PLATFORM%
+  - nvs use %NODEJS_VERSION%/%PLATFORM%
+  - node --version
+  - node -p process.arch
+  - npm --version
+  # app
+  - npm install
+
+test_script:
+  - npm test
+
+build: off
+
+version: "{build}"
+
+cache:
+  - node_modules

package/vendor/node-addon-api/benchmark/README.md

@@ -0,0 +1,47 @@
+# Benchmarks
+
+## Running the benchmarks
+
+From the parent directory, run
+
+```bash
+npm run-script benchmark
+```
+
+The above script supports the following arguments:
+
+* `--benchmarks=...`: A semicolon-separated list of benchmark names. These names
+    will be mapped to file names in this directory by appending `.js`.
+
+## Adding benchmarks
+
+The steps below should be followed when adding new benchmarks.
+
+0. Decide on a name for the benchmark. This name will be used in several places.
+   This example will use the name `new_benchmark`.
+
+0. Create files `new_benchmark.cc` and `new_benchmark.js` in this directory.
+
+0. Copy an existing benchmark in `binding.gyp` and change the target name prefix
+    and the source file name to `new_benchmark`. This should result in two new
+    targets which look like this:
+
+    ```gyp
+      {
+        'target_name': 'new_benchmark',
+        'sources': [ 'new_benchmark.cc' ],
+        'includes': [ '../except.gypi' ],
+      },
+      {
+        'target_name': 'new_benchmark_noexcept',
+        'sources': [ 'new_benchmark.cc' ],
+        'includes': [ '../noexcept.gypi' ],
+      },
+    ```
+
+    There should always be a pair of targets: one bearing the name of the
+    benchmark and configured with C++ exceptions enabled, and one bearing the
+    same name followed by the suffix `_noexcept` and configured with C++
+    exceptions disabled. This will ensure that the benchmark can be written to
+    cover both the case where C++ exceptions are enabled and the case where they
+    are disabled.

package/vendor/node-addon-api/benchmark/binding.gyp

@@ -0,0 +1,25 @@
+{
+  'target_defaults': { 'includes': ['../common.gypi'] },
+  'targets': [
+    {
+      'target_name': 'function_args',
+      'sources': [ 'function_args.cc' ],
+      'includes': [ '../except.gypi' ],
+    },
+    {
+      'target_name': 'function_args_noexcept',
+      'sources': [ 'function_args.cc' ],
+      'includes': [ '../noexcept.gypi' ],
+    },
+    {
+      'target_name': 'property_descriptor',
+      'sources': [ 'property_descriptor.cc' ],
+      'includes': [ '../except.gypi' ],
+    },
+    {
+      'target_name': 'property_descriptor_noexcept',
+      'sources': [ 'property_descriptor.cc' ],
+      'includes': [ '../noexcept.gypi' ],
+    },
+  ]
+}