ya-struct 0.0.11 → 0.0.13

package/dist/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { define } from "./parser.js";
 import { types } from "./types/index.js";
+import { compileAndCompare } from "./tests/compile-and-compare.vibe.js";
 import type { TAbi, TCompiler, TDataModel, TEndianness } from "./common.js";
-export { define, types };
+export { define, types, compileAndCompare };
 export type { TAbi, TEndianness, TCompiler, TDataModel };

package/dist/lib/index.js

@@ -1,5 +1,6 @@
 import { define } from "./parser.js";
 import { types } from "./types/index.js";
+import { compileAndCompare } from "./tests/compile-and-compare.vibe.js";
 
 /*import type {
   TAbi,
@@ -10,7 +11,8 @@ import { types } from "./types/index.js";
 
 export {
   define,
-  types
+  types,
+  compileAndCompare
 };
 
 /*export type {

package/dist/lib/layout.d.ts

@@ -26,10 +26,15 @@ type TLayoutedField = {
     readonly type: "struct";
     readonly offsetInBits: number;
     readonly sizeInBits: number;
-    readonly fields: readonly {
+    readonly fields: readonly ({
+        readonly pad?: false;
         readonly name: string;
         readonly definition: TLayoutedField;
-    }[];
+    } | {
+        readonly pad: true;
+        readonly name: string | undefined;
+        readonly definition: TLayoutedField;
+    })[];
     readonly packed: boolean;
     readonly fixedAbi: Partial<TAbi>;
 } | {

package/dist/lib/layout.js

@@ -29,7 +29,15 @@ import nodeUtil from "node:util";
   readonly type: "struct";
   readonly offsetInBits: number;
   readonly sizeInBits: number;
-  readonly fields: readonly { readonly name: string; readonly definition: TLayoutedField }[];
+  readonly fields: readonly ({
+    readonly pad?: false;
+    readonly name: string;
+    readonly definition: TLayoutedField;
+  } | {
+    readonly pad: true;
+    readonly name: string | undefined;
+    readonly definition: TLayoutedField;
+  })[];
   readonly packed: boolean;
   readonly fixedAbi: Partial<TAbi>;
 } | {
@@ -51,6 +59,83 @@ const pointerSizeInBitsByDataModel = ({ dataModel }/*: { dataModel: TAbi["dataMo
   }
 };
 
+// eslint-disable-next-line max-statements, complexity
+const alignmentOfField = ({ definition, abi }/*: { definition: TFieldType, abi: TAbi }*/)/*: number*/ => {
+  if (definition.type === "c-type") {
+    const cTypeNormalizer = createCTypeNormalizer({ abi });
+    const normalizedField = cTypeNormalizer.normalize({ cField: definition });
+    return alignmentOfField({ definition: normalizedField, abi });
+  }
+
+  if (definition.type === "integer" || definition.type === "float") {
+    const sizeInBits = definition.sizeInBits;
+    if (abi.compiler === "gcc" && abi.dataModel === "ILP32" && sizeInBits === 64) {
+      return 32;
+    }
+    return sizeInBits;
+  }
+
+  if (definition.type === "pointer") {
+    return pointerSizeInBitsByDataModel({ dataModel: abi.dataModel });
+  }
+
+  if (definition.type === "array") {
+    return alignmentOfField({ definition: definition.elementType, abi });
+  }
+
+  if (definition.type === "struct") {
+    if (definition.packed) {
+      return 8;
+    }
+    if (definition.fields.length === 0) {
+      return 8;
+    }
+    return Math.max(...definition.fields.map((f) => {
+      return alignmentOfField({ definition: f.definition, abi });
+    }));
+  }
+
+  if (definition.type === "string") {
+    return definition.charSizeInBits;
+  }
+
+  throw Error(`unsupported field type for alignment calculation`);
+};
+
+// eslint-disable-next-line complexity
+const translateLayoutOffset = ({ field, offset }/*: { field: TLayoutedField; offset: number }*/)/*: TLayoutedField*/ => {
+  if (offset === 0) {
+    return field;
+  }
+
+  switch (field.type) {
+  case "integer":
+    return { ...field, offsetInBits: field.offsetInBits + offset };
+  case "float":
+    return { ...field, offsetInBits: field.offsetInBits + offset };
+  case "pointer":
+    return { ...field, offsetInBits: field.offsetInBits + offset };
+  case "string":
+    return { ...field, offsetInBits: field.offsetInBits + offset };
+  case "array":
+    return { ...field, offsetInBits: field.offsetInBits + offset };
+  case "struct":
+    return {
+      ...field,
+      offsetInBits: field.offsetInBits + offset,
+      fields: field.fields.map((f) => {
+        const translated = translateLayoutOffset({ field: f.definition, offset });
+        if (f.pad) {
+          return { pad: true /*as const*/, name: f.name, definition: translated };
+        }
+        return { name: f.name, definition: translated };
+      })
+    };
+  default:
+    throw Error(`unsupported field type for layout offset translation`);
+  }
+};
+
 const layoutStruct = ({
   definition,
   abi,
@@ -61,13 +146,13 @@ const layoutStruct = ({
   currentOffsetInBits: number
 }*/)/*: TLayoutedField*/ => {
 
-  // TODO: implement alignment handling
-  const structAlignmentInBits = 64;
-  // const fieldAlignmentInBits = 64;
+  const structAlignmentInBits = definition.packed ? 8 : alignmentOfField({ definition, abi });
   const fieldAlignmentInBits = 1;
   const pointerSizeInBits = pointerSizeInBitsByDataModel({ dataModel: abi.dataModel });
 
-  let currentOffsetInBits = align({ offset: initialOffsetInBits, alignment: structAlignmentInBits });
+  // Compute internal layout from offset 0 to ensure correct internal alignment
+  // independent of the struct's placement position
+  let currentOffsetInBits = 0;
   let layoutedFields/*: (TLayoutedField & { type: "struct" })["fields"]*/ = [];
 
   // eslint-disable-next-line max-statements,complexity
@@ -112,11 +197,8 @@ const layoutStruct = ({
         break;
       }
       case "struct": {
-
-        if (currentOffsetInBits % 64 !== 0) {
-          throw Error("nested struct alignment handling not implemented yet");
-        }
-
+        const nestedAlignment = alignmentOfField({ definition: normalizedField, abi });
+        currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: nestedAlignment });
         break;
       }
       case "string": {
@@ -137,20 +219,34 @@ const layoutStruct = ({
 
     layoutedFields = [
       ...layoutedFields,
-      {
-        name: field.name,
-        definition: fieldLayout
-      }
+      field.pad
+        ? { pad: true /*as const*/, name: field.name, definition: fieldLayout }
+        : { name: field.name, definition: fieldLayout }
     ];
 
     currentOffsetInBits = align({ offset: fieldLayout.offsetInBits + fieldLayout.sizeInBits, alignment: fieldAlignmentInBits });
   });
 
+  if (!definition.packed) {
+    currentOffsetInBits = align({ offset: currentOffsetInBits, alignment: structAlignmentInBits });
+  }
+
+  const sizeInBits = currentOffsetInBits;
+
+  // Translate all field offsets to the actual placement position
+  const translatedFields = layoutedFields.map((f) => {
+    const translated = translateLayoutOffset({ field: f.definition, offset: initialOffsetInBits });
+    if (f.pad) {
+      return { pad: true /*as const*/, name: f.name, definition: translated };
+    }
+    return { name: f.name, definition: translated };
+  });
+
   return {
     type: "struct",
     offsetInBits: initialOffsetInBits,
-    sizeInBits: currentOffsetInBits - initialOffsetInBits,
-    fields: layoutedFields,
+    sizeInBits,
+    fields: translatedFields,
     packed: definition.packed,
     fixedAbi: definition.fixedAbi
   };

package/dist/lib/parser.d.ts

@@ -16,20 +16,42 @@ type FieldValue<T extends TFieldType> = T extends {
 } ? FieldValue<E & TFieldType>[] : T extends {
     type: "struct";
     fields: infer F;
-} ? StructValue<F & readonly {
+} ? StructValue<F & readonly ({
+    pad?: false | undefined;
     name: string;
     definition: TFieldType;
-}[]> : T extends {
+} | {
+    pad: true;
+    name: string | undefined;
+    definition: TFieldType;
+})[]> : T extends {
     type: "c-type";
     cType: "float" | "double" | "long double";
 } ? number : T extends {
     type: "c-type";
 } ? bigint : never;
-type StructValue<F extends readonly {
+type NonPadFields<F extends readonly ({
+    pad?: false | undefined;
+    name: string;
+    definition: TFieldType;
+} | {
+    pad: true;
+    name: string | undefined;
+    definition: TFieldType;
+})[]> = Extract<F[number], {
+    pad?: false | undefined;
+    name: string;
+}>;
+type StructValue<F extends readonly ({
+    pad?: false | undefined;
     name: string;
     definition: TFieldType;
-}[]> = {
-    [K in F[number] as K["name"]]: FieldValue<K["definition"]>;
+} | {
+    pad: true;
+    name: string | undefined;
+    definition: TFieldType;
+})[]> = {
+    [K in NonPadFields<F> as K["name"]]: FieldValue<K["definition"]>;
 };
 type Simplify<T> = {
     [K in keyof T]: T[K];
@@ -54,3 +76,4 @@ declare const define: <const T extends TFieldType>({ definition }: {
     }) => TParser<T>;
 };
 export { define };
+export type { TParser, };

package/dist/lib/parser.js

@@ -12,15 +12,34 @@ import { createStructParser } from "./types/struct.js";
   T extends { type: "array"; elementType: infer E; length: number }
   ? FieldValue<E & TFieldType>[] :
   T extends { type: "struct"; fields: infer F }
-  ? StructValue<F & readonly { name: string; definition: TFieldType }[]> :
-  T extends { type: "c-type"; cType: "float" | "double" | "long double" } ? number :
+  ? StructValue<
+    F & readonly (
+      | { pad?: false | undefined; name: string; definition: TFieldType }
+      | { pad: true; name: string | undefined; definition: TFieldType }
+    )[]
+  > :
+  T extends {
+    type: "c-type";
+    cType: "float" | "double" | "long double";
+  } ? number :
   T extends { type: "c-type" } ? bigint :
   never;*/
 
+/*type NonPadFields<
+  F extends readonly (
+    | { pad?: false | undefined; name: string; definition: TFieldType }
+    | { pad: true; name: string | undefined; definition: TFieldType }
+  )[]
+> =
+  Extract<F[number], { pad?: false | undefined; name: string }>;*/
+
 /*type StructValue<
-  F extends readonly { name: string; definition: TFieldType }[]
+  F extends readonly (
+    | { pad?: false | undefined; name: string; definition: TFieldType }
+    | { pad: true; name: string | undefined; definition: TFieldType }
+  )[]
 > = {
-    [K in F[number]as K["name"]]: FieldValue<K["definition"]>;
+    [K in NonPadFields<F> as K["name"]]: FieldValue<K["definition"]>;
   };*/
 
 /*type Simplify<T> = {
@@ -88,3 +107,7 @@ const define = /*<const T extends TFieldType>*/({ definition }/*: { definition:
 export {
   define
 };
+
+/*export type {
+  TParser,
+};*/

package/dist/lib/tests/compile-and-compare.vibe.d.ts

@@ -0,0 +1,30 @@
+import type { TAbi } from "../common.js";
+import type { TFieldType } from "../types/index.js";
+type TLayoutError = {
+    type: "size-mismatch";
+    fieldPath: string;
+    expectedSizeInBits: number;
+    actualSizeInBits: number;
+} | {
+    type: "offset-mismatch";
+    fieldPath: string;
+    expectedOffsetInBits: number;
+    actualOffsetInBits: number;
+};
+type TCompileAndCompareResult = {
+    layoutErrors: TLayoutError[];
+};
+declare const compileAndCompare: ({ structDefinition, abi, globalCode, cStructName, compileAndRun }: {
+    structDefinition: Extract<TFieldType, {
+        type: "struct";
+    }>;
+    abi: TAbi;
+    globalCode: string;
+    cStructName: string;
+    compileAndRun: ({ sourceCode }: {
+        sourceCode: string;
+    }) => Promise<{
+        output: string;
+    }>;
+}) => Promise<TCompileAndCompareResult>;
+export { compileAndCompare };

package/dist/lib/tests/compile-and-compare.vibe.js

@@ -0,0 +1,225 @@
+/*import type { TAbi } from "../common.ts";*/
+/*import type { TLayoutedField } from "../layout.ts";*/
+import { define } from "../parser.js";
+/*import type { TFieldType } from "../types/index.ts";*/
+
+/*type TLayoutError = {
+  type: "size-mismatch",
+  fieldPath: string;
+  expectedSizeInBits: number;
+  actualSizeInBits: number;
+} | {
+  type: "offset-mismatch",
+  fieldPath: string;
+  expectedOffsetInBits: number;
+  actualOffsetInBits: number;
+};*/
+
+/*type TCompileAndCompareResult = {
+  layoutErrors: TLayoutError[];
+};*/
+
+/*type TFlatField = {
+  fieldPath: string;
+  offsetInBits: number;
+  sizeInBits: number;
+  isStruct: boolean;
+};*/
+
+/*type TStructLayoutedFields =
+  (TLayoutedField & { type: "struct" })["fields"];*/
+
+const flattenLayout = ({
+  fields,
+  parentPath
+}/*: {
+  fields: TStructLayoutedFields;
+  parentPath: string;
+}*/)/*: TFlatField[]*/ => {
+  return fields.flatMap((field) => {
+    if (field.pad) {
+      return [];
+    }
+
+    const fieldPath = parentPath
+      ? `${parentPath}.${field.name}`
+      : field.name/*!*/;
+
+    const isStruct = field.definition.type === "struct";
+
+    const entry/*: TFlatField*/ = {
+      fieldPath,
+      offsetInBits: field.definition.offsetInBits,
+      sizeInBits: field.definition.sizeInBits,
+      isStruct,
+    };
+
+    if (isStruct) {
+      return [
+        entry,
+        ...flattenLayout({
+          fields: field.definition.fields,
+          parentPath: fieldPath,
+        }),
+      ];
+    }
+
+    return [entry];
+  });
+};
+
+const generateSourceCode = ({
+  globalCode,
+  cStructName,
+  flatFields,
+}/*: {
+  globalCode: string;
+  cStructName: string;
+  flatFields: TFlatField[];
+}*/) => {
+
+  const printStatements = flatFields.map((f, idx) => {
+    if (f.isStruct) {
+      const offsetExpr =
+        `offsetof(struct ${cStructName}, ${f.fieldPath}) * CHAR_BIT`;
+      const sizeExpr =
+        `sizeof(((struct ${cStructName}*)0)->${f.fieldPath}) * CHAR_BIT`;
+
+      return `  printf("%zu %zu\\n", `
+        + `(size_t)(${offsetExpr}), (size_t)(${sizeExpr}));`;
+    }
+
+    // Use memory scanning to detect actual bit offset and size.
+    // This works for both regular fields and bitfields.
+    return `  {
+    struct ${cStructName} __s${idx};
+    memset(&__s${idx}, 0, sizeof(__s${idx}));
+    memset(&__s${idx}.${f.fieldPath}, 0xFF, sizeof(__s${idx}.${f.fieldPath}));
+    unsigned char *__p${idx} = (unsigned char *)&__s${idx};
+    size_t __off${idx} = 0, __sz${idx} = 0;
+    int __found${idx} = 0;
+    for (size_t __i = 0; __i < sizeof(struct ${cStructName}) * CHAR_BIT; __i++) {
+      if (__p${idx}[__i / CHAR_BIT] & (1u << (__i % CHAR_BIT))) {
+        if (!__found${idx}) { __off${idx} = __i; __found${idx} = 1; }
+        __sz${idx}++;
+      }
+    }
+    printf("%zu %zu\\n", __off${idx}, __sz${idx});
+  }`;
+  }).join("\n");
+
+  return `#include <stdio.h>
+#include <stddef.h>
+#include <limits.h>
+#include <string.h>
+${globalCode}
+
+int main(void) {
+${printStatements}
+  return 0;
+}
+`;
+};
+
+const parseCOutput = ({
+  output,
+}/*: {
+  output: string;
+}*/)/*: { offset: number; size: number }[]*/ => {
+  return output.trim().split("\n").map((line) => {
+    const parts = line.trim().split(" ");
+    return {
+      offset: parseInt(parts[0], 10),
+      size: parseInt(parts[1], 10),
+    };
+  });
+};
+
+const compareLayouts = ({
+  flatFields,
+  cFields,
+}/*: {
+  flatFields: TFlatField[];
+  cFields: { offset: number; size: number }[];
+}*/)/*: TLayoutError[]*/ => {
+  return flatFields.flatMap((field, idx) => {
+    const cField = cFields[idx];
+    if (!cField) {
+      return [];
+    }
+
+    const sizeMismatch/*: TLayoutError[]*/ =
+      cField.size === field.sizeInBits
+        ? []
+        : [{
+          type: "size-mismatch" /*as const*/,
+          fieldPath: field.fieldPath,
+          expectedSizeInBits: cField.size,
+          actualSizeInBits: field.sizeInBits,
+        }];
+
+    const offsetMismatch/*: TLayoutError[]*/ =
+      cField.offset === field.offsetInBits
+        ? []
+        : [{
+          type: "offset-mismatch" /*as const*/,
+          fieldPath: field.fieldPath,
+          expectedOffsetInBits: cField.offset,
+          actualOffsetInBits: field.offsetInBits,
+        }];
+
+    return [...sizeMismatch, ...offsetMismatch];
+  });
+};
+
+const compileAndCompare = async ({
+  structDefinition,
+  abi,
+
+  globalCode,
+  cStructName,
+
+  compileAndRun
+}/*: {
+  structDefinition: Extract<TFieldType, { type: "struct" }>;
+  abi: TAbi;
+
+  globalCode: string;
+  cStructName: string;
+
+  compileAndRun: ({ sourceCode }: { sourceCode: string }) => Promise<{
+    output: string;
+  }>;
+}*/)/*: Promise<TCompileAndCompareResult>*/ => {
+
+  const def = define({ definition: structDefinition });
+  const parser = def.parser({ abi });
+  const layoutResult = parser.layout;
+
+  if (layoutResult.type !== "struct") {
+    throw Error("expected struct layout");
+  }
+
+  const flatFields = flattenLayout({
+    fields: layoutResult.fields,
+    parentPath: "",
+  });
+
+  const sourceCode = generateSourceCode({
+    globalCode,
+    cStructName,
+    flatFields,
+  });
+
+  const { output } = await compileAndRun({ sourceCode });
+
+  const cFields = parseCOutput({ output });
+
+  const layoutErrors = compareLayouts({ flatFields, cFields });
+
+  return { layoutErrors };
+};
+
+export {
+  compileAndCompare
+};

package/dist/lib/types/index.d.ts

@@ -18,10 +18,15 @@ type TFieldType = {
     readonly length: number;
 } | {
     readonly type: "struct";
-    readonly fields: readonly {
+    readonly fields: readonly ({
+        readonly pad?: false | undefined;
         readonly name: string;
         readonly definition: TFieldType;
-    }[];
+    } | {
+        readonly pad: true;
+        readonly name: string | undefined;
+        readonly definition: TFieldType;
+    })[];
     readonly packed: boolean;
     readonly fixedAbi: Partial<TAbi>;
 } | {

package/dist/lib/types/index.js

@@ -26,7 +26,15 @@
   readonly length: number;
 } | {
   readonly type: "struct";
-  readonly fields: readonly { readonly name: string; readonly definition: TFieldType }[];
+  readonly fields: readonly ({
+    readonly pad?: false | undefined;
+    readonly name: string;
+    readonly definition: TFieldType
+  } | {
+    readonly pad: true;
+    readonly name: string | undefined;
+    readonly definition: TFieldType;
+  })[];
   readonly packed: boolean;
   readonly fixedAbi: Partial<TAbi>;
 } | {

package/dist/lib/types/struct.js

@@ -78,6 +78,10 @@ const createStructParser = ({
     let result/*: Record<string, unknown>*/ = {};
 
     layoutedFields.forEach((field, idx) => {
+      if (field.pad) {
+        return;
+      }
+
       const fieldParser = fieldParsers[idx];
 
       // field definition is absolute, subtracting struct offset gives bit offset inside struct
@@ -99,7 +103,7 @@ const createStructParser = ({
       });
 
       // eslint-disable-next-line immutable/no-mutation -- performance
-      result[field.name] = fieldParser.parse({ data: fieldData, offsetInBits: fieldOffsetInBits });
+      result[field.name/*!*/] = fieldParser.parse({ data: fieldData, offsetInBits: fieldOffsetInBits });
     });
 
     return result;
@@ -111,7 +115,11 @@ const createStructParser = ({
     }
 
     layoutedFields.forEach((field, idx) => {
-      const fieldValue = value[field.name];
+      if (field.pad) {
+        return;
+      }
+
+      const fieldValue = value[field.name/*!*/];
       const fieldParser = fieldParsers[idx];
 
       const offsetInBitsInByte = field.definition.offsetInBits % 8;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.11",
+  "version": "0.0.13",
   "name": "ya-struct",
   "type": "module",
   "description": "Yet Another Node.js Structure API",