EBuild

https://github.com/yldrefruz/ebuild
Admin
EBuild is a powerful, independent build system designed to handle complex module-based projects,...
Tokens:11,714
Snippets:45
Trust Score:5.1
License:MIT
Update:11 months ago
Show doc for...
Tokens:
Raw
### Build Zlib Example with Bash

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Command to build the Zlib example project using EBuild. Demonstrates automatic source downloading and verification with SHA256 checksum validation.

```bash
ebuild build examples/zlib/zlib.ebuild.cs
```

--------------------------------

### Build ICU Example with Bash

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Commands to build the ICU example project in different configurations. Includes options for shared library output and data mode settings.

```bash
ebuild build examples/icu/icu.ebuild.cs
```

```bash
ebuild build shared:examples/icu/icu.ebuild.cs
```

```bash
ebuild build examples/icu/icu.ebuild.cs -D DataMode=common
```

--------------------------------

### Download and Setup Zlib Library in C#

Source: https://context7.com/yldrefruz/ebuild/llms.txt

The ZlibModule class inherits from ModuleBase and implements setup logic to download zlib from a URL, validate with SHA256 checksum, extract the archive, and configure source files and compiler options. It depends on ebuild.api for context and utilities like ModuleUtilities.GetAndExtractSourceFromArchiveUrl. Inputs include module context and temporary paths; outputs are configured source files and include directories. Limitations include synchronous setup blocking and platform-specific definitions assuming Windows or Unix.

```csharp
using System.Threading.Tasks;
using ebuild.api;

public class ZlibModule : ModuleBase
{
    private const string ZlibVersion = "1.3.1";
    private const string ZlibUrl = "https://github.com/madler/zlib/releases/download/v1.3.1/zlib-1.3.1.tar.gz";
    private const string ZlibSha256 = "9a93b2b7dfdac77ceba5a558a580e74667dd6fede4585b91eefb60f03b72df23";

    public ZlibModule(ModuleContext context) : base(context)
    {
        Name = "zlib";
        Type = ModuleType.StaticLibrary;
        CStandard = CStandards.C99;
        UseVariants = false;

        // Setup synchronously in constructor
        SetupSync();
    }

    private void SetupSync()
    {
        Setup().GetAwaiter().GetResult();
    }

    private async Task<bool> Setup()
    {
        var extractPath = Path.Combine(
            Path.GetTempPath(),
            "ebuild",
            "zlib",
            $"zlib-{ZlibVersion}"
        );

        // Check if already downloaded
        if (Directory.Exists(extractPath) && File.Exists(Path.Combine(extractPath, "zlib.h")))
        {
            ConfigureSourceFiles(extractPath);
            return true;
        }

        // Download and extract with checksum verification
        var success = await ModuleUtilities.GetAndExtractSourceFromArchiveUrl(
            ZlibUrl,
            extractPath,
            expectedHash: ZlibSha256
        );

        if (!success)
        {
            Context.AddMessage(
                ModuleContext.Message.SeverityTypes.Error,
                "Failed to download or extract zlib"
            );
            return false;
        }

        ConfigureSourceFiles(extractPath);
        return true;
    }

    private void ConfigureSourceFiles(string extractPath)
    {
        // Add specific source files
        var sourceFiles = new[]
        {
            "adler32.c", "compress.c", "crc32.c", "deflate.c",
            "gzclose.c", "gzlib.c", "gzread.c", "gzwrite.c",
            "infback.c", "inffast.c", "inflate.c", "inftrees.c",
            "trees.c", "uncompr.c", "zutil.c"
        };

        foreach (var file in sourceFiles)
        {
            var fullPath = Path.Combine(extractPath, file);
            if (File.Exists(fullPath))
            {
                SourceFiles.Add(fullPath);
            }
        }

        // Add include directory
        Includes.Public.Add(extractPath);

        // Platform-specific configuration
        if (Context.Platform.Name == "windows")
        {
            Definitions.Private.Add(new Definition("_CRT_SECURE_NO_DEPRECATE"));
            Definitions.Private.Add(new Definition("_CRT_NONSTDC_NO_DEPRECATE"));
        }
        else if (Context.Platform.Name == "unix")
        {
            CompilerOptions.Add("-Wno-implicit-function-declaration");
        }

        OptimizationLevel = OptimizationLevel.Speed;
    }
}
```

--------------------------------

### Implement IToolchain in C#

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Demonstrates how to create a custom toolchain by implementing the IToolchain interface. Includes methods for getting compiler and linker factories based on module type.

```csharp
using ebuild.api.Toolchain;

public class MyToolchain : IToolchain
{
    public string Name => "mytoolchain";
    
    public ICompilerFactory? GetCompilerFactory(ModuleBase module, IModuleInstancingParams instancingParams)
    {
        return new MyCompilerFactory();
    }
    
    public ILinkerFactory? GetLinkerFactory(ModuleBase module, IModuleInstancingParams instancingParams)
    {
        if (module.Type == ModuleType.StaticLibrary)
            return new MyArchiverFactory();
        return new MyLinkerFactory();
    }
    
    public ICompilerFactory? GetResourceCompilerFactory(ModuleBase module, IModuleInstancingParams instancingParams)
    {
        return null; // Optional resource compiler
    }
}
```

--------------------------------

### C# Example: Circular Dependency Detection

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This C# code example demonstrates a scenario to trigger circular dependency detection. The example defines two modules, ModuleA and ModuleB, where each module depends on the other, creating a circular dependency.

