objutils 0.10.17__tar.gz → 0.10.19__tar.gz

objutils-0.10.19/.idea/objutils@1.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module external.system.id="pyproject.toml" type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+      <excludeFolder url="file://$MODULE_DIR$/objutils/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Poetry (objutils) (2)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

{objutils-0.10.17 → objutils-0.10.19}/.pre-commit-config.yaml

@@ -42,7 +42,7 @@ repos:
         args: ["--line-length=132"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.16.1
+    rev: v0.16.6
     hooks:
       - id: ruff
         args: ["--fix", "--exit-non-zero-on-fix"]

{objutils-0.10.17 → objutils-0.10.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: objutils
-Version: 0.10.17
+Version: 0.10.19
 Summary: Objectfile library for Python
 Keywords: hex files,intel hex,s19,srec,srecords,object files,map files,embedded,microcontroller,ECU,shf,rfc4194
 Author-Email: Christoph Schueler <cpu12.gems@googlemail.com>

{objutils-0.10.17 → objutils-0.10.19}/docs/tutorial.rst

@@ -256,6 +256,13 @@ Quick reference for the ASAM array helpers on ``Image`` and ``Section``.
    | ``ALTERNATE_WITH_Y``   | 2-D maps only: each Y-row preceded by its Y-axis  |
    |                        | coordinate value in memory                        |
    +------------------------+---------------------------------------------------+
+   | ``ALTERNATE_CURVES``   | 1-D curves sharing a common axis, stored as       |
+   |                        | Array-of-Structs (AoS).  Shape must be            |
+   |                        | ``(num_curves, num_axis_points)`` in ASAM         |
+   |                        | convention.  Equivalent to C-order ROW_DIR of     |
+   |                        | a 2-D array; returns                              |
+   |                        | ``ndarray(num_axis_points, num_curves)``.         |
+   +------------------------+---------------------------------------------------+
 
    For ``ALTERNATE_WITH_X`` / ``ALTERNATE_WITH_Y``:
 
@@ -324,6 +331,43 @@ Quick reference for the ASAM array helpers on ``Image`` and ``Section``.
    - Assuming MSW swapping affects 8-bit types (it does not).
    - Using ``ALTERNATE_WITH_X`` / ``ALTERNATE_WITH_Y`` with a 1-D array or
      without a 2-D ``shape`` parameter.
+   - Using ``ALTERNATE_CURVES`` with a 1-D array or a non-2-D ``shape``.
+
+.. rubric:: ALTERNATE_CURVES example (3 curves, 5 axis points)
+
+Corresponds to the C Array-of-Structs pattern from the ASAM specification::
+
+    typedef struct { int DT10; int DT20; int DT30; } CURVE_TYPE;
+    const CURVE_TYPE DATA[5] = {
+        {10, 3, 4}, {12, 2, 6}, {17, 9, 8}, {10, 1, 8}, {18, 3, 8},
+    };
+
+.. code-block:: python
+
+   import numpy as np
+   from objutils import Image, Section
+
+   # numpy shape (5 axis_points, 3 curves); ASAM shape (X=3, Y=5)
+   curves = np.array(
+       [[10, 3, 4],
+        [12, 2, 6],
+        [17, 9, 8],
+        [10, 1, 8],
+        [18, 3, 8]],
+       dtype=np.int32,
+   )
+   total = curves.nbytes
+   img = Image([Section(0xC000, bytes(total + 8))])
+   img.write_asam_ndarray(0xC000, curves, "SLONG", "MSB_LAST",
+                          index_mode="ALTERNATE_CURVES")
+
+   result = img.read_asam_ndarray(0xC000, 15, "SLONG",
+                                  shape=(3, 5), byte_order="MSB_LAST",
+                                  index_mode="ALTERNATE_CURVES")
+   # result.shape == (5, 3)  –  each column is one curve
+   curve_dt10 = result[:, 0]   # [10, 12, 17, 10, 18]
+   curve_dt20 = result[:, 1]   # [ 3,  2,  9,  1,  3]
+   curve_dt30 = result[:, 2]   # [ 4,  6,  8,  8,  8]
 
 .. rubric:: Copy/paste example: ULONG array roundtrip
 

{objutils-0.10.17 → objutils-0.10.19}/objutils/__init__.py

@@ -13,7 +13,7 @@ Registers CODECS and implements an interface to them.
 The first parameter is always the codec name.
 """
 
-__version__ = "0.10.17"
+__version__ = "0.10.19"
 
 __all__ = [
     "Image",

{objutils-0.10.17 → objutils-0.10.19}/objutils/elf/__init__.py

@@ -667,9 +667,9 @@ class SymbolAPI(DBAPI):
         Example:
             >>> parser = ElfParser('firmware.elf')
             >>> # Find any 'main' symbol
-            >>> main = parser.symbols.get('main')
+            >>> main = parser.coff_symbols.get('main')
             >>> # Find 'main' in .text section specifically
-            >>> main_text = parser.symbols.get('main', section_name='.text')
+            >>> main_text = parser.coff_symbols.get('main', section_name='.text')
         """
         query = self.query(model.Elf_Symbol)
         if section_name:
@@ -718,18 +718,18 @@ class SymbolAPI(DBAPI):
         Example:
             >>> parser = ElfParser('firmware.elf')
             >>> # Get all global functions
-            >>> funcs = parser.symbols.fetch(
+            >>> funcs = parser.coff_symbols.fetch(
             ...     bindings='g',
             ...     types_str='func'
             ... )
             >>> # Get symbols in .text section by address
-            >>> text_syms = parser.symbols.fetch(
+            >>> text_syms = parser.coff_symbols.fetch(
             ...     sections='.text',
             ...     order_by_value=True,
             ...     group_by_section=False
             ... )
             >>> # Get GCC special symbols
-            >>> special = parser.symbols.fetch(
+            >>> special = parser.coff_symbols.fetch(
             ...     name_pattern=r'^_'
             ... )
         """
@@ -815,7 +815,7 @@ class SymbolAPI(DBAPI):
 
         Example:
             >>> parser = ElfParser('firmware.elf')
-            >>> special_syms = parser.symbols.fetch_gcc_special_symbols()
+            >>> special_syms = parser.coff_symbols.fetch_gcc_special_symbols()
             >>> for sym in special_syms:
             ...     print(f"{sym.symbol_name}: 0x{sym.st_value:08x}")
         """
@@ -878,7 +878,7 @@ class ElfParser:
         >>> parser = ElfParser('firmware.elf')
         >>> print(f"Machine: {parser.e_machine}")
         >>> text = parser.sections.get('.text')
-        >>> main = parser.symbols.get('main')
+        >>> main = parser.coff_symbols.get('main')
         >>> image = parser.create_image()
 
         >>> # No .prgdb file written to disk
@@ -926,7 +926,7 @@ class ElfParser:
         ),
     )
 
-    def __init__(self, filename: str, in_memory: bool = False) -> None:
+    def __init__(self, filename: str | Path, in_memory: bool = False) -> None:
         """Initialize ElfParser with an ELF file.
 
         Creates or opens the associated .prgdb database file and parses the ELF

{objutils-0.10.17 → objutils-0.10.19}/objutils/image.py

@@ -812,6 +812,10 @@ class Image:
                 - ``"ALTERNATE_WITH_Y"`` – 2-D maps only; each Y-row is preceded by
                   its Y-axis coordinate value.  Pass axis values via
                   ``y_axis=<array>`` in *kws*.
+                - ``"ALTERNATE_CURVES"`` – multiple 1-D curves sharing a common axis,
+                  stored as Array-of-Structs (AoS).  Array shape must be
+                  ``(num_axis_points, num_curves)`` in numpy convention.
+                  Memory layout is identical to C-order ``ROW_DIR``.
             **kws: Keyword arguments passed through to the section method.
                 Relevant for ALTERNATE modes:
 
@@ -882,6 +886,9 @@ class Image:
                   by its X-axis coordinate value in memory.
                 - ``"ALTERNATE_WITH_Y"`` – 2-D maps only; each Y-row is preceded by
                   its Y-axis coordinate value in memory.
+                - ``"ALTERNATE_CURVES"`` – multiple 1-D curves sharing a common axis,
+                  stored as Array-of-Structs (AoS); returns
+                  ``ndarray(num_axis_points, num_curves)``.
             **kws: Keyword arguments passed through to the section method.
                 Relevant for ALTERNATE modes:
 

{objutils-0.10.17 → objutils-0.10.19}/objutils/pecoff/__init__.py

@@ -137,6 +137,7 @@ See Also:
 """
 
 import io
+from dataclasses import dataclass
 import os
 import typing
 from pathlib import Path
@@ -147,6 +148,7 @@ from objutils import Image, Section
 from objutils.utils import create_memorymapped_fileview
 
 from . import defs, model
+from ..symbols import VariableType
 
 try:
     from .pdb import pdb_symbols_for_pe  # type: ignore
@@ -220,6 +222,16 @@ CoffSymbol = Struct(
 )
 
 
+@dataclass(slots=True)
+class Symbol:
+    name: str
+    value: int
+    section_number: int
+    type: int
+    storage_class: int
+    location: int
+
+
 class PeParser:
     """Parser for PE/COFF executables and object files.
 
@@ -238,7 +250,7 @@ class PeParser:
         coff_header: COFF header dictionary (machine, sections, characteristics)
         optional_header: Optional header dictionary (image_base, entry_point, alignments)
         sections: List of section dictionaries (name, vaddr, size, characteristics)
-        symbols: List of symbol dictionaries (name, value, section, type)
+        coff_symbols: List of symbol dictionaries (name, value, section, type)
         db: Optional SQLAlchemy database model for querying
 
     Example:
@@ -297,7 +309,8 @@ class PeParser:
         self.coff_header: dict[str, int] | None = None
         self.optional_header: dict[str, int] | None = None
         self.sections: list[dict[str, typing.Any]] = []
-        self.symbols: list[dict[str, typing.Any]] = []
+        self.coff_symbols: list[Symbol] = []
+        self.pdb_symbols: list[VariableType] = []
 
         # DB model
         self.db: model.Model | None = None
@@ -423,6 +436,7 @@ class PeParser:
 
         # Section table
         self.sections = []
+        self.section_start_addresses = []
         for i in range(number_of_sections):
             section_hdr = SectionHeader.parse_stream(f)
             # name may be slash + offset into string table for long names in OBJ; in PE, usually inline
@@ -437,21 +451,26 @@ class PeParser:
                     "characteristics": section_hdr.characteristics,
                 }
             )
+            self.section_start_addresses.append(section_hdr.virtual_address)
 
         # Symbols (COFF symbol table) if present
-        self.symbols = []
+        self.coff_symbols = []
         if self.coff_header["pointer_to_symbol_table"] and self.coff_header["number_of_symbols"]:
             self._parse_coff_symbols()
         # If no COFF symbols, try PDB symbols via dbghelp (best effort)
-        if not self.symbols and pdb_symbols_for_pe:
+        if not self.coff_symbols and pdb_symbols_for_pe:
             try:
-                # pdb_file = str(self._pdb_path) if self._pdb_path else str(self._path)
-                # self.symbols = pdb_symbols_for_pe(pdb_file)  # type: ignore[misc]
-                self.symbols = pdb_symbols_for_pe(self._path, self._pdb_path)  # type: ignore[misc]
+                self.pdb_symbols = pdb_symbols_for_pe(self._path, self._pdb_path)  # type: ignore[misc]
             except (OSError, RuntimeError, ValueError) as e:
                 # Best-effort only; ignore if PDB not available
                 print(f"Failed to retrieve PDB symbols: {e}")
 
+    def symbol_addresses(self, symbol_names: list[str]) -> dict[str | int]:
+        if self.coff_symbols:
+            return {sym.name: sym.location for sym in self.coff_symbols if sym.name in symbol_names}
+        elif self.pdb_symbols:
+            return {sym.name: sym.location for sym in self.pdb_symbols if sym.name in symbol_names}
+
     def _parse_coff_symbols(self) -> None:
         """Parse COFF symbol table and string table.
 
@@ -503,6 +522,7 @@ class PeParser:
 
         f.seek(start_symtab)
         i = 0
+        MAX_SECTIONS = len(self.sections)
         while i < count:
             rec = f.read(symrec_size)
             if len(rec) < symrec_size:
@@ -510,14 +530,31 @@ class PeParser:
             symbol = CoffSymbol.parse(rec)
             name8 = symbol.name_raw
             name = get_name(name8)
-            self.symbols.append(
-                {
-                    "name": name,
-                    "value": symbol.value,
-                    "section_number": symbol.section_number,
-                    "type": symbol.type,
-                    "storage_class": symbol.storage_class,
-                }
+            if symbol.storage_class in (2, 3) and symbol.section_number <= MAX_SECTIONS:
+                try:
+                    address_base = self.section_start_addresses[symbol.section_number - 1] + symbol.value
+                except IndexError:
+                    address_base = None
+            else:
+                address_base = None
+            """
+            class Symbol:
+                name: str
+                value: int
+                section_number: int
+                type: int
+                storage_class: int
+                location: int
+            """
+            self.coff_symbols.append(
+                Symbol(
+                    name=name,
+                    value=symbol.value,
+                    section_number=symbol.section_number,
+                    type=symbol.type,
+                    storage_class=symbol.storage_class,
+                    location=address_base,
+                )
             )
             # Skip aux records
             if symbol.number_of_aux_symbols:

{objutils-0.10.17 → objutils-0.10.19}/objutils/pecoff/defs.py

@@ -79,6 +79,8 @@ See Also:
       https://docs.microsoft.com/windows/win32/debug/pe-format
 """
 
+from enum import IntEnum
+
 # PE file signature (follows DOS header at offset 0x3C)
 PE_SIGNATURE = b"PE\x00\x00"
 
@@ -165,6 +167,31 @@ IMAGE_SYM_CLASS_EXTERNAL = 2  # External (public) symbol
 IMAGE_SYM_CLASS_STATIC = 3  # Static (private) symbol
 
 
+# ============================================================================
+# Symbol Types (IMAGE_SYM_TYPE_*)
+# ============================================================================
+# Microsoft COFF Symbol Base Types.
+
+
+class ImageSym(IntEnum):
+    IMAGE_SYM_TYPE_NULL = 0  # No type information or unknown base type. Microsoft tools use this setting
+    IMAGE_SYM_TYPE_VOID = 1  # No valid type; used with void pointers and functions
+    IMAGE_SYM_TYPE_CHAR = 2  # A character (signed byte)
+    IMAGE_SYM_TYPE_SHORT = 3  # A 2-byte signed integer
+    IMAGE_SYM_TYPE_INT = 4  # A natural integer type (normally 4 bytes in Windows)
+    IMAGE_SYM_TYPE_LONG = 5  # A 4-byte signed integer
+    IMAGE_SYM_TYPE_FLOAT = 6  # A 4-byte floating-point number
+    IMAGE_SYM_TYPE_DOUBLE = 7  # An 8-byte floating-point number
+    IMAGE_SYM_TYPE_STRUCT = 8  # A structure
+    IMAGE_SYM_TYPE_UNION = 9  # A union
+    IMAGE_SYM_TYPE_ENUM = 10  # An enumerated type
+    IMAGE_SYM_TYPE_MOE = 11  # A member of enumeration (a specific value)
+    IMAGE_SYM_TYPE_BYTE = 12  # A byte; unsigned 1-byte integer
+    IMAGE_SYM_TYPE_WORD = 13  # A word; unsigned 2-byte integer
+    IMAGE_SYM_TYPE_UINT = 14  # An unsigned integer of natural size (normally, 4 bytes)
+    IMAGE_SYM_TYPE_DWORD = 15  # An unsigned 4-byte integer
+
+
 def decode_characteristics(characteristics: int) -> list[str]:
     """Decode COFF header characteristics flags into readable strings.
 

{objutils-0.10.17 → objutils-0.10.19}/objutils/pecoff/pdb/__init__.py

@@ -1421,7 +1421,7 @@ def pdb_symbols_for_pe(pe_path: str, symbol_path: str | None = None) -> list[dic
                     continue
                 ti = session.type_info(mod_base, sym.TypeIndex)
                 # print(f"{sym.tag:15}", sym.Name, hex(sym.Address - mod_base), sym.Size, sym.decode_flags(), "==>", ti)
-                result.append(symbols.VariableType(sym.Name, ti, sym.Address - mod_base, sym.Size))
+                result.append(symbols.VariableType(sym.Name.decode("utf8"), ti, sym.Address - mod_base, sym.Size))
             return result
             """
             Name: Symbol name (null-terminated char array)

{objutils-0.10.17 → objutils-0.10.19}/objutils/scripts/oj_coff_import.py

@@ -71,7 +71,8 @@ def main(argv: list[str] | None = None) -> int:
             )
 
         # Symbols
-        for sym in pp.symbols:
+        for sym in pp.coff_symbols:
+            print(sym)
             ses.add(
                 pe_model.Pe_Symbol(
                     name=sym["name"],

{objutils-0.10.17 → objutils-0.10.19}/objutils/scripts/oj_coff_info.py

@@ -54,15 +54,29 @@ def main(argv: list[str] | None = None) -> int:
             f"0x{s['size_of_raw_data']:06X} 0x{s['virtual_size']:06X}"
         )
 
-    if pp.symbols and args.symbols:
-        # pp.symbols = sorted(pp.symbols, key=lambda s: s.name)
-        pp.symbols = sorted(pp.symbols, key=lambda s: s.location)
-
-        print_header("Symbols (COFF or PDB)")
-        print("Name                                               Value              Size")
-        print("-" * 80)
-        for sym in pp.symbols:
-            print(f"{sym.name.decode():<50} 0x{sym.location:016X} {sym.size}")
+    if args.symbols:
+        if pp.pdb_symbols:
+            coff_symbols = sorted(pp.pdb_symbols, key=lambda s: s.location)
+
+            print_header("Symbols (PDB)")
+            print("Name                                               Value              Size")
+            print("-" * 80)
+            for sym in coff_symbols:
+                print(f"{sym.name:<50} 0x{sym.location:016X} {sym.size}")
+        elif pp.coff_symbols:
+
+            def pe_sorter(s: dict):
+                return 0 if s.location is None else s.location
+
+            coff_symbols = sorted(pp.coff_symbols, key=pe_sorter)
+
+            print_header("Symbols (COFF)")
+            print("Name                                               Value")
+            print("-" * 80)
+            for sym in coff_symbols:
+                if sym.storage_class not in (2, 3) or sym.location is None:
+                    continue
+                print(f"{sym.name:<50} 0x{int(sym.location):016X}")
     return 0
 
 

{objutils-0.10.17 → objutils-0.10.19}/objutils/scripts/oj_coff_syms.py

@@ -36,23 +36,29 @@ def main(argv: list[str] | None = None) -> int:
 
     # Fetch via SymbolAPI to ensure DB is created/reused
     # syms = SymbolAPI(pp).fetch(name_pattern=args.pattern)
-    syms = pp.symbols
-
-    # Fallback: if SymbolAPI attr is not present (static type), use direct list
-    # if not syms and pp.symbols:
-    #    syms = [type("_S", (), s) for s in pp.symbols]  # quick adapter for printing
-
-    # syms is a list of model.Pe_Symbol; order by value already in fetch()
-    if args.order_by == "N":
-        syms = sorted(syms, key=lambda s: getattr(s, "name", getattr(s, "symbol_name", "")))
-
-    print("Name")
-    print("Value")
-    print("-" * 79)
-    for sym in syms:
-        name = getattr(sym, "name", getattr(sym, "symbol_name", ""))
-        value = getattr(sym, "value", getattr(sym, "st_value", 0))
-        print(f"{name:40}\n0x{int(value):016X}\n")
+    syms = pp.coff_symbols
+    if syms:
+        if args.order_by == "N":
+            syms = sorted(syms, key=lambda s: getattr(s, "name", getattr(s, "symbol_name", "")))
+
+        print("Name")
+        print("Value")
+        print("-" * 79)
+        for sym in syms:
+            if not sym.storage_class in (2, 3) or sym.location is None:
+                continue
+            name = sym.name
+            value = sym.value
+            address = sym.location
+            print(f"{name:40}\n0x{int(value):016X}  0x{int(address):016X}\n")
+    syms = pp.pdb_symbols
+    if syms:
+        syms = sorted(syms, key=lambda s: getattr(s, "name", ""))
+        for sym in syms:
+            name = sym.name
+            name = name.decode("utf-8") if isinstance(name, bytes) else name
+            location = sym.location
+            print(f"{name:40}\n0x{location:016X}\n")
 
     return 0
 

{objutils-0.10.17 → objutils-0.10.19}/objutils/section.py

@@ -427,7 +427,7 @@ def fortran_array_to_buffer(array: np.ndarray) -> bytearray:
         return result
 
 
-ASAM_INDEX_MODES = {"ROW_DIR", "COLUMN_DIR", "ALTERNATE_WITH_X", "ALTERNATE_WITH_Y"}
+ASAM_INDEX_MODES = {"ROW_DIR", "COLUMN_DIR", "ALTERNATE_WITH_X", "ALTERNATE_WITH_Y", "ALTERNATE_CURVES"}
 
 AlternateArrayResult = namedtuple("AlternateArrayResult", "values axis")
 
@@ -1273,7 +1273,12 @@ class Section:
             index_mode: ``"ROW_DIR"`` (default) – X increments fastest
                 (C-like row-major).  ``"COLUMN_DIR"`` – Y increments
                 fastest; only X and Y are swapped (not true column-major
-                for dims > 2).
+                for dims > 2).  ``"ALTERNATE_WITH_X"`` / ``"ALTERNATE_WITH_Y"``
+                – 2-D maps with interleaved axis values (see
+                :meth:`read_asam_ndarray`).  ``"ALTERNATE_CURVES"`` – multiple
+                1-D curves sharing a common axis, stored as Array-of-Structs;
+                array shape must be ``(num_axis_points, num_curves)`` in numpy
+                convention.
             **kws: Passed through to :meth:`write`.
 
         Raises:
@@ -1314,6 +1319,17 @@ class Section:
             # element size; for different element sizes the permutation is applied per data-dtype
             # stride which may be incorrect – a documented limitation for word-swap byte orders.
             permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
+        elif index_mode == "ALTERNATE_CURVES":
+            # ALTERNATE_CURVES: multiple curves sharing a common axis, stored as
+            # Array-of-Structs (AoS).  Array shape must be (num_axis_points, num_curves)
+            # in numpy convention.  Each row in memory contains all curve values at one
+            # axis breakpoint.  This is identical to C-order (ROW_DIR) for a 2-D array.
+            if typed_array.ndim != 2:
+                raise ValueError(
+                    "ALTERNATE_CURVES requires a 2-D array with shape " "(num_axis_points, num_curves) in numpy convention"
+                )
+            raw_data = typed_array.tobytes()  # C-order = AoS
+            permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
         else:
             raw_data = typed_array.tobytes()
             permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
@@ -1371,9 +1387,11 @@ class Section:
                 - ``"ALTERNATE_WITH_X"`` – 2-D maps only; columns of values alternate
                   with X-axis coordinate values.  Returns
                   :class:`AlternateArrayResult` ``(values, x_axis)``.
-                - ``"ALTERNATE_WITH_Y"`` – 2-D maps only; rows of values alternate
-                  with Y-axis coordinate values.  Returns
-                  :class:`AlternateArrayResult` ``(values, y_axis)``.
+                - ``"ALTERNATE_CURVES"`` – 1-D curves with a shared axis, stored
+                  as Array-of-Structs (AoS).  *shape* must be
+                  ``(num_curves, num_axis_points)`` in ASAM convention.
+                  Returns ``ndarray`` with shape
+                  ``(num_axis_points, num_curves)``; each column is one curve.
             **kws: Optional keyword arguments:
 
                 - ``axis_dtype`` (str): ASAM datatype of axis values for
@@ -1400,6 +1418,20 @@ class Section:
         # Convert ASAM shape (X, Y, Z …) → numpy shape (… Z, Y, X).
         numpy_shape = tuple(reversed(shape)) if shape else None
 
+        # --- ALTERNATE_CURVES --------------------------------------------------
+        if index_mode == "ALTERNATE_CURVES":
+            if numpy_shape is None or len(numpy_shape) != 2:
+                raise ValueError("ALTERNATE_CURVES requires a 2-D shape (num_curves, num_axis_points) " "in ASAM convention")
+            type_name = internal_dtype.split("_")[0]
+            type_size = TYPE_SIZES[type_name]
+            byte_count = length * type_size
+            raw_data = self.read(addr, byte_count, **kws)
+            permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
+            # numpy_shape is (num_axis_points, num_curves) after ASAM reversal –
+            # exactly the shape of the C-order (AoS) buffer.
+            flat = np.frombuffer(permuted, dtype=dt)
+            return flat.reshape(numpy_shape)
+
         # --- ALTERNATE_WITH_X --------------------------------------------------
         if index_mode == "ALTERNATE_WITH_X":
             if numpy_shape is None or len(numpy_shape) != 2: