koffi 2.16.1 → 3.0.0-alpha.2

package/src/koffi/src/util.hh

@@ -10,14 +10,36 @@
 
 namespace K {
 
+#if defined(_MSC_VER)
+    #define FORCE_INLINE __forceinline
+#else
+    #define FORCE_INLINE __attribute__((always_inline)) inline
+#endif
+#if defined(UNITY_BUILD)
+    #define INLINE_UNITY FORCE_INLINE
+#else
+    #define INLINE_UNITY
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    #if  __has_attribute(musttail) && __has_attribute(preserve_none)
+        #define MUST_TAIL __attribute__((musttail))
+        #define PRESERVE_NONE __attribute__((preserve_none))
+    #elif  __has_attribute(musttail) && !defined(__clang__)
+        // GCC regalloc seems better, so the generated code is not too bad even without preserve_none
+        #define MUST_TAIL __attribute__((musttail))
+        #define PRESERVE_NONE
+    #endif
+#endif
+
 extern const napi_type_tag TypeInfoMarker;
 extern const napi_type_tag CastMarker;
-extern const napi_type_tag MagicUnionMarker;
+extern const napi_type_tag UnionClassMarker;
 
-class MagicUnion: public Napi::ObjectWrap<MagicUnion> {
+class UnionClass: public Napi::ObjectWrap<UnionClass> {
+    InstanceData *instance;
     const TypeInfo *type;
 
-    Napi::Reference<Napi::Symbol> active_symbol;
     Size active_idx = -1;
 
     HeapArray<uint8_t> raw;
@@ -25,7 +47,9 @@ class MagicUnion: public Napi::ObjectWrap<MagicUnion> {
 public:
     static Napi::Function InitClass(Napi::Env env, const TypeInfo *type);
 
-    MagicUnion(const Napi::CallbackInfo &info);
+    UnionClass(const Napi::CallbackInfo &info);
+
+    void Finalize(Napi::BasicEnv env) override;
 
     const TypeInfo *GetType() { return type; }
     const RecordMember *GetMember() const { return (active_idx >= 0) ? &type->members[active_idx] : nullptr; }
@@ -48,21 +72,21 @@ void ThrowError(Napi::Env env, const char *msg, Args... args)
     err.ThrowAsJavaScriptException();
 }
 
-static inline bool IsInteger(const TypeInfo *type)
+static FORCE_INLINE bool IsInteger(const TypeInfo *type)
 {
     bool integer = ((int)type->primitive >= (int)PrimitiveKind::Int8 &&
                     (int)type->primitive <= (int)PrimitiveKind::UInt64);
     return integer;
 }
 
-static inline bool IsFloat(const TypeInfo *type)
+static FORCE_INLINE bool IsFloat(const TypeInfo *type)
 {
     bool fp = (type->primitive == PrimitiveKind::Float32 ||
                type->primitive == PrimitiveKind::Float64);
     return fp;
 }
 
-static inline bool IsRegularSize(Size size, Size max)
+static FORCE_INLINE bool IsRegularSize(Size size, Size max)
 {
     bool regular = (size <= max && !(size & (size - 1)));
     return regular;
@@ -82,65 +106,235 @@ bool CanPassType(const TypeInfo *type, int directions);
 bool CanReturnType(const TypeInfo *type);
 bool CanStoreType(const TypeInfo *type);
 
+static FORCE_INLINE napi_valuetype GetKindOf(napi_env env, napi_value value)
+{
+    napi_valuetype kind = napi_undefined;
+    napi_typeof(env, value, &kind);
+
+    return kind;
+}
+
+static FORCE_INLINE napi_valuetype GetKindOf(Napi::Value value)
+{
+    return GetKindOf(value.Env(), value);
+}
+
 // Can be slow, only use for error messages
-const char *GetValueType(const InstanceData *instance, Napi::Value value);
+const char *GetValueType(const InstanceData *instance, napi_value value);
 
-void SetValueTag(Napi::Value value, const void *marker);
-bool CheckValueTag(Napi::Value value, const void *marker);
+void SetValueTag(napi_env env, napi_value value, const void *marker);
+bool CheckValueTag(napi_env env, napi_value value, const void *marker);
 
-static inline bool IsNullOrUndefined(Napi::Value value)
+static FORCE_INLINE bool IsNullOrUndefined(napi_valuetype kind)
 {
-    return value.IsNull() || value.IsUndefined();
+    return kind == napi_null || kind == napi_undefined;
 }
 
-static inline bool IsObject(Napi::Value value)
+static FORCE_INLINE bool IsNullOrUndefined(napi_env env, napi_value value)
 {
-    return value.IsObject() && !IsNullOrUndefined(value) && !value.IsArray();
+    napi_valuetype kind = GetKindOf(env, value);
+    return IsNullOrUndefined(kind);
 }
 
-static inline bool IsRawBuffer(Napi::Value value)
+static FORCE_INLINE bool IsArray(napi_env env, napi_value value)
 {
-    return value.IsTypedArray() || value.IsArrayBuffer();
+    bool array = false;
+    napi_is_array(env, value, &array);
+
+    return array;
 }
 
-static inline Span<uint8_t> GetRawBuffer(Napi::Value value)
+static FORCE_INLINE bool IsObject(napi_env env, napi_value value)
 {
-    if (value.IsBuffer()) {
-        void *ptr = nullptr;
-        size_t length = 0;
+    if (GetKindOf(env, value) != napi_object)
+        return false;
+    if (IsArray(env, value))
+        return false;
 
-        // Assume it works
-        napi_get_buffer_info(value.Env(), value, &ptr, &length);
+    return true;
+}
 
-        return MakeSpan((uint8_t *)ptr, (Size)length);
-    } else if (value.IsArrayBuffer()) {
-        Napi::ArrayBuffer buffer = value.As<Napi::ArrayBuffer>();
+static FORCE_INLINE bool IsTypedArray(napi_env env, napi_value value)
+{
+    bool typedarray = false;
+    napi_is_typedarray(env, value, &typedarray);
+    return typedarray;
+}
 
-        return MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
-    }
+static FORCE_INLINE bool IsArrayBuffer(napi_env env, napi_value value)
+{
+    bool arraybuffer = false;
+    napi_is_arraybuffer(env, value, &arraybuffer);
+    return arraybuffer;
+}
 
-    K_UNREACHABLE();
+static FORCE_INLINE bool IsBuffer(napi_env env, napi_value value)
+{
+    bool buffer = false;
+    napi_is_buffer(env, value, &buffer);
+    return buffer;
 }
 
-int GetTypedArrayType(const TypeInfo *type);
+static FORCE_INLINE napi_value GetReferenceValue(napi_env env, napi_ref ref)
+{
+    napi_value value;
 
-template <typename T>
-T GetNumber(Napi::Value value)
+    napi_status status = napi_get_reference_value(env, ref, &value);
+    K_ASSERT(status == napi_ok);
+
+    return value;
+}
+
+static FORCE_INLINE uint32_t GetArrayLength(napi_env env, napi_value array)
 {
-    K_ASSERT(value.IsNumber() || value.IsBigInt());
+    uint32_t length = 0;
 
-    if (value.IsNumber()) [[likely]] {
-        return (T)value.As<Napi::Number>().DoubleValue();
-    } else if (value.IsBigInt()) {
-        Napi::BigInt bigint = value.As<Napi::BigInt>();
+    napi_status status = napi_get_array_length(env, array, &length);
+    K_ASSERT(status == napi_ok);
+
+    return length;
+}
+
+template <typename T>
+static FORCE_INLINE bool TryNumber(napi_env env, napi_value value, T *out_value)
+{
+    T v;
+    napi_status status;
+
+    // Assume number first
+    if constexpr (std::is_same_v<T, double>) {
+        status = napi_get_value_double(env, value, &v);
+    } else if constexpr (std::is_same_v<T, float>) {
+        double d;
+        status = napi_get_value_double(env, value, &d);
+        v = (float)d;
+    } else {
+        int64_t i64;
+        status = napi_get_value_int64(env, value, &i64);
+        v = (T)i64;
+    }
+    if (status == napi_ok) [[likely]] {
+        *out_value = v;
+        return true;
+    }
 
+    // Maybe a BigInt?
+    if constexpr (std::is_signed_v<T>) {
+        int64_t i64;
         bool lossless;
-        return (T)bigint.Uint64Value(&lossless);
+        status = napi_get_value_bigint_int64(env, value, &i64, &lossless);
+        v = (T)i64;
+    } else {
+        uint64_t u64;
+        bool lossless;
+        status = napi_get_value_bigint_uint64(env, value, &u64, &lossless);
+        v = (T)u64;
+    }
+    if (status == napi_ok) {
+        *out_value = v;
+        return true;
     }
 
-    K_UNREACHABLE();
+    return false;
 }
 
+static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_ptr)
+{
+    if (uintptr_t ptr = 0; TryNumber(env, value, &ptr)) {
+        *out_ptr = (void *)ptr;
+        return true;
+    }
+
+    napi_valuetype kind = GetKindOf(env, value);
+
+    if (IsNullOrUndefined(kind)) {
+        *out_ptr = nullptr;
+        return true;
+    } else if (IsTypedArray(env, value)) {
+        napi_get_typedarray_info(env, value, nullptr, nullptr, out_ptr, nullptr, nullptr);
+        return true;
+    } else if (kind == napi_external) {
+        Napi::External<void> external = Napi::External<void>(env, value);
+
+        *out_ptr = (void *)external.Data();
+        return true;
+    } else if (IsArrayBuffer(env, value)) {
+        Napi::ArrayBuffer buffer = Napi::ArrayBuffer(env, value);
+
+        *out_ptr = (void *)buffer.Data();
+        return true;
+    }
+
+    return false;
+}
+
+static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_ptr, bool *out_external)
+{
+    if (uintptr_t ptr = 0; TryNumber(env, value, &ptr)) {
+        *out_ptr = (void *)ptr;
+        *out_external = false;
+
+        return true;
+    }
+
+    napi_valuetype kind = GetKindOf(env, value);
+
+    if (IsNullOrUndefined(kind)) {
+        *out_ptr = nullptr;
+        *out_external = false;
+
+        return true;
+    } else if (IsTypedArray(env, value)) {
+        napi_get_typedarray_info(env, value, nullptr, nullptr, out_ptr, nullptr, nullptr);
+        *out_external = false;
+
+        return true;
+    } else if (kind == napi_external) {
+        Napi::External<void> external = Napi::External<void>(env, value);
+
+        *out_ptr = (void *)external.Data();
+        *out_external = true;
+
+        return true;
+    } else if (IsArrayBuffer(env, value)) {
+        Napi::ArrayBuffer buffer = Napi::ArrayBuffer(env, value);
+
+        *out_ptr = (void *)buffer.Data();
+        *out_external = false;
+
+        return true;
+    }
+
+    return false;
+}
+
+static FORCE_INLINE bool TryBuffer(napi_env env, napi_value value, Span<uint8_t> *out_buffer)
+{
+    // Before somewhere around Node 20.12, napi_get_buffer_info() would assert/crash
+    // when used with something it did not support, instead of returning napi_invalid_arg.
+    // So we need to call napi_is_buffer(), at least for now.
+
+    if (IsBuffer(env, value)) {
+        void *ptr = nullptr;
+        size_t length = 0;
+
+        // Assume it works
+        napi_get_buffer_info(env, value, &ptr, &length);
+
+        *out_buffer = MakeSpan((uint8_t *)ptr, (Size)length);
+        return true;
+    } else if (IsArrayBuffer(env, value)) {
+        Napi::ArrayBuffer buffer = Napi::ArrayBuffer(env, value);
+
+        *out_buffer = MakeSpan((uint8_t *)buffer.Data(), (Size)buffer.ByteLength());
+        return true;
+    }
+
+    return false;
+}
+
+int GetTypedArrayType(const TypeInfo *type);
+
 template <typename T>
 Size NullTerminatedLength(const T *ptr)
 {
@@ -165,10 +359,10 @@ static inline Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *pt
     { return MakeStringFromUTF32(env, ptr, NullTerminatedLength(ptr)); }
 
 Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
-void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type);
-Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len);
+void DecodeObject(Napi::Env env, napi_value obj, const uint8_t *origin, const TypeInfo *type);
 Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
-void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref);
+Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, uint32_t len);
+void DecodeElements(Napi::Env env, napi_value array, const uint8_t *origin, const TypeInfo *ref, uint32_t len);
 void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref);
 
 Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
