ya-struct 0.0.1 → 0.0.5

package/.eslintrc

@@ -1,20 +1,18 @@
 {
-  "parser": "@babel/eslint-parser",
   "parserOptions": {
-    "ecmaVersion": 8,
+    "ecmaVersion": 2021,
     "sourceType": "module",
-    "requireConfigFile": false,
-    "babelOptions": {
-      "plugins": ["@babel/syntax-top-level-await"]
-    }
+    "requireConfigFile": false
   },
   "env": {
     "node": true,
-    "es6": true
+    "es2020": true
   },
   "rules": {
     "global-require": "off",
-    "quote-props": "warn",
+    "quote-props": ["warn", "consistent-as-needed"],
+    "comma-dangle": ["error", {"arrays": "always-multiline", "objects": "always-multiline", "functions": "never"}],
+    "id-length": ["error", {"min": 3, "properties": "always", "exceptions": ["i", "os", "fs"]}],
     "quotes": ["error", "double", { "allowTemplateLiterals": true }],
     "no-plusplus": "error",
     "no-nested-ternary": "error",
@@ -25,6 +23,8 @@
     "no-delete-var": "error",
     "no-param-reassign": "error",
     "no-return-assign": "error",
+    "no-import-assign": "error",
+    "no-multi-assign": "error",
     "keyword-spacing": "error",
     "max-len": [ "warn", { "code": 140 } ],
     "max-params": ["error", 4],
@@ -51,6 +51,7 @@
     "no-new-object": "error",
     "no-new-wrappers": "error",
     "no-useless-concat": "error",
+    "no-unused-vars": ["error", {"ignoreRestSiblings": true}],
     "array-bracket-newline": ["error", "consistent"],
     "func-names": ["error", "never"],
     "func-style": ["error", "expression", { "allowArrowFunctions": true }],
@@ -58,7 +59,6 @@
     "arrow-parens": "error",
     "no-confusing-arrow": "error",
     "prefer-const": "error",
-    "prefer-destructuring": ["error", {"object": true, "array": false}],
     "rest-spread-spacing": ["error", "never"],
     "template-curly-spacing": ["error", "never"],
     "prefer-rest-params": "error",

package/.github/workflows/CI.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       matrix:
         arch: [ amd64, arm64v8, arm32v7 ]
-        node: [ 12, 13, 14, 15 ]
+        node: [ 15, 16 ]
       fail-fast: false
 
     steps:

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+    "trailingComma": "es5",
+    "tabWidth": 2,
+    "singleQuote": false
+}

package/lib/builder.js

@@ -1,104 +1,62 @@
-/* global BigInt */
+import ctypes from "./types/ctypes.js";
+import basicTypes from "./types/basic.js";
+import marshallerFactory from "./marshaller.js";
 
-const bufferTypeSizes = {
-  "UInt8": 1,
-  "UInt16LE": 2,
-  "UInt16BE": 2,
-  "UInt32LE": 4,
-  "UInt32BE": 4,
-  "BigUInt64LE": 8,
-  "BigUInt64BE": 8,
-
-  "Int8": 1,
-  "Int16LE": 2,
-  "Int16BE": 2,
-  "Int32LE": 4,
-  "Int32BE": 4,
-  "BigInt64LE": 8,
-  "BigInt64BE": 8
-};
-
-const dataModelMaps = {
-  "LP64": {
-    "Pointer": "BigUInt64"
-  }
-};
-
-const createFieldsViaBuilder = ({ builder, "abi": { endianness, dataModel } = {} }) => {
-  let fields = {};
+const createFieldsViaBuilder = ({
+  builder,
+  abi: { endianness = "LE", dataModel = "LP64", compiler = "gcc" } = {},
+}) => {
+  let fieldDefinitions = {};
 
   let currentOffset = 0;
 
-  const standardField = (type) => {
-    return (name) => {
-      const offset = currentOffset;
-      const size = bufferTypeSizes[type];
-      if (size === undefined) {
-        throw new Error(`could not map unknown type "${type}"`);
-      }
-
-      fields = Object.assign({}, fields, {
-        [name]: {
-          name,
-          "readFrom": ({ buffer }) => {
-            return BigInt(buffer[`read${type}`](offset));
-          },
-          "writeTo": ({ buffer, value }) => {
-            if (type.indexOf("Big") >= 0) {
-              buffer[`write${type}`](value, offset);
-            } else {
-              buffer[`write${type}`](Number(value), offset);
-            }
-          },
-          "bufferType": type,
-          offset,
-          size
-        }
-      });
+  const fieldBuilderForAbi = ({ abi }) => {
+    let result = {};
+    Object.keys(abi).forEach((typeName) => {
+      result = {
+        ...result,
+        [typeName]: (name) => {
+          const def = abi[typeName]({ offset: currentOffset });
+
+          fieldDefinitions = {
+            ...fieldDefinitions,
+            [name]: def,
+          };
+
+          currentOffset = def.offset + def.size;
+        },
+      };
+    });
 
-      currentOffset += size;
-    };
+    return result;
   };
 
-  let fieldObject = {};
-  Object.keys(bufferTypeSizes).forEach((type) => {
-    fieldObject = Object.assign({}, fieldObject, {
-      [type]: standardField(type)
-    });
-  });
+  const basicTypesAbi = basicTypes.abi({ dataModel, compiler, endianness });
+  const cTypesAbi = ctypes.abi({ dataModel, compiler, endianness });
 
-  if (endianness === "LE" || endianness === "BE") {
-    [
-      "Int16",
-      "Int32",
-      "BigInt64",
-      "UInt16",
-      "UInt32",
-      "BigUInt64"
-    ].forEach((endianType) => {
-      fieldObject = Object.assign({}, fieldObject, {
-        [endianType]: standardField(`${endianType}${endianness}`)
-      });
-    });
-  }
-
-  const dataModelMap = dataModelMaps[dataModel] || {};
-  Object.keys(dataModelMap).forEach((key) => {
-    fieldObject = Object.assign({}, fieldObject, {
-      [key]: fieldObject[dataModelMap[key]]
-    });
-  });
+  const field = {
+    ...fieldBuilderForAbi({ abi: basicTypesAbi }),
+    CTypes: fieldBuilderForAbi({ abi: cTypesAbi }),
+  };
 
-  builder({ "field": fieldObject });
+  builder({ field });
 
   const size = currentOffset;
 
+  const { marshal, unmarshal } = marshallerFactory.create({
+    fieldDefinitions,
+    size,
+  });
+
   return {
-    fields,
-    size
+    fields: fieldDefinitions,
+    size,
+
+    marshal,
+    unmarshal,
   };
 };
 
 export default {
-  createFieldsViaBuilder
+  createFieldsViaBuilder,
 };

package/lib/index.js

@@ -1,29 +1,11 @@
-import buffer2address from "buffer2address";
+import b2a from "buffer2address";
 import os from "os";
 
 import fieldBuilder from "./builder.js";
-import refbuf from "./refbuf.js";
 
 const defineWithBuilderAndAbi = ({ builder, abi }) => {
-  const { fields, size } = fieldBuilder.createFieldsViaBuilder({ builder, abi });
-
-  const offsetof = (fieldName) => {
-    const field = fields[fieldName];
-    if (!field) {
-      throw new Error(`field "${fieldName}" not found`);
-    }
-
-    return field.offset;
-  };
-
-  const sizeof = (fieldName) => {
-    const field = fields[fieldName];
-    if (!field) {
-      throw new Error(`field "${fieldName}" not found`);
-    }
-
-    return field.size;
-  };
+  const { fields, size, marshal, unmarshal } =
+    fieldBuilder.createFieldsViaBuilder({ builder, abi });
 
   const parse = (buf) => {
     if (!Buffer.isBuffer(buf)) {
@@ -31,22 +13,22 @@ const defineWithBuilderAndAbi = ({ builder, abi }) => {
     }
 
     if (buf.length < size) {
-      throw new Error(`given buffer is too small for structure (has ${buf.length} bytes, needs ${size} bytes)`);
+      throw new Error(
+        `given buffer is too small for structure (has ${buf.length} bytes, needs ${size} bytes)`
+      );
     }
 
-    let result = {};
-
-    Object.keys(fields).forEach((name) => {
-      const field = fields[name];
-
-      result = Object.assign({}, result, {
-        [name]: field.readFrom({ "buffer": buf })
-      });
-    });
-
-    return result;
+    return unmarshal({ buffer: buf });
   };
 
+  let emptyData = {};
+  Object.keys(fields).forEach((fieldName) => {
+    emptyData = {
+      ...emptyData,
+      [fieldName]: 0n,
+    };
+  });
+
   const format = (data) => {
     if (typeof data !== "object") {
       throw new Error(`given argument is not a object`);
@@ -60,91 +42,118 @@ const defineWithBuilderAndAbi = ({ builder, abi }) => {
       const value = data[fieldName];
       if (Buffer.isBuffer(value)) {
         buffers = Object.assign({}, buffers, {
-          [fieldName]: value
+          [fieldName]: value,
         });
         links = [...links, value];
       } else if (typeof value === "bigint") {
         primitives = Object.assign({}, primitives, {
-          [fieldName]: value
+          [fieldName]: value,
         });
       } else {
-        throw new Error("only Buffer and BigInt supported");
+        throw new Error(
+          `only Buffer and BigInt supported, "${fieldName}" was of type "${typeof value}"`
+        );
       }
     });
 
-    const result = refbuf.create({ links, size });
-
-    Object.keys(primitives).forEach((fieldName) => {
-      const value = data[fieldName];
-      const field = fields[fieldName];
-      field.writeTo({ "buffer": result, value });
-    });
+    let bufferDataToMarshal = {};
 
     Object.keys(buffers).forEach((fieldName) => {
-      const value = buffer2address(data[fieldName]);
-      const field = fields[fieldName];
-      field.writeTo({ "buffer": result, value });
+      const value = b2a.buffer2address(data[fieldName]);
+
+      bufferDataToMarshal = {
+        ...bufferDataToMarshal,
+        [fieldName]: value,
+      };
     });
 
-    return result;
+    return marshal({
+      data: {
+        ...emptyData,
+        ...primitives,
+        ...bufferDataToMarshal,
+      },
+      links,
+    });
   };
 
   return {
-    offsetof,
-    sizeof,
+    fields,
     size,
 
     parse,
-    format
+    format,
   };
 };
 
-const abi = ({ endianness, dataModel }) => {
-  const define = (builder) => {
-    return defineWithBuilderAndAbi({
-      builder,
-      "abi": {
-        endianness,
-        dataModel
-      }
-    });
-  };
-
-  return {
-    define
-  };
+const hostDataModels = {
+  x64: {
+    win32: "LLP64",
+    linux: "LP64",
+  },
+  arm: {
+    linux: "ILP32",
+  },
+  arm64: {
+    linux: "LP64",
+  },
 };
 
-const findHostDataModel = () => {
-  if (process.arch === "x64") {
-    if (process.platform === "win32") {
-      return "LLP64";
-    } else if (process.platform === "linux") {
-      return "LP64";
-    } else {
-      throw new Error(`unsupported platform ${process.platform}`);
-    }
-  } else {
-    throw new Error(`unsupported CPU architecture ${process.arch}`);
+const findDataModelFor = ({ arch, platform }) => {
+  const archDataModels = hostDataModels[arch];
+  if (!archDataModels) {
+    throw new Error(`unsupported CPU architecture ${arch}`);
   }
-};
 
-const forHost = () => {
-  const dataModel = findHostDataModel();
-  const endianness = os.endianness();
+  const dataModel = archDataModels[platform];
+  if (!dataModel) {
+    throw new Error(`unsupported platform ${platform}`);
+  }
+
+  return dataModel;
+};
 
-  return abi({
-    dataModel,
-    endianness
+const findHostDataModel = () => {
+  return findDataModelFor({
+    arch: process.arch,
+    platform: process.platform,
   });
 };
 
+const findLikelyHostCompiler = () => {
+  return "gcc";
+};
+
 const define = (builder) => {
-  return defineWithBuilderAndAbi({ builder });
+  const abi = ({ endianness, dataModel, compiler }) => {
+    return defineWithBuilderAndAbi({
+      builder,
+      abi: {
+        endianness,
+        dataModel,
+        compiler,
+      },
+    });
+  };
+
+  const forHost = () => {
+    const endianness = os.endianness();
+    const dataModel = findHostDataModel();
+    const compiler = findLikelyHostCompiler();
+
+    return abi({
+      endianness,
+      dataModel,
+      compiler,
+    });
+  };
+
+  return {
+    abi,
+    forHost,
+  };
 };
 
 export default {
   define,
-  abi,
-  forHost
 };

package/lib/marshaller.js

@@ -0,0 +1,88 @@
+import refbuf from "./refbuf.js";
+
+const createInterpretingMarshaller = ({ fieldDefinitions, size }) => {
+  const findReadWriteMethodName = ({ signed, fieldSizeInBits, endianness }) => {
+    const bigOrNot = fieldSizeInBits === 64 ? "Big" : "";
+    const signedOrNot = signed ? "" : "U";
+    const intType = `Int${fieldSizeInBits}`;
+
+    return `${bigOrNot}${signedOrNot}${intType}${endianness || ""}`;
+  };
+
+  const marshal = ({ data, links }) => {
+    const result = refbuf.create({ links, size });
+
+    Object.keys(fieldDefinitions).forEach((fieldName) => {
+      const {
+        signed,
+        offset,
+        size: fieldSize,
+        endianness,
+      } = fieldDefinitions[fieldName];
+
+      const fieldSizeInBits = fieldSize * 8;
+      const writeFuncName = `write${findReadWriteMethodName({
+        signed,
+        fieldSizeInBits,
+        endianness,
+      })}`;
+      const valueToWrite = writeFuncName.includes("Big")
+        ? BigInt(data[fieldName])
+        : Number(data[fieldName]);
+
+      if (!result[writeFuncName]) {
+        throw Error(`can't marshal "${fieldName}" ${JSON.stringify(fieldDefinitions[fieldName])}`);
+      }
+
+      result[writeFuncName](valueToWrite, offset);
+    });
+
+    return result;
+  };
+
+  const unmarshal = ({ buffer }) => {
+    let result = {};
+
+    Object.keys(fieldDefinitions).forEach((fieldName) => {
+      const {
+        signed,
+        offset,
+        size: fieldSize,
+        endianness,
+      } = fieldDefinitions[fieldName];
+
+      const fieldSizeInBits = fieldSize * 8;
+      const readFuncName = `read${findReadWriteMethodName({
+        signed,
+        fieldSizeInBits,
+        endianness,
+      })}`;
+
+      if (!buffer[readFuncName]) {
+        throw Error(`can't unmarshal "${fieldName}" ${JSON.stringify(fieldDefinitions[fieldName])}`);
+      }
+
+      const val = buffer[readFuncName](offset);
+
+      result = {
+        ...result,
+        [fieldName]: BigInt(val),
+      };
+    });
+
+    return result;
+  };
+
+  return {
+    marshal,
+    unmarshal,
+  };
+};
+
+const create = ({ fieldDefinitions, size }) => {
+  return createInterpretingMarshaller({ fieldDefinitions, size });
+};
+
+export default {
+  create,
+};

package/lib/refbuf.js

@@ -7,5 +7,5 @@ const create = ({ links, size }) => {
 };
 
 export default {
-  create
+  create,
 };