```csharp
// ModuleA.ebuild.cs
public class ModuleA : ModuleBase
{
    public ModuleA(ModuleContext context) : base(context)
    {
        Name = "ModuleA";
        Type = ModuleType.StaticLibrary;
        Dependencies.Public.Add(new ModuleReference("../ModuleB/module_b.ebuild.cs"));
    }
}

```

```csharp
// ModuleB.ebuild.cs
public class ModuleB : ModuleBase
{
    public ModuleB(ModuleContext context) : base(context)
    {
        Name = "ModuleB";
        Type = ModuleType.StaticLibrary;
        Dependencies.Public.Add(new ModuleReference("../ModuleA/module_a.ebuild.cs"));
    }
}

```

--------------------------------

### Complete Advanced Module Definition in EBuild (C#)

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

This full class example extends ModuleBase to create an executable module with options, conditional logic, and platform-specific settings. It integrates all prior features like sources, dependencies, and compiler configs. Inputs include ModuleContext; outputs a configured module for building. Limitations: Requires ebuild.api namespace and proper inheritance.

```csharp
using ebuild.api;

public class AdvancedModule : ModuleBase
{
    [ModuleOption(Description = "Enable extra features", ChangesResultBinary = true)]
    public bool EnableExtraFeatures = false;
    
    public AdvancedModule(ModuleContext context) : base(context)
    {
        Name = "AdvancedModule";
        Type = ModuleType.Executable;
        
        // Public includes for dependent modules
        Includes.Public.AddRange(new[] { "include", "third_party/include" });
        
        // Private implementation includes
        Includes.Private.Add("src/internal");
        
        // Source files
        SourceFiles.AddRange(ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "h"));
        
        // Public dependencies (transitive)
        Dependencies.Public.Add(new ModuleReference("CoreLibrary"));
        
        // Private dependencies (non-transitive)
        Dependencies.Private.Add(new ModuleReference("ThirdPartyLib"));
        
        // Libraries
        Libraries.Public.AddRange(new[] { "SomeLibrary.lib", "AnotherLibrary.lib" });
        LibrarySearchPaths.Public.Add("third_party/lib");
        
        // Definitions
        Definitions.Public.Add("API_VERSION=2");
        if (EnableExtraFeatures)
        {
            Definitions.Public.Add("EXTRA_FEATURES=1");
        }
        
        // Compiler settings
        CppStandard = CppStandards.Cpp20;
        OptimizationLevel = context.Configuration == "release" 
            ? OptimizationLevel.Speed 
            : OptimizationLevel.None;
        
        // Platform-specific configuration
        if (context.Platform.Name == "windows")
        {
            Libraries.Public.Add("user32.lib");
            CompilerOptions.Add("/W4");
        }
        else if (context.Platform.Name == "unix")
        {
            Libraries.Public.Add("pthread");
            CompilerOptions.Add("-Wall");
        }
    }
}
```

--------------------------------

### Define a Basic C# Module in EBuild

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Defines a basic module in C# by inheriting from `ModuleBase`. This example shows how to set the module name, type, include paths, source files, and public/private dependencies.

```csharp
using ebuild.api;

public class MyModule : ModuleBase
{
    public MyModule(ModuleContext context) : base(context)
    {
        Name = "MyModule";
        Type = ModuleType.StaticLibrary; // or SharedLibrary, Executable, ExecutableWin32
        
        // Public includes are propagated to dependent modules
        Includes.Public.Add("include");
        
        // Private includes are only used by this module
        Includes.Private.Add("src");
        
        // Add source files
        SourceFiles.AddRange(ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "h"));
        
        // Public libraries are passed to dependent modules
        Libraries.Public.Add("SomeLibrary.lib");
        
        // Public dependencies become transitive dependencies
        Dependencies.Public.Add(new ModuleReference("PublicDependency"));
        
        // Private dependencies are only linked to this module
        Dependencies.Private.Add(new ModuleReference("PrivateDependency"));
    }
}
```

--------------------------------

### Get EBuild Properties using CLI

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Retrieves the value of specified EBuild properties. Currently supports retrieving the path to the ebuild.api.dll assembly.

```bash
ebuild property get <property-name>

Available properties:
- ebuild.api.dll: Returns the path to the ebuild.api.dll assembly
```

--------------------------------

### Ebuild Command Line for Configurable Modules (Bash)

Source: https://context7.com/yldrefruz/ebuild/llms.txt

Demonstrates how to build a module with different configurations using the ebuild command-line tool. It shows the default build command, how to enable specific module options using the `-D` flag, and how to pass multiple options simultaneously.

```bash
# Default build
ebuild build module.ebuild.cs

# Build with debug enabled (creates variant with unique ID)
ebuild build module.ebuild.cs -D "EnableDebug=true"

# Build with multiple options
ebuild build module.ebuild.cs -D "EnableDebug=true;EnableAdvancedFeatures=true;OptimizationMode=size"
```

--------------------------------

### Build EBuild with Dotnet CLI

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Commands to clone, build, and test the EBuild project using the Dotnet CLI. Includes options for release mode and verbose test output.

```bash
git clone https://github.com/yldrefruz/ebuild.git
cd ebuild
dotnet build
```

```bash
dotnet build -c Release
```

```bash
dotnet test
```

```bash
dotnet test --logger "console;verbosity=detailed"
```

--------------------------------

### Ebuild Command Line for Output Transformers (Bash)

Source: https://context7.com/yldrefruz/ebuild/llms.txt

Illustrates how to build a module with different output types using the ebuild command-line interface. It shows the command for building the default static library, and how to specify shared library or header-only outputs using the `-D "output=..."` option.

```bash
# Build static library (default)
ebuild build module.ebuild.cs

# Build shared library/DLL
ebuild build module.ebuild.cs -D "output=shared"

# Build as header-only
ebuild build module.ebuild.cs -D "output=header"
```

