statable 3.1.0__py3-none-any.whl

codegen/code_templates.py

@@ -0,0 +1,509 @@
+# codegen/code_templates.py
+"""
+Code generation template definitions (multi-layer state machine / ISR support)
+
+Version: 2.2.5 (2026-09-20 / gcc compile fix)
+  - Fix: SUPER_LOOP_TEMPLATES['run_block'] now wraps each layer's
+    event processing in its own `{ ... }` scope. Previously all layers
+    emitted `EVENT_<Layer>_t evt = ...` at the same function scope,
+    causing "conflicting types for 'evt'" errors under gcc when the
+    per-layer EVENT types differ.
+    The scoped block keeps the variable name `evt` unchanged, so the
+    generated code remains readable and the diff is minimal.
+
+Version: 2.2.4 (2026-09-20 / MISRA 12.1 + 10.4 fixes)
+Version: 2.2.3 (2026-09-20 / MISRA 17.3 fix)
+Version: 2.2.2 (2026-09-19)
+Version: 2.2.1
+"""
+
+
+class CodeTemplates:
+    """Code generation template dictionary"""
+
+    # ===== Basic string definitions =====
+    STRINGS = {
+        # --- Fixed section line (VALID C block comment) ---
+        'section_line_start': '/*==============================================================',
+        'section_line_end':   ' *==============================================================*/',
+
+        'indent_1': '    ',
+        'indent_2': '        ',
+        'indent_3': '            ',
+        'newline': '\n',
+        'blank_line': '',
+        'typedef': 'typedef',
+        'struct': 'struct',
+        'enum': 'enum',
+        'include': '#include',
+        'define': '#define',
+        'ifndef': '#ifndef',
+        'endif': '#endif',
+        'return': 'return',
+        'void': 'void',
+        'static': 'static',
+        'const': 'const',
+        'switch': 'switch',
+        'case': 'case',
+        'break': 'break',
+        'default': 'default',
+        'if': 'if',
+        'else': 'else',
+        'todo': 'TODO: implement the code here',
+        'unused_arg': 'suppress unused argument warning',
+        'auto_generated': 'Code auto-generated by StaTable',
+        'no_edit': 'Manual editing is not recommended',
+        'edit_in_statable': 'To modify, use StaTable',
+        'log_debug': 'LOG_DEBUG',
+        'log_info': 'LOG_INFO',
+        'log_warning': 'LOG_WARNING',
+        'log_error': 'LOG_ERROR',
+    }
+
+    SECTION_HEADERS = {
+        'include': 'Include files',
+        'type_defs': 'Type definitions',
+        'custom_types': 'User-defined types',
+        'system_structs': 'System structs',
+        'transition_context': 'Transition context',
+        'pending_event': 'Pending event control',
+        'layer_types': 'Layer-specific type definitions',
+        'function_decls': 'Function declarations',
+        'role_functions': 'Role function declarations',
+        'role_impl': 'Role function implementations',
+        'transition_table': 'State transition table',
+        'transition_cells': 'Per-cell transition functions',
+        'transition_func': 'State transition functions',
+        'get_next_event': 'Event retrieval function',
+        'init_func': 'Initialization function',
+        'var_macros': 'Variable access macros',
+        'super_include': 'Super include',
+        'mutex_impl': 'Mutex implementation',
+        'semaphore_impl': 'Semaphore implementation',
+        'queue_impl': 'Queue implementation',
+        'critical_section_impl': 'Critical section implementation',
+        'cell_actions': 'Cell actions (transition-independent)',
+        'cell_transitions': 'Cell transitions (ordered)',
+        'state_entry_exit': 'State entry / exit calls',
+        'common_function_decls': 'Common function declarations',
+    }
+
+    STRUCT_COMMENTS = {
+        'system_data': {'title': 'Global variable struct', 'description': 'Manages variables shared across the system'},
+        'event_flags': {'title': 'Event flag struct', 'description': 'Manages flags indicating event occurrences'},
+        'system_context': {'title': 'System context struct', 'description': 'Integrates global variables and event flags'},
+        'transition_cell': {'title': 'Transition cell struct', 'description': 'Represents one cell of the state transition table'},
+        'transition_context': {'title': 'Transition context struct', 'description': 'Holds source state and event'},
+    }
+
+    ENUM_COMMENTS = {
+        'state': {'title': 'State definitions', 'description': 'Enum representing states of the state machine'},
+        'event': {'title': 'Event definitions', 'description': 'Enum of events that trigger state transitions'},
+        'flag': {'title': 'Event flag definitions', 'description': 'Enum representing event flag identifiers'},
+    }
+
+    TYPE_NAMES = {
+        'state': 'STATE_t',
+        'event': 'EVENT_t',
+        'flag': 'FLAG_t',
+        'system_data': 'SystemData_t',
+        'event_flags': 'EventFlags_t',
+        'system_context': 'SystemContext_t',
+        'transition_cell': 'TransitionCell_t',
+        'transition_table': 'transition_matrix',
+        'layer_state_prefix': 'STATE_',
+        'layer_event_prefix': 'EVENT_',
+        'layer_transition_context_prefix': 'TransitionContext_',
+        'layer_process_prefix': 'StateMachine_Process_',
+        'layer_get_next_event_prefix': 'StateMachine_GetNextEvent_',
+        'layer_role_func_prefix': 'RoleFunc_',
+        'layer_transition_func_prefix': 'transition_',
+    }
+
+    FUNCTION_NAMES = {
+        'state_machine_process': 'StateMachine_Process',
+        'system_context_init': 'SystemContext_Init',
+        'role_func_prefix': 'RoleFunc',
+        'action_prefix': 'Action',
+        'condition_prefix': 'Condition',
+        'get_next_event_prefix': 'StateMachine_GetNextEvent',
+        'layer_process_prefix': 'StateMachine_Process_',
+    }
+
+    MACRO_NAMES = {
+        'data_prefix': 'DATA_',
+        'flag_prefix': 'FLAG_',
+        'max_suffix': '_MAX',
+        'fire_event': 'FIRE_EVENT',
+        'max_consecutive_pending_events': 'MAX_CONSECUTIVE_PENDING_EVENTS',
+    }
+
+    FORMATS = {
+        'section_header': '{start}\n *  {title}\n{end}',
+        'file_header': '''/**
+ * @file    {filename}
+ * @brief   {description}
+ *
+ * @note    {auto_generated}
+ *          - {no_edit}
+ *          - {edit_in_statable}
+ *
+ * @date    {date}
+ */''',
+        'include_guard_start': '#ifndef {guard_macro}\n#define {guard_macro}\n',
+        'include_guard_end': '#endif /* {guard_macro} */',
+        'struct_start': 'typedef struct {',
+        'struct_end': '} {type_name};',
+        'enum_start': 'typedef enum {',
+        'enum_end': '} {type_name};',
+        'enum_value': '{name} = {value},',
+        'enum_value_with_comment': '{name} = {value},    /* {comment} */',
+        'enum_max': '{name}           /* {comment} */',
+        'data_macro': '#define DATA_{var_name}(ctx)    ((ctx)->data.{var_name})',
+        'flag_macro': '#define FLAG_{flag_name}(ctx)   ((ctx)->flags.{flag_name})',
+        'group_separator': '/* === {group_name} === */',
+        'member_normal': '{indent}{type} {name};',
+        'member_array': '{indent}{type} {name}[{size}];',
+        'member_bitfield': '{indent}{type} {name} : {width};',
+        'inline_comment': '{indent}/* {comment} */',
+        'title_comment': '{indent}/* Title: {title} */',
+    }
+
+    LAYER_TEMPLATES = {
+        'types_header_comment': '''/**
+ * @file    statable_types_{layer}.h
+ * @brief   Type definitions for {layer} layer
+ */''',
+        'state_enum_comment': '/* State definitions for {layer} layer */',
+        'event_enum_comment': '/* Event definitions for {layer} layer */',
+        'transition_context_comment': '/* Transition context for {layer} layer */',
+        'transition_context_struct': '''typedef struct {{
+    STATE_{layer}_t from_state;
+    EVENT_{layer}_t event;
+}} TransitionContext_{layer}_t;''',
+    }
+
+    COMMON_TYPES_TEMPLATES = {
+        'system_context': '''typedef struct {{
+    SystemData_t data;
+    EventFlags_t flags;
+    uint16_t pending_event;
+    bool pending_event_valid;
+}} SystemContext_t;''',
+        'fire_event_macro': '''#define FIRE_EVENT(ctx, evt)  do {{ \\
+    (ctx)->pending_event = (uint16_t)(evt); \\
+    (ctx)->pending_event_valid = true; \\
+}} while(0)''',
+        'max_consecutive_pending_events': '''#ifndef MAX_CONSECUTIVE_PENDING_EVENTS
+#define MAX_CONSECUTIVE_PENDING_EVENTS 16
+#endif''',
+    }
+
+    ISR_TEMPLATES = {
+        'context_section':    '    /* ===== Context reference (auto-generated) ===== */',
+        'enter_log_section':  '    /* ===== Enter log ===== */',
+        'action_section':     '    /* ===== Actions (auto-generated) ===== */',
+        'user_section':       '    /* ===== User code area ===== */',
+        'exit_log_section':   '    /* ===== Exit log ===== */',
+        'context_decl':       '    SystemContext_t *ctx = &g_ctx;',
+        'context_void':       '    (void)ctx;',
+        'enter_log':          '    LOG_DEBUG("Enter ISR: {name}");',
+        'exit_log':           '    LOG_DEBUG("Exit ISR: {name}");',
+        'user_marker_start':  '    /* [[STABLE_USER_CODE_START:{marker}]] */',
+        'user_hint':          '    /* Write user code here */',
+        'user_marker_end':    '    /* [[STABLE_USER_CODE_END:{marker}]] */',
+        'used_rf_header':     ' * @note   Used role functions:',
+        'used_rf_line':       ' *         - {ref}',
+        'no_action_hint':     '    /* (no action defined) */',
+    }
+
+    DEBUG_MESSAGES = {
+        'function_entry': 'Enter {func_name}: state={state}, event={event}',
+        'function_exit': 'Exit {func_name}: next_state={next_state}',
+        'condition_check': 'Check condition: {condition_name}',
+        'condition_not_met': 'Condition not met',
+        'action_execute': 'Execute action: {action_name}',
+        'transition': 'Transition: {from_state} -> {to_state} (event: {event})',
+        'no_transition': 'No transition: state={state}, event={event}',
+        'null_pointer': 'NULL pointer: {var_name}',
+        'out_of_range': 'Out of range: {var_name}={value}, max={max}',
+        'pending_event_too_long': 'Pending event chain too long ({count})',
+    }
+
+    OSAL = {
+        'os_types': {
+            'non_rtos': {'name': 'NonRTOS', 'description': 'No RTOS (bare metal)', 'header': 'osal.h', 'source': 'osal.c'},
+            'freertos': {'name': 'FreeRTOS', 'description': 'FreeRTOS', 'header': 'osal_freertos.h', 'source': 'osal_freertos.c'},
+            'threadx': {'name': 'ThreadX', 'description': 'Azure RTOS ThreadX', 'header': 'osal_threadx.h', 'source': 'osal_threadx.c'},
+        },
+        'header': {
+            'file_comment': '''/**
+ * @file    {filename}
+ * @brief   OSAL (OS Abstraction Layer) - {os_name}
+ */''',
+            'include_guard_start': '#ifndef {guard_name}\n#define {guard_name}\n',
+            'include_guard_end': '#endif /* {guard_name} */',
+            'type_defs_comment': '/* OSAL type definitions */',
+            'status_enum': '''typedef enum {
+    OSAL_OK = 0,
+    OSAL_ERROR,
+    OSAL_TIMEOUT,
+    OSAL_BUSY,
+} OSAL_Status_t;''',
+            'mutex_type_nonrtos': '''typedef struct {
+    volatile bool locked;
+} OSAL_Mutex_t;''',
+            'semaphore_type_nonrtos': '''typedef struct {
+    volatile uint32_t count;
+    volatile uint32_t max_count;
+} OSAL_Semaphore_t;''',
+            'queue_type_nonrtos': '''typedef struct {
+    void *buffer;
+    uint32_t size;
+    uint32_t item_size;
+    volatile uint32_t head;
+    volatile uint32_t tail;
+    volatile uint32_t count;
+} OSAL_Queue_t;''',
+            'mutex_decls': '''OSAL_Status_t OSAL_Mutex_Create(OSAL_Mutex_t *mutex);
+OSAL_Status_t OSAL_Mutex_Lock(OSAL_Mutex_t *mutex, uint32_t timeout_ms);
+OSAL_Status_t OSAL_Mutex_Unlock(OSAL_Mutex_t *mutex);''',
+            'semaphore_decls': '''OSAL_Status_t OSAL_Semaphore_Create(OSAL_Semaphore_t *sem, uint32_t max_count, uint32_t initial_count);
+OSAL_Status_t OSAL_Semaphore_Take(OSAL_Semaphore_t *sem, uint32_t timeout_ms);
+OSAL_Status_t OSAL_Semaphore_Give(OSAL_Semaphore_t *sem);''',
+            'queue_decls': '''OSAL_Status_t OSAL_Queue_Create(OSAL_Queue_t *queue, void *buffer, uint32_t size, uint32_t item_size);
+OSAL_Status_t OSAL_Queue_Send(OSAL_Queue_t *queue, const void *item, uint32_t timeout_ms);
+OSAL_Status_t OSAL_Queue_Receive(OSAL_Queue_t *queue, void *item, uint32_t timeout_ms);''',
+            'critical_decls': '''void OSAL_Critical_Enter(void);
+void OSAL_Critical_Exit(void);''',
+            'freertos_includes': '#include "FreeRTOS.h"\n#include "semphr.h"\n#include "queue.h"',
+            'threadx_includes': '#include "tx_api.h"',
+        },
+        'source': {
+            'file_comment': '''/**
+ * @file    {filename}
+ * @brief   OSAL (OS Abstraction Layer) - {os_name} implementation
+ */''',
+            'mutex_section_comment': '/* Mutex implementation */',
+            'semaphore_section_comment': '/* Semaphore implementation */',
+            'queue_section_comment': '/* Queue implementation */',
+            'critical_section_comment': '/* Critical section implementation */',
+            'mutex_create_nonrtos': '''OSAL_Status_t OSAL_Mutex_Create(OSAL_Mutex_t *mutex)
+{
+    if (mutex == NULL) {
+        return OSAL_ERROR;
+    }
+    mutex->locked = false;
+    return OSAL_OK;
+}''',
+            'mutex_lock_nonrtos': '''OSAL_Status_t OSAL_Mutex_Lock(OSAL_Mutex_t *mutex, uint32_t timeout_ms)
+{
+    (void)timeout_ms;
+    if (mutex == NULL) {
+        return OSAL_ERROR;
+    }
+    if (mutex->locked) {
+        return OSAL_BUSY;
+    }
+    mutex->locked = true;
+    return OSAL_OK;
+}''',
+            'mutex_unlock_nonrtos': '''OSAL_Status_t OSAL_Mutex_Unlock(OSAL_Mutex_t *mutex)
+{
+    if (mutex == NULL) {
+        return OSAL_ERROR;
+    }
+    mutex->locked = false;
+    return OSAL_OK;
+}''',
+            'semaphore_create_nonrtos': '''OSAL_Status_t OSAL_Semaphore_Create(OSAL_Semaphore_t *sem, uint32_t max_count, uint32_t initial_count)
+{
+    if (sem == NULL) {
+        return OSAL_ERROR;
+    }
+    sem->max_count = max_count;
+    sem->count = initial_count;
+    return OSAL_OK;
+}''',
+            'semaphore_take_nonrtos': '''OSAL_Status_t OSAL_Semaphore_Take(OSAL_Semaphore_t *sem, uint32_t timeout_ms)
+{
+    (void)timeout_ms;
+    if (sem == NULL) {
+        return OSAL_ERROR;
+    }
+    if (sem->count == 0U) {
+        return OSAL_BUSY;
+    }
+    sem->count--;
+    return OSAL_OK;
+}''',
+            'semaphore_give_nonrtos': '''OSAL_Status_t OSAL_Semaphore_Give(OSAL_Semaphore_t *sem)
+{
+    if (sem == NULL) {
+        return OSAL_ERROR;
+    }
+    if (sem->count >= sem->max_count) {
+        return OSAL_BUSY;
+    }
+    sem->count++;
+    return OSAL_OK;
+}''',
+            'queue_create_nonrtos': '''OSAL_Status_t OSAL_Queue_Create(OSAL_Queue_t *queue, void *buffer, uint32_t size, uint32_t item_size)
+{
+    if ((queue == NULL) || (buffer == NULL)) {
+        return OSAL_ERROR;
+    }
+    queue->buffer = buffer;
+    queue->size = size;
+    queue->item_size = item_size;
+    queue->head = 0U;
+    queue->tail = 0U;
+    queue->count = 0U;
+    return OSAL_OK;
+}''',
+            'queue_send_nonrtos': '''OSAL_Status_t OSAL_Queue_Send(OSAL_Queue_t *queue, const void *item, uint32_t timeout_ms)
+{
+    (void)timeout_ms;
+    if ((queue == NULL) || (item == NULL)) {
+        return OSAL_ERROR;
+    }
+    if (queue->count >= queue->size) {
+        return OSAL_BUSY;
+    }
+    uint8_t *dest = (uint8_t *)queue->buffer + (queue->tail * queue->item_size);
+    const uint8_t *src = (const uint8_t *)item;
+    for (uint32_t i = 0U; i < queue->item_size; i++) {
+        dest[i] = src[i];
+    }
+    queue->tail = (queue->tail + 1U) % queue->size;
+    queue->count++;
+    return OSAL_OK;
+}''',
+            'queue_receive_nonrtos': '''OSAL_Status_t OSAL_Queue_Receive(OSAL_Queue_t *queue, void *item, uint32_t timeout_ms)
+{
+    (void)timeout_ms;
+    if ((queue == NULL) || (item == NULL)) {
+        return OSAL_ERROR;
+    }
+    if (queue->count == 0U) {
+        return OSAL_BUSY;
+    }
+    uint8_t *src = (uint8_t *)queue->buffer + (queue->head * queue->item_size);
+    uint8_t *dest = (uint8_t *)item;
+    for (uint32_t i = 0U; i < queue->item_size; i++) {
+        dest[i] = src[i];
+    }
+    queue->head = (queue->head + 1U) % queue->size;
+    queue->count--;
+    return OSAL_OK;
+}''',
+            'critical_enter_nonrtos': '''/* ===== Critical section: enter =====
+ *
+ * [!] STUB - must be implemented for your target.
+ *
+ * Called by the generated framework to prevent interrupts /
+ * preemption until OSAL_Critical_Exit() is called.  Must be
+ * nestable on platforms where the caller may re-enter.
+ *
+ * Implementation examples:
+ *   ARM Cortex-M : __asm__ volatile ("cpsid i" ::: "memory");
+ *   ARM Cortex-A : __asm__ volatile ("msr DAIFSet, #2" ::: "memory");
+ *   RISC-V       : __asm__ volatile ("csrsi mstatus, 8" ::: "memory");
+ *   FreeRTOS     : taskENTER_CRITICAL();
+ *
+ * See docs/OSAL_PORTING_GUIDE_ja.md for the OSAL contract. */
+void OSAL_Critical_Enter(void)
+{
+    /* TODO: implement for your target. */
+}''',
+            'critical_exit_nonrtos': '''/* ===== Critical section: exit =====
+ *
+ * [!] STUB - must be implemented for your target.
+ *
+ * Re-enables interrupts / preemption after a matching
+ * OSAL_Critical_Enter().  Must respect nesting depth if the
+ * platform requires it.
+ *
+ * Implementation examples:
+ *   ARM Cortex-M : __asm__ volatile ("cpsie i" ::: "memory");
+ *   ARM Cortex-A : __asm__ volatile ("msr DAIFClr, #2" ::: "memory");
+ *   RISC-V       : __asm__ volatile ("csrci mstatus, 8" ::: "memory");
+ *   FreeRTOS     : taskEXIT_CRITICAL();
+ *
+ * See docs/OSAL_PORTING_GUIDE_ja.md for the OSAL contract. */
+void OSAL_Critical_Exit(void)
+{
+    /* TODO: implement for your target. */
+}''',
+        },
+    }
+
+    SUPER_INCLUDE_TEMPLATES = {
+        'file_comment': '''/**
+ * @file    {filename}
+ * @brief   StaTable generated code super include
+ */''',
+        'guard_start': '#ifndef STATABLE_ALL_H\n#define STATABLE_ALL_H\n',
+        'common_section': '/* ---- Common headers ---- */',
+        'layer_section': '/* ---- Per-layer headers ---- */',
+        'project_section': '/* ---- Project headers ---- */',
+        'external_section': '/* ---- External includes (user-specified) ---- */',
+        'user_section': '/* ---- User-added includes ---- */',
+        'user_marker_start': '/* [[STABLE_USER_INCLUDES_START]] */',
+        'user_marker_end': '/* [[STABLE_USER_INCLUDES_END]] */',
+        'guard_end': '#endif /* STATABLE_ALL_H */',
+        'extern_var_section': '/* ---- Super loop variables (extern) ---- */',
+        'extern_context': 'extern SystemContext_t g_ctx;',
+        'extern_state': 'extern STATE_{layer}_t g_{layer}_state;',
+        'extern_state_nolayer': 'extern STATE_t g_state;',
+        'extern_func_section': '/* ---- Super loop functions ---- */',
+        'extern_init': 'void {project_name}_Init(void);',
+        'extern_run': 'void {project_name}_Run(void);',
+    }
+
+    # [v2.2.5 / gcc compile fix]
+    # Each layer's event processing is now wrapped in its own `{ ... }`
+    # scope, so `evt` (of type EVENT_<Layer>_t) does not conflict across
+    # layers. The variable name is kept as `evt` for readability.
+    SUPER_LOOP_TEMPLATES = {
+        'file_comment': '''/**
+ * @file    {project_name}_run.c
+ * @brief   State machine super loop
+ */''',
+        'include': '#include "statable_all.h"',
+        'context_var': 'SystemContext_t g_ctx;',
+        'state_var': 'STATE_{layer}_t g_{layer}_state;',
+        'state_var_nolayer': 'STATE_t g_state;',
+        'init_func_comment': '''/**
+ * @brief  State machine initialization
+ */''',
+        'init_func_signature': 'void {project_name}_Init(void)',
+        'init_func_open': '{',
+        'init_context': (
+            '    SystemContext_Init(&g_ctx);\n'
+            '    SystemContext_InitQueues(&g_ctx);'
+        ),
+        'init_state': '    g_{layer}_state = STATE_{layer}_{initial};',
+        'init_state_nolayer': '    g_state = STATE_{initial};',
+        'init_func_close': '}',
+        'run_func_comment': '''/**
+ * @brief  State machine main loop
+ */''',
+        'run_func_signature': 'void {project_name}_Run(void)',
+        'run_func_open': '{',
+        'run_while': '    while (1) {',
+        'run_block': '''        {{
+            EVENT_{layer}_t evt = StateMachine_GetNextEvent_{layer}(&g_ctx);
+            if (evt != EVENT_{layer}_NONE) {{
+                g_{layer}_state = StateMachine_Process_{layer}(g_{layer}_state, evt, &g_ctx);
+            }}
+        }}''',
+        'run_block_nolayer': '''        {
+            EVENT_t evt = StateMachine_GetNextEvent(&g_ctx);
+            if (evt != EVENT_NONE) {
+                g_state = StateMachine_Process(g_state, evt, &g_ctx);
+            }
+        }''',
+        'run_while_close': '    }',
+        'run_func_close': '}',
+    }

