ya-struct 0.0.4 → 0.0.6

package/dist/lib/parser.js

@@ -0,0 +1,87 @@
+/*import type { TAbi } from "./common.ts";*/
+import { layout, /*type TLayoutedField */} from "./layout.js";
+/*import type { TFieldType } from "./types/index.ts";*/
+import { createStructParser } from "./types/struct.js";
+/*import type { TValueParser } from "./types/value.ts";*/
+
+/*type FieldValue<T extends TFieldType> =
+  T extends { type: "integer" } ? bigint :
+  T extends { type: "float" } ? number :
+  T extends { type: "pointer" } ? bigint :
+  T extends { type: "string" } ? string :
+  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 }[]> :
+  never;*/
+
+/*type StructValue<
+  F extends readonly { name: string; definition: TFieldType }[]
+> = {
+    [K in F[number]as K["name"]]: FieldValue<K["definition"]>;
+  };*/
+
+/*type Simplify<T> = {
+  [K in keyof T]: T[K]
+} & {};*/
+
+/*type TParsedValueOfDefinition<T extends TFieldType> = Simplify<FieldValue<T>>;*/
+
+/*type TParser<T extends TFieldType> = {
+  size: number;
+  parse: ({ data }: { data: Uint8Array }) => TParsedValueOfDefinition<T>;
+  format: ({ value }: { value: TParsedValueOfDefinition<T> }) => Uint8Array;
+  layout: TLayoutedField;
+};*/
+
+const define = /*<const T extends TFieldType>*/({ definition }/*: { definition: T }*/) => {
+
+  const parser = ({ abi }/*: { abi: TAbi }*/)/*: TParser<T>*/ => {
+
+    /*type P = TParser<T>;*/
+
+    const l = layout({ definition, abi, currentOffsetInBits: 0 });
+
+    const size = Math.ceil(l.sizeInBits / 8);
+
+    // console.log(l);
+
+    let valueParser/*: TValueParser<TParsedValueOfDefinition<T>>*/;
+
+    if (l.type === "struct") {
+      valueParser = createStructParser({
+        layoutedFields: l.fields,
+        endianness: abi.endianness
+      }) /*as unknown*/ /*as TValueParser<TParsedValueOfDefinition<T>>*/;
+    } else {
+      throw Error("only struct root definitions are supported currently");
+    }
+
+    const parse/*: P["parse"]*/ = ({ data }) => {
+      return valueParser.parse({ data, offsetInBits: 0 });
+    };
+
+    const format/*: P["format"]*/ = ({ value }) => {
+      const data = new Uint8Array(l.sizeInBits / 8);
+      valueParser.format({ value, target: data, offsetInBits: 0 });
+
+      return data;
+    };
+
+    return {
+      size,
+      parse,
+      format,
+      layout: l
+    };
+  };
+
+  return {
+    definition,
+    parser
+  };
+};
+
+export {
+  define
+};

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

@@ -0,0 +1,10 @@
+import type { TEndianness } from "../common.js";
+import type { TFieldType } from "./index.js";
+import type { TValueParser } from "./value.js";
+type TArrayParser = TValueParser<unknown[]>;
+declare const createArrayParser: ({ elementType, length, endianness }: {
+    elementType: TFieldType;
+    length: number;
+    endianness: TEndianness;
+}) => TArrayParser;
+export { createArrayParser };

package/dist/lib/types/array.js

