ya-struct 0.0.1 → 0.0.5

package/lib/types/basic.js

@@ -0,0 +1,200 @@
+const dataAndAlignmentModels = {
+  LP64: {
+    gcc: {
+      Int8: {
+        signed: true,
+        align: 1,
+        size: 1,
+      },
+      Int16: {
+        signed: true,
+        align: 2,
+        size: 2,
+      },
+      Int32: {
+        signed: true,
+        align: 4,
+        size: 4,
+      },
+      Int64: {
+        signed: true,
+        align: 8,
+        size: 8,
+      },
+
+      UInt8: {
+        signed: false,
+        align: 1,
+        size: 1,
+      },
+      UInt16: {
+        signed: false,
+        align: 2,
+        size: 2,
+      },
+      UInt32: {
+        signed: false,
+        align: 4,
+        size: 4,
+      },
+      UInt64: {
+        signed: false,
+        align: 8,
+        size: 8,
+      },
+
+      Pointer: {
+        signed: false,
+        align: 8,
+        size: 8,
+      },
+    },
+  },
+  ILP32: {
+    gcc: {
+      Int8: {
+        signed: true,
+        align: 1,
+        size: 1,
+      },
+      Int16: {
+        signed: true,
+        align: 2,
+        size: 2,
+      },
+      Int32: {
+        signed: true,
+        align: 4,
+        size: 4,
+      },
+      Int64: {
+        signed: true,
+        align: 8,
+        size: 8,
+      },
+
+      UInt8: {
+        signed: false,
+        align: 1,
+        size: 1,
+      },
+      UInt16: {
+        signed: false,
+        align: 2,
+        size: 2,
+      },
+      UInt32: {
+        signed: false,
+        align: 4,
+        size: 4,
+      },
+      UInt64: {
+        signed: false,
+        align: 8,
+        size: 8,
+      },
+
+      Pointer: {
+        signed: false,
+        align: 4,
+        size: 4,
+      },
+    },
+  },
+  default: {
+    Int8: {
+      signed: true,
+      align: 1,
+      size: 1,
+    },
+    Int16: {
+      signed: true,
+      align: 2,
+      size: 2,
+    },
+    Int32: {
+      signed: true,
+      align: 4,
+      size: 4,
+    },
+    Int64: {
+      signed: true,
+      align: 8,
+      size: 8,
+    },
+
+    UInt8: {
+      signed: false,
+      align: 1,
+      size: 1,
+    },
+    UInt16: {
+      signed: false,
+      align: 2,
+      size: 2,
+    },
+    UInt32: {
+      signed: false,
+      align: 4,
+      size: 4,
+    },
+    UInt64: {
+      signed: false,
+      align: 8,
+      size: 8,
+    },
+  },
+};
+
+const abi = ({ dataModel, compiler, endianness: defaultEndianess }) => {
+  const model =
+    dataAndAlignmentModels[dataModel]?.[compiler] ||
+    dataAndAlignmentModels.default;
+
+  const findAlignedOffset = ({ offset, align }) => {
+    return Math.floor((offset + align - 1) / align) * align;
+  };
+
+  const type = ({ signed, align, size, endianness }) => {
+    return ({ offset }) => {
+      const alignedOffset = findAlignedOffset({ offset, align });
+
+      return {
+        signed,
+        offset: alignedOffset,
+        size,
+        endianness,
+      };
+    };
+  };
+
+  return {
+    Int8: type({ ...model.Int8, endianness: undefined }),
+    Int16: type({ ...model.Int16, endianness: defaultEndianess }),
+    Int16LE: type({ ...model.Int16, endianness: "LE" }),
+    Int16BE: type({ ...model.Int16, endianness: "BE" }),
+    Int32: type({ ...model.Int32, endianness: defaultEndianess }),
+    Int32LE: type({ ...model.Int32, endianness: "LE" }),
+    Int32BE: type({ ...model.Int32, endianness: "BE" }),
+    Int64: type({ ...model.Int64, endianness: defaultEndianess }),
+    Int64LE: type({ ...model.Int64, endianness: "LE" }),
+    Int64BE: type({ ...model.Int64, endianness: "BE" }),
+
+    UInt8: type({ ...model.UInt8, endianness: undefined }),
+    UInt16: type({ ...model.UInt16, endianness: defaultEndianess }),
+    UInt16LE: type({ ...model.UInt16, endianness: "LE" }),
+    UInt16BE: type({ ...model.UInt16, endianness: "BE" }),
+    UInt32: type({ ...model.UInt32, endianness: defaultEndianess }),
+    UInt32LE: type({ ...model.UInt32, endianness: "LE" }),
+    UInt32BE: type({ ...model.UInt32, endianness: "BE" }),
+    UInt64: type({ ...model.UInt64, endianness: defaultEndianess }),
+    UInt64LE: type({ ...model.UInt64, endianness: "LE" }),
+    UInt64BE: type({ ...model.UInt64, endianness: "BE" }),
+
+    Pointer: type({ ...model.Pointer, endianness: defaultEndianess }),
+  };
+};
+
+export default {
+  abi,
+};

