ya-struct 0.0.5 → 0.0.6

package/test/c-structs.ts

@@ -0,0 +1,399 @@
+import { type TCompiler, type TDataModel } from "../lib/common.ts";
+import { define } from "../lib/parser.ts";
+import { type TCFieldType, type TFieldType } from "../lib/types/index.ts";
+import { determineCCompilerStructLayout } from "./compile-util.ts";
+import nodeAssert from "node:assert";
+
+type TStructDefinition = TFieldType & { type: "struct" };
+
+const simpleStructDefinitionToCCode = ({
+  definition,
+  structName,
+  packed
+}: {
+  definition: TStructDefinition,
+  structName: string,
+  packed: boolean
+}) => {
+
+  const fieldDefinitions = definition.fields.map((field) => {
+
+    switch (field.definition.type) {
+      case "c-type": {
+        return `${field.definition.cType} ${field.name};`;
+      }
+      case "pointer": {
+        return `void* ${field.name};`;
+      }
+      case "string": {
+        return `char ${field.name}[${field.definition.length}];`;
+      }
+      default: {
+        throw Error(`unsupported field type "${field.definition.type}"`);
+      }
+    }
+  });
+
+  return `
+      struct ${structName} {
+        ${fieldDefinitions.join("\n")}
+      } ${packed ? "__attribute__((__packed__))" : ""};
+    `;
+};
+
+const defineStructTestFor = ({
+  packed,
+  dataModel,
+  compiler,
+  fields,
+  structName,
+}: {
+  packed: boolean,
+  dataModel: TDataModel,
+  compiler: TCompiler,
+  fields: TStructDefinition["fields"],
+  structName: string
+}) => {
+  it(`should work for ${structName}, packed=${packed ? "true" : "false"}, dataModel=${dataModel}, compiler=${compiler}`, async () => {
+    const definition: TStructDefinition = {
+      type: "struct",
+      fields,
+      fixedAbi: {},
+      packed
+    };
+
+    const cStructName = "MyStruct1";
+
+    const cDefinition = simpleStructDefinitionToCCode({
+      definition,
+      structName: cStructName,
+      packed
+    });
+
+    const cLayout = await determineCCompilerStructLayout({
+      definitions: cDefinition,
+      structName: cStructName,
+      fieldNames: definition.fields.map((f) => f.name),
+      bits: dataModel === "LP64" ? 64 : 32
+    });
+
+    const def = define({
+      definition
+    });
+
+    const parser = def.parser({
+      abi: {
+        compiler,
+        dataModel,
+        endianness: "little"
+      }
+    });
+
+    nodeAssert.strictEqual(parser.layout.type, "struct");
+
+    let ourLayout = {};
+
+    parser.layout.fields.forEach((fieldLayout) => {
+      const correspondinCLayout = cLayout[fieldLayout.name];
+      nodeAssert.ok(correspondinCLayout !== undefined);
+
+      nodeAssert.ok(fieldLayout.definition.offsetInBits % 8 === 0);
+      nodeAssert.ok(fieldLayout.definition.sizeInBits % 8 === 0);
+
+      ourLayout = {
+        ...ourLayout,
+        [fieldLayout.name]: {
+          offset: fieldLayout.definition.offsetInBits / 8,
+          length: fieldLayout.definition.sizeInBits / 8
+        }
+      };
+    });
+
+    nodeAssert.deepStrictEqual(ourLayout, cLayout);
+  });
+};
+
+type TSingleStructField = TStructDefinition["fields"][0];
+
+const cField = ({ name, cType }: { name: string; cType: TCFieldType }): TSingleStructField => {
+  return {
+    name,
+    definition: {
+      type: "c-type",
+      cType,
+      fixedAbi: {}
+    }
+  };
+};
+
+describe("c-structs", () => {
+
+  const dataModels: TDataModel[] = [
+    "LP64",
+    "ILP32"
+  ];
+
+  const compilers: TCompiler[] = [
+    "gcc"
+  ];
+
+  const fieldsDefinitions: { structName: string, fields: TStructDefinition["fields"] }[] = [
+    {
+      structName: "definition #1",
+      fields: [
+        cField({ name: "a", cType: "char" }),
+        cField({ name: "b", cType: "int" }),
+      ]
+    },
+    // {
+    //     fields: [
+    //         cField({ name: "a", cType: "double" }),
+    //         cField({ name: "b", cType: "int" }),
+    //         cField({ name: "c", cType: "char" }),
+    //     ]
+    // }
+    {
+      structName: "definition #2",
+      fields: [
+        cField({ name: "a", cType: "char" }),
+        cField({ name: "b", cType: "char" }),
+        cField({ name: "c", cType: "char" }),
+      ]
+    },
+    {
+      structName: "definition #3",
+      fields: [
+        cField({ name: "a", cType: "unsigned char" }),
+        cField({ name: "b", cType: "unsigned char" }),
+        cField({ name: "c", cType: "unsigned char" }),
+      ]
+    },
+    {
+      structName: "definition #4",
+      fields: [
+        cField({ name: "a", cType: "short" }),
+        cField({ name: "b", cType: "short" }),
+        cField({ name: "c", cType: "short" }),
+      ]
+    },
+    {
+      structName: "definition #5",
+      fields: [
+        cField({ name: "a", cType: "unsigned short" }),
+        cField({ name: "b", cType: "unsigned short" }),
+        cField({ name: "c", cType: "unsigned short" }),
+      ]
+    },
+    {
+      structName: "definition #6",
+      fields: [
+        cField({ name: "a", cType: "int" }),
+        cField({ name: "b", cType: "int" }),
+        cField({ name: "c", cType: "int" }),
+      ]
+    },
+    {
+      structName: "definition #7",
+      fields: [
+        cField({ name: "a", cType: "unsigned int" }),
+        cField({ name: "b", cType: "unsigned int" }),
+        cField({ name: "c", cType: "unsigned int" }),
+      ]
+    },
+    {
+      structName: "definition #8",
+      fields: [
+        cField({ name: "a", cType: "long" }),
+        cField({ name: "b", cType: "long" }),
+        cField({ name: "c", cType: "long" }),
+      ]
+    },
+    {
+      structName: "definition #9",
+      fields: [
+        cField({ name: "a", cType: "unsigned long" }),
+        cField({ name: "b", cType: "unsigned long" }),
+        cField({ name: "c", cType: "unsigned long" }),
+      ]
+    },
+    {
+      structName: "definition #10",
+      fields: [
+        cField({ name: "a", cType: "long long" }),
+        cField({ name: "b", cType: "long long" }),
+        cField({ name: "c", cType: "long long" }),
+      ]
+    },
+    {
+      structName: "definition #11",
+      fields: [
+        cField({ name: "a", cType: "unsigned long long" }),
+        cField({ name: "b", cType: "unsigned long long" }),
+        cField({ name: "c", cType: "unsigned long long" }),
+      ]
+    },
+    {
+      structName: "definition #12",
+      fields: [
+        cField({ name: "a", cType: "char" }),
+        cField({ name: "b", cType: "short" }),
+        cField({ name: "c", cType: "int" }),
+        cField({ name: "d", cType: "long" }),
+        cField({ name: "e", cType: "long long" }),
+      ]
+    },
+    {
+      structName: "definition #13",
+      fields: [
+        cField({ name: "a", cType: "unsigned char" }),
+        cField({ name: "b", cType: "unsigned short" }),
+        cField({ name: "c", cType: "unsigned int" }),
+        cField({ name: "d", cType: "unsigned long" }),
+        cField({ name: "e", cType: "unsigned long long" }),
+      ]
+    },
+    {
+      structName: "definition #14",
+      fields: [
+        cField({ name: "a", cType: "long long" }),
+        cField({ name: "b", cType: "long" }),
+        cField({ name: "c", cType: "int" }),
+        cField({ name: "d", cType: "short" }),
+        cField({ name: "e", cType: "char" }),
+      ]
+    },
+    {
+      structName: "definition #15",
+      fields: [
+        cField({ name: "a", cType: "unsigned long long" }),
+        cField({ name: "b", cType: "unsigned long" }),
+        cField({ name: "c", cType: "unsigned int" }),
+        cField({ name: "d", cType: "unsigned short" }),
+        cField({ name: "e", cType: "unsigned char" }),
+      ]
+    },
+
+    {
+      structName: "definition #16",
+      fields: [
+        cField({ name: "a", cType: "int" }),
+        {
+          name: "b",
+          definition: {
+            type: "string",
+            charSizeInBits: 8,
+            nullTerminatorMandatory: true,
+            length: 9
+          }
+        },
+        cField({ name: "c", cType: "int" }),
+      ]
+    },
+
+    {
+      structName: "definition #17",
+      fields: [
+        cField({ name: "a", cType: "char" }),
+        {
+          name: "b",
+          definition: {
+            type: "pointer",
+            fixedAbi: {}
+          }
+        },
+        cField({ name: "c", cType: "unsigned long" }),
+      ]
+    },
+
+    {
+      structName: "definition #18",
+      fields: [
+        cField({ name: "a", cType: "char" }),
+        {
+          name: "b",
+          definition: {
+            type: "pointer",
+            fixedAbi: {}
+          }
+        },
+        cField({ name: "c", cType: "unsigned long long" }),
+      ]
+    },
+
+    {
+      structName: "definition #19",
+      fields: [
+        cField({ name: "a", cType: "char" }),
+        {
+          name: "b",
+          definition: {
+            type: "pointer",
+            fixedAbi: {}
+          }
+        },
+        cField({ name: "c", cType: "unsigned int" }),
+      ]
+    },
+
+    {
+      structName: "definition #20",
+      fields: [
+        cField({ name: "a", cType: "unsigned long" }),
+        {
+          name: "b",
+          definition: {
+            type: "pointer",
+            fixedAbi: {}
+          }
+        },
+        cField({ name: "c", cType: "unsigned int" }),
+      ]
+    },
+
+    {
+      structName: "definition #21",
+      fields: [
+        {
+          name: "a",
+          definition: {
+            type: "pointer",
+            fixedAbi: {}
+          }
+        },
+        {
+          name: "b",
+          definition: {
+            type: "pointer",
+            fixedAbi: {}
+          }
+        },
+        {
+          name: "c",
+          definition: {
+            type: "pointer",
+            fixedAbi: {}
+          }
+        },
+      ]
+    }
+  ];
+
+  fieldsDefinitions.forEach(({ fields, structName }) => {
+    [
+      false,
+      true
+    ].forEach((packed) => {
+      dataModels.forEach((dataModel) => {
+        compilers.forEach((compiler) => {
+          defineStructTestFor({
+            packed,
+            dataModel,
+            compiler,
+            fields,
+            structName
+          });
+        });
+      });
+    });
+  });
+});

