struct2ui 0.1.0__py3-none-any.whl

struct2ui/exporters/__init__.py

@@ -0,0 +1,15 @@
+"""Exporters: turn collected UI values + schema into target file formats.
+
+Public API (stable; safe to import from outside):
+    emit_c   - (sections, registry) -> C source string
+"""
+
+from .c_emitter import emit_c
+from .json_format import dumps as dumps_json
+from .bin_emitter import emit_bin, merge_abi
+from .elf_verifier import verify_sections
+from .c_parser import parse_c_source, build_schema_dict
+
+
+__all__ = ['emit_c', 'dumps_json', 'emit_bin', 'merge_abi', 'verify_sections',
+           'parse_c_source', 'build_schema_dict']

struct2ui/exporters/bin_emitter.py

@@ -0,0 +1,254 @@
+"""JSON/UI values + schema -> raw .bin emitter that mirrors the C memory layout.
+
+The output is a byte-for-byte image of the target's struct memory, so the chip
+SDK can memcpy it straight into the algorithm's config struct.
+
+Layout model (C ABI simulation):
+  - Little-endian.
+  - Natural alignment: each member starts at an offset aligned to its
+    alignof; gaps are zero padding.
+  - A struct's alignof is the max alignof of its members; its size is padded
+    up to a multiple of that alignof (tail padding).
+  - `pack` is an alignment *cap*: effective align = min(natural, pack).
+  - enum -> fixed enum_size bytes (default 4).
+  - char[N] / arrays -> fixed length.
+
+ABI knobs come from a dict (built-in defaults, overridable by a document-level
+`abi` block). Defaults: little-endian, natural alignment, enum_size=4,
+double 8-aligned, no pack.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+from ..schema import (
+    Field, ScalarField, EnumField, StructField, ArrayField, SchemaRegistry,
+)
+
+
+Section = Tuple[str, str, Any]  # (label, type_name, values)
+
+
+# Built-in default ABI: name -> (size, natural_align, struct format char).
+_DEFAULT_TYPES: Dict[str, Tuple[int, int, str]] = {
+    'bool': (1, 1, 'B'), '_bool': (1, 1, 'B'),
+    'char': (1, 1, 'b'),
+    'int8_t': (1, 1, 'b'), 'uint8_t': (1, 1, 'B'),
+    'int16_t': (2, 2, 'h'), 'uint16_t': (2, 2, 'H'),
+    'short': (2, 2, 'h'),
+    'int32_t': (4, 4, 'i'), 'uint32_t': (4, 4, 'I'),
+    'int': (4, 4, 'i'), 'unsigned': (4, 4, 'I'),
+    'long': (4, 4, 'i'),
+    'int64_t': (8, 8, 'q'), 'uint64_t': (8, 8, 'Q'),
+    'float': (4, 4, 'f'), 'double': (8, 8, 'd'),
+}
+
+DEFAULT_ABI: Dict[str, Any] = {
+    'endian': 'little',
+    'pack': None,
+    'enum_size': 4,
+    'enum_signed': True,
+    'types': _DEFAULT_TYPES,
+}
+
+
+def merge_abi(overlay: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    """Merge a document-level abi overlay over the built-in defaults."""
+    abi = dict(DEFAULT_ABI)
+    abi['types'] = dict(_DEFAULT_TYPES)
+    if not overlay:
+        return abi
+    for key, value in overlay.items():
+        if key == 'types' and isinstance(value, dict):
+            for tname, spec in value.items():
+                abi['types'][tname] = _coerce_type_spec(spec)
+        else:
+            abi[key] = value
+    return abi
+
+
+def _coerce_type_spec(spec: Any) -> Tuple[int, int, str]:
+    if isinstance(spec, (list, tuple)):
+        return (int(spec[0]), int(spec[1]), str(spec[2]))
+    size = int(spec['size'])
+    align = int(spec.get('align', size))
+    fmt = str(spec['fmt'])
+    return (size, align, fmt)
+
+
+def emit_bin(sections: Sequence[Section], registry: SchemaRegistry,
+             abi: Optional[Dict[str, Any]] = None) -> bytes:
+    """Render `sections` as a raw little-endian C-ABI byte image."""
+    abi = abi if abi is not None else merge_abi(None)
+    out = bytearray()
+    for label, type_name, values in sections:
+        root = registry.build(type_name)
+        _emit_struct(root, values if isinstance(values, dict) else {}, abi, out)
+    return bytes(out)
+
+
+def _endian_prefix(abi: Dict[str, Any]) -> str:
+    return '>' if abi.get('endian') == 'big' else '<'
+
+
+def _cap(natural: int, abi: Dict[str, Any]) -> int:
+    pack = abi.get('pack')
+    return min(natural, pack) if pack else natural
+
+
+def _alignof(field: Field, abi: Dict[str, Any]) -> int:
+    if isinstance(field, ArrayField):
+        return _alignof(field.element, abi)
+    if isinstance(field, StructField):
+        align = 1
+        for child in field.children:
+            align = max(align, _alignof(child, abi))
+        return _cap(align, abi)
+    if isinstance(field, EnumField):
+        return _cap(int(abi.get('enum_size', 4)), abi)
+    natural = _scalar_size_align(field, abi)[1]
+    return _cap(natural, abi)
+
+
+def _scalar_size_align(field: ScalarField, abi: Dict[str, Any]) -> Tuple[int, int]:
+    m = re.match(r'char\[(\d+)\]', field.c_type or '')
+    if m:
+        return (int(m.group(1)), 1)
+    size, align, _ = _lookup_type(field.c_type, abi)
+    return (size, align)
+
+
+def _lookup_type(c_type: str, abi: Dict[str, Any]) -> Tuple[int, int, str]:
+    spec = abi['types'].get((c_type or '').lower())
+    if spec is None:
+        raise ValueError(f'unknown C type for .bin layout: {c_type!r}')
+    return spec
+
+
+def _pad_to(buf: bytearray, align: int) -> None:
+    rem = len(buf) % align
+    if rem:
+        buf.extend(b'\x00' * (align - rem))
+
+
+def _emit_struct(node: StructField, values: Any, abi: Dict[str, Any],
+                 out: bytearray) -> None:
+    if not isinstance(values, dict):
+        values = {}
+    start = len(out)
+    struct_align = _alignof(node, abi)
+    for child in node.children:
+        _pad_to_within(out, start, _alignof(child, abi))
+        val = values.get(child.name, child.default)
+        _emit_field(child, val, abi, out)
+    # Tail padding so the struct size is a multiple of its alignment.
+    _pad_to_within(out, start, struct_align)
+
+
+def _pad_to_within(out: bytearray, start: int, align: int) -> None:
+    rem = (len(out) - start) % align
+    if rem:
+        out.extend(b'\x00' * (align - rem))
+
+
+def _emit_field(field: Field, value: Any, abi: Dict[str, Any],
+                out: bytearray) -> None:
+    if isinstance(field, ArrayField):
+        _emit_array(field, value, abi, out)
+    elif isinstance(field, StructField):
+        _emit_struct(field, value, abi, out)
+    elif isinstance(field, EnumField):
+        _emit_enum(field, value, abi, out)
+    elif isinstance(field, ScalarField):
+        _emit_scalar(field, value, abi, out)
+    else:
+        raise ValueError(f'cannot serialise field {field!r}')
+
+
+def _emit_array(field: ArrayField, value: Any, abi: Dict[str, Any],
+                out: bytearray) -> None:
+    elem = field.element
+    items = value if isinstance(value, list) else []
+    start = len(out)
+    stride = _sizeof(elem, abi)
+    for i in range(field.count):
+        target = start + i * stride
+        if len(out) < target:
+            out.extend(b'\x00' * (target - len(out)))
+        val = items[i] if i < len(items) else (
+            elem.default if elem is not None else None)
+        _emit_field(elem, val, abi, out)
+        if len(out) < start + (i + 1) * stride:
+            out.extend(b'\x00' * (start + (i + 1) * stride - len(out)))
+
+
+def _emit_enum(field: EnumField, value: Any, abi: Dict[str, Any],
+               out: bytearray) -> None:
+    num = _enum_to_int(field, value)
+    size = int(abi.get('enum_size', 4))
+    signed = bool(abi.get('enum_signed', True))
+    out.extend(num.to_bytes(size, _byteorder(abi), signed=signed))
+
+
+def _emit_scalar(field: ScalarField, value: Any, abi: Dict[str, Any],
+                 out: bytearray) -> None:
+    import struct
+    m = re.match(r'char\[(\d+)\]', field.c_type or '')
+    if m:
+        n = int(m.group(1))
+        raw = (value if isinstance(value, str) else '').encode('utf-8')[:n]
+        out.extend(raw + b'\x00' * (n - len(raw)))
+        return
+    size, _, fmt = _lookup_type(field.c_type, abi)
+    coerced = _coerce_scalar(field.ui_type, value)
+    out.extend(struct.pack(_endian_prefix(abi) + fmt, coerced))
+
+
+def _coerce_scalar(ui_type: str, value: Any) -> Any:
+    if ui_type == 'bool':
+        return 1 if value else 0
+    if ui_type == 'int':
+        return int(value if value is not None else 0)
+    if ui_type == 'float':
+        return float(value if value is not None else 0.0)
+    return int(value if value is not None else 0)
+
+
+def _enum_to_int(field: EnumField, value: Any) -> int:
+    if isinstance(value, str):
+        if value in field.items:
+            return int(field.items[value])
+        return 0
+    if isinstance(value, bool):
+        return int(value)
+    if value is None:
+        return 0
+    return int(value)
+
+
+def _byteorder(abi: Dict[str, Any]) -> str:
+    return 'big' if abi.get('endian') == 'big' else 'little'
+
+
+def _sizeof(field: Field, abi: Dict[str, Any]) -> int:
+    """Aligned size (stride) of a field, including struct/array padding."""
+    if isinstance(field, ArrayField):
+        return field.count * _sizeof(field.element, abi)
+    if isinstance(field, StructField):
+        size = 0
+        for child in field.children:
+            calign = _alignof(child, abi)
+            rem = size % calign
+            if rem:
+                size += calign - rem
+            size += _sizeof(child, abi)
+        salign = _alignof(field, abi)
+        rem = size % salign
+        if rem:
+            size += salign - rem
+        return size
+    if isinstance(field, EnumField):
+        return int(abi.get('enum_size', 4))
+    return _scalar_size_align(field, abi)[0]

struct2ui/exporters/c_emitter.py

@@ -0,0 +1,233 @@
+"""JSON/UI values + schema -> C source emitter.
+
+Pure functions, no Qt. Input is the collected values (plain dicts/lists, as
+produced by the UI read-back) plus the schema Field tree (from
+SchemaRegistry.build). Output is a C source string.
+
+Emit policy (agreed with the project owner):
+  - One struct instance per pipeline section.
+  - Designated initialisers ({ .field = value }) for struct instances, so the
+    output is field-order independent and readable.
+  - Flat struct arrays that the UI renders as a *table* use compact positional
+    initialisers ({ {50, A_MODE_HIGH}, ... }); other struct arrays keep
+    designated initialisers per element.
+  - Enum values are written as their symbol (A_MODE_HIGH), not the integer.
+  - Booleans -> true/false (assumes <stdbool.h>).
+  - Strings (char[N]) -> "quoted".
+  - Only .c is produced (no header).
+"""
+
+from __future__ import annotations
+
+from typing import Any, List, Sequence, Tuple
+
+from ..schema import (
+    Field, ScalarField, EnumField, StructField, ArrayField, SchemaRegistry,
+)
+from ..ui.tables import is_flat_struct_array
+
+
+Section = Tuple[str, str, Any]  # (variable_label, type_name, values)
+
+
+def emit_c(sections: Sequence[Section], registry: SchemaRegistry) -> str:
+    """Render `sections` as a C source string.
+
+    sections: ordered list of (label, type_name, values). `label` becomes the
+              C variable name, `type_name` is resolved against `registry` to a
+              StructField, `values` is the collected per-field dict.
+    """
+    blocks: List[str] = []
+    for label, type_name, values in sections:
+        root = registry.build(type_name)
+        var = _c_identifier(label)
+        init = _emit_struct(root, values, indent=0)
+        blocks.append(f'{type_name} {var} = {init};')
+
+    body = '\n\n'.join(blocks)
+    return _HEADER + body + '\n'
+
+
+_HEADER = (
+    '/* Auto-generated by struct2ui. Do not edit by hand. */\n'
+    '#include <stdbool.h>\n'
+    '#include <stdint.h>\n\n'
+)
+
+
+def _c_identifier(label: str) -> str:
+    out = ''.join(c if c.isalnum() or c == '_' else '_' for c in label)
+    if out and out[0].isdigit():
+        out = '_' + out
+    return out or '_'
+
+
+def _emit_struct(node: StructField, values: Any, indent: int) -> str:
+    """Designated initialiser for a struct: { .a = .., .b = .. }."""
+    if not isinstance(values, dict):
+        values = {}
+    pad = '    ' * (indent + 1)
+    close_pad = '    ' * indent
+    lines: List[str] = []
+    for child in node.children:
+        val = values.get(child.name, child.default)
+        rendered = _emit_field(child, val, indent + 1)
+        lines.append(f'{pad}.{child.name} = {rendered}')
+    if not lines:
+        return '{ 0 }'
+    return '{\n' + ',\n'.join(lines) + f'\n{close_pad}}}'
+
+
+def _emit_field(field: Field, value: Any, indent: int) -> str:
+    if isinstance(field, ArrayField):
+        return _emit_array(field, value, indent)
+    if isinstance(field, StructField):
+        return _emit_struct(field, value, indent)
+    if isinstance(field, EnumField):
+        return _emit_enum(field, value)
+    if isinstance(field, ScalarField):
+        return _emit_scalar(field, value)
+    return _emit_literal(value)
+
+
+def _emit_array(field: ArrayField, value: Any, indent: int) -> str:
+    elem = field.element
+    items = value if isinstance(value, list) else []
+
+    def at(i: int) -> Any:
+        if i < len(items):
+            return items[i]
+        return elem.default if elem is not None else None
+
+    # Flat struct array rendered as a table -> compact positional initialiser,
+    # one element per line so wide tables stay readable.
+    if isinstance(elem, StructField) and _renders_as_table(field):
+        pad = '    ' * (indent + 1)
+        close_pad = '    ' * indent
+        grid: List[List[str]] = []
+        for i in range(field.count):
+            row = at(i) if isinstance(at(i), dict) else {}
+            grid.append([_emit_field(c, row.get(c.name, c.default), indent + 1)
+                         for c in elem.children])
+        widths = _column_widths(grid)
+        rows: List[str] = []
+        for cells in grid:
+            padded = [c.ljust(widths[j]) for j, c in enumerate(cells)]
+            rows.append(pad + '{' + ', '.join(padded).rstrip() + '}')
+        return '{\n' + ',\n'.join(rows) + f'\n{close_pad}}}'
+
+    # Other struct array -> designated initialiser per element.
+    if isinstance(elem, StructField):
+        pad = '    ' * (indent + 1)
+        close_pad = '    ' * indent
+        rows = [pad + _emit_struct(elem, at(i), indent + 1)
+                for i in range(field.count)]
+        return '{\n' + ',\n'.join(rows) + f'\n{close_pad}}}'
+
+    # Scalar/enum array. widget=multiline breaks the values into rows by the
+    # innermost dimension; otherwise long arrays are wrapped at MAX_ROW so a
+    # single line never runs to hundreds of values. Short arrays stay on one
+    # line: { a, b, c }.
+    cells = [_emit_field(elem, at(i), indent) for i in range(field.count)]
+    row_size = _multiline_row_size(field)
+    if row_size > 0:
+        return _wrap_cells_aligned(cells, row_size, indent)
+    if len(cells) > MAX_ROW:
+        return _wrap_cells_aligned(cells, MAX_ROW, indent)
+    return '{ ' + ', '.join(cells) + ' }'
+
+
+# Wrap scalar/enum arrays longer than this many elements, even without an
+# explicit widget=multiline. Keeps generated lines readable.
+MAX_ROW = 64
+
+
+def _wrap_cells_aligned(cells: List[str], row_size: int, indent: int) -> str:
+    """Lay out `cells` row_size-per-line inside braces, padding each column to
+    its max width so values line up vertically."""
+    pad = '    ' * (indent + 1)
+    close_pad = '    ' * indent
+    grid = [cells[i:i + row_size] for i in range(0, len(cells), row_size)]
+    widths = _column_widths(grid)
+    rows = []
+    for row in grid:
+        padded = [c.ljust(widths[j]) for j, c in enumerate(row)]
+        rows.append(pad + ', '.join(padded).rstrip())
+    return '{\n' + ',\n'.join(rows) + f'\n{close_pad}}}'
+
+
+def _column_widths(grid: List[List[str]]) -> List[int]:
+    """Max rendered width of each column across all rows (for table alignment)."""
+    if not grid:
+        return []
+    ncols = max(len(row) for row in grid)
+    widths = [0] * ncols
+    for row in grid:
+        for j, cell in enumerate(row):
+            if len(cell) > widths[j]:
+                widths[j] = len(cell)
+    return widths
+
+
+def _multiline_row_size(field: ArrayField) -> int:
+    """Values-per-row for a widget=multiline scalar array.
+
+    Uses the last (innermost) dimension of meta.shape as the column count so
+    a float[3][4] prints 4 numbers per line. Returns 0 when the field is not
+    multiline (caller keeps single-line output).
+    """
+    if field.meta.get('widget') != 'multiline':
+        return 0
+    shape = field.meta.get('shape')
+    if isinstance(shape, (list, tuple)) and shape:
+        return int(shape[-1])
+    return 0
+
+
+def _renders_as_table(field: ArrayField) -> bool:
+    """Mirror the UI's table-vs-tree decision (ui.renderers).
+
+    meta.render='tree' forces tree; otherwise a flat struct array is a table.
+    Kept in lock-step with TreeRenderer._should_render_as_table so the .c
+    layout matches what the user sees.
+    """
+    if field.meta.get('render') == 'tree':
+        return False
+    return is_flat_struct_array(field)
+
+
+def _emit_enum(field: EnumField, value: Any) -> str:
+    # Symbol passes through; integer is reverse-looked-up to its symbol.
+    if isinstance(value, str) and value in field.items:
+        return value
+    for symbol, num in field.items.items():
+        if num == value:
+            return symbol
+    if isinstance(value, str) and value:
+        return value
+    return str(value if value is not None else 0)
+
+
+def _emit_scalar(field: ScalarField, value: Any) -> str:
+    if field.ui_type == 'bool':
+        return 'true' if value else 'false'
+    if field.ui_type == 'str':
+        return _c_string(value if value is not None else '')
+    return _emit_literal(value if value is not None else 0)
+
+
+def _emit_literal(value: Any) -> str:
+    if isinstance(value, bool):
+        return 'true' if value else 'false'
+    if isinstance(value, str):
+        return _c_string(value)
+    return str(value)
+
+
+def _c_string(text: str) -> str:
+    escaped = (str(text)
+               .replace('\\', '\\\\')
+               .replace('"', '\\"')
+               .replace('\n', '\\n')
+               .replace('\t', '\\t'))
+    return f'"{escaped}"'