statable 3.1.0__py3-none-any.whl

codegen/sample_data.py

@@ -0,0 +1,269 @@
+# codegen/sample_data.py
+"""
+Sample data for code generation tests.
+Provides test data independent of the GUI.
+
+[v1.5 fix]
+  - Transition action= migrated to pre_actions=[] (bug #87)
+    The action field is defined as "compat / unused" in v1.4 sec 2.2,
+    and role_function_generator only references pre_actions,
+    so action= does not reflect calls in code generation.
+"""
+
+import sys
+import os
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from statable.model import State, Event, Transition, StateType, EventKind, RoleFunction
+from statable.state_machine import StateMachine
+from statable.global_defs import (
+    GlobalDefinitions, SystemVariable, EventFlag,
+    CustomTypeDef, StructMemberDef,
+    EventQueueDef, InterruptHandlerDef, InterruptAction,
+    DevicePlaceholderDef, TimerBaseDef, TimerDerivedDef
+)
+
+
+class SampleDataGenerator:
+    """Sample data generator class"""
+
+    def __init__(self):
+        self.state_machine = None
+        self.global_defs = None
+
+    def create_sample_state_machine(self):
+        sm = StateMachine()
+
+        sm.add_state(State(name="INIT", type=StateType.INITIAL, description="Initial state"))
+        sm.add_state(State(name="IDLE", type=StateType.NORMAL, description="Idle state"))
+        sm.add_state(State(name="RUNNING", type=StateType.NORMAL, description="Running state"))
+        sm.add_state(State(name="ERROR", type=StateType.NORMAL, description="Error state"))
+        sm.set_initial("INIT")
+
+        sm.add_event(Event(name="POWER_ON", kind=EventKind.SIGNAL, description="Power-on event"))
+        sm.add_event(Event(name="START", kind=EventKind.SIGNAL, description="Start event"))
+        sm.add_event(Event(name="STOP", kind=EventKind.SIGNAL, description="Stop event"))
+        sm.add_event(Event(name="ERROR_DETECTED", kind=EventKind.SIGNAL, description="Error detected event"))
+
+        # ==============================================================
+        # [v1.5 fix] action= -> pre_actions=[]
+        # ==============================================================
+        sm.add_transition(Transition(
+            source="INIT",
+            event="POWER_ON",
+            target="IDLE",
+            pre_actions=["PowerOn"],
+            title="Power on",
+        ))
+        sm.add_transition(Transition(
+            source="IDLE",
+            event="START",
+            target="RUNNING",
+            condition="StartOk",
+            pre_actions=["Start"],
+            title="Start",
+        ))
+        sm.add_transition(Transition(
+            source="RUNNING",
+            event="STOP",
+            target="IDLE",
+            pre_actions=["Stop"],
+            title="Stop",
+        ))
+        sm.add_transition(Transition(
+            source="RUNNING",
+            event="ERROR_DETECTED",
+            target="ERROR",
+            pre_actions=["HandleError"],
+            title="Error handling",
+        ))
+
+        sm.add_role_function(RoleFunction(
+            name="PowerOn", return_type="void",
+            description="Power-on processing",
+        ))
+        sm.add_role_function(RoleFunction(
+            name="StartOk", return_type="bool",
+            description="Start condition check",
+        ))
+        sm.add_role_function(RoleFunction(
+            name="Start", return_type="void",
+            description="Start processing",
+        ))
+        sm.add_role_function(RoleFunction(
+            name="Stop", return_type="void",
+            description="Stop processing",
+        ))
+        sm.add_role_function(RoleFunction(
+            name="HandleError", return_type="void",
+            description="Error handling",
+        ))
+        sm.add_role_function(RoleFunction(
+            name="ProcessData", return_type="int",
+            arg1_type="uint8_t*", arg1_name="data",
+            arg2_type="uint16_t", arg2_name="len",
+            description="Data processing",
+        ))
+
+        self.state_machine = sm
+        return sm
+
+    def create_sample_global_defs(self):
+        gd = GlobalDefinitions()
+
+        gd.variables = [
+            SystemVariable(name="battery_voltage", type="uint16", unit="mV",
+                           group="Power", description="Battery voltage"),
+            SystemVariable(name="system_tick", type="uint32", unit="ms",
+                           group="Timer", description="System timer"),
+            SystemVariable(name="temperature", type="int16", unit="0.1C",
+                           group="Sensor", description="Temperature sensor value"),
+            SystemVariable(name="data_buffer", type="uint8",
+                           group="Data", description="Data buffer",
+                           array_size=64),
+        ]
+
+        gd.flags = [
+            EventFlag(name="EVT_POWER_ON_REQ", min_value=0, max_value=1,
+                      group="System", description="Power-on request"),
+            EventFlag(name="EVT_START_REQ", min_value=0, max_value=1,
+                      group="System", description="Start request"),
+            EventFlag(name="EVT_STOP_REQ", min_value=0, max_value=1,
+                      group="System", description="Stop request"),
+            EventFlag(name="EVT_ERROR_FLAG", min_value=0, max_value=1,
+                      group="Error", description="Error flag"),
+        ]
+
+        gd.custom_types = [
+            CustomTypeDef(name="SystemStatus", description="System status management struct", members=[
+                StructMemberDef(name="power_on", data_type="bool", bit_width=1,
+                                description="Power-on state"),
+                StructMemberDef(name="initialized", data_type="bool", bit_width=1,
+                                description="Initialization completed flag"),
+                StructMemberDef(name="error_code", data_type="uint8",
+                                description="Error code"),
+                StructMemberDef(name="mode", data_type="uint8",
+                                description="Operation mode"),
+            ]),
+            CustomTypeDef(name="SensorData", description="Sensor data struct", members=[
+                StructMemberDef(name="temperature", data_type="int16",
+                                description="Temperature value"),
+                StructMemberDef(name="humidity", data_type="uint8",
+                                description="Humidity value"),
+                StructMemberDef(name="pressure", data_type="uint16",
+                                description="Pressure value"),
+            ]),
+        ]
+
+        gd.event_queues = [
+            EventQueueDef(
+                name="MainEventQueue",
+                size=16,
+                element_type="EVENT_t",
+                event_ids=["POWER_ON", "START", "STOP", "ERROR_DETECTED"],
+                priority_enabled=False,
+                interrupt_safe=True,
+                rtos_enabled=False,
+                description="Main event queue",
+            ),
+            EventQueueDef(
+                name="HighPriorityQueue",
+                size=8,
+                element_type="EVENT_t",
+                event_ids=["ERROR_DETECTED"],
+                priority_enabled=True,
+                interrupt_safe=True,
+                rtos_enabled=False,
+                description="High-priority event queue",
+            ),
+        ]
+
+        gd.interrupts = [
+            InterruptHandlerDef(
+                name="UART_RX",
+                description="UART receive interrupt",
+                event_names=["START", "STOP"],
+                is_timer=False,
+                actions=[
+                    InterruptAction(condition="", action="EVT_START_REQ = 1"),
+                    InterruptAction(
+                        condition="ctx->data.battery_voltage > 3000",
+                        action="EVT_STOP_REQ = 1",
+                    ),
+                ],
+            ),
+            InterruptHandlerDef(
+                name="TimerTick",
+                description="Timer interrupt",
+                event_names=[],
+                is_timer=True,
+                actions=[
+                    InterruptAction(condition="", action="ctx->data.system_tick++"),
+                ],
+            ),
+        ]
+
+        gd.placeholders = [
+            DevicePlaceholderDef(name="UART0", description="UART communication port"),
+            DevicePlaceholderDef(name="ADC0", description="AD converter"),
+        ]
+
+        gd.timer_base = TimerBaseDef(
+            variable_name="g_system_tick",
+            unit="1ms",
+            data_type="volatile uint32_t",
+            interrupt_name="TimerTick",
+            derived=[
+                TimerDerivedDef(period_name="10ms", multiplier=10,
+                                variable_name="g_tick_10ms", data_type="uint8_t"),
+                TimerDerivedDef(period_name="100ms", multiplier=100,
+                                variable_name="g_tick_100ms", data_type="uint8_t"),
+            ],
+        )
+
+        gd.extra_timers = [
+            TimerBaseDef(
+                variable_name="g_high_speed_tick",
+                unit="100us",
+                data_type="volatile uint32_t",
+                interrupt_name="HighSpeedTimerTick",
+                derived=[
+                    TimerDerivedDef(period_name="1ms", multiplier=10,
+                                    variable_name="g_hs_tick_1ms",
+                                    data_type="uint16_t"),
+                ],
+            ),
+        ]
+
+        self.global_defs = gd
+        return gd
+
+    def get_sample_data(self):
+        if self.state_machine is None:
+            self.create_sample_state_machine()
+        if self.global_defs is None:
+            self.create_sample_global_defs()
+        return self.state_machine, self.global_defs
+
+
+_sample_data_instance = None
+
+
+def get_sample_data_instance():
+    global _sample_data_instance
+    if _sample_data_instance is None:
+        _sample_data_instance = SampleDataGenerator()
+    return _sample_data_instance
+
+
+def get_sample_state_machine():
+    return get_sample_data_instance().create_sample_state_machine()
+
+
+def get_sample_global_defs():
+    return get_sample_data_instance().create_sample_global_defs()
+
+
+def get_sample_data():
+    return get_sample_data_instance().get_sample_data()