@@ -0,0 +1,90 @@
+/*import type { TEndianness } from "../common.ts";*/
+/*import type { TFieldType } from "./index.ts";*/
+import { createIntegerParser } from "./integer.js";
+/*import type { TValueParser } from "./value.ts";*/
+
+/*type TArrayParser = TValueParser<unknown[]>;*/
+
+const createArrayParser = ({
+  elementType,
+  length,
+  endianness
+}/*: {
+  elementType: TFieldType,
+  length: number,
+  endianness: TEndianness
+}*/)/*: TArrayParser*/ => {
+
+  let fieldParser/*: TValueParser<unknown>*/;
+
+  if (elementType.type === "integer") {
+    fieldParser = createIntegerParser({
+      sizeInBits: elementType.sizeInBits,
+      signed: elementType.signed,
+      endianness
+    }) /*as TValueParser<unknown>*/;
+  } else {
+    throw Error("only integer array elements are supported currently");
+  }
+
+  const elementSizeInBytes = elementType.sizeInBits / 8;
+  if (!Number.isInteger(elementSizeInBytes)) {
+    throw Error("BUG: non byte-aligned array element size");
+  }
+
+  const parse/*: TArrayParser["parse"]*/ = ({ data, offsetInBits }) => {
+    if (offsetInBits !== 0) {
+      throw Error("unaligned array parsing not supported yet");
+    }
+
+    // eslint-disable-next-line prefer-const
+    let result/*: unknown[]*/ = [];
+
+    for (let i = 0; i < length; i += 1) {
+      const fieldData = data.subarray(i * elementSizeInBytes, (i + 1) * elementSizeInBytes);
+      const fieldValue = fieldParser.parse({ data: fieldData, offsetInBits: 0 });
+      result.push(fieldValue);
+    }
+
+    return result;
+  };
+
+  // eslint-disable-next-line complexity
+  const format/*: TArrayParser["format"]*/ = ({ value, target, offsetInBits }) => {
+    if (offsetInBits !== 0) {
+      throw Error("unaligned array formatting not supported yet");
+    }
+
+    if (value.length !== length) {
+      throw Error(`array length mismatch: field length is ${length}, value length is ${value.length}`);
+    }
+
+    if (target.length < length * elementSizeInBytes) {
+      throw Error("not enough space in target for array formatting");
+    }
+
+    for (let i = 0; i < length; i += 1) {
+      const fieldTarget = target.subarray(i * elementSizeInBytes, (i + 1) * elementSizeInBytes);
+
+      try {
+        fieldParser.format({
+          value: value[i],
+          target: fieldTarget,
+          offsetInBits: 0
+        });
+      } catch (ex) {
+        throw Error(`failed to format array element at index ${i}`, { cause: ex });
+      }
+
+    }
+  };
+
+  return {
+    parse,
+    format
+  };
+};
+
+export {
+  createArrayParser
+};

package/dist/lib/types/c-types.d.ts

@@ -0,0 +1,13 @@
+import { type TAbi } from "../common.js";
+import { type TFieldType, type TPrimitiveBasicFieldType } from "./index.js";
+type TCField = TFieldType & {
+    type: "c-type";
+};
+declare const createCTypeNormalizer: ({ abi }: {
+    abi: TAbi;
+}) => {
+    normalize: ({ cField }: {
+        cField: TCField;
+    }) => TPrimitiveBasicFieldType;
+};
+export { createCTypeNormalizer };

package/dist/lib/types/c-types.js

@@ -0,0 +1,222 @@
+import { /*type TCompiler, *//*type TDataModel, *//*type TAbi */} from "../common.js";
+import { /*type TFieldType, *//*type TCFieldType, *//*type TPrimitiveBasicFieldType */} from "./index.js";
+
+/*type TCField = TFieldType & { type: "c-type" };*/
+
+/*type TPartialCTypeMappings = {
+  [dataModel in TDataModel]?: {
+    [compiler in TCompiler]?: {
+      [field in TCFieldType]?: TPrimitiveBasicFieldType
+    }
+  }
+};*/
+
+const cTypeMappings/*: TPartialCTypeMappings*/ = {
+  LP64: {
+    gcc: {
+      "char": {
+        type: "integer",
+        sizeInBits: 8,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned char": {
+        type: "integer",
+        sizeInBits: 8,
+        fixedAbi: {},
+        signed: false
+      },
+      "short": {
+        type: "integer",
+        sizeInBits: 16,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned short": {
+        type: "integer",
+        sizeInBits: 16,
+        fixedAbi: {},
+        signed: false
+      },
+      "int": {
+        type: "integer",
+        sizeInBits: 32,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned int": {
+        type: "integer",
+        sizeInBits: 32,
+        fixedAbi: {},
+        signed: false
+      },
+      "long": {
+        type: "integer",
+        sizeInBits: 64,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned long": {
+        type: "integer",
+        sizeInBits: 64,
+        fixedAbi: {},
+        signed: false
+      },
+      "long long": {
+        type: "integer",
+        sizeInBits: 64,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned long long": {
+        type: "integer",
+        sizeInBits: 64,
+        fixedAbi: {},
+        signed: false
+      },
+      "float": {
+        type: "float",
+        sizeInBits: 32,
+        fixedAbi: {}
+      },
+      "double": {
+        type: "float",
+        sizeInBits: 64,
+        fixedAbi: {}
+      },
+      "long double": {
+        type: "float",
+        sizeInBits: 128,
+        fixedAbi: {}
+      },
+    }
+  },
+
+  ILP32: {
+    gcc: {
+      "char": {
+        type: "integer",
+        sizeInBits: 8,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned char": {
+        type: "integer",
+        sizeInBits: 8,
+        fixedAbi: {},
+        signed: false
+      },
+      "short": {
+        type: "integer",
+        sizeInBits: 16,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned short": {
+        type: "integer",
+        sizeInBits: 16,
+        fixedAbi: {},
+        signed: false
+      },
+      "int": {
+        type: "integer",
+        sizeInBits: 32,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned int": {
+        type: "integer",
+        sizeInBits: 32,
+        fixedAbi: {},
+        signed: false
+      },
+      "long": {
+        type: "integer",
+        sizeInBits: 32,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned long": {
+        type: "integer",
+        sizeInBits: 32,
+        fixedAbi: {},
+        signed: false
+      },
+      "long long": {
+        type: "integer",
+        sizeInBits: 64,
+        fixedAbi: {},
+        signed: true
+      },
+      "unsigned long long": {
+        type: "integer",
+        sizeInBits: 64,
+        fixedAbi: {},
+        signed: false
+      },
+      "float": {
+        type: "float",
+        sizeInBits: 32,
+        fixedAbi: {}
+      },
+      "double": {
+        type: "float",
+        sizeInBits: 64,
+        fixedAbi: {}
+      },
+      "long double": {
+        type: "float",
+        sizeInBits: 128,
+        fixedAbi: {}
+      },
+    }
+  }
+};
+
+const createCTypeNormalizer = ({
+  abi
+}/*: {
+  abi: TAbi
+}*/) => {
+
+  const fieldMappings = cTypeMappings[abi.dataModel]?.[abi.compiler];
+  if (!fieldMappings) {
+    throw Error(`no c-type mappings for data model ${abi.dataModel} and compiler ${abi.compiler}`);
+  }
+
+  const normalize = ({ cField }/*: { cField: TCField }*/)/*: TPrimitiveBasicFieldType*/ => {
+
+    const mapping = fieldMappings[cField.cType];
+    if (mapping === undefined) {
+      throw Error(`no c-type mapping for c-type "${cField.cType}" for data model ${abi.dataModel} and compiler ${abi.compiler}`);
+    }
+
+    const mappingFixedAbi = mapping.fixedAbi;
+    const fieldFixedAbi = cField.fixedAbi;
+
+    const fixedAbi = {
+      ...mappingFixedAbi,
+      ...fieldFixedAbi
+    };
+
+    Object.keys(fixedAbi).forEach((keyAsString) => {
+      const key = keyAsString /*as keyof TAbi*/;
+      if (mappingFixedAbi[key] !== undefined && fieldFixedAbi[key] !== undefined) {
+        throw Error(`conflicting fixed ABI property for key ${key} between c-type mapping and c-field`);
+      }
+    });
+
+    return {
+      ...mapping,
+      fixedAbi
+    };
+  };
+
+  return {
+    normalize
+  };
+};
+
+export {
+  createCTypeNormalizer
+};

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

