Blame: lib/std/std.zig - ziglang/zig

hash_map: rename to ArrayHashMap and add new HashMap implementation

2020-08-02 23:24:03 +02:00

								pub const ArrayHashMap = array_hash_map.ArrayHashMap;

							

std.Mutex: implement blocking mutexes on linux closes #1463 Thanks to Shawn Landden for the original pull request. This commit is based on that code.

2018-10-03 13:19:10 -04:00

								pub const ArrayList = @import("array_list.zig").ArrayList;

							

rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.

2020-05-10 02:05:54 -04:00

								pub const ArrayListAligned = @import("array_list.zig").ArrayListAligned;

							

hash_map: rename to ArrayHashMap and add new HashMap implementation

2020-08-02 23:24:03 +02:00

								pub const AutoArrayHashMap = array_hash_map.AutoArrayHashMap;

							

std: expose unmanaged hash maps These are useful when you have many of them in memory, and already have the allocator stored elsewhere.

2020-07-06 06:10:03 +00:00

								pub const AutoHashMap = hash_map.AutoHashMap;

							

std.json: Unify stringify and writeStream (#16405)

2023-07-21 19:56:46 -04:00

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

							

BoundedArray: a simple way to represent small data whose max size is known (#9134) This is a simple structure containing an array and a length, that can be viewed as a slice. It is useful to pass-by-copy small data whose exact size is known at runtime, but whose maximum size is known at comptime. This greatly simplifies code that otherwise would require an allocator, or reimplementing what this type does.

2021-08-24 13:59:28 +02:00

								pub const BoundedArray = @import("bounded_array.zig").BoundedArray;

							

add BoundedArrayAligned (#14580) This is useful for creating byte buffers of actually-different-things. Copied the argument order from `Allocator.alignedAlloc` I noted that `ArrayListAligned` is going out of it's way to not set the alignment at comptime when it is not specified. However, I was not able to do that the same way here, and good people on IRC, @ifreund in particular (thanks!) assured me that [N]T align(@alignOf(T)) is equivalent to [N]T

2023-03-17 18:50:25 +02:00

								pub const BoundedArrayAligned = @import("bounded_array.zig").BoundedArrayAligned;

							

combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time.

2023-01-31 00:19:51 -07:00

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

							

std: rename List to ArrayList and re-organize... ...the exports of std. closes #356

2017-05-04 14:05:06 -04:00

								pub const BufMap = @import("buf_map.zig").BufMap;

							

ComptimeStringMap: return a regular struct and optimize this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here https://github.com/ziglang/zig/pull/19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * new public methods * `keys()`, `values()` helpers * `init(allocator)`, `deinit(allocator)` for runtime data * `getLongestPrefix(str)`, `getLongestPrefixIndex(str)` - i'm not sure these belong but have left in for now incase they are deemed useful * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed a speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full output in link above.

2024-04-20 23:14:39 -07:00

								pub const StaticStringMap = static_string_map.StaticStringMap;

							

de-genericify DoublyLinkedList by making it always intrusive, we make it more broadly useful API, and avoid binary bloat.

2025-04-03 15:35:21 -07:00

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

							

std.Mutex: implement blocking mutexes on linux closes #1463 Thanks to Shawn Landden for the original pull request. This commit is based on that code.

2018-10-03 13:19:10 -04:00

								pub const DynLib = @import("dynamic_library.zig").DynLib;

							

Add some bit set variants

2021-02-04 23:04:49 -06:00

								pub const DynamicBitSet = bit_set.DynamicBitSet;

							

Add some enum utilities

2021-03-06 18:25:04 -06:00

								pub const EnumArray = enums.EnumArray;

							

std: expose unmanaged hash maps These are useful when you have many of them in memory, and already have the allocator stored elsewhere.

2020-07-06 06:10:03 +00:00

								pub const HashMap = hash_map.HashMap;

							

add std.MultiArrayList Also known as "Struct-Of-Arrays" or "SOA". The purpose of this data structure is to provide a similar API to ArrayList but instead of the element type being a struct, the fields of the struct are in N different arrays, all with the same length and capacity. Having this abstraction means we can put them in the same allocation, avoiding overhead with the allocator. It also saves a tiny bit of overhead from the redundant capacity and length fields, since each struct element shares the same value. This is an alternate implementation to #7854.

2021-01-30 20:12:13 -07:00

								pub const MultiArrayList = @import("multi_array_list.zig").MultiArrayList;

							

Add priority queue

2019-02-25 20:25:21 +01:00

								pub const PriorityQueue = @import("priority_queue.zig").PriorityQueue;

							

std: Add Priority Dequeue

2021-01-16 12:01:06 +00:00

								pub const PriorityDequeue = @import("priority_dequeue.zig").PriorityDequeue;

							

std.Progress: make the API thread-safe We generally get away with atomic primitives, however a lock is required around the refresh function since it traverses the Node graph, and we need to be sure no references to Nodes remain after end() is called.

2020-12-18 21:51:18 -07:00

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

							

std.rand: Move to std.Random

2024-02-08 14:43:20 +01:00

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

							

std.RingBuffer: add (non-concurrent) RingBuffer implementation

2023-02-21 12:07:44 +11:00

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

							

std: bring back SegmentedList I want to use it for the self-hosted compiler.

2022-04-18 07:49:23 -07:00

								pub const SegmentedList = @import("segmented_list.zig").SegmentedList;

							

std: Introduce SemanticVersion data structure This will parse, format, and compare version strings following the SemVer 2 specification. See: https://semver.org Updates #6466

2020-10-06 23:06:19 -04:00

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

							

de-genericify SinglyLinkedList by making it always intrusive, we make it a more broadly useful API, and avoid binary bloat.

2025-04-03 14:11:38 -07:00

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

							

Add some bit set variants

2021-02-04 23:04:49 -06:00

								pub const StaticBitSet = bit_set.StaticBitSet;

							

std: expose unmanaged hash maps These are useful when you have many of them in memory, and already have the allocator stored elsewhere.

2020-07-06 06:10:03 +00:00

								pub const StringHashMap = hash_map.StringHashMap;

							

std: add StringHashMapUnmanaged

2020-07-13 00:34:02 +10:00

								pub const StringHashMapUnmanaged = hash_map.StringHashMapUnmanaged;

							

hash_map: rename to ArrayHashMap and add new HashMap implementation

2020-08-02 23:24:03 +02:00

								pub const StringArrayHashMap = array_hash_map.StringArrayHashMap;

							

std.Target: flatten

2023-12-04 12:14:58 -07:00

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

							

organize std lib concurrency primitives and add RwLock * move concurrency primitives that always operate on kernel threads to the std.Thread namespace * remove std.SpinLock. Nobody should use this in a non-freestanding environment; the other primitives are always preferable. In freestanding, it will be necessary to put custom spin logic in there, so there are no use cases for a std lib version. * move some std lib files to the top level fields convention * add std.Thread.spinLoopHint * add std.Thread.Condition * add std.Thread.Semaphore * new implementation of std.Thread.Mutex for Windows and non-pthreads Linux * add std.Thread.RwLock Implementations provided by @kprotty

2021-01-14 20:41:37 -07:00

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

							

treap: initial implementation

2022-04-15 15:26:51 -05:00

								pub const Treap = @import("treap.zig").Treap;

							

Make std.tz namespace accessible Closes #13978

2022-12-16 16:26:04 -05:00

								pub const Tz = tz.Tz;

							

Renames Url.zig to Uri.zig

2023-01-05 13:23:58 +01:00

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

							

std: rename List to ArrayList and re-organize... ...the exports of std. closes #356

2017-05-04 14:05:06 -04:00

hash_map: rename to ArrayHashMap and add new HashMap implementation

2020-08-02 23:24:03 +02:00

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

							

rename std lib files to new convention

2019-03-02 16:46:04 -05:00

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

							

zig build system creates symlinks atomically * add std.base64 * add std.os.rename * add std.os.atomicSymLink

2017-04-17 19:08:41 -04:00

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

							

Add some bit set variants

2021-02-04 23:04:49 -06:00

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

							

move types from builtin to std * All the data types from `@import("builtin")` are moved to `@import("std").builtin`. The target-related types are moved to `std.Target`. This allows the data types to have methods, such as `std.Target.current.isDarwin()`. * `std.os.windows.subsystem` is moved to `std.Target.current.subsystem`. * Remove the concept of the panic package from the compiler implementation. Instead, `std.builtin.panic` is always the panic function. It checks for `@hasDecl(@import("root"), "panic")`, or else provides a default implementation. This is an important step for multibuilds (#3028). Without this change, the types inside the builtin namespace look like different types, when trying to merge builds with different target settings. With this change, Zig can figure out that, e.g., `std.builtin.Os` (the enum type) from one compilation and `std.builtin.Os` from another compilation are the same type, even if the target OS value differs.

2019-10-23 18:43:24 -04:00

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

							

rename std lib files to new convention

2019-03-02 16:46:04 -05:00

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

							

Very much WIP base implementation for #721. Currently does: - read COFF executable file - locate and load corresponding .pdb file - expose .pdb content as streams (PDB format)

2018-07-21 20:30:11 +02:00

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

							

std: Add DEFLATE and zlib decompressors

2020-09-07 19:07:27 +02:00

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

							

ComptimeStringMap: return a regular struct and optimize this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here https://github.com/ziglang/zig/pull/19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * new public methods * `keys()`, `values()` helpers * `init(allocator)`, `deinit(allocator)` for runtime data * `getLongestPrefix(str)`, `getLongestPrefixIndex(str)` - i'm not sure these belong but have left in for now incase they are deemed useful * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed a speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full output in link above.

2024-04-20 23:14:39 -07:00

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

							

rename std lib files to new convention

2019-03-02 16:46:04 -05:00

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

							

std: rename List to ArrayList and re-organize... ...the exports of std. closes #356

2017-05-04 14:05:06 -04:00

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

							

Add some enum utilities

2021-03-06 18:25:04 -06:00

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

							

std: Add fifo useful for buffers

2019-11-05 07:05:29 +11:00

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

							

rename std lib files to new convention

2019-03-02 16:46:04 -05:00

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

							

do Jay's suggestion with posix/os API naming & layout

2019-05-24 18:27:18 -04:00

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

							

std: add gpu namespace

2024-02-02 17:48:40 +03:30

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

							

rename std lib files to new convention

2019-03-02 16:46:04 -05:00

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

							

macos stack traces: read debug info sections from .o files

2018-08-23 23:08:34 -04:00

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

							

breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink.

2017-10-31 04:47:55 -04:00

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

							

std: add http definitions for Method and Status (#10661)

2022-05-11 12:43:18 -07:00

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

							

break off some of std.io into std.fmt, generalize printf closes #250

2017-03-09 19:12:15 -05:00

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

							

Add json decoder - streaming json decoder - dynamic tree/value decoder

2018-05-02 18:04:40 +12:00

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

							

Move leb128 and remove trivial *mem functions as discussed in #5588 (#6876) * Move leb128 out of debug and remove trivial *mem functions as discussed in #5588 * Turns out one of the *Mem functions was used by MachO. Replaced with trivial use of FixedBufferStream.

2020-11-16 17:51:54 -06:00

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

							

Introduce std.log std.log provides 8 log levels and corresponding logging functions. It allows the user to override the logging "backend" by defining root.log and to override the default log level by defining root.log_level. Logging functions accept a scope parameter which allows the implementer of the logging "backend" to filter logging by library as well as level. Using the standardized syslog [1] log levels ensures that std.log will be flexible enough to work for as many use-cases as possible. If we were to stick with only 3/4 log levels, std.log would be insufficient for large and/or complex projects such as a kernel or display server. [1]: https://tools.ietf.org/html/rfc5424#section-6.2.1

2020-05-15 17:10:56 +02:00

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

							

add support for stack traces on macosx Add basic address->symbol resolution support. Uses symtab data from the MachO image, not external dSYM data; that's left as a future exercise. The net effect is that we can now map addresses to function names but not much more. File names and line number data will have to wait until a future pull request. Partially fixes #434.

2018-02-19 23:06:54 +01:00

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

							

rename std lib files to new convention

2019-03-02 16:46:04 -05:00

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

							

add list implementation to standard library

2016-05-08 01:34:00 -07:00

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

							

rename std lib files to new convention

2019-03-02 16:46:04 -05:00

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

							

break off some of std.io into std.fmt, generalize printf closes #250

2017-03-09 19:12:15 -05:00

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

							

rename std lib files to new convention

2019-03-02 16:46:04 -05:00

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

							

std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way.

2020-04-18 13:26:12 +02:00

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

							

Very much WIP base implementation for #721. Currently does: - read COFF executable file - locate and load corresponding .pdb file - expose .pdb content as streams (PDB format)

2018-07-21 20:30:11 +02:00

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

							

extract std.posix from std.os closes #5019

2024-03-18 22:39:59 -07:00

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

							

do Jay's suggestion with posix/os API naming & layout

2019-05-24 18:27:18 -04:00

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

							

break off some of std.io into std.fmt, generalize printf closes #250

2017-03-09 19:12:15 -05:00

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

							

std: SIMD utility functions This file contains a collections of functions that may be useful for SIMD, such as generating a vector with a linear range of numbers starting at zero, joining two vectors together, getting the index of the first true in a vector of bools, etc.

2022-03-27 10:28:44 +02:00

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

							

2019-03-21 20:33:37 -06:00

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

							

add std.tar for tar file unpacking

2023-01-09 22:36:35 -07:00

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

							

std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304

2019-02-08 18:18:47 -05:00

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

							

do Jay's suggestion with posix/os API naming & layout

2019-05-24 18:27:18 -04:00

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

							

Make std.tz namespace accessible Closes #13978

2022-12-16 16:26:04 -05:00

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

							

move utf8 parsing to std source files no longer need to end with a newline

2017-12-26 23:17:33 -07:00

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

							

Merge branch 'valgrind' of https://github.com/daurnimator/zig into daurnimator-valgrind

2019-03-11 13:27:04 -04:00

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

							

Define wasm constants Update link.Wasm.zig to use std.wasm for its constants Make opcodes u8 and non-exhaustive Update test and rename 'spec' to 'wasm'

2021-01-24 10:54:51 +01:00

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

							

rename std lib files to new convention

2019-03-02 16:46:04 -05:00

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

							

add std.zip and support zip files in build.zig.zon fixes #17408 Helpful reviewers/testers include Joshe Wolfe, Auguste Rame, Andrew Kelley and Jacob Young. Co-authored-by: Joel Gustafson <joelg@mit.edu>

2024-04-20 16:52:02 -06:00

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

							

compiler,std: implement ZON support This commit allows using ZON (Zig Object Notation) in a few ways. * `@import` can be used to load ZON at comptime and convert it to a normal Zig value. In this case, `@import` must have a result type. * `std.zon.parse` can be used to parse ZON at runtime, akin to the parsing logic in `std.json`. * `std.zon.stringify` can be used to convert arbitrary data structures to ZON at runtime, again akin to `std.json`.

2024-11-04 14:03:36 -08:00

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

							

un-special-case startup code in the std lib Previously, the compiler had special logic to determine whether to include the startup code, which was in `std/special/start.zig`. Now, the file is moved to `std/start.zig`, and there is no special logic in the compiler. Instead, the standard library unconditionally imports the `start.zig` file, which then has a `comptime` block that does the logic of determining what, if any, start symbols to export. Instead of `start.zig` being in its own special package, it is just another normal file that is part of the standard library. `std.builtin.TestFn` is now part of the standard library rather than specially generated by the compiler.

2019-12-12 18:27:17 -05:00

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

							

std: collect all options under one namespace

2023-01-03 19:37:11 +02:00

								const root = @import("root");

							

autodoc: new layout (#16715) * autodoc: init guide TOC work * autodoc: working guides toc navigation * autodoc: more improvements * autodoc: ui refinements * autodoc: new layout and init descriptions for namespaces in std.zig

2023-08-06 18:12:05 +02:00

/// Stdlib-wide options that can be overridden by the root file.

std: make options a struct instance instead of a namespace

2024-01-28 00:30:24 +02:00

								pub const options: Options = if (@hasDecl(root, "std_options")) root.std_options else .{};

							

std: collect all options under one namespace

2023-01-03 19:37:11 +02:00

std: clean up top-level namespaces documentation This cleans up existing documentation, adds a bit more, and fixes some typos too.

2023-09-08 20:59:25 +02:00

								    /// Function used to implement `std.fs.cwd` for WASI.

							

std: change return type of `wasiCwd` `fd_t` is not declared on freestanding so returning a `Dir` causes an error.

2024-01-30 23:11:52 +02:00

								    wasiCwd: fn () os.wasi.fd_t = fs.defaultWasiCwd,

							

std: collect all options under one namespace

2023-01-03 19:37:11 +02:00

std: make options a struct instance instead of a namespace

2024-01-28 00:30:24 +02:00

								    log_level: log.Level = log.default_level,

							

std: collect all options under one namespace

2023-01-03 19:37:11 +02:00

std: make options a struct instance instead of a namespace

2024-01-28 00:30:24 +02:00

								    log_scope_levels: []const log.ScopeLevel = &.{},

							

std: collect all options under one namespace

2023-01-03 19:37:11 +02:00

std: make options a struct instance instead of a namespace

2024-01-28 00:30:24 +02:00

								    logFn: fn (

							

std: collect all options under one namespace

2023-01-03 19:37:11 +02:00

								        comptime message_level: log.Level,

							

std: make options a struct instance instead of a namespace

2024-01-28 00:30:24 +02:00

								    ) void = log.defaultLog,

							

adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit.

2025-01-29 14:16:25 -08:00

								    /// Overrides `std.heap.page_size_min`.

							

runtime page size detection heap.zig: define new default page sizes heap.zig: add min/max_page_size and their options lib/std/c: add miscellaneous declarations heap.zig: add pageSize() and its options switch to new page sizes, especially in GPA/stdlib mem.zig: remove page_size

2024-10-20 14:55:57 -07:00

std: make options a struct instance instead of a namespace

2024-01-28 00:30:24 +02:00

								    fmt_max_depth: usize = fmt.default_max_depth,

							

std: remove meta.globalOption

2024-01-26 15:38:22 +02:00

use std_options for keep_sigpipe and existence of SIG.PIPE to check for support

2023-02-18 11:46:24 -07:00

								    /// By default Zig disables SIGPIPE by setting a "no-op" handler for it.  Set this option

							

std: make options a struct instance instead of a namespace

2024-01-28 00:30:24 +02:00

								    keep_sigpipe: bool = false,

							

std.http: rework connection pool into its own type

2023-03-08 11:27:13 -06:00

std.http.Client: add option to disable https std_options.http_connection_pool_size removed in favor of ``` client.connection_pool.resize(client.allocator, size); ``` std_options.http_disable_tls will remove all https capability from std.http when true. Any https request will error with `error.TlsInitializationFailed`. Solves #17051.

2023-10-05 12:19:06 -05:00

								    /// By default, std.http.Client will support HTTPS connections.  Set this option to `true` to

							

std.http: use loadDefaultProxies in compiler

2023-10-05 12:29:49 -05:00

///

std.http.Client: add option to disable https std_options.http_connection_pool_size removed in favor of ``` client.connection_pool.resize(client.allocator, size); ``` std_options.http_disable_tls will remove all https capability from std.http when true. Any https request will error with `error.TlsInitializationFailed`. Solves #17051.

2023-10-05 12:19:06 -05:00

								    /// This will likely reduce the size of the binary, but it will also make it impossible to

							

std: make options a struct instance instead of a namespace

2024-01-28 00:30:24 +02:00

								    http_disable_tls: bool = false,

							

std.crypto.tls: improve debuggability of encrypted connections By default, programs built in debug mode that open a https connection will append secrets to the file specified in the SSLKEYLOGFILE environment variable to allow protocol debugging by external programs.

2024-11-05 01:37:12 -05:00

								    /// This enables `std.http.Client` to log ssl secrets to the file specified by the SSLKEYLOGFILE

							

std: make options a struct instance instead of a namespace

2024-01-28 00:30:24 +02:00

								    side_channels_mitigations: crypto.SideChannelsMitigations = crypto.default_side_channels_mitigations,

							

std: collect all options under one namespace

2023-01-03 19:37:11 +02:00

};

un-special-case startup code in the std lib Previously, the compiler had special logic to determine whether to include the startup code, which was in `std/special/start.zig`. Now, the file is moved to `std/start.zig`, and there is no special logic in the compiler. Instead, the standard library unconditionally imports the `start.zig` file, which then has a `comptime` block that does the logic of determining what, if any, start symbols to export. Instead of `start.zig` being in its own special package, it is just another normal file that is part of the standard library. `std.builtin.TestFn` is now part of the standard library rather than specially generated by the compiler.

2019-12-12 18:27:17 -05:00

								// This forces the start.zig file to be imported, and the comptime logic inside that

							

stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr

2021-04-08 19:05:05 -07:00

// file decides whether to export any appropriate start symbols, and call main.

un-special-case startup code in the std lib Previously, the compiler had special logic to determine whether to include the startup code, which was in `std/special/start.zig`. Now, the file is moved to `std/start.zig`, and there is no special logic in the compiler. Instead, the standard library unconditionally imports the `start.zig` file, which then has a `comptime` block that does the logic of determining what, if any, start symbols to export. Instead of `start.zig` being in its own special package, it is just another normal file that is part of the standard library. `std.builtin.TestFn` is now part of the standard library rather than specially generated by the compiler.

2019-12-12 18:27:17 -05:00

								comptime {

							

zig test no longer requires a separate test_runner.o file See #298

2017-04-27 16:15:41 -04:00

std: Update `test ""` to `test` where it makes sense

2021-01-22 15:45:28 +01:00

								test {

							

std.build: extract steps to separate files There are intended to be no functional changes in this commit.

2022-12-09 23:06:23 -07:00

								    testing.refAllDecls(@This());

							

zig test no longer requires a separate test_runner.o file See #298

2017-04-27 16:15:41 -04:00

extract std.posix from std.os closes #5019

2024-03-18 22:39:59 -07:00

hash_map: rename to ArrayHashMap and add new HashMap implementation 2020-08-02 23:24:03 +02:00			`pub const ArrayHashMap = array_hash_map.ArrayHashMap;`
			`pub const ArrayHashMapUnmanaged = array_hash_map.ArrayHashMapUnmanaged;`
std.Mutex: implement blocking mutexes on linux closes #1463 Thanks to Shawn Landden for the original pull request. This commit is based on that code. 2018-10-03 13:19:10 -04:00			`pub const ArrayList = @import("array_list.zig").ArrayList;`
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build. 2020-05-10 02:05:54 -04:00			`pub const ArrayListAligned = @import("array_list.zig").ArrayListAligned;`
			`pub const ArrayListAlignedUnmanaged = @import("array_list.zig").ArrayListAlignedUnmanaged;`
			`pub const ArrayListUnmanaged = @import("array_list.zig").ArrayListUnmanaged;`
hash_map: rename to ArrayHashMap and add new HashMap implementation 2020-08-02 23:24:03 +02:00			`pub const AutoArrayHashMap = array_hash_map.AutoArrayHashMap;`
			`pub const AutoArrayHashMapUnmanaged = array_hash_map.AutoArrayHashMapUnmanaged;`
std: expose unmanaged hash maps These are useful when you have many of them in memory, and already have the allocator stored elsewhere. 2020-07-06 06:10:03 +00:00			`pub const AutoHashMap = hash_map.AutoHashMap;`
			`pub const AutoHashMapUnmanaged = hash_map.AutoHashMapUnmanaged;`
std.json: Unify stringify and writeStream (#16405) 2023-07-21 19:56:46 -04:00			`pub const BitStack = @import("BitStack.zig");`
BoundedArray: a simple way to represent small data whose max size is known (#9134) This is a simple structure containing an array and a length, that can be viewed as a slice. It is useful to pass-by-copy small data whose exact size is known at runtime, but whose maximum size is known at comptime. This greatly simplifies code that otherwise would require an allocator, or reimplementing what this type does. 2021-08-24 13:59:28 +02:00			`pub const BoundedArray = @import("bounded_array.zig").BoundedArray;`
add BoundedArrayAligned (#14580) This is useful for creating byte buffers of actually-different-things. Copied the argument order from `Allocator.alignedAlloc` I noted that `ArrayListAligned` is going out of it's way to not set the alignment at comptime when it is not specified. However, I was not able to do that the same way here, and good people on IRC, @ifreund in particular (thanks!) assured me that [N]T align(@alignOf(T)) is equivalent to [N]T 2023-03-17 18:50:25 +02:00			`pub const BoundedArrayAligned = @import("bounded_array.zig").BoundedArrayAligned;`
combine std.build and std.build.Builder into std.Build I've been wanting to do this for along time. 2023-01-31 00:19:51 -07:00			`pub const Build = @import("Build.zig");`
std: rename List to ArrayList and re-organize... ...the exports of std. closes #356 2017-05-04 14:05:06 -04:00			`pub const BufMap = @import("buf_map.zig").BufMap;`
			`pub const BufSet = @import("buf_set.zig").BufSet;`
ComptimeStringMap: return a regular struct and optimize this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here https://github.com/ziglang/zig/pull/19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * new public methods * `keys()`, `values()` helpers * `init(allocator)`, `deinit(allocator)` for runtime data * `getLongestPrefix(str)`, `getLongestPrefixIndex(str)` - i'm not sure these belong but have left in for now incase they are deemed useful * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed a speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full output in link above. 2024-04-20 23:14:39 -07:00			`pub const StaticStringMap = static_string_map.StaticStringMap;`
			`pub const StaticStringMapWithEql = static_string_map.StaticStringMapWithEql;`
de-genericify DoublyLinkedList by making it always intrusive, we make it more broadly useful API, and avoid binary bloat. 2025-04-03 15:35:21 -07:00			`pub const DoublyLinkedList = @import("DoublyLinkedList.zig");`
std.Mutex: implement blocking mutexes on linux closes #1463 Thanks to Shawn Landden for the original pull request. This commit is based on that code. 2018-10-03 13:19:10 -04:00			`pub const DynLib = @import("dynamic_library.zig").DynLib;`
Add some bit set variants 2021-02-04 23:04:49 -06:00			`pub const DynamicBitSet = bit_set.DynamicBitSet;`
			`pub const DynamicBitSetUnmanaged = bit_set.DynamicBitSetUnmanaged;`
Add some enum utilities 2021-03-06 18:25:04 -06:00			`pub const EnumArray = enums.EnumArray;`
			`pub const EnumMap = enums.EnumMap;`
			`pub const EnumSet = enums.EnumSet;`
std: expose unmanaged hash maps These are useful when you have many of them in memory, and already have the allocator stored elsewhere. 2020-07-06 06:10:03 +00:00			`pub const HashMap = hash_map.HashMap;`
			`pub const HashMapUnmanaged = hash_map.HashMapUnmanaged;`
add std.MultiArrayList Also known as "Struct-Of-Arrays" or "SOA". The purpose of this data structure is to provide a similar API to ArrayList but instead of the element type being a struct, the fields of the struct are in N different arrays, all with the same length and capacity. Having this abstraction means we can put them in the same allocation, avoiding overhead with the allocator. It also saves a tiny bit of overhead from the redundant capacity and length fields, since each struct element shares the same value. This is an alternate implementation to #7854. 2021-01-30 20:12:13 -07:00			`pub const MultiArrayList = @import("multi_array_list.zig").MultiArrayList;`
Add priority queue 2019-02-25 20:25:21 +01:00			`pub const PriorityQueue = @import("priority_queue.zig").PriorityQueue;`
std: Add Priority Dequeue 2021-01-16 12:01:06 +00:00			`pub const PriorityDequeue = @import("priority_dequeue.zig").PriorityDequeue;`
std.Progress: make the API thread-safe We generally get away with atomic primitives, however a lock is required around the refresh function since it traverses the Node graph, and we need to be sure no references to Nodes remain after end() is called. 2020-12-18 21:51:18 -07:00			`pub const Progress = @import("Progress.zig");`
std.rand: Move to std.Random 2024-02-08 14:43:20 +01:00			`pub const Random = @import("Random.zig");`
std.RingBuffer: add (non-concurrent) RingBuffer implementation 2023-02-21 12:07:44 +11:00			`pub const RingBuffer = @import("RingBuffer.zig");`
std: bring back SegmentedList I want to use it for the self-hosted compiler. 2022-04-18 07:49:23 -07:00			`pub const SegmentedList = @import("segmented_list.zig").SegmentedList;`
std: Introduce SemanticVersion data structure This will parse, format, and compare version strings following the SemVer 2 specification. See: https://semver.org Updates #6466 2020-10-06 23:06:19 -04:00			`pub const SemanticVersion = @import("SemanticVersion.zig");`
de-genericify SinglyLinkedList by making it always intrusive, we make it a more broadly useful API, and avoid binary bloat. 2025-04-03 14:11:38 -07:00			`pub const SinglyLinkedList = @import("SinglyLinkedList.zig");`
Add some bit set variants 2021-02-04 23:04:49 -06:00			`pub const StaticBitSet = bit_set.StaticBitSet;`
std: expose unmanaged hash maps These are useful when you have many of them in memory, and already have the allocator stored elsewhere. 2020-07-06 06:10:03 +00:00			`pub const StringHashMap = hash_map.StringHashMap;`
std: add StringHashMapUnmanaged 2020-07-13 00:34:02 +10:00			`pub const StringHashMapUnmanaged = hash_map.StringHashMapUnmanaged;`
hash_map: rename to ArrayHashMap and add new HashMap implementation 2020-08-02 23:24:03 +02:00			`pub const StringArrayHashMap = array_hash_map.StringArrayHashMap;`
			`pub const StringArrayHashMapUnmanaged = array_hash_map.StringArrayHashMapUnmanaged;`
std.Target: flatten 2023-12-04 12:14:58 -07:00			`pub const Target = @import("Target.zig");`
organize std lib concurrency primitives and add RwLock * move concurrency primitives that always operate on kernel threads to the std.Thread namespace * remove std.SpinLock. Nobody should use this in a non-freestanding environment; the other primitives are always preferable. In freestanding, it will be necessary to put custom spin logic in there, so there are no use cases for a std lib version. * move some std lib files to the top level fields convention * add std.Thread.spinLoopHint * add std.Thread.Condition * add std.Thread.Semaphore * new implementation of std.Thread.Mutex for Windows and non-pthreads Linux * add std.Thread.RwLock Implementations provided by @kprotty 2021-01-14 20:41:37 -07:00			`pub const Thread = @import("Thread.zig");`
treap: initial implementation 2022-04-15 15:26:51 -05:00			`pub const Treap = @import("treap.zig").Treap;`
Make std.tz namespace accessible Closes #13978 2022-12-16 16:26:04 -05:00			`pub const Tz = tz.Tz;`
Renames Url.zig to Uri.zig 2023-01-05 13:23:58 +01:00			`pub const Uri = @import("Uri.zig");`
std: rename List to ArrayList and re-organize... ...the exports of std. closes #356 2017-05-04 14:05:06 -04:00
hash_map: rename to ArrayHashMap and add new HashMap implementation 2020-08-02 23:24:03 +02:00			`pub const array_hash_map = @import("array_hash_map.zig");`
rename std lib files to new convention 2019-03-02 16:46:04 -05:00			`pub const atomic = @import("atomic.zig");`
zig build system creates symlinks atomically * add std.base64 * add std.os.rename * add std.os.atomicSymLink 2017-04-17 19:08:41 -04:00			`pub const base64 = @import("base64.zig");`
Add some bit set variants 2021-02-04 23:04:49 -06:00			`pub const bit_set = @import("bit_set.zig");`
move types from builtin to std * All the data types from `@import("builtin")` are moved to `@import("std").builtin`. The target-related types are moved to `std.Target`. This allows the data types to have methods, such as `std.Target.current.isDarwin()`. * `std.os.windows.subsystem` is moved to `std.Target.current.subsystem`. * Remove the concept of the panic package from the compiler implementation. Instead, `std.builtin.panic` is always the panic function. It checks for `@hasDecl(@import("root"), "panic")`, or else provides a default implementation. This is an important step for multibuilds (#3028). Without this change, the types inside the builtin namespace look like different types, when trying to merge builds with different target settings. With this change, Zig can figure out that, e.g., `std.builtin.Os` (the enum type) from one compilation and `std.builtin.Os` from another compilation are the same type, even if the target OS value differs. 2019-10-23 18:43:24 -04:00			`pub const builtin = @import("builtin.zig");`
rename std lib files to new convention 2019-03-02 16:46:04 -05:00			`pub const c = @import("c.zig");`
Very much WIP base implementation for #721. Currently does: - read COFF executable file - locate and load corresponding .pdb file - expose .pdb content as streams (PDB format) 2018-07-21 20:30:11 +02:00			`pub const coff = @import("coff.zig");`
std: Add DEFLATE and zlib decompressors 2020-09-07 19:07:27 +02:00			`pub const compress = @import("compress.zig");`
ComptimeStringMap: return a regular struct and optimize this patch renames ComptimeStringMap to StaticStringMap, makes it accept only a single type parameter, and return a known struct type instead of an anonymous struct. initial motivation for these changes was to reduce the 'very long type names' issue described here https://github.com/ziglang/zig/pull/19682. this breaks the previous API. users will now need to write: `const map = std.StaticStringMap(T).initComptime(kvs_list);` * move `kvs_list` param from type param to an `initComptime()` param * new public methods * `keys()`, `values()` helpers * `init(allocator)`, `deinit(allocator)` for runtime data * `getLongestPrefix(str)`, `getLongestPrefixIndex(str)` - i'm not sure these belong but have left in for now incase they are deemed useful * performance notes: * i posted some benchmarking results here: https://github.com/travisstaloch/comptime-string-map-revised/issues/1 * i noticed a speedup reducing the size of the struct from 48 to 32 bytes and thus use u32s instead of usize for all length fields * i noticed speedup storing KVs as a struct of arrays * latest benchmark shows these wall_time improvements for debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full output in link above. 2024-04-20 23:14:39 -07:00			`pub const static_string_map = @import("static_string_map.zig");`
rename std lib files to new convention 2019-03-02 16:46:04 -05:00			`pub const crypto = @import("crypto.zig");`
			`pub const debug = @import("debug.zig");`
std: rename List to ArrayList and re-organize... ...the exports of std. closes #356 2017-05-04 14:05:06 -04:00			`pub const dwarf = @import("dwarf.zig");`
			`pub const elf = @import("elf.zig");`
Add some enum utilities 2021-03-06 18:25:04 -06:00			`pub const enums = @import("enums.zig");`
std: Add fifo useful for buffers 2019-11-05 07:05:29 +11:00			`pub const fifo = @import("fifo.zig");`
rename std lib files to new convention 2019-03-02 16:46:04 -05:00			`pub const fmt = @import("fmt.zig");`
do Jay's suggestion with posix/os API naming & layout 2019-05-24 18:27:18 -04:00			`pub const fs = @import("fs.zig");`
std: add gpu namespace 2024-02-02 17:48:40 +03:30			`pub const gpu = @import("gpu.zig");`
rename std lib files to new convention 2019-03-02 16:46:04 -05:00			`pub const hash = @import("hash.zig");`
macos stack traces: read debug info sections from .o files 2018-08-23 23:08:34 -04:00			`pub const hash_map = @import("hash_map.zig");`
breaking change to std.io API * Merge io.InStream and io.OutStream into io.File * Introduce io.OutStream and io.InStream interfaces - io.File implements both of these * Move mem.IncrementingAllocator to heap.IncrementingAllocator Instead of: ``` %return std.io.stderr.printf("hello\n"); ``` now do: ``` std.debug.warn("hello\n"); ``` To print to stdout, see `io.getStdOut()`. * Rename std.ArrayList.resizeDown to std.ArrayList.shrink. 2017-10-31 04:47:55 -04:00			`pub const heap = @import("heap.zig");`
std: add http definitions for Method and Status (#10661) 2022-05-11 12:43:18 -07:00			`pub const http = @import("http.zig");`
break off some of std.io into std.fmt, generalize printf closes #250 2017-03-09 19:12:15 -05:00			`pub const io = @import("io.zig");`
Add json decoder - streaming json decoder - dynamic tree/value decoder 2018-05-02 18:04:40 +12:00			`pub const json = @import("json.zig");`
Move leb128 and remove trivial mem functions as discussed in #5588 (#6876) Move leb128 out of debug and remove trivial mem functions as discussed in #5588 Turns out one of the *Mem functions was used by MachO. Replaced with trivial use of FixedBufferStream. 2020-11-16 17:51:54 -06:00			`pub const leb = @import("leb128.zig");`
Introduce std.log std.log provides 8 log levels and corresponding logging functions. It allows the user to override the logging "backend" by defining root.log and to override the default log level by defining root.log_level. Logging functions accept a scope parameter which allows the implementer of the logging "backend" to filter logging by library as well as level. Using the standardized syslog [1] log levels ensures that std.log will be flexible enough to work for as many use-cases as possible. If we were to stick with only 3/4 log levels, std.log would be insufficient for large and/or complex projects such as a kernel or display server. [1]: https://tools.ietf.org/html/rfc5424#section-6.2.1 2020-05-15 17:10:56 +02:00			`pub const log = @import("log.zig");`
add support for stack traces on macosx Add basic address->symbol resolution support. Uses symtab data from the MachO image, not external dSYM data; that's left as a future exercise. The net effect is that we can now map addresses to function names but not much more. File names and line number data will have to wait until a future pull request. Partially fixes #434. 2018-02-19 23:06:54 +01:00			`pub const macho = @import("macho.zig");`
rename std lib files to new convention 2019-03-02 16:46:04 -05:00			`pub const math = @import("math.zig");`
add list implementation to standard library 2016-05-08 01:34:00 -07:00			`pub const mem = @import("mem.zig");`
rename std lib files to new convention 2019-03-02 16:46:04 -05:00			`pub const meta = @import("meta.zig");`
break off some of std.io into std.fmt, generalize printf closes #250 2017-03-09 19:12:15 -05:00			`pub const net = @import("net.zig");`
rename std lib files to new convention 2019-03-02 16:46:04 -05:00			`pub const os = @import("os.zig");`
std: Introduce the Once synchronization primitive The Once object allows the user to execute a function just once in a thread-safe way. 2020-04-18 13:26:12 +02:00			`pub const once = @import("once.zig").once;`
Very much WIP base implementation for #721. Currently does: - read COFF executable file - locate and load corresponding .pdb file - expose .pdb content as streams (PDB format) 2018-07-21 20:30:11 +02:00			`pub const pdb = @import("pdb.zig");`
extract std.posix from std.os closes #5019 2024-03-18 22:39:59 -07:00			`pub const posix = @import("posix.zig");`
do Jay's suggestion with posix/os API naming & layout 2019-05-24 18:27:18 -04:00			`pub const process = @import("process.zig");`
break off some of std.io into std.fmt, generalize printf closes #250 2017-03-09 19:12:15 -05:00			`pub const sort = @import("sort.zig");`
std: SIMD utility functions This file contains a collections of functions that may be useful for SIMD, such as generating a vector with a linear range of numbers starting at zero, joining two vectors together, getting the index of the first true in a vector of bools, etc. 2022-03-27 10:28:44 +02:00			`pub const simd = @import("simd.zig");`
std: add ascii with C ASCII character classes Does NOT look at the locale the way the C functions do. int isalnum(int c); int isalpha(int c); int iscntrl(int c); int isdigit(int c); int isgraph(int c); int islower(int c); int isprint(int c); int ispunct(int c); int isspace(int c); int isupper(int c); int isxdigit(int c); int isascii(int c); int isblank(int c); int toupper(int c); int tolower(int c); Tested to match glibc (when using C locale) with this program: const c = @cImport({ // See https://github.com/ziglang/zig/issues/515 @cDefine("_NO_CRT_STDIO_INLINE", "1"); @cInclude("stdio.h"); @cInclude("string.h"); @cInclude("ctype.h"); }); const std = @import("std"); const ascii = std.ascii; const abort = std.os.abort; export fn main(argc: c_int, argv: **u8) c_int { var i: u8 = undefined; i = 0; while (true) { if (ascii.isAlNum(i) != (c.isalnum(i) > 0)) { abort(); } if (ascii.isAlpha(i) != (c.isalpha(i) > 0)) { abort(); } if (ascii.isCtrl(i) != (c.iscntrl(i) > 0)) { abort(); } if (ascii.isDigit(i) != (c.isdigit(i) > 0)) { abort(); } if (ascii.isGraph(i) != (c.isgraph(i) > 0)) { abort(); } if (ascii.isLower(i) != (c.islower(i) > 0)) { abort(); } if (ascii.isPrint(i) != (c.isprint(i) > 0)) { abort(); } if (ascii.isPunct(i) != (c.ispunct(i) > 0)) { abort(); } if (ascii.isSpace(i) != (c.isspace(i) > 0)) { abort(); } if (ascii.isUpper(i) != (c.isupper(i) > 0)) { abort(); } if (ascii.isXDigit(i) != (c.isxdigit(i) > 0)) { abort(); } if (i == 255) { break; } i += 1; } _ = c.printf(c"Success!\n"); return 0; } 2019-03-21 20:33:37 -06:00			`pub const ascii = @import("ascii.zig");`
add std.tar for tar file unpacking 2023-01-09 22:36:35 -07:00			`pub const tar = @import("tar.zig");`
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304 2019-02-08 18:18:47 -05:00			`pub const testing = @import("testing.zig");`
do Jay's suggestion with posix/os API naming & layout 2019-05-24 18:27:18 -04:00			`pub const time = @import("time.zig");`
Make std.tz namespace accessible Closes #13978 2022-12-16 16:26:04 -05:00			`pub const tz = @import("tz.zig");`
move utf8 parsing to std source files no longer need to end with a newline 2017-12-26 23:17:33 -07:00			`pub const unicode = @import("unicode.zig");`
Merge branch 'valgrind' of https://github.com/daurnimator/zig into daurnimator-valgrind 2019-03-11 13:27:04 -04:00			`pub const valgrind = @import("valgrind.zig");`
Define wasm constants Update link.Wasm.zig to use std.wasm for its constants Make opcodes u8 and non-exhaustive Update test and rename 'spec' to 'wasm' 2021-01-24 10:54:51 +01:00			`pub const wasm = @import("wasm.zig");`
rename std lib files to new convention 2019-03-02 16:46:04 -05:00			`pub const zig = @import("zig.zig");`
add std.zip and support zip files in build.zig.zon fixes #17408 Helpful reviewers/testers include Joshe Wolfe, Auguste Rame, Andrew Kelley and Jacob Young. Co-authored-by: Joel Gustafson <joelg@mit.edu> 2024-04-20 16:52:02 -06:00			`pub const zip = @import("zip.zig");`
compiler,std: implement ZON support This commit allows using ZON (Zig Object Notation) in a few ways. * `@import` can be used to load ZON at comptime and convert it to a normal Zig value. In this case, `@import` must have a result type. * `std.zon.parse` can be used to parse ZON at runtime, akin to the parsing logic in `std.json`. * `std.zon.stringify` can be used to convert arbitrary data structures to ZON at runtime, again akin to `std.json`. 2024-11-04 14:03:36 -08:00			`pub const zon = @import("zon.zig");`
un-special-case startup code in the std lib Previously, the compiler had special logic to determine whether to include the startup code, which was in `std/special/start.zig`. Now, the file is moved to `std/start.zig`, and there is no special logic in the compiler. Instead, the standard library unconditionally imports the `start.zig` file, which then has a `comptime` block that does the logic of determining what, if any, start symbols to export. Instead of `start.zig` being in its own special package, it is just another normal file that is part of the standard library. `std.builtin.TestFn` is now part of the standard library rather than specially generated by the compiler. 2019-12-12 18:27:17 -05:00			`pub const start = @import("start.zig");`

std: collect all options under one namespace 2023-01-03 19:37:11 +02:00			`const root = @import("root");`

autodoc: new layout (#16715) * autodoc: init guide TOC work * autodoc: working guides toc navigation * autodoc: more improvements * autodoc: ui refinements * autodoc: new layout and init descriptions for namespaces in std.zig 2023-08-06 18:12:05 +02:00			`/// Stdlib-wide options that can be overridden by the root file.`
std: make options a struct instance instead of a namespace 2024-01-28 00:30:24 +02:00			`pub const options: Options = if (@hasDecl(root, "std_options")) root.std_options else .{};`

			`pub const Options = struct {`
			`enable_segfault_handler: bool = debug.default_enable_segfault_handler,`
std: collect all options under one namespace 2023-01-03 19:37:11 +02:00
std: clean up top-level namespaces documentation This cleans up existing documentation, adds a bit more, and fixes some typos too. 2023-09-08 20:59:25 +02:00			/// Function used to implement `std.fs.cwd` for WASI.
std: change return type of `wasiCwd` `fd_t` is not declared on freestanding so returning a `Dir` causes an error. 2024-01-30 23:11:52 +02:00			`wasiCwd: fn () os.wasi.fd_t = fs.defaultWasiCwd,`
std: collect all options under one namespace 2023-01-03 19:37:11 +02:00
			`/// The current log level.`
std: make options a struct instance instead of a namespace 2024-01-28 00:30:24 +02:00			`log_level: log.Level = log.default_level,`
std: collect all options under one namespace 2023-01-03 19:37:11 +02:00
std: make options a struct instance instead of a namespace 2024-01-28 00:30:24 +02:00			`log_scope_levels: []const log.ScopeLevel = &.{},`
std: collect all options under one namespace 2023-01-03 19:37:11 +02:00
std: make options a struct instance instead of a namespace 2024-01-28 00:30:24 +02:00			`logFn: fn (`
std: collect all options under one namespace 2023-01-03 19:37:11 +02:00			`comptime message_level: log.Level,`
			`comptime scope: @TypeOf(.enum_literal),`
			`comptime format: []const u8,`
			`args: anytype,`
std: make options a struct instance instead of a namespace 2024-01-28 00:30:24 +02:00			`) void = log.defaultLog,`

adjust runtime page size APIs * fix merge conflicts * rename the declarations * reword documentation * extract FixedBufferAllocator to separate file * take advantage of locals * remove the assertion about max alignment in Allocator API, leaving it Allocator implementation defined * fix non-inline function call in start logic The GeneralPurposeAllocator implementation is totally broken because it uses global state but I didn't address that in this commit. 2025-01-29 14:16:25 -08:00			/// Overrides `std.heap.page_size_min`.
			`page_size_min: ?usize = null,`
			/// Overrides `std.heap.page_size_max`.
			`page_size_max: ?usize = null,`
			`/// Overrides default implementation for determining OS page size at runtime.`
			`queryPageSize: fn () usize = heap.defaultQueryPageSize,`
runtime page size detection heap.zig: define new default page sizes heap.zig: add min/max_page_size and their options lib/std/c: add miscellaneous declarations heap.zig: add pageSize() and its options switch to new page sizes, especially in GPA/stdlib mem.zig: remove page_size 2024-10-20 14:55:57 -07:00
std: make options a struct instance instead of a namespace 2024-01-28 00:30:24 +02:00			`fmt_max_depth: usize = fmt.default_max_depth,`

			`cryptoRandomSeed: fn (buffer: []u8) void = @import("crypto/tlcsprng.zig").defaultRandomSeed,`

			`crypto_always_getrandom: bool = false,`

			`crypto_fork_safety: bool = true,`
std: remove meta.globalOption 2024-01-26 15:38:22 +02:00
use std_options for keep_sigpipe and existence of SIG.PIPE to check for support 2023-02-18 11:46:24 -07:00			`/// 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.`
std: make options a struct instance instead of a namespace 2024-01-28 00:30:24 +02:00			`keep_sigpipe: bool = false,`
std.http: rework connection pool into its own type 2023-03-08 11:27:13 -06:00
std.http.Client: add option to disable https std_options.http_connection_pool_size removed in favor of ``` client.connection_pool.resize(client.allocator, size); ``` std_options.http_disable_tls will remove all https capability from std.http when true. Any https request will error with `error.TlsInitializationFailed`. Solves #17051. 2023-10-05 12:19:06 -05:00			/// By default, std.http.Client will support HTTPS connections. Set this option to `true` to
			`/// disable TLS support.`
std.http: use loadDefaultProxies in compiler 2023-10-05 12:29:49 -05:00			`///`
std.http.Client: add option to disable https std_options.http_connection_pool_size removed in favor of ``` client.connection_pool.resize(client.allocator, size); ``` std_options.http_disable_tls will remove all https capability from std.http when true. Any https request will error with `error.TlsInitializationFailed`. Solves #17051. 2023-10-05 12:19:06 -05:00			`/// This will likely reduce the size of the binary, but it will also make it impossible to`
			`/// make a HTTPS connection.`
std: make options a struct instance instead of a namespace 2024-01-28 00:30:24 +02:00			`http_disable_tls: bool = false,`

std.crypto.tls: improve debuggability of encrypted connections By default, programs built in debug mode that open a https connection will append secrets to the file specified in the SSLKEYLOGFILE environment variable to allow protocol debugging by external programs. 2024-11-05 01:37:12 -05:00			/// This enables `std.http.Client` to log ssl secrets to the file specified by the SSLKEYLOGFILE
			`/// env var. Creating such a log file allows other programs with access to that file to decrypt`
			/// all `std.http.Client` traffic made by this program.
			`http_enable_ssl_key_log_file: bool = @import("builtin").mode == .Debug,`

std: make options a struct instance instead of a namespace 2024-01-28 00:30:24 +02:00			`side_channels_mitigations: crypto.SideChannelsMitigations = crypto.default_side_channels_mitigations,`
std: collect all options under one namespace 2023-01-03 19:37:11 +02:00			`};`

un-special-case startup code in the std lib Previously, the compiler had special logic to determine whether to include the startup code, which was in `std/special/start.zig`. Now, the file is moved to `std/start.zig`, and there is no special logic in the compiler. Instead, the standard library unconditionally imports the `start.zig` file, which then has a `comptime` block that does the logic of determining what, if any, start symbols to export. Instead of `start.zig` being in its own special package, it is just another normal file that is part of the standard library. `std.builtin.TestFn` is now part of the standard library rather than specially generated by the compiler. 2019-12-12 18:27:17 -05:00			`// This forces the start.zig file to be imported, and the comptime logic inside that`
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr 2021-04-08 19:05:05 -07:00			`// file decides whether to export any appropriate start symbols, and call main.`
un-special-case startup code in the std lib Previously, the compiler had special logic to determine whether to include the startup code, which was in `std/special/start.zig`. Now, the file is moved to `std/start.zig`, and there is no special logic in the compiler. Instead, the standard library unconditionally imports the `start.zig` file, which then has a `comptime` block that does the logic of determining what, if any, start symbols to export. Instead of `start.zig` being in its own special package, it is just another normal file that is part of the standard library. `std.builtin.TestFn` is now part of the standard library rather than specially generated by the compiler. 2019-12-12 18:27:17 -05:00			`comptime {`
			`_ = start;`
			`}`
zig test no longer requires a separate test_runner.o file See #298 2017-04-27 16:15:41 -04:00
std: Update `test ""` to `test` where it makes sense 2021-01-22 15:45:28 +01:00			`test {`
std.build: extract steps to separate files There are intended to be no functional changes in this commit. 2022-12-09 23:06:23 -07:00			`testing.refAllDecls(@This());`
zig test no longer requires a separate test_runner.o file See #298 2017-04-27 16:15:41 -04:00			`}`
extract std.posix from std.os closes #5019 2024-03-18 22:39:59 -07:00
			`comptime {`
			`debug.assert(@import("std") == @This()); // std lib tests require --zig-lib-dir`
			`}`