objutils 0.10.14__tar.gz → 0.10.15__tar.gz

{objutils-0.10.14 → objutils-0.10.15}/CMakeLists.txt

@@ -82,7 +82,11 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/objutils/extensions ${PROJECT_SOURCE_DIR}/objutils/aml)
 
-pybind11_add_module(hexfiles_ext ${CMAKE_CURRENT_SOURCE_DIR}/objutils/extensions/wrapper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/objutils/extensions/exceptions.cpp)
+pybind11_add_module(hexfiles_ext
+    ${CMAKE_CURRENT_SOURCE_DIR}/objutils/extensions/wrapper.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/objutils/extensions/exceptions.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/objutils/extensions/elf_parser.cpp
+)
 
 target_compile_options(hexfiles_ext PUBLIC "-DEXTENSION_NAME=hexfiles_ext" PUBLIC $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>)
 

{objutils-0.10.14 → objutils-0.10.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: objutils
-Version: 0.10.14
+Version: 0.10.15
 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.14 → objutils-0.10.15}/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.14"
+__version__ = "0.10.15"
 
 __all__ = [
     "Image",

{objutils-0.10.14 → objutils-0.10.15}/objutils/elf/__init__.py

@@ -1428,7 +1428,7 @@ class ElfParser:
                 )
                 self.session.add(header)
 
-    def _parse_symbol_section(self, section: model.Elf_Section) -> None:
+    def _parse_symbol_section(self, section: typing.Any) -> None:
         """Parse symbol table section and populate database with symbol entries.
 
         Parses all symbol entries from a symbol table section (SHT_SYMTAB or SHT_DYNSYM)
@@ -1436,43 +1436,119 @@ class ElfParser:
         section, or other named entity with associated metadata like address, size,
         binding, type, and visibility.
 
-        Symbol table structure for 32-bit ELF:
-            - st_name: Offset into string table for symbol name
-            - st_value: Symbol value (typically address)
-            - st_size: Size of symbol in bytes
-            - st_info: Symbol binding (4 bits) and type (4 bits)
-            - st_other: Symbol visibility
-            - st_shndx: Section index symbol is defined in (or special value)
+        Symbol table structure for 32-bit ELF (Elf32_Sym, 16 bytes):
+            - st_name:  Offset into string table for symbol name (uint32)
+            - st_value: Symbol value / address (uint32)
+            - st_size:  Size of symbol in bytes (uint32)
+            - st_info:  Binding (upper 4 bits) and type (lower 4 bits) (uint8)
+            - st_other: Symbol visibility (uint8)
+            - st_shndx: Section index symbol is defined in (uint16)
 
-        Symbol table structure for 64-bit ELF:
+        Symbol table structure for 64-bit ELF (Elf64_Sym, 24 bytes):
             - Field order differs: st_name, st_info, st_other, st_shndx, st_value, st_size
 
+        The method first tries to use the C++ extension ``hexfiles_ext.parse_symbol_table``
+        for maximum performance.  If the extension is not available (e.g. not yet built),
+        it falls back to the ``construct``-based pure-Python parser.
+
+        In both cases, section-name resolution (shndx → section_name, sh_flags) is done
+        in Python with a local cache to avoid repeated SQLAlchemy queries for the same
+        section index.
+
         Args:
-            section: Elf_Section database model representing the symbol table section.
-                Must have sh_link pointing to the associated string table section.
+            section: Parsed construct Container for the symbol-table section.
+                Must have ``sh_link`` (string-table section index) and ``image`` (raw bytes).
 
         Side Effects:
             - Bulk inserts model.Elf_Symbol entries into database
             - Commits transaction on success, rolls back on error
-            - Prints error messages if symbol parsing or database operations fail
-
-        Note:
-            - Symbol names are resolved via section.sh_link string table index
-            - st_shndx may be special value (SHN_ABS, SHN_COMMON, SHN_UNDEF) or section index
-            - Symbol section_name field resolved from st_shndx section reference
-            - Parse errors for individual symbols are caught and logged but don't stop processing
-            - Uses bulk_save_objects for efficient database insertion
-
-        Example:
-            Symbol types (st_info.st_type):
-                - STT_NOTYPE (0): Type not specified
-                - STT_OBJECT (1): Data object (variable)
-                - STT_FUNC (2): Function or executable code
-                - STT_SECTION (3): Section symbol
-                - STT_FILE (4): Source file name
         """
         sh_link = section.sh_link
