zig/lib/std/std.zig

pub const ArrayHashMap = array_hash_map.ArrayHashMap;
pub const ArrayHashMapUnmanaged = array_hash_map.ArrayHashMapUnmanaged;
pub const ArrayList = @import("array_list.zig").ArrayList;
pub const ArrayListAligned = @import("array_list.zig").ArrayListAligned;
pub const ArrayListAlignedUnmanaged = @import("array_list.zig").ArrayListAlignedUnmanaged;
pub const ArrayListUnmanaged = @import("array_list.zig").ArrayListUnmanaged;
pub const AutoArrayHashMap = array_hash_map.AutoArrayHashMap;
pub const AutoArrayHashMapUnmanaged = array_hash_map.AutoArrayHashMapUnmanaged;
pub const AutoHashMap = hash_map.AutoHashMap;
pub const AutoHashMapUnmanaged = hash_map.AutoHashMapUnmanaged;
pub const BitStack = @import("BitStack.zig");
pub const BoundedArray = @import("bounded_array.zig").BoundedArray;
pub const BoundedArrayAligned = @import("bounded_array.zig").BoundedArrayAligned;
pub const Build = @import("Build.zig");
pub const BufMap = @import("buf_map.zig").BufMap;
pub const BufSet = @import("buf_set.zig").BufSet;
/// Deprecated: use `process.Child`.
pub const ChildProcess = @import("child_process.zig").ChildProcess;
pub const ComptimeStringMap = comptime_string_map.ComptimeStringMap;
pub const ComptimeStringMapWithEql = comptime_string_map.ComptimeStringMapWithEql;
pub const DoublyLinkedList = @import("linked_list.zig").DoublyLinkedList;
pub const DynLib = @import("dynamic_library.zig").DynLib;
pub const DynamicBitSet = bit_set.DynamicBitSet;
pub const DynamicBitSetUnmanaged = bit_set.DynamicBitSetUnmanaged;
pub const EnumArray = enums.EnumArray;
pub const EnumMap = enums.EnumMap;
pub const EnumSet = enums.EnumSet;
pub const HashMap = hash_map.HashMap;
pub const HashMapUnmanaged = hash_map.HashMapUnmanaged;
pub const Ini = @import("Ini.zig");
pub const MultiArrayList = @import("multi_array_list.zig").MultiArrayList;
pub const PackedIntArray = @import("packed_int_array.zig").PackedIntArray;
pub const PackedIntArrayEndian = @import("packed_int_array.zig").PackedIntArrayEndian;
pub const PackedIntSlice = @import("packed_int_array.zig").PackedIntSlice;
pub const PackedIntSliceEndian = @import("packed_int_array.zig").PackedIntSliceEndian;
pub const PriorityQueue = @import("priority_queue.zig").PriorityQueue;
pub const PriorityDequeue = @import("priority_dequeue.zig").PriorityDequeue;
pub const Progress = @import("Progress.zig");
pub const RingBuffer = @import("RingBuffer.zig");
pub const SegmentedList = @import("segmented_list.zig").SegmentedList;
pub const SemanticVersion = @import("SemanticVersion.zig");
pub const SinglyLinkedList = @import("linked_list.zig").SinglyLinkedList;
pub const StaticBitSet = bit_set.StaticBitSet;
pub const StringHashMap = hash_map.StringHashMap;
pub const StringHashMapUnmanaged = hash_map.StringHashMapUnmanaged;
pub const StringArrayHashMap = array_hash_map.StringArrayHashMap;
pub const StringArrayHashMapUnmanaged = array_hash_map.StringArrayHashMapUnmanaged;
/// deprecated: use `DoublyLinkedList`.
pub const TailQueue = DoublyLinkedList;
pub const Target = @import("target.zig").Target;
pub const Thread = @import("Thread.zig");
pub const Treap = @import("treap.zig").Treap;
pub const Tz = tz.Tz;
pub const Uri = @import("Uri.zig");

pub const array_hash_map = @import("array_hash_map.zig");

