time-assurance-code-scanner 0.2.0rc2__py3-none-any.whl

config_detector/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2026 Y2038.com LLC
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Auto-Detection Configuration Utility
+
+A separate Python utility that analyzes build systems and outputs likelihood scores
+for all eight possible environment configurations.
+"""
+
+__version__ = "1.0.0"

config_detector/analyzers/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2026 Y2038.com LLC
+# SPDX-License-Identifier: Apache-2.0
+
+"""Analyzers for detecting architecture, time_t configuration, and C library."""
+
+from .architecture import ArchitectureDetector
+from .time_t_config import TimeTConfigDetector
+
+__all__ = ['ArchitectureDetector', 'TimeTConfigDetector']

config_detector/analyzers/architecture.py

@@ -0,0 +1,188 @@
+# Copyright (c) 2026 Y2038.com LLC
+# SPDX-License-Identifier: Apache-2.0
+
+"""Architecture detection analyzer (ILP32 vs LP64)."""
+
+import re
+from typing import Dict, Tuple, Optional, List
+from dataclasses import dataclass
+
+
+@dataclass
+class ArchitectureEvidence:
+    """Evidence for architecture detection."""
+    source: str  # "makefile", "cmake", "toolchain", etc.
+    indicator: str  # What was detected
+    architecture: str  # "ILP32" or "LP64"
+    confidence: float  # 0.0 to 1.0
+
+
+class ArchitectureDetector:
+    """Detects hardware architecture (ILP32 vs LP64) from build system information."""
+    
+    def __init__(self):
+        """Initialize the architecture detector."""
+        pass
+    
+    def detect(self, extracted_info: Dict) -> Tuple[Optional[str], float, List[ArchitectureEvidence]]:
+        """
+        Detect architecture from extracted build system information.
+        
+        Args:
+            extracted_info: Dictionary from build parser with 'cflags', 'defines', 
+                          'variables', 'toolchain'
+        
+        Returns:
+            Tuple of (architecture, confidence, evidence_list)
+            - architecture: "ILP32", "LP64", or None if uncertain
+            - confidence: 0.0 to 1.0
+            - evidence_list: List of ArchitectureEvidence objects
+        """
+        evidence: List[ArchitectureEvidence] = []
+        
+        cflags = extracted_info.get('cflags', [])
+        variables = extracted_info.get('variables', {})
+        toolchain = extracted_info.get('toolchain', '')
+        
+        # Check explicit architecture flags (highest confidence)
+        for flag in cflags:
+            if flag == '-m32':
+                evidence.append(ArchitectureEvidence(
+                    source='compiler_flag',
+                    indicator='-m32',
+                    architecture='ILP32',
+                    confidence=0.95
+                ))
+            elif flag == '-m64':
+                evidence.append(ArchitectureEvidence(
+                    source='compiler_flag',
+                    indicator='-m64',
+                    architecture='LP64',
+                    confidence=0.95
+                ))
+            elif flag.startswith('-march='):
+                arch = self._parse_march(flag)
+                if arch:
+                    evidence.append(ArchitectureEvidence(
+                        source='compiler_flag',
+                        indicator=flag,
+                        architecture=arch[0],
+                        confidence=arch[1]
+                    ))
+        
+        # Check toolchain (medium-high confidence)
+        if toolchain:
+            arch = self._parse_toolchain(toolchain)
+            if arch:
+                evidence.append(ArchitectureEvidence(
+                    source='toolchain',
+                    indicator=toolchain,
+                    architecture=arch[0],
+                    confidence=arch[1]
+                ))
+        
+        # Check CMAKE_SYSTEM_PROCESSOR (medium confidence)
+        if 'CMAKE_SYSTEM_PROCESSOR' in variables:
+            processor = variables['CMAKE_SYSTEM_PROCESSOR'].lower()
+            arch = self._parse_processor(processor)
+            if arch:
+                evidence.append(ArchitectureEvidence(
+                    source='cmake',
+                    indicator=f'CMAKE_SYSTEM_PROCESSOR={processor}',
+                    architecture=arch[0],
+                    confidence=arch[1]
+                ))
+        
+        # Determine final architecture and confidence
+        if not evidence:
+            return None, 0.0, []
+        
+        # Count evidence for each architecture
+        ilp32_evidence = [e for e in evidence if e.architecture == 'ILP32']
+        lp64_evidence = [e for e in evidence if e.architecture == 'LP64']
+        
+        # If conflicting evidence, use highest confidence
+        if ilp32_evidence and lp64_evidence:
+            ilp32_max = max(e.confidence for e in ilp32_evidence)
+            lp64_max = max(e.confidence for e in lp64_evidence)
+            
+            if ilp32_max > lp64_max:
+                return 'ILP32', ilp32_max * 0.9, evidence  # Slightly reduce due to conflict
+            else:
+                return 'LP64', lp64_max * 0.9, evidence
+        elif ilp32_evidence:
+            max_conf = max(e.confidence for e in ilp32_evidence)
+            return 'ILP32', max_conf, evidence
+        elif lp64_evidence:
+            max_conf = max(e.confidence for e in lp64_evidence)
+            return 'LP64', max_conf, evidence
+        
+        return None, 0.0, evidence
+    
+    def _parse_march(self, flag: str) -> Optional[Tuple[str, float]]:
+        """Parse -march= flag to determine architecture."""
+        match = re.search(r'-march=([\w-]+)', flag)
+        if not match:
+            return None
+        
+        arch_str = match.group(1).lower()
+        
+        # ILP32 indicators
+        if any(x in arch_str for x in ['armv7', 'armv6', 'armv5', 'armv4']):
+            return ('ILP32', 0.85)
+        if arch_str in ['i386', 'i686']:
+            return ('ILP32', 0.85)
+        
+        # LP64 indicators
+        if arch_str in ['x86_64', 'amd64']:
+            return ('LP64', 0.95)
+        if 'armv8' in arch_str or 'aarch64' in arch_str:
+            return ('LP64', 0.90)
+        if arch_str.startswith('mips64'):
+            return ('LP64', 0.85)
+        
+        return None
+    
+    def _parse_toolchain(self, toolchain: str) -> Optional[Tuple[str, float]]:
+        """Parse toolchain name to determine architecture."""
+        toolchain_lower = toolchain.lower()
+        
+        # ILP32 toolchains
+        if 'arm-none-eabi' in toolchain_lower or 'arm-eabi' in toolchain_lower:
+            return ('ILP32', 0.85)
+        if toolchain_lower.startswith('arm-'):
+            return ('ILP32', 0.80)
+        if 'mips32' in toolchain_lower:
+            return ('ILP32', 0.80)
+        
+        # LP64 toolchains
+        if 'aarch64' in toolchain_lower:
+            return ('LP64', 0.90)
+        if 'x86_64' in toolchain_lower or 'amd64' in toolchain_lower:
+            return ('LP64', 0.90)
+        if 'mips64' in toolchain_lower:
+            return ('LP64', 0.85)
+        
+        return None
+    
+    def _parse_processor(self, processor: str) -> Optional[Tuple[str, float]]:
+        """Parse CMAKE_SYSTEM_PROCESSOR to determine architecture."""
+        processor_lower = processor.lower()
+        
+        # ILP32 processors
+        if processor_lower in ['arm', 'armv7', 'armv6', 'armv5']:
+            return ('ILP32', 0.80)
+        if processor_lower in ['i386', 'i686']:
+            return ('ILP32', 0.80)
+        if 'mips32' in processor_lower:
+            return ('ILP32', 0.75)
+        
+        # LP64 processors
+        if processor_lower in ['aarch64', 'arm64', 'armv8']:
+            return ('LP64', 0.85)
+        if processor_lower in ['x86_64', 'amd64']:
+            return ('LP64', 0.90)
+        if 'mips64' in processor_lower:
+            return ('LP64', 0.80)
+        
+        return None

config_detector/analyzers/time_t_config.py

@@ -0,0 +1,183 @@
+# Copyright (c) 2026 Y2038.com LLC
+# SPDX-License-Identifier: Apache-2.0
+
+"""time_t configuration detection analyzer."""
+
+import re
+from typing import Dict, Tuple, Optional, List
+from dataclasses import dataclass
+
+
+@dataclass
+class TimeTEvidence:
+    """Evidence for time_t configuration detection."""
+    source: str  # "makefile", "cmake", etc.
+    indicator: str  # What was detected
+    time_t_size: Optional[int] = None  # 32 or 64, or None
+    time_t_signed: Optional[str] = None  # "signed" or "unsigned" or None
+    confidence: float = 0.0  # 0.0 to 1.0
+
+
+class TimeTConfigDetector:
+    """Detects time_t size and signedness configuration from build system information."""
+    
+    def __init__(self):
+        """Initialize the time_t config detector."""
+        pass
+    
+    def detect(self, extracted_info: Dict, architecture: Optional[str] = None) -> Tuple[Optional[int], float, Optional[str], float, List[TimeTEvidence]]:
+        """
+        Detect time_t size and signedness from extracted build system information.
+        
+        Args:
+            extracted_info: Dictionary from build parser
+            architecture: Detected architecture (ILP32 or LP64) for inference
+        
+        Returns:
+            Tuple of (time_t_size, time_t_size_confidence, time_t_signed, time_t_signed_confidence, evidence_list)
+            - time_t_size: 32, 64, or None if uncertain
+            - time_t_size_confidence: 0.0 to 1.0
+            - time_t_signed: "signed" or "unsigned" or None if uncertain
+            - time_t_signed_confidence: 0.0 to 1.0
+            - evidence_list: List of TimeTEvidence objects
+        """
+        evidence: List[TimeTEvidence] = []
+        
+        defines = extracted_info.get('defines', [])
+        cflags = extracted_info.get('cflags', [])
+        
+        # Check for explicit _TIME_BITS define (highest confidence)
+        time_bits_value = None
+        for define in defines:
+            if define.startswith('TIME_BITS='):
+                time_bits_value = define.split('=')[1]
+            elif define == 'TIME_BITS':
+                # Check cflags for -D_TIME_BITS=64
+                for flag in cflags:
+                    match = re.search(r'-D_TIME_BITS=(\d+)', flag)
+                    if match:
+                        time_bits_value = match.group(1)
+                        break
+        
+        # Also check cflags directly
+        for flag in cflags:
+            match = re.search(r'-D_TIME_BITS=(\d+)', flag)
+            if match:
+                time_bits_value = match.group(1)
+                evidence.append(TimeTEvidence(
+                    source='compiler_flag',
+                    indicator=f'-D_TIME_BITS={time_bits_value}',
+                    time_t_size=int(time_bits_value),
+                    confidence=0.95
+                ))
+                break
+        
+        # Detect time_t signedness
+        time_t_signed = None
+        time_t_signed_confidence = 0.0
+        
+        # Check for explicit unsigned time_t defines
+        for define in defines:
+            if 'TIME_T_UNSIGNED' in define.upper() or 'CONFIG_TIME_T_UNSIGNED' in define.upper():
+                time_t_signed = 'unsigned'
+                time_t_signed_confidence = 0.85
+                evidence.append(TimeTEvidence(
+                    source='define',
+                    indicator=define,
+                    time_t_signed='unsigned',
+                    confidence=0.85
+                ))
+                break
+        
+        # Check cflags for unsigned time_t
+        for flag in cflags:
+            if '-D_TIME_T_UNSIGNED' in flag or '-DCONFIG_TIME_T_UNSIGNED' in flag:
+                time_t_signed = 'unsigned'
+                time_t_signed_confidence = 0.85
+                evidence.append(TimeTEvidence(
+                    source='compiler_flag',
+                    indicator=flag,
+                    time_t_signed='unsigned',
+                    confidence=0.85
+                ))
+                break
+        
+        # Infer signedness from library (if we can detect it)
+        # Most standard libraries (glibc, musl) use signed by default
+        # Some embedded libraries (Zephyr, picolibc) may use unsigned
+        # For now, default to signed if not explicitly detected
+        if time_t_signed is None:
+            # Default to signed (most common), but with low confidence
+            time_t_signed = 'signed'
+            time_t_signed_confidence = 0.5  # Low confidence default
+        
+        if time_bits_value:
+            # Add signedness to evidence if not already added
+            if time_t_signed and not any(e.time_t_signed == time_t_signed for e in evidence):
+                evidence.append(TimeTEvidence(
+                    source='default',
+                    indicator=f'Default {time_t_signed} (not explicitly detected)',
+                    time_t_signed=time_t_signed,
+                    confidence=time_t_signed_confidence
+                ))
+            return int(time_bits_value), 0.95, time_t_signed, time_t_signed_confidence, evidence
+        
+        # Check for _FILE_OFFSET_BITS=64 (hint for 64-bit time_t)
+        for flag in cflags:
+            if '-D_FILE_OFFSET_BITS=64' in flag:
+                evidence.append(TimeTEvidence(
+                    source='compiler_flag',
+                    indicator='-D_FILE_OFFSET_BITS=64',
+                    time_t_size=64,
+                    time_t_signed=time_t_signed,
+                    confidence=0.60  # Lower confidence, just a hint
+                ))
+        
+        # Infer from architecture if no explicit flags
+        if architecture:
+            if architecture == 'LP64':
+                # LP64 typically uses 64-bit time_t by default
+                # Add signedness to evidence if not already added
+                if time_t_signed and not any(e.time_t_signed == time_t_signed for e in evidence):
+                    evidence.append(TimeTEvidence(
+                        source='default',
+                        indicator=f'Default {time_t_signed} (not explicitly detected)',
+                        time_t_signed=time_t_signed,
+                        confidence=time_t_signed_confidence
+                    ))
+                evidence.append(TimeTEvidence(
+                    source='architecture_inference',
+                    indicator=f'LP64 architecture (default 64-bit time_t)',
+                    time_t_size=64,
+                    time_t_signed=time_t_signed,
+                    confidence=0.70
+                ))
+                return 64, 0.70, time_t_signed, time_t_signed_confidence, evidence
+            elif architecture == 'ILP32':
+                # ILP32 typically uses 32-bit time_t by default (unless explicitly set)
+                # Add signedness to evidence if not already added
+                if time_t_signed and not any(e.time_t_signed == time_t_signed for e in evidence):
+                    evidence.append(TimeTEvidence(
+                        source='default',
+                        indicator=f'Default {time_t_signed} (not explicitly detected)',
+                        time_t_signed=time_t_signed,
+                        confidence=time_t_signed_confidence
+                    ))
+                evidence.append(TimeTEvidence(
+                    source='architecture_inference',
+                    indicator=f'ILP32 architecture (default 32-bit time_t)',
+                    time_t_size=32,
+                    time_t_signed=time_t_signed,
+                    confidence=0.65
+                ))
+                return 32, 0.65, time_t_signed, time_t_signed_confidence, evidence
+        
+        # No evidence found - still return signedness defaults
+        if time_t_signed and not any(e.time_t_signed == time_t_signed for e in evidence):
+            evidence.append(TimeTEvidence(
+                source='default',
+                indicator=f'Default {time_t_signed} (not explicitly detected)',
+                time_t_signed=time_t_signed,
+                confidence=time_t_signed_confidence
+            ))
+        return None, 0.0, time_t_signed, time_t_signed_confidence, evidence

config_detector/build_parsers/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2026 Y2038.com LLC
+# SPDX-License-Identifier: Apache-2.0
+
+"""Build system parsers for extracting compiler flags and configuration."""
+
+from .base import BaseParser
+from .makefile import MakefileParser
+from .cmake import CMakeParser
+
+__all__ = ['BaseParser', 'MakefileParser', 'CMakeParser']

config_detector/build_parsers/base.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2026 Y2038.com LLC
+# SPDX-License-Identifier: Apache-2.0
+
+"""Base parser interface for build system files."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import List, Dict, Set
+
+
+class BaseParser(ABC):
+    """Base class for build system parsers."""
+    
+    def __init__(self, root_path: Path):
+        """
+        Initialize parser.
+        
+        Args:
+            root_path: Root directory of the project
+        """
+        self.root_path = root_path
+    
+    @abstractmethod
+    def find_build_files(self) -> List[Path]:
+        """
+        Find relevant build system files.
+        
+        Returns:
+            List of paths to build files
+        """
+        pass
+    
+    @abstractmethod
+    def extract_flags(self, build_file: Path) -> Dict[str, any]:
+        """
+        Extract compiler flags and configuration from a build file.
+        
+        Args:
+            build_file: Path to the build file
+            
+        Returns:
+            Dictionary with extracted information:
+            - 'cflags': List of C compiler flags
+            - 'defines': List of -D defines
+            - 'variables': Dictionary of variable assignments
+            - 'toolchain': Toolchain information if found
+        """
+        pass
+    
+    def extract_all(self) -> Dict[str, any]:
+        """
+        Extract all information from all build files.
+        
+        Returns:
+            Combined dictionary with all extracted information
+        """
+        build_files = self.find_build_files()
+        
+        all_cflags: Set[str] = set()
+        all_defines: Set[str] = set()
+        all_variables: Dict[str, str] = {}
+        toolchain: str = ""
+        
+        for build_file in build_files:
+            try:
+                extracted = self.extract_flags(build_file)
+                all_cflags.update(extracted.get('cflags', []))
+                all_defines.update(extracted.get('defines', []))
+                all_variables.update(extracted.get('variables', {}))
+                if extracted.get('toolchain') and not toolchain:
+                    toolchain = extracted.get('toolchain')
+            except Exception as e:
+                # Continue if one file fails
+                continue
+        
+        return {
+            'cflags': list(all_cflags),
+            'defines': list(all_defines),
+            'variables': all_variables,
+            'toolchain': toolchain,
+            'build_files_found': len(build_files)
+        }

