statable 3.1.0__py3-none-any.whl

codegen/enum_generator.py

@@ -0,0 +1,377 @@
+# codegen/enum_generator.py
+"""
+C enum code generation module (multi-layer state machine support)
+
+[v1.5 fix]
+  - generate_event_enum: filter out empty-name events from the main loop
+    (NONE is already handled at the top, preventing duplicate definitions)
+"""
+
+import sys
+import os
+import logging
+from string import Template
+from typing import Dict, List, Any, Optional
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from statable.model import State, Event, StateType, EventKind
+from statable.global_defs import EventFlag
+
+try:
+    from .naming_convention import CNamingConvention
+    from .code_templates import CodeTemplates
+except ImportError:
+    from naming_convention import CNamingConvention
+    from code_templates import CodeTemplates
+
+logger = logging.getLogger(__name__)
+
+
+class CEnumGenerator:
+    """C enum code generation class (multi-layer state machine support)"""
+
+    ENUM_TEMPLATES = {
+        'section_comment': Template(
+            '/* $description */\n'
+        ),
+        'enum_start': 'typedef enum {\n',
+        'value_with_comment': Template(
+            '    $name = $value,    /* $comment */\n'
+        ),
+        'value': Template(
+            '    $name = $value,\n'
+        ),
+        'max_value': Template(
+            '    $name           /* element count (for system use) */\n'
+        ),
+        'enum_end': Template(
+            '} $type_name;\n'
+        ),
+    }
+
+    LAYER_TYPE_NAMES = {
+        'state': {
+            'value_prefix': 'STATE',
+            'type_suffix': '_t',
+            'max_suffix': '_MAX',
+            'none_value': None,
+        },
+        'event': {
+            'value_prefix': 'EVENT',
+            'type_suffix': '_t',
+            'max_suffix': '_MAX',
+            'none_value': 'NONE',
+        },
+        'flag': {
+            'value_prefix': 'FLAG',
+            'type_suffix': '_t',
+            'max_suffix': '_MAX',
+            'none_value': None,
+        },
+    }
+
+    COMMENT_FORMATS = {
+        'state': {
+            'description_suffix': None,
+            'type_suffix': 'Type: {type_name}',
+            'title_prefix': 'Title: ',
+        },
+        'event': {
+            'description_suffix': None,
+            'kind_suffix': 'Kind: {kind_name}',
+            'title_prefix': 'Title: ',
+        },
+        'flag': {
+            'description_suffix': None,
+            'title_prefix': 'Title: ',
+        },
+    }
+
+    def __init__(self):
+        self.naming = CNamingConvention()
+        self.templates = CodeTemplates()
+        self.strings = self.templates.STRINGS
+        self.formats = self.templates.FORMATS
+        self.layer_name: str = ""
+
+    def set_layer(self, layer_name: str):
+        self.layer_name = layer_name
+        logger.debug(f"CEnumGenerator.set_layer: layer_name='{layer_name}'")
+
+    def _log_debug(self, message, level='debug'):
+        log_func = getattr(logger, level, logger.debug)
+        log_func(message)
+
+    def _state_value_name(self, state_name: str) -> str:
+        pascal = self.naming.to_pascal_case(state_name) if state_name else "Unknown"
+        if self.layer_name:
+            return f"STATE_{self.layer_name}_{pascal}"
+        return f"STATE_{pascal}"
+
+    def _event_value_name(self, event_name: str) -> str:
+        if not event_name:
+            upper = "NONE"
+        else:
+            upper = self.naming.to_upper_snake(event_name)
+        if self.layer_name:
+            return f"EVENT_{self.layer_name}_{upper}"
+        return f"EVENT_{upper}"
+
+    def _flag_value_name(self, flag_name: str) -> str:
+        upper = self.naming.to_upper_snake(flag_name)
+        return f"FLAG_{upper}"
+
+    def _state_type_name(self) -> str:
+        if self.layer_name:
+            return f"STATE_{self.layer_name}_t"
+        return "STATE_t"
+
+    def _event_type_name(self) -> str:
+        if self.layer_name:
+            return f"EVENT_{self.layer_name}_t"
+        return "EVENT_t"
+
+    def _flag_type_name(self) -> str:
+        return "FLAG_t"
+
+    def _state_max_name(self) -> str:
+        if self.layer_name:
+            return f"STATE_{self.layer_name}_MAX"
+        return "STATE_MAX"
+
+    def _event_max_name(self) -> str:
+        if self.layer_name:
+            return f"EVENT_{self.layer_name}_MAX"
+        return "EVENT_MAX"
+
+    def _flag_max_name(self) -> str:
+        return "FLAG_MAX"
+
+    def _generate_state_comment(self, state: State) -> str:
+        comments = []
+        if getattr(state, 'description', ''):
+            comments.append(state.description)
+        if getattr(state, 'type', None) and state.type != StateType.NORMAL:
+            comments.append(f"Type: {state.type.name}")
+        if getattr(state, 'title', ''):
+            comments.append(f"Title: {state.title}")
+        return ' '.join(comments)
+
+    def _generate_event_comment(self, event: Event) -> str:
+        comments = []
+        if getattr(event, 'description', ''):
+            comments.append(event.description)
+        if getattr(event, 'kind', None) and event.kind != EventKind.SIGNAL:
+            comments.append(f"Kind: {event.kind.name}")
+        if getattr(event, 'title', ''):
+            comments.append(f"Title: {event.title}")
+        return ' '.join(comments)
+
+    def _generate_flag_comment(self, flag: EventFlag) -> str:
+        comments = []
+        if getattr(flag, 'description', ''):
+            comments.append(flag.description)
+        if getattr(flag, 'title', ''):
+            comments.append(f"Title: {flag.title}")
+        return ' '.join(comments)
+
+    def _generate_enum_values(self, items: List[Any],
+                              value_name_func,
+                              comment_func,
+                              none_value: Optional[str] = None,
+                              none_comment: str = "") -> str:
+        T = self.ENUM_TEMPLATES
+        parts = []
+
+        if none_value is not None:
+            none_name = value_name_func("")
+            parts.append(T['value_with_comment'].substitute(
+                name=none_name,
+                value=0,
+                comment=none_comment,
+            ))
+            start_index = 1
+        else:
+            start_index = 0
+
+        for i, item in enumerate(items):
+            value = start_index + i
+            name = value_name_func(getattr(item, 'name', 'unnamed'))
+            comment = comment_func(item)
+
+            if comment:
+                parts.append(T['value_with_comment'].substitute(
+                    name=name, value=value, comment=comment,
+                ))
+            else:
+                parts.append(T['value'].substitute(
+                    name=name, value=value,
+                ))
+
+        return ''.join(parts)
+
+    def generate_state_enum(self, states: List[State]) -> str:
+        if not states:
+            return ''
+
+        self._log_debug(f"=== generate_state_enum START: {len(states)} states ===")
+        T = self.ENUM_TEMPLATES
+        parts = []
+
+        desc = f"{self.layer_name} layer state definitions" if self.layer_name else "State definitions"
+        parts.append(T['section_comment'].substitute(description=desc))
+
+        parts.append(T['enum_start'])
+
+        parts.append(self._generate_enum_values(
+            items=states,
+            value_name_func=self._state_value_name,
+            comment_func=self._generate_state_comment,
+            none_value=None,
+        ))
+
+        parts.append(T['max_value'].substitute(name=self._state_max_name()))
+        parts.append(T['enum_end'].substitute(type_name=self._state_type_name()))
+
+        result = ''.join(parts)
+        self._log_debug(f"=== generate_state_enum END ===")
+        return result
+
+    def generate_event_enum(self, events: List[Event]) -> str:
+        """
+        Generate event enum (including NONE = 0).
+
+        [v1.5 fix]
+          Empty-name events (used for completion transitions, `name=""`)
+          are already handled as NONE at the top, so exclude them from
+          the main loop. This prevents duplicate EVENT_<Layer>_NONE.
+        """
+        if not events:
+            return ''
+
+        # v1.5 fix: exclude empty-name events
+        non_empty_events = [
+            e for e in events if getattr(e, 'name', '')
+        ]
+        filtered = len(events) - len(non_empty_events)
+        if filtered:
+            self._log_debug(
+                f"generate_event_enum: filtered out {filtered} empty-name "
+                f"event(s) (already processed as NONE)"
+            )
+
+        self._log_debug(f"=== generate_event_enum START: "
+                        f"{len(non_empty_events)} events ===")
+        T = self.ENUM_TEMPLATES
+        parts = []
+
+        desc = f"{self.layer_name} layer event definitions" if self.layer_name else "Event definitions"
+        parts.append(T['section_comment'].substitute(description=desc))
+
+        parts.append(T['enum_start'])
+
+        parts.append(self._generate_enum_values(
+            items=non_empty_events,
+            value_name_func=self._event_value_name,
+            comment_func=self._generate_event_comment,
+            none_value="NONE",
+            none_comment="completion transition",
+        ))
+
+        parts.append(T['max_value'].substitute(name=self._event_max_name()))
+        parts.append(T['enum_end'].substitute(type_name=self._event_type_name()))
+
+        result = ''.join(parts)
+        self._log_debug(f"=== generate_event_enum END ===")
+        return result
+
+    def generate_flag_enum(self, flags: List[EventFlag]) -> str:
+        if not flags:
+            return ''
+
+        self._log_debug(f"=== generate_flag_enum START: {len(flags)} flags ===")
+        T = self.ENUM_TEMPLATES
+        parts = []
+
+        parts.append(T['section_comment'].substitute(description="Event flag definitions"))
+        parts.append(T['enum_start'])
+
+        parts.append(self._generate_enum_values(
+            items=flags,
+            value_name_func=self._flag_value_name,
+            comment_func=self._generate_flag_comment,
+            none_value=None,
+        ))
+
+        parts.append(T['max_value'].substitute(name=self._flag_max_name()))
+        parts.append(T['enum_end'].substitute(type_name=self._flag_type_name()))
+
+        result = ''.join(parts)
+        self._log_debug(f"=== generate_flag_enum END ===")
+        return result
+
+    def generate_all_enums(self, states: List[State], events: List[Event],
+                           flags: List[EventFlag] = None) -> str:
+        self._log_debug(f"=== generate_all_enums START: "
+                        f"{len(states)} states, {len(events)} events, "
+                        f"{len(flags) if flags else 0} flags ===")
+        parts = []
+
+        state_enum = self.generate_state_enum(states)
+        if state_enum:
+            parts.append(state_enum)
+            parts.append("")
+
+        event_enum = self.generate_event_enum(events)
+        if event_enum:
+            parts.append(event_enum)
+            parts.append("")
+
+        if flags:
+            flag_enum = self.generate_flag_enum(flags)
+            if flag_enum:
+                parts.append(flag_enum)
+
+        result = '\n'.join(parts)
+        self._log_debug(f"=== generate_all_enums END: {len(result)} chars ===")
+        return result
+
+    def generate_bit_mask_enum(self, flags: List[EventFlag]) -> str:
+        if not flags:
+            return ''
+
+        self._log_debug(f"=== generate_bit_mask_enum START: {len(flags)} flags ===")
+        T = self.ENUM_TEMPLATES
+        parts = []
+
+        parts.append('/* Event flag bitmask definitions */\n')
+        parts.append('/* Used when managing flags as individual bits */\n')
+        parts.append(T['enum_start'])
+
+        for i, flag in enumerate(flags):
+            bit_value = 1 << i
+            upper = self.naming.to_upper_snake(getattr(flag, 'name', 'unnamed'))
+            name = f"FLAG_MASK_{upper}"
+            comment = self._generate_flag_comment(flag)
+            if comment:
+                parts.append(f"    {name} = 0x{bit_value:02X},    /* {comment} */\n")
+            else:
+                parts.append(f"    {name} = 0x{bit_value:02X},\n")
+
+        parts.append(T['enum_end'].substitute(type_name="FLAG_MASK_t"))
+
+        result = ''.join(parts)
+        self._log_debug(f"=== generate_bit_mask_enum END ===")
+        return result
+
+    def generate_enum(self, enum_type: str, items: List[Any]) -> str:
+        if enum_type == 'state':
+            return self.generate_state_enum(items)
+        elif enum_type == 'event':
+            return self.generate_event_enum(items)
+        elif enum_type == 'flag':
+            return self.generate_flag_enum(items)
+        else:
+            logger.warning(f"Unknown enum_type: {enum_type}")
+            return ""

