ya-struct 0.0.3 → 0.0.4

package/.eslintrc

@@ -6,11 +6,13 @@
   },
   "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",
@@ -21,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],
@@ -47,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 }],
@@ -54,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/.prettierrc

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

package/lib/builder.js

@@ -1,126 +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": "UInt64"
-  }
-};
-
-const createAccessorFor = ({ type, offset }) => {
-  const readFrom = ({ buffer }) => {
-    return BigInt(buffer[`read${type}`](offset));
-  };
-
-  const writeTo = ({ buffer, value }) => {
-    if (type.indexOf("Big") >= 0) {
-      buffer[`write${type}`](value, offset);
-    } else {
-      buffer[`write${type}`](Number(value), offset);
-    }
-  };
-
-  return {
-    readFrom,
-    writeTo
-  };
-};
-
-const createFieldsViaBuilder = ({ builder, "abi": { endianness, dataModel, alignmentModel = {} } = {} }) => {
-  let fields = {};
+const createFieldsViaBuilder = ({
+  builder,
+  abi: { endianness = "LE", dataModel = "LP64", compiler = "gcc" } = {},
+}) => {
+  let fieldDefinitions = {};
 
   let currentOffset = 0;
 
-  const standardField = (type, alignment) => {
-    return (name) => {
-      const alignmentToUse = Math.max(alignment || 1, 1);
-      currentOffset = Math.floor((currentOffset + alignmentToUse - 1) / alignmentToUse) * alignmentToUse;
-      const offset = currentOffset;
-
-      const size = bufferTypeSizes[type];
-      if (size === undefined) {
-        throw new Error(`could not map unknown type "${type}"`);
-      }
-
-      const { readFrom, writeTo } = createAccessorFor({ type, offset });
-
-      fields = Object.assign({}, fields, {
-        [name]: {
-          name,
-          readFrom,
-          writeTo,
-          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 = {
-    "UInt8": standardField("UInt8", alignmentModel.UInt8),
-    "UInt16LE": standardField("UInt16LE", alignmentModel.UInt16),
-    "UInt16BE": standardField("UInt16BE", alignmentModel.UInt16),
-    "UInt32LE": standardField("UInt32LE", alignmentModel.UInt32),
-    "UInt32BE": standardField("UInt32BE", alignmentModel.UInt32),
-    "UInt64LE": standardField("BigUInt64LE", alignmentModel.UInt64),
-    "UInt64BE": standardField("BigUInt64BE", alignmentModel.UInt64),
+  const basicTypesAbi = basicTypes.abi({ dataModel, compiler, endianness });
+  const cTypesAbi = ctypes.abi({ dataModel, compiler, endianness });
 
-    "Int8": standardField("Int8", alignmentModel.Int8),
-    "Int16LE": standardField("Int16LE", alignmentModel.Int16),
-    "Int16BE": standardField("Int16BE", alignmentModel.Int16),
-    "Int32LE": standardField("Int32LE", alignmentModel.Int32),
-    "Int32BE": standardField("Int32BE", alignmentModel.Int32),
-    "Int64LE": standardField("BigInt64LE", alignmentModel.Int64),
-    "Int64BE": standardField("BigInt64BE", alignmentModel.Int64)
+  const field = {
+    ...fieldBuilderForAbi({ abi: basicTypesAbi }),
+    CTypes: fieldBuilderForAbi({ abi: cTypesAbi }),
   };
 
-  if (endianness === "LE" || endianness === "BE") {
-    fieldObject = Object.assign({}, fieldObject, {
-      "Int16": standardField(`Int16${endianness}`, alignmentModel.Int16),
-      "Int32": standardField(`Int32${endianness}`, alignmentModel.Int32),
-      "Int64": standardField(`BigInt64${endianness}`, alignmentModel.Int64),
-      "UInt16": standardField(`UInt16${endianness}`, alignmentModel.UInt16),
-      "UInt32": standardField(`UInt32${endianness}`, alignmentModel.UInt32),
-      "UInt64": standardField(`BigUInt64${endianness}`, alignmentModel.UInt64),
-    });
-  }
-
-  const dataModelMap = dataModelMaps[dataModel] || {};
-  Object.keys(dataModelMap).forEach((key) => {
-    fieldObject = Object.assign({}, fieldObject, {
-      [key]: fieldObject[dataModelMap[key]]
-    });
-  });
-
-  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

@@ -2,28 +2,10 @@ 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,53 +42,61 @@ 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, "${fieldName}" was of type "${typeof value}"`);
+        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 = b2a.buffer2address(data[fieldName]);
-      const field = fields[fieldName];
-      field.writeTo({ "buffer": result, value });
+
+      bufferDataToMarshal = {
+        ...bufferDataToMarshal,
+        [fieldName]: value,
+      };
     });
 
-    return result;
+    return marshal({
+      data: {
+        ...emptyData,
+        ...primitives,
+        ...bufferDataToMarshal,
+      },
+      links,
+    });
   };
 
   return {
-    offsetof,
-    sizeof,
+    fields,
     size,
 
     parse,
-    format
+    format,
   };
 };
 
 const hostDataModels = {
-  "x64": {
-    "win32": "LLP64",
-    "linux": "LP64"
+  x64: {
+    win32: "LLP64",
+    linux: "LP64",
+  },
+  arm: {
+    linux: "ILP32",
+  },
+  arm64: {
+    linux: "LP64",
   },
-  "arm64": {
-    "linux": "LP64"
-  }
 };
 
 const findDataModelFor = ({ arch, platform }) => {
@@ -125,69 +115,45 @@ const findDataModelFor = ({ arch, platform }) => {
 
 const findHostDataModel = () => {
   return findDataModelFor({
-    "arch": process.arch,
-    "platform": process.platform
+    arch: process.arch,
+    platform: process.platform,
   });
 };
 
-const alignmentModels = {
-  "LP64": {
-    "gcc": {
-      "Int8": 1,
-      "UInt8": 1,
-      "Int16": 2,
-      "UInt16": 2,
-      "Int32": 4,
-      "UInt32": 4,
-      "Int64": 8,
-      "UInt64": 8
-    }
-  }
-};
-
 const findLikelyHostCompiler = () => {
   return "gcc";
 };
 
-const findHostAlignmentModel = () => {
-  const dataModel = findHostDataModel();
-
-  const compiler = findLikelyHostCompiler();
-
-  return alignmentModels[dataModel] && alignmentModels[dataModel][compiler];
-};
-
 const define = (builder) => {
-  const abi = ({ endianness, dataModel, alignmentModel }) => {
+  const abi = ({ endianness, dataModel, compiler }) => {
     return defineWithBuilderAndAbi({
       builder,
-      "abi": {
+      abi: {
         endianness,
         dataModel,
-        alignmentModel
-      }
+        compiler,
+      },
     });
   };
 
   const forHost = () => {
     const endianness = os.endianness();
     const dataModel = findHostDataModel();
-    const alignmentModel = findHostAlignmentModel();
-  
+    const compiler = findLikelyHostCompiler();
+
     return abi({
       endianness,
       dataModel,
-      alignmentModel
+      compiler,
     });
   };
-  
+
   return {
     abi,
-    forHost
+    forHost,
   };
 };
 
 export default {
   define,
-  alignmentModels
 };

package/lib/marshaller.js

@@ -0,0 +1,80 @@
+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]);
+
+      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,
+      })}`;
+
+      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,
 };