+        symtab_bytes: bytes = section.image or b""
+        strtab_bytes: bytes = self._images.get(sh_link) or b""
+
+        # ── Fast path: C++ extension ──────────────────────────────────────
+        raw_symbols: list[dict] | None = None
+        try:
+            from objutils.hexfiles_ext import parse_symbol_table as _cpp_parse  # type: ignore[import]
+
+            raw_symbols = _cpp_parse(
+                symtab_bytes,
+                strtab_bytes,
+                self.b64,
+                self._endianess == "<",
+            )
+        except Exception:
+            pass  # fall through to pure-Python path
+
+        if raw_symbols is None:
+            # ── Fallback: construct-based parser ─────────────────────────
+            raw_symbols = self._parse_symbol_section_py(symtab_bytes, strtab_bytes, sh_link)
+
+        # ── Section-name resolution (Python, with cache) ──────────────────
+        # Cache: shndx -> (section_name: str, sh_flags: int)
+        section_cache: dict[int, tuple[str, int]] = {}
         symbols = []
+
+        for sym in raw_symbols:
+            shndx: int = sym["st_shndx"]
+            if shndx in defs.SpecialSections:
+                section_name = defs.special_section_name(shndx)
+                access = 0
+            elif shndx in section_cache:
+                section_name, access = section_cache[shndx]
+            else:
+                section_header = self.session.query(model.Elf_Section).filter(model.Elf_Section.index == shndx).first()
+                if section_header:
+                    section_name = section_header.section_name
+                    access = section_header.sh_flags
+                else:
+                    section_name = str(shndx)
+                    access = 0
+                section_cache[shndx] = (section_name, access)
+
+            db_sym = model.Elf_Symbol(
+                st_name=sym["st_name"],
+                st_value=sym["st_value"],
+                st_size=sym["st_size"],
+                st_bind=sym["st_bind"],
+                st_type=sym["st_type"],
+                st_other=sym["st_other"],
+                st_shndx=shndx,
+                symbol_name=sym["symbol_name"],
+                section_name=section_name,
+                access=access,
+            )
+            symbols.append(db_sym)
+
+        try:
+            self.session.bulk_save_objects(symbols)
+            self.session.commit()
+        except SQLAlchemyError as e:
+            self.session.rollback()
+            print(f"{e}")
+
+    def _parse_symbol_section_py(
+        self,
+        symtab_bytes: bytes,
+        strtab_bytes: bytes,
+        sh_link: int,
+    ) -> list[dict]:
+        """Pure-Python fallback for symbol-table parsing (used when the C++ extension
+        is unavailable).
+
+        Uses the ``construct`` library to parse Elf32_Sym / Elf64_Sym entries and
+        resolves symbol names via :meth:`get_string`.
+
+        Args:
+            symtab_bytes: Raw bytes of the symbol-table section.
+            strtab_bytes: Raw bytes of the string-table section (unused here;
+                name resolution goes through :meth:`get_string` instead).
+            sh_link: Index of the string-table section in ``self._images``.
+
+        Returns:
+            List of dicts with keys matching the C++ extension output.
+        """
         if self.b64:
             Symbol = Struct(
                 "st_name" / self.Word,
@@ -1501,43 +1577,27 @@ class ElfParser:
                 "symbol_name" / Computed(lambda ctx: self.get_string(sh_link, ctx.st_name)),
                 "st_shndx" / self.Half,
             )
-        symbol_cache = {}
-        # num_symbols = len(section.image) // Symbol.sizeof()
-        for offset in range(0, len(section.image), Symbol.sizeof()):
+        entry_size = Symbol.sizeof()
+        result: list[dict] = []
+        for offset in range(0, len(symtab_bytes), entry_size):
             try:
-                sym = Symbol.parse(section.image[offset : offset + Symbol.sizeof()])
+                sym = Symbol.parse(symtab_bytes[offset : offset + entry_size])
             except StreamError as e:
-                print(f"parse symbol section: {e}")
+                print(f"parse symbol section (fallback): {e}")
                 continue
