@koromix/koffi-linux-ppc64 3.3.0

package/README.md

@@ -0,0 +1,6 @@
+# @koromix/koffi-linux-ppc64
+
+This contains the linux-ppc64 binaries for [Koffi](https://koffi.dev), a fast and and easy-to-use dynamic C FFI (foreign function interface) module for Node.js.
+
+> [!NOTE]
+> Do not install this package directly, use `npm install koffi` instead.

package/index.js

@@ -0,0 +1,165 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../cnoke/src/abi.js
+var import_node_fs = __toESM(require("node:fs"), 1);
+function determineAbi() {
+  let abi = process.arch.toString();
+  if (abi == "riscv32" || abi == "riscv64") {
+    let file = openFile(process.execPath, "r");
+    try {
+      let header = readElfHeader(file);
+      let float_abi = header.e_flags & 6;
+      switch (float_abi) {
+        case 0:
+          {
+          }
+          break;
+        case 2:
+          {
+            abi += "f";
+          }
+          break;
+        case 4:
+          {
+            abi += "d";
+          }
+          break;
+        case 6:
+          {
+            abi += "q";
+          }
+          break;
+      }
+    } finally {
+      file.close();
+    }
+  } else if (abi == "arm") {
+    let file = openFile(process.execPath, "r");
+    try {
+      let header = readElfHeader(file);
+      if (header.e_flags & 1024) {
+        abi += "hf";
+      } else if (header.e_flags & 512) {
+        abi += "sf";
+      } else {
+        throw new Error("Unknown ARM floating-point ABI");
+      }
+    } finally {
+      file.close();
+    }
+  } else if (abi == "ppc64") {
+    let file = openFile(process.execPath, "r");
+    try {
+      let header = readElfHeader(file);
+      switch (header.ei_data) {
+        case 1:
+          {
+            abi += "le";
+          }
+          break;
+        case 2:
+          {
+            abi += "be";
+          }
+          break;
+        default:
+          throw new Error("Invalid ELF endianness value");
+      }
+    } finally {
+      file.close();
+    }
+  }
+  return abi;
+}
+function readElfHeader(file, offset = 0) {
+  let buf = file.read(offset, 512);
+  if (buf.length < 16)
+    throw new Error("Truncated header");
+  if (buf[0] != 127 || buf[1] != 69 || buf[2] != 76 || buf[3] != 70)
+    throw new Error("Invalid magic number");
+  if (buf[6] != 1)
+    throw new Error("Invalid ELF version");
+  if (buf[5] != 1)
+    throw new Error("Big-endian architectures are not supported");
+  switch (buf[4]) {
+    case 1:
+      {
+        if (buf.length < 68)
+          throw new Error("Truncated ELF header");
+        return {
+          ei_class: 32,
+          ei_data: buf[5],
+          e_machine: buf.readUInt16LE(18),
+          e_flags: buf.readUInt32LE(36),
+          e_phoff: buf.readUInt32LE(28),
+          e_phentsize: buf.readUInt16LE(42),
+          e_phnum: buf.readUInt16LE(44)
+        };
+      }
+      break;
+    case 2:
+      {
+        if (buf.length < 120)
+          throw new Error("Truncated ELF header");
+        return {
+          ei_class: 64,
+          ei_data: buf[5],
+          e_machine: buf.readUInt16LE(18),
+          e_flags: buf.readUInt32LE(48),
+          e_phoff: buf.readBigUInt64LE(32),
+          e_phentsize: buf.readUInt16LE(54),
+          e_phnum: buf.readUInt16LE(56)
+        };
+      }
+      break;
+    default:
+      throw new Error("Invalid ELF class");
+  }
+}
+function openFile(filename2, flags) {
+  let fd = import_node_fs.default.openSync(filename2, flags);
+  return new FileHandle(fd);
+}
+var FileHandle = class {
+  constructor(fd) {
+    this.fd = fd;
+  }
+  close() {
+    import_node_fs.default.closeSync(this.fd);
+  }
+  [Symbol.dispose]() {
+    import_node_fs.default.closeSync(this.fd);
+  }
+  read(offset, len) {
+    let buf = Buffer.allocUnsafe(len);
+    let read = import_node_fs.default.readSync(this.fd, buf, 0, len, offset);
+    return buf.subarray(0, read);
+  }
+};
+
+// tools/loaders/ppc64.js
+if (determineAbi() != "ppc64le")
+  throw new Error("The PowerPC64 prebuild only supports ELFv2 Little-Endian systems");
+var filename = "./linux_ppc64le/koffi.node";
+module.exports = require(filename);

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "@koromix/koffi-linux-ppc64",
+    "version": "3.3.0",
+    "description": "Fast and easy-to-use dynamic C FFI (foreign function interface) for Node.js (@koromix/koffi-linux-ppc64)",
+    "author": {
+        "name": "Niels Martignène",
+        "email": "niels.martignene@protonmail.com",
+        "url": "https://koromix.dev/"
+    },
+    "homepage": "https://koffi.dev/",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Koromix/koffi"
+    },
+    "license": "MIT",
+    "funding": "https://liberapay.com/Koromix",
+    "main": "./index.js",
+    "os": [
+        "linux"
+    ],
+    "cpu": [
+        "ppc64"
+    ]
+}