ya-struct 0.0.10 → 0.0.12

package/lib/types/c-types.ts

@@ -1,222 +0,0 @@
-import { type TCompiler, type TDataModel, type TAbi } from "../common.ts";
-import { type TFieldType, type TCFieldType, type TPrimitiveBasicFieldType } from "./index.ts";
-
-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/lib/types/index.ts

@@ -1,122 +0,0 @@
-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 }) => {
-  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/lib/types/integer.ts

@@ -1,160 +0,0 @@
-import type { TEndianness } from "../common.ts";
-import type { TValueParser } from "./value.ts";
-
-type TIntegerParser = TValueParser<bigint>;
-
-const createIntegerParser = ({
-  sizeInBits,
-  signed,
-  endianness
-}: {
-  sizeInBits: number,
-  signed: boolean,
-  endianness: TEndianness
-}): TIntegerParser => {
-
-  // eslint-disable-next-line max-statements, complexity
-  const parse: TIntegerParser["parse"] = ({ data, offsetInBits }) => {
-    if (data.length < sizeInBits / 8) {
-      throw Error("BUG: not enough data for integer parsing");
-    }
-
-    if (offsetInBits !== 0) {
-      throw Error("unaligned data in integer parser, not supported yet");
-    }
-
-    const view = new DataView(data.buffer, data.byteOffset);
-
-    if (sizeInBits === 8) {
-      if (signed) {
-        return BigInt(view.getInt8(0));
-      } else {
-        return BigInt(view.getUint8(0));
-      }
-    } else if (sizeInBits === 16) {
-      if (signed) {
-        if (endianness === "little") {
-          return BigInt(view.getInt16(0, true));
-        } else {
-          return BigInt(view.getInt16(0, false));
-        }
-      } else {
-        // eslint-disable-next-line no-lonely-if
-        if (endianness === "little") {
-          return BigInt(view.getUint16(0, true));
-        } else {
-          return BigInt(view.getUint16(0, false));
-        }
-      }
-    } else if (sizeInBits === 32) {
-      if (signed) {
-        if (endianness === "little") {
-          return BigInt(view.getInt32(0, true));
-        } else {
-          return BigInt(view.getInt32(0, false));
-        }
-      } else {
-        // eslint-disable-next-line no-lonely-if
-        if (endianness === "little") {
-          return BigInt(view.getUint32(0, true));
-        } else {
-          return BigInt(view.getUint32(0, false));
-        }
-      }
-    } else if (sizeInBits === 64) {
-      if (signed) {
-        if (endianness === "little") {
-          return view.getBigInt64(0, true);
-        } else {
-          return view.getBigInt64(0, false);
-        }
-      } else {
-        // eslint-disable-next-line no-lonely-if
-        if (endianness === "little") {
-          return view.getBigUint64(0, true);
-        } else {
-          return view.getBigUint64(0, false);
-        }
-      }
-    }
-
-    throw Error("not implemented yet");
-  };
-
-  // eslint-disable-next-line max-statements, complexity
-  const format: TIntegerParser["format"] = ({ value, target, offsetInBits }) => {
-    if (offsetInBits !== 0) {
-      throw Error("unaligned data in integer formatter, not supported yet");
-    }
-
-    if (typeof value !== "bigint") {
-      throw Error("invalid value type for integer formatter");
-    }
-
-    const view = new DataView(target.buffer, target.byteOffset);
-
-    if (sizeInBits === 8) {
-      if (signed) {
-        view.setInt8(0, Number(value));
-      } else {
-        view.setUint8(0, Number(value));
-      }
-    } else if (sizeInBits === 16) {
-      if (signed) {
-        if (endianness === "little") {
-          view.setInt16(0, Number(value), true);
-        } else {
-          view.setInt16(0, Number(value), false);
-        }
-      } else {
-        // eslint-disable-next-line no-lonely-if
-        if (endianness === "little") {
-          view.setUint16(0, Number(value), true);
-        } else {
-          view.setUint16(0, Number(value), false);
-        }
-      }
-    } else if (sizeInBits === 32) {
-      if (signed) {
-        if (endianness === "little") {
-          view.setInt32(0, Number(value), true);
-        } else {
-          view.setInt32(0, Number(value), false);
-        }
-      } else {
-        // eslint-disable-next-line no-lonely-if
-        if (endianness === "little") {
-          view.setUint32(0, Number(value), true);
-        } else {
-          view.setUint32(0, Number(value), false);
-        }
-      }
-    } else if (sizeInBits === 64) {
-      if (signed) {
-        if (endianness === "little") {
-          view.setBigInt64(0, value, true);
-        } else {
-          view.setBigInt64(0, value, false);
-        }
-      } else {
-        // eslint-disable-next-line no-lonely-if
-        if (endianness === "little") {
-          view.setBigUint64(0, value, true);
-        } else {
-          view.setBigUint64(0, value, false);
-        }
-      }
-    } else {
-      throw Error("not implemented yet");
-    }
-  };
-
-  return {
-    parse,
-    format
-  };
-};
-
-export {
-  createIntegerParser
-};

package/lib/types/pointer.ts

@@ -1,27 +0,0 @@
-import type { TEndianness } from "../common.ts";
-import { createIntegerParser } from "./integer.ts";
-import type { TValueParser } from "./value.ts";
-
-type TPointerParser = TValueParser<bigint>;
-
-const createPointerParser = ({ sizeInBits, endianness }: { sizeInBits: number, endianness: TEndianness }): TPointerParser => {
-
-  const integerParser = createIntegerParser({ sizeInBits, signed: false, endianness });
-
-  const parse: TPointerParser["parse"] = ({ data, offsetInBits }) => {
-    return integerParser.parse({ data, offsetInBits });
-  };
-
-  const format: TPointerParser["format"] = ({ value, target, offsetInBits }) => {
-    return integerParser.format({ value, target, offsetInBits });
-  };
-
-  return {
-    parse,
-    format
-  };
-};
-
-export {
-  createPointerParser
-};

package/lib/types/string.ts

@@ -1,56 +0,0 @@
-import type { TValueParser } from "./value.ts";
-
-type TStringParser = TValueParser<string>;
-
-const createStringParser = ({ length }: { length: number }): TStringParser => {
-
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-
-  const parse: TStringParser["parse"] = ({ data, offsetInBits }) => {
-    if (offsetInBits !== 0) {
-      throw Error("unaligned data in string parser, not supported yet");
-    }
-
-    if (data.length < length) {
-      throw Error("not enough data for string parsing");
-    }
-
-    const stringData = data.subarray(0, length);
-    const nullTerminatorIndex = stringData.indexOf(0);
-
-    if (nullTerminatorIndex < 0) {
-      return decoder.decode(stringData);
-    }
-
-    return decoder.decode(stringData.subarray(0, nullTerminatorIndex));
-  };
-
-  const format: TStringParser["format"] = ({ value, target, offsetInBits }) => {
-    if (offsetInBits !== 0) {
-      throw Error("unaligned data in string formatter, not supported yet");
-    }
-
-    if (target.length < length) {
-      throw Error("not enough space in target for string formatting");
-    }
-
-    const encoded = encoder.encode(value);
-
-    if (encoded.length + 1 > length) {
-      throw Error("string too long to fit in target");
-    }
-
-    target.set(encoded, 0);
-    target[encoded.length] = 0;
-  };
-
-  return {
-    parse,
-    format
-  };
-};
-
-export {
-  createStringParser
-};