aboutsummaryrefslogtreecommitdiff
path: root/std
diff options
context:
space:
mode:
Diffstat (limited to 'std')
-rw-r--r--std/array_list.zig6
-rw-r--r--std/base64.zig6
-rw-r--r--std/buffer.zig12
-rw-r--r--std/build.zig498
-rw-r--r--std/fmt/index.zig48
-rw-r--r--std/hash_map.zig16
-rw-r--r--std/heap.zig6
-rw-r--r--std/io_test.zig18
-rw-r--r--std/linked_list.zig10
-rw-r--r--std/math/index.zig60
-rw-r--r--std/mem.zig6
-rw-r--r--std/net.zig89
-rw-r--r--std/os/child_process.zig2
-rw-r--r--std/os/index.zig4
-rw-r--r--std/os/path.zig38
-rw-r--r--std/os/zen.zig19
-rw-r--r--std/rand.zig4
-rw-r--r--std/sort.zig2
-rw-r--r--std/special/bootstrap.zig5
-rw-r--r--std/special/build_runner.zig4
-rw-r--r--std/special/test_runner.zig5
-rw-r--r--std/unicode.zig4
22 files changed, 395 insertions, 467 deletions
diff --git a/std/array_list.zig b/std/array_list.zig
index f07b9fb7f5..a16dec113c 100644
--- a/std/array_list.zig
+++ b/std/array_list.zig
@@ -116,7 +116,7 @@ test "basic ArrayList test" {
defer list.deinit();
{var i: usize = 0; while (i < 10) : (i += 1) {
- %%list.append(i32(i + 1));
+ list.append(i32(i + 1)) catch unreachable;
}}
{var i: usize = 0; while (i < 10) : (i += 1) {
@@ -126,13 +126,13 @@ test "basic ArrayList test" {
assert(list.pop() == 10);
assert(list.len == 9);
- %%list.appendSlice([]const i32 { 1, 2, 3 });
+ list.appendSlice([]const i32 { 1, 2, 3 }) catch unreachable;
assert(list.len == 12);
assert(list.pop() == 3);
assert(list.pop() == 2);
assert(list.pop() == 1);
assert(list.len == 9);
- %%list.appendSlice([]const i32 {});
+ list.appendSlice([]const i32 {}) catch unreachable;
assert(list.len == 9);
}
diff --git a/std/base64.zig b/std/base64.zig
index a790227c5d..10650d3243 100644
--- a/std/base64.zig
+++ b/std/base64.zig
@@ -120,7 +120,7 @@ pub const Base64Decoder = struct {
/// invalid characters result in error.InvalidCharacter.
/// invalid padding results in error.InvalidPadding.
pub fn decode(decoder: &const Base64Decoder, dest: []u8, source: []const u8) -> %void {
- assert(dest.len == %%decoder.calcSize(source));
+ assert(dest.len == (decoder.calcSize(source) catch unreachable));
assert(source.len % 4 == 0);
var src_cursor: usize = 0;
@@ -374,8 +374,8 @@ fn calcDecodedSizeExactUnsafe(source: []const u8, pad_char: u8) -> usize {
test "base64" {
@setEvalBranchQuota(5000);
- %%testBase64();
- comptime %%testBase64();
+ testBase64() catch unreachable;
+ comptime (testBase64() catch unreachable);
}
fn testBase64() -> %void {
diff --git a/std/buffer.zig b/std/buffer.zig
index 27c6b2f216..be69eafcfe 100644
--- a/std/buffer.zig
+++ b/std/buffer.zig
@@ -151,20 +151,20 @@ pub const Buffer = struct {
test "simple Buffer" {
const cstr = @import("cstr.zig");
- var buf = %%Buffer.init(debug.global_allocator, "");
+ var buf = try Buffer.init(debug.global_allocator, "");
assert(buf.len() == 0);
- %%buf.append("hello");
- %%buf.appendByte(' ');
- %%buf.append("world");
+ try buf.append("hello");
+ try buf.appendByte(' ');
+ try buf.append("world");
assert(buf.eql("hello world"));
assert(mem.eql(u8, cstr.toSliceConst(buf.toSliceConst().ptr), buf.toSliceConst()));
- var buf2 = %%Buffer.initFromBuffer(&buf);
+ var buf2 = try Buffer.initFromBuffer(&buf);
assert(buf.eql(buf2.toSliceConst()));
assert(buf.startsWith("hell"));
assert(buf.endsWith("orld"));
- %%buf2.resize(4);
+ try buf2.resize(4);
assert(buf.startsWith(buf2.toSliceConst()));
}
diff --git a/std/build.zig b/std/build.zig
index 716b94e12e..cd6b3811ea 100644
--- a/std/build.zig
+++ b/std/build.zig
@@ -95,7 +95,7 @@ pub const Builder = struct {
var self = Builder {
.zig_exe = zig_exe,
.build_root = build_root,
- .cache_root = %%os.path.relative(allocator, build_root, cache_root),
+ .cache_root = os.path.relative(allocator, build_root, cache_root) catch unreachable,
.verbose = false,
.verbose_tokenize = false,
.verbose_ast = false,
@@ -113,7 +113,7 @@ pub const Builder = struct {
.available_options_list = ArrayList(AvailableOption).init(allocator),
.top_level_steps = ArrayList(&TopLevelStep).init(allocator),
.default_step = undefined,
- .env_map = %%os.getEnvMap(allocator),
+ .env_map = os.getEnvMap(allocator) catch unreachable,
.prefix = undefined,
.search_prefixes = ArrayList([]const u8).init(allocator),
.lib_dir = undefined,
@@ -146,8 +146,8 @@ pub const Builder = struct {
pub fn setInstallPrefix(self: &Builder, maybe_prefix: ?[]const u8) {
self.prefix = maybe_prefix ?? "/usr/local"; // TODO better default
- self.lib_dir = %%os.path.join(self.allocator, self.prefix, "lib");
- self.exe_dir = %%os.path.join(self.allocator, self.prefix, "bin");
+ self.lib_dir = os.path.join(self.allocator, self.prefix, "lib") catch unreachable;
+ self.exe_dir = os.path.join(self.allocator, self.prefix, "bin") catch unreachable;
}
pub fn addExecutable(self: &Builder, name: []const u8, root_src: ?[]const u8) -> &LibExeObjStep {
@@ -169,7 +169,7 @@ pub const Builder = struct {
}
pub fn addTest(self: &Builder, root_src: []const u8) -> &TestStep {
- const test_step = %%self.allocator.create(TestStep);
+ const test_step = self.allocator.create(TestStep) catch unreachable;
*test_step = TestStep.init(self, root_src);
return test_step;
}
@@ -204,20 +204,20 @@ pub const Builder = struct {
}
pub fn addWriteFile(self: &Builder, file_path: []const u8, data: []const u8) -> &WriteFileStep {
- const write_file_step = %%self.allocator.create(WriteFileStep);
+ const write_file_step = self.allocator.create(WriteFileStep) catch unreachable;
*write_file_step = WriteFileStep.init(self, file_path, data);
return write_file_step;
}
pub fn addLog(self: &Builder, comptime format: []const u8, args: ...) -> &LogStep {
const data = self.fmt(format, args);
- const log_step = %%self.allocator.create(LogStep);
+ const log_step = self.allocator.create(LogStep) catch unreachable;
*log_step = LogStep.init(self, data);
return log_step;
}
pub fn addRemoveDirTree(self: &Builder, dir_path: []const u8) -> &RemoveDirStep {
- const remove_dir_step = %%self.allocator.create(RemoveDirStep);
+ const remove_dir_step = self.allocator.create(RemoveDirStep) catch unreachable;
*remove_dir_step = RemoveDirStep.init(self, dir_path);
return remove_dir_step;
}
@@ -231,15 +231,15 @@ pub const Builder = struct {
}
pub fn addCIncludePath(self: &Builder, path: []const u8) {
- %%self.include_paths.append(path);
+ self.include_paths.append(path) catch unreachable;
}
pub fn addRPath(self: &Builder, path: []const u8) {
- %%self.rpaths.append(path);
+ self.rpaths.append(path) catch unreachable;
}
pub fn addLibPath(self: &Builder, path: []const u8) {
- %%self.lib_paths.append(path);
+ self.lib_paths.append(path) catch unreachable;
}
pub fn make(self: &Builder, step_names: []const []const u8) -> %void {
@@ -247,11 +247,11 @@ pub const Builder = struct {
defer wanted_steps.deinit();
if (step_names.len == 0) {
- %%wanted_steps.append(&self.default_step);
+ wanted_steps.append(&self.default_step) catch unreachable;
} else {
for (step_names) |step_name| {
const s = try self.getTopLevelStepByName(step_name);
- %%wanted_steps.append(s);
+ wanted_steps.append(s) catch unreachable;
}
}
@@ -264,7 +264,7 @@ pub const Builder = struct {
if (self.have_install_step)
return &self.install_tls.step;
- %%self.top_level_steps.append(&self.install_tls);
+ self.top_level_steps.append(&self.install_tls) catch unreachable;
self.have_install_step = true;
return &self.install_tls.step;
}
@@ -273,7 +273,7 @@ pub const Builder = struct {
if (self.have_uninstall_step)
return &self.uninstall_tls.step;
- %%self.top_level_steps.append(&self.uninstall_tls);
+ self.top_level_steps.append(&self.uninstall_tls) catch unreachable;
self.have_uninstall_step = true;
return &self.uninstall_tls.step;
}
@@ -372,10 +372,10 @@ pub const Builder = struct {
.type_id = type_id,
.description = description,
};
- if (%%self.available_options_map.put(name, available_option) != null) {
+ if ((self.available_options_map.put(name, available_option) catch unreachable) != null) {
debug.panic("Option '{}' declared twice", name);
}
- %%self.available_options_list.append(available_option);
+ self.available_options_list.append(available_option) catch unreachable;
const entry = self.user_input_options.get(name) ?? return null;
entry.value.used = true;
@@ -419,12 +419,12 @@ pub const Builder = struct {
}
pub fn step(self: &Builder, name: []const u8, description: []const u8) -> &Step {
- const step_info = %%self.allocator.create(TopLevelStep);
+ const step_info = self.allocator.create(TopLevelStep) catch unreachable;
*step_info = TopLevelStep {
.step = Step.initNoOp(name, self.allocator),
.description = description,
};
- %%self.top_level_steps.append(step_info);
+ self.top_level_steps.append(step_info) catch unreachable;
return &step_info.step;
}
@@ -450,32 +450,32 @@ pub const Builder = struct {
}
pub fn addUserInputOption(self: &Builder, name: []const u8, value: []const u8) -> bool {
- if (%%self.user_input_options.put(name, UserInputOption {
+ if (self.user_input_options.put(name, UserInputOption {
.name = name,
.value = UserValue { .Scalar = value },
.used = false,
- })) |*prev_value| {
+ }) catch unreachable) |*prev_value| {
// option already exists
switch (prev_value.value) {
UserValue.Scalar => |s| {
// turn it into a list
var list = ArrayList([]const u8).init(self.allocator);
- %%list.append(s);
- %%list.append(value);
- _ = %%self.user_input_options.put(name, UserInputOption {
+ list.append(s) catch unreachable;
+ list.append(value) catch unreachable;
+ _ = self.user_input_options.put(name, UserInputOption {
.name = name,
.value = UserValue { .List = list },
.used = false,
- });
+ }) catch unreachable;
},
UserValue.List => |*list| {
// append to the list
- %%list.append(value);
- _ = %%self.user_input_options.put(name, UserInputOption {
+ list.append(value) catch unreachable;
+ _ = self.user_input_options.put(name, UserInputOption {
.name = name,
.value = UserValue { .List = *list },
.used = false,
- });
+ }) catch unreachable;
},
UserValue.Flag => {
warn("Option '-D{}={}' conflicts with flag '-D{}'.\n", name, value, name);
@@ -487,11 +487,11 @@ pub const Builder = struct {
}
pub fn addUserInputFlag(self: &Builder, name: []const u8) -> bool {
- if (%%self.user_input_options.put(name, UserInputOption {
+ if (self.user_input_options.put(name, UserInputOption {
.name = name,
.value = UserValue {.Flag = {} },
.used = false,
- })) |*prev_value| {
+ }) catch unreachable) |*prev_value| {
switch (prev_value.value) {
UserValue.Scalar => |s| {
warn("Flag '-D{}' conflicts with option '-D{}={}'.\n", name, name, s);
@@ -567,7 +567,7 @@ pub const Builder = struct {
printCmd(cwd, argv);
}
- const child = %%os.ChildProcess.init(argv, self.allocator);
+ const child = os.ChildProcess.init(argv, self.allocator) catch unreachable;
defer child.deinit();
child.cwd = cwd;
@@ -617,17 +617,17 @@ pub const Builder = struct {
///::dest_rel_path is relative to prefix path or it can be an absolute path
pub fn addInstallFile(self: &Builder, src_path: []const u8, dest_rel_path: []const u8) -> &InstallFileStep {
- const full_dest_path = %%os.path.resolve(self.allocator, self.prefix, dest_rel_path);
+ const full_dest_path = os.path.resolve(self.allocator, self.prefix, dest_rel_path) catch unreachable;
self.pushInstalledFile(full_dest_path);
- const install_step = %%self.allocator.create(InstallFileStep);
+ const install_step = self.allocator.create(InstallFileStep) catch unreachable;
*install_step = InstallFileStep.init(self, src_path, full_dest_path);
return install_step;
}
pub fn pushInstalledFile(self: &Builder, full_path: []const u8) {
_ = self.getUninstallStep();
- %%self.installed_files.append(full_path);
+ self.installed_files.append(full_path) catch unreachable;
}
fn copyFile(self: &Builder, source_path: []const u8, dest_path: []const u8) -> %void {
@@ -652,11 +652,11 @@ pub const Builder = struct {
}
fn pathFromRoot(self: &Builder, rel_path: []const u8) -> []u8 {
- return %%os.path.resolve(self.allocator, self.build_root, rel_path);
+ return os.path.resolve(self.allocator, self.build_root, rel_path) catch unreachable;
}
pub fn fmt(self: &Builder, comptime format: []const u8, args: ...) -> []u8 {
- return %%fmt_lib.allocPrint(self.allocator, format, args);
+ return fmt_lib.allocPrint(self.allocator, format, args) catch unreachable;
}
fn getCCExe(self: &Builder) -> []const u8 {
@@ -746,7 +746,7 @@ pub const Builder = struct {
}
pub fn addSearchPrefix(self: &Builder, search_prefix: []const u8) {
- %%self.search_prefixes.append(search_prefix);
+ self.search_prefixes.append(search_prefix) catch unreachable;
}
};
@@ -869,50 +869,50 @@ pub const LibExeObjStep = struct {
pub fn createSharedLibrary(builder: &Builder, name: []const u8, root_src: ?[]const u8,
ver: &const Version) -> &LibExeObjStep
{
- const self = %%builder.allocator.create(LibExeObjStep);
+ const self = builder.allocator.create(LibExeObjStep) catch unreachable;
*self = initExtraArgs(builder, name, root_src, Kind.Lib, false, ver);
return self;
}
pub fn createCSharedLibrary(builder: &Builder, name: []const u8, version: &const Version) -> &LibExeObjStep {
- const self = %%builder.allocator.create(LibExeObjStep);
+ const self = builder.allocator.create(LibExeObjStep) catch unreachable;
*self = initC(builder, name, Kind.Lib, version, false);
return self;
}
pub fn createStaticLibrary(builder: &Builder, name: []const u8, root_src: ?[]const u8) -> &LibExeObjStep {
- const self = %%builder.allocator.create(LibExeObjStep);
+ const self = builder.allocator.create(LibExeObjStep) catch unreachable;
*self = initExtraArgs(builder, name, root_src, Kind.Lib, true, builder.version(0, 0, 0));
return self;
}
pub fn createCStaticLibrary(builder: &Builder, name: []const u8) -> &LibExeObjStep {
- const self = %%builder.allocator.create(LibExeObjStep);
+ const self = builder.allocator.create(LibExeObjStep) catch unreachable;
*self = initC(builder, name, Kind.Lib, builder.version(0, 0, 0), true);
return self;
}
pub fn createObject(builder: &Builder, name: []const u8, root_src: []const u8) -> &LibExeObjStep {
- const self = %%builder.allocator.create(LibExeObjStep);
+ const self = builder.allocator.create(LibExeObjStep) catch unreachable;
*self = initExtraArgs(builder, name, root_src, Kind.Obj, false, builder.version(0, 0, 0));
return self;
}
pub fn createCObject(builder: &Builder, name: []const u8, src: []const u8) -> &LibExeObjStep {
- const self = %%builder.allocator.create(LibExeObjStep);
+ const self = builder.allocator.create(LibExeObjStep) catch unreachable;
*self = initC(builder, name, Kind.Obj, builder.version(0, 0, 0), false);
self.object_src = src;
return self;
}
pub fn createExecutable(builder: &Builder, name: []const u8, root_src: ?[]const u8) -> &LibExeObjStep {
- const self = %%builder.allocator.create(LibExeObjStep);
+ const self = builder.allocator.create(LibExeObjStep) catch unreachable;
*self = initExtraArgs(builder, name, root_src, Kind.Exe, false, builder.version(0, 0, 0));
return self;
}
pub fn createCExecutable(builder: &Builder, name: []const u8) -> &LibExeObjStep {
- const self = %%builder.allocator.create(LibExeObjStep);
+ const self = builder.allocator.create(LibExeObjStep) catch unreachable;
*self = initC(builder, name, Kind.Exe, builder.version(0, 0, 0), false);
return self;
}
@@ -1052,7 +1052,7 @@ pub const LibExeObjStep = struct {
pub fn linkFramework(self: &LibExeObjStep, framework_name: []const u8) {
assert(self.target.isDarwin());
- %%self.frameworks.put(framework_name);
+ self.frameworks.put(framework_name) catch unreachable;
}
pub fn linkLibrary(self: &LibExeObjStep, lib: &LibExeObjStep) {
@@ -1061,30 +1061,30 @@ pub const LibExeObjStep = struct {
self.step.dependOn(&lib.step);
- %%self.full_path_libs.append(lib.getOutputPath());
+ self.full_path_libs.append(lib.getOutputPath()) catch unreachable;
// TODO should be some kind of isolated directory that only has this header in it
- %%self.include_dirs.append(self.builder.cache_root);
+ self.include_dirs.append(self.builder.cache_root) catch unreachable;
self.need_flat_namespace_hack = true;
// inherit the object's frameworks
if (self.target.isDarwin() and lib.static) {
var it = lib.frameworks.iterator();
while (it.next()) |entry| {
- %%self.frameworks.put(entry.key);
+ self.frameworks.put(entry.key) catch unreachable;
}
}
}
pub fn linkSystemLibrary(self: &LibExeObjStep, name: []const u8) {
assert(self.kind != Kind.Obj);
- %%self.link_libs.put(name);
+ self.link_libs.put(name) catch unreachable;
}
pub fn addSourceFile(self: &LibExeObjStep, file: []const u8) {
assert(self.kind != Kind.Obj);
assert(!self.is_zig);
- %%self.source_files.append(file);
+ self.source_files.append(file) catch unreachable;
}
pub fn setVerboseLink(self: &LibExeObjStep, value: bool) {
@@ -1108,7 +1108,7 @@ pub const LibExeObjStep = struct {
return if (self.output_path) |output_path|
output_path
else
- %%os.path.join(self.builder.allocator, self.builder.cache_root, self.out_filename);
+ os.path.join(self.builder.allocator, self.builder.cache_root, self.out_filename) catch unreachable;
}
pub fn setOutputHPath(self: &LibExeObjStep, file_path: []const u8) {
@@ -1124,17 +1124,17 @@ pub const LibExeObjStep = struct {
return if (self.output_h_path) |output_h_path|
output_h_path
else
- %%os.path.join(self.builder.allocator, self.builder.cache_root, self.out_h_filename);
+ os.path.join(self.builder.allocator, self.builder.cache_root, self.out_h_filename) catch unreachable;
}
pub fn addAssemblyFile(self: &LibExeObjStep, path: []const u8) {
- %%self.assembly_files.append(path);
+ self.assembly_files.append(path) catch unreachable;
}
pub fn addObjectFile(self: &LibExeObjStep, path: []const u8) {
assert(self.kind != Kind.Obj);
- %%self.object_files.append(path);
+ self.object_files.append(path) catch unreachable;
}
pub fn addObject(self: &LibExeObjStep, obj: &LibExeObjStep) {
@@ -1143,7 +1143,7 @@ pub const LibExeObjStep = struct {
self.step.dependOn(&obj.step);
- %%self.object_files.append(obj.getOutputPath());
+ self.object_files.append(obj.getOutputPath()) catch unreachable;
// TODO make this lazy instead of stateful
if (!obj.disable_libc) {
@@ -1151,29 +1151,29 @@ pub const LibExeObjStep = struct {
}
// TODO should be some kind of isolated directory that only has this header in it
- %%self.include_dirs.append(self.builder.cache_root);
+ self.include_dirs.append(self.builder.cache_root) catch unreachable;
}
pub fn addIncludeDir(self: &LibExeObjStep, path: []const u8) {
- %%self.include_dirs.append(path);
+ self.include_dirs.append(path) catch unreachable;
}
pub fn addLibPath(self: &LibExeObjStep, path: []const u8) {
- %%self.lib_paths.append(path);
+ self.lib_paths.append(path) catch unreachable;
}
pub fn addPackagePath(self: &LibExeObjStep, name: []const u8, pkg_index_path: []const u8) {
assert(self.is_zig);
- %%self.packages.append(Pkg {
+ self.packages.append(Pkg {
.name = name,
.path = pkg_index_path,
- });
+ }) catch unreachable;
}
pub fn addCompileFlags(self: &LibExeObjStep, flags: []const []const u8) {
for (flags) |flag| {
- %%self.cflags.append(flag);
+ self.cflags.append(flag) catch unreachable;
}
}
@@ -1200,148 +1200,148 @@ pub const LibExeObjStep = struct {
var zig_args = ArrayList([]const u8).init(builder.allocator);
defer zig_args.deinit();
- %%zig_args.append(builder.zig_exe);
+ zig_args.append(builder.zig_exe) catch unreachable;
const cmd = switch (self.kind) {
Kind.Lib => "build-lib",
Kind.Exe => "build-exe",
Kind.Obj => "build-obj",
};
- %%zig_args.append(cmd);
+ zig_args.append(cmd) catch unreachable;
if (self.root_src) |root_src| {
- %%zig_args.append(builder.pathFromRoot(root_src));
+ zig_args.append(builder.pathFromRoot(root_src)) catch unreachable;
}
for (self.object_files.toSliceConst()) |object_file| {
- %%zig_args.append("--object");
- %%zig_args.append(builder.pathFromRoot(object_file));
+ zig_args.append("--object") catch unreachable;
+ zig_args.append(builder.pathFromRoot(object_file)) catch unreachable;
}
for (self.assembly_files.toSliceConst()) |asm_file| {
- %%zig_args.append("--assembly");
- %%zig_args.append(builder.pathFromRoot(asm_file));
+ zig_args.append("--assembly") catch unreachable;
+ zig_args.append(builder.pathFromRoot(asm_file)) catch unreachable;
}
- if (builder.verbose_tokenize) %%zig_args.append("--verbose-tokenize");
- if (builder.verbose_ast) %%zig_args.append("--verbose-ast");
- if (builder.verbose_cimport) %%zig_args.append("--verbose-cimport");
- if (builder.verbose_ir) %%zig_args.append("--verbose-ir");
- if (builder.verbose_llvm_ir) %%zig_args.append("--verbose-llvm-ir");
- if (builder.verbose_link or self.verbose_link) %%zig_args.append("--verbose-link");
+ if (builder.verbose_tokenize) zig_args.append("--verbose-tokenize") catch unreachable;
+ if (builder.verbose_ast) zig_args.append("--verbose-ast") catch unreachable;
+ if (builder.verbose_cimport) zig_args.append("--verbose-cimport") catch unreachable;
+ if (builder.verbose_ir) zig_args.append("--verbose-ir") catch unreachable;
+ if (builder.verbose_llvm_ir) zig_args.append("--verbose-llvm-ir") catch unreachable;
+ if (builder.verbose_link or self.verbose_link) zig_args.append("--verbose-link") catch unreachable;
if (self.strip) {
- %%zig_args.append("--strip");
+ zig_args.append("--strip") catch unreachable;
}
switch (self.build_mode) {
builtin.Mode.Debug => {},
- builtin.Mode.ReleaseSafe => %%zig_args.append("--release-safe"),
- builtin.Mode.ReleaseFast => %%zig_args.append("--release-fast"),
+ builtin.Mode.ReleaseSafe => zig_args.append("--release-safe") catch unreachable,
+ builtin.Mode.ReleaseFast => zig_args.append("--release-fast") catch unreachable,
}
- %%zig_args.append("--cache-dir");
- %%zig_args.append(builder.pathFromRoot(builder.cache_root));
+ zig_args.append("--cache-dir") catch unreachable;
+ zig_args.append(builder.pathFromRoot(builder.cache_root)) catch unreachable;
const output_path = builder.pathFromRoot(self.getOutputPath());
- %%zig_args.append("--output");
- %%zig_args.append(output_path);
+ zig_args.append("--output") catch unreachable;
+ zig_args.append(output_path) catch unreachable;
if (self.kind != Kind.Exe) {
const output_h_path = self.getOutputHPath();
- %%zig_args.append("--output-h");
- %%zig_args.append(builder.pathFromRoot(output_h_path));
+ zig_args.append("--output-h") catch unreachable;
+ zig_args.append(builder.pathFromRoot(output_h_path)) catch unreachable;
}
- %%zig_args.append("--name");
- %%zig_args.append(self.name);
+ zig_args.append("--name") catch unreachable;
+ zig_args.append(self.name) catch unreachable;
if (self.kind == Kind.Lib and !self.static) {
- %%zig_args.append("--ver-major");
- %%zig_args.append(builder.fmt("{}", self.version.major));
+ zig_args.append("--ver-major") catch unreachable;
+ zig_args.append(builder.fmt("{}", self.version.major)) catch unreachable;
- %%zig_args.append("--ver-minor");
- %%zig_args.append(builder.fmt("{}", self.version.minor));
+ zig_args.append("--ver-minor") catch unreachable;
+ zig_args.append(builder.fmt("{}", self.version.minor)) catch unreachable;
- %%zig_args.append("--ver-patch");
- %%zig_args.append(builder.fmt("{}", self.version.patch));
+ zig_args.append("--ver-patch") catch unreachable;
+ zig_args.append(builder.fmt("{}", self.version.patch)) catch unreachable;
}
switch (self.target) {
Target.Native => {},
Target.Cross => |cross_target| {
- %%zig_args.append("--target-arch");
- %%zig_args.append(@tagName(cross_target.arch));
+ zig_args.append("--target-arch") catch unreachable;
+ zig_args.append(@tagName(cross_target.arch)) catch unreachable;
- %%zig_args.append("--target-os");
- %%zig_args.append(@tagName(cross_target.os));
+ zig_args.append("--target-os") catch unreachable;
+ zig_args.append(@tagName(cross_target.os)) catch unreachable;
- %%zig_args.append("--target-environ");
- %%zig_args.append(@tagName(cross_target.environ));
+ zig_args.append("--target-environ") catch unreachable;
+ zig_args.append(@tagName(cross_target.environ)) catch unreachable;
},
}
if (self.linker_script) |linker_script| {
- %%zig_args.append("--linker-script");
- %%zig_args.append(linker_script);
+ zig_args.append("--linker-script") catch unreachable;
+ zig_args.append(linker_script) catch unreachable;
}
{
var it = self.link_libs.iterator();
while (true) {
const entry = it.next() ?? break;
- %%zig_args.append("--library");
- %%zig_args.append(entry.key);
+ zig_args.append("--library") catch unreachable;
+ zig_args.append(entry.key) catch unreachable;
}
}
if (!self.disable_libc) {
- %%zig_args.append("--library");
- %%zig_args.append("c");
+ zig_args.append("--library") catch unreachable;
+ zig_args.append("c") catch unreachable;
}
for (self.packages.toSliceConst()) |pkg| {
- %%zig_args.append("--pkg-begin");
- %%zig_args.append(pkg.name);
- %%zig_args.append(builder.pathFromRoot(pkg.path));
- %%zig_args.append("--pkg-end");
+ zig_args.append("--pkg-begin") catch unreachable;
+ zig_args.append(pkg.name) catch unreachable;
+ zig_args.append(builder.pathFromRoot(pkg.path)) catch unreachable;
+ zig_args.append("--pkg-end") catch unreachable;
}
for (self.include_dirs.toSliceConst()) |include_path| {
- %%zig_args.append("-isystem");
- %%zig_args.append(self.builder.pathFromRoot(include_path));
+ zig_args.append("-isystem") catch unreachable;
+ zig_args.append(self.builder.pathFromRoot(include_path)) catch unreachable;
}
for (builder.include_paths.toSliceConst()) |include_path| {
- %%zig_args.append("-isystem");
- %%zig_args.append(builder.pathFromRoot(include_path));
+ zig_args.append("-isystem") catch unreachable;
+ zig_args.append(builder.pathFromRoot(include_path)) catch unreachable;
}
for (builder.rpaths.toSliceConst()) |rpath| {
- %%zig_args.append("-rpath");
- %%zig_args.append(rpath);
+ zig_args.append("-rpath") catch unreachable;
+ zig_args.append(rpath) catch unreachable;
}
for (self.lib_paths.toSliceConst()) |lib_path| {
- %%zig_args.append("--library-path");
- %%zig_args.append(lib_path);
+ zig_args.append("--library-path") catch unreachable;
+ zig_args.append(lib_path) catch unreachable;
}
for (builder.lib_paths.toSliceConst()) |lib_path| {
- %%zig_args.append("--library-path");
- %%zig_args.append(lib_path);
+ zig_args.append("--library-path") catch unreachable;
+ zig_args.append(lib_path) catch unreachable;
}
for (self.full_path_libs.toSliceConst()) |full_path_lib| {
- %%zig_args.append("--library");
- %%zig_args.append(builder.pathFromRoot(full_path_lib));
+ zig_args.append("--library") catch unreachable;
+ zig_args.append(builder.pathFromRoot(full_path_lib)) catch unreachable;
}
if (self.target.isDarwin()) {
var it = self.frameworks.iterator();
while (it.next()) |entry| {
- %%zig_args.append("-framework");
- %%zig_args.append(entry.key);
+ zig_args.append("-framework") catch unreachable;
+ zig_args.append(entry.key) catch unreachable;
}
}
@@ -1355,46 +1355,46 @@ pub const LibExeObjStep = struct {
fn appendCompileFlags(self: &LibExeObjStep, args: &ArrayList([]const u8)) {
if (!self.strip) {
- %%args.append("-g");
+ args.append("-g") catch unreachable;
}
switch (self.build_mode) {
builtin.Mode.Debug => {
if (self.disable_libc) {
- %%args.append("-fno-stack-protector");
+ args.append("-fno-stack-protector") catch unreachable;
} else {
- %%args.append("-fstack-protector-strong");
- %%args.append("--param");
- %%args.append("ssp-buffer-size=4");
+ args.append("-fstack-protector-strong") catch unreachable;
+ args.append("--param") catch unreachable;
+ args.append("ssp-buffer-size=4") catch unreachable;
}
},
builtin.Mode.ReleaseSafe => {
- %%args.append("-O2");
+ args.append("-O2") catch unreachable;
if (self.disable_libc) {
- %%args.append("-fno-stack-protector");
+ args.append("-fno-stack-protector") catch unreachable;
} else {
- %%args.append("-D_FORTIFY_SOURCE=2");
- %%args.append("-fstack-protector-strong");
- %%args.append("--param");
- %%args.append("ssp-buffer-size=4");
+ args.append("-D_FORTIFY_SOURCE=2") catch unreachable;
+ args.append("-fstack-protector-strong") catch unreachable;
+ args.append("--param") catch unreachable;
+ args.append("ssp-buffer-size=4") catch unreachable;
}
},
builtin.Mode.ReleaseFast => {
- %%args.append("-O2");
- %%args.append("-fno-stack-protector");
+ args.append("-O2") catch unreachable;
+ args.append("-fno-stack-protector") catch unreachable;
},
}
for (self.include_dirs.toSliceConst()) |dir| {
- %%args.append("-I");
- %%args.append(self.builder.pathFromRoot(dir));
+ args.append("-I") catch unreachable;
+ args.append(self.builder.pathFromRoot(dir)) catch unreachable;
}
for (self.cflags.toSliceConst()) |cflag| {
- %%args.append(cflag);
+ args.append(cflag) catch unreachable;
}
if (self.disable_libc) {
- %%args.append("-nostdlib");
+ args.append("-nostdlib") catch unreachable;
}
}
@@ -1408,18 +1408,18 @@ pub const LibExeObjStep = struct {
var cc_args = ArrayList([]const u8).init(builder.allocator);
defer cc_args.deinit();
- %%cc_args.append(cc);
+ cc_args.append(cc) catch unreachable;
const is_darwin = self.target.isDarwin();
switch (self.kind) {
Kind.Obj => {
- %%cc_args.append("-c");
- %%cc_args.append(builder.pathFromRoot(self.object_src));
+ cc_args.append("-c") catch unreachable;
+ cc_args.append(builder.pathFromRoot(self.object_src)) catch unreachable;
const output_path = builder.pathFromRoot(self.getOutputPath());
- %%cc_args.append("-o");
- %%cc_args.append(output_path);
+ cc_args.append("-o") catch unreachable;
+ cc_args.append(output_path) catch unreachable;
self.appendCompileFlags(&cc_args);
@@ -1427,113 +1427,113 @@ pub const LibExeObjStep = struct {
},
Kind.Lib => {
for (self.source_files.toSliceConst()) |source_file| {
- %%cc_args.resize(0);
- %%cc_args.append(cc);
+ cc_args.resize(0) catch unreachable;
+ cc_args.append(cc) catch unreachable;
if (!self.static) {
- %%cc_args.append("-fPIC");
+ cc_args.append("-fPIC") catch unreachable;
}
const abs_source_file = builder.pathFromRoot(source_file);
- %%cc_args.append("-c");
- %%cc_args.append(abs_source_file);
+ cc_args.append("-c") catch unreachable;
+ cc_args.append(abs_source_file) catch unreachable;
- const cache_o_src = %%os.path.join(builder.allocator, builder.cache_root, source_file);
+ const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;
const cache_o_dir = os.path.dirname(cache_o_src);
try builder.makePath(cache_o_dir);
const cache_o_file = builder.fmt("{}{}", cache_o_src, self.target.oFileExt());
- %%cc_args.append("-o");
- %%cc_args.append(builder.pathFromRoot(cache_o_file));
+ cc_args.append("-o") catch unreachable;
+ cc_args.append(builder.pathFromRoot(cache_o_file)) catch unreachable;
self.appendCompileFlags(&cc_args);
try builder.spawnChild(cc_args.toSliceConst());
- %%self.object_files.append(cache_o_file);
+ self.object_files.append(cache_o_file) catch unreachable;
}
if (self.static) {
// ar
- %%cc_args.resize(0);
- %%cc_args.append("ar");
+ cc_args.resize(0) catch unreachable;
+ cc_args.append("ar") catch unreachable;
- %%cc_args.append("qc");
+ cc_args.append("qc") catch unreachable;
const output_path = builder.pathFromRoot(self.getOutputPath());
- %%cc_args.append(output_path);
+ cc_args.append(output_path) catch unreachable;
for (self.object_files.toSliceConst()) |object_file| {
- %%cc_args.append(builder.pathFromRoot(object_file));
+ cc_args.append(builder.pathFromRoot(object_file)) catch unreachable;
}
try builder.spawnChild(cc_args.toSliceConst());
// ranlib
- %%cc_args.resize(0);
- %%cc_args.append("ranlib");
- %%cc_args.append(output_path);
+ cc_args.resize(0) catch unreachable;
+ cc_args.append("ranlib") catch unreachable;
+ cc_args.append(output_path) catch unreachable;
try builder.spawnChild(cc_args.toSliceConst());
} else {
- %%cc_args.resize(0);
- %%cc_args.append(cc);
+ cc_args.resize(0) catch unreachable;
+ cc_args.append(cc) catch unreachable;
if (is_darwin) {
- %%cc_args.append("-dynamiclib");
+ cc_args.append("-dynamiclib") catch unreachable;
- %%cc_args.append("-Wl,-headerpad_max_install_names");
+ cc_args.append("-Wl,-headerpad_max_install_names") catch unreachable;
- %%cc_args.append("-compatibility_version");
- %%cc_args.append(builder.fmt("{}.0.0", self.version.major));
+ cc_args.append("-compatibility_version") catch unreachable;
+ cc_args.append(builder.fmt("{}.0.0", self.version.major)) catch unreachable;
- %%cc_args.append("-current_version");
- %%cc_args.append(builder.fmt("{}.{}.{}", self.version.major, self.version.minor, self.version.patch));
+ cc_args.append("-current_version") catch unreachable;
+ cc_args.append(builder.fmt("{}.{}.{}", self.version.major, self.version.minor, self.version.patch)) catch unreachable;
- const install_name = builder.pathFromRoot(%%os.path.join(builder.allocator, builder.cache_root, self.major_only_filename));
- %%cc_args.append("-install_name");
- %%cc_args.append(install_name);
+ const install_name = builder.pathFromRoot(os.path.join(builder.allocator, builder.cache_root, self.major_only_filename) catch unreachable);
+ cc_args.append("-install_name") catch unreachable;
+ cc_args.append(install_name) catch unreachable;
} else {
- %%cc_args.append("-fPIC");
- %%cc_args.append("-shared");
+ cc_args.append("-fPIC") catch unreachable;
+ cc_args.append("-shared") catch unreachable;
const soname_arg = builder.fmt("-Wl,-soname,lib{}.so.{d}", self.name, self.version.major);
defer builder.allocator.free(soname_arg);
- %%cc_args.append(soname_arg);
+ cc_args.append(soname_arg) catch unreachable;
}
const output_path = builder.pathFromRoot(self.getOutputPath());
- %%cc_args.append("-o");
- %%cc_args.append(output_path);
+ cc_args.append("-o") catch unreachable;
+ cc_args.append(output_path) catch unreachable;
for (self.object_files.toSliceConst()) |object_file| {
- %%cc_args.append(builder.pathFromRoot(object_file));
+ cc_args.append(builder.pathFromRoot(object_file)) catch unreachable;
}
if (!is_darwin) {
const rpath_arg = builder.fmt("-Wl,-rpath,{}",
- %%os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)));
+ os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)) catch unreachable);
defer builder.allocator.free(rpath_arg);
- %%cc_args.append(rpath_arg);
+ cc_args.append(rpath_arg) catch unreachable;
- %%cc_args.append("-rdynamic");
+ cc_args.append("-rdynamic") catch unreachable;
}
for (self.full_path_libs.toSliceConst()) |full_path_lib| {
- %%cc_args.append(builder.pathFromRoot(full_path_lib));
+ cc_args.append(builder.pathFromRoot(full_path_lib)) catch unreachable;
}
{
var it = self.link_libs.iterator();
while (it.next()) |entry| {
- %%cc_args.append(builder.fmt("-l{}", entry.key));
+ cc_args.append(builder.fmt("-l{}", entry.key)) catch unreachable;
}
}
if (is_darwin and !self.static) {
var it = self.frameworks.iterator();
while (it.next()) |entry| {
- %%cc_args.append("-framework");
- %%cc_args.append(entry.key);
+ cc_args.append("-framework") catch unreachable;
+ cc_args.append(entry.key) catch unreachable;
}
}
@@ -1547,75 +1547,75 @@ pub const LibExeObjStep = struct {
},
Kind.Exe => {
for (self.source_files.toSliceConst()) |source_file| {
- %%cc_args.resize(0);
- %%cc_args.append(cc);
+ cc_args.resize(0) catch unreachable;
+ cc_args.append(cc) catch unreachable;
const abs_source_file = builder.pathFromRoot(source_file);
- %%cc_args.append("-c");
- %%cc_args.append(abs_source_file);
+ cc_args.append("-c") catch unreachable;
+ cc_args.append(abs_source_file) catch unreachable;
- const cache_o_src = %%os.path.join(builder.allocator, builder.cache_root, source_file);
+ const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;
const cache_o_dir = os.path.dirname(cache_o_src);
try builder.makePath(cache_o_dir);
const cache_o_file = builder.fmt("{}{}", cache_o_src, self.target.oFileExt());
- %%cc_args.append("-o");
- %%cc_args.append(builder.pathFromRoot(cache_o_file));
+ cc_args.append("-o") catch unreachable;
+ cc_args.append(builder.pathFromRoot(cache_o_file)) catch unreachable;
for (self.cflags.toSliceConst()) |cflag| {
- %%cc_args.append(cflag);
+ cc_args.append(cflag) catch unreachable;
}
for (self.include_dirs.toSliceConst()) |dir| {
- %%cc_args.append("-I");
- %%cc_args.append(builder.pathFromRoot(dir));
+ cc_args.append("-I") catch unreachable;
+ cc_args.append(builder.pathFromRoot(dir)) catch unreachable;
}
try builder.spawnChild(cc_args.toSliceConst());
- %%self.object_files.append(cache_o_file);
+ self.object_files.append(cache_o_file) catch unreachable;
}
- %%cc_args.resize(0);
- %%cc_args.append(cc);
+ cc_args.resize(0) catch unreachable;
+ cc_args.append(cc) catch unreachable;
for (self.object_files.toSliceConst()) |object_file| {
- %%cc_args.append(builder.pathFromRoot(object_file));
+ cc_args.append(builder.pathFromRoot(object_file)) catch unreachable;
}
const output_path = builder.pathFromRoot(self.getOutputPath());
- %%cc_args.append("-o");
- %%cc_args.append(output_path);
+ cc_args.append("-o") catch unreachable;
+ cc_args.append(output_path) catch unreachable;
const rpath_arg = builder.fmt("-Wl,-rpath,{}",
- %%os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)));
+ os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)) catch unreachable);
defer builder.allocator.free(rpath_arg);
- %%cc_args.append(rpath_arg);
+ cc_args.append(rpath_arg) catch unreachable;
- %%cc_args.append("-rdynamic");
+ cc_args.append("-rdynamic") catch unreachable;
{
var it = self.link_libs.iterator();
while (it.next()) |entry| {
- %%cc_args.append(builder.fmt("-l{}", entry.key));
+ cc_args.append(builder.fmt("-l{}", entry.key)) catch unreachable;
}
}
if (is_darwin) {
if (self.need_flat_namespace_hack) {
- %%cc_args.append("-Wl,-flat_namespace");
+ cc_args.append("-Wl,-flat_namespace") catch unreachable;
}
- %%cc_args.append("-Wl,-search_paths_first");
+ cc_args.append("-Wl,-search_paths_first") catch unreachable;
}
for (self.full_path_libs.toSliceConst()) |full_path_lib| {
- %%cc_args.append(builder.pathFromRoot(full_path_lib));
+ cc_args.append(builder.pathFromRoot(full_path_lib)) catch unreachable;
}
if (is_darwin) {
var it = self.frameworks.iterator();
while (it.next()) |entry| {
- %%cc_args.append("-framework");
- %%cc_args.append(entry.key);
+ cc_args.append("-framework") catch unreachable;
+ cc_args.append(entry.key) catch unreachable;
}
}
@@ -1662,7 +1662,7 @@ pub const TestStep = struct {
}
pub fn linkSystemLibrary(self: &TestStep, name: []const u8) {
- %%self.link_libs.put(name);
+ self.link_libs.put(name) catch unreachable;
}
pub fn setNamePrefix(self: &TestStep, text: []const u8) {
@@ -1696,78 +1696,78 @@ pub const TestStep = struct {
var zig_args = ArrayList([]const u8).init(builder.allocator);
defer zig_args.deinit();
- %%zig_args.append(builder.zig_exe);
+ try zig_args.append(builder.zig_exe);
- %%zig_args.append("test");
- %%zig_args.append(builder.pathFromRoot(self.root_src));
+ try zig_args.append("test");
+ try zig_args.append(builder.pathFromRoot(self.root_src));
if (self.verbose) {
- %%zig_args.append("--verbose");
+ try zig_args.append("--verbose");
}
switch (self.build_mode) {
builtin.Mode.Debug => {},
- builtin.Mode.ReleaseSafe => %%zig_args.append("--release-safe"),
- builtin.Mode.ReleaseFast => %%zig_args.append("--release-fast"),
+ builtin.Mode.ReleaseSafe => try zig_args.append("--release-safe"),
+ builtin.Mode.ReleaseFast => try zig_args.append("--release-fast"),
}
switch (self.target) {
Target.Native => {},
Target.Cross => |cross_target| {
- %%zig_args.append("--target-arch");
- %%zig_args.append(@tagName(cross_target.arch));
+ try zig_args.append("--target-arch");
+ try zig_args.append(@tagName(cross_target.arch));
- %%zig_args.append("--target-os");
- %%zig_args.append(@tagName(cross_target.os));
+ try zig_args.append("--target-os");
+ try zig_args.append(@tagName(cross_target.os));
- %%zig_args.append("--target-environ");
- %%zig_args.append(@tagName(cross_target.environ));
+ try zig_args.append("--target-environ");
+ try zig_args.append(@tagName(cross_target.environ));
},
}
if (self.filter) |filter| {
- %%zig_args.append("--test-filter");
- %%zig_args.append(filter);
+ try zig_args.append("--test-filter");
+ try zig_args.append(filter);
}
if (self.name_prefix.len != 0) {
- %%zig_args.append("--test-name-prefix");
- %%zig_args.append(self.name_prefix);
+ try zig_args.append("--test-name-prefix");
+ try zig_args.append(self.name_prefix);
}
{
var it = self.link_libs.iterator();
while (true) {
const entry = it.next() ?? break;
- %%zig_args.append("--library");
- %%zig_args.append(entry.key);
+ try zig_args.append("--library");
+ try zig_args.append(entry.key);
}
}
if (self.exec_cmd_args) |exec_cmd_args| {
for (exec_cmd_args) |cmd_arg| {
if (cmd_arg) |arg| {
- %%zig_args.append("--test-cmd");
- %%zig_args.append(arg);
+ try zig_args.append("--test-cmd");
+ try zig_args.append(arg);
} else {
- %%zig_args.append("--test-cmd-bin");
+ try zig_args.append("--test-cmd-bin");
}
}
}
for (builder.include_paths.toSliceConst()) |include_path| {
- %%zig_args.append("-isystem");
- %%zig_args.append(builder.pathFromRoot(include_path));
+ try zig_args.append("-isystem");
+ try zig_args.append(builder.pathFromRoot(include_path));
}
for (builder.rpaths.toSliceConst()) |rpath| {
- %%zig_args.append("-rpath");
- %%zig_args.append(rpath);
+ try zig_args.append("-rpath");
+ try zig_args.append(rpath);
}
for (builder.lib_paths.toSliceConst()) |lib_path| {
- %%zig_args.append("--library-path");
- %%zig_args.append(lib_path);
+ try zig_args.append("--library-path");
+ try zig_args.append(lib_path);
}
try builder.spawnChild(zig_args.toSliceConst());
@@ -1785,11 +1785,11 @@ pub const CommandStep = struct {
pub fn create(builder: &Builder, cwd: ?[]const u8, env_map: &const BufMap,
argv: []const []const u8) -> &CommandStep
{
- const self = %%builder.allocator.create(CommandStep);
+ const self = builder.allocator.create(CommandStep) catch unreachable;
*self = CommandStep {
.builder = builder,
.step = Step.init(argv[0], builder.allocator, make),
- .argv = %%builder.allocator.alloc([]u8, argv.len),
+ .argv = builder.allocator.alloc([]u8, argv.len) catch unreachable,
.cwd = cwd,
.env_map = env_map,
};
@@ -1815,7 +1815,7 @@ const InstallArtifactStep = struct {
const Self = this;
pub fn create(builder: &Builder, artifact: &LibExeObjStep) -> &Self {
- const self = %%builder.allocator.create(Self);
+ const self = builder.allocator.create(Self) catch unreachable;
const dest_dir = switch (artifact.kind) {
LibExeObjStep.Kind.Obj => unreachable,
LibExeObjStep.Kind.Exe => builder.exe_dir,
@@ -1825,15 +1825,15 @@ const InstallArtifactStep = struct {
.builder = builder,
.step = Step.init(builder.fmt("install {}", artifact.step.name), builder.allocator, make),
.artifact = artifact,
- .dest_file = %%os.path.join(builder.allocator, dest_dir, artifact.out_filename),
+ .dest_file = os.path.join(builder.allocator, dest_dir, artifact.out_filename) catch unreachable,
};
self.step.dependOn(&artifact.step);
builder.pushInstalledFile(self.dest_file);
if (self.artifact.kind == LibExeObjStep.Kind.Lib and !self.artifact.static) {
- builder.pushInstalledFile(%%os.path.join(builder.allocator, builder.lib_dir,
- artifact.major_only_filename));
- builder.pushInstalledFile(%%os.path.join(builder.allocator, builder.lib_dir,
- artifact.name_only_filename));
+ builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir,
+ artifact.major_only_filename) catch unreachable);
+ builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir,
+ artifact.name_only_filename) catch unreachable);
}
return self;
}
@@ -1978,7 +1978,7 @@ pub const Step = struct {
}
pub fn dependOn(self: &Step, other: &Step) {
- %%self.dependencies.append(other);
+ self.dependencies.append(other) catch unreachable;
}
fn makeNoOp(self: &Step) -> %void {}
@@ -1990,13 +1990,13 @@ fn doAtomicSymLinks(allocator: &Allocator, output_path: []const u8, filename_maj
const out_dir = os.path.dirname(output_path);
const out_basename = os.path.basename(output_path);
// sym link for libfoo.so.1 to libfoo.so.1.2.3
- const major_only_path = %%os.path.join(allocator, out_dir, filename_major_only);
+ const major_only_path = os.path.join(allocator, out_dir, filename_major_only) catch unreachable;
os.atomicSymLink(allocator, out_basename, major_only_path) catch |err| {
warn("Unable to symlink {} -> {}\n", major_only_path, out_basename);
return err;
};
// sym link for libfoo.so to libfoo.so.1
- const name_only_path = %%os.path.join(allocator, out_dir, filename_name_only);
+ const name_only_path = os.path.join(allocator, out_dir, filename_name_only) catch unreachable;
os.atomicSymLink(allocator, filename_major_only, name_only_path) catch |err| {
warn("Unable to symlink {} -> {}\n", name_only_path, filename_major_only);
return err;
diff --git a/std/fmt/index.zig b/std/fmt/index.zig
index 0e82555874..4c4a809e6a 100644
--- a/std/fmt/index.zig
+++ b/std/fmt/index.zig
@@ -123,7 +123,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->%void,
},
State.IntegerWidth => switch (c) {
'}' => {
- width = comptime %%parseUnsigned(usize, fmt[width_start..i], 10);
+ width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
try formatInt(args[next_arg], radix, uppercase, width, context, output);
next_arg += 1;
state = State.Start;
@@ -147,7 +147,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->%void,
},
State.FloatWidth => switch (c) {
'}' => {
- width = comptime %%parseUnsigned(usize, fmt[width_start..i], 10);
+ width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
try formatFloatDecimal(args[next_arg], width, context, output);
next_arg += 1;
state = State.Start;
@@ -158,7 +158,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->%void,
},
State.BufWidth => switch (c) {
'}' => {
- width = comptime %%parseUnsigned(usize, fmt[width_start..i], 10);
+ width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
try formatBuf(args[next_arg], width, context, output);
next_arg += 1;
state = State.Start;
@@ -410,7 +410,7 @@ pub fn formatIntBuf(out_buf: []u8, value: var, base: u8, uppercase: bool, width:
.out_buf = out_buf,
.index = 0,
};
- %%formatInt(value, base, uppercase, width, &context, formatIntCallback);
+ formatInt(value, base, uppercase, width, &context, formatIntCallback) catch unreachable;
return context.index;
}
const FormatIntBuf = struct {
@@ -437,12 +437,12 @@ pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) -> %T {
}
test "fmt.parseInt" {
- assert(%%parseInt(i32, "-10", 10) == -10);
- assert(%%parseInt(i32, "+10", 10) == 10);
+ assert((parseInt(i32, "-10", 10) catch unreachable) == -10);
+ assert((parseInt(i32, "+10", 10) catch unreachable) == 10);
assert(if (parseInt(i32, " 10", 10)) |_| false else |err| err == error.InvalidChar);
assert(if (parseInt(i32, "10 ", 10)) |_| false else |err| err == error.InvalidChar);
assert(if (parseInt(u32, "-10", 10)) |_| false else |err| err == error.InvalidChar);
- assert(%%parseInt(u8, "255", 10) == 255);
+ assert((parseInt(u8, "255", 10) catch unreachable) == 255);
assert(if (parseInt(u8, "256", 10)) |_| false else |err| err == error.Overflow);
}
@@ -501,7 +501,7 @@ pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: ...) -> %[]u8 {
pub fn allocPrint(allocator: &mem.Allocator, comptime fmt: []const u8, args: ...) -> %[]u8 {
var size: usize = 0;
// Cannot fail because `countSize` cannot fail.
- %%format(&size, countSize, fmt, args);
+ format(&size, countSize, fmt, args) catch unreachable;
const buf = try allocator.alloc(u8, size);
return bufPrint(buf, fmt, args);
}
@@ -542,7 +542,7 @@ test "parse u64 digit too big" {
test "parse unsigned comptime" {
comptime {
- assert(%%parseUnsigned(usize, "2", 10) == 2);
+ assert((try parseUnsigned(usize, "2", 10)) == 2);
}
}
@@ -550,31 +550,31 @@ test "fmt.format" {
{
var buf1: [32]u8 = undefined;
const value: ?i32 = 1234;
- const result = %%bufPrint(buf1[0..], "nullable: {}\n", value);
+ const result = try bufPrint(buf1[0..], "nullable: {}\n", value);
assert(mem.eql(u8, result, "nullable: 1234\n"));
}
{
var buf1: [32]u8 = undefined;
const value: ?i32 = null;
- const result = %%bufPrint(buf1[0..], "nullable: {}\n", value);
+ const result = try bufPrint(buf1[0..], "nullable: {}\n", value);
assert(mem.eql(u8, result, "nullable: null\n"));
}
{
var buf1: [32]u8 = undefined;
const value: %i32 = 1234;
- const result = %%bufPrint(buf1[0..], "error union: {}\n", value);
+ const result = try bufPrint(buf1[0..], "error union: {}\n", value);
assert(mem.eql(u8, result, "error union: 1234\n"));
}
{
var buf1: [32]u8 = undefined;
const value: %i32 = error.InvalidChar;
- const result = %%bufPrint(buf1[0..], "error union: {}\n", value);
+ const result = try bufPrint(buf1[0..], "error union: {}\n", value);
assert(mem.eql(u8, result, "error union: error.InvalidChar\n"));
}
{
var buf1: [32]u8 = undefined;
const value: u3 = 0b101;
- const result = %%bufPrint(buf1[0..], "u3: {}\n", value);
+ const result = try bufPrint(buf1[0..], "u3: {}\n", value);
assert(mem.eql(u8, result, "u3: 5\n"));
}
@@ -584,46 +584,46 @@ test "fmt.format" {
{
var buf1: [32]u8 = undefined;
const value: f32 = 12.34;
- const result = %%bufPrint(buf1[0..], "f32: {}\n", value);
+ const result = try bufPrint(buf1[0..], "f32: {}\n", value);
assert(mem.eql(u8, result, "f32: 1.23400001e1\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f64 = -12.34e10;
- const result = %%bufPrint(buf1[0..], "f64: {}\n", value);
+ const result = try bufPrint(buf1[0..], "f64: {}\n", value);
assert(mem.eql(u8, result, "f64: -1.234e11\n"));
}
{
var buf1: [32]u8 = undefined;
- const result = %%bufPrint(buf1[0..], "f64: {}\n", math.nan_f64);
+ const result = try bufPrint(buf1[0..], "f64: {}\n", math.nan_f64);
assert(mem.eql(u8, result, "f64: NaN\n"));
}
{
var buf1: [32]u8 = undefined;
- const result = %%bufPrint(buf1[0..], "f64: {}\n", math.inf_f64);
+ const result = try bufPrint(buf1[0..], "f64: {}\n", math.inf_f64);
assert(mem.eql(u8, result, "f64: Infinity\n"));
}
{
var buf1: [32]u8 = undefined;
- const result = %%bufPrint(buf1[0..], "f64: {}\n", -math.inf_f64);
+ const result = try bufPrint(buf1[0..], "f64: {}\n", -math.inf_f64);
assert(mem.eql(u8, result, "f64: -Infinity\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f32 = 1.1234;
- const result = %%bufPrint(buf1[0..], "f32: {.1}\n", value);
+ const result = try bufPrint(buf1[0..], "f32: {.1}\n", value);
assert(mem.eql(u8, result, "f32: 1.1\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f32 = 1234.567;
- const result = %%bufPrint(buf1[0..], "f32: {.2}\n", value);
+ const result = try bufPrint(buf1[0..], "f32: {.2}\n", value);
assert(mem.eql(u8, result, "f32: 1234.56\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f32 = -11.1234;
- const result = %%bufPrint(buf1[0..], "f32: {.4}\n", value);
+ const result = try bufPrint(buf1[0..], "f32: {.4}\n", value);
// -11.1234 is converted to f64 -11.12339... internally (errol3() function takes f64).
// -11.12339... is truncated to -11.1233
assert(mem.eql(u8, result, "f32: -11.1233\n"));
@@ -631,13 +631,13 @@ test "fmt.format" {
{
var buf1: [32]u8 = undefined;
const value: f32 = 91.12345;
- const result = %%bufPrint(buf1[0..], "f32: {.}\n", value);
+ const result = try bufPrint(buf1[0..], "f32: {.}\n", value);
assert(mem.eql(u8, result, "f32: 91.12345\n"));
}
{
var buf1: [32]u8 = undefined;
const value: f64 = 91.12345678901235;
- const result = %%bufPrint(buf1[0..], "f64: {.10}\n", value);
+ const result = try bufPrint(buf1[0..], "f64: {.10}\n", value);
assert(mem.eql(u8, result, "f64: 91.1234567890\n"));
}
diff --git a/std/hash_map.zig b/std/hash_map.zig
index dda1ecce47..f91e4b31ba 100644
--- a/std/hash_map.zig
+++ b/std/hash_map.zig
@@ -236,14 +236,14 @@ test "basicHashMapTest" {
var map = HashMap(i32, i32, hash_i32, eql_i32).init(debug.global_allocator);
defer map.deinit();
- assert(%%map.put(1, 11) == null);
- assert(%%map.put(2, 22) == null);
- assert(%%map.put(3, 33) == null);
- assert(%%map.put(4, 44) == null);
- assert(%%map.put(5, 55) == null);
-
- assert(??%%map.put(5, 66) == 55);
- assert(??%%map.put(5, 55) == 66);
+ assert((map.put(1, 11) catch unreachable) == null);
+ assert((map.put(2, 22) catch unreachable) == null);
+ assert((map.put(3, 33) catch unreachable) == null);
+ assert((map.put(4, 44) catch unreachable) == null);
+ assert((map.put(5, 55) catch unreachable) == null);
+
+ assert(??(map.put(5, 66) catch unreachable) == 55);
+ assert(??(map.put(5, 55) catch unreachable) == 66);
assert((??map.get(2)).value == 22);
_ = map.remove(2);
diff --git a/std/heap.zig b/std/heap.zig
index 6d7fb258be..f88ac9b1a6 100644
--- a/std/heap.zig
+++ b/std/heap.zig
@@ -145,14 +145,14 @@ test "c_allocator" {
test "IncrementingAllocator" {
const total_bytes = 100 * 1024 * 1024;
- var inc_allocator = %%IncrementingAllocator.init(total_bytes);
+ var inc_allocator = try IncrementingAllocator.init(total_bytes);
defer inc_allocator.deinit();
const allocator = &inc_allocator.allocator;
- const slice = %%allocator.alloc(&i32, 100);
+ const slice = try allocator.alloc(&i32, 100);
for (slice) |*item, i| {
- *item = %%allocator.create(i32);
+ *item = try allocator.create(i32);
**item = i32(i);
}
diff --git a/std/io_test.zig b/std/io_test.zig
index 267b02dfcf..3b1f646616 100644
--- a/std/io_test.zig
+++ b/std/io_test.zig
@@ -18,34 +18,34 @@ test "write a file, read it, then delete it" {
rng.fillBytes(data[0..]);
const tmp_file_name = "temp_test_file.txt";
{
- var file = %%io.File.openWrite(tmp_file_name, allocator);
+ var file = try io.File.openWrite(tmp_file_name, allocator);
defer file.close();
var file_out_stream = io.FileOutStream.init(&file);
var buf_stream = io.BufferedOutStream.init(&file_out_stream.stream);
const st = &buf_stream.stream;
- %%st.print("begin");
- %%st.write(data[0..]);
- %%st.print("end");
- %%buf_stream.flush();
+ try st.print("begin");
+ try st.write(data[0..]);
+ try st.print("end");
+ try buf_stream.flush();
}
{
- var file = %%io.File.openRead(tmp_file_name, allocator);
+ var file = try io.File.openRead(tmp_file_name, allocator);
defer file.close();
- const file_size = %%file.getEndPos();
+ const file_size = try file.getEndPos();
const expected_file_size = "begin".len + data.len + "end".len;
assert(file_size == expected_file_size);
var file_in_stream = io.FileInStream.init(&file);
var buf_stream = io.BufferedInStream.init(&file_in_stream.stream);
const st = &buf_stream.stream;
- const contents = %%st.readAllAlloc(allocator, 2 * 1024);
+ const contents = try st.readAllAlloc(allocator, 2 * 1024);
defer allocator.free(contents);
assert(mem.eql(u8, contents[0.."begin".len], "begin"));
assert(mem.eql(u8, contents["begin".len..contents.len - "end".len], data));
assert(mem.eql(u8, contents[contents.len - "end".len ..], "end"));
}
- %%os.deleteFile(allocator, tmp_file_name);
+ try os.deleteFile(allocator, tmp_file_name);
}
diff --git a/std/linked_list.zig b/std/linked_list.zig
index c33db4424b..9536e9991a 100644
--- a/std/linked_list.zig
+++ b/std/linked_list.zig
@@ -199,11 +199,11 @@ test "basic linked list test" {
const allocator = debug.global_allocator;
var list = LinkedList(u32).init();
- var one = %%list.createNode(1, allocator);
- var two = %%list.createNode(2, allocator);
- var three = %%list.createNode(3, allocator);
- var four = %%list.createNode(4, allocator);
- var five = %%list.createNode(5, allocator);
+ var one = list.createNode(1, allocator) catch unreachable;
+ var two = list.createNode(2, allocator) catch unreachable;
+ var three = list.createNode(3, allocator) catch unreachable;
+ var four = list.createNode(4, allocator) catch unreachable;
+ var five = list.createNode(5, allocator) catch unreachable;
defer {
list.destroyNode(one, allocator);
list.destroyNode(two, allocator);
diff --git a/std/math/index.zig b/std/math/index.zig
index d382154059..081c59a88a 100644
--- a/std/math/index.zig
+++ b/std/math/index.zig
@@ -277,10 +277,10 @@ test "math overflow functions" {
}
fn testOverflow() {
- assert(%%mul(i32, 3, 4) == 12);
- assert(%%add(i32, 3, 4) == 7);
- assert(%%sub(i32, 3, 4) == -1);
- assert(%%shlExact(i32, 0b11, 4) == 0b110000);
+ assert((mul(i32, 3, 4) catch unreachable) == 12);
+ assert((add(i32, 3, 4) catch unreachable) == 7);
+ assert((sub(i32, 3, 4) catch unreachable) == -1);
+ assert((shlExact(i32, 0b11, 4) catch unreachable) == 0b110000);
}
@@ -302,8 +302,8 @@ test "math.absInt" {
comptime testAbsInt();
}
fn testAbsInt() {
- assert(%%absInt(i32(-10)) == 10);
- assert(%%absInt(i32(10)) == 10);
+ assert((absInt(i32(-10)) catch unreachable) == 10);
+ assert((absInt(i32(10)) catch unreachable) == 10);
}
pub const absFloat = @import("fabs.zig").fabs;
@@ -329,13 +329,13 @@ test "math.divTrunc" {
comptime testDivTrunc();
}
fn testDivTrunc() {
- assert(%%divTrunc(i32, 5, 3) == 1);
- assert(%%divTrunc(i32, -5, 3) == -1);
+ assert((divTrunc(i32, 5, 3) catch unreachable) == 1);
+ assert((divTrunc(i32, -5, 3) catch unreachable) == -1);
if (divTrunc(i8, -5, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
if (divTrunc(i8, -128, -1)) |_| unreachable else |err| assert(err == error.Overflow);
- assert(%%divTrunc(f32, 5.0, 3.0) == 1.0);
- assert(%%divTrunc(f32, -5.0, 3.0) == -1.0);
+ assert((divTrunc(f32, 5.0, 3.0) catch unreachable) == 1.0);
+ assert((divTrunc(f32, -5.0, 3.0) catch unreachable) == -1.0);
}
error DivisionByZero;
@@ -359,13 +359,13 @@ test "math.divFloor" {
comptime testDivFloor();
}
fn testDivFloor() {
- assert(%%divFloor(i32, 5, 3) == 1);
- assert(%%divFloor(i32, -5, 3) == -2);
+ assert((divFloor(i32, 5, 3) catch unreachable) == 1);
+ assert((divFloor(i32, -5, 3) catch unreachable) == -2);
if (divFloor(i8, -5, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
if (divFloor(i8, -128, -1)) |_| unreachable else |err| assert(err == error.Overflow);
- assert(%%divFloor(f32, 5.0, 3.0) == 1.0);
- assert(%%divFloor(f32, -5.0, 3.0) == -2.0);
+ assert((divFloor(f32, 5.0, 3.0) catch unreachable) == 1.0);
+ assert((divFloor(f32, -5.0, 3.0) catch unreachable) == -2.0);
}
error DivisionByZero;
@@ -393,14 +393,14 @@ test "math.divExact" {
comptime testDivExact();
}
fn testDivExact() {
- assert(%%divExact(i32, 10, 5) == 2);
- assert(%%divExact(i32, -10, 5) == -2);
+ assert((divExact(i32, 10, 5) catch unreachable) == 2);
+ assert((divExact(i32, -10, 5) catch unreachable) == -2);
if (divExact(i8, -5, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
if (divExact(i8, -128, -1)) |_| unreachable else |err| assert(err == error.Overflow);
if (divExact(i32, 5, 2)) |_| unreachable else |err| assert(err == error.UnexpectedRemainder);
- assert(%%divExact(f32, 10.0, 5.0) == 2.0);
- assert(%%divExact(f32, -10.0, 5.0) == -2.0);
+ assert((divExact(f32, 10.0, 5.0) catch unreachable) == 2.0);
+ assert((divExact(f32, -10.0, 5.0) catch unreachable) == -2.0);
if (divExact(f32, 5.0, 2.0)) |_| unreachable else |err| assert(err == error.UnexpectedRemainder);
}
@@ -420,13 +420,13 @@ test "math.mod" {
comptime testMod();
}
fn testMod() {
- assert(%%mod(i32, -5, 3) == 1);
- assert(%%mod(i32, 5, 3) == 2);
+ assert((mod(i32, -5, 3) catch unreachable) == 1);
+ assert((mod(i32, 5, 3) catch unreachable) == 2);
if (mod(i32, 10, -1)) |_| unreachable else |err| assert(err == error.NegativeDenominator);
if (mod(i32, 10, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
- assert(%%mod(f32, -5, 3) == 1);
- assert(%%mod(f32, 5, 3) == 2);
+ assert((mod(f32, -5, 3) catch unreachable) == 1);
+ assert((mod(f32, 5, 3) catch unreachable) == 2);
if (mod(f32, 10, -1)) |_| unreachable else |err| assert(err == error.NegativeDenominator);
if (mod(f32, 10, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
}
@@ -447,13 +447,13 @@ test "math.rem" {
comptime testRem();
}
fn testRem() {
- assert(%%rem(i32, -5, 3) == -2);
- assert(%%rem(i32, 5, 3) == 2);
+ assert((rem(i32, -5, 3) catch unreachable) == -2);
+ assert((rem(i32, 5, 3) catch unreachable) == 2);
if (rem(i32, 10, -1)) |_| unreachable else |err| assert(err == error.NegativeDenominator);
if (rem(i32, 10, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
- assert(%%rem(f32, -5, 3) == -2);
- assert(%%rem(f32, 5, 3) == 2);
+ assert((rem(f32, -5, 3) catch unreachable) == -2);
+ assert((rem(f32, 5, 3) catch unreachable) == 2);
if (rem(f32, 10, -1)) |_| unreachable else |err| assert(err == error.NegativeDenominator);
if (rem(f32, 10, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
}
@@ -497,11 +497,11 @@ pub fn negateCast(x: var) -> %@IntType(true, @typeOf(x).bit_count) {
}
test "math.negateCast" {
- assert(%%negateCast(u32(999)) == -999);
- assert(@typeOf(%%negateCast(u32(999))) == i32);
+ assert((negateCast(u32(999)) catch unreachable) == -999);
+ assert(@typeOf(negateCast(u32(999)) catch unreachable) == i32);
- assert(%%negateCast(u32(-@minValue(i32))) == @minValue(i32));
- assert(@typeOf(%%negateCast(u32(-@minValue(i32)))) == i32);
+ assert((negateCast(u32(-@minValue(i32))) catch unreachable) == @minValue(i32));
+ assert(@typeOf(negateCast(u32(-@minValue(i32))) catch unreachable) == i32);
if (negateCast(u32(@maxValue(i32) + 10))) |_| unreachable else |err| assert(err == error.Overflow);
}
diff --git a/std/mem.zig b/std/mem.zig
index bc16abf362..2d5b6f7a25 100644
--- a/std/mem.zig
+++ b/std/mem.zig
@@ -93,7 +93,7 @@ pub const Allocator = struct {
// n <= old_mem.len and the multiplication didn't overflow for that operation.
const byte_count = @sizeOf(T) * n;
- const byte_slice = %%self.reallocFn(self, ([]u8)(old_mem), byte_count, alignment);
+ const byte_slice = self.reallocFn(self, ([]u8)(old_mem), byte_count, alignment) catch unreachable;
return ([]align(alignment) T)(@alignCast(alignment, byte_slice));
}
@@ -446,8 +446,8 @@ pub fn join(allocator: &Allocator, sep: u8, strings: ...) -> %[]u8 {
}
test "mem.join" {
- assert(eql(u8, %%join(debug.global_allocator, ',', "a", "b", "c"), "a,b,c"));
- assert(eql(u8, %%join(debug.global_allocator, ',', "a"), "a"));
+ assert(eql(u8, try join(debug.global_allocator, ',', "a", "b", "c"), "a,b,c"));
+ assert(eql(u8, try join(debug.global_allocator, ',', "a"), "a"));
}
test "testStringEquality" {
diff --git a/std/net.zig b/std/net.zig
index a51765c05d..fa337eab75 100644
--- a/std/net.zig
+++ b/std/net.zig
@@ -3,6 +3,8 @@ const linux = std.os.linux;
const assert = std.debug.assert;
const endian = std.endian;
+// TODO don't trust this file, it bit rotted. start over
+
error SigInterrupt;
error Io;
error TimedOut;
@@ -67,24 +69,9 @@ const Address = struct {
pub fn lookup(hostname: []const u8, out_addrs: []Address) -> %[]Address {
if (hostname.len == 0) {
-//
-// if (family != AF_INET6)
-// buf[cnt++] = (struct address){ .family = AF_INET, .addr = { 127,0,0,1 } };
-// if (family != AF_INET)
-// buf[cnt++] = (struct address){ .family = AF_INET6, .addr = { [15] = 1 } };
-//
unreachable; // TODO
}
- // TODO
- //switch (parseIpLiteral(hostname)) {
- // Ok => |addr| {
- // out_addrs[0] = addr;
- // return out_addrs[0..1];
- // },
- // else => {},
- //};
-
unreachable; // TODO
}
@@ -142,23 +129,6 @@ pub fn connect(hostname: []const u8, port: u16) -> %Connection {
error InvalidIpLiteral;
pub fn parseIpLiteral(buf: []const u8) -> %Address {
- // TODO
- //switch (parseIp4(buf)) {
- // Ok => |ip4| {
- // var result: Address = undefined;
- // @memcpy(&result.addr[0], (&u8)(&ip4), @sizeOf(u32));
- // result.family = linux.AF_INET;
- // result.scope_id = 0;
- // return result;
- // },
- // else => {},
- //}
- //switch (parseIp6(buf)) {
- // Ok => |addr| {
- // return addr;
- // },
- // else => {},
- //}
return error.InvalidIpLiteral;
}
@@ -249,21 +219,6 @@ fn parseIp6(buf: []const u8) -> %Address {
return error.Incomplete;
}
-//
-// if (p) {
-// if (isdigit(*++p)) scopeid = strtoull(p, &z, 10);
-// else z = p-1;
-// if (*z) {
-// if (!IN6_IS_ADDR_LINKLOCAL(&a6) and
-// !IN6_IS_ADDR_MC_LINKLOCAL(&a6))
-// return EAI_NONAME;
-// scopeid = if_nametoindex(p);
-// if (!scopeid) return EAI_NONAME;
-// }
-// if (scopeid > UINT_MAX) return EAI_NONAME;
-// }
-//
-
if (scope_id) {
return result;
}
@@ -316,43 +271,3 @@ fn parseIp4(buf: []const u8) -> %u32 {
return error.Incomplete;
}
-
-
-// TODO
-//fn testParseIp4() {
-// @setFnTest(this);
-//
-// assert(%%parseIp4("127.0.0.1") == endian.swapIfLe(u32, 0x7f000001));
-// switch (parseIp4("256.0.0.1")) { Overflow => {}, else => unreachable, }
-// switch (parseIp4("x.0.0.1")) { InvalidChar => {}, else => unreachable, }
-// switch (parseIp4("127.0.0.1.1")) { JunkAtEnd => {}, else => unreachable, }
-// switch (parseIp4("127.0.0.")) { Incomplete => {}, else => unreachable, }
-// switch (parseIp4("100..0.1")) { InvalidChar => {}, else => unreachable, }
-//}
-//
-//fn testParseIp6() {
-// @setFnTest(this);
-//
-// {
-// const addr = %%parseIp6("FF01:0:0:0:0:0:0:FB");
-// assert(addr.addr[0] == 0xff);
-// assert(addr.addr[1] == 0x01);
-// assert(addr.addr[2] == 0x00);
-// }
-//}
-//
-//fn testLookupSimpleIp() {
-// @setFnTest(this);
-//
-// {
-// var addrs_buf: [5]Address = undefined;
-// const addrs = %%lookup("192.168.1.1", addrs_buf);
-// assert(addrs.len == 1);
-// const addr = addrs[0];
-// assert(addr.family == linux.AF_INET);
-// assert(addr.addr[0] == 192);
-// assert(addr.addr[1] == 168);
-// assert(addr.addr[2] == 1);
-// assert(addr.addr[3] == 1);
-// }
-//}
diff --git a/std/os/child_process.zig b/std/os/child_process.zig
index e112cce66a..8bf60bc52b 100644
--- a/std/os/child_process.zig
+++ b/std/os/child_process.zig
@@ -191,7 +191,7 @@ pub const ChildProcess = struct {
pub fn exec(allocator: &mem.Allocator, argv: []const []const u8, cwd: ?[]const u8,
env_map: ?&const BufMap, max_output_size: usize) -> %ExecResult
{
- const child = %%ChildProcess.init(argv, allocator);
+ const child = try ChildProcess.init(argv, allocator);
defer child.deinit();
child.stdin_behavior = ChildProcess.StdIo.Ignore;
diff --git a/std/os/index.zig b/std/os/index.zig
index 44d1507f44..e338359522 100644
--- a/std/os/index.zig
+++ b/std/os/index.zig
@@ -121,7 +121,7 @@ pub fn getRandomBytes(buf: []u8) -> %void {
test "os.getRandomBytes" {
var buf: [50]u8 = undefined;
- %%getRandomBytes(buf[0..]);
+ try getRandomBytes(buf[0..]);
}
/// Raises a signal in the current kernel thread, ending its execution.
@@ -1489,7 +1489,7 @@ test "windows arg parsing" {
fn testWindowsCmdLine(input_cmd_line: &const u8, expected_args: []const []const u8) {
var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line);
for (expected_args) |expected_arg| {
- const arg = %%??it.next(debug.global_allocator);
+ const arg = ??it.next(debug.global_allocator) catch unreachable;
assert(mem.eql(u8, arg, expected_arg));
}
assert(it.next(debug.global_allocator) == null);
diff --git a/std/os/path.zig b/std/os/path.zig
index d14cc6ae20..7597282669 100644
--- a/std/os/path.zig
+++ b/std/os/path.zig
@@ -49,23 +49,23 @@ pub fn joinPosix(allocator: &Allocator, paths: ...) -> %[]u8 {
}
test "os.path.join" {
- assert(mem.eql(u8, %%joinWindows(debug.global_allocator, "c:\\a\\b", "c"), "c:\\a\\b\\c"));
- assert(mem.eql(u8, %%joinWindows(debug.global_allocator, "c:\\a\\b\\", "c"), "c:\\a\\b\\c"));
+ assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\a\\b", "c"), "c:\\a\\b\\c"));
+ assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\a\\b\\", "c"), "c:\\a\\b\\c"));
- assert(mem.eql(u8, %%joinWindows(debug.global_allocator, "c:\\", "a", "b\\", "c"), "c:\\a\\b\\c"));
- assert(mem.eql(u8, %%joinWindows(debug.global_allocator, "c:\\a\\", "b\\", "c"), "c:\\a\\b\\c"));
+ assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\", "a", "b\\", "c"), "c:\\a\\b\\c"));
+ assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\a\\", "b\\", "c"), "c:\\a\\b\\c"));
- assert(mem.eql(u8, %%joinWindows(debug.global_allocator,
+ assert(mem.eql(u8, try joinWindows(debug.global_allocator,
"c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std", "io.zig"),
"c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std\\io.zig"));
- assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/a/b", "c"), "/a/b/c"));
- assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/a/b/", "c"), "/a/b/c"));
+ assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/a/b", "c"), "/a/b/c"));
+ assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/a/b/", "c"), "/a/b/c"));
- assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/", "a", "b/", "c"), "/a/b/c"));
- assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/a/", "b/", "c"), "/a/b/c"));
+ assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/", "a", "b/", "c"), "/a/b/c"));
+ assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/a/", "b/", "c"), "/a/b/c"));
- assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/home/andy/dev/zig/build/lib/zig/std", "io.zig"),
+ assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/home/andy/dev/zig/build/lib/zig/std", "io.zig"),
"/home/andy/dev/zig/build/lib/zig/std/io.zig"));
}
@@ -584,7 +584,7 @@ pub fn resolvePosix(allocator: &Allocator, paths: []const []const u8) -> %[]u8 {
}
test "os.path.resolve" {
- const cwd = %%os.getCwd(debug.global_allocator);
+ const cwd = try os.getCwd(debug.global_allocator);
if (is_windows) {
if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {
cwd[0] = asciiUpper(cwd[0]);
@@ -598,11 +598,11 @@ test "os.path.resolve" {
test "os.path.resolveWindows" {
if (is_windows) {
- const cwd = %%os.getCwd(debug.global_allocator);
+ const cwd = try os.getCwd(debug.global_allocator);
const parsed_cwd = windowsParsePath(cwd);
{
const result = testResolveWindows([][]const u8{"/usr/local", "lib\\zig\\std\\array_list.zig"});
- const expected = %%join(debug.global_allocator,
+ const expected = try join(debug.global_allocator,
parsed_cwd.disk_designator, "usr\\local\\lib\\zig\\std\\array_list.zig");
if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
@@ -611,7 +611,7 @@ test "os.path.resolveWindows" {
}
{
const result = testResolveWindows([][]const u8{"usr/local", "lib\\zig"});
- const expected = %%join(debug.global_allocator, cwd, "usr\\local\\lib\\zig");
+ const expected = try join(debug.global_allocator, cwd, "usr\\local\\lib\\zig");
if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
}
@@ -649,11 +649,11 @@ test "os.path.resolvePosix" {
}
fn testResolveWindows(paths: []const []const u8) -> []u8 {
- return %%resolveWindows(debug.global_allocator, paths);
+ return resolveWindows(debug.global_allocator, paths) catch unreachable;
}
fn testResolvePosix(paths: []const []const u8) -> []u8 {
- return %%resolvePosix(debug.global_allocator, paths);
+ return resolvePosix(debug.global_allocator, paths) catch unreachable;
}
pub fn dirname(path: []const u8) -> []const u8 {
@@ -1057,12 +1057,12 @@ test "os.path.relative" {
}
fn testRelativePosix(from: []const u8, to: []const u8, expected_output: []const u8) {
- const result = %%relativePosix(debug.global_allocator, from, to);
+ const result = relativePosix(debug.global_allocator, from, to) catch unreachable;
assert(mem.eql(u8, result, expected_output));
}
fn testRelativeWindows(from: []const u8, to: []const u8, expected_output: []const u8) {
- const result = %%relativeWindows(debug.global_allocator, from, to);
+ const result = relativeWindows(debug.global_allocator, from, to) catch unreachable;
assert(mem.eql(u8, result, expected_output));
}
@@ -1172,7 +1172,7 @@ pub fn real(allocator: &Allocator, pathname: []const u8) -> %[]u8 {
defer os.close(fd);
var buf: ["/proc/self/fd/-2147483648".len]u8 = undefined;
- const proc_path = %%fmt.bufPrint(buf[0..], "/proc/self/fd/{}", fd);
+ const proc_path = fmt.bufPrint(buf[0..], "/proc/self/fd/{}", fd) catch unreachable;
return os.readLink(allocator, proc_path);
},
diff --git a/std/os/zen.zig b/std/os/zen.zig
index ffc491e404..37ec68763d 100644
--- a/std/os/zen.zig
+++ b/std/os/zen.zig
@@ -9,16 +9,23 @@ pub const MBOX_TERMINAL = 1;
//// Syscall numbers ////
///////////////////////////
-pub const SYS_createMailbox = 0;
-pub const SYS_send = 1;
-pub const SYS_receive = 2;
-pub const SYS_map = 3;
+pub const SYS_exit = 0;
+pub const SYS_createMailbox = 1;
+pub const SYS_send = 2;
+pub const SYS_receive = 3;
+pub const SYS_map = 4;
+pub const SYS_createThread = 5;
////////////////////
//// Syscalls ////
////////////////////
+pub fn exit(status: i32) -> noreturn {
+ _ = syscall1(SYS_exit, @bitCast(usize, isize(status)));
+ unreachable;
+}
+
pub fn createMailbox(id: u16) {
_ = syscall1(SYS_createMailbox, id);
}
@@ -35,6 +42,10 @@ pub fn map(v_addr: usize, p_addr: usize, size: usize, writable: bool) -> bool {
return syscall4(SYS_map, v_addr, p_addr, size, usize(writable)) != 0;
}
+pub fn createThread(function: fn()) -> u16 {
+ return u16(syscall1(SYS_createThread, @ptrToInt(function)));
+}
+
/////////////////////////
//// Syscall stubs ////
diff --git a/std/rand.zig b/std/rand.zig
index 037cf68cd4..09109cfbf7 100644
--- a/std/rand.zig
+++ b/std/rand.zig
@@ -74,7 +74,7 @@ pub const Rand = struct {
return T(r.range(uint, uint(start), uint(end)));
} else if (start < 0 and end < 0) {
// Can't overflow because the range is over signed ints
- return %%math.negateCast(r.range(uint, math.absCast(end), math.absCast(start)) + 1);
+ return math.negateCast(r.range(uint, math.absCast(end), math.absCast(start)) + 1) catch unreachable;
} else if (start < 0 and end >= 0) {
const end_uint = uint(end);
const total_range = math.absCast(start) + end_uint;
@@ -85,7 +85,7 @@ pub const Rand = struct {
break :x start;
} else x: {
// Can't overflow because the range is over signed ints
- break :x %%math.negateCast(value - end_uint);
+ break :x math.negateCast(value - end_uint) catch unreachable;
};
return result;
} else {
diff --git a/std/sort.zig b/std/sort.zig
index a36a5e1747..02cb9acb2e 100644
--- a/std/sort.zig
+++ b/std/sort.zig
@@ -1115,7 +1115,7 @@ var fixed_buffer_mem: [100 * 1024]u8 = undefined;
fn fuzzTest(rng: &std.rand.Rand) {
const array_size = rng.range(usize, 0, 1000);
var fixed_allocator = mem.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
- var array = %%fixed_allocator.allocator.alloc(IdAndValue, array_size);
+ var array = fixed_allocator.allocator.alloc(IdAndValue, array_size) catch unreachable;
// populate with random data
for (array) |*item, index| {
item.id = index;
diff --git a/std/special/bootstrap.zig b/std/special/bootstrap.zig
index 28175de725..55d28a2d0e 100644
--- a/std/special/bootstrap.zig
+++ b/std/special/bootstrap.zig
@@ -21,9 +21,8 @@ comptime {
}
extern fn zenMain() -> noreturn {
- // TODO: call exit.
- root.main() catch {};
- while (true) {}
+ root.main() catch std.os.posix.exit(1);
+ std.os.posix.exit(0);
}
nakedcc fn _start() -> noreturn {
diff --git a/std/special/build_runner.zig b/std/special/build_runner.zig
index 284c04a236..24d9c756e7 100644
--- a/std/special/build_runner.zig
+++ b/std/special/build_runner.zig
@@ -14,7 +14,7 @@ pub fn main() -> %void {
var arg_it = os.args();
// TODO use a more general purpose allocator here
- var inc_allocator = %%std.heap.IncrementingAllocator.init(40 * 1024 * 1024);
+ var inc_allocator = std.heap.IncrementingAllocator.init(40 * 1024 * 1024) catch unreachable;
defer inc_allocator.deinit();
const allocator = &inc_allocator.allocator;
@@ -107,7 +107,7 @@ pub fn main() -> %void {
return usageAndErr(&builder, false, try stderr_stream);
}
} else {
- %%targets.append(arg);
+ targets.append(arg) catch unreachable;
}
}
diff --git a/std/special/test_runner.zig b/std/special/test_runner.zig
index f133eed59f..1a36f50b62 100644
--- a/std/special/test_runner.zig
+++ b/std/special/test_runner.zig
@@ -8,7 +8,10 @@ pub fn main() -> %void {
for (test_fn_list) |test_fn, i| {
warn("Test {}/{} {}...", i + 1, test_fn_list.len, test_fn.name);
- test_fn.func();
+ test_fn.func() catch |err| {
+ warn("{}\n", err);
+ return err;
+ };
warn("OK\n");
}
diff --git a/std/unicode.zig b/std/unicode.zig
index c821011558..d21ed0204a 100644
--- a/std/unicode.zig
+++ b/std/unicode.zig
@@ -19,7 +19,7 @@ error Utf8EncodesSurrogateHalf;
error Utf8CodepointTooLarge;
/// Decodes the UTF-8 codepoint encoded in the given slice of bytes.
-/// bytes.len must be equal to %%utf8ByteSequenceLength(bytes[0]).
+/// bytes.len must be equal to utf8ByteSequenceLength(bytes[0]) catch unreachable.
/// If you already know the length at comptime, you can call one of
/// utf8Decode2,utf8Decode3,utf8Decode4 directly instead of this function.
pub fn utf8Decode(bytes: []const u8) -> %u32 {
@@ -158,7 +158,7 @@ fn testError(bytes: []const u8, expected_err: error) {
}
fn testValid(bytes: []const u8, expected_codepoint: u32) {
- std.debug.assert(%%testDecode(bytes) == expected_codepoint);
+ std.debug.assert((testDecode(bytes) catch unreachable) == expected_codepoint);
}
fn testDecode(bytes: []const u8) -> %u32 {
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-28 09:22:29 +0000