@@ -177,29 +371,44 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
 bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
 bool Encode(Napi::Env env, uint8_t *ptr, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
 
-static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
-{
-    if (value <= 9007199254740992ll && value >= -9007199254740992ll) {
-        double d = (double)value;
-        return Napi::Number::New(env, d);
-    } else {
-        return Napi::BigInt::New(env, value);
-    }
-}
+static FORCE_INLINE Napi::Value NewInt(Napi::Env env, int8_t i)
+    { napi_value value; napi_create_int32(env, (int32_t)i, &value); return Napi::Value(env, value); }
+static FORCE_INLINE Napi::Value NewInt(Napi::Env env, uint8_t i)
+    { napi_value value; napi_create_uint32(env, (uint32_t)i, &value); return Napi::Value(env, value); }
+static FORCE_INLINE Napi::Value NewInt(Napi::Env env, int16_t i)
+    { napi_value value; napi_create_int32(env, (int32_t)i, &value); return Napi::Value(env, value); }
+static FORCE_INLINE Napi::Value NewInt(Napi::Env env, uint16_t i)
+    { napi_value value; napi_create_uint32(env, (uint32_t)i, &value); return Napi::Value(env, value); }
+static FORCE_INLINE Napi::Value NewInt(Napi::Env env, int32_t i)
+    { napi_value value; napi_create_int32(env, i, &value); return Napi::Value(env, value); }
+static FORCE_INLINE Napi::Value NewInt(Napi::Env env, uint32_t i)
+    { napi_value value; napi_create_uint32(env, i, &value); return Napi::Value(env, value); }
 
-static inline Napi::Value NewBigInt(Napi::Env env, uint64_t value)
+template <typename T>
+static FORCE_INLINE Napi::Value NewInt(Napi::Env env, T i)
 {
-    if (value <= 9007199254740992ull) {
-        double d = (double)value;
-        return Napi::Number::New(env, d);
+    static_assert(sizeof(T) == 8);
+
+    if constexpr (std::is_signed_v<T>) {
+        if (i <= 9007199254740992ll && i >= -9007199254740992ll) {
+            napi_value value;
+            napi_create_int64(env, (int64_t)i, &value);
+            return Napi::Value(env, value);
+        }
     } else {
-        return Napi::BigInt::New(env, value);
+        if (i <= 9007199254740992ull) {
+            napi_value value;
+            napi_create_int64(env, (int64_t)i, &value);
+            return Napi::Value(env, value);
+        }
     }
+
+    return Napi::BigInt::New(env, i);
 }
 
-static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
+static FORCE_INLINE Napi::Array GetOwnPropertyNames(napi_env env, napi_value obj)
 {
-    Napi::Env env = obj.Env();
+    K_ASSERT(IsObject(env, obj));
 
     napi_value result;
     napi_status status = napi_get_all_property_names(env, obj, napi_key_own_only,
@@ -212,6 +421,9 @@ static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
 
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
 
+Napi::Value INLINE_UNITY WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr);
+Napi::Value INLINE_UNITY WrapCallback(Napi::Env env, const TypeInfo *ref, void *ptr);
+
 bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
 
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);

package/src/koffi/src/uv.cc

@@ -143,7 +143,7 @@ void PollHandle::OnPoll(uv_poll_t *h, int status, int events)
     obj.Set("writable", !!(events & UV_WRITABLE));
     obj.Set("disconnect", !!(events & UV_DISCONNECT));
 
-    napi_value args[] = { Napi::Number::New(env, status), obj };
+    napi_value args[] = { NewInt(env, (int32_t)status), obj };
     poll->callback.Call(poll->Value(), K_LEN(args), args);
 }
 
@@ -171,7 +171,7 @@ Napi::Value Poll(const Napi::CallbackInfo &info)
     int fd = info[0].As<Napi::Number>().Int32Value();
 
     Napi::Function ctor = PollHandle::Define(env);
-    Napi::Object inst = ctor.New({ Napi::Number::New(env, fd) });
+    Napi::Object inst = ctor.New({ NewInt(env, (int32_t)fd) });
     Napi::Function start = inst.Get("start").As<Napi::Function>();
 
     if (env.IsExceptionPending()) [[unlikely]]

package/src/koffi/src/uv.def

@@ -8,3 +8,6 @@ uv_poll_init
 uv_poll_init_socket
 uv_poll_start
 uv_poll_stop
+uv_dlopen
+uv_dlclose
+uv_dlsym

package/src/koffi/src/win32.hh

@@ -49,7 +49,7 @@ struct PE_NT_HEADERS {
     // ... OptionalHeader;
 };
 
-#if _WIN64
+#if defined(_WIN64)
 
 struct TEB {
     void *ExceptionList;
@@ -107,6 +107,35 @@ static inline TEB *GetTEB()
     return teb;
 }
 
+#if defined(_WIN64)
+    #define ADJUST_TEB(Teb, Low, High) \
+        K_DEFER_C(base = (Teb)->StackBase, \
+                  limit = (Teb)->StackLimit, \
+                  dealloc = (Teb)->DeallocationStack) { \
+            (Teb)->StackBase = base; \
+            (Teb)->StackLimit = limit; \
+            (Teb)->DeallocationStack = dealloc; \
+        }; \
+        (Teb)->StackBase = (High); \
+        (Teb)->StackLimit = (Low); \
+        (Teb)->DeallocationStack = (Low);
+#else
+    #define ADJUST_TEB(Teb, Low, High) \
+        K_DEFER_C(base = (Teb)->StackBase, \
+                  limit = (Teb)->StackLimit, \
+                  dealloc = (Teb)->DeallocationStack, \
+                  seh = (Teb)->ExceptionList) { \
+            (Teb)->StackBase = base; \
+            (Teb)->StackLimit = limit; \
+            (Teb)->DeallocationStack = dealloc; \
+            (Teb)->ExceptionList = seh; \
+        }; \
+        (Teb)->StackBase = (High); \
+        (Teb)->StackLimit = (Low); \
+        (Teb)->DeallocationStack = (Low); \
+        (Teb)->ExceptionList = (High) - K_SIZE(SehFrame);
+#endif
+
 extern const HashMap<int, const char *> WindowsMachineNames;
 
 void *LoadWindowsLibrary(Napi::Env env, Span<const char> path); // Returns HANDLE

package/vendor/node-addon-api/napi-inl.h

@@ -4094,6 +4094,10 @@ inline const Value CallbackInfo::operator[](size_t index) const {
   return index < _argc ? Value(_env, _argv[index]) : Env().Undefined();
 }
 
+inline napi_value *CallbackInfo::First() const {
+  return _argv;
+}
+
 inline Value CallbackInfo::This() const {
   if (_this == nullptr) {
     return Env().Undefined();

package/vendor/node-addon-api/napi.h

@@ -1977,6 +1977,7 @@ class CallbackInfo {
   bool IsConstructCall() const;
   size_t Length() const;
   const Value operator[](size_t index) const;
+  napi_value *First() const;
   Value This() const;
   void* Data() const;
   void SetData(void* data);

package/doc/platforms.md

@@ -1,36 +0,0 @@
-# Node.js
-
-Koffi requires a recent [Node.js](https://nodejs.org/) version with [N-API](https://nodejs.org/api/n-api.html) version 8 support:
-
-- Node < 12.22.0 is not supported
-- _Node 12.x_: Node 12.22.0 or newer
-- _Node 14.x_: Node 14.17.0 or newer
-- _Node 15.x_: Node 15.12.0 or newer
-- Node 16.0.0 or later versions
-
-Use [NVM](https://github.com/nvm-sh/nvm) to install more recent Node versions on older Linux distributions.
-
-# Supported platforms
-
-The following combinations of OS and architectures __are officially supported and tested__ at the moment:
-
-ISA / OS           | Windows     | Linux (glibc) | Linux (musl) | macOS       | FreeBSD     | OpenBSD
------------------- | ----------- | ------------- | ------------ | ----------- | ----------- | --------
-x86 (IA32) [^1]    | ✅ Yes      | ✅ Yes        | 🟨 Probably  | ⬜️ *N/A*    | ✅ Yes      | ✅ Yes
-x86_64 (AMD64)     | ✅ Yes      | ✅ Yes        | ✅ Yes       | ✅ Yes      | ✅ Yes      | ✅ Yes
-ARM32 LE [^2]      | ⬜️ *N/A*    | ✅ Yes        | 🟨 Probably  | ⬜️ *N/A*    | 🟨 Probably | 🟨 Probably
-ARM64 (AArch64) LE | ✅ Yes      | ✅ Yes        | ✅ Yes       | ✅ Yes      | ✅ Yes      | 🟨 Probably
-RISC-V 64 [^3]     | ⬜️ *N/A*    | ✅ Yes        | 🟨 Probably  | ⬜️ *N/A*    | 🟨 Probably | 🟨 Probably
-LoongArch64        | ⬜️ *N/A*    | ✅ Yes        | 🟨 Probably  | ⬜️ *N/A*    | 🟨 Probably | 🟨 Probably
-
-<div class="legend">✅ Yes | 🟨 Probably | ⬜️ Not applicable</div>
-
-[^1]: The following call conventions are supported for forward calls: cdecl, stdcall, MS fastcall, thiscall. Only cdecl and stdcall can be used for C to JS callbacks.
-[^2]: The prebuilt binary uses the hard float ABI and expects a VFP coprocessor. Build from source to use Koffi with a different ABI (softfp, soft).
-[^3]: The prebuilt binary uses the LP64D (double-precision float) ABI. The LP64 ABI is supported in theory if you build Koffi from source (untested), the LP64F ABI is not supported.
-
-For all fully supported platforms (green check marks), a prebuilt binary is included in the NPM package which means you can install Koffi without a C++ compiler.
-
-<style>
-     table td:not(:first-child) { text-align: center; }
-</style>

package/src/cnoke/LICENSE.txt

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the “Software”), to deal in
-the Software without restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.