package/test/compile-util.ts

@@ -0,0 +1,92 @@
+import tmp from "tmp-promise";
+import path from "node:path";
+import fs from "node:fs";
+import child_process from "node:child_process";
+import assert from "node:assert";
+
+const exec = ({ command }: { command: string }) => {
+  return new Promise<{ stdout: string }>((resolve, reject) => {
+    child_process.exec(command, (err, stdout, stderr) => {
+      if (err) {
+        reject(Error(`run failed: ${stderr}`, { cause: err }));
+      } else {
+        resolve({ stdout });
+      }
+    });
+  });
+};
+
+const compileAndRun = async ({ code, bits }: { code: string, bits: 64 | 32 }) => {
+  return await tmp.withDir(async (dir) => {
+    const sourceFile = path.resolve(dir.path, "main.c");
+    const binaryFile = path.resolve(dir.path, "main.out");
+
+    await fs.promises.writeFile(sourceFile, code);
+    try {
+      await exec({ command: `gcc -m${bits} "${sourceFile}" -o "${binaryFile}"` });
+      try {
+        return await exec({ command: `"${binaryFile}"` });
+      } finally {
+        await fs.promises.unlink(binaryFile);
+      }
+    } finally {
+      await fs.promises.unlink(sourceFile);
+    }
+  });
+};
+
+const determineCCompilerStructLayout = async ({
+  definitions,
+  structName,
+  fieldNames,
+  bits
+}: {
+  definitions: string,
+  structName: string,
+  fieldNames: string[],
+  bits: 64 | 32
+}) => {
+  const code = `
+
+    ${definitions}
+
+    #include <stdio.h>
+
+    int main(int argc, char* argv[]) {
+      printf("{ \\"fields\\": {");
+      ${fieldNames.map((field, idx) => {
+
+    let lines = [`printf("\\"${field}\\": { \\"offset\\": %i, \\"length\\": %i }",
+                     __builtin_offsetof(struct ${structName}, ${field}),
+                    sizeof(((struct ${structName}*) 0)->${field}));`];
+
+    if (idx < fieldNames.length - 1) {
+      lines = [...lines, ` printf(", "); `];
+    }
+
+    return lines.join("\n");
+  }).join("\n")}
+      printf("} }");
+
+
+      return 0;
+    }
+  `;
+
+  const { stdout } = await compileAndRun({ code, bits });
+
+  const parsed = JSON.parse(stdout.trim());
+
+  const fields = parsed.fields;
+  Object.keys(fields).forEach((fieldName) => {
+    assert.ok(typeof fields[fieldName].offset === "number");
+    assert.ok(typeof fields[fieldName].length === "number");
+  });
+
+  return fields as { [key: string]: { offset: number; length: number } };
+};
+
+export {
+  compileAndRun,
+  determineCCompilerStructLayout
+};

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "allowImportingTsExtensions": true,
+    "moduleResolution": "NodeNext",
+    "noEmit": true,
+    "esModuleInterop": true,
+    "strict": true
+  }
+}

package/.eslintrc

@@ -1,92 +0,0 @@
-{
-  "parserOptions": {
-    "ecmaVersion": 2021,
-    "sourceType": "module",
-    "requireConfigFile": false
-  },
-  "env": {
-    "node": true,
-    "es2020": true
-  },
-  "rules": {
-    "global-require": "off",
-    "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",
-    "no-multiple-empty-lines": "error",
-    "no-inline-comments": "error",
-    "no-lonely-if": "error",
-    "no-array-constructor": "error",
-    "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],
-    "max-statements": ["error", 15],
-    "no-loss-of-precision": "error",
-    "no-unreachable-loop": "error",
-    "require-atomic-updates": "error",
-    "complexity": ["error", 4],
-    "max-statements-per-line": ["error", { "max": 1 }],
-    "no-tabs": "error",
-    "no-underscore-dangle": "error",
-    "no-negated-condition": "error",
-    "no-use-before-define": "error",
-    "no-shadow": "error",
-    "no-labels": "error",
-    "no-throw-literal": "error",
-    "default-case": "error",
-    "default-case-last": "error",
-    "no-caller": "error",
-    "no-eval": "error",
-    "no-implied-eval": "error",
-    "no-new": "error",
-    "no-new-func": "error",
-    "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 }],
-    "max-depth": ["error", 4],
-    "arrow-parens": "error",
-    "no-confusing-arrow": "error",
-    "prefer-const": "error",
-    "rest-spread-spacing": ["error", "never"],
-    "template-curly-spacing": ["error", "never"],
-    "prefer-rest-params": "error",
-    "prefer-spread": "error",
-    "prefer-template": "error",
-    "object-shorthand": ["error", "properties"],
-    "no-var": "error",
-    "no-useless-computed-key": "error",
-    "array-callback-return": "error",
-    "consistent-return": "error",
-    "dot-notation": "error",
-    "eqeqeq": "error",
-    "no-eq-null": "error",
-    "no-implicit-coercion": "error",
-    "no-multi-spaces": "error",
-    "no-proto": "error",
-    "yoda": "error",
-    "indent": ["error", 2],
-    "object-curly-spacing": [ "error", "always" ],
-    "object-curly-newline": ["error", { "consistent": true, "multiline": true }],
-    "space-before-blocks": "error",
-    "space-before-function-paren": [ "error", "always" ],
-    "spaced-comment": "error",
-    "no-whitespace-before-property": "error",
-    "brace-style": ["error", "1tbs", { "allowSingleLine": false }],
-    "eol-last": ["error", "always"],
-    "func-call-spacing": ["error", "never"],
-    "semi": ["error", "always"]
-  },
-  "extends": "eslint:recommended"
-}