config_detector/build_parsers/cmake.py

@@ -0,0 +1,113 @@
+# Copyright (c) 2026 Y2038.com LLC
+# SPDX-License-Identifier: Apache-2.0
+
+"""CMake parser for extracting compiler flags and configuration."""
+
+import re
+from pathlib import Path
+from typing import Dict, List, Set
+from .base import BaseParser
+
+
+class CMakeParser(BaseParser):
+    """Parser for CMake build systems."""
+    
+    def find_build_files(self) -> List[Path]:
+        """Find CMakeLists.txt files in the project."""
+        build_files = []
+        seen_files = set()
+        
+        # Check root directory first
+        cmake_file = self.root_path / 'CMakeLists.txt'
+        if cmake_file.exists():
+            build_files.append(cmake_file)
+            seen_files.add(cmake_file)
+        
+        # Search for CMakeLists.txt in subdirectories (limit depth)
+        for cmake_file in self.root_path.rglob('CMakeLists.txt'):
+            if cmake_file.is_file() and cmake_file not in seen_files:
+                # Limit to reasonable depth and common locations
+                rel_path = cmake_file.relative_to(self.root_path)
+                if len(rel_path.parts) <= 4:  # Max 4 levels deep
+                    build_files.append(cmake_file)
+                    seen_files.add(cmake_file)
+        
+        return build_files[:10]  # Limit to first 10
+    
+    def extract_flags(self, build_file: Path) -> Dict[str, any]:
+        """
+        Extract compiler flags from a CMakeLists.txt file.
+        
+        Looks for:
+        - add_definitions(), add_compile_definitions()
+        - set(CMAKE_C_FLAGS ...)
+        - set(CMAKE_SYSTEM_PROCESSOR ...)
+        - find_package() calls
+        """
+        try:
+            content = build_file.read_text(encoding='utf-8', errors='ignore')
+        except Exception:
+            return {'cflags': [], 'defines': [], 'variables': {}, 'toolchain': ''}
+        
+        cflags: Set[str] = set()
+        defines: Set[str] = set()
+        variables: Dict[str, str] = {}
+        toolchain = ""
+        
+        # Pattern for set() commands: set(VAR value) or set(VAR "value")
+        set_pattern = re.compile(r'set\s*\(\s*(\w+)\s+(.+?)\s*\)', re.IGNORECASE | re.DOTALL)
+        
+        # Pattern for add_definitions: add_definitions(-DFOO -DBAR=value)
+        def_pattern = re.compile(r'add_(?:compile_)?definitions\s*\((.+?)\)', re.IGNORECASE | re.DOTALL)
+        
+        # Pattern for CMAKE_SYSTEM_PROCESSOR
+        processor_pattern = re.compile(r'CMAKE_SYSTEM_PROCESSOR', re.IGNORECASE)
+        
+        # Extract set() variables
+        for match in set_pattern.finditer(content):
+            var_name = match.group(1).upper()
+            var_value = match.group(2).strip()
+            
+            # Remove quotes
+            var_value = re.sub(r'^["\']|["\']$', '', var_value)
+            # Remove comments
+            var_value = re.sub(r'#.*$', '', var_value).strip()
+            
+            variables[var_name] = var_value
+            
+            # Extract flags from CMAKE_C_FLAGS, etc.
+            if 'CMAKE_C_FLAGS' in var_name or 'CMAKE_CXX_FLAGS' in var_name:
+                flags = var_value.split()
+                for flag in flags:
+                    flag = flag.strip()
+                    if flag:
+                        cflags.add(flag)
+            
+            # Extract CMAKE_SYSTEM_PROCESSOR
+            if var_name == 'CMAKE_SYSTEM_PROCESSOR':
+                variables['CMAKE_SYSTEM_PROCESSOR'] = var_value
+            
+            # Extract toolchain from CMAKE_C_COMPILER
+            if var_name == 'CMAKE_C_COMPILER' and not toolchain:
+                toolchain_match = re.match(r'^([\w-]+)-gcc', var_value)
+                if toolchain_match:
+                    toolchain = toolchain_match.group(1)
+        
+        # Extract add_definitions
+        for match in def_pattern.finditer(content):
+            defs_str = match.group(1)
+            # Extract -D defines
+            define_matches = re.finditer(r'-D(\w+(?:=\w+)?)', defs_str)
+            for def_match in define_matches:
+                defines.add(def_match.group(1))
+        
+        # Look for find_package(Zephyr) or similar
+        if re.search(r'find_package\s*\(\s*Zephyr', content, re.IGNORECASE):
+            variables['ZEPHYR'] = 'true'
+        
+        return {
+            'cflags': list(cflags),
+            'defines': list(defines),
+            'variables': variables,
+            'toolchain': toolchain
+        }