codegen/state_actions_generator.py

@@ -0,0 +1,395 @@
+# codegen/state_actions_generator.py
+"""
+State actions generation module (v2.7.0)
+
+Generates per-layer Entry / Exit / Do dispatch code:
+
+  - statable_state_actions_<Layer>.h
+      void <Layer>_Entry(STATE_<Layer>_t state, SystemContext_t *ctx);
+      void <Layer>_Exit (STATE_<Layer>_t state, SystemContext_t *ctx);
+      void <Layer>_Do   (STATE_<Layer>_t state, SystemContext_t *ctx);
+
+  - statable_state_actions_<Layer>.c
+      - Entry / Exit / Do dispatch tables (ordered init, C89-compatible)
+      - Dispatchers
+      - Per-state functions with [[STABLE_USER_CODE_..._custom]] markers
+
+Design notes
+------------
+- Table order MUST match STATE_<Layer>_t enum order.
+- Each per-state function contains:
+    * GUI-edited actions (regenerated)
+    * User custom code (preserved)
+- Role function calls receive NULL for the transition pointer
+  (state actions are not tied to a specific transition).
+
+Version: 1.0 (2026-09-26 / initial)
+"""
+
+import sys
+import os
+import logging
+from string import Template
+from typing import Dict, List, Optional
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from statable.model import State, ActionStep
+from statable.state_machine import StateMachine
+
+try:
+    from .type_mapper import CTypeMapper
+    from .naming_convention import CNamingConvention
+    from .code_templates import CodeTemplates
+except ImportError:
+    from type_mapper import CTypeMapper
+    from naming_convention import CNamingConvention
+    from code_templates import CodeTemplates
+
+logger = logging.getLogger(__name__)
+
+
+def _extract_rf_name(action) -> str:
+    """[v2.7.0] Extract role_function name from ActionStep or str."""
+    if action is None:
+        return ""
+    if isinstance(action, str):
+        return action
+    return getattr(action, "role_function", "") or ""
+
+
+class StateActionsGenerator:
+    """State actions (Entry / Exit / Do) code generator."""
+
+    HEADER_TEMPLATES = {
+        'file_comment': '''/**
+ * @file    statable_state_actions_{layer}.h
+ * @brief   State actions (Entry / Exit / Do) for {layer} layer
+ *
+ * @note    Code auto-generated by StaTable
+ *          - Manual editing is not recommended
+ *          - To modify, use StaTable
+ */''',
+        'guard_start': '#ifndef STATABLE_STATE_ACTIONS_{LAYER}_H\n'
+                       '#define STATABLE_STATE_ACTIONS_{LAYER}_H\n',
+        'guard_end': '#endif /* STATABLE_STATE_ACTIONS_{LAYER}_H */',
+        'include_common': '#include "statable_types_common.h"',
+        'include_layer': '#include "statable_types_{layer}.h"',
+        'decl_entry': 'void {layer}_Entry(STATE_{layer}_t state, SystemContext_t *ctx);',
+        'decl_exit':  'void {layer}_Exit (STATE_{layer}_t state, SystemContext_t *ctx);',
+        'decl_do':    'void {layer}_Do   (STATE_{layer}_t state, SystemContext_t *ctx);',
+    }
+
+    SOURCE_TEMPLATES = {
+        'file_comment': '''/**
+ * @file    statable_state_actions_{layer}.c
+ * @brief   State actions (Entry / Exit / Do) for {layer} layer
+ *
+ * @note    Code auto-generated by StaTable
+ *          - Manual editing is not recommended
+ *          - To modify, use StaTable
+ *          - C89-compatible: no designated initializers used.
+ *            Table order MUST match STATE_{layer}_t enum order.
+ */''',
+        'include_own': '#include "statable_state_actions_{layer}.h"',
+        'type_typedef': 'typedef void (*{layer}_StateFunc_t)(SystemContext_t *ctx);',
+    }
+
+    def __init__(self):
+        self.mapper = CTypeMapper()
+        self.naming = CNamingConvention()
+        self.templates = CodeTemplates()
+        self.layer_name: str = ""
+
+    def set_layer(self, layer_name: str):
+        self.layer_name = layer_name
+
+    def _log_debug(self, message, level='debug'):
+        log_func = getattr(logger, level, logger.debug)
+        log_func(message)
+
+    # ------------------------------------------------------------------
+    # Name helpers
+    # ------------------------------------------------------------------
+    def _state_type(self) -> str:
+        return (f"STATE_{self.layer_name}_t"
+                if self.layer_name else "STATE_t")
+
+    def _state_max(self) -> str:
+        return (f"STATE_{self.layer_name}_MAX"
+                if self.layer_name else "STATE_MAX")
+
+    def _state_enum(self, state_name: str) -> str:
+        s = self.naming.to_pascal_case(state_name) if state_name else "Unknown"
+        return (f"STATE_{self.layer_name}_{s}"
+                if self.layer_name else f"STATE_{s}")
+
+    def _func_type(self) -> str:
+        return (f"{self.layer_name}_StateFunc_t"
+                if self.layer_name else "StateFunc_t")
+
+    def _state_suffix(self, state_name: str) -> str:
+        """C-safe suffix for per-state function names."""
+        return self.naming.to_pascal_case(state_name) if state_name else "Unknown"
+
+    def _rf_call(self, rf_name: str) -> str:
+        """Generate RoleFunc_<NS>_<Name>(NULL, ctx) or fallback."""
+        if not rf_name:
+            return ""
+        if rf_name.startswith("RoleFunc_"):
+            full = rf_name
+        elif "." in rf_name:
+            ns, name = rf_name.split(".", 1)
+            full = (f"RoleFunc_{self.naming.to_pascal_case(ns)}_"
+                    f"{self.naming.to_pascal_case(name)}")
+        elif self.layer_name:
+            full = (f"RoleFunc_{self.layer_name}_"
+                    f"{self.naming.to_pascal_case(rf_name)}")
+        else:
+            full = f"RoleFunc_{self.naming.to_pascal_case(rf_name)}"
+        return f"(void){full}(NULL, ctx)"
+
+    def _fire_event_call(self, event_name: str) -> str:
+        """Generate FIRE_EVENT_<Layer>(ctx, EVENT_<Layer>_<EVT>).
+
+        The FIRE_EVENT_<Layer> macro is defined as:
+            #define FIRE_EVENT_Driver(ctx, evt) ...
+        so `ctx` must be passed explicitly.
+
+        The event enum is named EVENT_<Layer>_<UPPER_SNAKE>.
+        """
+        if not event_name:
+            return ""
+        # event_name is expected to be "Layer.EVENT" or "EVENT"
+        if "." in event_name:
+            layer, evt = event_name.split(".", 1)
+        else:
+            layer, evt = self.layer_name, event_name
+        evt_upper = self.naming.to_upper_snake(evt)
+        return f"FIRE_EVENT_{layer}(ctx, EVENT_{layer}_{evt_upper})"
+
+    # ------------------------------------------------------------------
+    # Per-action code emission
+    # ------------------------------------------------------------------
+    def _action_line(self, action: ActionStep, indent: str = "    ") -> str:
+        """Emit one ActionStep as a C statement (with optional condition)."""
+        atype = getattr(action, "action_type", "role") or "role"
+        cond = (getattr(action, "condition", "") or "").strip()
+
+        if atype == "fire_event":
+            call = self._fire_event_call(
+                getattr(action, "event_name", "") or "")
+            if not call:
+                return ""
+        elif atype == "custom":
+            # Custom is not emitted from GUI actions
+            return ""
+        else:
+            rf = _extract_rf_name(action)
+            call = self._rf_call(rf)
+            if not call:
+                return ""
+
+        if cond:
+            return (f"{indent}if ({cond}) {{\n"
+                    f"{indent}    {call};\n"
+                    f"{indent}}}\n")
+        return f"{indent}{call};\n"
+
+    def _emit_actions(self, actions: List[ActionStep]) -> str:
+        """Emit all GUI-edited actions for one kind (Entry / Exit / Do)."""
+        if not actions:
+            return ""
+        parts = ["    /* --- GUI-edited actions (regenerated) --- */\n"]
+        for a in actions:
+            line = self._action_line(a)
+            if line:
+                parts.append(line)
+        parts.append("    /* --- end GUI-edited actions --- */\n\n")
+        return "".join(parts)
+
+    # ------------------------------------------------------------------
+    # Per-state function
+    # ------------------------------------------------------------------
+    def _state_func_name(self, kind: str, state_name: str) -> str:
+        """<Layer>_<Kind>_<State>"""
+        return (f"{self.layer_name}_{kind}_"
+                f"{self._state_suffix(state_name)}")
+
+    def _custom_marker_name(self, kind: str, state_name: str) -> str:
+        return (f"{self.layer_name}_{kind}_"
+                f"{self._state_suffix(state_name)}_custom")
+
+    def _generate_state_func(self, kind: str, state: State,
+                             actions: List[ActionStep]) -> str:
+        """Generate one per-state function (Entry / Exit / Do)."""
+        func_name = self._state_func_name(kind, state.name)
+        marker = self._custom_marker_name(kind, state.name)
+
+        parts = []
+        parts.append(f"static void {func_name}(SystemContext_t *ctx)\n")
+        parts.append("{\n")
+        parts.append(self._emit_actions(actions))
+        parts.append(
+            f"    /* --- user custom code (preserved) --- */\n")
+        parts.append(
+            f"    /* [[STABLE_USER_CODE_START:{marker}]] */\n")
+        parts.append("    (void)ctx;\n")
+        parts.append(
+            f"    /* [[STABLE_USER_CODE_END:{marker}]] */\n")
+        parts.append("}\n")
+        return "".join(parts)
+
+    # ------------------------------------------------------------------
+    # Entry / Exit / Do groups
+    # ------------------------------------------------------------------
+    def _collect_actions_by_kind(self, sm: StateMachine,
+                                 kind: str) -> Dict[str, List[ActionStep]]:
+        """Return {state_name: [ActionStep, ...]} for the given kind."""
+        result: Dict[str, List[ActionStep]] = {}
+        for state in sm.states.values():
+            if kind == "Entry":
+                actions = list(getattr(state, "entry", []) or [])
+            elif kind == "Exit":
+                actions = list(getattr(state, "exit", []) or [])
+            elif kind == "Do":
+                actions = list(getattr(state, "do_actions", []) or [])
+            else:
+                actions = []
+            result[state.name] = actions
+        return result
+
+    # ------------------------------------------------------------------
+    # Forward declarations
+    # ------------------------------------------------------------------
+    def _generate_forward_decls(self, sm: StateMachine) -> str:
+        parts = []
+        for kind in ("Entry", "Exit", "Do"):
+            parts.append(
+                f"/* ---- {kind} forward declarations ---- */\n")
+            for state in sm.states.values():
+                func_name = self._state_func_name(kind, state.name)
+                parts.append(
+                    f"static void {func_name}(SystemContext_t *ctx);\n")
+            parts.append("\n")
+        return "".join(parts)
+
+    # ------------------------------------------------------------------
+    # Dispatch table (ordered init, C89)
+    # ------------------------------------------------------------------
+    def _generate_table(self, kind: str, sm: StateMachine) -> str:
+        """Generate one ordered-init dispatch table."""
+        layer = self.layer_name or "System"
+        func_type = self._func_type()
+        state_max = self._state_max()
+        table_name = f"g_{layer}_{kind}Table"
+
+        parts = []
+        parts.append(
+            f"static const {func_type} {table_name}[{state_max}] = {{\n")
+
+        # Ordered by enum definition order.
+        # StateMachine.states is a dict (insertion order); we rely on
+        # the same iteration order used by enum generation.
+        for state in sm.states.values():
+            func_name = self._state_func_name(kind, state.name)
+            parts.append(
+                f"    {func_name},  /* {self._state_enum(state.name)} */\n")
+        parts.append("};\n")
+        return "".join(parts)
+
+    # ------------------------------------------------------------------
+    # Dispatcher
+    # ------------------------------------------------------------------
+    def _generate_dispatcher(self, kind: str, sm: StateMachine) -> str:
+        layer = self.layer_name or "System"
+        func_type = self._func_type()
+        state_type = self._state_type()
+        state_max = self._state_max()
+        table_name = f"g_{layer}_{kind}Table"
+
+        parts = []
+        parts.append(f"void {layer}_{kind}({state_type} state, "
+                     f"SystemContext_t *ctx)\n")
+        parts.append("{\n")
+        parts.append(f"    if ((unsigned)state < (unsigned){state_max}) {{\n")
+        parts.append(f"        {func_type} fn = {table_name}[state];\n")
+        parts.append("        if (fn != NULL) {\n")
+        parts.append("            fn(ctx);\n")
+        parts.append("        }\n")
+        parts.append("    }\n")
+        parts.append("}\n")
+        return "".join(parts)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def generate_header(self, sm: StateMachine) -> str:
+        """Generate statable_state_actions_<Layer>.h"""
+        layer = self.layer_name or "System"
+        T = self.HEADER_TEMPLATES
+        guard = T['guard_start'].replace("{LAYER}", layer.upper())
+
+        parts = []
+        parts.append(T['file_comment'].format(layer=layer))
+        parts.append("\n\n")
+        parts.append(guard)
+        parts.append("\n")
+        parts.append(T['include_common'])
+        parts.append("\n")
+        parts.append(T['include_layer'].format(layer=layer))
+        parts.append("\n\n")
+        parts.append(
+            "/* Entry / Exit / Do dispatch (state actions) */\n")
+        parts.append(T['decl_entry'].format(layer=layer))
+        parts.append("\n")
+        parts.append(T['decl_exit'].format(layer=layer))
+        parts.append("\n")
+        parts.append(T['decl_do'].format(layer=layer))
+        parts.append("\n\n")
+        parts.append(T['guard_end'].replace("{LAYER}", layer.upper()))
+        parts.append("\n")
+        return "".join(parts)
+
+    def generate_source(self, sm: StateMachine) -> str:
+        """Generate statable_state_actions_<Layer>.c"""
+        layer = self.layer_name or "System"
+        T = self.SOURCE_TEMPLATES
+
+        parts = []
+        parts.append(T['file_comment'].format(layer=layer))
+        parts.append("\n\n")
+        parts.append(T['include_own'].format(layer=layer))
+        parts.append("\n\n")
+        parts.append(T['type_typedef'].format(layer=layer))
+        parts.append("\n\n")
+
+        # Forward declarations
+        parts.append(self._generate_forward_decls(sm))
+        parts.append("\n")
+
+        # Tables
+        for kind in ("Entry", "Exit", "Do"):
+            parts.append(
+                f"/* ---- {kind} dispatch table ---- */\n")
+            parts.append(self._generate_table(kind, sm))
+            parts.append("\n")
+
+        # Dispatchers
+        for kind in ("Entry", "Exit", "Do"):
+            parts.append(
+                f"/* ---- {kind} dispatcher ---- */\n")
+            parts.append(self._generate_dispatcher(kind, sm))
+            parts.append("\n")
+
+        # Per-state functions
+        for kind in ("Entry", "Exit", "Do"):
+            actions_by_state = self._collect_actions_by_kind(sm, kind)
+            parts.append(
+                f"/* ---- {kind} functions (user-editable) ---- */\n")
+            for state in sm.states.values():
+                parts.append(self._generate_state_func(
+                    kind, state, actions_by_state.get(state.name, [])))
+                parts.append("\n")
+
+        return "".join(parts)