std: collect all options under one namespace

Author: Vexu

lib/std/crypto/tlcsprng.zig

@@ -5,7 +5,6 @@
 
 const std = @import("std");
 const builtin = @import("builtin");
-const root = @import("root");
 const mem = std.mem;
 const os = std.os;
 
@@ -67,8 +66,8 @@ fn tlsCsprngFill(_: *anyopaque, buffer: []u8) void {
     // Allow applications to decide they would prefer to have every call to
     // std.crypto.random always make an OS syscall, rather than rely on an
     // application implementation of a CSPRNG.
-    if (comptime std.meta.globalOption("crypto_always_getrandom", bool) orelse false) {
-        return fillWithOsEntropy(buffer);
+    if (std.options.crypto_always_getrandom) {
+        return defaultRandomSeed(buffer);
     }
 
     if (wipe_mem.len == 0) {
@@ -86,7 +85,7 @@ fn tlsCsprngFill(_: *anyopaque, buffer: []u8) void {
             ) catch {
                 // Could not allocate memory for the local state, fall back to
                 // the OS syscall.
-                return fillWithOsEntropy(buffer);
+                return std.options.cryptoRandomSeed(buffer);
             };
             // The memory is already zero-initialized.
         } else {
@@ -128,14 +127,14 @@ fn tlsCsprngFill(_: *anyopaque, buffer: []u8) void {
             // Since we failed to set up fork safety, we fall back to always
             // calling getrandom every time.
             ctx.init_state = .failed;
-            return fillWithOsEntropy(buffer);
+            return std.options.cryptoRandomSeed(buffer);
         },
         .initialized => {
             return fillWithCsprng(buffer);
         },
         .failed => {
             if (want_fork_safety) {
-                return fillWithOsEntropy(buffer);
+                return std.options.cryptoRandomSeed(buffer);
             } else {
                 unreachable;
             }
@@ -165,7 +164,7 @@ fn fillWithCsprng(buffer: []u8) void {
     mem.set(u8, ctx.gimli.toSlice()[0..std.crypto.core.Gimli.RATE], 0);
 }
 
-fn fillWithOsEntropy(buffer: []u8) void {
+pub fn defaultRandomSeed(buffer: []u8) void {
     os.getrandom(buffer) catch @panic("getrandom() failed to provide entropy");
 }
 
@@ -174,12 +173,8 @@ fn initAndFill(buffer: []u8) void {
     // Because we panic on getrandom() failing, we provide the opportunity
     // to override the default seed function. This also makes
     // `std.crypto.random` available on freestanding targets, provided that
-    // the `cryptoRandomSeed` function is provided.
-    if (@hasDecl(root, "cryptoRandomSeed")) {
-        root.cryptoRandomSeed(&seed);
-    } else {
-        fillWithOsEntropy(&seed);
-    }
+    // the `std.options.cryptoRandomSeed` function is provided.
+    std.options.cryptoRandomSeed(&seed);
 
     const ctx = @ptrCast(*Context, wipe_mem.ptr);
     ctx.gimli = std.crypto.core.Gimli.init(seed);

lib/std/debug.zig

@@ -1861,10 +1861,9 @@ pub const have_segfault_handling_support = switch (native_os) {
     .freebsd, .openbsd => @hasDecl(os.system, "ucontext_t"),
     else => false,
 };
-pub const enable_segfault_handler: bool = if (@hasDecl(root, "enable_segfault_handler"))
-    root.enable_segfault_handler
-else
-    runtime_safety and have_segfault_handling_support;
+
+const enable_segfault_handler = std.options.enable_segfault_handler;
+pub const default_enable_segfault_handler = runtime_safety and have_segfault_handling_support;
 
 pub fn maybeEnableSegfaultHandler() void {
     if (enable_segfault_handler) {

lib/std/event/batch.zig

@@ -17,7 +17,7 @@ pub fn Batch(
     comptime async_behavior: enum {
         /// Observe the value of `std.io.is_async` to decide whether `add`
         /// and `wait` will be async functions. Asserts that the jobs do not suspend when
-        /// `std.io.mode == .blocking`. This is a generally safe assumption, and the
+        /// `std.options.io_mode == .blocking`. This is a generally safe assumption, and the
         /// usual recommended option for this parameter.
         auto_async,
 

lib/std/event/loop.zig

@@ -1,6 +1,5 @@
 const std = @import("../std.zig");
 const builtin = @import("builtin");
-const root = @import("root");
 const assert = std.debug.assert;
 const testing = std.testing;
 const mem = std.mem;
@@ -104,25 +103,29 @@ pub const Loop = struct {
         };
     };
 
-    const LoopOrVoid = switch (std.io.mode) {
-        .blocking => void,
-        .evented => Loop,
+    pub const Instance = switch (std.options.io_mode) {
+        .blocking => @TypeOf(null),
+        .evented => ?*Loop,
     };
+    pub const instance = std.options.event_loop;
 
-    var global_instance_state: LoopOrVoid = undefined;
-    const default_instance: ?*LoopOrVoid = switch (std.io.mode) {
+    var global_instance_state: Loop = undefined;
+    pub const default_instance = switch (std.options.io_mode) {
         .blocking => null,
         .evented => &global_instance_state,
     };
-    pub const instance: ?*LoopOrVoid = if (@hasDecl(root, "event_loop")) root.event_loop else default_instance;
+
+    pub const Mode = enum {
+        single_threaded,
+        multi_threaded,
+    };
+    pub const default_mode = .multi_threaded;
 
     /// TODO copy elision / named return values so that the threads referencing *Loop
     /// have the correct pointer value.
     /// https://github.com/ziglang/zig/issues/2761 and https://github.com/ziglang/zig/issues/2765
     pub fn init(self: *Loop) !void {
-        if (builtin.single_threaded or
-            (@hasDecl(root, "event_loop_mode") and root.event_loop_mode == .single_threaded))
-        {
+        if (builtin.single_threaded or std.options.event_loop_mode == .single_threaded) {
             return self.initSingleThreaded();
         } else {
             return self.initMultiThreaded();

lib/std/fs.zig

@@ -2661,17 +2661,17 @@ pub fn cwd() Dir {
     if (builtin.os.tag == .windows) {
         return Dir{ .fd = os.windows.peb().ProcessParameters.CurrentDirectory.Handle };
     } else if (builtin.os.tag == .wasi) {
-        if (@hasDecl(root, "wasi_cwd")) {
-            return root.wasi_cwd();
-        } else {
-            // Expect the first preopen to be current working directory.
-            return .{ .fd = 3 };
-        }
+        return std.options.wasiCwd();
     } else {
         return Dir{ .fd = os.AT.FDCWD };
     }
 }
 
+pub fn defaultWasiCwd() Dir {
+    // Expect the first preopen to be current working directory.
+    return .{ .fd = 3 };
+}
+
 /// Opens a directory at the given path. The directory is a system resource that remains
 /// open until `close` is called on the result.
 /// See `openDirAbsoluteZ` for a function that accepts a null-terminated path.

lib/std/fs/file.zig

@@ -21,7 +21,7 @@ pub const File = struct {
     /// blocking.
     capable_io_mode: io.ModeOverride = io.default_mode,
 
-    /// Furthermore, even when `std.io.mode` is async, it is still sometimes desirable
+    /// Furthermore, even when `std.options.io_mode` is async, it is still sometimes desirable
     /// to perform blocking I/O, although not by default. For example, when printing a
     /// stack trace to stderr. This field tracks both by acting as an overriding I/O mode.
     /// When not building in async I/O mode, the type only has the `.blocking` tag, making

lib/std/io.zig

@@ -19,14 +19,7 @@ pub const Mode = enum {
     evented,
 };
 
-/// The application's chosen I/O mode. This defaults to `Mode.blocking` but can be overridden
-/// by `root.event_loop`.
-pub const mode: Mode = if (@hasDecl(root, "io_mode"))
-    root.io_mode
-else if (@hasDecl(root, "event_loop"))
-    Mode.evented
-else
-    Mode.blocking;
+const mode = std.options.io_mode;
 pub const is_async = mode != .blocking;
 
 /// This is an enum value to use for I/O mode at runtime, since it takes up zero bytes at runtime,

lib/std/log.zig

@@ -1,6 +1,6 @@
 //! std.log is a standardized interface for logging which allows for the logging
 //! of programs and libraries using this interface to be formatted and filtered
-//! by the implementer of the root.log function.
+//! by the implementer of the `std.options.logFn` function.
 //!
 //! Each log message has an associated scope enum, which can be used to give
 //! context to the logging. The logging functions in std.log implicitly use a
@@ -13,16 +13,20 @@
 //! `const log = std.log.scoped(.libfoo);` to use .libfoo as the scope of its
 //! log messages.
 //!
-//! An example root.log might look something like this:
+//! An example `logFn` might look something like this:
 //!
 //! ```
 //! const std = @import("std");
 //!
-//! // Set the log level to info
-//! pub const log_level: std.log.Level = .info;
+//! pub const std_options = struct {
+//!     // Set the log level to info
+//!     pub const log_level = .info;
 //!
-//! // Define root.log to override the std implementation
-//! pub fn log(
+//!     // Define logFn to override the std implementation
+//!     pub const logFn = myLogFn;
+//! };
+//!
+//! pub fn myLogFn(
 //!     comptime level: std.log.Level,
 //!     comptime scope: @TypeOf(.EnumLiteral),
 //!     comptime format: []const u8,
@@ -70,7 +74,6 @@
 
 const std = @import("std.zig");
 const builtin = @import("builtin");
-const root = @import("root");
 
 pub const Level = enum {
     /// Error: something has gone wrong. This might be recoverable or might
@@ -102,22 +105,14 @@ pub const default_level: Level = switch (builtin.mode) {
     .ReleaseFast, .ReleaseSmall => .err,
 };
 
-/// The current log level. This is set to root.log_level if present, otherwise
-/// log.default_level.
-pub const level: Level = if (@hasDecl(root, "log_level"))
-    root.log_level
-else
-    default_level;
+const level = std.options.log_level;
 
 pub const ScopeLevel = struct {
     scope: @Type(.EnumLiteral),
     level: Level,
 };
 
-const scope_levels = if (@hasDecl(root, "scope_levels"))
-    root.scope_levels
-else
-    [0]ScopeLevel{};
+const scope_levels = std.options.log_scope_levels;
 
 fn log(
     comptime message_level: Level,
@@ -127,13 +122,7 @@ fn log(
 ) void {
     if (comptime !logEnabled(message_level, scope)) return;
 
-    if (@hasDecl(root, "log")) {
-        if (@typeInfo(@TypeOf(root.log)) != .Fn)
-            @compileError("Expected root.log to be a function");
-        root.log(message_level, scope, format, args);
-    } else {
-        defaultLog(message_level, scope, format, args);
-    }
+    std.options.logFn(message_level, scope, format, args);
 }
 
 /// Determine if a specific log message level and scope combination are enabled for logging.
@@ -149,8 +138,8 @@ pub fn defaultLogEnabled(comptime message_level: Level) bool {
     return comptime logEnabled(message_level, default_log_scope);
 }
 
-/// The default implementation for root.log.  root.log may forward log messages
-/// to this function.
+/// The default implementation for the log function, custom log functions may
+/// forward log messages to this function.
 pub fn defaultLog(
     comptime message_level: Level,
     comptime scope: @Type(.EnumLiteral),

lib/std/start.zig

@@ -527,7 +527,7 @@ const bad_main_ret = "expected return type of main to be 'void', '!void', 'noret
 // and we want fewer call frames in stack traces.
 inline fn initEventLoopAndCallMain() u8 {
     if (std.event.Loop.instance) |loop| {
-        if (!@hasDecl(root, "event_loop")) {
+        if (loop == std.event.Loop.default_instance) {
             loop.init() catch |err| {
                 std.log.err("{s}", .{@errorName(err)});
                 if (@errorReturnTrace()) |trace| {
@@ -556,7 +556,7 @@ inline fn initEventLoopAndCallMain() u8 {
 // because it is working around stage1 compiler bugs.
 inline fn initEventLoopAndCallWinMain() std.os.windows.INT {
     if (std.event.Loop.instance) |loop| {
-        if (!@hasDecl(root, "event_loop")) {
+        if (loop == std.event.Loop.default_instance) {
             loop.init() catch |err| {
                 std.log.err("{s}", .{@errorName(err)});
                 if (@errorReturnTrace()) |trace| {

lib/std/std.zig

@@ -94,10 +94,79 @@ pub const wasm = @import("wasm.zig");
 pub const zig = @import("zig.zig");
 pub const start = @import("start.zig");
 
+const root = @import("root");
+const options_override = if (@hasDecl(root, "std_options")) root.std_options else struct {};
+
+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 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;
+};
+
 // 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 {