package/lib/types/ctypes.js

@@ -0,0 +1,160 @@
+const dataAndAlignmentModels = {
+  LP64: {
+    gcc: {
+      signedChar: {
+        signed: true,
+        size: 1,
+        align: 1,
+      },
+      signedShort: {
+        signed: true,
+        size: 2,
+        align: 2,
+      },
+      signedInt: {
+        signed: true,
+        size: 4,
+        align: 4,
+      },
+      signedLong: {
+        signed: true,
+        size: 8,
+        align: 8,
+      },
+      signedLongLong: {
+        signed: true,
+        size: 8,
+        align: 8,
+      },
+      unsignedChar: {
+        signed: false,
+        size: 1,
+        align: 1,
+      },
+      unsignedShort: {
+        signed: false,
+        size: 2,
+        align: 2,
+      },
+      unsignedInt: {
+        signed: false,
+        size: 4,
+        align: 4,
+      },
+      unsignedLong: {
+        signed: false,
+        size: 8,
+        align: 8,
+      },
+      unsignedLongLong: {
+        signed: false,
+        size: 8,
+        align: 8,
+      },
+    },
+  },
+  ILP32: {
+    gcc: {
+      signedChar: {
+        signed: true,
+        size: 1,
+        align: 1,
+      },
+      signedShort: {
+        signed: true,
+        size: 2,
+        align: 2,
+      },
+      signedInt: {
+        signed: true,
+        size: 4,
+        align: 4,
+      },
+      signedLong: {
+        signed: true,
+        size: 4,
+        align: 4,
+      },
+      signedLongLong: {
+        signed: true,
+        size: 8,
+        align: 8,
+      },
+      unsignedChar: {
+        signed: false,
+        size: 1,
+        align: 1,
+      },
+      unsignedShort: {
+        signed: false,
+        size: 2,
+        align: 2,
+      },
+      unsignedInt: {
+        signed: false,
+        size: 4,
+        align: 4,
+      },
+      unsignedLong: {
+        signed: false,
+        size: 4,
+        align: 4,
+      },
+      unsignedLongLong: {
+        signed: false,
+        size: 8,
+        align: 8,
+      },
+    },
+  },
+};
+
+const abi = ({ dataModel, compiler, endianness }) => {
+  const model = dataAndAlignmentModels[dataModel]?.[compiler];
+  if (!model) {
+    throw Error(
+      `data model ${dataModel} on compiler ${compiler} not supported`
+    );
+  }
+
+  const findAlignedOffset = ({ offset, align }) => {
+    return Math.floor((offset + align - 1) / align) * align;
+  };
+
+  const type = ({ signed, size, align }) => {
+    return ({ offset }) => {
+      const alignedOffset = findAlignedOffset({ offset, align });
+
+      return {
+        signed,
+        offset: alignedOffset,
+        size,
+        endianness: size > 1 ? endianness : undefined,
+      };
+    };
+  };
+
+  return {
+    char: type(model.signedChar),
+    short: type(model.signedShort),
+    int: type(model.signedInt),
+    long: type(model.signedLong),
+    longLong: type(model.signedLongLong),
+
+    signedChar: type(model.signedChar),
+    signedShort: type(model.signedShort),
+    signedInt: type(model.signedInt),
+    signedLong: type(model.signedLong),
+    signedLongLong: type(model.signedLongLong),
+
+    unsignedChar: type(model.unsignedChar),
+    unsignedShort: type(model.unsignedShort),
+    unsignedInt: type(model.unsignedInt),
+    unsignedLong: type(model.unsignedLong),
+    unsignedLongLong: type(model.unsignedLongLong),
+  };
+};
+
+export default {
+  abi,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ya-struct",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "description": "Yet Another Node.js Structure API",
   "main": "lib/index.js",
   "scripts": {
@@ -29,15 +29,13 @@
   },
   "homepage": "https://github.com/k13-engineering/node-ya-struct#readme",
   "dependencies": {
-    "buffer2address": "^0.0.1"
+    "buffer2address": "^0.0.2"
   },
   "devDependencies": {
-    "@babel/core": "^7.12.3",
-    "@babel/eslint-parser": "^7.12.1",
-    "@babel/plugin-syntax-top-level-await": "^7.12.1",
-    "c8": "^7.3.0",
-    "eslint": "^7.9.0",
-    "mocha": "^8.1.3",
-    "node-archibald": "^0.0.5"
+    "c8": "^7.9.0",
+    "eslint": "^7.32.0",
+    "mocha": "^9.1.1",
+    "node-archibald": "^0.0.6",
+    "tmp-promise": "^3.0.3"
   }
 }

