objutils 0.10.18__tar.gz → 0.10.19__tar.gz

{objutils-0.10.18 → objutils-0.10.19}/.idea/objutils@1.iml

@@ -8,4 +8,4 @@
     <orderEntry type="jdk" jdkName="Poetry (objutils) (2)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
-</module>
+</module>

{objutils-0.10.18 → 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.18 → objutils-0.10.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: objutils
-Version: 0.10.18
+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.18 → 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.18"
+__version__ = "0.10.19"
 
 __all__ = [
     "Image",

{objutils-0.10.18 → 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.18 → 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.18 → 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.18 → 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.18 → 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.18 → 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.18 → 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.18 → objutils-0.10.19}/objutils/section.py

@@ -1326,8 +1326,7 @@ class Section:
             # 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"
+                    "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)
@@ -1422,10 +1421,7 @@ class Section:
         # --- 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"
-                )
+                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

{objutils-0.10.18 → objutils-0.10.19}/objutils/tests/test_asam_alternate_modes.py

@@ -731,21 +731,96 @@ def test_column_dir_still_works():
 # Das Beispiel-Array aus der Spezifikation: 5 Achsbreakpoints × 4 Kurven
 VXP_TYPE_DATA = np.array(
     [
-        [10, 3, 4, 8],   # Breakpoint 0
-        [12, 2, 4, 6],   # Breakpoint 1
-        [17, 9, 5, 8],   # Breakpoint 2
-        [10, 1, 4, 8],   # Breakpoint 3
-        [18, 3, 8, 8],   # Breakpoint 4
+        [10, 3, 4, 8],  # Breakpoint 0
+        [12, 2, 4, 6],  # Breakpoint 1
+        [17, 9, 5, 8],  # Breakpoint 2
+        [10, 1, 4, 8],  # Breakpoint 3
+        [18, 3, 8, 8],  # Breakpoint 4
     ],
     dtype=np.int32,
 )
 
 VXP_FLAT_LE = [
-    10, 0, 0, 0,   3, 0, 0, 0,   4, 0, 0, 0,   8, 0, 0, 0,
-    12, 0, 0, 0,   2, 0, 0, 0,   4, 0, 0, 0,   6, 0, 0, 0,
-    17, 0, 0, 0,   9, 0, 0, 0,   5, 0, 0, 0,   8, 0, 0, 0,
-    10, 0, 0, 0,   1, 0, 0, 0,   4, 0, 0, 0,   8, 0, 0, 0,
-    18, 0, 0, 0,   3, 0, 0, 0,   8, 0, 0, 0,   8, 0, 0, 0,
+    10,
+    0,
+    0,
+    0,
+    3,
+    0,
+    0,
+    0,
+    4,
+    0,
+    0,
+    0,
+    8,
+    0,
+    0,
+    0,
+    12,
+    0,
+    0,
+    0,
+    2,
+    0,
+    0,
+    0,
+    4,
+    0,
+    0,
+    0,
+    6,
+    0,
+    0,
+    0,
+    17,
+    0,
+    0,
+    0,
+    9,
+    0,
+    0,
+    0,
+    5,
+    0,
+    0,
+    0,
+    8,
+    0,
+    0,
+    0,
+    10,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    4,
+    0,
+    0,
+    0,
+    8,
+    0,
+    0,
+    0,
+    18,
+    0,
+    0,
+    0,
+    3,
+    0,
+    0,
+    0,
+    8,
+    0,
+    0,
+    0,
+    8,
+    0,
+    0,
+    0,
 ]  # 5 * 4 * 4 = 80 Bytes (SLONG, LE)
 
 
@@ -758,11 +833,26 @@ def test_alternate_curves_memory_layout_ubyte():
     """
     arr = VXP_TYPE_DATA.astype(np.uint8)
     expected = [
-        10, 3, 4, 8,
-        12, 2, 4, 6,
-        17, 9, 5, 8,
-        10, 1, 4, 8,
-        18, 3, 8, 8,
+        10,
+        3,
+        4,
+        8,
+        12,
+        2,
+        4,
+        6,
+        17,
+        9,
+        5,
+        8,
+        10,
+        1,
+        4,
+        8,
+        18,
+        3,
+        8,
+        8,
     ]
     total_bytes = 5 * 4  # num_axis_points * num_curves
     sec = Section(start_address=0x1000, data=bytearray(total_bytes + 8))
@@ -860,8 +950,7 @@ def test_alternate_curves_layout_equals_row_dir():
     """ALTERNATE_CURVES und ROW_DIR erzeugen identisches Speicher-Layout."""
     arr = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8)
     sec_curves = Section(start_address=0, data=bytearray(16))
-    sec_row    = Section(start_address=0, data=bytearray(16))
+    sec_row = Section(start_address=0, data=bytearray(16))
     sec_curves.write_asam_ndarray(0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
-    sec_row.write_asam_ndarray(   0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ROW_DIR")
+    sec_row.write_asam_ndarray(0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ROW_DIR")
     assert sec_curves.read(0, 6) == sec_row.read(0, 6)
-

{objutils-0.10.18 → objutils-0.10.19}/objutils/version.py

@@ -1,3 +1,3 @@
 """objutils version module"""
 
-__version__ = "0.10.18"
+__version__ = "0.10.19"

{objutils-0.10.18 → objutils-0.10.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "objutils"
-version = "0.10.18"
+version = "0.10.19"
 description = "Objectfile library for Python"
 authors = [
     {name = "Christoph Schueler", email = "cpu12.gems@googlemail.com"}
@@ -126,7 +126,7 @@ skip = ["*_i686", "*-musllinux*"]
 build-frontend = "build"
 
 [tool.bumpver]
-current_version = "0.10.18"
+current_version = "0.10.19"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true