ya-struct 0.0.10 → 0.0.12

package/lib/types/struct.ts

@@ -1,146 +0,0 @@
-import type { TEndianness } from "../common.ts";
-import type { TLayoutedField } from "../layout.ts";
-import { createIntegerParser } from "./integer.ts";
-import { createPointerParser } from "./pointer.ts";
-import { createStringParser } from "./string.ts";
-import { createArrayParser } from "./array.ts";
-import type { TValueParser } from "./value.ts";
-import type { TFieldType } from "./index.ts";
-
-type TStructParser = TValueParser<Record<string, unknown>>;
-
-const subData = ({ data, offsetInBits, sizeInBits }: { data: Uint8Array, offsetInBits: number, sizeInBits: number }) => {
-  return {
-    data: new Uint8Array(data.buffer, data.byteOffset + Math.floor(offsetInBits / 8), Math.ceil(sizeInBits / 8)),
-    offsetInBits: offsetInBits % 8
-  };
-};
-
-const createStructParser = ({
-  layoutedFields,
-  structOffsetInBits,
-  endianness
-}: {
-  layoutedFields: (TLayoutedField & { type: "struct" })["fields"];
-  structOffsetInBits: number;
-  endianness: TEndianness
-}): TStructParser => {
-
-  // eslint-disable-next-line complexity, @typescript-eslint/no-explicit-any
-  const fieldParsers: TValueParser<any>[] = layoutedFields.map((field) => {
-    if (field.definition.type === "integer") {
-      return createIntegerParser({
-        sizeInBits: field.definition.sizeInBits,
-        signed: field.definition.signed,
-        endianness
-      });
-    }
-
-    if (field.definition.type === "pointer") {
-      return createPointerParser({
-        sizeInBits: field.definition.sizeInBits,
-        endianness
-      });
-    }
-
-    if (field.definition.type === "struct") {
-      return createStructParser({
-        layoutedFields: field.definition.fields,
-        structOffsetInBits: field.definition.offsetInBits,
-        endianness
-      });
-    }
-
-    if (field.definition.type === "string") {
-      return createStringParser({
-        length: field.definition.length,
-      });
-    }
-
-    if (field.definition.type === "array") {
-      return createArrayParser({
-        // TODO: cast should not be necessary
-        elementType: field.definition.elementType as TFieldType,
-        endianness,
-        length: field.definition.length
-      });
-    }
-
-    throw Error("not implemented yet");
-  });
-
-  const parse: TStructParser["parse"] = ({ data, offsetInBits }) => {
-    if (offsetInBits !== 0) {
-      throw Error("unaligned struct parsing not supported yet");
-    }
-
-    // eslint-disable-next-line prefer-const
-    let result: Record<string, unknown> = {};
-
-    layoutedFields.forEach((field, idx) => {
-      const fieldParser = fieldParsers[idx];
-
-      // field definition is absolute, subtracting struct offset gives bit offset inside struct
-      // adding data bit offset gives bit offset inside provided data
-      const offsetToProvidedDataInBits = field.definition.offsetInBits - structOffsetInBits + offsetInBits;
-
-      const offsetInBitsInByte = field.definition.offsetInBits % 8;
-      if (offsetInBitsInByte !== 0) {
-        throw Error("not implemented yet: unaligned field parsing");
-      }
-
-      const {
-        data: fieldData,
-        offsetInBits: fieldOffsetInBits
-      } = subData({
-        data,
-        offsetInBits: offsetToProvidedDataInBits,
-        sizeInBits: field.definition.sizeInBits
-      });
-
-      result[field.name] = fieldParser.parse({ data: fieldData, offsetInBits: fieldOffsetInBits });
-    });
-
-    return result;
-  };
-
-  const format: TStructParser["format"] = ({ value, target, offsetInBits }) => {
-    if (offsetInBits % 8 !== 0) {
-      throw Error("unaligned struct formatting not supported yet");
-    }
-
-    layoutedFields.forEach((field, idx) => {
-      const fieldValue = value[field.name];
-      const fieldParser = fieldParsers[idx];
-
-      const offsetInBitsInByte = field.definition.offsetInBits % 8;
-      if (offsetInBitsInByte !== 0) {
-        throw Error("not implemented yet: unaligned field formatting");
-      }
-
-      const {
-        data: fieldTarget,
-        offsetInBits: fieldOffsetInBits
-      } = subData({
-        data: target,
-        offsetInBits: field.definition.offsetInBits - structOffsetInBits + offsetInBits,
-        sizeInBits: field.definition.sizeInBits
-      });
-
-      try {
-        fieldParser.format({ value: fieldValue, target: fieldTarget, offsetInBits: fieldOffsetInBits });
-      } catch (ex) {
-        throw Error(`failed to format field "${field.name}"`, { cause: ex });
-      }
-    });
-  };
-
-  return {
-    parse,
-    format
-  };
-};
-
-export {
-  createStructParser
-};

package/lib/types/value.ts

@@ -1,8 +0,0 @@
-type TValueParser<T> = {
-  parse: ({ data }: { data: Uint8Array, offsetInBits: number }) => T;
-  format: ({ value, target }: { value: T, target: Uint8Array, offsetInBits: number }) => void;
-};
-
-export type {
-  TValueParser
-};

package/package.npm.json

@@ -1,25 +0,0 @@
-{
-  "name": "ya-struct",
-  "description": "Yet Another Node.js Structure API",
-  "main": "dist/lib/index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/k13-engineering/node-ya-struct.git"
-  },
-  "keywords": [
-    "structure",
-    "struct",
-    "abi",
-    "endian",
-    "alignment",
-    "c",
-    "c++",
-    "layout"
-  ],
-  "author": "Simon Kadisch",
-  "license": "LGPL 2.1",
-  "bugs": {
-    "url": "https://github.com/k13-engineering/node-ya-struct/issues"
-  },
-  "homepage": "https://github.com/k13-engineering/node-ya-struct#readme"
-}

package/samples/basic.ts

@@ -1,40 +0,0 @@
-import { define, types } from "../lib/index.ts";
-
-const def = define({
-  definition: {
-    type: "struct",
-    packed: false,
-    fixedAbi: {},
-    fields: [
-      { name: "a", definition: types.Int16 },
-      { name: "b", definition: types.UInt16 },
-      { name: "c", definition: types.UInt32 },
-    ]
-  }
-});
-
-const parser = def.parser({
-  abi: {
-    endianness: "little",
-    dataModel: "LP64",
-    compiler: "gcc",
-  }
-});
-
-const value: ReturnType<typeof parser.parse> = {
-  a: 0n,
-  b: 1n,
-  c: 2n,
-};
-
-console.log("value", value);
-
-const formatted = parser.format({
-  value
-});
-
-console.log("formatted", formatted);
-
-const reparsed = parser.parse({ data: formatted });
-
-console.log("reparsed", reparsed);

package/test/c-structs.ts

@@ -1,399 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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
-};