/// Memory ordering, atomic data structures, and operations.
pub const atomic = @import("atomic.zig");

/// Base64 encoding/decoding.
pub const base64 = @import("base64.zig");

/// Bit manipulation data structures.
pub const bit_set = @import("bit_set.zig");

/// Comptime-available information about the build environment, such as the target and optimize mode.
pub const builtin = @import("builtin.zig");

pub const c = @import("c.zig");

/// COFF format.
pub const coff = @import("coff.zig");

/// Compression algorithms such as zlib, zstd, etc.
pub const compress = @import("compress.zig");

pub const comptime_string_map = @import("comptime_string_map.zig");

/// Cryptography.
pub const crypto = @import("crypto.zig");

pub const cstr = @import("cstr.zig");

/// Debug printing, allocation and other debug helpers.
pub const debug = @import("debug.zig");

/// DWARF debugging data format.
pub const dwarf = @import("dwarf.zig");

/// ELF format.
pub const elf = @import("elf.zig");

/// Enum-related metaprogramming helpers.
pub const enums = @import("enums.zig");

/// Evented I/O data structures.
pub const event = @import("event.zig");

/// First in, first out data structures.
pub const fifo = @import("fifo.zig");

/// String formatting and parsing (e.g. parsing numbers out of strings).
pub const fmt = @import("fmt.zig");

/// File system-related functionality.
pub const fs = @import("fs.zig");

/// Fast hashing functions (i.e. not cryptographically secure).
pub const hash = @import("hash.zig");
pub const hash_map = @import("hash_map.zig");

/// Allocator implementations.
pub const heap = @import("heap.zig");

/// HTTP client and server.
pub const http = @import("http.zig");

/// I/O streams, reader/writer interfaces and common helpers.
pub const io = @import("io.zig");

/// JSON parsing and serialization.
pub const json = @import("json.zig");

/// LEB128 encoding.
pub const leb = @import("leb128.zig");

/// A standardized interface for logging.
pub const log = @import("log.zig");

/// Mach-O format.
pub const macho = @import("macho.zig");

/// Mathematical constants and operations.
pub const math = @import("math.zig");

/// Functions for comparing, searching, and manipulating memory.
pub const mem = @import("mem.zig");

/// Metaprogramming helpers.
pub const meta = @import("meta.zig");

/// Networking.
pub const net = @import("net.zig");

/// Wrappers around OS-specific APIs.
pub const os = @import("os.zig");

pub const once = @import("once.zig").once;

/// A set of array and slice types that bit-pack integer elements.
pub const packed_int_array = @import("packed_int_array.zig");

/// PDB file format.
pub const pdb = @import("pdb.zig");

/// Accessors for process-related info (e.g. command line arguments)
/// and spawning of child processes.
pub const process = @import("process.zig");

/// Fast pseudo-random number generators (i.e. not cryptographically secure).
pub const rand = @import("rand.zig");

/// Sorting.
pub const sort = @import("sort.zig");

/// Single Instruction Multiple Data (SIMD) helpers.
pub const simd = @import("simd.zig");

/// ASCII text processing.
pub const ascii = @import("ascii.zig");

/// Tar archive format compression/decompression.
pub const tar = @import("tar.zig");

/// Testing allocator, testing assertions, and other helpers for testing code.
pub const testing = @import("testing.zig");

/// Sleep, obtaining the current time, conversion constants, and more.
pub const time = @import("time.zig");

/// Time zones.
pub const tz = @import("tz.zig");

/// UTF-8 and UTF-16LE encoding/decoding.
pub const unicode = @import("unicode.zig");

/// Helpers for integrating with Valgrind.
pub const valgrind = @import("valgrind.zig");

/// Constants and types representing the Wasm binary format.
pub const wasm = @import("wasm.zig");

/// Tokenizing and parsing of Zig code and other Zig-specific language tooling.
pub const zig = @import("zig.zig");

pub const start = @import("start.zig");

/// deprecated: use `Build`.
pub const build = Build;

const root = @import("root");
const options_override = if (@hasDecl(root, "std_options")) root.std_options else struct {};

