#!/usr/bin/env python3 """ Build script for nsis7z plugin (7-Zip 25.01 version) - Visual Studio 2026 Supports multiple build configurations with flexible parameters Uses PlatformToolset v145 (Visual Studio 2026 Build Tools) NOTE: VS2026 Build Tools use v145 toolset (version 18.x) """ import argparse import os import sys import subprocess import shutil import time import multiprocessing import threading from concurrent.futures import ThreadPoolExecutor, as_completed from pathlib import Path from typing import List, Tuple, Optional import xml.etree.ElementTree as ET class BuildConfig: """Configuration for a single build target""" def __init__(self, name: str, config: str, platform: str, dest_dir: str): self.name = name self.config = config self.platform = platform self.dest_dir = dest_dir # Predefined build configurations CONFIGS = { 'x86-unicode': BuildConfig( name='x86-unicode', config='Release Unicode', platform='Win32', dest_dir='x86-unicode' ), 'x64-unicode': BuildConfig( name='x64-unicode', config='Release Unicode', platform='x64', dest_dir='amd64-unicode' ), 'x86-ansi': BuildConfig( name='x86-ansi', config='Release', platform='Win32', dest_dir='x86-ansi' ), } # Standard vswhere.exe location (installed with any VS 2017+ setup) _VSWHERE_PATH = Path(r'C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe') # vswhere version range per VS year _VS_VERSION_RANGE = { '2026': '[18.0,19.0)', '2022': '[17.0,18.0)', } # MSBuild toolset per VS year _VS_TOOLSET = { '2026': 'v145', # VS 2026 uses v145 toolset '2022': 'v143', # VS 2022 uses v143 toolset } def _find_msbuild_via_vswhere(vs_version: str) -> 'Optional[Tuple[Path, str, str]]': """Locate MSBuild via vswhere.exe.""" if not _VSWHERE_PATH.exists(): return None versions_to_try = ['2026', '2022'] if vs_version == 'auto' else [vs_version] for ver in versions_to_try: if ver not in _VS_VERSION_RANGE: continue try: result = subprocess.run( [ str(_VSWHERE_PATH), '-version', _VS_VERSION_RANGE[ver], '-latest', '-requires', 'Microsoft.Component.MSBuild', '-find', r'MSBuild\**\Bin\MSBuild.exe', ], capture_output=True, text=True, timeout=15, ) if result.returncode == 0: lines = [ln.strip() for ln in result.stdout.splitlines() if ln.strip()] if lines: msbuild_path = Path(lines[0]) if msbuild_path.exists(): return msbuild_path, _VS_TOOLSET[ver], ver except Exception: pass return None def find_msbuild(vs_version: str = 'auto') -> 'Optional[Tuple[Path, str, str]]': """Find MSBuild.exe via vswhere, then well-known fallback paths. Returns (msbuild_path, toolset_version, vs_year) or None. """ result = _find_msbuild_via_vswhere(vs_version) if result is not None: return result vs_editions = ['Community', 'Professional', 'Enterprise', 'BuildTools'] versions_to_try = ['2026', '2022'] if vs_version == 'auto' else [vs_version] for version in versions_to_try: base_path = Path(rf'C:\Program Files\Microsoft Visual Studio\{version}') for edition in vs_editions: msbuild_path = base_path / edition / 'MSBuild' / 'Current' / 'Bin' / 'MSBuild.exe' if msbuild_path.exists(): return msbuild_path, _VS_TOOLSET[version], version return None def get_project_paths() -> Tuple[Path, Path, Path]: """Get project directory, project file, and plugins directory""" script_dir = Path(__file__).parent.absolute() project_dir = script_dir.parent.parent / 'versions' / '25.01' project_file = project_dir / 'CPP' / '7zip' / 'Bundles' / 'Nsis7z' / 'Nsis7z_vs2026.vcxproj' plugins_dir = script_dir.parent.parent / 'plugins' return project_dir, project_file, plugins_dir def get_cpu_info() -> dict: """Get CPU information for parallel build optimization""" try: import psutil logical_cores = psutil.cpu_count(logical=True) physical_cores = psutil.cpu_count(logical=False) return { 'logical_cores': logical_cores, 'physical_cores': physical_cores, 'has_hyperthreading': logical_cores > physical_cores, 'has_psutil': True } except ImportError: # Fallback if psutil is not available cpu_count = multiprocessing.cpu_count() return { 'logical_cores': cpu_count, 'physical_cores': cpu_count, 'has_hyperthreading': False, 'has_psutil': False } def get_optimal_thread_count() -> int: """Get optimal thread count for compilation""" cpu_info = get_cpu_info() # Use physical cores for optimal performance (avoids hyperthreading overhead in compilation) if cpu_info['has_hyperthreading'] and cpu_info['physical_cores'] > 1: return cpu_info['physical_cores'] else: return cpu_info['logical_cores'] def get_build_optimizations() -> List[str]: """Get additional build optimization flags""" return [ '/p:BuildInParallel=true', # Enable parallel project builds '/p:MultiProcessorCompilation=true', # Enable MP compilation '/p:PreferredToolArchitecture=x64', # Use 64-bit tools (faster) '/p:UseSharedCompilation=true', # Enable shared compilation '/p:TrackFileAccess=false', # Disable file tracking (faster) '/nodeReuse:true', # Reuse MSBuild nodes '/p:GenerateResourceUsePreserializedResources=true' # Faster resources ] def get_memory_optimizations() -> List[str]: """Get memory optimization flags for faster builds""" try: import psutil # Get available memory in GB memory_gb = psutil.virtual_memory().total / (1024**3) if memory_gb >= 16: # High memory system - aggressive caching return [ '/p:DisableFastUpToDateCheck=false', '/p:BuildProjectReferences=true', '/p:UseCommonOutputDirectory=false' ] elif memory_gb >= 8: # Medium memory system return [ '/p:DisableFastUpToDateCheck=false' ] else: # Low memory system - conservative return [] except ImportError: # Conservative defaults without psutil return ['/p:DisableFastUpToDateCheck=false'] def print_cpu_info(use_parallel: bool, use_optimizations: bool = True) -> None: """Print CPU information for build optimization""" if not use_parallel: print("Build mode: Single-threaded") if use_optimizations: print("Optimizations: ENABLED (memory, caching)") return cpu_info = get_cpu_info() optimal_threads = get_optimal_thread_count() print("Build mode: Parallel") print(f"Logical cores: {cpu_info['logical_cores']}") print(f"Physical cores: {cpu_info['physical_cores']}") if cpu_info['has_hyperthreading']: print("Hyperthreading: ENABLED") print(f"Optimal threads: {optimal_threads} (using physical cores)") else: print("Hyperthreading: NOT AVAILABLE") print(f"Optimal threads: {optimal_threads}") print(f"MSBuild threads: {optimal_threads}") if use_optimizations: print("Optimizations: ENABLED (parallel, memory, caching)") try: import psutil memory_gb = psutil.virtual_memory().total / (1024**3) print(f"Available memory: {memory_gb:.1f} GB") except ImportError: print("Available memory: Unknown (install psutil for details)") else: print("Optimizations: DISABLED") if not cpu_info['has_psutil']: print("Note: Install 'psutil' for detailed CPU/memory info (pip install psutil)") print() def build_configuration( msbuild_path: Path, project_file: Path, config: BuildConfig, rebuild: bool = True, verbosity: str = 'quiet', parallel: bool = True, optimizations: bool = True, counter: str = "", capture_output: bool = False ) -> Tuple[bool, float, str]: """Build a single configuration Returns: Tuple of (success: bool, elapsed_time: float, captured_output: str) """ # Build MSBuild command cmd = [ str(msbuild_path), str(project_file), f'/t:{"Rebuild" if rebuild else "Build"}', f'/p:Configuration={config.config}', f'/p:Platform={config.platform}', f'/p:OutDir=Build\\{config.name}\\', f'/p:IntDir=Build\\{config.name}\\obj\\', '/p:WindowsTargetPlatformVersion=10.0', '/p:PlatformToolset=v145', f'/v:{verbosity}', ] if parallel: optimal_threads = get_optimal_thread_count() cmd.extend([ f'/maxcpucount:{optimal_threads}', '/p:UseMultiToolTask=true', f'/p:CL_MPCount={optimal_threads}' ]) # Add build optimizations if optimizations: cmd.extend(get_build_optimizations()) cmd.extend(get_memory_optimizations()) # Add cache directory if available cache_dir = setup_build_cache() if cache_dir: cmd.append(f'/p:MSBuildCacheEnabled=true') if not capture_output: print(f"\n{'='*50}") if counter: print(f"Building {config.name} [{counter}]") else: print(f"Building {config.name}...") print('='*50) # Execute build and measure time start_time = time.time() try: if capture_output: result = subprocess.run(cmd, check=False, capture_output=True, text=True) elapsed = time.time() - start_time return result.returncode == 0, elapsed, result.stdout + result.stderr else: result = subprocess.run(cmd, check=False) elapsed = time.time() - start_time return result.returncode == 0, elapsed, "" except Exception as e: elapsed = time.time() - start_time msg = f"ERROR: Build failed with exception: {e}" if capture_output: return False, elapsed, msg print(msg) return False, elapsed, "" def copy_output( project_dir: Path, plugins_dir: Path, config: BuildConfig ) -> Tuple[bool, int, Optional[Path]]: """Copy built DLL to destination directory Returns: Tuple of (success: bool, file_size: int, dest_path: Optional[Path]) """ # Output is in Build\{config.name}\ relative to project directory output_file = project_dir / 'CPP' / '7zip' / 'Bundles' / 'Nsis7z' / 'Build' / config.name / 'nsis7z.dll' dest_dir = plugins_dir / config.dest_dir if not output_file.exists(): print(f"ERROR: {config.name} DLL not found at {output_file}") return False, 0, None # Create destination directory dest_dir.mkdir(parents=True, exist_ok=True) # Copy file try: dest_path = dest_dir / 'nsis7z.dll' shutil.copy2(output_file, dest_path) file_size = output_file.stat().st_size print(f"SUCCESS: {config.name} - {file_size:,} bytes - Copied to {dest_dir}") return True, file_size, dest_path except Exception as e: print(f"ERROR: Failed to copy {config.name}: {e}") return False, 0, None def clean_build_artifacts(project_dir: Path, configs: List[BuildConfig]) -> None: """Clean up build artifacts""" print("\nCleaning build artifacts...") build_base_dir = project_dir / 'CPP' / '7zip' / 'Bundles' / 'Nsis7z' / 'Build' # Collect unique output directories dirs_to_clean = set() for config in configs: output_dir = build_base_dir / config.name dirs_to_clean.add(output_dir) for dir_path in dirs_to_clean: if dir_path.exists(): try: shutil.rmtree(dir_path) print(f" - Cleaned: {dir_path.name}") except Exception as e: print(f" - Failed to clean {dir_path.name}: {e}") print("Build artifacts cleaned successfully.") def format_time(seconds: float) -> str: """Format time in seconds to human readable format""" if seconds < 60: return f"{seconds:.2f}s" elif seconds < 3600: minutes = int(seconds // 60) secs = seconds % 60 return f"{minutes}m {secs:.1f}s" else: hours = int(seconds // 3600) minutes = int((seconds % 3600) // 60) secs = seconds % 60 return f"{hours}h {minutes}m {secs:.0f}s" def setup_build_cache() -> Optional[str]: """Setup build cache directory for faster incremental builds""" try: cache_dir = Path.home() / '.msbuild_cache' / 'nsis7z-2501-vs2026' cache_dir.mkdir(parents=True, exist_ok=True) return str(cache_dir) except Exception: return None def wait_for_key() -> bool: """Wait for user to press a key. Returns False if 'q' is pressed.""" print("\nPress any key to continue, or 'q' to quit...") try: if sys.platform == 'win32': import msvcrt key = msvcrt.getch() return key.lower() not in (b'q', b'Q') else: import termios import tty fd = sys.stdin.fileno() old_settings = termios.tcgetattr(fd) try: tty.setraw(fd) key = sys.stdin.read(1) return key.lower() not in ('q', 'Q') finally: termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) except Exception: input() # Fallback to input() return True def get_available_configurations(project_file: Path) -> List[Tuple[str, str]]: """Parse .vcxproj file to get available configurations Returns: List of (Configuration, Platform) tuples """ try: tree = ET.parse(project_file) root = tree.getroot() # XML namespace for MSBuild project files ns = {'ms': 'http://schemas.microsoft.com/developer/msbuild/2003'} configs = [] for item_group in root.findall('.//ms:ItemGroup', ns): for proj_config in item_group.findall('ms:ProjectConfiguration', ns): include = proj_config.get('Include') if include: # Format is "Configuration|Platform" parts = include.split('|') if len(parts) == 2: configs.append((parts[0], parts[1])) return configs except Exception as e: print(f"Warning: Could not parse project file: {e}") return [] def print_available_configurations(project_file: Path) -> None: """Print all configurations available in the project""" configs = get_available_configurations(project_file) if not configs: print("No configurations found or could not read project file.") return print("Available configurations in project:") print("-" * 60) # Group by configuration name from collections import defaultdict grouped = defaultdict(list) for config, platform in configs: grouped[config].append(platform) for config_name in sorted(grouped.keys()): platforms = ', '.join(sorted(grouped[config_name])) print(f" {config_name:25s} - {platforms}") print(f"\nTotal: {len(configs)} configuration(s)") print() # Show which ones are mapped in this script print("Configurations mapped in this build script:") print("-" * 60) for name, config in CONFIGS.items(): print(f" {name:15s} -> {config.config} / {config.platform}") print() _print_lock = threading.Lock() def _build_configs_parallel( msbuild_path: Path, project_file: Path, configs: 'List[BuildConfig]', *, rebuild: bool, verbosity: str, parallel: bool, optimizations: bool, project_dir: Path, plugins_dir: Path, ) -> list: """Build all configurations simultaneously, printing output atomically. Returns list of (config, success, build_time, file_size, dest_path) tuples in the same order as *configs*. """ n = len(configs) print(f"\nParallel-configs: launching {n} builds simultaneously...") print("=" * 50) total_start = time.time() results_by_idx: dict = {} idx_lock = threading.Lock() def _build_one(idx: int, config: 'BuildConfig'): success, build_time, captured = build_configuration( msbuild_path, project_file, config, rebuild=rebuild, verbosity=verbosity, parallel=parallel, optimizations=optimizations, capture_output=True, ) import io import contextlib copy_buf = io.StringIO() if success: with contextlib.redirect_stdout(copy_buf): copy_ok, file_size, dest_path = copy_output(project_dir, plugins_dir, config) else: copy_ok, file_size, dest_path = False, 0, None with _print_lock: all_ok = success and copy_ok tag = "OK" if all_ok else "FAILED" size_str = f"{file_size:,} bytes" if file_size > 0 else "N/A" print(f"[{tag}] {config.name} ({format_time(build_time)}) {size_str}") if dest_path: print(f" -> {dest_path}") if not all_ok: copy_out = copy_buf.getvalue() if copy_out.strip(): print(copy_out.rstrip()) if captured.strip(): print("--- Build output ---") print(captured.rstrip()) with idx_lock: results_by_idx[idx] = (config, success and copy_ok, build_time, file_size, dest_path) with ThreadPoolExecutor(max_workers=n) as executor: futures = {executor.submit(_build_one, i, cfg): i for i, cfg in enumerate(configs)} for fut in as_completed(futures): exc = fut.exception() if exc: idx = futures[fut] with _print_lock: print(f"ERROR: worker for config index {idx} raised: {exc}") with idx_lock: results_by_idx[idx] = (configs[idx], False, 0.0, 0, None) wall_time = time.time() - total_start print(f"\nAll {n} configs finished in {format_time(wall_time)} (wall clock)") return [results_by_idx[i] for i in range(n)] def main(): """Main build function""" parser = argparse.ArgumentParser( description='Build nsis7z plugin for NSIS (7-Zip 25.01, Visual Studio 2026)', formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: %(prog)s # Build all configurations %(prog)s --list # List script configurations %(prog)s --list-project # List all project configurations %(prog)s --configs x86-unicode # Build only x86-unicode %(prog)s --configs x86-unicode x64-unicode # Build specific configs %(prog)s --no-rebuild # Incremental build %(prog)s --no-parallel # Single-threaded build %(prog)s --no-clean # Skip cleanup %(prog)s --verbosity minimal # Show more build output %(prog)s --pause # Wait for key press at the end """ ) parser.add_argument( '--configs', nargs='+', choices=list(CONFIGS.keys()) + ['all'], default=['all'], help='Configurations to build (default: all)' ) parser.add_argument( '--rebuild', action='store_true', default=True, help='Force full rebuild (default: True)' ) parser.add_argument( '--no-rebuild', action='store_false', dest='rebuild', help='Incremental build (only changed files)' ) parser.add_argument( '--parallel', action='store_true', default=True, help='Enable parallel build (default: True)' ) parser.add_argument( '--no-parallel', action='store_false', dest='parallel', help='Disable parallel build' ) parser.add_argument( '--verbosity', choices=['quiet', 'minimal', 'normal', 'detailed', 'diagnostic'], default='quiet', help='MSBuild verbosity level (default: quiet)' ) parser.add_argument( '--clean', action='store_true', default=True, help='Clean build artifacts after successful build (default: True)' ) parser.add_argument( '--no-clean', action='store_false', dest='clean', help='Do not clean build artifacts' ) parser.add_argument( '--list', action='store_true', help='List script configurations and exit' ) parser.add_argument( '--list-project', action='store_true', help='List all configurations available in the project file and exit' ) parser.add_argument( '--pause', action='store_true', help='Pause and wait for key press at the end' ) parser.add_argument( '--no-optimizations', action='store_true', help='Disable additional build optimizations' ) parser.add_argument( '--benchmark', action='store_true', help='Run performance comparison (with/without optimizations)' ) parser.add_argument( '--vs-version', choices=['auto', '2026', '2022'], default='auto', help='Visual Studio version to use (default: auto - tries 2026 then 2022)' ) args = parser.parse_args() # Get project paths early for list-project project_dir, project_file, plugins_dir = get_project_paths() # List project configurations if args.list_project: if not project_file.exists(): print(f"ERROR: Project file not found: {project_file}") return 1 print_available_configurations(project_file) return 0 # List script configurations if args.list: print("Build script configurations (7-Zip 25.01, VS2026):") print("-" * 60) for name, config in CONFIGS.items(): print(f" {name:15s} -> {config.config} / {config.platform}") print(f"\nTotal: {len(CONFIGS)} configuration(s)") print("\nUse --list-project to see all configurations in the .vcxproj file") return 0 # Find MSBuild msbuild_result = find_msbuild(args.vs_version) if not msbuild_result: print("ERROR: MSBuild not found!") print() print("Visual Studio 2026 Build Tools not found.") print("Checked locations:") print(" - C:\\Program Files\\Microsoft Visual Studio\\2026\\") print(" - C:\\Program Files (x86)\\Microsoft Visual Studio\\18\\") print(" - C:\\BuildTools\\") print() print("To install VS2026 Build Tools:") print(" choco install visualstudio2026buildtools") return 1 msbuild_path, platform_toolset, vs_version_name = msbuild_result if not project_file.exists(): print(f"ERROR: Project file not found: {project_file}") print() print("You need to create the VS2026 project file first.") print("Copy Nsis7z.vcxproj to Nsis7z_vs2026.vcxproj and update the toolset.") return 1 # Determine configurations to build if 'all' in args.configs: configs_to_build = list(CONFIGS.values()) else: configs_to_build = [CONFIGS[name] for name in args.configs] # Print header print("=" * 60) print(f"Building nsis7z plugin (7-Zip 25.01, VS2026) - {len(configs_to_build)} configuration(s)") print("=" * 60) print(f"Visual Studio: {vs_version_name} (toolset {platform_toolset})") print(f"MSBuild: {msbuild_path}") print(f"Project: {project_file}") print(f"Plugins: {plugins_dir}") print(f"Rebuild: {args.rebuild}") print(f"Verbosity: {args.verbosity}") print() # Print CPU and parallel build info use_optimizations = not args.no_optimizations print_cpu_info(args.parallel, use_optimizations) # Benchmark mode - compare with and without optimizations if args.benchmark and len(configs_to_build) == 1: config = configs_to_build[0] print("=" * 50) print("BENCHMARK MODE - Comparing optimization strategies") print("=" * 50) # Test without optimizations print("\n[1/2] Building WITHOUT optimizations...") success1, time1, _ = build_configuration( msbuild_path, project_file, config, rebuild=True, verbosity=args.verbosity, parallel=args.parallel, optimizations=False ) if success1: copy_output(project_dir, plugins_dir, config) # Test with optimizations print("\n[2/2] Building WITH optimizations...") success2, time2, _ = build_configuration( msbuild_path, project_file, config, rebuild=True, verbosity=args.verbosity, parallel=args.parallel, optimizations=True ) if success2: copy_output(project_dir, plugins_dir, config) # Show comparison print("\n" + "=" * 50) print("BENCHMARK RESULTS") print("=" * 50) print(f"Without optimizations: {format_time(time1)}") print(f"With optimizations: {format_time(time2)}") if time1 > time2: speedup = time1 / time2 improvement = ((time1 - time2) / time1) * 100 print(f"Speedup: {speedup:.2f}x faster ({improvement:.1f}% improvement)") else: slowdown = time2 / time1 print(f"Slowdown: {slowdown:.2f}x slower") if args.clean: clean_build_artifacts(project_dir, configs_to_build) return 0 if (success1 and success2) else 1 # Build each configuration build_results = [] total_start_time = time.time() if args.parallel and len(configs_to_build) > 1: build_results = _build_configs_parallel( msbuild_path, project_file, configs_to_build, rebuild=args.rebuild, verbosity=args.verbosity, parallel=args.parallel, optimizations=use_optimizations, project_dir=project_dir, plugins_dir=plugins_dir, ) else: for i, config in enumerate(configs_to_build, 1): # Build success, build_time, _ = build_configuration( msbuild_path, project_file, config, rebuild=args.rebuild, verbosity=args.verbosity, parallel=args.parallel, optimizations=use_optimizations, counter=f"{i}/{len(configs_to_build)}" ) if not success: print(f"ERROR: {config.name} build failed! (Time: {format_time(build_time)})") build_results.append((config, False, build_time, 0, None)) continue # Copy output success, file_size, dest_path = copy_output(project_dir, plugins_dir, config) print(f"Build time: {format_time(build_time)}") build_results.append((config, success, build_time, file_size, dest_path)) # Calculate total time total_time = time.time() - total_start_time # Summary print("\n" + "=" * 50) all_success = all(success for _, success, _, _, _ in build_results) if all_success: print("ALL BUILDS SUCCESSFUL!") print("=" * 50) print("\nPlugins copied to:") for config, _, build_time, file_size, dest_path in build_results: dest = dest_path if dest_path else plugins_dir / config.dest_dir / 'nsis7z.dll' print(f" - {dest}") # Clean up if args.clean: print() clean_build_artifacts(project_dir, configs_to_build) else: print("SOME BUILDS FAILED!") print("=" * 50) print("\nFailed configurations:") for config, success, build_time, file_size, dest_path in build_results: if not success: print(f" - {config.name}") # Show timing summary print("\n" + "-" * 50) print("Build Summary:") for config, success, build_time, file_size, dest_path in build_results: status = "✓" if success else "✗" size_str = f"{file_size:,} bytes" if file_size > 0 else "N/A" print(f" {status} {config.name:15s} - {format_time(build_time):8s} - {size_str}") print("-" * 50) print(f"Total time: {format_time(total_time)}") print() # Pause if requested if args.pause: if not wait_for_key(): print("Exiting...") return 1 return 0 if all_success else 1 if __name__ == '__main__': sys.exit(main())