package/.github/workflows/CI.yml

@@ -1,39 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-jobs:
-  tests:
-    runs-on: ubuntu-latest
-    name: tests
-
-    strategy:
-      matrix:
-        arch: [ amd64, arm64v8, arm32v7 ]
-        node: [ 15, 16 ]
-      fail-fast: false
-
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2-beta
-        with:
-          node-version: '15'
-      - uses: docker/setup-qemu-action@v1
-      - name: Install dependencies
-        run: npm install
-      - name: Run tests
-        run: node_modules/.bin/archibald -p -a ${{ matrix.arch }} -n ${{ matrix.node }} .
-
-  linter:
-    runs-on: ubuntu-latest
-    name: linter
-
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2-beta
-        with:
-          node-version: '15'
-      - name: Install dependencies
-        run: npm install
-      - name: Verify code with ESLint
-        run: npm run eslint

package/.prettierrc

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

package/lib/builder.js

@@ -1,62 +0,0 @@
-import ctypes from "./types/ctypes.js";
-import basicTypes from "./types/basic.js";
-import marshallerFactory from "./marshaller.js";
-
-const createFieldsViaBuilder = ({
-  builder,
-  abi: { endianness = "LE", dataModel = "LP64", compiler = "gcc" } = {},
-}) => {
-  let fieldDefinitions = {};
-
-  let currentOffset = 0;
-
-  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;
-        },
-      };
-    });
-
-    return result;
-  };
-
-  const basicTypesAbi = basicTypes.abi({ dataModel, compiler, endianness });
-  const cTypesAbi = ctypes.abi({ dataModel, compiler, endianness });
-
-  const field = {
-    ...fieldBuilderForAbi({ abi: basicTypesAbi }),
-    CTypes: fieldBuilderForAbi({ abi: cTypesAbi }),
-  };
-
-  builder({ field });
-
-  const size = currentOffset;
-
-  const { marshal, unmarshal } = marshallerFactory.create({
-    fieldDefinitions,
-    size,
-  });
-
-  return {
-    fields: fieldDefinitions,
-    size,
-
-    marshal,
-    unmarshal,
-  };
-};
-
-export default {
-  createFieldsViaBuilder,
-};