Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

42807 0 0 Zig
Normal View History Raw
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;
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;
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;
rework the progress module and integrate with stage1
2019-10-17 20:20:22 -04:00
pub const ChildProcess = @import("child_process.zig").ChildProcess;
Add std.ComptimeStringMap
2020-05-26 21:22:20 -07:00
pub const ComptimeStringMap = @import("comptime_string_map.zig").ComptimeStringMap;
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;
Ugh. I updated these but forgot to git add.
2019-05-04 03:08:33 +00:00
pub const PackedIntArray = @import("packed_int_array.zig").PackedIntArray;
rework the progress module and integrate with stage1
2019-10-17 20:20:22 -04:00
pub const PackedIntArrayEndian = @import("packed_int_array.zig").PackedIntArrayEndian;
Ugh. I updated these but forgot to git add.
2019-05-04 03:08:33 +00:00
pub const PackedIntSlice = @import("packed_int_array.zig").PackedIntSlice;
rework the progress module and integrate with stage1
2019-10-17 20:20:22 -04:00
pub const PackedIntSliceEndian = @import("packed_int_array.zig").PackedIntSliceEndian;
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: 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");
rework the progress module and integrate with stage1
2019-10-17 20:20:22 -04:00
pub const SinglyLinkedList = @import("linked_list.zig").SinglyLinkedList;
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: existing LinkedList is actually a TailQueue
2019-05-04 13:54:28 +10:00
pub const TailQueue = @import("linked_list.zig").TailQueue;
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 Target = @import("target.zig").Target;
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");
tz parsing reader interface, test thicc files, and exclude tzif
2021-12-31 17:17:49 +00:00
pub const Tz = @import("tz.zig").Tz;
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");
first pass at zig build system * `zig build --export [obj|lib|exe]` changed to `zig build_obj`, `zig build_lib` and `zig build_exe` respectively. * `--name` parameter is optional when it can be inferred from the root source filename. closes #207 * `zig build` now looks for `build.zig` which interacts with `std.build.Builder` to describe the targets, and then the zig build system prints TODO: build these targets. See #204 * add `@bitcast` which is mainly used for pointer reinterpret casting and make explicit casting not do pointer reinterpretation. Closes #290 * fix debug info for byval parameters * sort command line help options * `std.debug.panic` supports format string printing * add `std.mem.IncrementingAllocator` * fix const ptr to a variable with data changing at runtime. closes #289
2017-03-31 05:48:15 -04:00
pub const build = @import("build.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");
rename std lib files to new convention
2019-03-02 16:46:04 -05:00
pub const crypto = @import("crypto.zig");
std: separate str and cstr
2016-05-07 10:52:52 -07:00
pub const cstr = @import("cstr.zig");
rename std lib files to new convention
2019-03-02 16:46:04 -05:00
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");
*WIP* async/await TCP server
2018-03-07 03:55:52 -05:00
pub const event = @import("event.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");
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");
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;
std: add BloomFilter data structure
2019-07-08 01:09:54 +10:00
pub const packed_int_array = @import("packed_int_array.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 pdb = @import("pdb.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");
rename std lib files to new convention
2019-03-02 16:46:04 -05:00
pub const rand = @import("rand.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: 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");
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");
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");
x, x/os/Socket: initial work on new Socket abstraction Kick-start initial work on new cross-platform abstraction for sockets. Adds a test for read timeouts and a test for creating a non-blocking socket pair on Linux. The new Socket abstraction is barebones and is made to support both blocking and non-blocking abstractions, alongside different socket protocols and domains. Support for platform-dependant socket options that handles unsupported platforms gracefully via. comptime checks is provided for the new Socket abstraction. This also marks the first out of many commits for introducing breaking changes to the standard library in a separate `x` folder, which was pre-approved by @andrewrk. The intent for the new `x` package is to introduce new async, event loop, networking, and operating system abstractions that would require breaking the standard library significantly. By having the `x` package, code in the standard library and compiler may then slowly be refactored to use the `x` package. Once modules in the `x` package are stabilized, they can be moved out of the `x` package, and a global 'grep' can be done to update import paths that resolve to the stabilized module in the `x` package.
2021-04-21 16:33:53 +09:00
pub const x = @import("x.zig");
rename std lib files to new convention
2019-03-02 16:46:04 -05:00
pub const zig = @import("zig.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");
// 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 {
migrate from `std.Target.current` to `@import("builtin").target` closes #9388 closes #9321
2021-10-04 23:47:27 -07:00
if (@import("builtin").os.tag == .windows) {
std: skip more tests on Windows to save CI memory I've enabled only the tests that check things specific to Windows that are not tested by other systems.
2021-01-04 22:25:04 -07:00
// We only test the Windows-relevant stuff to save memory because the CI
// server is hitting OOM. TODO revert this after stage2 arrives.
_ = ChildProcess;
_ = DynLib;
_ = Progress;
_ = Target;
_ = Thread;
_ = atomic;
_ = build;
_ = builtin;
_ = debug;
_ = event;
_ = fs;
_ = heap;
_ = io;
_ = log;
_ = macho;
_ = net;
_ = os;
_ = once;
_ = pdb;
_ = process;
_ = testing;
_ = time;
_ = unicode;
_ = zig;
_ = start;
} else {
testing.refAllDecls(@This());
}
zig test no longer requires a separate test_runner.o file See #298
2017-04-27 16:15:41 -04:00
}
Reference in New Issue Copy Permalink