From 3c094116aae459b651934663a31981cf09cdb3e4 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 9 Jan 2018 00:07:01 -0500 Subject: [PATCH] remove %% prefix operator See #632 closes #545 closes #510 this makes #651 higher priority --- build.zig | 34 +- doc/docgen.zig | 14 +- doc/langref.html.in | 2 +- example/guess_number/main.zig | 5 +- src/all_types.hpp | 1 - src/analyze.cpp | 2 +- src/ast_render.cpp | 1 - src/ir.cpp | 2 - src/parser.cpp | 1 - src/tokenizer.cpp | 6 - src/tokenizer.hpp | 1 - std/array_list.zig | 6 +- std/base64.zig | 6 +- std/buffer.zig | 12 +- std/build.zig | 498 +++++++++++----------- std/fmt/index.zig | 48 +-- std/hash_map.zig | 14 +- std/heap.zig | 6 +- std/io_test.zig | 18 +- std/linked_list.zig | 10 +- std/math/index.zig | 60 +-- std/mem.zig | 6 +- std/net.zig | 89 +--- std/os/child_process.zig | 2 +- std/os/index.zig | 4 +- std/os/path.zig | 38 +- std/rand.zig | 4 +- std/sort.zig | 2 +- std/special/build_runner.zig | 4 +- std/special/test_runner.zig | 5 +- std/unicode.zig | 4 +- test/cases/cast.zig | 24 +- test/cases/const_slice_child.zig | 2 +- test/cases/defer.zig | 2 +- test/cases/enum_with_members.zig | 4 +- test/cases/error.zig | 6 +- test/cases/ir_block_deps.zig | 4 +- test/cases/misc.zig | 4 +- test/cases/switch_prong_err_enum.zig | 2 +- test/cases/switch_prong_implicit_cast.zig | 2 +- test/cases/union.zig | 2 +- test/cases/while.zig | 2 +- test/compare_output.zig | 88 ++-- test/compile_errors.zig | 4 +- test/standalone/issue_339/test.zig | 2 +- test/tests.zig | 138 +++--- 46 files changed, 550 insertions(+), 641 deletions(-) diff --git a/build.zig b/build.zig index 9f66cf8728..7c1563c706 100644 --- a/build.zig +++ b/build.zig @@ -18,14 +18,14 @@ pub fn build(b: &Builder) { var docgen_cmd = b.addCommand(null, b.env_map, [][]const u8 { docgen_exe.getOutputPath(), "doc/langref.html.in", - %%os.path.join(b.allocator, b.cache_root, "langref.html"), + os.path.join(b.allocator, b.cache_root, "langref.html") catch unreachable, }); docgen_cmd.step.dependOn(&docgen_exe.step); var docgen_home_cmd = b.addCommand(null, b.env_map, [][]const u8 { docgen_exe.getOutputPath(), "doc/home.html.in", - %%os.path.join(b.allocator, b.cache_root, "home.html"), + os.path.join(b.allocator, b.cache_root, "home.html") catch unreachable, }); docgen_home_cmd.step.dependOn(&docgen_exe.step); @@ -47,7 +47,7 @@ pub fn build(b: &Builder) { const c_header_files = nextValue(&index, build_info); const dia_guids_lib = nextValue(&index, build_info); - const llvm = findLLVM(b, llvm_config_exe); + const llvm = findLLVM(b, llvm_config_exe) catch unreachable; var exe = b.addExecutable("zig", "src-self-hosted/main.zig"); exe.setBuildMode(mode); @@ -143,8 +143,8 @@ fn dependOnLib(lib_exe_obj: &std.build.LibExeObjStep, dep: &const LibraryDep) { fn addCppLib(b: &Builder, lib_exe_obj: &std.build.LibExeObjStep, cmake_binary_dir: []const u8, lib_name: []const u8) { const lib_prefix = if (lib_exe_obj.target.isWindows()) "" else "lib"; - lib_exe_obj.addObjectFile(%%os.path.join(b.allocator, cmake_binary_dir, "zig_cpp", - b.fmt("{}{}{}", lib_prefix, lib_name, lib_exe_obj.target.libFileExt()))); + lib_exe_obj.addObjectFile(os.path.join(b.allocator, cmake_binary_dir, "zig_cpp", + b.fmt("{}{}{}", lib_prefix, lib_name, lib_exe_obj.target.libFileExt())) catch unreachable); } const LibraryDep = struct { @@ -154,7 +154,7 @@ const LibraryDep = struct { includes: ArrayList([]const u8), }; -fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> LibraryDep { +fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> %LibraryDep { const libs_output = b.exec([][]const u8{llvm_config_exe, "--libs", "--system-libs"}); const includes_output = b.exec([][]const u8{llvm_config_exe, "--includedir"}); const libdir_output = b.exec([][]const u8{llvm_config_exe, "--libdir"}); @@ -169,12 +169,12 @@ fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> LibraryDep { var it = mem.split(libs_output, " \r\n"); while (it.next()) |lib_arg| { if (mem.startsWith(u8, lib_arg, "-l")) { - %%result.system_libs.append(lib_arg[2..]); + try result.system_libs.append(lib_arg[2..]); } else { if (os.path.isAbsolute(lib_arg)) { - %%result.libs.append(lib_arg); + try result.libs.append(lib_arg); } else { - %%result.system_libs.append(lib_arg); + try result.system_libs.append(lib_arg); } } } @@ -183,9 +183,9 @@ fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> LibraryDep { var it = mem.split(includes_output, " \r\n"); while (it.next()) |include_arg| { if (mem.startsWith(u8, include_arg, "-I")) { - %%result.includes.append(include_arg[2..]); + try result.includes.append(include_arg[2..]); } else { - %%result.includes.append(include_arg); + try result.includes.append(include_arg); } } } @@ -193,9 +193,9 @@ fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> LibraryDep { var it = mem.split(libdir_output, " \r\n"); while (it.next()) |libdir| { if (mem.startsWith(u8, libdir, "-L")) { - %%result.libdirs.append(libdir[2..]); + try result.libdirs.append(libdir[2..]); } else { - %%result.libdirs.append(libdir); + try result.libdirs.append(libdir); } } } @@ -205,8 +205,8 @@ fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> LibraryDep { pub fn installStdLib(b: &Builder, stdlib_files: []const u8) { var it = mem.split(stdlib_files, ";"); while (it.next()) |stdlib_file| { - const src_path = %%os.path.join(b.allocator, "std", stdlib_file); - const dest_path = %%os.path.join(b.allocator, "lib", "zig", "std", stdlib_file); + const src_path = os.path.join(b.allocator, "std", stdlib_file) catch unreachable; + const dest_path = os.path.join(b.allocator, "lib", "zig", "std", stdlib_file) catch unreachable; b.installFile(src_path, dest_path); } } @@ -214,8 +214,8 @@ pub fn installStdLib(b: &Builder, stdlib_files: []const u8) { pub fn installCHeaders(b: &Builder, c_header_files: []const u8) { var it = mem.split(c_header_files, ";"); while (it.next()) |c_header_file| { - const src_path = %%os.path.join(b.allocator, "c_headers", c_header_file); - const dest_path = %%os.path.join(b.allocator, "lib", "zig", "include", c_header_file); + const src_path = os.path.join(b.allocator, "c_headers", c_header_file) catch unreachable; + const dest_path = os.path.join(b.allocator, "lib", "zig", "include", c_header_file) catch unreachable; b.installFile(src_path, dest_path); } } diff --git a/doc/docgen.zig b/doc/docgen.zig index 34b276d75c..f3bb7df6b1 100644 --- a/doc/docgen.zig +++ b/doc/docgen.zig @@ -4,7 +4,7 @@ const os = std.os; pub fn main() -> %void { // TODO use a more general purpose allocator here - var inc_allocator = %%std.heap.IncrementingAllocator.init(5 * 1024 * 1024); + var inc_allocator = try std.heap.IncrementingAllocator.init(5 * 1024 * 1024); defer inc_allocator.deinit(); const allocator = &inc_allocator.allocator; @@ -12,16 +12,16 @@ pub fn main() -> %void { if (!args_it.skip()) @panic("expected self arg"); - const in_file_name = %%(args_it.next(allocator) ?? @panic("expected input arg")); + const in_file_name = try (args_it.next(allocator) ?? @panic("expected input arg")); defer allocator.free(in_file_name); - const out_file_name = %%(args_it.next(allocator) ?? @panic("expected output arg")); + const out_file_name = try (args_it.next(allocator) ?? @panic("expected output arg")); defer allocator.free(out_file_name); - var in_file = %%io.File.openRead(in_file_name, allocator); + var in_file = try io.File.openRead(in_file_name, allocator); defer in_file.close(); - var out_file = %%io.File.openWrite(out_file_name, allocator); + var out_file = try io.File.openWrite(out_file_name, allocator); defer out_file.close(); var file_in_stream = io.FileInStream.init(&in_file); @@ -31,7 +31,7 @@ pub fn main() -> %void { var buffered_out_stream = io.BufferedOutStream.init(&file_out_stream.stream); gen(&buffered_in_stream.stream, &buffered_out_stream.stream); - %%buffered_out_stream.flush(); + try buffered_out_stream.flush(); } @@ -54,7 +54,7 @@ fn gen(in: &io.InStream, out: &io.OutStream) { switch (state) { State.Start => switch (byte) { else => { - %%out.writeByte(byte); + out.writeByte(byte) catch unreachable; }, }, State.Derp => unreachable, diff --git a/doc/langref.html.in b/doc/langref.html.in index 54acf34809..2476790105 100644 --- a/doc/langref.html.in +++ b/doc/langref.html.in @@ -5989,7 +5989,7 @@ ContainerInitBody = list(StructLiteralField, ",") | list(Expression, ",") StructLiteralField = "." Symbol "=" Expression -PrefixOp = "!" | "-" | "~" | "*" | ("&" option("align" "(" Expression option(":" Integer ":" Integer) ")" ) option("const") option("volatile")) | "?" | "%" | "%%" | "??" | "-%" | "try" +PrefixOp = "!" | "-" | "~" | "*" | ("&" option("align" "(" Expression option(":" Integer ":" Integer) ")" ) option("const") option("volatile")) | "?" | "%" | "??" | "-%" | "try" PrimaryExpression = Integer | Float | String | CharLiteral | KeywordLiteral | GroupedExpression | BlockExpression(BlockOrExpression) | Symbol | ("@" Symbol FnCallExpression) | ArrayType | FnProto | AsmExpression | ("error" "." Symbol) | ContainerDecl | ("continue" option(":" Symbol)) diff --git a/example/guess_number/main.zig b/example/guess_number/main.zig index a2a763488a..69486a2528 100644 --- a/example/guess_number/main.zig +++ b/example/guess_number/main.zig @@ -15,7 +15,10 @@ pub fn main() -> %void { try stdout.print("Welcome to the Guess Number Game in Zig.\n"); var seed_bytes: [@sizeOf(usize)]u8 = undefined; - %%os.getRandomBytes(seed_bytes[0..]); + os.getRandomBytes(seed_bytes[0..]) catch |err| { + std.debug.warn("unable to seed random number generator: {}", err); + return err; + }; const seed = std.mem.readInt(seed_bytes, usize, builtin.Endian.Big); var rand = Rand.init(seed); diff --git a/src/all_types.hpp b/src/all_types.hpp index 50af911092..4388619840 100644 --- a/src/all_types.hpp +++ b/src/all_types.hpp @@ -594,7 +594,6 @@ enum PrefixOp { PrefixOpDereference, PrefixOpMaybe, PrefixOpError, - PrefixOpUnwrapError, PrefixOpUnwrapMaybe, }; diff --git a/src/analyze.cpp b/src/analyze.cpp index 596bced2f1..2c6f0f209e 100644 --- a/src/analyze.cpp +++ b/src/analyze.cpp @@ -2587,7 +2587,7 @@ TypeTableEntry *get_test_fn_type(CodeGen *g) { return g->test_fn_type; FnTypeId fn_type_id = {0}; - fn_type_id.return_type = g->builtin_types.entry_void; + fn_type_id.return_type = get_error_type(g, g->builtin_types.entry_void); g->test_fn_type = get_fn_type(g, &fn_type_id); return g->test_fn_type; } diff --git a/src/ast_render.cpp b/src/ast_render.cpp index 47da6c8e2f..abe880941c 100644 --- a/src/ast_render.cpp +++ b/src/ast_render.cpp @@ -68,7 +68,6 @@ static const char *prefix_op_str(PrefixOp prefix_op) { case PrefixOpDereference: return "*"; case PrefixOpMaybe: return "?"; case PrefixOpError: return "%"; - case PrefixOpUnwrapError: return "catch"; case PrefixOpUnwrapMaybe: return "??"; } zig_unreachable(); diff --git a/src/ir.cpp b/src/ir.cpp index 826015c4ad..176e5791f8 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -3963,8 +3963,6 @@ static IrInstruction *ir_gen_prefix_op_expr(IrBuilder *irb, Scope *scope, AstNod return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpMaybe), lval); case PrefixOpError: return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpError), lval); - case PrefixOpUnwrapError: - return ir_gen_err_assert_ok(irb, scope, node, node->data.prefix_op_expr.primary_expr, lval); case PrefixOpUnwrapMaybe: return ir_gen_maybe_assert_ok(irb, scope, node, lval); } diff --git a/src/parser.cpp b/src/parser.cpp index 9ee1147729..511936fb30 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -956,7 +956,6 @@ static PrefixOp tok_to_prefix_op(Token *token) { case TokenIdStar: return PrefixOpDereference; case TokenIdMaybe: return PrefixOpMaybe; case TokenIdPercent: return PrefixOpError; - case TokenIdPercentPercent: return PrefixOpUnwrapError; case TokenIdDoubleQuestion: return PrefixOpUnwrapMaybe; case TokenIdStarStar: return PrefixOpDereference; default: return PrefixOpInvalid; diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp index cc586e1623..f12f539626 100644 --- a/src/tokenizer.cpp +++ b/src/tokenizer.cpp @@ -816,11 +816,6 @@ void tokenize(Buf *buf, Tokenization *out) { end_token(&t); t.state = TokenizeStateStart; break; - case '%': - set_token_id(&t, t.cur_tok, TokenIdPercentPercent); - end_token(&t); - t.state = TokenizeStateStart; - break; default: t.pos -= 1; end_token(&t); @@ -1564,7 +1559,6 @@ const char * token_name(TokenId id) { case TokenIdNumberSign: return "#"; case TokenIdPercent: return "%"; case TokenIdPercentDot: return "%."; - case TokenIdPercentPercent: return "%%"; case TokenIdPlus: return "+"; case TokenIdPlusEq: return "+="; case TokenIdPlusPercent: return "+%"; diff --git a/src/tokenizer.hpp b/src/tokenizer.hpp index 84a96383d3..43d1309026 100644 --- a/src/tokenizer.hpp +++ b/src/tokenizer.hpp @@ -101,7 +101,6 @@ enum TokenId { TokenIdNumberSign, TokenIdPercent, TokenIdPercentDot, - TokenIdPercentPercent, TokenIdPlus, TokenIdPlusEq, TokenIdPlusPercent, 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(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) == 55); - assert(??%%map.put(5, 55) == 66); + 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/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/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 { diff --git a/test/cases/cast.zig b/test/cases/cast.zig index 15cdf47349..673c5891e3 100644 --- a/test/cases/cast.zig +++ b/test/cases/cast.zig @@ -85,14 +85,14 @@ const A = struct { fn castToMaybeTypeError(z: i32) { const x = i32(1); const y: %?i32 = x; - assert(??%%y == 1); + assert(??(try y) == 1); const f = z; const g: %?i32 = f; const a = A{ .a = z }; const b: %?A = a; - assert((??%%b).a == 1); + assert((??(b catch unreachable)).a == 1); } test "implicitly cast from int to %?T" { @@ -108,7 +108,7 @@ fn implicitIntLitToMaybe() { test "return null from fn() -> %?&T" { const a = returnNullFromMaybeTypeErrorRef(); const b = returnNullLitFromMaybeTypeErrorRef(); - assert(%%a == null and %%b == null); + assert((try a) == null and (try b) == null); } fn returnNullFromMaybeTypeErrorRef() -> %?&A { const a: ?&A = null; @@ -167,7 +167,7 @@ test "implicitly cast from [0]T to %[]T" { } fn testCastZeroArrayToErrSliceMut() { - assert((%%gimmeErrOrSlice()).len == 0); + assert((gimmeErrOrSlice() catch unreachable).len == 0); } fn gimmeErrOrSlice() -> %[]u8 { @@ -178,14 +178,14 @@ test "peer type resolution: [0]u8, []const u8, and %[]u8" { { var data = "hi"; const slice = data[0..]; - assert((%%peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); - assert((%%peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); + assert((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); + assert((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); } comptime { var data = "hi"; const slice = data[0..]; - assert((%%peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); - assert((%%peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); + assert((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0); + assert((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1); } } fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) -> %[]u8 { @@ -231,11 +231,11 @@ fn foo(args: ...) { test "peer type resolution: error and [N]T" { // TODO: implicit %T to %U where T can implicitly cast to U - //assert(mem.eql(u8, %%testPeerErrorAndArray(0), "OK")); - //comptime assert(mem.eql(u8, %%testPeerErrorAndArray(0), "OK")); + //assert(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); + //comptime assert(mem.eql(u8, try testPeerErrorAndArray(0), "OK")); - assert(mem.eql(u8, %%testPeerErrorAndArray2(1), "OKK")); - comptime assert(mem.eql(u8, %%testPeerErrorAndArray2(1), "OKK")); + assert(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK")); + comptime assert(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK")); } error BadValue; diff --git a/test/cases/const_slice_child.zig b/test/cases/const_slice_child.zig index e1e06b4e7f..4b7905ec97 100644 --- a/test/cases/const_slice_child.zig +++ b/test/cases/const_slice_child.zig @@ -21,7 +21,7 @@ fn foo(args: [][]const u8) { } fn bar(argc: usize) { - const args = %%debug.global_allocator.alloc([]const u8, argc); + const args = debug.global_allocator.alloc([]const u8, argc) catch unreachable; for (args) |_, i| { const ptr = argv[i]; args[i] = ptr[0..strlen(ptr)]; diff --git a/test/cases/defer.zig b/test/cases/defer.zig index b1eee8bece..b84e784713 100644 --- a/test/cases/defer.zig +++ b/test/cases/defer.zig @@ -14,7 +14,7 @@ fn runSomeErrorDefers(x: bool) -> %bool { } test "mixing normal and error defers" { - assert(%%runSomeErrorDefers(true)); + assert(runSomeErrorDefers(true) catch unreachable); assert(result[0] == 'c'); assert(result[1] == 'a'); diff --git a/test/cases/enum_with_members.zig b/test/cases/enum_with_members.zig index c28692575e..b5bf3ae299 100644 --- a/test/cases/enum_with_members.zig +++ b/test/cases/enum_with_members.zig @@ -19,9 +19,9 @@ test "enum with members" { const b = ET { .UINT = 42 }; var buf: [20]u8 = undefined; - assert(%%a.print(buf[0..]) == 3); + assert((a.print(buf[0..]) catch unreachable) == 3); assert(mem.eql(u8, buf[0..3], "-42")); - assert(%%b.print(buf[0..]) == 2); + assert((b.print(buf[0..]) catch unreachable) == 2); assert(mem.eql(u8, buf[0..2], "42")); } diff --git a/test/cases/error.zig b/test/cases/error.zig index dbe96366d3..f4743082d9 100644 --- a/test/cases/error.zig +++ b/test/cases/error.zig @@ -16,7 +16,7 @@ pub fn baz() -> %i32 { } test "error wrapping" { - assert(%%baz() == 15); + assert((baz() catch unreachable) == 15); } error ItBroke; @@ -65,14 +65,14 @@ fn errBinaryOperatorG(x: bool) -> %isize { test "unwrap simple value from error" { - const i = %%unwrapSimpleValueFromErrorDo(); + const i = unwrapSimpleValueFromErrorDo() catch unreachable; assert(i == 13); } fn unwrapSimpleValueFromErrorDo() -> %isize { return 13; } test "error return in assignment" { - %%doErrReturnInAssignment(); + doErrReturnInAssignment() catch unreachable; } fn doErrReturnInAssignment() -> %void { diff --git a/test/cases/ir_block_deps.zig b/test/cases/ir_block_deps.zig index 6932a58b7f..12b8808050 100644 --- a/test/cases/ir_block_deps.zig +++ b/test/cases/ir_block_deps.zig @@ -16,6 +16,6 @@ fn getErrInt() -> %i32 { return 0; } error ItBroke; test "ir block deps" { - assert(%%foo(1) == 0); - assert(%%foo(2) == 0); + assert((foo(1) catch unreachable) == 0); + assert((foo(2) catch unreachable) == 0); } diff --git a/test/cases/misc.zig b/test/cases/misc.zig index e3ddfdfd76..137fda9c74 100644 --- a/test/cases/misc.zig +++ b/test/cases/misc.zig @@ -258,7 +258,7 @@ test "explicit cast maybe pointers" { } test "generic malloc free" { - const a = %%memAlloc(u8, 10); + const a = memAlloc(u8, 10) catch unreachable; memFree(u8, a); } const some_mem : [100]u8 = undefined; @@ -417,7 +417,7 @@ test "cast slice to u8 slice" { } test "pointer to void return type" { - %%testPointerToVoidReturnType(); + testPointerToVoidReturnType() catch unreachable; } fn testPointerToVoidReturnType() -> %void { const a = testPointerToVoidReturnType2(); diff --git a/test/cases/switch_prong_err_enum.zig b/test/cases/switch_prong_err_enum.zig index 90aa4a4d44..0585112ecf 100644 --- a/test/cases/switch_prong_err_enum.zig +++ b/test/cases/switch_prong_err_enum.zig @@ -22,7 +22,7 @@ fn doThing(form_id: u64) -> %FormValue { } test "switch prong returns error enum" { - switch (%%doThing(17)) { + switch (doThing(17) catch unreachable) { FormValue.Address => |payload| { assert(payload == 1); }, else => unreachable, } diff --git a/test/cases/switch_prong_implicit_cast.zig b/test/cases/switch_prong_implicit_cast.zig index 9e7c091494..b59231038d 100644 --- a/test/cases/switch_prong_implicit_cast.zig +++ b/test/cases/switch_prong_implicit_cast.zig @@ -16,7 +16,7 @@ fn foo(id: u64) -> %FormValue { } test "switch prong implicit cast" { - const result = switch (%%foo(2)) { + const result = switch (foo(2) catch unreachable) { FormValue.One => false, FormValue.Two => |x| x, }; diff --git a/test/cases/union.zig b/test/cases/union.zig index 6db43fc14b..adab8b7e96 100644 --- a/test/cases/union.zig +++ b/test/cases/union.zig @@ -26,7 +26,7 @@ test "unions embedded in aggregate types" { Value.Array => |arr| assert(arr[4] == 3), else => unreachable, } - switch((%%err).val1) { + switch((err catch unreachable).val1) { Value.Int => |x| assert(x == 1234), else => unreachable, } diff --git a/test/cases/while.zig b/test/cases/while.zig index e61fe1f9d2..f1e269b9fd 100644 --- a/test/cases/while.zig +++ b/test/cases/while.zig @@ -48,7 +48,7 @@ fn runContinueAndBreakTest() { } test "return with implicit cast from while loop" { - %%returnWithImplicitCastFromWhileLoopTest(); + returnWithImplicitCastFromWhileLoopTest() catch unreachable; } fn returnWithImplicitCastFromWhileLoopTest() -> %void { while (true) { diff --git a/test/compare_output.zig b/test/compare_output.zig index d7b9e3e167..e4600d70e5 100644 --- a/test/compare_output.zig +++ b/test/compare_output.zig @@ -17,8 +17,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\ \\pub fn main() -> %void { \\ privateFunction(); - \\ const stdout = &(FileOutStream.init(&%%getStdOut()).stream); - \\ %%stdout.print("OK 2\n"); + \\ const stdout = &(FileOutStream.init(&(getStdOut() catch unreachable)).stream); + \\ stdout.print("OK 2\n") catch unreachable; \\} \\ \\fn privateFunction() { @@ -32,8 +32,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\// purposefully conflicting function with main.zig \\// but it's private so it should be OK \\fn privateFunction() { - \\ const stdout = &(FileOutStream.init(&%%getStdOut()).stream); - \\ %%stdout.print("OK 1\n"); + \\ const stdout = &(FileOutStream.init(&(getStdOut() catch unreachable)).stream); + \\ stdout.print("OK 1\n") catch unreachable; \\} \\ \\pub fn printText() { @@ -58,8 +58,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) { tc.addSourceFile("foo.zig", \\use @import("std").io; \\pub fn foo_function() { - \\ const stdout = &(FileOutStream.init(&%%getStdOut()).stream); - \\ %%stdout.print("OK\n"); + \\ const stdout = &(FileOutStream.init(&(getStdOut() catch unreachable)).stream); + \\ stdout.print("OK\n") catch unreachable; \\} ); @@ -69,8 +69,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\ \\pub fn bar_function() { \\ if (foo_function()) { - \\ const stdout = &(FileOutStream.init(&%%getStdOut()).stream); - \\ %%stdout.print("OK\n"); + \\ const stdout = &(FileOutStream.init(&(getStdOut() catch unreachable)).stream); + \\ stdout.print("OK\n") catch unreachable; \\ } \\} ); @@ -101,8 +101,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\pub const a_text = "OK\n"; \\ \\pub fn ok() { - \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream); - \\ %%stdout.print(b_text); + \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); + \\ stdout.print(b_text) catch unreachable; \\} ); @@ -119,8 +119,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\const io = @import("std").io; \\ \\pub fn main() -> %void { - \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream); - \\ %%stdout.print("Hello, world!\n{d4} {x3} {c}\n", u32(12), u16(0x12), u8('a')); + \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); + \\ stdout.print("Hello, world!\n{d4} {x3} {c}\n", u32(12), u16(0x12), u8('a')) catch unreachable; \\} , "Hello, world!\n0012 012 a\n"); @@ -272,8 +272,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\ var x_local : i32 = print_ok(x); \\} \\fn print_ok(val: @typeOf(x)) -> @typeOf(foo) { - \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream); - \\ %%stdout.print("OK\n"); + \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); + \\ stdout.print("OK\n") catch unreachable; \\ return 0; \\} \\const foo : i32 = 0; @@ -354,26 +354,26 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\pub fn main() -> %void { \\ const bar = Bar {.field2 = 13,}; \\ const foo = Foo {.field1 = bar,}; - \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream); + \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); \\ if (!foo.method()) { - \\ %%stdout.print("BAD\n"); + \\ stdout.print("BAD\n") catch unreachable; \\ } \\ if (!bar.method()) { - \\ %%stdout.print("BAD\n"); + \\ stdout.print("BAD\n") catch unreachable; \\ } - \\ %%stdout.print("OK\n"); + \\ stdout.print("OK\n") catch unreachable; \\} , "OK\n"); cases.add("defer with only fallthrough", \\const io = @import("std").io; \\pub fn main() -> %void { - \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream); - \\ %%stdout.print("before\n"); - \\ defer %%stdout.print("defer1\n"); - \\ defer %%stdout.print("defer2\n"); - \\ defer %%stdout.print("defer3\n"); - \\ %%stdout.print("after\n"); + \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); + \\ stdout.print("before\n") catch unreachable; + \\ defer stdout.print("defer1\n") catch unreachable; + \\ defer stdout.print("defer2\n") catch unreachable; + \\ defer stdout.print("defer3\n") catch unreachable; + \\ stdout.print("after\n") catch unreachable; \\} , "before\nafter\ndefer3\ndefer2\ndefer1\n"); @@ -381,14 +381,14 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\const io = @import("std").io; \\const os = @import("std").os; \\pub fn main() -> %void { - \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream); - \\ %%stdout.print("before\n"); - \\ defer %%stdout.print("defer1\n"); - \\ defer %%stdout.print("defer2\n"); + \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); + \\ stdout.print("before\n") catch unreachable; + \\ defer stdout.print("defer1\n") catch unreachable; + \\ defer stdout.print("defer2\n") catch unreachable; \\ var args_it = @import("std").os.args(); \\ if (args_it.skip() and !args_it.skip()) return; - \\ defer %%stdout.print("defer3\n"); - \\ %%stdout.print("after\n"); + \\ defer stdout.print("defer3\n") catch unreachable; + \\ stdout.print("after\n") catch unreachable; \\} , "before\ndefer2\ndefer1\n"); @@ -398,13 +398,13 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\ do_test() catch return; \\} \\fn do_test() -> %void { - \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream); - \\ %%stdout.print("before\n"); - \\ defer %%stdout.print("defer1\n"); - \\ %defer %%stdout.print("deferErr\n"); + \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); + \\ stdout.print("before\n") catch unreachable; + \\ defer stdout.print("defer1\n") catch unreachable; + \\ %defer stdout.print("deferErr\n") catch unreachable; \\ try its_gonna_fail(); - \\ defer %%stdout.print("defer3\n"); - \\ %%stdout.print("after\n"); + \\ defer stdout.print("defer3\n") catch unreachable; + \\ stdout.print("after\n") catch unreachable; \\} \\error IToldYouItWouldFail; \\fn its_gonna_fail() -> %void { @@ -418,13 +418,13 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\ do_test() catch return; \\} \\fn do_test() -> %void { - \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream); - \\ %%stdout.print("before\n"); - \\ defer %%stdout.print("defer1\n"); - \\ %defer %%stdout.print("deferErr\n"); + \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); + \\ stdout.print("before\n") catch unreachable; + \\ defer stdout.print("defer1\n") catch unreachable; + \\ %defer stdout.print("deferErr\n") catch unreachable; \\ try its_gonna_pass(); - \\ defer %%stdout.print("defer3\n"); - \\ %%stdout.print("after\n"); + \\ defer stdout.print("defer3\n") catch unreachable; + \\ stdout.print("after\n") catch unreachable; \\} \\fn its_gonna_pass() -> %void { } , "before\nafter\ndefer3\ndefer1\n"); @@ -435,8 +435,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) { \\const io = @import("std").io; \\ \\pub fn main() -> %void { - \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream); - \\ %%stdout.print(foo_txt); + \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream); + \\ stdout.print(foo_txt) catch unreachable; \\} , "1234\nabcd\n"); diff --git a/test/compile_errors.zig b/test/compile_errors.zig index e6e769c85d..005fe55e41 100644 --- a/test/compile_errors.zig +++ b/test/compile_errors.zig @@ -1423,10 +1423,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) { cases.add("ignored assert-err-ok return value", \\export fn foo() { - \\ %%bar(); + \\ bar() catch unreachable; \\} \\fn bar() -> %i32 { return 0; } - , ".tmp_source.zig:2:5: error: expression value is ignored"); + , ".tmp_source.zig:2:11: error: expression value is ignored"); cases.add("ignored statement value", \\export fn foo() { diff --git a/test/standalone/issue_339/test.zig b/test/standalone/issue_339/test.zig index c1faa015c6..e0d6c3f3e5 100644 --- a/test/standalone/issue_339/test.zig +++ b/test/standalone/issue_339/test.zig @@ -3,5 +3,5 @@ pub fn panic(msg: []const u8) -> noreturn { @breakpoint(); while (true) {} } fn bar() -> %void {} export fn foo() { - %%bar(); + bar() catch unreachable; } diff --git a/test/tests.zig b/test/tests.zig index b9808fe764..20e1e94459 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -54,7 +54,7 @@ error TestFailed; const max_stdout_size = 1 * 1024 * 1024; // 1 MB pub fn addCompareOutputTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step { - const cases = %%b.allocator.create(CompareOutputContext); + const cases = b.allocator.create(CompareOutputContext) catch unreachable; *cases = CompareOutputContext { .b = b, .step = b.step("test-compare-output", "Run the compare output tests"), @@ -68,7 +68,7 @@ pub fn addCompareOutputTests(b: &build.Builder, test_filter: ?[]const u8) -> &bu } pub fn addDebugSafetyTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step { - const cases = %%b.allocator.create(CompareOutputContext); + const cases = b.allocator.create(CompareOutputContext) catch unreachable; *cases = CompareOutputContext { .b = b, .step = b.step("test-debug-safety", "Run the debug safety tests"), @@ -82,7 +82,7 @@ pub fn addDebugSafetyTests(b: &build.Builder, test_filter: ?[]const u8) -> &buil } pub fn addCompileErrorTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step { - const cases = %%b.allocator.create(CompileErrorContext); + const cases = b.allocator.create(CompileErrorContext) catch unreachable; *cases = CompileErrorContext { .b = b, .step = b.step("test-compile-errors", "Run the compile error tests"), @@ -96,7 +96,7 @@ pub fn addCompileErrorTests(b: &build.Builder, test_filter: ?[]const u8) -> &bui } pub fn addBuildExampleTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step { - const cases = %%b.allocator.create(BuildExamplesContext); + const cases = b.allocator.create(BuildExamplesContext) catch unreachable; *cases = BuildExamplesContext { .b = b, .step = b.step("test-build-examples", "Build the examples"), @@ -110,7 +110,7 @@ pub fn addBuildExampleTests(b: &build.Builder, test_filter: ?[]const u8) -> &bui } pub fn addAssembleAndLinkTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step { - const cases = %%b.allocator.create(CompareOutputContext); + const cases = b.allocator.create(CompareOutputContext) catch unreachable; *cases = CompareOutputContext { .b = b, .step = b.step("test-asm-link", "Run the assemble and link tests"), @@ -124,7 +124,7 @@ pub fn addAssembleAndLinkTests(b: &build.Builder, test_filter: ?[]const u8) -> & } pub fn addTranslateCTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step { - const cases = %%b.allocator.create(TranslateCContext); + const cases = b.allocator.create(TranslateCContext) catch unreachable; *cases = TranslateCContext { .b = b, .step = b.step("test-translate-c", "Run the C header file parsing tests"), @@ -197,10 +197,10 @@ pub const CompareOutputContext = struct { }; pub fn addSourceFile(self: &TestCase, filename: []const u8, source: []const u8) { - %%self.sources.append(SourceFile { + self.sources.append(SourceFile { .filename = filename, .source = source, - }); + }) catch unreachable; } pub fn setCommandLineArgs(self: &TestCase, args: []const []const u8) { @@ -222,7 +222,7 @@ pub const CompareOutputContext = struct { cli_args: []const []const u8) -> &RunCompareOutputStep { const allocator = context.b.allocator; - const ptr = %%allocator.create(RunCompareOutputStep); + const ptr = allocator.create(RunCompareOutputStep) catch unreachable; *ptr = RunCompareOutputStep { .context = context, .exe_path = exe_path, @@ -244,14 +244,14 @@ pub const CompareOutputContext = struct { var args = ArrayList([]const u8).init(b.allocator); defer args.deinit(); - %%args.append(full_exe_path); + args.append(full_exe_path) catch unreachable; for (self.cli_args) |arg| { - %%args.append(arg); + args.append(arg) catch unreachable; } warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name); - const child = %%os.ChildProcess.init(args.toSliceConst(), b.allocator); + const child = os.ChildProcess.init(args.toSliceConst(), b.allocator) catch unreachable; defer child.deinit(); child.stdin_behavior = StdIo.Ignore; @@ -267,8 +267,8 @@ pub const CompareOutputContext = struct { var stdout_file_in_stream = io.FileInStream.init(&??child.stdout); var stderr_file_in_stream = io.FileInStream.init(&??child.stderr); - %%stdout_file_in_stream.stream.readAllBuffer(&stdout, max_stdout_size); - %%stderr_file_in_stream.stream.readAllBuffer(&stderr, max_stdout_size); + stdout_file_in_stream.stream.readAllBuffer(&stdout, max_stdout_size) catch unreachable; + stderr_file_in_stream.stream.readAllBuffer(&stderr, max_stdout_size) catch unreachable; const term = child.wait() catch |err| { debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err)); @@ -313,7 +313,7 @@ pub const CompareOutputContext = struct { name: []const u8) -> &DebugSafetyRunStep { const allocator = context.b.allocator; - const ptr = %%allocator.create(DebugSafetyRunStep); + const ptr = allocator.create(DebugSafetyRunStep) catch unreachable; *ptr = DebugSafetyRunStep { .context = context, .exe_path = exe_path, @@ -333,7 +333,7 @@ pub const CompareOutputContext = struct { warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name); - const child = %%os.ChildProcess.init([][]u8{full_exe_path}, b.allocator); + const child = os.ChildProcess.init([][]u8{full_exe_path}, b.allocator) catch unreachable; defer child.deinit(); child.env_map = &b.env_map; @@ -416,11 +416,11 @@ pub const CompareOutputContext = struct { pub fn addCase(self: &CompareOutputContext, case: &const TestCase) { const b = self.b; - const root_src = %%os.path.join(b.allocator, b.cache_root, case.sources.items[0].filename); + const root_src = os.path.join(b.allocator, b.cache_root, case.sources.items[0].filename) catch unreachable; switch (case.special) { Special.Asm => { - const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "assemble-and-link {}", case.name); + const annotated_case_name = fmt.allocPrint(self.b.allocator, "assemble-and-link {}", case.name) catch unreachable; if (self.test_filter) |filter| { if (mem.indexOf(u8, annotated_case_name, filter) == null) return; @@ -430,7 +430,7 @@ pub const CompareOutputContext = struct { exe.addAssemblyFile(root_src); for (case.sources.toSliceConst()) |src_file| { - const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename); + const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable; const write_src = b.addWriteFile(expanded_src_path, src_file.source); exe.step.dependOn(&write_src.step); } @@ -443,8 +443,8 @@ pub const CompareOutputContext = struct { }, Special.None => { for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) |mode| { - const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "{} {} ({})", - "compare-output", case.name, @tagName(mode)); + const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {} ({})", + "compare-output", case.name, @tagName(mode)) catch unreachable; if (self.test_filter) |filter| { if (mem.indexOf(u8, annotated_case_name, filter) == null) continue; @@ -457,7 +457,7 @@ pub const CompareOutputContext = struct { } for (case.sources.toSliceConst()) |src_file| { - const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename); + const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable; const write_src = b.addWriteFile(expanded_src_path, src_file.source); exe.step.dependOn(&write_src.step); } @@ -470,7 +470,7 @@ pub const CompareOutputContext = struct { } }, Special.DebugSafety => { - const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "safety {}", case.name); + const annotated_case_name = fmt.allocPrint(self.b.allocator, "safety {}", case.name) catch unreachable; if (self.test_filter) |filter| { if (mem.indexOf(u8, annotated_case_name, filter) == null) return; @@ -482,7 +482,7 @@ pub const CompareOutputContext = struct { } for (case.sources.toSliceConst()) |src_file| { - const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename); + const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable; const write_src = b.addWriteFile(expanded_src_path, src_file.source); exe.step.dependOn(&write_src.step); } @@ -515,14 +515,14 @@ pub const CompileErrorContext = struct { }; pub fn addSourceFile(self: &TestCase, filename: []const u8, source: []const u8) { - %%self.sources.append(SourceFile { + self.sources.append(SourceFile { .filename = filename, .source = source, - }); + }) catch unreachable; } pub fn addExpectedError(self: &TestCase, text: []const u8) { - %%self.expected_errors.append(text); + self.expected_errors.append(text) catch unreachable; } }; @@ -538,7 +538,7 @@ pub const CompileErrorContext = struct { case: &const TestCase, build_mode: Mode) -> &CompileCmpOutputStep { const allocator = context.b.allocator; - const ptr = %%allocator.create(CompileCmpOutputStep); + const ptr = allocator.create(CompileCmpOutputStep) catch unreachable; *ptr = CompileCmpOutputStep { .step = build.Step.init("CompileCmpOutput", allocator, make), .context = context, @@ -555,25 +555,25 @@ pub const CompileErrorContext = struct { const self = @fieldParentPtr(CompileCmpOutputStep, "step", step); const b = self.context.b; - const root_src = %%os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename); - const obj_path = %%os.path.join(b.allocator, b.cache_root, "test.o"); + const root_src = os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename) catch unreachable; + const obj_path = os.path.join(b.allocator, b.cache_root, "test.o") catch unreachable; var zig_args = ArrayList([]const u8).init(b.allocator); - %%zig_args.append(b.zig_exe); + zig_args.append(b.zig_exe) catch unreachable; - %%zig_args.append(if (self.case.is_exe) "build-exe" else "build-obj"); - %%zig_args.append(b.pathFromRoot(root_src)); + zig_args.append(if (self.case.is_exe) "build-exe" else "build-obj") catch unreachable; + zig_args.append(b.pathFromRoot(root_src)) catch unreachable; - %%zig_args.append("--name"); - %%zig_args.append("test"); + zig_args.append("--name") catch unreachable; + zig_args.append("test") catch unreachable; - %%zig_args.append("--output"); - %%zig_args.append(b.pathFromRoot(obj_path)); + zig_args.append("--output") catch unreachable; + zig_args.append(b.pathFromRoot(obj_path)) catch unreachable; switch (self.build_mode) { Mode.Debug => {}, - Mode.ReleaseSafe => %%zig_args.append("--release-safe"), - Mode.ReleaseFast => %%zig_args.append("--release-fast"), + Mode.ReleaseSafe => zig_args.append("--release-safe") catch unreachable, + Mode.ReleaseFast => zig_args.append("--release-fast") catch unreachable, } warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name); @@ -582,7 +582,7 @@ pub const CompileErrorContext = struct { printInvocation(zig_args.toSliceConst()); } - const child = %%os.ChildProcess.init(zig_args.toSliceConst(), b.allocator); + const child = os.ChildProcess.init(zig_args.toSliceConst(), b.allocator) catch unreachable; defer child.deinit(); child.env_map = &b.env_map; @@ -598,8 +598,8 @@ pub const CompileErrorContext = struct { var stdout_file_in_stream = io.FileInStream.init(&??child.stdout); var stderr_file_in_stream = io.FileInStream.init(&??child.stderr); - %%stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size); - %%stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size); + stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size) catch unreachable; + stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable; const term = child.wait() catch |err| { debug.panic("Unable to spawn {}: {}\n", zig_args.items[0], @errorName(err)); @@ -660,7 +660,7 @@ pub const CompileErrorContext = struct { pub fn create(self: &CompileErrorContext, name: []const u8, source: []const u8, expected_lines: ...) -> &TestCase { - const tc = %%self.b.allocator.create(TestCase); + const tc = self.b.allocator.create(TestCase) catch unreachable; *tc = TestCase { .name = name, .sources = ArrayList(TestCase.SourceFile).init(self.b.allocator), @@ -697,8 +697,8 @@ pub const CompileErrorContext = struct { const b = self.b; for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) |mode| { - const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "compile-error {} ({})", - case.name, @tagName(mode)); + const annotated_case_name = fmt.allocPrint(self.b.allocator, "compile-error {} ({})", + case.name, @tagName(mode)) catch unreachable; if (self.test_filter) |filter| { if (mem.indexOf(u8, annotated_case_name, filter) == null) continue; @@ -708,7 +708,7 @@ pub const CompileErrorContext = struct { self.step.dependOn(&compile_and_cmp_errors.step); for (case.sources.toSliceConst()) |src_file| { - const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename); + const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable; const write_src = b.addWriteFile(expanded_src_path, src_file.source); compile_and_cmp_errors.step.dependOn(&write_src.step); } @@ -740,17 +740,17 @@ pub const BuildExamplesContext = struct { } var zig_args = ArrayList([]const u8).init(b.allocator); - const rel_zig_exe = %%os.path.relative(b.allocator, b.build_root, b.zig_exe); - %%zig_args.append(rel_zig_exe); - %%zig_args.append("build"); + const rel_zig_exe = os.path.relative(b.allocator, b.build_root, b.zig_exe) catch unreachable; + zig_args.append(rel_zig_exe) catch unreachable; + zig_args.append("build") catch unreachable; - %%zig_args.append("--build-file"); - %%zig_args.append(b.pathFromRoot(build_file)); + zig_args.append("--build-file") catch unreachable; + zig_args.append(b.pathFromRoot(build_file)) catch unreachable; - %%zig_args.append("test"); + zig_args.append("test") catch unreachable; if (b.verbose) { - %%zig_args.append("--verbose"); + zig_args.append("--verbose") catch unreachable; } const run_cmd = b.addCommand(null, b.env_map, zig_args.toSliceConst()); @@ -765,8 +765,8 @@ pub const BuildExamplesContext = struct { const b = self.b; for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) |mode| { - const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "build {} ({})", - root_src, @tagName(mode)); + const annotated_case_name = fmt.allocPrint(self.b.allocator, "build {} ({})", + root_src, @tagName(mode)) catch unreachable; if (self.test_filter) |filter| { if (mem.indexOf(u8, annotated_case_name, filter) == null) continue; @@ -804,14 +804,14 @@ pub const TranslateCContext = struct { }; pub fn addSourceFile(self: &TestCase, filename: []const u8, source: []const u8) { - %%self.sources.append(SourceFile { + self.sources.append(SourceFile { .filename = filename, .source = source, - }); + }) catch unreachable; } pub fn addExpectedLine(self: &TestCase, text: []const u8) { - %%self.expected_lines.append(text); + self.expected_lines.append(text) catch unreachable; } }; @@ -824,7 +824,7 @@ pub const TranslateCContext = struct { pub fn create(context: &TranslateCContext, name: []const u8, case: &const TestCase) -> &TranslateCCmpOutputStep { const allocator = context.b.allocator; - const ptr = %%allocator.create(TranslateCCmpOutputStep); + const ptr = allocator.create(TranslateCCmpOutputStep) catch unreachable; *ptr = TranslateCCmpOutputStep { .step = build.Step.init("ParseCCmpOutput", allocator, make), .context = context, @@ -840,13 +840,13 @@ pub const TranslateCContext = struct { const self = @fieldParentPtr(TranslateCCmpOutputStep, "step", step); const b = self.context.b; - const root_src = %%os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename); + const root_src = os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename) catch unreachable; var zig_args = ArrayList([]const u8).init(b.allocator); - %%zig_args.append(b.zig_exe); + zig_args.append(b.zig_exe) catch unreachable; - %%zig_args.append("translate-c"); - %%zig_args.append(b.pathFromRoot(root_src)); + zig_args.append("translate-c") catch unreachable; + zig_args.append(b.pathFromRoot(root_src)) catch unreachable; warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name); @@ -854,7 +854,7 @@ pub const TranslateCContext = struct { printInvocation(zig_args.toSliceConst()); } - const child = %%os.ChildProcess.init(zig_args.toSliceConst(), b.allocator); + const child = os.ChildProcess.init(zig_args.toSliceConst(), b.allocator) catch unreachable; defer child.deinit(); child.env_map = &b.env_map; @@ -870,8 +870,8 @@ pub const TranslateCContext = struct { var stdout_file_in_stream = io.FileInStream.init(&??child.stdout); var stderr_file_in_stream = io.FileInStream.init(&??child.stderr); - %%stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size); - %%stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size); + stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size) catch unreachable; + stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable; const term = child.wait() catch |err| { debug.panic("Unable to spawn {}: {}\n", zig_args.toSliceConst()[0], @errorName(err)); @@ -933,7 +933,7 @@ pub const TranslateCContext = struct { pub fn create(self: &TranslateCContext, allow_warnings: bool, filename: []const u8, name: []const u8, source: []const u8, expected_lines: ...) -> &TestCase { - const tc = %%self.b.allocator.create(TestCase); + const tc = self.b.allocator.create(TestCase) catch unreachable; *tc = TestCase { .name = name, .sources = ArrayList(TestCase.SourceFile).init(self.b.allocator), @@ -966,7 +966,7 @@ pub const TranslateCContext = struct { pub fn addCase(self: &TranslateCContext, case: &const TestCase) { const b = self.b; - const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "translate-c {}", case.name); + const annotated_case_name = fmt.allocPrint(self.b.allocator, "translate-c {}", case.name) catch unreachable; if (self.test_filter) |filter| { if (mem.indexOf(u8, annotated_case_name, filter) == null) return; @@ -976,7 +976,7 @@ pub const TranslateCContext = struct { self.step.dependOn(&translate_c_and_cmp.step); for (case.sources.toSliceConst()) |src_file| { - const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename); + const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable; const write_src = b.addWriteFile(expanded_src_path, src_file.source); translate_c_and_cmp.step.dependOn(&write_src.step); }