-            section_header = None
-            if sym.st_shndx in defs.SpecialSections:
-                section_name = defs.special_section_name(sym.st_shndx)
-            else:
-                if sym.st_shndx not in symbol_cache:
-                    section_header = self.session.query(model.Elf_Section).filter(model.Elf_Section.index == sym.st_shndx).first()
-                    if section_header:
-                        section_name = section_header.section_name
-                    else:
-                        section_name = str(sym.st_shndx)
-            db_sym = model.Elf_Symbol(
-                st_name=sym.st_name,
-                st_value=sym.st_value,
-                st_size=sym.st_size,
-                st_bind=sym.st_info.st_bind,
-                st_type=sym.st_info.st_type,
-                st_other=sym.st_other,
-                st_shndx=sym.st_shndx,
-                symbol_name=sym.symbol_name,
-                section_name=section_name,
-                access=section_header.sh_flags if section_header else 0,
+            result.append(
+                {
+                    "st_name": sym.st_name,
+                    "st_value": sym.st_value,
+                    "st_size": sym.st_size,
+                    "st_bind": sym.st_info.st_bind,
+                    "st_type": sym.st_info.st_type,
+                    "st_other": sym.st_other,
+                    "st_shndx": sym.st_shndx,
+                    "symbol_name": sym.symbol_name,
+                }
             )
-            symbols.append(db_sym)
-        try:
-            self.session.bulk_save_objects(symbols)
-            self.session.commit()
-        except SQLAlchemyError as e:
-            self.session.rollback()
-            print(f"{e}")
+        return result
 
     def _parse_comment(self, data: bytes) -> str:
         """Parse .comment section containing compiler/linker identification strings.

objutils-0.10.15/objutils/extensions/elf_parser.cpp

@@ -0,0 +1,257 @@
+/**
+ * @file elf_parser.cpp
+ * @brief Fast C++ ELF symbol-table parser.
+ *
+ * Design notes
+ * ------------
+ * The Python/construct-based implementation in ElfParser._parse_symbol_section
+ * is slow because it:
+ *   1.  Invokes the construct DSL parser once per symbol entry.
+ *   2.  Calls CString.parse() (another construct round-trip) for every name.
+ *   3.  Had a caching bug so the SQLAlchemy section lookup was never cached.
+ *
+ * This C++ implementation avoids all of that:
+ *   - Direct pointer arithmetic over the raw symbol-table bytes.
+ *   - strnlen / pointer scan for null-terminated strings.
+ *   - Single allocation: one std::vector<SymbolEntry> for the whole table.
+ *   - Byte swapping only when target endianness != host endianness.
+ *
+ * ELF symbol layout (System V ABI)
+ * ---------------------------------
+ * Elf32_Sym  (16 bytes, offsets):
+ *    0  st_name   uint32
+ *    4  st_value  uint32
+ *    8  st_size   uint32
+ *   12  st_info   uint8    (bind << 4 | type)
+ *   13  st_other  uint8
+ *   14  st_shndx  uint16
+ *
+ * Elf64_Sym  (24 bytes, offsets):
+ *    0  st_name   uint32
+ *    4  st_info   uint8
+ *    5  st_other  uint8
+ *    6  st_shndx  uint16
+ *    8  st_value  uint64
+ *   16  st_size   uint64
+ */
+
+#include "elf_parser.hpp"
+
+#include <bit>        // std::endian  (C++20)
+#include <cstdint>
+#include <cstring>    // std::memcpy, strnlen
+#include <string>
+#include <vector>
+
+// ── Platform byte-swap helpers ────────────────────────────────────────────────
+
+namespace {
+
+inline uint16_t bswap16(uint16_t v) noexcept {
+#if defined(_MSC_VER)
+    return _byteswap_ushort(v);
+#else
+    return __builtin_bswap16(v);
+#endif
+}
+
+inline uint32_t bswap32(uint32_t v) noexcept {
+#if defined(_MSC_VER)
+    return _byteswap_ulong(v);
+#else
+    return __builtin_bswap32(v);
+#endif
+}
+
+inline uint64_t bswap64(uint64_t v) noexcept {
+#if defined(_MSC_VER)
+    return _byteswap_uint64(v);
+#else
+    return __builtin_bswap64(v);
+#endif
+}
+
+// Is the current host little-endian?  Evaluated at compile time on C++20.
+constexpr bool HOST_LE = (std::endian::native == std::endian::little);
+
+// Read an integer of type T from raw bytes and convert from file endianness
+// to host endianness.  Single-byte types are returned unchanged.
+template <typename T>
+[[nodiscard]] T read_val(const uint8_t* p, bool file_le) noexcept {
+    T v{};
+    std::memcpy(&v, p, sizeof(T));
+    if constexpr (sizeof(T) == 1) {
+        return v;
+    }
+    if (file_le != HOST_LE) {   // need a swap
+        if constexpr (sizeof(T) == 2) v = static_cast<T>(bswap16(static_cast<uint16_t>(v)));
+        else if constexpr (sizeof(T) == 4) v = static_cast<T>(bswap32(static_cast<uint32_t>(v)));
+        else if constexpr (sizeof(T) == 8) v = static_cast<T>(bswap64(static_cast<uint64_t>(v)));
+    }
+    return v;
+}
+
+// ── String-table helper ───────────────────────────────────────────────────────
+
+// Retrieve a null-terminated ASCII string from an ELF string table.
+// Returns an empty string when the offset is out of range.
+[[nodiscard]] std::string strtab_get(
+    const uint8_t* strtab,
+    std::size_t    strtab_size,
+    uint32_t       offset) noexcept
+{
+    if (static_cast<std::size_t>(offset) >= strtab_size) {
+        return {};
+    }
+    const char* s   = reinterpret_cast<const char*>(strtab + offset);
+    std::size_t max = strtab_size - static_cast<std::size_t>(offset);
+    std::size_t len = strnlen(s, max);
+    return {s, len};
+}
+
+// ── Per-symbol intermediate representation ───────────────────────────────────
+
+struct SymEntry {
+    uint64_t    st_value;
+    uint64_t    st_size;
+    uint32_t    st_name;
+    uint16_t    st_shndx;
+    uint8_t     st_bind;    // st_info >> 4
+    uint8_t     st_type;    // st_info & 0x0F
+    uint8_t     st_other;
+    std::string symbol_name;
+};
+
+// ── ELF32 parser ─────────────────────────────────────────────────────────────
+
+//  Elf32_Sym layout (16 bytes):
+//   [0] st_name  : u32
+//   [4] st_value : u32
+//   [8] st_size  : u32
+//  [12] st_info  : u8
+//  [13] st_other : u8
+//  [14] st_shndx : u16
+
+static constexpr std::size_t SYM32_SIZE = 16;
+
+std::vector<SymEntry> parse_sym32(
+    const uint8_t* sym_ptr, std::size_t sym_size,
+    const uint8_t* str_ptr, std::size_t str_size,
+    bool le)
+{
+    const std::size_t count = sym_size / SYM32_SIZE;
+    std::vector<SymEntry> result;
+    result.reserve(count);
+
+    for (std::size_t i = 0; i < count; ++i) {
+        const uint8_t* p = sym_ptr + i * SYM32_SIZE;
+
+        SymEntry e{};
+        e.st_name   = read_val<uint32_t>(p +  0, le);
+        e.st_value  = read_val<uint32_t>(p +  4, le);
+        e.st_size   = read_val<uint32_t>(p +  8, le);
+        const uint8_t info = p[12];
+        e.st_bind   = static_cast<uint8_t>(info >> 4u);
+        e.st_type   = static_cast<uint8_t>(info & 0x0Fu);
+        e.st_other  = p[13];
+        e.st_shndx  = read_val<uint16_t>(p + 14, le);
+        e.symbol_name = strtab_get(str_ptr, str_size, e.st_name);
+        result.push_back(std::move(e));
+    }
+    return result;
+}
+
+// ── ELF64 parser ─────────────────────────────────────────────────────────────
+
+//  Elf64_Sym layout (24 bytes):
+//   [0] st_name  : u32
+//   [4] st_info  : u8
+//   [5] st_other : u8
+//   [6] st_shndx : u16
+//   [8] st_value : u64
+//  [16] st_size  : u64
+
+static constexpr std::size_t SYM64_SIZE = 24;
+
+std::vector<SymEntry> parse_sym64(
+    const uint8_t* sym_ptr, std::size_t sym_size,
+    const uint8_t* str_ptr, std::size_t str_size,
+    bool le)
+{
+    const std::size_t count = sym_size / SYM64_SIZE;
+    std::vector<SymEntry> result;
+    result.reserve(count);
+
+    for (std::size_t i = 0; i < count; ++i) {
+        const uint8_t* p = sym_ptr + i * SYM64_SIZE;
+
+        SymEntry e{};
+        e.st_name   = read_val<uint32_t>(p +  0, le);
+        const uint8_t info = p[4];
+        e.st_bind   = static_cast<uint8_t>(info >> 4u);
+        e.st_type   = static_cast<uint8_t>(info & 0x0Fu);
+        e.st_other  = p[5];
+        e.st_shndx  = read_val<uint16_t>(p +  6, le);
+        e.st_value  = read_val<uint64_t>(p +  8, le);
+        e.st_size   = read_val<uint64_t>(p + 16, le);
+        e.symbol_name = strtab_get(str_ptr, str_size, e.st_name);
+        result.push_back(std::move(e));
+    }
+    return result;
+}
+
+} // anonymous namespace
+
+// ── Public API (pybind11) ─────────────────────────────────────────────────────
+
+py::list parse_symbol_table(
+    py::bytes symtab_data,
+    py::bytes strtab_data,
+    bool      is_64bit,
+    bool      little_endian)
+{
+    // Obtain raw pointers without copying – PyBytes_AsStringAndSize is O(1).
+    const char* sym_raw  = nullptr;
+    Py_ssize_t  sym_raw_size = 0;
+    if (PyBytes_AsStringAndSize(symtab_data.ptr(),
+                                const_cast<char**>(&sym_raw), &sym_raw_size) < 0) {
+        throw py::error_already_set();
+    }
+
+    const char* str_raw  = nullptr;
+    Py_ssize_t  str_raw_size = 0;
+    if (PyBytes_AsStringAndSize(strtab_data.ptr(),
+                                const_cast<char**>(&str_raw), &str_raw_size) < 0) {
+        throw py::error_already_set();
+    }
+
+    const auto*  sym_ptr  = reinterpret_cast<const uint8_t*>(sym_raw);
+    const auto*  str_ptr  = reinterpret_cast<const uint8_t*>(str_raw);
+    const std::size_t sym_size = static_cast<std::size_t>(sym_raw_size);
+    const std::size_t str_size = static_cast<std::size_t>(str_raw_size);
+
+    // Parse all symbol entries in C++.
+    std::vector<SymEntry> entries = is_64bit
+        ? parse_sym64(sym_ptr, sym_size, str_ptr, str_size, little_endian)
+        : parse_sym32(sym_ptr, sym_size, str_ptr, str_size, little_endian);
+
+    // Build Python list of dicts.  The bulk of the per-symbol overhead is now
+    // in Python-object construction, which is unavoidable, but still much
+    // cheaper than running the construct DSL for each entry.
+    py::list result;
+    result.attr("__class__");  // force Python to realise the list (no-op, for clarity)
+
+    for (const SymEntry& e : entries) {
+        py::dict d;
+        d["st_name"]     = static_cast<uint32_t>(e.st_name);
+        d["st_value"]    = static_cast<uint64_t>(e.st_value);
+        d["st_size"]     = static_cast<uint64_t>(e.st_size);
+        d["st_bind"]     = static_cast<uint8_t>(e.st_bind);
+        d["st_type"]     = static_cast<uint8_t>(e.st_type);
+        d["st_other"]    = static_cast<uint8_t>(e.st_other);
+        d["st_shndx"]    = static_cast<uint16_t>(e.st_shndx);
+        d["symbol_name"] = e.symbol_name;
+        result.append(std::move(d));
+    }
+    return result;
+}

objutils-0.10.15/objutils/extensions/elf_parser.hpp

@@ -0,0 +1,43 @@
+
+#pragma once
+
+/**
+ * @file elf_parser.hpp
+ * @brief Fast C++ ELF symbol-table parser exposed via pybind11.
+ *
+ * parse_symbol_table() replaces the Python/construct-based loop in
+ * ElfParser._parse_symbol_section().  It reads raw ELF32_Sym / ELF64_Sym
+ * entries directly with pointer arithmetic – no Python object overhead per
+ * entry – and resolves symbol names from the string table in a single pass.
+ *
+ * Supported:
+ *   - 32-bit and 64-bit ELF
+ *   - Little-endian and big-endian ELF files on any host
+ *
+ * Return value:
+ *   Python list of dicts, one entry per symbol, with keys:
+ *     st_name (int), st_value (int), st_size (int),
+ *     st_bind (int), st_type (int), st_other (int),
+ *     st_shndx (int), symbol_name (str)
+ */
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+/**
+ * @brief Parse a raw ELF symbol-table section.
+ *
+ * @param symtab_data  Raw bytes of the symbol-table section (SHT_SYMTAB / SHT_DYNSYM).
+ * @param strtab_data  Raw bytes of the associated string-table section (.strtab / .dynstr).
+ * @param is_64bit     True for ELF64, false for ELF32.
+ * @param little_endian True when the ELF file uses little-endian encoding (EI_DATA == 1).
+ * @return             Python list of dicts – one per symbol.
+ */
+py::list parse_symbol_table(
+    py::bytes symtab_data,
+    py::bytes strtab_data,
+    bool      is_64bit,
+    bool      little_endian
+);

objutils-0.10.15/objutils/extensions/wrapper.cpp

@@ -0,0 +1,58 @@
+
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "difflib.h"
+#include "elf_parser.hpp"
+
+namespace py = pybind11;
+using namespace difflib;
+
+
+PYBIND11_MODULE(hexfiles_ext, m) {
+	// ── difflib.SequenceMatcher ────────────────────────────────────────────
+	py::class_<SequenceMatcher<std::string>>(m, "SequenceMatcher")
+		.def(py::init<const std::string &, const std::string &, SequenceMatcher<std::string>::junk_function_type, bool>(),
+		     py::arg("a"), py::arg("b"),
+		     py::arg("is_junk") = nullptr, py::arg("auto_junk") = true)
+		.def("ratio",      &SequenceMatcher<std::string>::ratio)
+		.def("get_opcodes",&SequenceMatcher<std::string>::get_opcodes)
+	;
+
+	// ── ELF symbol-table parser ────────────────────────────────────────────
+	m.def(
+		"parse_symbol_table",
+		&parse_symbol_table,
+		py::arg("symtab_data"),
+		py::arg("strtab_data"),
+		py::arg("is_64bit"),
+		py::arg("little_endian"),
+		R"doc(
+Parse a raw ELF symbol-table section in C++ and return a list of dicts.
+
+This is a high-performance replacement for the construct-based loop in
+ElfParser._parse_symbol_section().  It handles both ELF32 and ELF64 as
+well as little-endian and big-endian ELF files.
+
+Parameters
+----------
+symtab_data : bytes
+    Raw bytes of the SHT_SYMTAB / SHT_DYNSYM section.
+strtab_data : bytes
+    Raw bytes of the associated string-table section (.strtab / .dynstr).
+is_64bit : bool
+    True for ELF64 (24-byte Elf64_Sym entries), False for ELF32 (16-byte).
+little_endian : bool
+    True when EI_DATA == ELFDATA2LSB (little-endian).
+
+Returns
+-------
+list[dict]
+    One dict per symbol with keys:
+      st_name (int), st_value (int), st_size (int),
+      st_bind (int), st_type (int), st_other (int),
+      st_shndx (int), symbol_name (str).
+)doc"
+	);
+}

{objutils-0.10.14 → objutils-0.10.15}/objutils/version.py

@@ -1,3 +1,3 @@
 """objutils version module"""
 
-__version__ = "0.10.14"
+__version__ = "0.10.15"

{objutils-0.10.14 → objutils-0.10.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "objutils"
-version = "0.10.14"
+version = "0.10.15"
 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.14"
+current_version = "0.10.15"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

objutils-0.10.14/objutils/extensions/wrapper.cpp

@@ -1,18 +0,0 @@
-
-#include <pybind11/functional.h>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-
-#include "difflib.h"
-
-namespace py = pybind11;
-using namespace difflib;
-
-
-PYBIND11_MODULE(hexfiles_ext, m) {
-	py::class_<SequenceMatcher<std::string>>(m, "SequenceMatcher")
-		.def(py::init<const std::string &, const std::string &, SequenceMatcher<std::string>::junk_function_type, bool>(), py::arg("a"), py::arg("b"), py::arg("is_junk")=nullptr, py::arg("auto_junk")=true)
-		.def("ratio", &SequenceMatcher<std::string>::ratio)
-		.def("get_opcodes", &SequenceMatcher<std::string>::get_opcodes)
-	;
-}