ya-struct 0.0.3 → 0.0.4

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 }) => {
+  const model =
+    dataAndAlignmentModels[dataModel]?.[compiler] ||
+    dataAndAlignmentModels.default;
+
+  const findAlignedOffset = ({ offset, align }) => {
+    return Math.floor((offset + align - 1) / align) * align;
+  };
+
+  const type = ({ signed, align, size }) => {
+    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 }),
+    Int16LE: type({ ...model.Int16, endianness: "LE" }),
+    Int16BE: type({ ...model.Int16, endianness: "BE" }),
+    Int32: type({ ...model.Int32, endianness }),
+    Int32LE: type({ ...model.Int32, endianness: "LE" }),
+    Int32BE: type({ ...model.Int32, endianness: "BE" }),
+    Int64: type({ ...model.Int64, endianness }),
+    Int64LE: type({ ...model.Int64, endianness: "LE" }),
+    Int64BE: type({ ...model.Int64, endianness: "BE" }),
+
+    UInt8: type({ ...model.UInt8, endianness: undefined }),
+    UInt16: type({ ...model.UInt16, endianness }),
+    UInt16LE: type({ ...model.UInt16, endianness: "LE" }),
+    UInt16BE: type({ ...model.UInt16, endianness: "BE" }),
+    UInt32: type({ ...model.UInt32, endianness }),
+    UInt32LE: type({ ...model.UInt32, endianness: "LE" }),
+    UInt32BE: type({ ...model.UInt32, endianness: "BE" }),
+    UInt64: type({ ...model.UInt64, endianness }),
+    UInt64LE: type({ ...model.UInt64, endianness: "LE" }),
+    UInt64BE: type({ ...model.UInt64, endianness: "BE" }),
+
+    Pointer: type({ ...model.Pointer, endianness }),
+  };
+};
+
+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.3",
+  "version": "0.0.4",
   "description": "Yet Another Node.js Structure API",
   "main": "lib/index.js",
   "scripts": {
@@ -33,8 +33,9 @@
   },
   "devDependencies": {
     "c8": "^7.9.0",
-    "eslint": "^8.5.0",
+    "eslint": "^7.32.0",
     "mocha": "^9.1.1",
-    "node-archibald": "^0.0.5"
+    "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");
-      }).abi({});
-    });
-  });
-
   const testEndiannessFor = ({ endianness }) => {
     it("should support structure definition", () => {
-      const def = struct.define(({ field }) => {
-        field.UInt32("myfield1");
-        field.UInt32("myfield2");
-      }).abi({ endianness });
+      const def = struct
+        .define(({ field }) => {
+          field.UInt32("myfield1");
+          field.UInt32("myfield2");
+        })
+        .abi({ endianness });
 
       assert.strictEqual(def.size, 8);
-      assert.strictEqual(def.offsetof("myfield1"), 0);
-      assert.strictEqual(def.sizeof("myfield1"), 4);
-      assert.strictEqual(def.offsetof("myfield2"), 4);
-      assert.strictEqual(def.sizeof("myfield2"), 4);
+      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.define(({ field }) => {
-        field.UInt32("myfield1");
-        field.UInt32("myfield2");
-      }).abi({ endianness });
+      const def = struct
+        .define(({ field }) => {
+          field.UInt32("myfield1");
+          field.UInt32("myfield2");
+        })
+        .abi({ endianness });
 
       const buf = def.format({});
 
@@ -45,14 +40,16 @@ describe("abi", () => {
     });
 
     it("should format data correctly", () => {
-      const def = struct.define(({ field }) => {
-        field.UInt32("myfield1");
-        field.UInt32("myfield2");
-      }).abi({ endianness });
+      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);
@@ -64,11 +61,11 @@ describe("abi", () => {
   };
 
   describe("little endian", () => {
-    testEndiannessFor({ "endianness": "LE" });
+    testEndiannessFor({ endianness: "LE" });
   });
 
   describe("big endian", () => {
-    testEndiannessFor({ "endianness": "BE" });
+    testEndiannessFor({ endianness: "BE" });
   });
 
   describe("data models", () => {
@@ -77,23 +74,27 @@ describe("abi", () => {
       const dataModel = "LP64";
 
       it("should support structure definition", () => {
-        const def = struct.define(({ field }) => {
-          field.Pointer("myfield1");
-          field.Pointer("myfield2");
-        }).abi({ endianness, dataModel });
+        const def = struct
+          .define(({ field }) => {
+            field.Pointer("myfield1");
+            field.Pointer("myfield2");
+          })
+          .abi({ endianness, dataModel });
 
         assert.strictEqual(def.size, 16);
-        assert.strictEqual(def.offsetof("myfield1"), 0);
-        assert.strictEqual(def.sizeof("myfield1"), 8);
-        assert.strictEqual(def.offsetof("myfield2"), 8);
-        assert.strictEqual(def.sizeof("myfield2"), 8);
+        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 = struct.define(({ field }) => {
-          field.Pointer("myfield1");
-          field.Pointer("myfield2");
-        }).abi({ endianness, dataModel });
+        const def = struct
+          .define(({ field }) => {
+            field.Pointer("myfield1");
+            field.Pointer("myfield2");
+          })
+          .abi({ endianness, dataModel });
 
         const buf = def.format({});
 
@@ -106,14 +107,16 @@ describe("abi", () => {
       });
 
       it("should format data correctly", () => {
-        const def = struct.define(({ field }) => {
-          field.Pointer("myfield1");
-          field.Pointer("myfield2");
-        }).abi({ endianness, dataModel });
+        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);
@@ -129,55 +132,63 @@ describe("abi", () => {
     describe("LP64 - gcc", () => {
       const endianness = "LE";
       const dataModel = "LP64";
-      const alignmentModel = struct.alignmentModels.LP64.gcc;
+      const compiler = "gcc";
 
       it("should align Int8 correctly", () => {
-        const def = struct.define(({ field }) => {
-          field.Int8("myfield1");
-          field.Int8("myfield2");
-        }).abi({ endianness, dataModel, alignmentModel });
-
-        assert.strictEqual(def.offsetof("myfield1"), 0);
-        assert.strictEqual(def.offsetof("myfield2"), 1);
+        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, alignmentModel });
-
-        assert.strictEqual(def.offsetof("myfield1"), 0);
-        assert.strictEqual(def.offsetof("myfield2"), 2);
+        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, alignmentModel });
-
-        assert.strictEqual(def.offsetof("myfield1"), 0);
-        assert.strictEqual(def.offsetof("myfield2"), 4);
+        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, alignmentModel });
-
-        assert.strictEqual(def.offsetof("myfield1"), 0);
-        assert.strictEqual(def.offsetof("myfield2"), 8);
+        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 }) => {