fbuild 1.2.8__py3-none-any.whl

fbuild/build/flag_builder.py

@@ -0,0 +1,214 @@
+"""Compilation Flag Builder.
+
+This module handles parsing and building compilation flags from platform
+configuration files.
+
+Design:
+    - Parses flag strings with proper handling of quoted values
+    - Builds flags from configuration dictionaries
+    - Adds platform-specific defines (Arduino, ESP32, etc.)
+    - Merges user build flags from platformio.ini
+"""
+
+import shlex
+from typing import List, Dict, Any, Optional
+
+
+class FlagBuilderError(Exception):
+    """Raised when flag building operations fail."""
+    pass
+
+
+class FlagBuilder:
+    """Builds compilation flags from configuration.
+
+    This class handles:
+    - Parsing flag strings with quoted values
+    - Building flags from platform config
+    - Adding platform-specific defines
+    - Merging user build flags
+    """
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        board_config: Dict[str, Any],
+        board_id: str,
+        variant: str,
+        user_build_flags: Optional[List[str]] = None
+    ):
+        """Initialize flag builder.
+
+        Args:
+            config: Platform configuration dictionary
+            board_config: Board-specific configuration
+            board_id: Board identifier (e.g., "esp32-c6-devkitm-1")
+            variant: Board variant name
+            user_build_flags: Build flags from platformio.ini
+        """
+        self.config = config
+        self.board_config = board_config
+        self.board_id = board_id
+        self.variant = variant
+        self.user_build_flags = user_build_flags or []
+
+    @staticmethod
+    def parse_flag_string(flag_string: str) -> List[str]:
+        """Parse a flag string that may contain quoted values.
+
+        Args:
+            flag_string: String containing compiler flags
+
+        Returns:
+            List of individual flags with quotes preserved
+
+        Example:
+            >>> FlagBuilder.parse_flag_string('-DFOO="bar baz" -DTEST')
+            ['-DFOO="bar baz"', '-DTEST']
+        """
+        try:
+            return shlex.split(flag_string)
+        except KeyboardInterrupt as ke:
+            from fbuild.interrupt_utils import handle_keyboard_interrupt_properly
+            handle_keyboard_interrupt_properly(ke)
+            raise  # Never reached, but satisfies type checker
+        except Exception:
+            return flag_string.split()
+
+    def build_flags(self) -> Dict[str, List[str]]:
+        """Build compilation flags from configuration.
+
+        Returns:
+            Dictionary with 'cflags', 'cxxflags', and 'common' keys
+        """
+        flags = {
+            'common': [],  # Common flags for both C and C++
+            'cflags': [],  # C-specific flags
+            'cxxflags': []  # C++-specific flags
+        }
+
+        # Get flags from config
+        config_flags = self.config.get('compiler_flags', {})
+
+        # Common flags (CCFLAGS in PlatformIO)
+        if 'common' in config_flags:
+            flags['common'] = config_flags['common'].copy()
+
+        # C-specific flags (CFLAGS in PlatformIO)
+        if 'c' in config_flags:
+            flags['cflags'] = config_flags['c'].copy()
+
+        # C++-specific flags (CXXFLAGS in PlatformIO)
+        if 'cxx' in config_flags:
+            flags['cxxflags'] = config_flags['cxx'].copy()
+
+        # Add defines from config (CPPDEFINES in PlatformIO)
+        defines = self.config.get('defines', [])
+        for define in defines:
+            if isinstance(define, str):
+                flags['common'].append(f'-D{define}')
+            elif isinstance(define, list) and len(define) == 2:
+                flags['common'].append(f'-D{define[0]}={define[1]}')
+
+        # Add Arduino-specific defines
+        self._add_arduino_defines(flags)
+
+        # Add board-specific extra flags if present
+        self._add_board_extra_flags(flags)
+
+        # Add user build flags from platformio.ini
+        self._add_user_flags(flags)
+
+        return flags
+
+    def _add_arduino_defines(self, flags: Dict[str, List[str]]) -> None:
+        """Add Arduino-specific defines to flags.
+
+        Args:
+            flags: Flags dictionary to update
+        """
+        build_config = self.board_config.get("build", {})
+        f_cpu = build_config.get("f_cpu", "160000000L")
+        mcu = build_config.get("mcu", "")
+        board = build_config.get("board", self.board_id.upper().replace("-", "_"))
+
+        # Detect platform from MCU
+        is_stm32 = mcu.lower().startswith("stm32")
+        is_esp32 = mcu.lower().startswith("esp32")
+
+        # Common Arduino defines
+        flags['common'].extend([
+            f'-DF_CPU={f_cpu}',
+            '-DARDUINO=10812',  # Arduino version
+            f'-DARDUINO_BOARD="{board}"',
+            f'-DARDUINO_VARIANT="{self.variant}"',
+        ])
+
+        if is_stm32:
+            # STM32-specific defines
+            flags['common'].extend([
+                f'-DARDUINO_{board}',
+                '-DARDUINO_ARCH_STM32',
+            ])
+            # Add product line define (e.g., STM32F103xB, STM32F446xx)
+            product_line = build_config.get("product_line", "")
+            if product_line:
+                flags['common'].append(f'-D{product_line}')
+            # Add VARIANT_H pointing to correct variant header
+            if self.variant:
+                # Variant header path relative to variants directory
+                flags['common'].append(f'-DVARIANT_H="{self.variant}/variant.h"')
+        elif is_esp32:
+            # ESP32-specific defines
+            flags['common'].extend([
+                '-DESP32',
+                f'-DARDUINO_{board}',
+                '-DARDUINO_ARCH_ESP32',
+            ])
+        else:
+            # Generic Arduino defines
+            flags['common'].append(f'-DARDUINO_{board}')
+
+    def _add_board_extra_flags(self, flags: Dict[str, List[str]]) -> None:
+        """Add board-specific extra flags.
+
+        Args:
+            flags: Flags dictionary to update
+        """
+        build_config = self.board_config.get("build", {})
+        extra_flags = build_config.get("extra_flags", "")
+
+        if extra_flags:
+            if isinstance(extra_flags, str):
+                flag_list = extra_flags.split()
+            else:
+                flag_list = extra_flags
+
+            for flag in flag_list:
+                if flag.startswith('-D'):
+                    flags['common'].append(flag)
+
+    def _add_user_flags(self, flags: Dict[str, List[str]]) -> None:
+        """Add user build flags from platformio.ini.
+
+        These override/extend board defaults.
+
+        Args:
+            flags: Flags dictionary to update
+        """
+        for flag in self.user_build_flags:
+            if flag.startswith('-D'):
+                # Add defines to common flags
+                flags['common'].append(flag)
+            # Could extend to handle other flag types if needed
+
+    def get_base_flags_for_library(self) -> List[str]:
+        """Get base compiler flags for library compilation.
+
+        Returns:
+            List of compiler flags suitable for library compilation
+        """
+        flags = self.build_flags()
+        base_flags = flags['common'].copy()
+        base_flags.extend(flags['cxxflags'])
+        return base_flags

fbuild/build/library_dependency_processor.py

@@ -0,0 +1,185 @@
+"""
+Library dependency processing for Fbuild build system.
+
+This module handles downloading, compiling, and managing library dependencies
+from platformio.ini lib_deps configuration. It coordinates between the
+library manager and the build system to ensure all dependencies are ready.
+"""
+
+from pathlib import Path
+from typing import List, Optional
+
+from ..config.board_config import BoardConfig
+from ..packages.library_manager import LibraryManager
+from ..packages.toolchain import ToolchainAVR
+
+
+class LibraryDependencyProcessor:
+    """
+    Processes library dependencies for the build system.
+
+    This class handles:
+    - Downloading library dependencies from GitHub URLs
+    - Compiling libraries with appropriate flags
+    - Managing library include paths and object files
+    - Coordinating between LibraryManager and build components
+
+    Example usage:
+        processor = LibraryDependencyProcessor(
+            build_dir=Path(".fbuild/build/uno"),
+            mode="release",
+            verbose=True
+        )
+        result = processor.process_dependencies(
+            lib_deps=["https://github.com/user/library"],
+            toolchain=toolchain,
+            board_config=board_config,
+            core_path=Path("~/.fbuild/packages/arduino-avr-1.8.6")
+        )
+        include_paths = result.include_paths
+        object_files = result.object_files
+    """
+
+    def __init__(
+        self,
+        build_dir: Path,
+        mode: str = "release",
+        verbose: bool = False
+    ):
+        """
+        Initialize library dependency processor.
+
+        Args:
+            build_dir: Build directory for storing library artifacts
+            mode: Build mode ('release' or 'debug')
+            verbose: Enable verbose output
+        """
+        self.build_dir = build_dir
+        self.mode = mode
+        self.verbose = verbose
+        self.library_manager: Optional[LibraryManager] = None
+
+    def process_dependencies(
+        self,
+        lib_deps: List[str],
+        toolchain: ToolchainAVR,
+        board_config: BoardConfig,
+        core_path: Path
+    ) -> 'LibraryProcessingResult':
+        """
+        Process all library dependencies.
+
+        Downloads, compiles, and prepares all library dependencies for linking.
+
+        Args:
+            lib_deps: List of library dependency URLs (e.g., GitHub URLs)
+            toolchain: Toolchain instance for compilation
+            board_config: Board configuration for compiler flags
+            core_path: Arduino core installation path
+
+        Returns:
+            LibraryProcessingResult with include paths and object files
+
+        Raises:
+            LibraryError: If library processing fails
+        """
+        if not lib_deps:
+            if self.verbose:
+                print("      No library dependencies")
+            return LibraryProcessingResult(
+                libraries=[],
+                include_paths=[],
+                object_files=[]
+            )
+
+        if self.verbose:
+            print(f"      Found {len(lib_deps)} library dependencies")
+
+        # Initialize library manager
+        self.library_manager = LibraryManager(self.build_dir, mode=self.mode)
+
+        # Get compiler tools
+        tools = toolchain.get_all_tools()
+
+        # Prepare compilation parameters
+        lib_defines = self._prepare_defines(board_config)
+        lib_includes = board_config.get_include_paths(core_path)
+
+        # Ensure all libraries are downloaded and compiled
+        libraries = self.library_manager.ensure_libraries(
+            lib_deps=lib_deps,
+            compiler_path=tools['avr-gcc'],
+            mcu=board_config.mcu,
+            f_cpu=board_config.f_cpu,
+            defines=lib_defines,
+            include_paths=lib_includes,
+            extra_flags=[],
+            show_progress=self.verbose
+        )
+
+        # Get library artifacts
+        lib_include_paths = self.library_manager.get_library_include_paths()
+        lib_objects = self.library_manager.get_library_objects()
+
+        if self.verbose:
+            print(f"      Compiled {len(libraries)} libraries")
+            print(f"      Library objects: {len(lib_objects)}")
+
+        # Extract library directory paths from Library objects
+        library_paths = [lib.lib_dir for lib in libraries]
+
+        return LibraryProcessingResult(
+            libraries=library_paths,
+            include_paths=lib_include_paths,
+            object_files=lib_objects
+        )
+
+    def _prepare_defines(self, board_config: BoardConfig) -> List[str]:
+        """
+        Prepare defines for library compilation.
+
+        Converts board configuration defines dictionary to list format
+        suitable for library compilation.
+
+        Args:
+            board_config: Board configuration
+
+        Returns:
+            List of define strings (e.g., ["F_CPU=16000000L", "ARDUINO=10819"])
+        """
+        lib_defines_dict = board_config.get_defines()
+        lib_defines = []
+
+        for key, value in lib_defines_dict.items():
+            if value:
+                lib_defines.append(f"{key}={value}")
+            else:
+                lib_defines.append(key)
+
+        return lib_defines
+
+
+class LibraryProcessingResult:
+    """
+    Result of library dependency processing.
+
+    Contains all information needed by the build system about processed libraries.
+    """
+
+    def __init__(
+        self,
+        libraries: List[Path],
+        include_paths: List[Path],
+        object_files: List[Path]
+    ):
+        """
+        Initialize library processing result.
+
+        Args:
+            libraries: List of library root directories
+            include_paths: List of include directories to add to compiler
+            object_files: List of compiled object files to link
+        """
+        self.libraries = libraries
+        self.include_paths = include_paths
+        self.object_files = object_files