--------------------------------

### Configuring Compiler and Linker Options in EBuild (C#)

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

This snippet illustrates adding compiler warnings and linker subsystem options for MSVC and GCC. Options are platform-specific and added to the module's configuration. Inputs are flag strings; outputs influence build commands. Limitations: Requires correct toolchain selection for validity.

```csharp
CompilerOptions.Add("/W4");        // MSVC warning level
CompilerOptions.Add("-Wall");      // GCC warnings
LinkerOptions.Add("/SUBSYSTEM:WINDOWS");

if (context.Platform.Name == "windows")
{
    Libraries.Public.Add("user32.lib");
    CompilerOptions.Add("/W4");
}
else if (context.Platform.Name == "unix")
{
    Libraries.Public.Add("pthread");
    CompilerOptions.Add("-Wall");
}
```

--------------------------------

### Add New Platform to EBuild

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Shows how to define a new platform by inheriting from PlatformBase and specifying platform-specific details like toolchain, file extensions, definitions, compiler flags, and libraries.

```csharp
using ebuild.api;

[Platform("MyPlatform")]
public class MyPlatform : PlatformBase
{
    public MyPlatform() : base("myplatform")
    {
    }
    
    public override string? GetDefaultToolchainName() => "gcc";
    
    public override string ExtensionForStaticLibrary => ".a";
    public override string ExtensionForSharedLibrary => ".so";
    public override string ExtensionForExecutable => "";
    
    public override IEnumerable<string> GetPlatformDefinitions(ModuleBase module)
    {
        yield return new Definition("MY_PLATFORM", "1");
    }
    
    public override IEnumerable<string> GetPlatformCompilerFlags(ModuleBase module)
    {
        yield return "-fPIC";
    }
    
    public override IEnumerable<string> GetPlatformLibraries(ModuleBase module)
    {
        yield return "pthread";
        yield return "dl";
    }
}
```

--------------------------------

### Add New Compiler to EBuild

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Demonstrates how to create a new compiler by inheriting from CompilerBase and registering it with a Compiler attribute. Includes a factory class for creating compiler instances.

```csharp
using ebuild.api;
using ebuild.api.Compiler;

[Compiler("MyCompiler")]
public class MyCompiler : CompilerBase
{
    public override async Task<bool> Compile(CompilerSettings settings, CancellationToken cancellationToken)
    {
        // Implement compilation logic
        // Access settings.SourceFiles, settings.OutputFile, etc.
        // Return true on success
    }
}

public class MyCompilerFactory : ICompilerFactory
{
    public string Name => "my.compiler";
    public Type CompilerType => typeof(MyCompiler);
    
    public bool CanCreate(ModuleBase module, IModuleInstancingParams instancingParams)
    {
        // Return true if this compiler can handle the module
        return true;
    }
    
    public CompilerBase CreateCompiler(ModuleBase module, IModuleInstancingParams instancingParams)
    {
        return new MyCompiler();
    }
    
    public string GetExecutablePath(ModuleBase module, IModuleInstancingParams instancingParams)
    {
        return "/path/to/compiler";
    }
}
```

--------------------------------

### Print Dependencies using EBuild CLI

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Displays the complete dependency tree for a given module file, showing all direct and transitive dependencies.

```bash
ebuild check print-dependencies <module-file>
```

--------------------------------

### Implement Custom Toolchain with C#

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This C# code demonstrates how to implement the IToolchain interface to create a custom build toolchain. It specifies custom compiler and linker types and provides methods to create instances of them. This allows for full control over the build pipeline by integrating specific compiler and linker implementations.

```csharp
using ebuild.api.Compiler;
using ebuild.api.Linker;
using ebuild.api.Toolchain;

[Toolchain("MyToolchain")]
public class MyCustomToolchain : IToolchain
{
    public string Name => "mytoolchain";

    public Type GetCompilerFactory()
    {
        return typeof(MyCustomCompiler);
    }

    public Type GetLinkerFactory()
    {
        return typeof(MyCustomLinker);
    }

    public Type? GetResourceCompilerFactory()
    {
        // Return null if no resource compiler
        return null;
    }

    public CompilerBase CreateCompiler()
    {
        return new MyCustomCompiler();
    }

    public LinkerBase CreateLinker()
    {
        return new MyCustomLinker();
    }

    public object? CreateResourceCompiler()
    {
        return null;
    }
}
```

--------------------------------

### Adding Source Files and Includes in EBuild (C#)

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

This snippet demonstrates how to add source files using utility methods and configure public and private include paths for modules. It relies on the ModuleUtilities class and ModuleBase for context. Inputs are directory paths and file extensions; outputs update the module's source and include lists. Limitations include platform-agnostic paths without automatic resolution.

```csharp
SourceFiles.AddRange(ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "h"));

// Public includes for dependent modules
Includes.Public.AddRange(new[] { "include", "third_party/include" });

// Private implementation includes
Includes.Private.Add("src/internal");
```

--------------------------------

### Build Ebuild Module

Source: https://context7.com/yldrefruz/ebuild/llms.txt

The `ebuild build` command is used to build a specific Ebuild module. It takes the path to the Ebuild file as input and can accept optional flags like output variant and dependency search paths. The command's output depends on the module and defined build configurations.

```bash
# Build specific output variant
ebuid build path/to/module.ebuild.cs -D "output=shared"

```

```bash
# Add custom dependency search paths
ebuid build path/to/module.ebuild.cs -P "/path/to/deps1" -P "/path/to/deps2"

```

--------------------------------