codegen/config.py

@@ -0,0 +1,167 @@
+# codegen/config.py
+"""
+Code generation settings management module
+Centralizes generation options
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+
+@dataclass
+class CodeGenerationConfig:
+    """Code generation settings"""
+    
+    # ===== Generation style =====
+    generation_style: str = "table_driven"  # table_driven / switch_case
+    
+    # Transition table style
+    table_type: str = "array"  # array / switch / dictionary
+    
+    # OS type
+    os_type: str = "non_rtos"  # non_rtos / freertos / threadx
+    
+    # ===== Naming convention =====
+    naming_prefix: str = ""
+    state_prefix: str = "STATE"
+    event_prefix: str = "EVENT"
+    flag_prefix: str = "FLAG"
+    
+    # ===== Debug log =====
+    enable_debug_logs: bool = True
+    enable_info_logs: bool = True
+    enable_error_logs: bool = True
+    
+    # ===== Comment generation =====
+    enable_comments: bool = True
+    enable_doxygen: bool = True
+    
+    # ===== Marker =====
+    enable_user_markers: bool = True
+    
+    # ===== Output settings =====
+    output_directory: str = ""
+    save_with_merge: bool = True
+    
+    # ===== Project settings =====
+    project_name: str = "MyProject"
+    
+    # ===== Folder structure =====
+    folder_structure: str = "by_type"       # flat / by_layer / by_type
+    include_dir_name: str = "include"
+    source_dir_name: str = "src"
+    common_dir_name: str = "common"
+    project_dir_name: str = "project"
+    
+    # ===== Super include =====
+    generate_super_include: bool = True
+    super_include_file: str = "statable_all.h"
+    super_include_dir: str = "common"
+    
+    # ===== External include =====
+    external_includes: List[str] = field(default_factory=list)
+    external_includes_in_super: bool = True
+    external_includes_in_role: bool = True
+    external_includes_in_transitions: bool = False
+    external_includes_in_common: bool = False
+    
+    # ===== Reserved event limit =====
+    max_consecutive_pending_events: int = 16
+    
+    def to_dict(self) -> Dict:
+        """Convert to dictionary"""
+        return {
+            'generation_style': self.generation_style,
+            'table_type': self.table_type,
+            'os_type': self.os_type,
+            'naming_prefix': self.naming_prefix,
+            'state_prefix': self.state_prefix,
+            'event_prefix': self.event_prefix,
+            'flag_prefix': self.flag_prefix,
+            'enable_debug_logs': self.enable_debug_logs,
+            'enable_info_logs': self.enable_info_logs,
+            'enable_error_logs': self.enable_error_logs,
+            'enable_comments': self.enable_comments,
+            'enable_doxygen': self.enable_doxygen,
+            'enable_user_markers': self.enable_user_markers,
+            'output_directory': self.output_directory,
+            'save_with_merge': self.save_with_merge,
+            'project_name': self.project_name,
+            'folder_structure': self.folder_structure,
+            'include_dir_name': self.include_dir_name,
+            'source_dir_name': self.source_dir_name,
+            'common_dir_name': self.common_dir_name,
+            'project_dir_name': self.project_dir_name,
+            'generate_super_include': self.generate_super_include,
+            'super_include_file': self.super_include_file,
+            'super_include_dir': self.super_include_dir,
+            'external_includes': self.external_includes,
+            'external_includes_in_super': self.external_includes_in_super,
+            'external_includes_in_role': self.external_includes_in_role,
+            'external_includes_in_transitions': self.external_includes_in_transitions,
+            'external_includes_in_common': self.external_includes_in_common,
+            'max_consecutive_pending_events': self.max_consecutive_pending_events,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'CodeGenerationConfig':
+        """Restore from dictionary"""
+        # Ignore unknown keys
+        valid_keys = {f.name for f in cls.__dataclass_fields__.values()}
+        filtered = {k: v for k, v in data.items() if k in valid_keys}
+        return cls(**filtered)
+
+
+class ConfigManager:
+    """Settings management class"""
+    
+    def __init__(self):
+        self._config = CodeGenerationConfig()
+    
+    def get_config(self) -> CodeGenerationConfig:
+        """Get current settings"""
+        return self._config
+    
+    def set_config(self, config: CodeGenerationConfig):
+        """Update settings"""
+        self._config = config
+    
+    def update(self, **kwargs):
+        """Partially update settings"""
+        for key, value in kwargs.items():
+            if hasattr(self._config, key):
+                setattr(self._config, key, value)
+    
+    def reset(self):
+        """Reset settings"""
+        self._config = CodeGenerationConfig()
+    
+    def get_available_styles(self) -> Dict[str, str]:
+        """Available generation styles"""
+        return {
+            'table_driven': 'Table-driven style',
+            'switch_case': 'switch-case style',
+        }
+    
+    def get_available_table_types(self) -> Dict[str, str]:
+        """Available table styles"""
+        return {
+            'array': 'Array style',
+            'switch': 'switch-case style',
+            'dictionary': 'Dictionary style (deprecated)',
+        }
+    
+    def get_available_os_types(self) -> Dict[str, str]:
+        """Available OS types"""
+        return {
+            'non_rtos': 'NonRTOS (bare metal)',
+            'freertos': 'FreeRTOS',
+            'threadx': 'ThreadX',
+        }
+    
+    def get_available_folder_structures(self) -> Dict[str, str]:
+        return {
+            'flat': 'Flat',
+            'by_layer': 'Per layer',
+            'by_type': 'include/src separation',
+        }