codegen/event_queue_generator.py

@@ -0,0 +1,303 @@
+# codegen/event_queue_generator.py
+"""\nEvent queue code generation module (fully data-driven)\n"""
+
+import sys
+import os
+import logging
+from typing import Dict, Callable, List, Any
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from statable.global_defs import EventQueueDef, GlobalDefinitions
+
+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__)
+
+
+class EventQueueGenerator:
+    """Event queue code generation class (fully data-driven)"""
+    
+    def __init__(self):
+        self.mapper = CTypeMapper()
+        self.naming = CNamingConvention()
+        self.templates = CodeTemplates()
+        self.strings = self.templates.STRINGS
+        self.formats = self.templates.FORMATS
+        
+        # Generation step definition
+        self.struct_steps = [
+            {'action': 'comment'},
+            {'action': 'struct_start'},
+            {'action': 'members'},
+            {'action': 'struct_end'},
+        ]
+        
+        self.enqueue_steps = [
+            {'action': 'comment'},
+            {'action': 'signature'},
+            {'action': 'open'},
+            {'action': 'null_check'},
+            {'action': 'full_check'},
+            {'action': 'enqueue_body'},
+            {'action': 'close'},
+        ]
+        
+        self.dequeue_steps = [
+            {'action': 'comment'},
+            {'action': 'signature'},
+            {'action': 'open'},
+            {'action': 'null_check'},
+            {'action': 'empty_check'},
+            {'action': 'dequeue_body'},
+            {'action': 'close'},
+        ]
+        
+        # Step execution dictionary
+        self.struct_executors: Dict[str, Callable] = {
+            'comment': self._execute_struct_comment,
+            'struct_start': self._execute_struct_start,
+            'members': self._execute_members,
+            'struct_end': self._execute_struct_end,
+        }
+        
+        self.enqueue_executors: Dict[str, Callable] = {
+            'comment': self._execute_enqueue_comment,
+            'signature': self._execute_enqueue_signature,
+            'open': self._execute_open,
+            'null_check': self._execute_null_check,
+            'full_check': self._execute_full_check,
+            'enqueue_body': self._execute_enqueue_body,
+            'close': self._execute_close,
+        }
+        
+        self.dequeue_executors: Dict[str, Callable] = {
+            'comment': self._execute_dequeue_comment,
+            'signature': self._execute_dequeue_signature,
+            'open': self._execute_open,
+            'null_check': self._execute_null_check,
+            'empty_check': self._execute_empty_check,
+            'dequeue_body': self._execute_dequeue_body,
+            'close': self._execute_close,
+        }
+    
+    def _log_debug(self, message, level='debug'):
+        log_func = getattr(logger, level, logger.debug)
+        log_func(message)
+    
+    # ===== Name generation =====
+    def _generate_struct_name(self, queue):
+        return self.naming.create_type_name(getattr(queue, 'name', 'EventQueue'))
+    
+    def _generate_func_prefix(self, queue):
+        return f"EventQueue_{self.naming.to_pascal_case(getattr(queue, 'name', ''))}"
+    
+    # ===== Struct generation step =====
+    def _execute_struct_comment(self, step, context):
+        queue = context.get('queue')
+        name = getattr(queue, 'name', 'unknown')
+        desc = getattr(queue, 'description', '')
+        lines = [f"/* Event queue: {name} */"]
+        if desc:
+            lines.append(f"/* {desc} */")
+        return lines
+    
+    def _execute_struct_start(self, step, context):
+        return ["typedef struct {"]
+    
+    def _execute_members(self, step, context):
+        queue = context.get('queue')
+        indent = self.strings['indent_1']
+        size = getattr(queue, 'size', 0)
+        element_type = self.mapper.map_type(getattr(queue, 'element_type', 'EVENT_t'))
+        
+        lines = []
+        lines.append(f"{indent}{element_type} buffer[{size}];")
+        lines.append(f"{indent}uint8_t head;")
+        lines.append(f"{indent}uint8_t tail;")
+        lines.append(f"{indent}uint8_t count;")
+        
+        if getattr(queue, 'interrupt_safe', False):
+            lines.append(f"{indent}bool interrupt_safe;")
+        
+        if getattr(queue, 'rtos_enabled', False):
+            lines.append(f"{indent}bool rtos_enabled;")
+        
+        return lines
+    
+    def _execute_struct_end(self, step, context):
+        queue = context.get('queue')
+        type_name = self._generate_struct_name(queue)
+        return [f"}} {type_name};"]
+    
+    # ===== Enqueue generation step =====
+    def _execute_enqueue_comment(self, step, context):
+        queue = context.get('queue')
+        name = getattr(queue, 'name', 'unknown')
+        return [
+            "/**",
+            f" * @brief  Enqueue event ({name})",
+            " * @param  queue  Queue",
+            " * @param  event  Event",
+            " * @return success: true, failure: false",
+            " */",
+        ]
+    
+    def _execute_enqueue_signature(self, step, context):
+        queue = context.get('queue')
+        type_name = self._generate_struct_name(queue)
+        func_name = self._generate_func_prefix(queue) + "_Enqueue"
+        return [f"bool {func_name}({type_name} *queue, EVENT_t event)"]
+    
+    def _execute_dequeue_comment(self, step, context):
+        queue = context.get('queue')
+        name = getattr(queue, 'name', 'unknown')
+        return [
+            "/**",
+            f" * @brief  Dequeue event ({name})",
+            " * @param  queue  Queue",
+            " * @param  event  Dequeued event",
+            " * @return success: true, failure: false",
+            " */",
+        ]
+    
+    def _execute_dequeue_signature(self, step, context):
+        queue = context.get('queue')
+        type_name = self._generate_struct_name(queue)
+        func_name = self._generate_func_prefix(queue) + "_Dequeue"
+        return [f"bool {func_name}({type_name} *queue, EVENT_t *event)"]
+    
+    def _execute_open(self, step, context):
+        return ["{"]
+    
+    def _execute_close(self, step, context):
+        return ["}"]
+    
+    def _execute_null_check(self, step, context):
+        indent = self.strings['indent_1']
+        lines = []
+        lines.append(f"{indent}if (queue == NULL) {{")
+        lines.append(f"{indent}{indent}return false;")
+        lines.append(f"{indent}}}")
+        return lines
+    
+    def _execute_full_check(self, step, context):
+        queue = context.get('queue')
+        size = getattr(queue, 'size', 0)
+        indent = self.strings['indent_1']
+        lines = []
+        lines.append(f"{indent}if (queue->count >= {size}) {{")
+        lines.append(f"{indent}{indent}return false;  /* Queue full */")
+        lines.append(f"{indent}}}")
+        return lines
+    
+    def _execute_empty_check(self, step, context):
+        indent = self.strings['indent_1']
+        lines = []
+        lines.append(f"{indent}if (queue->count == 0) {{")
+        lines.append(f"{indent}{indent}return false;  /* Queue empty */")
+        lines.append(f"{indent}}}")
+        return lines
+    
+    def _execute_enqueue_body(self, step, context):
+        queue = context.get('queue')
+        size = getattr(queue, 'size', 0)
+        indent = self.strings['indent_1']
+        lines = []
+        lines.append(f"{indent}queue->buffer[queue->tail] = event;")
+        lines.append(f"{indent}queue->tail = (queue->tail + 1) % {size};")
+        lines.append(f"{indent}queue->count++;")
+        lines.append(f"{indent}return true;")
+        return lines
+    
+    def _execute_dequeue_body(self, step, context):
+        queue = context.get('queue')
+        size = getattr(queue, 'size', 0)
+        indent = self.strings['indent_1']
+        lines = []
+        lines.append(f"{indent}if (event == NULL) {{")
+        lines.append(f"{indent}{indent}return false;")
+        lines.append(f"{indent}}}")
+        lines.append(f"{indent}*event = queue->buffer[queue->head];")
+        lines.append(f"{indent}queue->head = (queue->head + 1) % {size};")
+        lines.append(f"{indent}queue->count--;")
+        lines.append(f"{indent}return true;")
+        return lines
+    
+    # ===== Public methods =====
+    def generate_struct(self, queue: EventQueueDef) -> str:
+        """Event queue struct generation"""
+        self._log_debug(f"Generating struct for: {getattr(queue, 'name', 'unknown')}")
+        context = {'queue': queue}
+        lines = []
+        for step in self.struct_steps:
+            executor = self.struct_executors.get(step['action'])
+            if executor:
+                lines.extend(executor(step, context))
+        return '\n'.join(lines)
+    
+    def generate_enqueue_function(self, queue: EventQueueDef) -> str:
+        """Enqueue function generation"""
+        self._log_debug(f"Generating enqueue for: {getattr(queue, 'name', 'unknown')}")
+        context = {'queue': queue}
+        lines = []
+        for step in self.enqueue_steps:
+            executor = self.enqueue_executors.get(step['action'])
+            if executor:
+                lines.extend(executor(step, context))
+        return '\n'.join(lines)
+    
+    def generate_dequeue_function(self, queue: EventQueueDef) -> str:
+        """Dequeue function generation"""
+        self._log_debug(f"Generating dequeue for: {getattr(queue, 'name', 'unknown')}")
+        context = {'queue': queue}
+        lines = []
+        for step in self.dequeue_steps:
+            executor = self.dequeue_executors.get(step['action'])
+            if executor:
+                lines.extend(executor(step, context))
+        return '\n'.join(lines)
+    
+    def generate_all_code(self, queue: EventQueueDef) -> str:
+        """Generate all event queue code"""
+        self._log_debug(f"Generating all code for: {getattr(queue, 'name', 'unknown')}")
+        lines = []
+        lines.append(self.generate_struct(queue))
+        lines.append("")
+        lines.append(self.generate_enqueue_function(queue))
+        lines.append("")
+        lines.append(self.generate_dequeue_function(queue))
+        return '\n'.join(lines)
+    
+    def generate_all_structs(self, global_defs: GlobalDefinitions) -> str:
+        """Generate all event queue structs"""
+        lines = []
+        for queue in getattr(global_defs, 'event_queues', []):
+            lines.append(self.generate_struct(queue))
+            lines.append("")
+        return '\n'.join(lines)
+    
+    def generate_all_functions(self, global_defs: GlobalDefinitions) -> str:
+        """Generate all event queue functions"""
+        lines = []
+        for queue in getattr(global_defs, 'event_queues', []):
+            lines.append(self.generate_enqueue_function(queue))
+            lines.append("")
+            lines.append(self.generate_dequeue_function(queue))
+            lines.append("")
+        return '\n'.join(lines)
+    
+    def generate_all(self, global_defs: GlobalDefinitions) -> str:
+        """Generate all event queue code"""
+        lines = []
+        for queue in getattr(global_defs, 'event_queues', []):
+            lines.append(self.generate_all_code(queue))
+            lines.append("")
+        return '\n'.join(lines)