-
-
Notifications
You must be signed in to change notification settings - Fork 2.4k
/
std.zig
311 lines (243 loc) · 11.2 KB
/
std.zig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
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());
}