statable 3.1.0__py3-none-any.whl

codegen/validate/items/variable_validator.py

@@ -0,0 +1,132 @@
+# codegen/validate/items/variable_validator.py
+"""\nVariable validation\n"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class VariableValidator(BaseValidator):
+    """Variable validation class"""
+    
+    category = "variable"
+    
+    def __init__(self):
+        logger.debug("VariableValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'VAR_DUPLICATE_NAME': self._check_duplicate_names,
+            'VAR_INVALID_TYPE': self._check_invalid_type,
+            'VAR_INVALID_ARRAY_SIZE': self._check_invalid_array_size,
+        }
+        logger.debug(f"VariableValidator.__init__ completed: {len(self.rules)} rules")
+    
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug(f"VariableValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        return issues
+    
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=kwargs.get('name', ''),
+        )
+    
+    def _check_duplicate_names(self, context):
+        issues = []
+        seen = set()
+        for var in context.variables:
+            name = getattr(var, 'name', '')
+            if name in seen:
+                issues.append(self._create_issue('VAR_DUPLICATE_NAME', name=name))
+            else:
+                seen.add(name)
+        return issues
+    
+    def _check_invalid_type(self, context):
+        """[v2.7.2 fix] Accept stdint.h types and strip qualifiers.
+
+        Previous behavior:
+          - 'uint32_t' / 'uint8_t' were flagged (only legacy aliases
+            'uint32' / 'uint8' were in the set)
+          - 'volatile uint32_t' was flagged
+        """
+        issues = []
+        basic_types = {
+            # Plain C
+            'int', 'short', 'long', 'unsigned', 'signed',
+            'float', 'double', 'bool', 'char', 'string', 'void',
+            # stdint.h (C99)
+            'int8_t', 'int16_t', 'int32_t', 'int64_t',
+            'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t',
+            'intptr_t', 'uintptr_t', 'size_t',
+            # Legacy aliases (without _t)
+            'int8', 'int16', 'int32', 'int64',
+            'uint', 'uint8', 'uint16', 'uint32', 'uint64',
+        }
+        qualifiers = {
+            'volatile', 'const', 'static', 'register',
+            'extern', 'inline', 'unsigned', 'signed',
+            'long', 'short',
+        }
+
+        def normalize(t: str) -> str:
+            parts = (t or '').strip().split()
+            base = [p for p in parts if p not in qualifiers]
+            return ' '.join(base) if base else (t or '').strip()
+
+        def strip_extras(t: str) -> str:
+            t = t.rstrip('*').strip()
+            t = t.split('[')[0].strip()
+            return t
+
+        custom_type_names = {
+            getattr(ct, 'name', '') for ct in context.custom_types
+        }
+        for var in context.variables:
+            var_type = getattr(var, 'type', '') or ''
+            name = getattr(var, 'name', '')
+            if not var_type:
+                continue
+            normalized = normalize(var_type)
+            candidates = {
+                var_type, normalized,
+                strip_extras(var_type), strip_extras(normalized),
+            }
+            if candidates & basic_types:
+                continue
+            if candidates & custom_type_names:
+                continue
+            issues.append(self._create_issue(
+                'VAR_INVALID_TYPE', name=name, type=var_type))
+        return issues
+    
+    def _check_invalid_array_size(self, context):
+        issues = []
+        for var in context.variables:
+            array_size = getattr(var, 'array_size', 0)
+            name = getattr(var, 'name', '')
+            if array_size < 0:
+                issues.append(self._create_issue('VAR_INVALID_ARRAY_SIZE', name=name))
+        return issues

codegen/validate/logger.py

@@ -0,0 +1,52 @@
+# codegen/validate/logger.py
+"""\nLogger setup for validation module\n"""
+
+import logging
+import os
+from datetime import datetime
+
+
+def setup_logger(name: str = "validate", log_dir: str = None) -> logging.Logger:
+    """Setup logger"""
+    logger = logging.getLogger(name)
+    
+    if logger.handlers:
+        return logger
+    
+    logger.setLevel(logging.DEBUG)
+    
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.DEBUG)
+    console_format = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - [%(funcName)s:%(lineno)d] - %(message)s',
+        datefmt='%H:%M:%S'
+    )
+    console_handler.setFormatter(console_format)
+    logger.addHandler(console_handler)
+    
+    # File handler
+    if log_dir is None:
+        log_dir = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+            'logs'
+        )
+    
+    os.makedirs(log_dir, exist_ok=True)
+    
+    log_file = os.path.join(log_dir, f'validate_{datetime.now().strftime("%Y%m%d")}.log')
+    file_handler = logging.FileHandler(log_file, encoding='utf-8')
+    file_handler.setLevel(logging.DEBUG)
+    file_format = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - [%(funcName)s:%(lineno)d] - %(message)s'
+    )
+    file_handler.setFormatter(file_format)
+    logger.addHandler(file_handler)
+    
+    logger.debug(f"Logger setup completed: {name} -> {log_file}")
+    return logger
+
+
+# Default logger
+validate_logger = setup_logger()
+logger = validate_logger

codegen/validate/models.py

@@ -0,0 +1,177 @@
+# codegen/validate/models.py
+"""\nValidation data model definitions\n"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Dict, Any, Optional
+
+
+class ValidationSeverity(Enum):
+    """Validation severity"""
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+    
+    @classmethod
+    def from_string(cls, value: str) -> 'ValidationSeverity':
+        """Convert from string"""
+        value_map = {
+            'error': cls.ERROR,
+            'warning': cls.WARNING,
+            'info': cls.INFO,
+            'ERROR': cls.ERROR,
+            'WARNING': cls.WARNING,
+            'INFO': cls.INFO,
+            'Error': cls.ERROR,
+            'Warning': cls.WARNING,
+            'Info': cls.INFO,
+        }
+        return value_map.get(value, cls.INFO)
+
+
+@dataclass
+class ValidationIssue:
+    """Validation issue"""
+    category: str
+    code: str
+    message: str
+    severity: ValidationSeverity
+    target: str = ""
+    suggestion: str = ""
+    details: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict:
+        """Convert to dictionary"""
+        return {
+            'category': self.category,
+            'code': self.code,
+            'message': self.message,
+            'severity': self.severity.value,
+            'target': self.target,
+            'suggestion': self.suggestion,
+            'details': self.details,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'ValidationIssue':
+        """Restore from dictionary"""
+        return cls(
+            category=data.get('category', ''),
+            code=data.get('code', ''),
+            message=data.get('message', ''),
+            severity=ValidationSeverity.from_string(data.get('severity', 'info')),
+            target=data.get('target', ''),
+            suggestion=data.get('suggestion', ''),
+            details=data.get('details', {}),
+        )
+    
+    def __str__(self) -> str:
+        return f"[{self.severity.value.upper()}] {self.category}: {self.message}"
+
+
+@dataclass
+class ValidationResult:
+    """Validation result"""
+    issues: List[ValidationIssue] = field(default_factory=list)
+    
+    @property
+    def passed(self) -> bool:
+        return self.error_count == 0
+    
+    @property
+    def error_count(self) -> int:
+        return sum(1 for i in self.issues if i.severity == ValidationSeverity.ERROR)
+    
+    @property
+    def warning_count(self) -> int:
+        return sum(1 for i in self.issues if i.severity == ValidationSeverity.WARNING)
+    
+    @property
+    def info_count(self) -> int:
+        return sum(1 for i in self.issues if i.severity == ValidationSeverity.INFO)
+    
+    def get_errors(self) -> List[ValidationIssue]:
+        return [i for i in self.issues if i.severity == ValidationSeverity.ERROR]
+    
+    def get_warnings(self) -> List[ValidationIssue]:
+        return [i for i in self.issues if i.severity == ValidationSeverity.WARNING]
+    
+    def get_infos(self) -> List[ValidationIssue]:
+        return [i for i in self.issues if i.severity == ValidationSeverity.INFO]
+    
+    def get_by_category(self, category: str) -> List[ValidationIssue]:
+        return [i for i in self.issues if i.category == category]
+    
+    def to_dict(self) -> Dict:
+        return {
+            'passed': self.passed,
+            'error_count': self.error_count,
+            'warning_count': self.warning_count,
+            'info_count': self.info_count,
+            'issues': [i.to_dict() for i in self.issues],
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'ValidationResult':
+        return cls(
+            issues=[ValidationIssue.from_dict(i) for i in data.get('issues', [])]
+        )
+    
+    def __str__(self) -> str:
+        return (f"ValidationResult(errors={self.error_count}, "
+                f"warnings={self.warning_count}, infos={self.info_count})")
+
+
+@dataclass
+class ValidationContext:
+    """Validation context"""
+    state_machine: Any = None
+    global_defs: Any = None
+    
+    @property
+    def states(self) -> Dict:
+        return self.state_machine.states if self.state_machine else {}
+    
+    @property
+    def events(self) -> Dict:
+        return self.state_machine.events if self.state_machine else {}
+    
+    @property
+    def transitions(self) -> List:
+        return self.state_machine.transitions if self.state_machine else []
+    
+    @property
+    def role_functions(self) -> Dict:
+        return self.state_machine.role_functions if self.state_machine else {}
+    
+    @property
+    def initial_state(self) -> Optional[str]:
+        return self.state_machine.initial_state if self.state_machine else None
+    
+    @property
+    def variables(self) -> List:
+        return self.global_defs.variables if self.global_defs else []
+    
+    @property
+    def flags(self) -> List:
+        return self.global_defs.flags if self.global_defs else []
+    
+    @property
+    def event_queues(self) -> List:
+        return self.global_defs.event_queues if self.global_defs else []
+    
+    @property
+    def interrupts(self) -> List:
+        return self.global_defs.interrupts if self.global_defs else []
+    
+    @property
+    def custom_types(self) -> List:
+        return self.global_defs.custom_types if self.global_defs else []
+    
+    @property
+    def timer_base(self):
+        return self.global_defs.timer_base if self.global_defs else None
+    
+    @property
+    def extra_timers(self) -> List:
+        return self.global_defs.extra_timers if self.global_defs else []