### Implement Custom Platform with PlatformBase

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This C# code defines a custom platform by inheriting from `PlatformBase`. It specifies the platform's name, file extensions for static and shared libraries, and provides methods to retrieve platform-specific include paths, library search paths, and linker libraries. It also includes a method for defining platform-specific preprocessor macros.

```csharp
using ebuild.api;

[Platform("MyCustomPlatform")]
public class MyCustomPlatform : PlatformBase
{
    public override string Name => "mycustom";

    public override string ExtensionForStaticLibrary => ".a";
    public override string ExtensionForSharedLibrary => ".so";
    public override string ExtensionForExecutable => "";

    public override List<string> GetPlatformIncludes(ModuleBase module)
    {
        return new List<string>
        {
            "/usr/include/mycustom",
            "/opt/mycustom/include"
        };
    }

    public override List<string> GetPlatformLibrarySearchPaths(ModuleBase module)
    {
        return new List<string>
        {
            "/usr/lib/mycustom",
            "/opt/mycustom/lib"
        };
    }

    public override List<string> GetPlatformLibraries(ModuleBase module)
    {
        return new List<string>
        {
            "pthread",
            "dl",
            "mycustom_runtime"
        };
    }

    public override List<Definition> GetPlatformDefinitions(ModuleBase module)
    {
        return new List<Definition>
        {
            new Definition("PLATFORM_MYCUSTOM"),
            new Definition("PLATFORM_UNIX_LIKE")
        };
    }
}

```

--------------------------------

### C#: Custom Build Logic with Pre/Post Build Steps in ebuild

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This C# code defines an advanced module for ebuild, demonstrating the use of PreBuildSteps to generate a version header and run a Python code generator, and PostBuildSteps to copy resources and strip debug symbols for release builds. It leverages the ebuild.api to access module context and build utilities.

```csharp
using System.Diagnostics;
using System.Threading.Tasks;
using ebuild.api;

public class AdvancedModule : ModuleBase
{
    public AdvancedModule(ModuleContext context) : base(context)
    {
        Name = "AdvancedModule";
        Type = ModuleType.Executable;

        SourceFiles.AddRange(
            ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "h")
        );

        // Pre-build: Generate version header
        PreBuildSteps.Add(new ModuleBuildStep(
            "Generate Version Header",
            async (module, token) =>
            {
                var versionHeader = Path.Combine(
                    module.Context.ModuleDirectory.FullName,
                    "src/generated/version.h"
                );

                Directory.CreateDirectory(Path.GetDirectoryName(versionHeader)!);

                var content = $"\
#pragma once
#define APP_VERSION_MAJOR 1
#define APP_VERSION_MINOR 0
#define APP_VERSION_PATCH 0
#define APP_BUILD_DATE \"{DateTime.Now:yyyy-MM-dd}\" \
#define APP_BUILD_TIME \"{DateTime.Now:HH:mm:ss}\" 
";

                await File.WriteAllTextAsync(versionHeader, content, token);
                Console.WriteLine($"Generated version header: {versionHeader}");
                return true;
            }
        ));

        // Pre-build: Run code generator
        PreBuildSteps.Add(new ModuleBuildStep(
            "Run Code Generator",
            async (module, token) =>
            {
                var generator = Path.Combine(
                    module.Context.ModuleDirectory.FullName,
                    "tools/codegen.py"
                );

                if (!File.Exists(generator))
                {
                    Console.WriteLine("Code generator not found, skipping");
                    return true;
                }

                var process = new Process
                {
                    StartInfo = new ProcessStartInfo
                    {
                        FileName = "python3",
                        Arguments = $"--output src/generated",
                        WorkingDirectory = module.Context.ModuleDirectory.FullName,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true,
                        UseShellExecute = false
                    }
                };

                process.Start();
                await process.WaitForExitAsync(token);

                if (process.ExitCode != 0)
                {
                    var error = await process.StandardError.ReadToEndAsync();
                    Console.Error.WriteLine($"Code generation failed: {error}");
                    return false;
                }

                Console.WriteLine("Code generation completed successfully");
                return true;
            }
        ));

        // Post-build: Copy resources
        PostBuildSteps.Add(new ModuleBuildStep(
            "Copy Resources",
            async (module, token) =>
            {
                var resourcesDir = Path.Combine(
                    module.Context.ModuleDirectory.FullName,
                    "resources"
                );

                var outputDir = module.GetBinaryOutputDirectory();
                var targetDir = Path.Combine(outputDir, "resources");

                if (Directory.Exists(resourcesDir))
                {
                    Directory.CreateDirectory(targetDir);

                    foreach (var file in Directory.GetFiles(resourcesDir, "*", SearchOption.AllDirectories))
                    {
                        var relativePath = Path.GetRelativePath(resourcesDir, file);
                        var targetPath = Path.Combine(targetDir, relativePath);

                        Directory.CreateDirectory(Path.GetDirectoryName(targetPath)!);
                        File.Copy(file, targetPath, overwrite: true);
                    }

                    Console.WriteLine($"Copied resources to {targetDir}");
                }

                return true;
            }
        ));

        // Post-build: Strip debug symbols on release
        PostBuildSteps.Add(new ModuleBuildStep(
            "Strip Debug Symbols",
            async (module, token) =>
            {
                if (module.Context.Configuration != "release")
                {
                    return true; // Only strip on release builds
                }

                var binaryPath = module.GetBinaryOutputPath();

                if (module.Context.Platform.Name == "unix")
                {
                    var process = new Process
                    {
                        StartInfo = new ProcessStartInfo
                        {
                            FileName = "strip",

```

--------------------------------