@@ -0,0 +1,93 @@
+import type { TAbi } from "../common.js";
+type TCFieldType = "char" | "unsigned char" | "short" | "unsigned short" | "int" | "unsigned int" | "long" | "unsigned long" | "long long" | "unsigned long long" | "float" | "double" | "long double";
+type TFieldType = {
+    readonly type: "integer";
+    readonly sizeInBits: number;
+    readonly signed: boolean;
+    readonly fixedAbi: Partial<TAbi>;
+} | {
+    readonly type: "float";
+    readonly sizeInBits: number;
+    readonly fixedAbi: Partial<TAbi>;
+} | {
+    readonly type: "pointer";
+    readonly fixedAbi: Partial<TAbi>;
+} | {
+    readonly type: "array";
+    readonly elementType: TFieldType;
+    readonly length: number;
+} | {
+    readonly type: "struct";
+    readonly fields: readonly {
+        readonly name: string;
+        readonly definition: TFieldType;
+    }[];
+    readonly packed: boolean;
+    readonly fixedAbi: Partial<TAbi>;
+} | {
+    readonly type: "string";
+    readonly charSizeInBits: number;
+    readonly nullTerminatorMandatory: boolean;
+    readonly length: number;
+} | {
+    readonly type: "c-type";
+    readonly cType: TCFieldType;
+    readonly fixedAbi: Partial<TAbi>;
+};
+type TBasicFieldType = Exclude<TFieldType, {
+    type: "c-type";
+}>;
+type TPrimitiveBasicFieldType = Exclude<TBasicFieldType, {
+    type: "array";
+} | {
+    type: "struct";
+} | {
+    type: "string";
+}>;
+export type { TBasicFieldType, TFieldType, TCFieldType, TPrimitiveBasicFieldType };
+declare const types: {
+    readonly Int16: {
+        readonly type: "integer";
+        readonly sizeInBits: number;
+        readonly signed: boolean;
+        readonly fixedAbi: Partial<TAbi>;
+    };
+    readonly UInt16: {
+        readonly type: "integer";
+        readonly sizeInBits: number;
+        readonly signed: boolean;
+        readonly fixedAbi: Partial<TAbi>;
+    };
+    readonly Int32: {
+        readonly type: "integer";
+        readonly sizeInBits: number;
+        readonly signed: boolean;
+        readonly fixedAbi: Partial<TAbi>;
+    };
+    readonly Int64: {
+        readonly type: "integer";
+        readonly sizeInBits: number;
+        readonly signed: boolean;
+        readonly fixedAbi: Partial<TAbi>;
+    };
+    readonly UInt32: {
+        readonly type: "integer";
+        readonly sizeInBits: number;
+        readonly signed: boolean;
+        readonly fixedAbi: Partial<TAbi>;
+    };
+    readonly UInt64: {
+        readonly type: "integer";
+        readonly sizeInBits: number;
+        readonly signed: boolean;
+        readonly fixedAbi: Partial<TAbi>;
+    };
+    readonly ascii: ({ length }: {
+        length: number;
+    }) => TFieldType;
+    readonly pointer: {
+        readonly type: "pointer";
+        readonly fixedAbi: Partial<TAbi>;
+    };
+};
+export { types };

