跨编译与WASM

// Import standard library for target querying and printing
const std = @import("std");
// Import builtin module to access compile-time host target information
const builtin = @import("builtin");

/// Entry point that demonstrates target discovery and cross-platform metadata inspection.
/// This example shows how to introspect both the host compilation target and parse
/// hypothetical cross-compilation targets without actually building for them.
pub fn main() void {
    // Print the host target triple (architecture-OS-ABI) by accessing builtin.target
    // This shows the platform Zig is currently compiling for
    std.debug.print(
        "host triple: {s}-{s}-{s}\n",
        .{
            @tagName(builtin.target.cpu.arch),
            @tagName(builtin.target.os.tag),
            @tagName(builtin.target.abi),
        },
    );

    // Display the pointer width for the host target
    // @bitSizeOf(usize) returns the size in bits of a pointer on the current platform
    std.debug.print("pointer width: {d} bits\n", .{@bitSizeOf(usize)});

    // Parse a WASI target query from a target triple string
    // This demonstrates how to inspect cross-compilation targets programmatically
    const wasm_query = std.Target.Query.parse(.{ .arch_os_abi = "wasm32-wasi" }) catch unreachable;
    describeQuery("wasm32-wasi", wasm_query);

    // Parse a Windows target query to show another cross-compilation scenario
    // The triple format follows: architecture-OS-ABI
    const windows_query = std.Target.Query.parse(.{ .arch_os_abi = "x86_64-windows-gnu" }) catch unreachable;
    describeQuery("x86_64-windows-gnu", windows_query);

    // Print whether the host target is configured for single-threaded execution
    // This compile-time constant affects runtime library behavior
    std.debug.print("single-threaded: {}\n", .{builtin.single_threaded});
}

/// Prints the resolved architecture, OS, and ABI for a given target query.
/// This helper demonstrates how to extract and display target metadata, using
/// the host target as a fallback when the query doesn't specify certain fields.
fn describeQuery(label: []const u8, query: std.Target.Query) void {
    std.debug.print(
        "query {s}: arch={s} os={s} abi={s}\n",
        .{
            label,
            // Fall back to host architecture if query doesn't specify one
            @tagName((query.cpu_arch orelse builtin.target.cpu.arch)),
            // Fall back to host OS if query doesn't specify one
            @tagName((query.os_tag orelse builtin.target.os.tag)),
            // Fall back to host ABI if query doesn't specify one
            @tagName((query.abi orelse builtin.target.abi)),
        },
    );
}

// Import the standard library for printing and platform utilities
const std = @import("std");
// Import builtin to access compile-time target information
const builtin = @import("builtin");

// Entry point that demonstrates cross-compilation by displaying target platform information
pub fn main() void {
    // Print the target platform's CPU architecture, OS, and ABI
    // Uses builtin.target to access compile-time target information
    std.debug.print("hello from {s}-{s}-{s}!\n", .{
        @tagName(builtin.target.cpu.arch),
        @tagName(builtin.target.os.tag),
        @tagName(builtin.target.abi),
    });

    // Retrieve the platform-specific executable file extension (e.g., ".exe" on Windows, "" on Linux)
    const suffix = std.Target.Os.Tag.exeFileExt(builtin.target.os.tag, builtin.target.cpu.arch);
    std.debug.print("default executable suffix: {s}\n", .{suffix});
}

// Import standard library for debug printing capabilities
const std = @import("std");
// Import builtin module to access compile-time target information
const builtin = @import("builtin");

/// Prints a stage name to stderr for tracking execution flow.
/// This helper function demonstrates debug output in cross-platform contexts.
fn stage(name: []const u8) void {
    std.debug.print("stage: {s}\n", .{name});
}

/// Demonstrates conditional compilation based on target OS.
/// This example shows how Zig code can branch at compile-time depending on
/// whether it's compiled for WASI (WebAssembly System Interface) or native platforms.
/// The execution flow changes based on the target, illustrating cross-compilation capabilities.
pub fn main() void {
    // Simulate initial argument parsing stage
    stage("parse-args");
    // Simulate payload rendering stage
    stage("render-payload");

    // Compile-time branch: different entry points for WASI vs native targets
    // This demonstrates how Zig handles platform-specific code paths
    if (builtin.target.os.tag == .wasi) {
        stage("wasi-entry");
    } else {
        stage("native-entry");
    }

    // Print the actual OS tag name for the compilation target
    // @tagName converts the enum value to its string representation
    stage(@tagName(builtin.target.os.tag));
}