### Build Module with Command-Line Options in EBuild

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Builds a module using the EBuild CLI, passing configurable module options via the command line. Demonstrates how to set boolean and integer options, and how `ChangesResultBinary` affects build variants.

```bash
ebuild build module.ebuild.cs -D EnableDebug=true -D OptimizationLevel=3
```

--------------------------------

### Implement Custom C++ Compiler with CompilerBase

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This C# code demonstrates how to create a custom compiler by inheriting from `CompilerBase`. It defines the compiler's name, executable path, and implements the `Compile` method to construct and execute build arguments for a C++ compiler, including source files, output paths, include directories, definitions, C++ standards, optimization levels, and custom flags. The `Generate` method is also included for potential metadata generation.

```csharp
using System.Threading;
using System.Threading.Tasks;
using ebuild.api;
using ebuild.api.Compiler;

[Compiler("MyCustomCompiler")]
public class MyCustomCompiler : CompilerBase
{
    public override string Name => "MyCustomCompiler";
    public override string ExecutablePath => "/usr/bin/mycc";

    public override async Task<bool> Compile(
        CompilerSettings settings,
        CancellationToken cancellationToken)
    {
        var args = new ArgumentBuilder();

        // Add source file
        args.Add(settings.SourceFile);

        // Add output flag
        args.Add("-o");
        args.Add(settings.OutputFile);

        // Add include paths
        foreach (var include in settings.IncludePaths)
        {
            args.Add("-I");
            args.Add(include);
        }

        // Add definitions
        foreach (var definition in settings.Definitions)
        {
            if (definition.HasValue())
            {
                args.Add($"-D{definition.GetName()}={definition.GetValue()}");
            }
            else
            {
                args.Add($"-D{definition.GetName()}");
            }
        }

        // Add C++ standard
        args.Add(settings.CppStandard switch
        {
            CppStandards.Cpp17 => "-std=c++17",
            CppStandards.Cpp20 => "-std=c++20",
            CppStandards.Cpp23 => "-std=c++23",
            _ => "-std=c++20"
        });

        // Add optimization flags
        args.Add(settings.Optimization switch
        {
            OptimizationLevel.None => "-O0",
            OptimizationLevel.Size => "-Os",
            OptimizationLevel.Speed => "-O2",
            OptimizationLevel.Max => "-O3",
            _ => "-O2"
        });

        // Add custom flags
        foreach (var flag in settings.OtherFlags)
        {
            args.Add(flag);
        }

        // Execute compiler
        var processInfo = new System.Diagnostics.ProcessStartInfo
        {
            FileName = ExecutablePath,
            Arguments = args.ToString(),
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false
        };

        using var process = System.Diagnostics.Process.Start(processInfo);
        await process!.WaitForExitAsync(cancellationToken);

        if (process.ExitCode != 0)
        {
            var error = await process.StandardError.ReadToEndAsync();
            Console.Error.WriteLine($"Compilation failed: {error}");
            return false;
        }

        return true;
    }

    public override Task<bool> Generate(
        CompilerSettings settings,
        CancellationToken cancellationToken,
        string type,
        object? data)
    {
        // Implement metadata generation if needed
        return Task.FromResult(true);
    }
}

```

--------------------------------

### Flexible Library with Output Transformers (C#)

Source: https://context7.com/yldrefruz/ebuild/llms.txt

Implements a C# module using ebuild's OutputTransformerAttribute to generate different output types (shared library, static library, header-only) from a single module definition. The `FlexibleLibrary` class allows specifying the output type via a build option, and the `[OutputTransformer]` methods configure the module's properties accordingly.

```csharp
using ebuild.api;

public class FlexibleLibrary : ModuleBase
{
    [ModuleOption(Description = "Enable exports for DLL", ChangesResultBinary = true)]
    public bool EnableExports = false;

    public FlexibleLibrary(ModuleContext context) : base(context)
    {
        // Default to static library
        Name = "FlexibleLibrary";
        Type = ModuleType.StaticLibrary;
        CppStandard = CppStandards.Cpp17;

        SourceFiles.AddRange(
            ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "h")
        );

        Includes.Public.Add("include");
    }

    [OutputTransformer("shared", "shared")]
    public void BuildAsSharedLibrary()
    {
        Type = ModuleType.SharedLibrary;
        Definitions.Public.Add(new Definition("LIBRARY_DLL"));
        Definitions.Private.Add(new Definition("LIBRARY_EXPORTS"));

        if (Context.Platform.Name == "windows")
        {
            Definitions.Public.Add(new Definition("DLLEXPORT=__declspec(dllexport)"));
        }
        else
        {
            CompilerOptions.Add("-fvisibility=default");
        }
    }

    [OutputTransformer("static", "static")]
    public void BuildAsStaticLibrary()
    {
        Type = ModuleType.StaticLibrary;
        Definitions.Public.Add(new Definition("LIBRARY_STATIC"));
    }

    [OutputTransformer("header-only", "header")]
    public void BuildHeaderOnly()
    {
        Type = ModuleType.StaticLibrary;
        SourceFiles.Clear(); // No compilation needed
        Definitions.Public.Add(new Definition("LIBRARY_HEADER_ONLY"));
    }
}
```

--------------------------------

### Build Executable Module with Dependencies in C# DSL

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This C# code creates an executable module that depends on a static library module, handling platform-specific dependencies and build steps. It uses ebuild.api for classes like ModuleBase and ModuleReference, and supports additional file copying. Limitations include manual handling of asynchronous pre-build steps and platform conditionals.