/// Stdlib-wide options that can be overridden by the root file.
pub const options = struct {
    pub const enable_segfault_handler: bool = if (@hasDecl(options_override, "enable_segfault_handler"))
        options_override.enable_segfault_handler
    else
        debug.default_enable_segfault_handler;

    /// Function used to implement `std.fs.cwd` for WASI.
    pub const wasiCwd: fn () fs.Dir = if (@hasDecl(options_override, "wasiCwd"))
        options_override.wasiCwd
    else
        fs.defaultWasiCwd;

    /// The application's chosen I/O mode.
    pub const io_mode: io.Mode = if (@hasDecl(options_override, "io_mode"))
        options_override.io_mode
    else if (@hasDecl(options_override, "event_loop"))
        .evented
    else
        .blocking;

    pub const event_loop: event.Loop.Instance = if (@hasDecl(options_override, "event_loop"))
        options_override.event_loop
    else
        event.Loop.default_instance;

    pub const event_loop_mode: event.Loop.Mode = if (@hasDecl(options_override, "event_loop_mode"))
        options_override.event_loop_mode
    else
        event.Loop.default_mode;

    /// The current log level.
    pub const log_level: log.Level = if (@hasDecl(options_override, "log_level"))
        options_override.log_level
    else
        log.default_level;

    pub const log_scope_levels: []const log.ScopeLevel = if (@hasDecl(options_override, "log_scope_levels"))
        options_override.log_scope_levels
    else
        &.{};

    pub const logFn: fn (
        comptime message_level: log.Level,
        comptime scope: @TypeOf(.enum_literal),
        comptime format: []const u8,
        args: anytype,
    ) void = if (@hasDecl(options_override, "logFn"))
        options_override.logFn
    else
        log.defaultLog;

    pub const fmt_max_depth = if (@hasDecl(options_override, "fmt_max_depth"))
        options_override.fmt_max_depth
    else
        fmt.default_max_depth;

    pub const cryptoRandomSeed: fn (buffer: []u8) void = if (@hasDecl(options_override, "cryptoRandomSeed"))
        options_override.cryptoRandomSeed
    else
        @import("crypto/tlcsprng.zig").defaultRandomSeed;

    pub const crypto_always_getrandom: bool = if (@hasDecl(options_override, "crypto_always_getrandom"))
        options_override.crypto_always_getrandom
    else
        false;

    /// By default Zig disables SIGPIPE by setting a "no-op" handler for it.  Set this option
    /// to `true` to prevent that.
    ///
    /// Note that we use a "no-op" handler instead of SIG_IGN because it will not be inherited by
    /// any child process.
    ///
    /// SIGPIPE is triggered when a process attempts to write to a broken pipe. By default, SIGPIPE
    /// will terminate the process instead of exiting.  It doesn't trigger the panic handler so in many
    /// cases it's unclear why the process was terminated.  By capturing SIGPIPE instead, functions that
    /// write to broken pipes will return the EPIPE error (error.BrokenPipe) and the program can handle
    /// it like any other error.
    pub const keep_sigpipe: bool = if (@hasDecl(options_override, "keep_sigpipe"))
        options_override.keep_sigpipe
    else
        false;

    pub const http_connection_pool_size = if (@hasDecl(options_override, "http_connection_pool_size"))
        options_override.http_connection_pool_size
    else
        http.Client.default_connection_pool_size;

    pub const side_channels_mitigations: crypto.SideChannelsMitigations = if (@hasDecl(options_override, "side_channels_mitigations"))
        options_override.side_channels_mitigations
    else
        crypto.default_side_channels_mitigations;
};

// This forces the start.zig file to be imported, and the comptime logic inside that
// file decides whether to export any appropriate start symbols, and call main.
comptime {
    _ = start;

    for (@typeInfo(options_override).Struct.decls) |decl| {
        if (!@hasDecl(options, decl.name)) @compileError("no option named " ++ decl.name);
    }
}

test {
    testing.refAllDecls(@This());
}