package/test/abi.js

@@ -5,34 +5,29 @@ import struct from "../lib/index.js";
 import assert from "assert";
 
 describe("abi", () => {
-  it("should not support endian-less types without ABI specification", () => {
-    assert.throws(() => {
-      struct.define(({ field }) => {
-        field.UInt32("myfield1");
-        field.UInt32("myfield2");
-      });
-    });
-  });
-
   const testEndiannessFor = ({ endianness }) => {
     it("should support structure definition", () => {
-      const def = struct.abi({ endianness }).define(({ field }) => {
-        field.UInt32("myfield1");
-        field.UInt32("myfield2");
-      });
-
-      assert.equal(def.size, 8);
-      assert.equal(def.offsetof("myfield1"), 0);
-      assert.equal(def.sizeof("myfield1"), 4);
-      assert.equal(def.offsetof("myfield2"), 4);
-      assert.equal(def.sizeof("myfield2"), 4);
+      const def = struct
+        .define(({ field }) => {
+          field.UInt32("myfield1");
+          field.UInt32("myfield2");
+        })
+        .abi({ endianness });
+
+      assert.strictEqual(def.size, 8);
+      assert.strictEqual(def.fields.myfield1.offset, 0);
+      assert.strictEqual(def.fields.myfield1.size, 4);
+      assert.strictEqual(def.fields.myfield2.offset, 4);
+      assert.strictEqual(def.fields.myfield2.size, 4);
     });
 
     it("should parse data correctly", () => {
-      const def = struct.abi({ endianness }).define(({ field }) => {
-        field.UInt32("myfield1");
-        field.UInt32("myfield2");
-      });
+      const def = struct
+        .define(({ field }) => {
+          field.UInt32("myfield1");
+          field.UInt32("myfield2");
+        })
+        .abi({ endianness });
 
       const buf = def.format({});
 
@@ -40,59 +35,66 @@ describe("abi", () => {
       buf[`writeUInt32${endianness}`](30, 4);
 
       const data = def.parse(buf);
-      assert.equal(data.myfield1, 20n);
-      assert.equal(data.myfield2, 30n);
+      assert.strictEqual(data.myfield1, 20n);
+      assert.strictEqual(data.myfield2, 30n);
     });
 
     it("should format data correctly", () => {
-      const def = struct.abi({ endianness }).define(({ field }) => {
-        field.UInt32("myfield1");
-        field.UInt32("myfield2");
-      });
+      const def = struct
+        .define(({ field }) => {
+          field.UInt32("myfield1");
+          field.UInt32("myfield2");
+        })
+        .abi({ endianness });
 
       const buf = def.format({
-        "myfield1": 20n,
-        "myfield2": 30n
+        myfield1: 20n,
+        myfield2: 30n,
       });
 
       const myfield1 = buf[`readUInt32${endianness}`](0);
       const myfield2 = buf[`readUInt32${endianness}`](4);
 
-      assert.equal(myfield1, 20n);
-      assert.equal(myfield2, 30n);
+      assert.strictEqual(myfield1, 20);
+      assert.strictEqual(myfield2, 30);
     });
   };
 
   describe("little endian", () => {
-    testEndiannessFor({ "endianness": "LE" });
+    testEndiannessFor({ endianness: "LE" });
   });
 
   describe("big endian", () => {
-    testEndiannessFor({ "endianness": "BE" });
+    testEndiannessFor({ endianness: "BE" });
   });
 
   describe("data models", () => {
     describe("LP64", () => {
-      const structAbi = struct.abi({ "endianness": "LE", "dataModel": "LP64" });
+      const endianness = "LE";
+      const dataModel = "LP64";
 
       it("should support structure definition", () => {
-        const def = structAbi.define(({ field }) => {
-          field.Pointer("myfield1");
-          field.Pointer("myfield2");
-        });
-
-        assert.equal(def.size, 16);
-        assert.equal(def.offsetof("myfield1"), 0);
-        assert.equal(def.sizeof("myfield1"), 8);
-        assert.equal(def.offsetof("myfield2"), 8);
-        assert.equal(def.sizeof("myfield2"), 8);
+        const def = struct
+          .define(({ field }) => {
+            field.Pointer("myfield1");
+            field.Pointer("myfield2");
+          })
+          .abi({ endianness, dataModel });
+
+        assert.strictEqual(def.size, 16);
+        assert.strictEqual(def.fields.myfield1.offset, 0);
+        assert.strictEqual(def.fields.myfield1.size, 8);
+        assert.strictEqual(def.fields.myfield2.offset, 8);
+        assert.strictEqual(def.fields.myfield2.size, 8);
       });
 
       it("should parse data correctly", () => {
-        const def = structAbi.define(({ field }) => {
-          field.Pointer("myfield1");
-          field.Pointer("myfield2");
-        });
+        const def = struct
+          .define(({ field }) => {
+            field.Pointer("myfield1");
+            field.Pointer("myfield2");
+          })
+          .abi({ endianness, dataModel });
 
         const buf = def.format({});
 
@@ -100,35 +102,93 @@ describe("abi", () => {
         buf.writeBigUInt64LE(30n, 8);
 
         const data = def.parse(buf);
-        assert.equal(data.myfield1, 20n);
-        assert.equal(data.myfield2, 30n);
+        assert.strictEqual(data.myfield1, 20n);
+        assert.strictEqual(data.myfield2, 30n);
       });
 
       it("should format data correctly", () => {
-        const def = structAbi.define(({ field }) => {
-          field.Pointer("myfield1");
-          field.Pointer("myfield2");
-        });
+        const def = struct
+          .define(({ field }) => {
+            field.Pointer("myfield1");
+            field.Pointer("myfield2");
+          })
+          .abi({ endianness, dataModel });
 
         const buf = def.format({
-          "myfield1": 20n,
-          "myfield2": 30n
+          myfield1: 20n,
+          myfield2: 30n,
         });
 
         const myfield1 = buf.readBigUInt64LE(0);
         const myfield2 = buf.readBigUInt64LE(8);
 
-        assert.equal(myfield1, 20n);
-        assert.equal(myfield2, 30n);
+        assert.strictEqual(myfield1, 20n);
+        assert.strictEqual(myfield2, 30n);
+      });
+    });
+  });
+
+  describe("alignment models", () => {
+    describe("LP64 - gcc", () => {
+      const endianness = "LE";
+      const dataModel = "LP64";
+      const compiler = "gcc";
+
+      it("should align Int8 correctly", () => {
+        const def = struct
+          .define(({ field }) => {
+            field.Int8("myfield1");
+            field.Int8("myfield2");
+          })
+          .abi({ endianness, dataModel, compiler });
+
+        assert.strictEqual(def.fields.myfield1.offset, 0);
+        assert.strictEqual(def.fields.myfield2.offset, 1);
+      });
+
+      it("should align Int16 correctly", () => {
+        const def = struct
+          .define(({ field }) => {
+            field.Int8("myfield1");
+            field.Int16LE("myfield2");
+          })
+          .abi({ endianness, dataModel, compiler });
+
+        assert.strictEqual(def.fields.myfield1.offset, 0);
+        assert.strictEqual(def.fields.myfield2.offset, 2);
+      });
+
+      it("should align Int32 correctly", () => {
+        const def = struct
+          .define(({ field }) => {
+            field.Int8("myfield1");
+            field.Int32LE("myfield2");
+          })
+          .abi({ endianness, dataModel, compiler });
+
+        assert.strictEqual(def.fields.myfield1.offset, 0);
+        assert.strictEqual(def.fields.myfield2.offset, 4);
+      });
+
+      it("should align Int64 correctly", () => {
+        const def = struct
+          .define(({ field }) => {
+            field.Int8("myfield1");
+            field.Int64LE("myfield2");
+          })
+          .abi({ endianness, dataModel, compiler });
+
+        assert.strictEqual(def.fields.myfield1.offset, 0);
+        assert.strictEqual(def.fields.myfield2.offset, 8);
       });
     });
   });
 
   const supportedAbiPlatforms = [
     {
-      "arch": "x64",
-      "platform": "linux"
-    }
+      arch: "x64",
+      platform: "linux",
+    },
   ];
 
   const isHostSupported = supportedAbiPlatforms.some(({ arch, platform }) => {
@@ -137,7 +197,7 @@ describe("abi", () => {
 
   describe("host detection", () => {
     (isHostSupported ? it : it.skip)("should detect host without error", () => {
-      struct.forHost();
+      struct.define(() => {}).forHost();
     });
   });
 });