```csharp
using ebuild.api;

public class MyApplication : ModuleBase
{
    public MyApplication(ModuleContext context) : base(context)
    {
        Name = "MyApplication";
        Type = ModuleType.Executable;
        CppStandard = CppStandards.Cpp20;

        // Source files
        SourceFiles.AddRange(
            ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "h")
        );

        // Depend on library module
        Dependencies.Public.Add(new ModuleReference("../MyLibrary/library.ebuild.cs"));

        // Additional dependencies are copied to output directory
        AdditionalDependencies.Public.Add(new AdditionalDependency
        {
            Type = DependencyType.File,
            DependencyPath = "assets/config.json",
            TargetDirectory = "${OutputDir}/config"
        });

        // Platform-specific configuration
        if (Context.Platform.Name == "windows")
        {
            Definitions.Private.Add(new Definition("PLATFORM_WINDOWS"));
            Libraries.Public.Add("user32.lib");
        }
        else if (Context.Platform.Name == "unix")
        {
            Definitions.Private.Add(new Definition("PLATFORM_UNIX"));
            Libraries.Public.Add("pthread");
        }

        // Pre-build and post-build steps
        PreBuildSteps.Add(new ModuleBuildStep(
            "Generate Version Header",
            async (module, token) =>
            {
                var versionFile = Path.Combine(
                    module.Context.ModuleDirectory.FullName,
                    "src/version.h"
                );
                await File.WriteAllTextAsync(
                    versionFile,
                    "#define APP_VERSION \"" + DateTime.Now.ToString("yyyyMMdd") + "\"\n",
                    token
                );
                return true;
            }
        ));
    }
}
```

--------------------------------

### Managing Dependencies and Libraries in EBuild (C#)

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

This snippet handles public/private dependencies, library additions, and search paths, including additional file dependencies. It uses ModuleReference for modules and strings for libraries. Inputs are paths and references; outputs link during build. Limitations: Transitive dependencies only for public ones.

```csharp
Dependencies.Public.Add(new ModuleReference("CoreLibrary"));

Dependencies.Private.Add(new ModuleReference("ThirdPartyLib"));

Libraries.Public.AddRange(new[] { "SomeLibrary.lib", "AnotherLibrary.lib" });
LibrarySearchPaths.Public.Add("third_party/lib");

AdditionalDependencies.Public.Add(new AdditionalDependency
{
    SourcePath = "path/to/file",
    DestinationPath = "relative/dest",
    IsDirectory = false
});
```

--------------------------------

### Visualize Build Graphs

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This command generates a visual representation of the module dependencies, which helps in understanding the overall build structure and identifying potential issues. The format can be specified as either an ASCII tree or an interactive HTML visualization. Configuration options allow for generating graphs for different build configurations.

```bash
# Generate ASCII tree representation
ebuid generate buildgraph path/to/module.ebuild.cs --format String

```

```bash
# Generate interactive HTML visualization
ebuid generate buildgraph path/to/module.ebuild.cs --format Html -o graph.html

```

```bash
# Generate for specific configuration
ebuid generate buildgraph path/to/module.ebuild.cs --format Html --configuration release

```

--------------------------------

### Configurable Module with Options (C#)

Source: https://context7.com/yldrefruz/ebuild/llms.txt

Defines a C# module using ebuild's ModuleOptionAttribute to allow for configurable build parameters such as debug symbols, advanced features, and optimization modes. These options can change the resulting binary, enabling variant builds. The constructor applies these options to the build configuration by adding definitions, source files, and setting optimization levels.

```csharp
using ebuild.api;

public class ConfigurableModule : ModuleBase
{
    [ModuleOption(
        Description = "Enable debug symbols and logging",
        ChangesResultBinary = true,
        Default = "false"
    )]
    public bool EnableDebug = false;

    [ModuleOption(
        Description = "Enable advanced features",
        ChangesResultBinary = true,
        Default = "false"
    )]
    public bool EnableAdvancedFeatures = false;

    [ModuleOption(
        Description = "Optimization mode: size or speed",
        ChangesResultBinary = true,
        Required = false,
        Default = "speed"
    )]
    public string OptimizationMode = "speed";

    public ConfigurableModule(ModuleContext context) : base(context)
    {
        Name = "ConfigurableModule";
        Type = ModuleType.StaticLibrary;
        UseVariants = true; // Enable variant directory structure

        SourceFiles.AddRange(
            ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "h")
        );

        // Apply options to build configuration
        if (EnableDebug)
        {
            Definitions.Private.Add(new Definition("DEBUG_BUILD"));
            Definitions.Private.Add(new Definition("ENABLE_LOGGING"));
            EnableDebugFileCreation = true;
        }

        if (EnableAdvancedFeatures)
        {
            Definitions.Private.Add(new Definition("ADVANCED_FEATURES"));
            SourceFiles.Add("src/advanced/features.cpp");
        }

        if (OptimizationMode == "size")
        {
            OptimizationLevel = OptimizationLevel.Size;
        }
        else
        {
            OptimizationLevel = OptimizationLevel.Speed;
        }
    }
}
```

--------------------------------

### Generate Compilation Database (compile_commands.json)

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This command generates a `compile_commands.json` file, which is commonly used for IDE integration with tools like CLion and Visual Studio Code. It allows the IDE to understand the build process and provide features like code completion and error highlighting. Optional flags can specify dependencies, output location, and build configuration.

```bash
# Generate compile_commands.json for the module
ebuid generate compile_commands.json path/to/module.ebuild.cs

```

```bash
# Generate including all dependencies
ebuid generate compile_commands.json path/to/module.ebuild.cs --dependencies

```

```bash
# Output to custom location
ebuid generate compile_commands.json path/to/module.ebuild.cs -o custom/path/compile_commands.json

```