package/dist/lib/types/index.js

@@ -0,0 +1,122 @@
+/*import type { TAbi } from "../common.ts";*/
+
+/*type TCFieldType =
+  "char" | "unsigned char" |
+  "short" | "unsigned short" |
+  "int" | "unsigned int" |
+  "long" | "unsigned long" |
+  "long long" | "unsigned long long" |
+  "float" | "double" | "long double";*/
+
+/*type TFieldType = {
+  readonly type: "integer";
+  readonly sizeInBits: number;
+  readonly signed: boolean;
+  readonly fixedAbi: Partial<TAbi>;
+} | {
+  readonly type: "float";
+  readonly sizeInBits: number;
+  readonly fixedAbi: Partial<TAbi>;
+} | {
+  readonly type: "pointer";
+  readonly fixedAbi: Partial<TAbi>;
+} | {
+  readonly type: "array";
+  readonly elementType: TFieldType;
+  readonly length: number;
+} | {
+  readonly type: "struct";
+  readonly fields: readonly { readonly name: string; readonly definition: TFieldType }[];
+  readonly packed: boolean;
+  readonly fixedAbi: Partial<TAbi>;
+} | {
+  readonly type: "string";
+  readonly charSizeInBits: number;
+  readonly nullTerminatorMandatory: boolean;
+  readonly length: number;
+} | {
+  readonly type: "c-type";
+  readonly cType: TCFieldType;
+  readonly fixedAbi: Partial<TAbi>;
+};*/
+
+/*type TBasicFieldType = Exclude<TFieldType, { type: "c-type" }>;*/
+/*type TPrimitiveBasicFieldType = Exclude<TBasicFieldType, { type: "array" } | { type: "struct" } | { type: "string" }>;*/
+
+const Int16/*: TFieldType*/ = {
+  type: "integer",
+  sizeInBits: 16,
+  signed: true,
+  fixedAbi: {}
+} /*as const*/;
+
+const UInt16/*: TFieldType*/ = {
+  type: "integer",
+  sizeInBits: 16,
+  signed: false,
+  fixedAbi: {}
+} /*as const*/;
+
+const Int32/*: TFieldType*/ = {
+  type: "integer",
+  sizeInBits: 32,
+  signed: true,
+  fixedAbi: {}
+} /*as const*/;
+
+const Int64/*: TFieldType*/ = {
+  type: "integer",
+  sizeInBits: 64,
+  signed: true,
+  fixedAbi: {}
+} /*as const*/;
+
+const UInt32/*: TFieldType*/ = {
+  type: "integer",
+  sizeInBits: 32,
+  signed: false,
+  fixedAbi: {}
+} /*as const*/;
+
+const UInt64/*: TFieldType*/ = {
+  type: "integer",
+  sizeInBits: 64,
+  signed: false,
+  fixedAbi: {}
+} /*as const*/;
+
+const ascii = ({ length }/*: { length: number }*/)/*: TFieldType*/ => {
+  return {
+    type: "string",
+    charSizeInBits: 8,
+    nullTerminatorMandatory: true,
+    length
+  } /*as const*/;
+};
+
+const pointer/*: TFieldType*/ = {
+  type: "pointer",
+  fixedAbi: {}
+} /*as const*/;
+
+/*export type {
+  TBasicFieldType,
+  TFieldType,
+  TCFieldType,
+  TPrimitiveBasicFieldType
+};*/
+
+const types = {
+  Int16,
+  UInt16,
+  Int32,
+  Int64,
+  UInt32,
+  UInt64,
+  ascii,
+  pointer
+} /*as const*/;
+
+export {
+  types
+};

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

@@ -0,0 +1,9 @@
+import type { TEndianness } from "../common.js";
+import type { TValueParser } from "./value.js";
+type TIntegerParser = TValueParser<bigint>;
+declare const createIntegerParser: ({ sizeInBits, signed, endianness }: {
+    sizeInBits: number;
+    signed: boolean;
+    endianness: TEndianness;
+}) => TIntegerParser;
+export { createIntegerParser };