ya-struct 0.0.12 → 0.0.13

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];

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> = {

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

@@ -37,9 +37,13 @@ const flattenLayout = ({
   parentPath: string;
 }*/)/*: TFlatField[]*/ => {
   return fields.flatMap((field) => {
+    if (field.pad) {
+      return [];
+    }
+
     const fieldPath = parentPath
       ? `${parentPath}.${field.name}`
-      : field.name;
+      : field.name/*!*/;
 
     const isStruct = field.definition.type === "struct";
 

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.12",
+  "version": "0.0.13",
   "name": "ya-struct",
   "type": "module",
   "description": "Yet Another Node.js Structure API",