```bash
# Generate with specific configuration
ebuid generate compile_commands.json path/to/module.ebuild.cs --configuration debug

```

```bash
# Generate for specific toolchain
ebuid generate compile_commands.json path/to/module.ebuild.cs --toolchain gcc

```

--------------------------------

### Advanced Compiler Settings in EBuild (C#)

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

This code configures C/C++ standards, optimization levels, and features like exceptions and RTTI. Settings are set on the module instance and depend on the build context. Inputs include enums for standards and booleans for features; outputs adjust compiler flags. Limitations: Not all toolchains support every option equally.

```csharp
CStandard = CStandards.C17;               // C standard
CppStandard = CppStandards.Cpp20;         // C++ standard
OptimizationLevel = OptimizationLevel.O2; // Optimization
EnableExceptions = true;
EnableRTTI = true;
EnableFastFloatingPointOperations = true;

CppStandard = CppStandards.Cpp20;
OptimizationLevel = context.Configuration == "release" 
    ? OptimizationLevel.Speed 
    : OptimizationLevel.None;
```

--------------------------------

### Generate Module File using EBuild CLI

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Generates a scaffolded module file or updates the C# solution to include module dependencies. It supports options for specifying the output file, forcing overwrites, updating the solution, selecting a template, and passing template options.

```bash
ebuild generate module <module-file> [options]

Options:
- -o, --outfile <path>: (when generating) the module file to create (default: `index.ebuild.cs`)
- -f, --force: Overwrite an existing module file
- -u, --update: Update the solution (.sln) to include dependencies of the module
- -t, --template <name>: Module template to use (default: `default`)
- -O, --template-options <key=value;...>: Semicolon-separated key=value pairs passed to the template generator
```

--------------------------------

### Define a Configurable Module with Options in C#

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Defines a module in C# that includes configurable options using the `[ModuleOption]` attribute. These options can be set via the command line and affect the build process. Demonstrates setting preprocessor definitions and compiler options based on module option values.

```csharp
public class ConfigurableModule : ModuleBase
{
    [ModuleOption(Description = "Enable debug logging", ChangesResultBinary = true)]
    public bool EnableDebug = false;
    
    [ModuleOption(Description = "Optimization level", ChangesResultBinary = true)]
    public int OptimizationLevel = 2;
    
    [ModuleOption(Description = "Custom define", ChangesResultBinary = false)]
    public string CustomDefine = "DEFAULT";
    
    public ConfigurableModule(ModuleContext context) : base(context)
    {
        Name = "ConfigurableModule";
        Type = ModuleType.StaticLibrary;
        
        // Use options in configuration
        if (EnableDebug)
        {
            Definitions.Public.Add("ENABLE_DEBUG=1");
        }
        
        CompilerOptions.Add($"/O{OptimizationLevel}");
    }
}
```

--------------------------------

### Add New Linker to EBuild

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Illustrates how to add a custom linker by extending LinkerBase and implementing a factory. The factory determines if the linker can be created for a given module.

```csharp
using ebuild.api.Linker;

public class MyLinker : LinkerBase
{
    public override async Task<bool> Link(LinkerSettings settings, CancellationToken cancellationToken)
    {
        // Implement linking logic
        // Access settings.ObjectFiles, settings.OutputFile, etc.
        // Return true on success
    }
}

public class MyLinkerFactory : ILinkerFactory
{
    public string Name => "my.linker";
    public Type LinkerType => typeof(MyLinker);
    
    public bool CanCreate(ModuleBase module, IModuleInstancingParams instancingParams)
    {
        return module.Type != ModuleType.StaticLibrary;
    }
    
    public LinkerBase CreateLinker(ModuleBase module, IModuleInstancingParams instancingParams)
    {
        return new MyLinker();
    }
}
```

--------------------------------

### Setting Preprocessor Definitions in EBuild (C#)

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

This code shows adding public, private, and global preprocessor definitions to modules. Definitions are applied during compilation and can be conditional. Inputs are key-value strings; outputs modify the build environment. No major limitations, but global definitions affect all modules.

```csharp
Definitions.Public.Add("MY_DEFINE=1");
Definitions.Private.Add("INTERNAL_USE");
GlobalDefinitions.Add("GLOBAL_DEFINE"); // Applied to all modules

Definitions.Public.Add("API_VERSION=2");
if (EnableExtraFeatures)
{
    Definitions.Public.Add("EXTRA_FEATURES=1");
}
```

--------------------------------

### Control Dependency Visibility (C#)

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This code illustrates how to manage the visibility of includes, definitions, dependencies, and libraries for modules within the ebuild system. It differentiates between public (exposed to dependents) and private (internal to the module) elements, ensuring controlled transitive behavior for build configurations.

