openc166 0.1.15__py3-none-win32.whl

openc166/__init__.py

@@ -0,0 +1,574 @@
+# SPDX-License-Identifier: MIT
+"""openc166: a Keil A166-compatible assembler for the Infineon C166/C167.
+
+    >>> import openc166
+    >>> result = openc166.assemble('''
+    ... PROG    SECTION CODE AT 0E000H
+    ...         MOV     R4, #0BEEFH
+    ...         RET
+    ... PROG    ENDS
+    ...         END
+    ... ''')
+    >>> result.ok, result.diagnostics
+    (True, [])
+    >>> image = result.image()
+    >>> hex(image.base), image.data.hex()
+    ('0xe000', 'e6f4efbecb00')
+
+assemble_many() and assemble_files() assemble several modules and link
+them, as Keil's A166 and L166 would: EXTERN symbols take their values from
+PUBLIC ones in other modules.
+
+assemble() never raises for mistakes in the source: they are listed in
+Result.diagnostics. Result.image() raises AssemblyError if there are
+errors, so code that only wants the bytes can write
+``openc166.assemble(src).image().data``.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import threading
+import weakref
+from dataclasses import dataclass, field
+from typing import Dict, Iterable, List, Mapping, Optional, Tuple, Union
+
+from . import _native
+
+__all__ = [
+    "assemble",
+    "assemble_file",
+    "assemble_many",
+    "assemble_files",
+    "Result",
+    "Diagnostic",
+    "Chunk",
+    "Image",
+    "Symbol",
+    "Section",
+    "AssemblyError",
+    "__version__",
+]
+
+_lib = _native.lib
+
+__version__: str = _lib.oc166_version().decode("ascii")
+
+PathLike = Union[str, "os.PathLike[str]"]
+SourceText = Union[str, bytes]
+
+
+def _text(b: Optional[bytes]) -> str:
+    return b.decode("utf-8", "replace") if b else ""
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    """An error or warning. str() gives "file:line:column: error A62: message"."""
+
+    severity: str  # "error" or "warning"
+    code: str  # Keil A166 number such as "A62", or "OCn" for openc166's own
+    message: str
+    file: str
+    line: int  # 1-based; 0 if not tied to a line
+    column: int  # 1-based; 0 if unknown
+    text: str = field(repr=False, compare=False, default="")
+
+    @property
+    def is_error(self) -> bool:
+        return self.severity == "error"
+
+    def __str__(self) -> str:
+        return self.text
+
+
+@dataclass(frozen=True)
+class Chunk:
+    """Bytes emitted at consecutive addresses."""
+
+    address: int
+    data: bytes
+
+    @property
+    def end(self) -> int:
+        """Address after the last byte."""
+        return self.address + len(self.data)
+
+
+@dataclass(frozen=True)
+class Image:
+    """One contiguous memory image: data[0] belongs at address 'base'."""
+
+    base: int
+    data: bytes
+
+    @property
+    def end(self) -> int:
+        """Address after the last byte."""
+        return self.base + len(self.data)
+
+    def __bytes__(self) -> bytes:
+        return self.data
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+
+@dataclass(frozen=True)
+class Symbol:
+    """A name defined in the source.
+
+    kind is how it was defined: "label", "equ", "set", "bit", "lit" or
+    "extern". An "extern" has the value of the PUBLIC symbol it names, and
+    its 'text' is the type from the EXTERN line, such as "WORD".
+    type says what value holds:
+      "number"    a number or address
+      "gpr"       a word register: 0..15 for R0..R15
+      "gpr_byte"  a byte register: 0..15 for RL0, RH0, RL1, ...
+      "sfr"       a special function register: its address
+      "bit"       a bit: address of the word that holds it; see 'bit'
+      "cc"        a condition code: its 4-bit encoding
+      ""          a LIT, which has no value; see 'text'
+    value is None for a LIT or if it could not be worked out (an error).
+    """
+
+    name: str
+    kind: str
+    type: str
+    value: Optional[int]
+    label_type: str = ""  # "near", "far", "byte", "word", "dword" or ""
+    bit: Optional[int] = None  # bit number 0..15 of a "bit"
+    text: str = ""  # replacement text of a LIT, type of an EXTERN
+    line: int = 0  # listing line of the definition, counted in its module
+    module: str = ""  # file name of the module that defines it
+    exported: bool = False  # named by PUBLIC or GLOBAL, so other modules can use it
+
+
+@dataclass(frozen=True)
+class Section:
+    """Where a SECTION went.
+
+    type is "CODE", "DATA", "CONST", "HDATA", "HCONST", "XDATA", "XCONST"
+    or "BIT". align is "BIT", "BYTE", "WORD", "DWORD", "PAGE", "SEGMENT",
+    "BITADDRESSABLE" or "PECADDRESSABLE". placement says how the address was chosen: "at"
+    (AT in the source), "given" (the 'sections' argument of assemble()) or
+    "located" (by openc166, in the first free place from the origin on).
+    class_name is the class from the SECTION line ('ROM' gives "ROM"), or "".
+    group is the DGROUP or CGROUP the section belongs to, or "".
+    size counts bytes; a BIT section counts every byte it touches. For a BIT
+    section, bit is the bit (0..7) of address it starts at and bit_size its
+    size in bits; other sections have bit 0 and bit_size 8 * size.
+    """
+
+    name: str
+    type: str
+    align: str
+    address: int
+    size: int
+    placement: str
+    class_name: str = ""
+    group: str = ""
+    bit: int = 0
+    bit_size: int = -1  # -1 gives 8 * size
+
+    def __post_init__(self) -> None:
+        if self.bit_size < 0:
+            object.__setattr__(self, "bit_size", 8 * self.size)
+
+    @property
+    def end(self) -> int:
+        """Address after the last byte."""
+        return self.address + self.size
+
+
+class AssemblyError(Exception):
+    """The source has errors. 'diagnostics' lists them; 'result' is the whole Result."""
+
+    def __init__(self, result: "Result"):
+        self.result = result
+        self.diagnostics: List[Diagnostic] = result.errors
+        lines = [str(d) for d in self.diagnostics[:20]]
+        if len(self.diagnostics) > 20:
+            lines.append("... and {} more".format(len(self.diagnostics) - 20))
+        super().__init__("{} error(s):\n{}".format(len(self.diagnostics), "\n".join(lines)))
+
+
+class Result:
+    """The outcome of assembling a source."""
+
+    def __init__(self, handle: int):
+        self._handle = handle
+        self._lock = threading.Lock()
+        self._finalizer = weakref.finalize(self, _lib.oc166_result_free, handle)
+        self._listing: Optional[str] = None
+
+        self.cpu: str = _lib.oc166_result_cpu(handle).decode("ascii")
+        """CPU the source was assembled for: "c166" or "c167"."""
+
+        self.diagnostics: List[Diagnostic] = []
+        """Errors and warnings in source order."""
+        d = _native.Diagnostic()
+        for i in range(_lib.oc166_result_diagnostic_count(handle)):
+            _lib.oc166_result_diagnostic(handle, i, ctypes.byref(d))
+            self.diagnostics.append(
+                Diagnostic(
+                    "error" if d.is_error else "warning",
+                    _text(d.code),
+                    _text(d.message),
+                    _text(d.file),
+                    d.line,
+                    d.column,
+                    _text(d.text),
+                )
+            )
+
+        self.chunks: List[Chunk] = []
+        """Code and data in source order."""
+        c = _native.Chunk()
+        for i in range(_lib.oc166_result_chunk_count(handle)):
+            _lib.oc166_result_chunk(handle, i, ctypes.byref(c))
+            data = ctypes.string_at(c.data, c.size) if c.size else b""
+            self.chunks.append(Chunk(c.address, data))
+
+        self.modules: List[str] = [
+            _text(_lib.oc166_result_module(handle, i))
+            for i in range(_lib.oc166_result_module_count(handle))
+        ]
+        """File name of each module: one per source."""
+
+        self.all_symbols: List[Symbol] = []
+        """The names defined in every module, sorted by name, then module."""
+        s = _native.Symbol()
+        for i in range(_lib.oc166_result_symbol_count(handle)):
+            _lib.oc166_result_symbol(handle, i, ctypes.byref(s))
+            kind = _text(s.kind)
+            sym_type = _text(s.type)
+            module = _lib.oc166_result_symbol_module(handle, i)
+            self.all_symbols.append(
+                Symbol(
+                    name=_text(s.name),
+                    kind=kind,
+                    type=sym_type,
+                    value=s.value if s.known and kind != "lit" else None,
+                    label_type=_text(s.label_type),
+                    bit=s.bit if sym_type == "bit" else None,
+                    text=_text(s.text),
+                    line=s.line,
+                    module=self.modules[module] if 0 <= module < len(self.modules) else "",
+                    exported=_lib.oc166_result_symbol_exported(handle, i) == 1,
+                )
+            )
+
+        self.symbols: Dict[str, Symbol] = {}
+        """Defined names, spelled as in their definition, sorted by name.
+
+        If several modules define a name, this holds the PUBLIC or GLOBAL
+        one, or else the one in the first of them; all_symbols has them all.
+        """
+        for sym in self.all_symbols:
+            if sym.name not in self.symbols or (sym.exported and not self.symbols[sym.name].exported):
+                self.symbols[sym.name] = sym
+        self._folded = {name.upper(): sym for name, sym in self.symbols.items()}
+
+        self.sections: Dict[str, Section] = {}
+        """Sections in order of first appearance, by name as first spelled."""
+        sec = _native.Section()
+        first_bit = ctypes.c_int()
+        bit_count = ctypes.c_int64()
+        for i in range(_lib.oc166_result_section_count(handle)):
+            _lib.oc166_result_section(handle, i, ctypes.byref(sec))
+            _lib.oc166_result_section_bits(handle, i, ctypes.byref(first_bit), ctypes.byref(bit_count))
+            self.sections[_text(sec.name)] = Section(
+                name=_text(sec.name),
+                type=_text(sec.type),
+                align=_text(sec.align),
+                address=sec.address,
+                size=sec.size,
+                placement=_text(sec.placement),
+                class_name=_text(_lib.oc166_result_section_class(handle, i)),
+                group=_text(_lib.oc166_result_section_group(handle, i)),
+                bit=first_bit.value,
+                bit_size=bit_count.value,
+            )
+
+    @property
+    def errors(self) -> List[Diagnostic]:
+        return [d for d in self.diagnostics if d.is_error]
+
+    @property
+    def warnings(self) -> List[Diagnostic]:
+        return [d for d in self.diagnostics if not d.is_error]
+
+    @property
+    def ok(self) -> bool:
+        """True if there are no errors (warnings are allowed)."""
+        return not any(d.is_error for d in self.diagnostics)
+
+    def symbol(self, name: str) -> Symbol:
+        """Looks a symbol up ignoring case, as the assembler does. Raises KeyError."""
+        return self._folded[name.upper()]
+
+    @property
+    def listing(self) -> str:
+        """The listing: addresses, code bytes, source lines and diagnostics."""
+        if self._listing is None:
+            with self._lock:
+                text = _lib.oc166_result_listing(self._handle)
+            if text is None:
+                raise MemoryError("cannot format the listing")
+            self._listing = _text(text)
+        return self._listing
+
+    def image(self, base: Optional[int] = None, fill: int = 0xFF) -> Image:
+        """Lays all code and data out as one image.
+
+        The image starts at 'base', or at the lowest address used. Gaps are
+        filled with 'fill'. Raises AssemblyError if the source has errors,
+        and ValueError if code lies below 'base' or the image would be
+        larger than 16 MB.
+        """
+        if not self.ok:
+            raise AssemblyError(self)
+        if not 0 <= fill <= 0xFF:
+            raise ValueError("fill must be 0..255")
+        if base is not None and base < 0:
+            raise ValueError("base must not be negative")
+        img = _native.Image()
+        with self._lock:
+            rc = _lib.oc166_result_image(
+                self._handle, base is not None, base or 0, fill, ctypes.byref(img)
+            )
+            if rc != 0:
+                raise ValueError(_text(_lib.oc166_result_last_error(self._handle)))
+            data = ctypes.string_at(img.data, img.size) if img.size else b""
+        return Image(img.base, data)
+
+    def intel_hex(self, record_size: int = 16) -> str:
+        """The code and data as Intel HEX text.
+
+        Data records hold up to 'record_size' bytes (1..255). An extended
+        linear address record (type 04) comes before each 64 KB bank, and
+        lines end with CR LF, as Keil OH166 writes them. Only the bytes used
+        are written: gaps stay empty. Raises AssemblyError if the source has
+        errors, and ValueError for a bad record size.
+        """
+        return self._text_output(_lib.oc166_result_intel_hex, record_size)
+
+    def srec(self, record_size: int = 16, address_size: Optional[int] = None) -> str:
+        """The code and data as Motorola S-records.
+
+        address_size is 2 for S1 records, 3 for S2, 4 for S3, or None for
+        the smallest that holds every address. Data records hold up to
+        'record_size' bytes. Raises AssemblyError if the source has errors,
+        and ValueError if an address does not fit or a size is out of range.
+        """
+        return self._text_output(_lib.oc166_result_srec, record_size, address_size or 0)
+
+    def _text_output(self, func, *args: int) -> str:
+        if not self.ok:
+            raise AssemblyError(self)
+        if any(not -(2**31) <= a < 2**31 for a in args):
+            raise ValueError("size out of range")
+        with self._lock:
+            text = func(self._handle, *args)
+            if text is None:
+                raise ValueError(_text(_lib.oc166_result_last_error(self._handle)))
+        return text.decode("ascii")
+
+    def __repr__(self) -> str:
+        return "<openc166.Result cpu={} errors={} warnings={} chunks={}>".format(
+            self.cpu, len(self.errors), len(self.warnings), len(self.chunks)
+        )
+
+
+def assemble(
+    source: Union[str, bytes],
+    *,
+    file_name: Optional[PathLike] = None,
+    cpu: Optional[str] = None,
+    origin: int = 0,
+    include_dirs: Iterable[PathLike] = (),
+    sections: Optional[Mapping[str, int]] = None,
+    dialect: str = "keil",
+    controls: Iterable[str] = (),
+) -> Result:
+    """Assembles Keil A166 (or TASKING a166) source text.
+
+    source        the text. A str is encoded as UTF-8; pass bytes to keep
+                  another encoding (Keil sources are often Windows-1252).
+    file_name     names the source in diagnostics; $INCLUDE also searches
+                  its directory. The source is not read from it.
+    cpu           "c166" (the default) or "c167". $MOD167 in the source
+                  selects the C167 too.
+    origin        address of code outside any section, and the lowest
+                  address for sections without AT.
+    include_dirs  more directories searched by $INCLUDE.
+    sections      addresses for sections without AT, by name (any case),
+                  like the SECTIONS control of Keil's L166:
+                  {"MYDATA": 0xF600}. The other sections go in order of
+                  appearance to the first free place from the origin on.
+    dialect       "keil" (the default) for Keil A166 sources, or "tasking"
+                  for TASKING a166 sources, which first pass through
+                  openc166's m166 preprocessor (@SET, @IF, ...). TASKING
+                  sources are always for the C167.
+    controls      controls read before the source, as on the assembler's
+                  command line: ["CASE", "STDNAMES(reg.def)"].
+    """
+    source = _source_bytes(source)
+    name = os.fsencode(os.fspath(file_name)) if file_name is not None else None
+    return _run(
+        lambda opts: _lib.oc166_assemble(opts, source, len(source), name),
+        cpu,
+        origin,
+        include_dirs,
+        sections,
+        dialect,
+        controls,
+    )
+
+
+def _source_bytes(source: SourceText) -> bytes:
+    if isinstance(source, str):
+        return source.encode("utf-8")
+    if not isinstance(source, (bytes, bytearray, memoryview)):
+        raise TypeError("source must be str or bytes")
+    return bytes(source)
+
+
+def _run(call, cpu, origin, include_dirs, sections, dialect, controls) -> Result:
+    """Makes the options, calls call(options) and wraps the result."""
+    opts = _lib.oc166_options_new()
+    if not opts:
+        raise MemoryError("cannot allocate options")
+    try:
+        if cpu is not None and _lib.oc166_options_set_cpu(opts, cpu.encode("ascii", "replace")) != 0:
+            raise ValueError("unknown CPU {!r} (use 'c166' or 'c167')".format(cpu))
+        if _lib.oc166_options_set_dialect(opts, str(dialect).encode("ascii", "replace")) != 0:
+            raise ValueError("unknown dialect {!r} (use 'keil' or 'tasking')".format(dialect))
+        if isinstance(controls, (str, bytes)):
+            raise TypeError("controls must be a list of strings, not a single string")
+        for c in controls:
+            if _lib.oc166_options_add_control(opts, str(c).encode("utf-8")) != 0:
+                raise MemoryError("cannot add control")
+        if _lib.oc166_options_set_origin(opts, origin) != 0:
+            raise ValueError("origin must not be negative")
+        for d in include_dirs:
+            _lib.oc166_options_add_include_dir(opts, os.fsencode(os.fspath(d)))
+        for sec_name, address in (sections or {}).items():
+            if not isinstance(address, int) or not 0 <= address <= 0xFFFFFF:
+                raise ValueError(
+                    "bad address {!r} for section {!r} (use 0..0FFFFFFH)".format(address, sec_name)
+                )
+            if _lib.oc166_options_set_section_address(opts, str(sec_name).encode("utf-8"), address) != 0:
+                raise ValueError("bad section name {!r}".format(sec_name))
+        handle = call(opts)
+    finally:
+        _lib.oc166_options_free(opts)
+    if not handle:
+        raise MemoryError("out of memory while assembling")
+    return Result(handle)
+
+
+def assemble_file(
+    path: PathLike,
+    *,
+    cpu: Optional[str] = None,
+    origin: int = 0,
+    include_dirs: Iterable[PathLike] = (),
+    sections: Optional[Mapping[str, int]] = None,
+    dialect: str = "keil",
+    controls: Iterable[str] = (),
+) -> Result:
+    """Reads and assembles a source file. See assemble() for the options."""
+    with open(path, "rb") as f:
+        source = f.read()
+    return assemble(
+        source,
+        file_name=path,
+        cpu=cpu,
+        origin=origin,
+        include_dirs=include_dirs,
+        sections=sections,
+        dialect=dialect,
+        controls=controls,
+    )
+
+
+def assemble_many(
+    sources: Union[Mapping[PathLike, SourceText], Iterable[Tuple[PathLike, SourceText]]],
+    *,
+    cpu: Optional[str] = None,
+    origin: int = 0,
+    include_dirs: Iterable[PathLike] = (),
+    sections: Optional[Mapping[str, int]] = None,
+    dialect: str = "keil",
+    controls: Iterable[str] = (),
+) -> Result:
+    """Assembles several modules and links them into one program.
+
+    sources is a dict or a list of (file name, source text) pairs; each is
+    a module, as one .a66 file is for Keil's A166. As L166 would, the
+    modules are joined: an EXTERN symbol takes the value of the PUBLIC or
+    GLOBAL symbol of that name in another module, and sections with the
+    same name and class are combined. Code outside sections starts at the
+    origin in every module. See assemble() for the other options.
+
+        >>> result = assemble_many({
+        ...     "main.a66": "EXTERN LIMIT:DATA16\\n"
+        ...                 "PROG SECTION CODE AT 0E000H\\n"
+        ...                 "     MOV R4, #LIMIT\\n"
+        ...                 "PROG ENDS\\n"
+        ...                 "     END\\n",
+        ...     "consts.a66": "PUBLIC LIMIT\\nLIMIT EQU 1234H\\n END\\n",
+        ... })
+        >>> result.image().data.hex(), result.symbol("LIMIT").module
+        ('e6f43412', 'consts.a66')
+    """
+    items = list(sources.items()) if isinstance(sources, Mapping) else list(sources)
+    if not items:
+        raise ValueError("no sources")
+    names = [os.fsencode(os.fspath(name)) for name, _ in items]
+    texts = [_source_bytes(text) for _, text in items]
+    count = len(items)
+    c_texts = (ctypes.c_char_p * count)(*texts)
+    c_lengths = (ctypes.c_size_t * count)(*(len(t) for t in texts))
+    c_names = (ctypes.c_char_p * count)(*names)
+    return _run(
+        lambda opts: _lib.oc166_assemble_many(opts, count, c_texts, c_lengths, c_names),
+        cpu,
+        origin,
+        include_dirs,
+        sections,
+        dialect,
+        controls,
+    )
+
+
+def assemble_files(
+    paths: Iterable[PathLike],
+    *,
+    cpu: Optional[str] = None,
+    origin: int = 0,
+    include_dirs: Iterable[PathLike] = (),
+    sections: Optional[Mapping[str, int]] = None,
+    dialect: str = "keil",
+    controls: Iterable[str] = (),
+) -> Result:
+    """Reads source files and assembles them as modules of one program.
+
+    See assemble_many().
+    """
+    items = []
+    for path in paths:
+        with open(path, "rb") as f:
+            items.append((path, f.read()))
+    return assemble_many(
+        items,
+        cpu=cpu,
+        origin=origin,
+        include_dirs=include_dirs,
+        sections=sections,
+        dialect=dialect,
+        controls=controls,
+    )

openc166/_native.py

@@ -0,0 +1,155 @@
+# SPDX-License-Identifier: MIT
+"""Loads the openc166 shared library and declares its C functions.
+
+The C interface is documented in include/openc166/openc166.h. The library
+is looked for next to this file; the OPENC166_LIBRARY environment variable
+names a different file (used to test a build tree).
+"""
+
+import ctypes
+import os
+import sys
+
+# OC166_API_VERSION this module was written for.
+API_VERSION = 1
+
+
+class Diagnostic(ctypes.Structure):
+    _fields_ = [
+        ("is_error", ctypes.c_int),
+        ("code", ctypes.c_char_p),
+        ("message", ctypes.c_char_p),
+        ("file", ctypes.c_char_p),
+        ("line", ctypes.c_int),
+        ("column", ctypes.c_int),
+        ("text", ctypes.c_char_p),
+    ]
+
+
+class Chunk(ctypes.Structure):
+    _fields_ = [
+        ("address", ctypes.c_int64),
+        ("data", ctypes.POINTER(ctypes.c_uint8)),
+        ("size", ctypes.c_size_t),
+    ]
+
+
+class Image(ctypes.Structure):
+    _fields_ = [
+        ("base", ctypes.c_int64),
+        ("data", ctypes.POINTER(ctypes.c_uint8)),
+        ("size", ctypes.c_size_t),
+    ]
+
+
+class Symbol(ctypes.Structure):
+    _fields_ = [
+        ("name", ctypes.c_char_p),
+        ("kind", ctypes.c_char_p),
+        ("type", ctypes.c_char_p),
+        ("label_type", ctypes.c_char_p),
+        ("value", ctypes.c_int64),
+        ("bit", ctypes.c_int),
+        ("known", ctypes.c_int),
+        ("text", ctypes.c_char_p),
+        ("line", ctypes.c_int),
+    ]
+
+
+class Section(ctypes.Structure):
+    _fields_ = [
+        ("name", ctypes.c_char_p),
+        ("type", ctypes.c_char_p),
+        ("align", ctypes.c_char_p),
+        ("address", ctypes.c_int64),
+        ("size", ctypes.c_int64),
+        ("placement", ctypes.c_char_p),
+    ]
+
+
+def _library_paths():
+    override = os.environ.get("OPENC166_LIBRARY")
+    if override:
+        return [override]
+    here = os.path.dirname(os.path.abspath(__file__))
+    if sys.platform in ("win32", "cygwin"):
+        names = ["openc166.dll", "libopenc166.dll", "cygopenc166.dll"]
+    elif sys.platform == "darwin":
+        names = ["libopenc166.dylib"]
+    else:
+        names = ["libopenc166.so"]
+    return [os.path.join(here, name) for name in names]
+
+
+def _load():
+    problems = []
+    for path in _library_paths():
+        if not os.path.exists(path):
+            problems.append(path + ": not found")
+            continue
+        try:
+            return ctypes.CDLL(path)
+        except OSError as e:
+            problems.append("{}: {}".format(path, e))
+    raise ImportError("cannot load the openc166 library:\n  " + "\n  ".join(problems))
+
+
+lib = _load()
+
+
+def _declare(name, restype, *argtypes):
+    f = getattr(lib, name)
+    f.restype = restype
+    f.argtypes = list(argtypes)
+
+
+_p = ctypes.c_void_p
+_size = ctypes.c_size_t
+_int = ctypes.c_int
+_str = ctypes.c_char_p
+
+_declare("oc166_api_version", _int)
+_declare("oc166_version", _str)
+_declare("oc166_options_new", _p)
+_declare("oc166_options_free", None, _p)
+_declare("oc166_options_set_cpu", _int, _p, _str)
+_declare("oc166_options_set_dialect", _int, _p, _str)
+_declare("oc166_options_add_control", _int, _p, _str)
+_declare("oc166_options_set_origin", _int, _p, ctypes.c_int64)
+_declare("oc166_options_add_include_dir", _int, _p, _str)
+_declare("oc166_options_set_section_address", _int, _p, _str, ctypes.c_int64)
+_declare("oc166_assemble", _p, _p, _str, _size, _str)
+_declare("oc166_result_free", None, _p)
+_declare("oc166_result_error_count", _size, _p)
+_declare("oc166_result_warning_count", _size, _p)
+_declare("oc166_result_cpu", _str, _p)
+_declare("oc166_result_diagnostic_count", _size, _p)
+_declare("oc166_result_diagnostic", _int, _p, _size, ctypes.POINTER(Diagnostic))
+_declare("oc166_result_chunk_count", _size, _p)
+_declare("oc166_result_chunk", _int, _p, _size, ctypes.POINTER(Chunk))
+_declare("oc166_result_image", _int, _p, _int, ctypes.c_int64, ctypes.c_uint8, ctypes.POINTER(Image))
+_declare("oc166_result_intel_hex", _str, _p, _int)
+_declare("oc166_result_srec", _str, _p, _int, _int)
+_declare("oc166_result_last_error", _str, _p)
+_declare("oc166_result_listing", _str, _p)
+_declare("oc166_result_symbol_count", _size, _p)
+_declare("oc166_result_symbol", _int, _p, _size, ctypes.POINTER(Symbol))
+_declare("oc166_result_section_count", _size, _p)
+_declare("oc166_result_section", _int, _p, _size, ctypes.POINTER(Section))
+_declare("oc166_assemble_many", _p, _p, _size, ctypes.POINTER(_str), ctypes.POINTER(_size), ctypes.POINTER(_str))
+_declare("oc166_result_module_count", _size, _p)
+_declare("oc166_result_module", _str, _p, _size)
+_declare("oc166_result_symbol_module", _int, _p, _size)
+_declare("oc166_result_symbol_exported", _int, _p, _size)
+_declare("oc166_result_section_class", _str, _p, _size)
+_declare("oc166_result_section_group", _str, _p, _size)
+_declare(
+    "oc166_result_section_bits", _int, _p, _size, ctypes.POINTER(_int), ctypes.POINTER(ctypes.c_int64)
+)
+
+if lib.oc166_api_version() != API_VERSION:
+    raise ImportError(
+        "the openc166 library has interface version {}, this module needs {}".format(
+            lib.oc166_api_version(), API_VERSION
+        )
+    )

openc166-0.1.15.dist-info/METADATA

@@ -0,0 +1,308 @@
+Metadata-Version: 2.4
+Name: openc166
+Version: 0.1.15
+Summary: Keil A166-compatible assembler for the Infineon C166/C167 microcontrollers
+Keywords: c166,c167,st10,assembler,keil,a166,infineon,ecu
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Assembly
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Assemblers
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://github.com/Dante383/openc166
+Project-URL: Issues, https://github.com/Dante383/openc166/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# openc166
+
+An open-source assembler for the Infineon C166 and C167 microcontroller
+family (including ST10 parts), compatible with the Keil A166 assembler.
+
+It turns Keil-style assembly source into a **raw binary image** at a fixed
+address, or into an Intel HEX or Motorola S-record file. That suits small
+programs loaded into RAM or flash and started directly, such as ECU
+payloads, bootstrap loaders, and test code. No linker or object-file
+converter is needed.
+
+openc166 runs on Linux, Windows and macOS. It needs only a C++20 compiler and
+CMake.
+
+## Status
+
+Early development (version 0.x). What works today:
+
+- **The complete C166 and C167 instruction set**, with all addressing modes.
+  Every instruction form is checked byte for byte against Keil A166 V5.38:
+  over 5,000 checks of code bytes, addresses and symbol values, all
+  identical.
+- Keil expression syntax: operators, `HIGH`/`LOW`, `SOF`/`SEG`/`PAG`/`POF`,
+  `BOF`, `DATA3`/`DATA4`/`DATA8`/`DATA16`, character constants, bit
+  addresses such as `PSW.3` or `0FD00H.5`, and extended-SFR checks inside
+  `EXTR` sequences.
+- Sections with an address (`SECTION CODE AT 0E000H`) and without one.
+  openc166 places sections without `AT` as Keil's L166 linker would, or at
+  addresses you give (`--section NAME=ADDR`), so code that leaves placement
+  to the linker can still be assembled straight to a binary. `DGROUP` and
+  `CGROUP` keep sections in one data page or code segment, as in L166.
+  `BIT` sections and `DBIT` hold bit variables, placed bit by bit as L166
+  places them.
+- `PROC`/`ENDP`, `ORG`, `EVEN`, `EQU`/`SET`/`BIT`, `DB`/`DW`/`DD`,
+  `DS`/`DSB`/`DSW`/`DSD`, and `DPPTR`/`DSPTR`/`DBPTR`, including Keil's
+  automatic alignment of word data.
+- Segmented mode (`$SEGMENTED`): `ASSUME`, `DPPn:` prefixes, and Keil's
+  rules for which data page register an address goes through.
+- `DEFR`/`DEFA`/`DEFB`, the register-definition directives that register
+  files use, with Keil's rules for repeated definitions.
+- A built-in `REG167.INC` register file, written from Infineon's manuals, so
+  `$INCLUDE(REG167.INC)` works without Keil installed.
+- Keil's rules for label arithmetic, which decide between short and long
+  instruction forms.
+- Generic `JMP` and `CALL`: like Keil, openc166 picks the shortest
+  instruction that reaches the target and shortens forward jumps over
+  several passes. Label types (`NEAR`, `FAR`, `WORD`, ...) and the `SHORT`
+  and type operators (`FAR x`, `WORD PTR x`, ...) work as in Keil.
+- `$INCLUDE` and `$INCDIR`, with Keil's search order and listing format.
+- Conditional assembly: `$SET`/`$RESET`, `$IF`/`$ELSEIF`/`$ELSE`/`$ENDIF`
+  and the `IF`/`ELSEIF`/`ELSE`/`ENDIF` statements, with Keil's quirks (only
+  bit 0 of a condition counts) and listing format.
+- `LIT` text replacement (`PORT LIT 'R2'`), with Keil's rules for where
+  names are replaced.
+- Keil's standard macros: `MACRO`/`ENDM` with parameters and `LOCAL`
+  labels, `REPT`, `IRP`, `IRPC`, `EXITM`, `NUL`, `&` and `%`, with Keil's
+  rules for splitting arguments. `$GEN`/`$NOGEN` choose whether the listing
+  shows expanded lines.
+- The `$MOD167`, `$CASE`, `$SEGMENTED` and `$TABS` controls, with Keil's
+  rule that these come before the first statement. Listing-only controls
+  are accepted and ignored.
+- Keil error and warning codes (A74, A111, ...), so messages line up with
+  the Keil manual.
+- Raw binary, Intel HEX and Motorola S-record output. The HEX records match
+  Keil OH166's `H167` format.
+- Several source files linked into one program, as L166 does: `EXTERN`,
+  `PUBLIC` and `GLOBAL` symbols, and sections of the same name combined
+  across files. Each file is assembled separately (a "module"), so a name
+  that is not `PUBLIC` stays private to its file.
+- Register banks (`REGBANK`/`REGDEF`), placed in `0FC00H..0FDFFH` as L166
+  places them, and the `NAME`, `SSKDEF`, `PECDEF` and `TYPEDEC` directives.
+- **TASKING sources** (`--dialect tasking`): the common part of TASKING's
+  m166 preprocessor (`@SET`, `@EVAL`, `@IF`/`@ELSE`/`@ENDI`, `@DEFINED`),
+  TASKING's controls and `STDNAMES` register files, and the places where
+  its assembler differs from Keil's. Infineon's MiniMon monitor and flash
+  drivers, which gkflasher's ECU code comes from, rebuild byte for byte
+  from their TASKING sources. See
+  [docs/tasking.md](https://github.com/Dante383/openc166/blob/main/docs/tasking.md).
+- A Python package and a C API, for tools that assemble code themselves.
+
+Not done yet:
+
+- Keil's MPL macro language (`%DEFINE` and the like); put `$NOMPL` at the
+  top of the file to use `%` as text
+- OMF-166 object files and libraries
+- TASKING's m166 macros with parameters (`@DEFINE`), loops and string
+  functions
+
+See [docs/compatibility.md](https://github.com/Dante383/openc166/blob/main/docs/compatibility.md) for exact behaviour and
+the few places where openc166 deliberately differs from Keil.
+
+## Building
+
+```sh
+cmake -S . -B build
+cmake --build build
+ctest --test-dir build
+```
+
+The program is `build/cli/openc166`. On Windows with Visual Studio it is
+under `build\cli\Debug\` or `build\cli\Release\`. The shared library with
+the C API is built in `build/src/`.
+
+## Usage
+
+```sh
+openc166 payload.a66                       # writes payload.bin
+openc166 payload.a66 -o out.bin -l out.lst # choose names, add a listing
+openc166 payload.a66 -o payload.hex        # Intel HEX
+openc166 payload.a66 -o payload.s19        # S-records (S1)
+openc166 main.a66 lib.a66 -o payload.bin   # link two source files
+```
+
+Several source files are linked into one program, the way Keil's L166
+linker joins the object files of A166:
+
+- An `EXTERN` name in one file takes the value of the `PUBLIC` or `GLOBAL`
+  name in another. A name that no file exports is an error.
+- Sections with the same name and class are joined into one: the parts of
+  a `PUBLIC` or `GLOBAL` section follow one another, the parts of a
+  `COMMON` section lie on top of each other.
+- Without `-o`, the output is named after the first file. With `-l`, the
+  listing has one part per file and a symbol table that names the file
+  each symbol comes from.
+- Code outside sections starts at `--origin` in every file, so normally
+  each file puts its code in sections.
+
+`$INCLUDE` looks in each file's own directory.
+[docs/compatibility.md](https://github.com/Dante383/openc166/blob/main/docs/compatibility.md#linking-several-files)
+has the exact rules.
+
+The output format follows the extension of the `-o` file: `.hex`, `.h86`
+and `.ihx` give Intel HEX; `.srec`, `.s19`, `.s28`, `.s37`, `.mot` and
+`.sx` give S-records; anything else gives a raw binary. `--format` chooses
+it explicitly.
+
+A raw binary starts at the lowest address used. For example, code in
+`SECTION CODE AT 0E000H` produces a file whose first byte belongs at
+`0E000H`. Gaps between pieces of code are filled. HEX and S-record files
+carry the address of every record, so they hold only the bytes used.
+
+| Option | Meaning |
+|---|---|
+| `-f, --format FMT` | `bin`, `hex` or `srec` (default: from the output extension) |
+| `--origin ADDR` | address of code outside sections, and the lowest address for sections without `AT` (default 0) |
+| `--section NAME=ADDR` | put section `NAME`, which has no `AT`, at `ADDR` (may be repeated) |
+| `--base ADDR` | binary: address of the first byte of the file |
+| `--fill BYTE` | binary: value of gaps between pieces of code (default `0FFh`) |
+| `--record-size N` | HEX and S-records: data bytes per record (default 16) |
+| `--cpu c166\|c167` | instruction set (`$MOD167` in the source also selects C167) |
+| `-I DIR` | also search `DIR` for `$INCLUDE` files (may be repeated) |
+| `--dialect D` | `keil` (default) or `tasking`, for TASKING a166 sources |
+| `-c, --control TEXT` | controls read before the sources, e.g. `-c "CASE STDNAMES(reg167.def)"` (may be repeated) |
+
+Sections without `AT` go in order of first appearance to the first free,
+suitably aligned place from the origin on, as L166 places them by default.
+`--section` overrides that for chosen sections, like L166's `SECTIONS`
+control. The listing ends with a table of where each section went.
+[examples/sections.a66](https://github.com/Dante383/openc166/blob/main/examples/sections.a66) shows both.
+
+Intel HEX files use extended linear address records (type 04) for addresses
+above 64 KB, like OH166 with its `H167` option. S-records use S1, S2 or S3
+records by extension (`.s19`, `.s28`, `.s37`); otherwise the smallest kind
+that holds every address.
+
+The exit status is 0 on success, 1 on assembly errors (no output is
+written), and 2 for usage or file errors. Messages use the format
+`file:line:column: error A74: ...`.
+
+[examples/payload.a66](https://github.com/Dante383/openc166/blob/main/examples/payload.a66) is a short, commented example.
+[examples/mtos/](https://github.com/Dante383/openc166/tree/main/examples/mtos) holds real ECU payloads for Siemens SIMK43
+ECUs, taken from gkflasher.
+
+## Python
+
+```sh
+pip install openc166     # or "pip install ." in a checkout
+```
+
+Wheels are published for Linux, Windows and macOS on x86 and ARM; other
+systems build from source, which needs CMake and a C++20 compiler. To get
+just the `openc166` command, `pipx install openc166` works too.
+
+```python
+import openc166
+
+result = openc166.assemble("""
+$MOD167
+PROG    SECTION CODE AT 0E000H
+        MOV     R4, #0BEEFH
+        RET
+PROG    ENDS
+        END
+""")
+image = result.image()     # raises openc166.AssemblyError if there are errors
+image.base                 # 0xE000, the address of image.data[0]
+image.data                 # b'\xe6\xf4\xef\xbe\xcb\x00'
+```
+
+- `openc166.assemble(source, *, file_name=None, cpu=None, origin=0, include_dirs=(), sections=None, dialect="keil", controls=())`
+  assembles a `str` or `bytes`. `sections` gives addresses for sections
+  without `AT`, e.g. `{"VARS": 0xF600}`. `dialect="tasking"` reads TASKING
+  source; `controls` is a list of controls read before the source, as with
+  `-c`. `openc166.assemble_file(path, ...)`
+  reads a file; `$INCLUDE` then also searches the file's directory.
+- The result has `ok`, `diagnostics` (each with `severity`, `code`,
+  `message`, `file`, `line`, `column`; `str()` gives the usual one-line
+  message), `errors`, `warnings`, `chunks` (address and bytes of each piece
+  of code), `symbols` (a dict of name to `Symbol`), `symbol(name)` (lookup
+  ignoring case), `sections` (a dict of name to `Section`: `type`, `align`,
+  `address`, `size`, and `placement`, which is `"at"`, `"given"` or
+  `"located"`), `listing` and `cpu`.
+- `openc166.assemble_many({"main.a66": text1, "lib.a66": text2}, ...)`
+  links several sources into one program, like several files on the
+  command line; `openc166.assemble_files([path1, path2], ...)` reads them
+  from files. Each `Symbol` then says which file defines it (`module`) and
+  whether it is `PUBLIC` or `GLOBAL` (`exported`). `result.modules` lists
+  the file names; `result.symbols` holds one symbol per name (the exported
+  one if there is one), `result.all_symbols` all of them. Each `Section`
+  has its `class_name` and `group`.
+- `result.image(base=None, fill=0xFF)` lays all code out as one block, like
+  the command-line tool.
+- `result.intel_hex(record_size=16)` and
+  `result.srec(record_size=16, address_size=None)` return Intel HEX and
+  S-record text (`address_size` 2, 3 or 4 picks S1, S2 or S3 records).
+
+The package needs Python 3.9 or newer. It also installs the `openc166`
+command. It loads the library through `ctypes`, so one wheel works with
+every Python version.
+
+## C API
+
+[include/openc166/openc166.h](https://github.com/Dante383/openc166/blob/main/include/openc166/openc166.h) declares a plain C
+interface, exported by the shared library (`libopenc166.so`,
+`libopenc166.dylib` or `openc166.dll`). Any language that can call C can
+use it: `oc166_assemble` assembles one source, `oc166_assemble_many`
+links several. The header documents every function; the Python package is
+an example of a complete binding.
+
+## Testing
+
+- `ctest --test-dir build` runs the unit tests, the C API test and the
+  Python package tests, and assembles the examples, checking every byte.
+- `tests/acceptance/minimon.py` rebuilds Infineon's MiniMon from its
+  TASKING sources and compares the result with its HEX files. MiniMon is
+  not included; set `MINIMON_DIR` to its directory (the one that holds
+  `MCPROG` and `Driver`) and `ctest` runs it too.
+- `tests/diff/` contains the differential test against Keil A166. Keil is
+  **not** included. If you have your own copy, run:
+
+  ```sh
+  KEIL_A166=/path/to/A166.EXE python3 tests/diff/keil_diff.py tests/diff/cases/*.a66
+  ```
+
+  It compares every line: address, code bytes, warnings and errors, and
+  the final value of every symbol. Add `--image` to also link Keil's output
+  with L166 and OH166 and compare the complete memory image, and `--codes`
+  to list lines where both assemblers report an error but with different
+  codes. Lines marked `; DIVERGES:` are deliberate differences (see
+  [docs/compatibility.md](https://github.com/Dante383/openc166/blob/main/docs/compatibility.md)) and are skipped.
+
+  Given a directory instead of a file, it treats each `.a66` file in it as
+  one module, links Keil's objects with L166, and compares the linked
+  image and the linker's errors with openc166's:
+
+  ```sh
+  KEIL_A166=/path/to/A166.EXE python3 tests/diff/keil_diff.py tests/diff/cases/link/*/
+  ```
+
+  On Linux and macOS, Keil runs under Wine. To generate test lines that
+  cover the whole instruction set, run
+  `tests/diff/gen_sweep.py build/generated/openc166/isa.json c167 > sweep.a66`.
+
+  The test inputs were written independently for this project. Keil's output
+  is used only for the local comparison and is never stored in the
+  repository.
+
+## License
+
+MIT; see [LICENSE](https://github.com/Dante383/openc166/blob/main/LICENSE). The bundled [doctest](https://github.com/Dante383/openc166/tree/main/third_party/doctest)
+test framework is also MIT.
+
+openc166 is not affiliated with Arm/Keil or Infineon. "Keil", "A166",
+"C166", "C167" and "TASKING" are trademarks of their respective owners. The
+names are used only to describe compatibility.

openc166-0.1.15.dist-info/RECORD

@@ -0,0 +1,9 @@
+openc166/__init__.py,sha256=in9eCKDEZSj-yuYzx51NSBGqeZYxlOnBTlrw5KVsy1I,21856
+openc166/_native.py,sha256=O1bnYN2NNHmGaerUSNNHsaukP2ThBZNsEnQNLuARAA8,5247
+openc166/openc166.dll,sha256=7WE_pDbPpLOpSiXbSAydik2Tc4XNSpe77lHYnGbN7Bk,716288
+openc166/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openc166-0.1.15.data/scripts/openc166.exe,sha256=_TQ1DB4folswcmzX5ENhDgZWyRvGahp9UwcLfmRjUsQ,740864
+openc166-0.1.15.dist-info/METADATA,sha256=Nv6tPorlUm59VHpUwPs0jR5YLnf4x0BEDKShmPwWEn4,15056
+openc166-0.1.15.dist-info/WHEEL,sha256=IyQ3IRe-zd6q-qUW9K5lLyXhxJMDLZxhe1OuvrM-g78,98
+openc166-0.1.15.dist-info/licenses/LICENSE,sha256=e2iZ1haqvx1-l9jomaSPVVH23WXENsT65NNPq-yL9Kk,1091
+openc166-0.1.15.dist-info/RECORD,,

openc166-0.1.15.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.1.2
+Root-Is-Purelib: false
+Tag: py3-none-win32
+

openc166-0.1.15.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Piotr Zdolski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.