```csharp
using ebuild.api;

public class LibraryModule : ModuleBase
{
    public LibraryModule(ModuleContext context) : base(context)
    {
        Name = "LibraryModule";
        Type = ModuleType.StaticLibrary;

        // Public includes are exposed to dependent modules
        Includes.Public.Add("include");

        // Private includes are only used for compiling this module
        Includes.Private.Add("src/internal");
        Includes.Private.Add("third-party/private-lib/include");

        // Public definitions visible to dependents
        Definitions.Public.Add(new Definition("LIBRARY_VERSION=2.0"));
        Definitions.Public.Add(new Definition("LIBRARY_FEATURE_X"));

        // Private definitions only used internally
        Definitions.Private.Add(new Definition("INTERNAL_DEBUG"));
        Definitions.Private.Add(new Definition("USE_FAST_ALLOCATOR"));

        // Public dependencies are transitive - dependents also link these
        Dependencies.Public.Add(
            new ModuleReference("../CoreUtilities/utils.ebuild.cs")
        );

        // Private dependencies are not exposed to dependents
        Dependencies.Private.Add(
            new ModuleReference("../InternalHelpers/helpers.ebuild.cs")
        );

        // Public libraries are linked by dependents
        Libraries.Public.Add("ws2_32.lib");

        // Private libraries only linked for this module
        Libraries.Private.Add("internal-compression.lib");

        SourceFiles.AddRange(
            ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "h")
        );
    }
}

public class ApplicationModule : ModuleBase
{
    public ApplicationModule(ModuleContext context) : base(context)
    {
        Name = "Application";
        Type = ModuleType.Executable;

        // Depends on LibraryModule
        Dependencies.Public.Add(
            new ModuleReference("../LibraryModule/library.ebuild.cs")
        );

        // Application automatically gets:
        // - LibraryModule's public includes (include/)
        // - LibraryModule's public definitions (LIBRARY_VERSION, LIBRARY_FEATURE_X)
        // - LibraryModule's public dependencies (CoreUtilities)
        // - LibraryModule's public libraries (ws2_32.lib)
        //
        // Application does NOT get:
        // - LibraryModule's private includes (src/internal, third-party/private-lib/include)
        // - LibraryModule's private definitions (INTERNAL_DEBUG, USE_FAST_ALLOCATOR)
        // - LibraryModule's private dependencies (InternalHelpers)
        // - LibraryModule's private libraries (internal-compression.lib)

        SourceFiles.AddRange(
            ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "h")
        );
    }
}
```

--------------------------------

### Generate Build Graph using EBuild CLI

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Generates a visual representation of the build dependency graph for a given module file. Supports outputting the graph in String or Html format.

```bash
ebuild generate buildgraph <module-file> [options]

Options:
- --format <format>: Output format - `String` or `Html` (default: `String`)
```

--------------------------------

### Strip Debug Symbols from Binary (C#)

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This snippet demonstrates how to strip debug symbols from a binary file using a C# process. It utilizes the `ProcessStartInfo` class to configure and execute an external command, likely a stripping utility. The function waits for the process to complete and checks the exit code to confirm success.

```csharp
using System.Diagnostics;
using System.Threading.Tasks;
using System.Threading;

// ... within a method context ...

var processInfo = new ProcessStartInfo
{
    FileName = "strip", // Assumes 'strip' command is in PATH
    Arguments = $"--strip-all \"{binaryPath}\"",
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    UseShellExecute = false
};

using (var process = Process.Start(processInfo))
{
    if (process == null)
    {
        // Handle error: process could not be started
        Console.Error.WriteLine("Error: Failed to start stripping process.");
        return false; // Or throw an exception
    }
    await process.WaitForExitAsync(token);

    if (process.ExitCode == 0)
    {
        Console.WriteLine($"Stripped debug symbols from {binaryPath}");
        return true;
    }
    else
    {
        // Handle error: stripping failed
        string errorOutput = await process.StandardError.ReadToEndAsync();
        Console.Error.WriteLine($"Error stripping {binaryPath}: Exit code {process.ExitCode}");
        Console.Error.WriteLine(errorOutput);
        return false; // Or throw an exception
    }
}
```

--------------------------------

### Define Static Library Module in C# DSL

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This C# code defines a basic static library module inheriting from ModuleBase, configuring includes, sources, definitions, and libraries. It depends on the ebuild.api namespace and ModuleUtilities for file gathering. The module is executable in EBuild to produce a library with public interfaces for dependent modules.

```csharp
using ebuild.api;

public class MyLibrary : ModuleBase
{
    public MyLibrary(ModuleContext context) : base(context)
    {
        // Module identity
        Name = "MyLibrary";
        Type = ModuleType.StaticLibrary;

        // C++ standard configuration
        CppStandard = CppStandards.Cpp20;

        // Include directories (public = exposed to dependents)
        Includes.Public.Add("include");
        Includes.Private.Add("src/internal");

        // Gather source files recursively
        SourceFiles.AddRange(
            ModuleUtilities.GetAllSourceFiles(this, "src", "cpp", "c", "h")
        );

        // Compiler definitions
        Definitions.Public.Add(new Definition("MY_LIBRARY_VERSION=1.0"));
        Definitions.Private.Add(new Definition("INTERNAL_BUILD"));

        // Libraries to link
        Libraries.Public.Add("ws2_32.lib");
        LibrarySearchPaths.Public.Add("lib/x64");

        // Optimization settings
        OptimizationLevel = OptimizationLevel.Speed;
        CPUExtension = CPUExtensions.AVX2;
    }
}
```

--------------------------------

### Detect Circular Dependencies

Source: https://context7.com/yldrefruz/ebuild/llms.txt

This command checks for circular dependencies in the Ebuild module and reports any detected cycles. Circular dependencies can cause build failures and are often indicative of design flaws. The command also provides an option to print the full dependency tree for debugging purposes.

```bash
# Check for circular dependencies
ebuid check circular-dependencies path/to/module.ebuild.cs

```

```bash
# Print full dependency tree
ebuid check print-dependencies path/to/module.ebuild.cs

```

```bash
# Check with specific configuration
ebuid check circular-dependencies path/to/module.ebuild.cs --configuration debug

```

--------------------------------

### Check for Circular Dependencies using EBuild CLI

Source: https://github.com/yldrefruz/ebuild/blob/main/README.md

Detects and reports circular dependency chains within the module graph for a specified module file.

```bash
ebuild check circular-dependencies <module-file>
```
Tokens:
Raw