authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-01-09 00:07:01-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-01-09 00:51:51-05:00
log3c094116aae459b651934663a31981cf09cdb3e4
tree18230df032df9f9857ce6c412c50ca5ad4ffec08
parent98a95cc6987988886b90957415e9ef850b6fb119

remove %% prefix operator

See #632 closes #545 closes #510 this makes #651 higher priority

46 files changed, 551 insertions(+), 642 deletions(-)

build.zig+17-17
......@@ -18,14 +18,14 @@ pub fn build(b: &Builder) {
1818 var docgen_cmd = b.addCommand(null, b.env_map, [][]const u8 {
1919 docgen_exe.getOutputPath(),
2020 "doc/langref.html.in",
21 %%os.path.join(b.allocator, b.cache_root, "langref.html"),
21 os.path.join(b.allocator, b.cache_root, "langref.html") catch unreachable,
2222 });
2323 docgen_cmd.step.dependOn(&docgen_exe.step);
2424
2525 var docgen_home_cmd = b.addCommand(null, b.env_map, [][]const u8 {
2626 docgen_exe.getOutputPath(),
2727 "doc/home.html.in",
28 %%os.path.join(b.allocator, b.cache_root, "home.html"),
28 os.path.join(b.allocator, b.cache_root, "home.html") catch unreachable,
2929 });
3030 docgen_home_cmd.step.dependOn(&docgen_exe.step);
3131
......@@ -47,7 +47,7 @@ pub fn build(b: &Builder) {
4747 const c_header_files = nextValue(&index, build_info);
4848 const dia_guids_lib = nextValue(&index, build_info);
4949
50 const llvm = findLLVM(b, llvm_config_exe);
50 const llvm = findLLVM(b, llvm_config_exe) catch unreachable;
5151
5252 var exe = b.addExecutable("zig", "src-self-hosted/main.zig");
5353 exe.setBuildMode(mode);
......@@ -143,8 +143,8 @@ fn dependOnLib(lib_exe_obj: &std.build.LibExeObjStep, dep: &const LibraryDep) {
143143
144144fn addCppLib(b: &Builder, lib_exe_obj: &std.build.LibExeObjStep, cmake_binary_dir: []const u8, lib_name: []const u8) {
145145 const lib_prefix = if (lib_exe_obj.target.isWindows()) "" else "lib";
146 lib_exe_obj.addObjectFile(%%os.path.join(b.allocator, cmake_binary_dir, "zig_cpp",
147 b.fmt("{}{}{}", lib_prefix, lib_name, lib_exe_obj.target.libFileExt())));
146 lib_exe_obj.addObjectFile(os.path.join(b.allocator, cmake_binary_dir, "zig_cpp",
147 b.fmt("{}{}{}", lib_prefix, lib_name, lib_exe_obj.target.libFileExt())) catch unreachable);
148148}
149149
150150const LibraryDep = struct {
......@@ -154,7 +154,7 @@ const LibraryDep = struct {
154154 includes: ArrayList([]const u8),
155155};
156156
157fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> LibraryDep {
157fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> %LibraryDep {
158158 const libs_output = b.exec([][]const u8{llvm_config_exe, "--libs", "--system-libs"});
159159 const includes_output = b.exec([][]const u8{llvm_config_exe, "--includedir"});
160160 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 {
169169 var it = mem.split(libs_output, " \r\n");
170170 while (it.next()) |lib_arg| {
171171 if (mem.startsWith(u8, lib_arg, "-l")) {
172 %%result.system_libs.append(lib_arg[2..]);
172 try result.system_libs.append(lib_arg[2..]);
173173 } else {
174174 if (os.path.isAbsolute(lib_arg)) {
175 %%result.libs.append(lib_arg);
175 try result.libs.append(lib_arg);
176176 } else {
177 %%result.system_libs.append(lib_arg);
177 try result.system_libs.append(lib_arg);
178178 }
179179 }
180180 }
......@@ -183,9 +183,9 @@ fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> LibraryDep {
183183 var it = mem.split(includes_output, " \r\n");
184184 while (it.next()) |include_arg| {
185185 if (mem.startsWith(u8, include_arg, "-I")) {
186 %%result.includes.append(include_arg[2..]);
186 try result.includes.append(include_arg[2..]);
187187 } else {
188 %%result.includes.append(include_arg);
188 try result.includes.append(include_arg);
189189 }
190190 }
191191 }
......@@ -193,9 +193,9 @@ fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> LibraryDep {
193193 var it = mem.split(libdir_output, " \r\n");
194194 while (it.next()) |libdir| {
195195 if (mem.startsWith(u8, libdir, "-L")) {
196 %%result.libdirs.append(libdir[2..]);
196 try result.libdirs.append(libdir[2..]);
197197 } else {
198 %%result.libdirs.append(libdir);
198 try result.libdirs.append(libdir);
199199 }
200200 }
201201 }
......@@ -205,8 +205,8 @@ fn findLLVM(b: &Builder, llvm_config_exe: []const u8) -> LibraryDep {
205205pub fn installStdLib(b: &Builder, stdlib_files: []const u8) {
206206 var it = mem.split(stdlib_files, ";");
207207 while (it.next()) |stdlib_file| {
208 const src_path = %%os.path.join(b.allocator, "std", stdlib_file);
209 const dest_path = %%os.path.join(b.allocator, "lib", "zig", "std", stdlib_file);
208 const src_path = os.path.join(b.allocator, "std", stdlib_file) catch unreachable;
209 const dest_path = os.path.join(b.allocator, "lib", "zig", "std", stdlib_file) catch unreachable;
210210 b.installFile(src_path, dest_path);
211211 }
212212}
......@@ -214,8 +214,8 @@ pub fn installStdLib(b: &Builder, stdlib_files: []const u8) {
214214pub fn installCHeaders(b: &Builder, c_header_files: []const u8) {
215215 var it = mem.split(c_header_files, ";");
216216 while (it.next()) |c_header_file| {
217 const src_path = %%os.path.join(b.allocator, "c_headers", c_header_file);
218 const dest_path = %%os.path.join(b.allocator, "lib", "zig", "include", c_header_file);
217 const src_path = os.path.join(b.allocator, "c_headers", c_header_file) catch unreachable;
218 const dest_path = os.path.join(b.allocator, "lib", "zig", "include", c_header_file) catch unreachable;
219219 b.installFile(src_path, dest_path);
220220 }
221221}
doc/docgen.zig+7-7
......@@ -4,7 +4,7 @@ const os = std.os;
44
55pub fn main() -> %void {
66 // TODO use a more general purpose allocator here
7 var inc_allocator = %%std.heap.IncrementingAllocator.init(5 * 1024 * 1024);
7 var inc_allocator = try std.heap.IncrementingAllocator.init(5 * 1024 * 1024);
88 defer inc_allocator.deinit();
99 const allocator = &inc_allocator.allocator;
1010
......@@ -12,16 +12,16 @@ pub fn main() -> %void {
1212
1313 if (!args_it.skip()) @panic("expected self arg");
1414
15 const in_file_name = %%(args_it.next(allocator) ?? @panic("expected input arg"));
15 const in_file_name = try (args_it.next(allocator) ?? @panic("expected input arg"));
1616 defer allocator.free(in_file_name);
1717
18 const out_file_name = %%(args_it.next(allocator) ?? @panic("expected output arg"));
18 const out_file_name = try (args_it.next(allocator) ?? @panic("expected output arg"));
1919 defer allocator.free(out_file_name);
2020
21 var in_file = %%io.File.openRead(in_file_name, allocator);
21 var in_file = try io.File.openRead(in_file_name, allocator);
2222 defer in_file.close();
2323
24 var out_file = %%io.File.openWrite(out_file_name, allocator);
24 var out_file = try io.File.openWrite(out_file_name, allocator);
2525 defer out_file.close();
2626
2727 var file_in_stream = io.FileInStream.init(&in_file);
......@@ -31,7 +31,7 @@ pub fn main() -> %void {
3131 var buffered_out_stream = io.BufferedOutStream.init(&file_out_stream.stream);
3232
3333 gen(&buffered_in_stream.stream, &buffered_out_stream.stream);
34 %%buffered_out_stream.flush();
34 try buffered_out_stream.flush();
3535
3636}
3737
......@@ -54,7 +54,7 @@ fn gen(in: &io.InStream, out: &io.OutStream) {
5454 switch (state) {
5555 State.Start => switch (byte) {
5656 else => {
57 %%out.writeByte(byte);
57 out.writeByte(byte) catch unreachable;
5858 },
5959 },
6060 State.Derp => unreachable,
doc/langref.html.in+1-1
......@@ -5989,7 +5989,7 @@ ContainerInitBody = list(StructLiteralField, ",") | list(Expression, ",")
59895989
59905990StructLiteralField = "." Symbol "=" Expression
59915991
5992PrefixOp = "!" | "-" | "~" | "*" | ("&amp;" option("align" "(" Expression option(":" Integer ":" Integer) ")" ) option("const") option("volatile")) | "?" | "%" | "%%" | "??" | "-%" | "try"
5992PrefixOp = "!" | "-" | "~" | "*" | ("&amp;" option("align" "(" Expression option(":" Integer ":" Integer) ")" ) option("const") option("volatile")) | "?" | "%" | "??" | "-%" | "try"
59935993
59945994PrimaryExpression = Integer | Float | String | CharLiteral | KeywordLiteral | GroupedExpression | BlockExpression(BlockOrExpression) | Symbol | ("@" Symbol FnCallExpression) | ArrayType | FnProto | AsmExpression | ("error" "." Symbol) | ContainerDecl | ("continue" option(":" Symbol))
59955995
example/guess_number/main.zig+4-1
......@@ -15,7 +15,10 @@ pub fn main() -> %void {
1515 try stdout.print("Welcome to the Guess Number Game in Zig.\n");
1616
1717 var seed_bytes: [@sizeOf(usize)]u8 = undefined;
18 %%os.getRandomBytes(seed_bytes[0..]);
18 os.getRandomBytes(seed_bytes[0..]) catch |err| {
19 std.debug.warn("unable to seed random number generator: {}", err);
20 return err;
21 };
1922 const seed = std.mem.readInt(seed_bytes, usize, builtin.Endian.Big);
2023 var rand = Rand.init(seed);
2124
src/all_types.hpp-1
......@@ -594,7 +594,6 @@ enum PrefixOp {
594594 PrefixOpDereference,
595595 PrefixOpMaybe,
596596 PrefixOpError,
597 PrefixOpUnwrapError,
598597 PrefixOpUnwrapMaybe,
599598};
600599
src/analyze.cpp+1-1
......@@ -2587,7 +2587,7 @@ TypeTableEntry *get_test_fn_type(CodeGen *g) {
25872587 return g->test_fn_type;
25882588
25892589 FnTypeId fn_type_id = {0};
2590 fn_type_id.return_type = g->builtin_types.entry_void;
2590 fn_type_id.return_type = get_error_type(g, g->builtin_types.entry_void);
25912591 g->test_fn_type = get_fn_type(g, &fn_type_id);
25922592 return g->test_fn_type;
25932593}
src/ast_render.cpp-1
......@@ -68,7 +68,6 @@ static const char *prefix_op_str(PrefixOp prefix_op) {
6868 case PrefixOpDereference: return "*";
6969 case PrefixOpMaybe: return "?";
7070 case PrefixOpError: return "%";
71 case PrefixOpUnwrapError: return "catch";
7271 case PrefixOpUnwrapMaybe: return "??";
7372 }
7473 zig_unreachable();
src/ir.cpp-2
......@@ -3963,8 +3963,6 @@ static IrInstruction *ir_gen_prefix_op_expr(IrBuilder *irb, Scope *scope, AstNod
39633963 return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpMaybe), lval);
39643964 case PrefixOpError:
39653965 return ir_lval_wrap(irb, scope, ir_gen_prefix_op_id(irb, scope, node, IrUnOpError), lval);
3966 case PrefixOpUnwrapError:
3967 return ir_gen_err_assert_ok(irb, scope, node, node->data.prefix_op_expr.primary_expr, lval);
39683966 case PrefixOpUnwrapMaybe:
39693967 return ir_gen_maybe_assert_ok(irb, scope, node, lval);
39703968 }
src/parser.cpp-1
......@@ -956,7 +956,6 @@ static PrefixOp tok_to_prefix_op(Token *token) {
956956 case TokenIdStar: return PrefixOpDereference;
957957 case TokenIdMaybe: return PrefixOpMaybe;
958958 case TokenIdPercent: return PrefixOpError;
959 case TokenIdPercentPercent: return PrefixOpUnwrapError;
960959 case TokenIdDoubleQuestion: return PrefixOpUnwrapMaybe;
961960 case TokenIdStarStar: return PrefixOpDereference;
962961 default: return PrefixOpInvalid;
src/tokenizer.cpp-6
......@@ -816,11 +816,6 @@ void tokenize(Buf *buf, Tokenization *out) {
816816 end_token(&t);
817817 t.state = TokenizeStateStart;
818818 break;
819 case '%':
820 set_token_id(&t, t.cur_tok, TokenIdPercentPercent);
821 end_token(&t);
822 t.state = TokenizeStateStart;
823 break;
824819 default:
825820 t.pos -= 1;
826821 end_token(&t);
......@@ -1564,7 +1559,6 @@ const char * token_name(TokenId id) {
15641559 case TokenIdNumberSign: return "#";
15651560 case TokenIdPercent: return "%";
15661561 case TokenIdPercentDot: return "%.";
1567 case TokenIdPercentPercent: return "%%";
15681562 case TokenIdPlus: return "+";
15691563 case TokenIdPlusEq: return "+=";
15701564 case TokenIdPlusPercent: return "+%";
src/tokenizer.hpp-1
......@@ -101,7 +101,6 @@ enum TokenId {
101101 TokenIdNumberSign,
102102 TokenIdPercent,
103103 TokenIdPercentDot,
104 TokenIdPercentPercent,
105104 TokenIdPlus,
106105 TokenIdPlusEq,
107106 TokenIdPlusPercent,
std/array_list.zig+3-3
......@@ -116,7 +116,7 @@ test "basic ArrayList test" {
116116 defer list.deinit();
117117
118118 {var i: usize = 0; while (i < 10) : (i += 1) {
119 %%list.append(i32(i + 1));
119 list.append(i32(i + 1)) catch unreachable;
120120 }}
121121
122122 {var i: usize = 0; while (i < 10) : (i += 1) {
......@@ -126,13 +126,13 @@ test "basic ArrayList test" {
126126 assert(list.pop() == 10);
127127 assert(list.len == 9);
128128
129 %%list.appendSlice([]const i32 { 1, 2, 3 });
129 list.appendSlice([]const i32 { 1, 2, 3 }) catch unreachable;
130130 assert(list.len == 12);
131131 assert(list.pop() == 3);
132132 assert(list.pop() == 2);
133133 assert(list.pop() == 1);
134134 assert(list.len == 9);
135135
136 %%list.appendSlice([]const i32 {});
136 list.appendSlice([]const i32 {}) catch unreachable;
137137 assert(list.len == 9);
138138}
std/base64.zig+3-3
......@@ -120,7 +120,7 @@ pub const Base64Decoder = struct {
120120 /// invalid characters result in error.InvalidCharacter.
121121 /// invalid padding results in error.InvalidPadding.
122122 pub fn decode(decoder: &const Base64Decoder, dest: []u8, source: []const u8) -> %void {
123 assert(dest.len == %%decoder.calcSize(source));
123 assert(dest.len == (decoder.calcSize(source) catch unreachable));
124124 assert(source.len % 4 == 0);
125125
126126 var src_cursor: usize = 0;
......@@ -374,8 +374,8 @@ fn calcDecodedSizeExactUnsafe(source: []const u8, pad_char: u8) -> usize {
374374
375375test "base64" {
376376 @setEvalBranchQuota(5000);
377 %%testBase64();
378 comptime %%testBase64();
377 testBase64() catch unreachable;
378 comptime (testBase64() catch unreachable);
379379}
380380
381381fn testBase64() -> %void {
std/buffer.zig+6-6
......@@ -151,20 +151,20 @@ pub const Buffer = struct {
151151test "simple Buffer" {
152152 const cstr = @import("cstr.zig");
153153
154 var buf = %%Buffer.init(debug.global_allocator, "");
154 var buf = try Buffer.init(debug.global_allocator, "");
155155 assert(buf.len() == 0);
156 %%buf.append("hello");
157 %%buf.appendByte(' ');
158 %%buf.append("world");
156 try buf.append("hello");
157 try buf.appendByte(' ');
158 try buf.append("world");
159159 assert(buf.eql("hello world"));
160160 assert(mem.eql(u8, cstr.toSliceConst(buf.toSliceConst().ptr), buf.toSliceConst()));
161161
162 var buf2 = %%Buffer.initFromBuffer(&buf);
162 var buf2 = try Buffer.initFromBuffer(&buf);
163163 assert(buf.eql(buf2.toSliceConst()));
164164
165165 assert(buf.startsWith("hell"));
166166 assert(buf.endsWith("orld"));
167167
168 %%buf2.resize(4);
168 try buf2.resize(4);
169169 assert(buf.startsWith(buf2.toSliceConst()));
170170}
std/build.zig+249-249
......@@ -95,7 +95,7 @@ pub const Builder = struct {
9595 var self = Builder {
9696 .zig_exe = zig_exe,
9797 .build_root = build_root,
98 .cache_root = %%os.path.relative(allocator, build_root, cache_root),
98 .cache_root = os.path.relative(allocator, build_root, cache_root) catch unreachable,
9999 .verbose = false,
100100 .verbose_tokenize = false,
101101 .verbose_ast = false,
......@@ -113,7 +113,7 @@ pub const Builder = struct {
113113 .available_options_list = ArrayList(AvailableOption).init(allocator),
114114 .top_level_steps = ArrayList(&TopLevelStep).init(allocator),
115115 .default_step = undefined,
116 .env_map = %%os.getEnvMap(allocator),
116 .env_map = os.getEnvMap(allocator) catch unreachable,
117117 .prefix = undefined,
118118 .search_prefixes = ArrayList([]const u8).init(allocator),
119119 .lib_dir = undefined,
......@@ -146,8 +146,8 @@ pub const Builder = struct {
146146
147147 pub fn setInstallPrefix(self: &Builder, maybe_prefix: ?[]const u8) {
148148 self.prefix = maybe_prefix ?? "/usr/local"; // TODO better default
149 self.lib_dir = %%os.path.join(self.allocator, self.prefix, "lib");
150 self.exe_dir = %%os.path.join(self.allocator, self.prefix, "bin");
149 self.lib_dir = os.path.join(self.allocator, self.prefix, "lib") catch unreachable;
150 self.exe_dir = os.path.join(self.allocator, self.prefix, "bin") catch unreachable;
151151 }
152152
153153 pub fn addExecutable(self: &Builder, name: []const u8, root_src: ?[]const u8) -> &LibExeObjStep {
......@@ -169,7 +169,7 @@ pub const Builder = struct {
169169 }
170170
171171 pub fn addTest(self: &Builder, root_src: []const u8) -> &TestStep {
172 const test_step = %%self.allocator.create(TestStep);
172 const test_step = self.allocator.create(TestStep) catch unreachable;
173173 *test_step = TestStep.init(self, root_src);
174174 return test_step;
175175 }
......@@ -204,20 +204,20 @@ pub const Builder = struct {
204204 }
205205
206206 pub fn addWriteFile(self: &Builder, file_path: []const u8, data: []const u8) -> &WriteFileStep {
207 const write_file_step = %%self.allocator.create(WriteFileStep);
207 const write_file_step = self.allocator.create(WriteFileStep) catch unreachable;
208208 *write_file_step = WriteFileStep.init(self, file_path, data);
209209 return write_file_step;
210210 }
211211
212212 pub fn addLog(self: &Builder, comptime format: []const u8, args: ...) -> &LogStep {
213213 const data = self.fmt(format, args);
214 const log_step = %%self.allocator.create(LogStep);
214 const log_step = self.allocator.create(LogStep) catch unreachable;
215215 *log_step = LogStep.init(self, data);
216216 return log_step;
217217 }
218218
219219 pub fn addRemoveDirTree(self: &Builder, dir_path: []const u8) -> &RemoveDirStep {
220 const remove_dir_step = %%self.allocator.create(RemoveDirStep);
220 const remove_dir_step = self.allocator.create(RemoveDirStep) catch unreachable;
221221 *remove_dir_step = RemoveDirStep.init(self, dir_path);
222222 return remove_dir_step;
223223 }
......@@ -231,15 +231,15 @@ pub const Builder = struct {
231231 }
232232
233233 pub fn addCIncludePath(self: &Builder, path: []const u8) {
234 %%self.include_paths.append(path);
234 self.include_paths.append(path) catch unreachable;
235235 }
236236
237237 pub fn addRPath(self: &Builder, path: []const u8) {
238 %%self.rpaths.append(path);
238 self.rpaths.append(path) catch unreachable;
239239 }
240240
241241 pub fn addLibPath(self: &Builder, path: []const u8) {
242 %%self.lib_paths.append(path);
242 self.lib_paths.append(path) catch unreachable;
243243 }
244244
245245 pub fn make(self: &Builder, step_names: []const []const u8) -> %void {
......@@ -247,11 +247,11 @@ pub const Builder = struct {
247247 defer wanted_steps.deinit();
248248
249249 if (step_names.len == 0) {
250 %%wanted_steps.append(&self.default_step);
250 wanted_steps.append(&self.default_step) catch unreachable;
251251 } else {
252252 for (step_names) |step_name| {
253253 const s = try self.getTopLevelStepByName(step_name);
254 %%wanted_steps.append(s);
254 wanted_steps.append(s) catch unreachable;
255255 }
256256 }
257257
......@@ -264,7 +264,7 @@ pub const Builder = struct {
264264 if (self.have_install_step)
265265 return &self.install_tls.step;
266266
267 %%self.top_level_steps.append(&self.install_tls);
267 self.top_level_steps.append(&self.install_tls) catch unreachable;
268268 self.have_install_step = true;
269269 return &self.install_tls.step;
270270 }
......@@ -273,7 +273,7 @@ pub const Builder = struct {
273273 if (self.have_uninstall_step)
274274 return &self.uninstall_tls.step;
275275
276 %%self.top_level_steps.append(&self.uninstall_tls);
276 self.top_level_steps.append(&self.uninstall_tls) catch unreachable;
277277 self.have_uninstall_step = true;
278278 return &self.uninstall_tls.step;
279279 }
......@@ -372,10 +372,10 @@ pub const Builder = struct {
372372 .type_id = type_id,
373373 .description = description,
374374 };
375 if (%%self.available_options_map.put(name, available_option) != null) {
375 if ((self.available_options_map.put(name, available_option) catch unreachable) != null) {
376376 debug.panic("Option '{}' declared twice", name);
377377 }
378 %%self.available_options_list.append(available_option);
378 self.available_options_list.append(available_option) catch unreachable;
379379
380380 const entry = self.user_input_options.get(name) ?? return null;
381381 entry.value.used = true;
......@@ -419,12 +419,12 @@ pub const Builder = struct {
419419 }
420420
421421 pub fn step(self: &Builder, name: []const u8, description: []const u8) -> &Step {
422 const step_info = %%self.allocator.create(TopLevelStep);
422 const step_info = self.allocator.create(TopLevelStep) catch unreachable;
423423 *step_info = TopLevelStep {
424424 .step = Step.initNoOp(name, self.allocator),
425425 .description = description,
426426 };
427 %%self.top_level_steps.append(step_info);
427 self.top_level_steps.append(step_info) catch unreachable;
428428 return &step_info.step;
429429 }
430430
......@@ -450,32 +450,32 @@ pub const Builder = struct {
450450 }
451451
452452 pub fn addUserInputOption(self: &Builder, name: []const u8, value: []const u8) -> bool {
453 if (%%self.user_input_options.put(name, UserInputOption {
453 if (self.user_input_options.put(name, UserInputOption {
454454 .name = name,
455455 .value = UserValue { .Scalar = value },
456456 .used = false,
457 })) |*prev_value| {
457 }) catch unreachable) |*prev_value| {
458458 // option already exists
459459 switch (prev_value.value) {
460460 UserValue.Scalar => |s| {
461461 // turn it into a list
462462 var list = ArrayList([]const u8).init(self.allocator);
463 %%list.append(s);
464 %%list.append(value);
465 _ = %%self.user_input_options.put(name, UserInputOption {
463 list.append(s) catch unreachable;
464 list.append(value) catch unreachable;
465 _ = self.user_input_options.put(name, UserInputOption {
466466 .name = name,
467467 .value = UserValue { .List = list },
468468 .used = false,
469 });
469 }) catch unreachable;
470470 },
471471 UserValue.List => |*list| {
472472 // append to the list
473 %%list.append(value);
474 _ = %%self.user_input_options.put(name, UserInputOption {
473 list.append(value) catch unreachable;
474 _ = self.user_input_options.put(name, UserInputOption {
475475 .name = name,
476476 .value = UserValue { .List = *list },
477477 .used = false,
478 });
478 }) catch unreachable;
479479 },
480480 UserValue.Flag => {
481481 warn("Option '-D{}={}' conflicts with flag '-D{}'.\n", name, value, name);
......@@ -487,11 +487,11 @@ pub const Builder = struct {
487487 }
488488
489489 pub fn addUserInputFlag(self: &Builder, name: []const u8) -> bool {
490 if (%%self.user_input_options.put(name, UserInputOption {
490 if (self.user_input_options.put(name, UserInputOption {
491491 .name = name,
492492 .value = UserValue {.Flag = {} },
493493 .used = false,
494 })) |*prev_value| {
494 }) catch unreachable) |*prev_value| {
495495 switch (prev_value.value) {
496496 UserValue.Scalar => |s| {
497497 warn("Flag '-D{}' conflicts with option '-D{}={}'.\n", name, name, s);
......@@ -567,7 +567,7 @@ pub const Builder = struct {
567567 printCmd(cwd, argv);
568568 }
569569
570 const child = %%os.ChildProcess.init(argv, self.allocator);
570 const child = os.ChildProcess.init(argv, self.allocator) catch unreachable;
571571 defer child.deinit();
572572
573573 child.cwd = cwd;
......@@ -617,17 +617,17 @@ pub const Builder = struct {
617617
618618 ///::dest_rel_path is relative to prefix path or it can be an absolute path
619619 pub fn addInstallFile(self: &Builder, src_path: []const u8, dest_rel_path: []const u8) -> &InstallFileStep {
620 const full_dest_path = %%os.path.resolve(self.allocator, self.prefix, dest_rel_path);
620 const full_dest_path = os.path.resolve(self.allocator, self.prefix, dest_rel_path) catch unreachable;
621621 self.pushInstalledFile(full_dest_path);
622622
623 const install_step = %%self.allocator.create(InstallFileStep);
623 const install_step = self.allocator.create(InstallFileStep) catch unreachable;
624624 *install_step = InstallFileStep.init(self, src_path, full_dest_path);
625625 return install_step;
626626 }
627627
628628 pub fn pushInstalledFile(self: &Builder, full_path: []const u8) {
629629 _ = self.getUninstallStep();
630 %%self.installed_files.append(full_path);
630 self.installed_files.append(full_path) catch unreachable;
631631 }
632632
633633 fn copyFile(self: &Builder, source_path: []const u8, dest_path: []const u8) -> %void {
......@@ -652,11 +652,11 @@ pub const Builder = struct {
652652 }
653653
654654 fn pathFromRoot(self: &Builder, rel_path: []const u8) -> []u8 {
655 return %%os.path.resolve(self.allocator, self.build_root, rel_path);
655 return os.path.resolve(self.allocator, self.build_root, rel_path) catch unreachable;
656656 }
657657
658658 pub fn fmt(self: &Builder, comptime format: []const u8, args: ...) -> []u8 {
659 return %%fmt_lib.allocPrint(self.allocator, format, args);
659 return fmt_lib.allocPrint(self.allocator, format, args) catch unreachable;
660660 }
661661
662662 fn getCCExe(self: &Builder) -> []const u8 {
......@@ -746,7 +746,7 @@ pub const Builder = struct {
746746 }
747747
748748 pub fn addSearchPrefix(self: &Builder, search_prefix: []const u8) {
749 %%self.search_prefixes.append(search_prefix);
749 self.search_prefixes.append(search_prefix) catch unreachable;
750750 }
751751};
752752
......@@ -869,50 +869,50 @@ pub const LibExeObjStep = struct {
869869 pub fn createSharedLibrary(builder: &Builder, name: []const u8, root_src: ?[]const u8,
870870 ver: &const Version) -> &LibExeObjStep
871871 {
872 const self = %%builder.allocator.create(LibExeObjStep);
872 const self = builder.allocator.create(LibExeObjStep) catch unreachable;
873873 *self = initExtraArgs(builder, name, root_src, Kind.Lib, false, ver);
874874 return self;
875875 }
876876
877877 pub fn createCSharedLibrary(builder: &Builder, name: []const u8, version: &const Version) -> &LibExeObjStep {
878 const self = %%builder.allocator.create(LibExeObjStep);
878 const self = builder.allocator.create(LibExeObjStep) catch unreachable;
879879 *self = initC(builder, name, Kind.Lib, version, false);
880880 return self;
881881 }
882882
883883 pub fn createStaticLibrary(builder: &Builder, name: []const u8, root_src: ?[]const u8) -> &LibExeObjStep {
884 const self = %%builder.allocator.create(LibExeObjStep);
884 const self = builder.allocator.create(LibExeObjStep) catch unreachable;
885885 *self = initExtraArgs(builder, name, root_src, Kind.Lib, true, builder.version(0, 0, 0));
886886 return self;
887887 }
888888
889889 pub fn createCStaticLibrary(builder: &Builder, name: []const u8) -> &LibExeObjStep {
890 const self = %%builder.allocator.create(LibExeObjStep);
890 const self = builder.allocator.create(LibExeObjStep) catch unreachable;
891891 *self = initC(builder, name, Kind.Lib, builder.version(0, 0, 0), true);
892892 return self;
893893 }
894894
895895 pub fn createObject(builder: &Builder, name: []const u8, root_src: []const u8) -> &LibExeObjStep {
896 const self = %%builder.allocator.create(LibExeObjStep);
896 const self = builder.allocator.create(LibExeObjStep) catch unreachable;
897897 *self = initExtraArgs(builder, name, root_src, Kind.Obj, false, builder.version(0, 0, 0));
898898 return self;
899899 }
900900
901901 pub fn createCObject(builder: &Builder, name: []const u8, src: []const u8) -> &LibExeObjStep {
902 const self = %%builder.allocator.create(LibExeObjStep);
902 const self = builder.allocator.create(LibExeObjStep) catch unreachable;
903903 *self = initC(builder, name, Kind.Obj, builder.version(0, 0, 0), false);
904904 self.object_src = src;
905905 return self;
906906 }
907907
908908 pub fn createExecutable(builder: &Builder, name: []const u8, root_src: ?[]const u8) -> &LibExeObjStep {
909 const self = %%builder.allocator.create(LibExeObjStep);
909 const self = builder.allocator.create(LibExeObjStep) catch unreachable;
910910 *self = initExtraArgs(builder, name, root_src, Kind.Exe, false, builder.version(0, 0, 0));
911911 return self;
912912 }
913913
914914 pub fn createCExecutable(builder: &Builder, name: []const u8) -> &LibExeObjStep {
915 const self = %%builder.allocator.create(LibExeObjStep);
915 const self = builder.allocator.create(LibExeObjStep) catch unreachable;
916916 *self = initC(builder, name, Kind.Exe, builder.version(0, 0, 0), false);
917917 return self;
918918 }
......@@ -1052,7 +1052,7 @@ pub const LibExeObjStep = struct {
10521052
10531053 pub fn linkFramework(self: &LibExeObjStep, framework_name: []const u8) {
10541054 assert(self.target.isDarwin());
1055 %%self.frameworks.put(framework_name);
1055 self.frameworks.put(framework_name) catch unreachable;
10561056 }
10571057
10581058 pub fn linkLibrary(self: &LibExeObjStep, lib: &LibExeObjStep) {
......@@ -1061,30 +1061,30 @@ pub const LibExeObjStep = struct {
10611061
10621062 self.step.dependOn(&lib.step);
10631063
1064 %%self.full_path_libs.append(lib.getOutputPath());
1064 self.full_path_libs.append(lib.getOutputPath()) catch unreachable;
10651065
10661066 // TODO should be some kind of isolated directory that only has this header in it
1067 %%self.include_dirs.append(self.builder.cache_root);
1067 self.include_dirs.append(self.builder.cache_root) catch unreachable;
10681068 self.need_flat_namespace_hack = true;
10691069
10701070 // inherit the object's frameworks
10711071 if (self.target.isDarwin() and lib.static) {
10721072 var it = lib.frameworks.iterator();
10731073 while (it.next()) |entry| {
1074 %%self.frameworks.put(entry.key);
1074 self.frameworks.put(entry.key) catch unreachable;
10751075 }
10761076 }
10771077 }
10781078
10791079 pub fn linkSystemLibrary(self: &LibExeObjStep, name: []const u8) {
10801080 assert(self.kind != Kind.Obj);
1081 %%self.link_libs.put(name);
1081 self.link_libs.put(name) catch unreachable;
10821082 }
10831083
10841084 pub fn addSourceFile(self: &LibExeObjStep, file: []const u8) {
10851085 assert(self.kind != Kind.Obj);
10861086 assert(!self.is_zig);
1087 %%self.source_files.append(file);
1087 self.source_files.append(file) catch unreachable;
10881088 }
10891089
10901090 pub fn setVerboseLink(self: &LibExeObjStep, value: bool) {
......@@ -1108,7 +1108,7 @@ pub const LibExeObjStep = struct {
11081108 return if (self.output_path) |output_path|
11091109 output_path
11101110 else
1111 %%os.path.join(self.builder.allocator, self.builder.cache_root, self.out_filename);
1111 os.path.join(self.builder.allocator, self.builder.cache_root, self.out_filename) catch unreachable;
11121112 }
11131113
11141114 pub fn setOutputHPath(self: &LibExeObjStep, file_path: []const u8) {
......@@ -1124,17 +1124,17 @@ pub const LibExeObjStep = struct {
11241124 return if (self.output_h_path) |output_h_path|
11251125 output_h_path
11261126 else
1127 %%os.path.join(self.builder.allocator, self.builder.cache_root, self.out_h_filename);
1127 os.path.join(self.builder.allocator, self.builder.cache_root, self.out_h_filename) catch unreachable;
11281128 }
11291129
11301130 pub fn addAssemblyFile(self: &LibExeObjStep, path: []const u8) {
1131 %%self.assembly_files.append(path);
1131 self.assembly_files.append(path) catch unreachable;
11321132 }
11331133
11341134 pub fn addObjectFile(self: &LibExeObjStep, path: []const u8) {
11351135 assert(self.kind != Kind.Obj);
11361136
1137 %%self.object_files.append(path);
1137 self.object_files.append(path) catch unreachable;
11381138 }
11391139
11401140 pub fn addObject(self: &LibExeObjStep, obj: &LibExeObjStep) {
......@@ -1143,7 +1143,7 @@ pub const LibExeObjStep = struct {
11431143
11441144 self.step.dependOn(&obj.step);
11451145
1146 %%self.object_files.append(obj.getOutputPath());
1146 self.object_files.append(obj.getOutputPath()) catch unreachable;
11471147
11481148 // TODO make this lazy instead of stateful
11491149 if (!obj.disable_libc) {
......@@ -1151,29 +1151,29 @@ pub const LibExeObjStep = struct {
11511151 }
11521152
11531153 // TODO should be some kind of isolated directory that only has this header in it
1154 %%self.include_dirs.append(self.builder.cache_root);
1154 self.include_dirs.append(self.builder.cache_root) catch unreachable;
11551155 }
11561156
11571157 pub fn addIncludeDir(self: &LibExeObjStep, path: []const u8) {
1158 %%self.include_dirs.append(path);
1158 self.include_dirs.append(path) catch unreachable;
11591159 }
11601160
11611161 pub fn addLibPath(self: &LibExeObjStep, path: []const u8) {
1162 %%self.lib_paths.append(path);
1162 self.lib_paths.append(path) catch unreachable;
11631163 }
11641164
11651165 pub fn addPackagePath(self: &LibExeObjStep, name: []const u8, pkg_index_path: []const u8) {
11661166 assert(self.is_zig);
11671167
1168 %%self.packages.append(Pkg {
1168 self.packages.append(Pkg {
11691169 .name = name,
11701170 .path = pkg_index_path,
1171 });
1171 }) catch unreachable;
11721172 }
11731173
11741174 pub fn addCompileFlags(self: &LibExeObjStep, flags: []const []const u8) {
11751175 for (flags) |flag| {
1176 %%self.cflags.append(flag);
1176 self.cflags.append(flag) catch unreachable;
11771177 }
11781178 }
11791179
......@@ -1200,148 +1200,148 @@ pub const LibExeObjStep = struct {
12001200 var zig_args = ArrayList([]const u8).init(builder.allocator);
12011201 defer zig_args.deinit();
12021202
1203 %%zig_args.append(builder.zig_exe);
1203 zig_args.append(builder.zig_exe) catch unreachable;
12041204
12051205 const cmd = switch (self.kind) {
12061206 Kind.Lib => "build-lib",
12071207 Kind.Exe => "build-exe",
12081208 Kind.Obj => "build-obj",
12091209 };
1210 %%zig_args.append(cmd);
1210 zig_args.append(cmd) catch unreachable;
12111211
12121212 if (self.root_src) |root_src| {
1213 %%zig_args.append(builder.pathFromRoot(root_src));
1213 zig_args.append(builder.pathFromRoot(root_src)) catch unreachable;
12141214 }
12151215
12161216 for (self.object_files.toSliceConst()) |object_file| {
1217 %%zig_args.append("--object");
1218 %%zig_args.append(builder.pathFromRoot(object_file));
1217 zig_args.append("--object") catch unreachable;
1218 zig_args.append(builder.pathFromRoot(object_file)) catch unreachable;
12191219 }
12201220
12211221 for (self.assembly_files.toSliceConst()) |asm_file| {
1222 %%zig_args.append("--assembly");
1223 %%zig_args.append(builder.pathFromRoot(asm_file));
1222 zig_args.append("--assembly") catch unreachable;
1223 zig_args.append(builder.pathFromRoot(asm_file)) catch unreachable;
12241224 }
12251225
1226 if (builder.verbose_tokenize) %%zig_args.append("--verbose-tokenize");
1227 if (builder.verbose_ast) %%zig_args.append("--verbose-ast");
1228 if (builder.verbose_cimport) %%zig_args.append("--verbose-cimport");
1229 if (builder.verbose_ir) %%zig_args.append("--verbose-ir");
1230 if (builder.verbose_llvm_ir) %%zig_args.append("--verbose-llvm-ir");
1231 if (builder.verbose_link or self.verbose_link) %%zig_args.append("--verbose-link");
1226 if (builder.verbose_tokenize) zig_args.append("--verbose-tokenize") catch unreachable;
1227 if (builder.verbose_ast) zig_args.append("--verbose-ast") catch unreachable;
1228 if (builder.verbose_cimport) zig_args.append("--verbose-cimport") catch unreachable;
1229 if (builder.verbose_ir) zig_args.append("--verbose-ir") catch unreachable;
1230 if (builder.verbose_llvm_ir) zig_args.append("--verbose-llvm-ir") catch unreachable;
1231 if (builder.verbose_link or self.verbose_link) zig_args.append("--verbose-link") catch unreachable;
12321232
12331233 if (self.strip) {
1234 %%zig_args.append("--strip");
1234 zig_args.append("--strip") catch unreachable;
12351235 }
12361236
12371237 switch (self.build_mode) {
12381238 builtin.Mode.Debug => {},
1239 builtin.Mode.ReleaseSafe => %%zig_args.append("--release-safe"),
1240 builtin.Mode.ReleaseFast => %%zig_args.append("--release-fast"),
1239 builtin.Mode.ReleaseSafe => zig_args.append("--release-safe") catch unreachable,
1240 builtin.Mode.ReleaseFast => zig_args.append("--release-fast") catch unreachable,
12411241 }
12421242
1243 %%zig_args.append("--cache-dir");
1244 %%zig_args.append(builder.pathFromRoot(builder.cache_root));
1243 zig_args.append("--cache-dir") catch unreachable;
1244 zig_args.append(builder.pathFromRoot(builder.cache_root)) catch unreachable;
12451245
12461246 const output_path = builder.pathFromRoot(self.getOutputPath());
1247 %%zig_args.append("--output");
1248 %%zig_args.append(output_path);
1247 zig_args.append("--output") catch unreachable;
1248 zig_args.append(output_path) catch unreachable;
12491249
12501250 if (self.kind != Kind.Exe) {
12511251 const output_h_path = self.getOutputHPath();
1252 %%zig_args.append("--output-h");
1253 %%zig_args.append(builder.pathFromRoot(output_h_path));
1252 zig_args.append("--output-h") catch unreachable;
1253 zig_args.append(builder.pathFromRoot(output_h_path)) catch unreachable;
12541254 }
12551255
1256 %%zig_args.append("--name");
1257 %%zig_args.append(self.name);
1256 zig_args.append("--name") catch unreachable;
1257 zig_args.append(self.name) catch unreachable;
12581258
12591259 if (self.kind == Kind.Lib and !self.static) {
1260 %%zig_args.append("--ver-major");
1261 %%zig_args.append(builder.fmt("{}", self.version.major));
1260 zig_args.append("--ver-major") catch unreachable;
1261 zig_args.append(builder.fmt("{}", self.version.major)) catch unreachable;
12621262
1263 %%zig_args.append("--ver-minor");
1264 %%zig_args.append(builder.fmt("{}", self.version.minor));
1263 zig_args.append("--ver-minor") catch unreachable;
1264 zig_args.append(builder.fmt("{}", self.version.minor)) catch unreachable;
12651265
1266 %%zig_args.append("--ver-patch");
1267 %%zig_args.append(builder.fmt("{}", self.version.patch));
1266 zig_args.append("--ver-patch") catch unreachable;
1267 zig_args.append(builder.fmt("{}", self.version.patch)) catch unreachable;
12681268 }
12691269
12701270 switch (self.target) {
12711271 Target.Native => {},
12721272 Target.Cross => |cross_target| {
1273 %%zig_args.append("--target-arch");
1274 %%zig_args.append(@tagName(cross_target.arch));
1273 zig_args.append("--target-arch") catch unreachable;
1274 zig_args.append(@tagName(cross_target.arch)) catch unreachable;
12751275
1276 %%zig_args.append("--target-os");
1277 %%zig_args.append(@tagName(cross_target.os));
1276 zig_args.append("--target-os") catch unreachable;
1277 zig_args.append(@tagName(cross_target.os)) catch unreachable;
12781278
1279 %%zig_args.append("--target-environ");
1280 %%zig_args.append(@tagName(cross_target.environ));
1279 zig_args.append("--target-environ") catch unreachable;
1280 zig_args.append(@tagName(cross_target.environ)) catch unreachable;
12811281 },
12821282 }
12831283
12841284 if (self.linker_script) |linker_script| {
1285 %%zig_args.append("--linker-script");
1286 %%zig_args.append(linker_script);
1285 zig_args.append("--linker-script") catch unreachable;
1286 zig_args.append(linker_script) catch unreachable;
12871287 }
12881288
12891289 {
12901290 var it = self.link_libs.iterator();
12911291 while (true) {
12921292 const entry = it.next() ?? break;
1293 %%zig_args.append("--library");
1294 %%zig_args.append(entry.key);
1293 zig_args.append("--library") catch unreachable;
1294 zig_args.append(entry.key) catch unreachable;
12951295 }
12961296 }
12971297
12981298 if (!self.disable_libc) {
1299 %%zig_args.append("--library");
1300 %%zig_args.append("c");
1299 zig_args.append("--library") catch unreachable;
1300 zig_args.append("c") catch unreachable;
13011301 }
13021302
13031303 for (self.packages.toSliceConst()) |pkg| {
1304 %%zig_args.append("--pkg-begin");
1305 %%zig_args.append(pkg.name);
1306 %%zig_args.append(builder.pathFromRoot(pkg.path));
1307 %%zig_args.append("--pkg-end");
1304 zig_args.append("--pkg-begin") catch unreachable;
1305 zig_args.append(pkg.name) catch unreachable;
1306 zig_args.append(builder.pathFromRoot(pkg.path)) catch unreachable;
1307 zig_args.append("--pkg-end") catch unreachable;
13081308 }
13091309
13101310 for (self.include_dirs.toSliceConst()) |include_path| {
1311 %%zig_args.append("-isystem");
1312 %%zig_args.append(self.builder.pathFromRoot(include_path));
1311 zig_args.append("-isystem") catch unreachable;
1312 zig_args.append(self.builder.pathFromRoot(include_path)) catch unreachable;
13131313 }
13141314
13151315 for (builder.include_paths.toSliceConst()) |include_path| {
1316 %%zig_args.append("-isystem");
1317 %%zig_args.append(builder.pathFromRoot(include_path));
1316 zig_args.append("-isystem") catch unreachable;
1317 zig_args.append(builder.pathFromRoot(include_path)) catch unreachable;
13181318 }
13191319
13201320 for (builder.rpaths.toSliceConst()) |rpath| {
1321 %%zig_args.append("-rpath");
1322 %%zig_args.append(rpath);
1321 zig_args.append("-rpath") catch unreachable;
1322 zig_args.append(rpath) catch unreachable;
13231323 }
13241324
13251325 for (self.lib_paths.toSliceConst()) |lib_path| {
1326 %%zig_args.append("--library-path");
1327 %%zig_args.append(lib_path);
1326 zig_args.append("--library-path") catch unreachable;
1327 zig_args.append(lib_path) catch unreachable;
13281328 }
13291329
13301330 for (builder.lib_paths.toSliceConst()) |lib_path| {
1331 %%zig_args.append("--library-path");
1332 %%zig_args.append(lib_path);
1331 zig_args.append("--library-path") catch unreachable;
1332 zig_args.append(lib_path) catch unreachable;
13331333 }
13341334
13351335 for (self.full_path_libs.toSliceConst()) |full_path_lib| {
1336 %%zig_args.append("--library");
1337 %%zig_args.append(builder.pathFromRoot(full_path_lib));
1336 zig_args.append("--library") catch unreachable;
1337 zig_args.append(builder.pathFromRoot(full_path_lib)) catch unreachable;
13381338 }
13391339
13401340 if (self.target.isDarwin()) {
13411341 var it = self.frameworks.iterator();
13421342 while (it.next()) |entry| {
1343 %%zig_args.append("-framework");
1344 %%zig_args.append(entry.key);
1343 zig_args.append("-framework") catch unreachable;
1344 zig_args.append(entry.key) catch unreachable;
13451345 }
13461346 }
13471347
......@@ -1355,46 +1355,46 @@ pub const LibExeObjStep = struct {
13551355
13561356 fn appendCompileFlags(self: &LibExeObjStep, args: &ArrayList([]const u8)) {
13571357 if (!self.strip) {
1358 %%args.append("-g");
1358 args.append("-g") catch unreachable;
13591359 }
13601360 switch (self.build_mode) {
13611361 builtin.Mode.Debug => {
13621362 if (self.disable_libc) {
1363 %%args.append("-fno-stack-protector");
1363 args.append("-fno-stack-protector") catch unreachable;
13641364 } else {
1365 %%args.append("-fstack-protector-strong");
1366 %%args.append("--param");
1367 %%args.append("ssp-buffer-size=4");
1365 args.append("-fstack-protector-strong") catch unreachable;
1366 args.append("--param") catch unreachable;
1367 args.append("ssp-buffer-size=4") catch unreachable;
13681368 }
13691369 },
13701370 builtin.Mode.ReleaseSafe => {
1371 %%args.append("-O2");
1371 args.append("-O2") catch unreachable;
13721372 if (self.disable_libc) {
1373 %%args.append("-fno-stack-protector");
1373 args.append("-fno-stack-protector") catch unreachable;
13741374 } else {
1375 %%args.append("-D_FORTIFY_SOURCE=2");
1376 %%args.append("-fstack-protector-strong");
1377 %%args.append("--param");
1378 %%args.append("ssp-buffer-size=4");
1375 args.append("-D_FORTIFY_SOURCE=2") catch unreachable;
1376 args.append("-fstack-protector-strong") catch unreachable;
1377 args.append("--param") catch unreachable;
1378 args.append("ssp-buffer-size=4") catch unreachable;
13791379 }
13801380 },
13811381 builtin.Mode.ReleaseFast => {
1382 %%args.append("-O2");
1383 %%args.append("-fno-stack-protector");
1382 args.append("-O2") catch unreachable;
1383 args.append("-fno-stack-protector") catch unreachable;
13841384 },
13851385 }
13861386
13871387 for (self.include_dirs.toSliceConst()) |dir| {
1388 %%args.append("-I");
1389 %%args.append(self.builder.pathFromRoot(dir));
1388 args.append("-I") catch unreachable;
1389 args.append(self.builder.pathFromRoot(dir)) catch unreachable;
13901390 }
13911391
13921392 for (self.cflags.toSliceConst()) |cflag| {
1393 %%args.append(cflag);
1393 args.append(cflag) catch unreachable;
13941394 }
13951395
13961396 if (self.disable_libc) {
1397 %%args.append("-nostdlib");
1397 args.append("-nostdlib") catch unreachable;
13981398 }
13991399 }
14001400
......@@ -1408,18 +1408,18 @@ pub const LibExeObjStep = struct {
14081408 var cc_args = ArrayList([]const u8).init(builder.allocator);
14091409 defer cc_args.deinit();
14101410
1411 %%cc_args.append(cc);
1411 cc_args.append(cc) catch unreachable;
14121412
14131413 const is_darwin = self.target.isDarwin();
14141414
14151415 switch (self.kind) {
14161416 Kind.Obj => {
1417 %%cc_args.append("-c");
1418 %%cc_args.append(builder.pathFromRoot(self.object_src));
1417 cc_args.append("-c") catch unreachable;
1418 cc_args.append(builder.pathFromRoot(self.object_src)) catch unreachable;
14191419
14201420 const output_path = builder.pathFromRoot(self.getOutputPath());
1421 %%cc_args.append("-o");
1422 %%cc_args.append(output_path);
1421 cc_args.append("-o") catch unreachable;
1422 cc_args.append(output_path) catch unreachable;
14231423
14241424 self.appendCompileFlags(&cc_args);
14251425
......@@ -1427,113 +1427,113 @@ pub const LibExeObjStep = struct {
14271427 },
14281428 Kind.Lib => {
14291429 for (self.source_files.toSliceConst()) |source_file| {
1430 %%cc_args.resize(0);
1431 %%cc_args.append(cc);
1430 cc_args.resize(0) catch unreachable;
1431 cc_args.append(cc) catch unreachable;
14321432
14331433 if (!self.static) {
1434 %%cc_args.append("-fPIC");
1434 cc_args.append("-fPIC") catch unreachable;
14351435 }
14361436
14371437 const abs_source_file = builder.pathFromRoot(source_file);
1438 %%cc_args.append("-c");
1439 %%cc_args.append(abs_source_file);
1438 cc_args.append("-c") catch unreachable;
1439 cc_args.append(abs_source_file) catch unreachable;
14401440
1441 const cache_o_src = %%os.path.join(builder.allocator, builder.cache_root, source_file);
1441 const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;
14421442 const cache_o_dir = os.path.dirname(cache_o_src);
14431443 try builder.makePath(cache_o_dir);
14441444 const cache_o_file = builder.fmt("{}{}", cache_o_src, self.target.oFileExt());
1445 %%cc_args.append("-o");
1446 %%cc_args.append(builder.pathFromRoot(cache_o_file));
1445 cc_args.append("-o") catch unreachable;
1446 cc_args.append(builder.pathFromRoot(cache_o_file)) catch unreachable;
14471447
14481448 self.appendCompileFlags(&cc_args);
14491449
14501450 try builder.spawnChild(cc_args.toSliceConst());
14511451
1452 %%self.object_files.append(cache_o_file);
1452 self.object_files.append(cache_o_file) catch unreachable;
14531453 }
14541454
14551455 if (self.static) {
14561456 // ar
1457 %%cc_args.resize(0);
1458 %%cc_args.append("ar");
1457 cc_args.resize(0) catch unreachable;
1458 cc_args.append("ar") catch unreachable;
14591459
1460 %%cc_args.append("qc");
1460 cc_args.append("qc") catch unreachable;
14611461
14621462 const output_path = builder.pathFromRoot(self.getOutputPath());
1463 %%cc_args.append(output_path);
1463 cc_args.append(output_path) catch unreachable;
14641464
14651465 for (self.object_files.toSliceConst()) |object_file| {
1466 %%cc_args.append(builder.pathFromRoot(object_file));
1466 cc_args.append(builder.pathFromRoot(object_file)) catch unreachable;
14671467 }
14681468
14691469 try builder.spawnChild(cc_args.toSliceConst());
14701470
14711471 // ranlib
1472 %%cc_args.resize(0);
1473 %%cc_args.append("ranlib");
1474 %%cc_args.append(output_path);
1472 cc_args.resize(0) catch unreachable;
1473 cc_args.append("ranlib") catch unreachable;
1474 cc_args.append(output_path) catch unreachable;
14751475
14761476 try builder.spawnChild(cc_args.toSliceConst());
14771477 } else {
1478 %%cc_args.resize(0);
1479 %%cc_args.append(cc);
1478 cc_args.resize(0) catch unreachable;
1479 cc_args.append(cc) catch unreachable;
14801480
14811481 if (is_darwin) {
1482 %%cc_args.append("-dynamiclib");
1482 cc_args.append("-dynamiclib") catch unreachable;
14831483
1484 %%cc_args.append("-Wl,-headerpad_max_install_names");
1484 cc_args.append("-Wl,-headerpad_max_install_names") catch unreachable;
14851485
1486 %%cc_args.append("-compatibility_version");
1487 %%cc_args.append(builder.fmt("{}.0.0", self.version.major));
1486 cc_args.append("-compatibility_version") catch unreachable;
1487 cc_args.append(builder.fmt("{}.0.0", self.version.major)) catch unreachable;
14881488
1489 %%cc_args.append("-current_version");
1490 %%cc_args.append(builder.fmt("{}.{}.{}", self.version.major, self.version.minor, self.version.patch));
1489 cc_args.append("-current_version") catch unreachable;
1490 cc_args.append(builder.fmt("{}.{}.{}", self.version.major, self.version.minor, self.version.patch)) catch unreachable;
14911491
1492 const install_name = builder.pathFromRoot(%%os.path.join(builder.allocator, builder.cache_root, self.major_only_filename));
1493 %%cc_args.append("-install_name");
1494 %%cc_args.append(install_name);
1492 const install_name = builder.pathFromRoot(os.path.join(builder.allocator, builder.cache_root, self.major_only_filename) catch unreachable);
1493 cc_args.append("-install_name") catch unreachable;
1494 cc_args.append(install_name) catch unreachable;
14951495 } else {
1496 %%cc_args.append("-fPIC");
1497 %%cc_args.append("-shared");
1496 cc_args.append("-fPIC") catch unreachable;
1497 cc_args.append("-shared") catch unreachable;
14981498
14991499 const soname_arg = builder.fmt("-Wl,-soname,lib{}.so.{d}", self.name, self.version.major);
15001500 defer builder.allocator.free(soname_arg);
1501 %%cc_args.append(soname_arg);
1501 cc_args.append(soname_arg) catch unreachable;
15021502 }
15031503
15041504 const output_path = builder.pathFromRoot(self.getOutputPath());
1505 %%cc_args.append("-o");
1506 %%cc_args.append(output_path);
1505 cc_args.append("-o") catch unreachable;
1506 cc_args.append(output_path) catch unreachable;
15071507
15081508 for (self.object_files.toSliceConst()) |object_file| {
1509 %%cc_args.append(builder.pathFromRoot(object_file));
1509 cc_args.append(builder.pathFromRoot(object_file)) catch unreachable;
15101510 }
15111511
15121512 if (!is_darwin) {
15131513 const rpath_arg = builder.fmt("-Wl,-rpath,{}",
1514 %%os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)));
1514 os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)) catch unreachable);
15151515 defer builder.allocator.free(rpath_arg);
1516 %%cc_args.append(rpath_arg);
1516 cc_args.append(rpath_arg) catch unreachable;
15171517
1518 %%cc_args.append("-rdynamic");
1518 cc_args.append("-rdynamic") catch unreachable;
15191519 }
15201520
15211521 for (self.full_path_libs.toSliceConst()) |full_path_lib| {
1522 %%cc_args.append(builder.pathFromRoot(full_path_lib));
1522 cc_args.append(builder.pathFromRoot(full_path_lib)) catch unreachable;
15231523 }
15241524
15251525 {
15261526 var it = self.link_libs.iterator();
15271527 while (it.next()) |entry| {
1528 %%cc_args.append(builder.fmt("-l{}", entry.key));
1528 cc_args.append(builder.fmt("-l{}", entry.key)) catch unreachable;
15291529 }
15301530 }
15311531
15321532 if (is_darwin and !self.static) {
15331533 var it = self.frameworks.iterator();
15341534 while (it.next()) |entry| {
1535 %%cc_args.append("-framework");
1536 %%cc_args.append(entry.key);
1535 cc_args.append("-framework") catch unreachable;
1536 cc_args.append(entry.key) catch unreachable;
15371537 }
15381538 }
15391539
......@@ -1547,75 +1547,75 @@ pub const LibExeObjStep = struct {
15471547 },
15481548 Kind.Exe => {
15491549 for (self.source_files.toSliceConst()) |source_file| {
1550 %%cc_args.resize(0);
1551 %%cc_args.append(cc);
1550 cc_args.resize(0) catch unreachable;
1551 cc_args.append(cc) catch unreachable;
15521552
15531553 const abs_source_file = builder.pathFromRoot(source_file);
1554 %%cc_args.append("-c");
1555 %%cc_args.append(abs_source_file);
1554 cc_args.append("-c") catch unreachable;
1555 cc_args.append(abs_source_file) catch unreachable;
15561556
1557 const cache_o_src = %%os.path.join(builder.allocator, builder.cache_root, source_file);
1557 const cache_o_src = os.path.join(builder.allocator, builder.cache_root, source_file) catch unreachable;
15581558 const cache_o_dir = os.path.dirname(cache_o_src);
15591559 try builder.makePath(cache_o_dir);
15601560 const cache_o_file = builder.fmt("{}{}", cache_o_src, self.target.oFileExt());
1561 %%cc_args.append("-o");
1562 %%cc_args.append(builder.pathFromRoot(cache_o_file));
1561 cc_args.append("-o") catch unreachable;
1562 cc_args.append(builder.pathFromRoot(cache_o_file)) catch unreachable;
15631563
15641564 for (self.cflags.toSliceConst()) |cflag| {
1565 %%cc_args.append(cflag);
1565 cc_args.append(cflag) catch unreachable;
15661566 }
15671567
15681568 for (self.include_dirs.toSliceConst()) |dir| {
1569 %%cc_args.append("-I");
1570 %%cc_args.append(builder.pathFromRoot(dir));
1569 cc_args.append("-I") catch unreachable;
1570 cc_args.append(builder.pathFromRoot(dir)) catch unreachable;
15711571 }
15721572
15731573 try builder.spawnChild(cc_args.toSliceConst());
15741574
1575 %%self.object_files.append(cache_o_file);
1575 self.object_files.append(cache_o_file) catch unreachable;
15761576 }
15771577
1578 %%cc_args.resize(0);
1579 %%cc_args.append(cc);
1578 cc_args.resize(0) catch unreachable;
1579 cc_args.append(cc) catch unreachable;
15801580
15811581 for (self.object_files.toSliceConst()) |object_file| {
1582 %%cc_args.append(builder.pathFromRoot(object_file));
1582 cc_args.append(builder.pathFromRoot(object_file)) catch unreachable;
15831583 }
15841584
15851585 const output_path = builder.pathFromRoot(self.getOutputPath());
1586 %%cc_args.append("-o");
1587 %%cc_args.append(output_path);
1586 cc_args.append("-o") catch unreachable;
1587 cc_args.append(output_path) catch unreachable;
15881588
15891589 const rpath_arg = builder.fmt("-Wl,-rpath,{}",
1590 %%os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)));
1590 os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)) catch unreachable);
15911591 defer builder.allocator.free(rpath_arg);
1592 %%cc_args.append(rpath_arg);
1592 cc_args.append(rpath_arg) catch unreachable;
15931593
1594 %%cc_args.append("-rdynamic");
1594 cc_args.append("-rdynamic") catch unreachable;
15951595
15961596 {
15971597 var it = self.link_libs.iterator();
15981598 while (it.next()) |entry| {
1599 %%cc_args.append(builder.fmt("-l{}", entry.key));
1599 cc_args.append(builder.fmt("-l{}", entry.key)) catch unreachable;
16001600 }
16011601 }
16021602
16031603 if (is_darwin) {
16041604 if (self.need_flat_namespace_hack) {
1605 %%cc_args.append("-Wl,-flat_namespace");
1605 cc_args.append("-Wl,-flat_namespace") catch unreachable;
16061606 }
1607 %%cc_args.append("-Wl,-search_paths_first");
1607 cc_args.append("-Wl,-search_paths_first") catch unreachable;
16081608 }
16091609
16101610 for (self.full_path_libs.toSliceConst()) |full_path_lib| {
1611 %%cc_args.append(builder.pathFromRoot(full_path_lib));
1611 cc_args.append(builder.pathFromRoot(full_path_lib)) catch unreachable;
16121612 }
16131613
16141614 if (is_darwin) {
16151615 var it = self.frameworks.iterator();
16161616 while (it.next()) |entry| {
1617 %%cc_args.append("-framework");
1618 %%cc_args.append(entry.key);
1617 cc_args.append("-framework") catch unreachable;
1618 cc_args.append(entry.key) catch unreachable;
16191619 }
16201620 }
16211621
......@@ -1662,7 +1662,7 @@ pub const TestStep = struct {
16621662 }
16631663
16641664 pub fn linkSystemLibrary(self: &TestStep, name: []const u8) {
1665 %%self.link_libs.put(name);
1665 self.link_libs.put(name) catch unreachable;
16661666 }
16671667
16681668 pub fn setNamePrefix(self: &TestStep, text: []const u8) {
......@@ -1696,78 +1696,78 @@ pub const TestStep = struct {
16961696 var zig_args = ArrayList([]const u8).init(builder.allocator);
16971697 defer zig_args.deinit();
16981698
1699 %%zig_args.append(builder.zig_exe);
1699 try zig_args.append(builder.zig_exe);
17001700
1701 %%zig_args.append("test");
1702 %%zig_args.append(builder.pathFromRoot(self.root_src));
1701 try zig_args.append("test");
1702 try zig_args.append(builder.pathFromRoot(self.root_src));
17031703
17041704 if (self.verbose) {
1705 %%zig_args.append("--verbose");
1705 try zig_args.append("--verbose");
17061706 }
17071707
17081708 switch (self.build_mode) {
17091709 builtin.Mode.Debug => {},
1710 builtin.Mode.ReleaseSafe => %%zig_args.append("--release-safe"),
1711 builtin.Mode.ReleaseFast => %%zig_args.append("--release-fast"),
1710 builtin.Mode.ReleaseSafe => try zig_args.append("--release-safe"),
1711 builtin.Mode.ReleaseFast => try zig_args.append("--release-fast"),
17121712 }
17131713
17141714 switch (self.target) {
17151715 Target.Native => {},
17161716 Target.Cross => |cross_target| {
1717 %%zig_args.append("--target-arch");
1718 %%zig_args.append(@tagName(cross_target.arch));
1717 try zig_args.append("--target-arch");
1718 try zig_args.append(@tagName(cross_target.arch));
17191719
1720 %%zig_args.append("--target-os");
1721 %%zig_args.append(@tagName(cross_target.os));
1720 try zig_args.append("--target-os");
1721 try zig_args.append(@tagName(cross_target.os));
17221722
1723 %%zig_args.append("--target-environ");
1724 %%zig_args.append(@tagName(cross_target.environ));
1723 try zig_args.append("--target-environ");
1724 try zig_args.append(@tagName(cross_target.environ));
17251725 },
17261726 }
17271727
17281728 if (self.filter) |filter| {
1729 %%zig_args.append("--test-filter");
1730 %%zig_args.append(filter);
1729 try zig_args.append("--test-filter");
1730 try zig_args.append(filter);
17311731 }
17321732
17331733 if (self.name_prefix.len != 0) {
1734 %%zig_args.append("--test-name-prefix");
1735 %%zig_args.append(self.name_prefix);
1734 try zig_args.append("--test-name-prefix");
1735 try zig_args.append(self.name_prefix);
17361736 }
17371737
17381738 {
17391739 var it = self.link_libs.iterator();
17401740 while (true) {
17411741 const entry = it.next() ?? break;
1742 %%zig_args.append("--library");
1743 %%zig_args.append(entry.key);
1742 try zig_args.append("--library");
1743 try zig_args.append(entry.key);
17441744 }
17451745 }
17461746
17471747 if (self.exec_cmd_args) |exec_cmd_args| {
17481748 for (exec_cmd_args) |cmd_arg| {
17491749 if (cmd_arg) |arg| {
1750 %%zig_args.append("--test-cmd");
1751 %%zig_args.append(arg);
1750 try zig_args.append("--test-cmd");
1751 try zig_args.append(arg);
17521752 } else {
1753 %%zig_args.append("--test-cmd-bin");
1753 try zig_args.append("--test-cmd-bin");
17541754 }
17551755 }
17561756 }
17571757
17581758 for (builder.include_paths.toSliceConst()) |include_path| {
1759 %%zig_args.append("-isystem");
1760 %%zig_args.append(builder.pathFromRoot(include_path));
1759 try zig_args.append("-isystem");
1760 try zig_args.append(builder.pathFromRoot(include_path));
17611761 }
17621762
17631763 for (builder.rpaths.toSliceConst()) |rpath| {
1764 %%zig_args.append("-rpath");
1765 %%zig_args.append(rpath);
1764 try zig_args.append("-rpath");
1765 try zig_args.append(rpath);
17661766 }
17671767
17681768 for (builder.lib_paths.toSliceConst()) |lib_path| {
1769 %%zig_args.append("--library-path");
1770 %%zig_args.append(lib_path);
1769 try zig_args.append("--library-path");
1770 try zig_args.append(lib_path);
17711771 }
17721772
17731773 try builder.spawnChild(zig_args.toSliceConst());
......@@ -1785,11 +1785,11 @@ pub const CommandStep = struct {
17851785 pub fn create(builder: &Builder, cwd: ?[]const u8, env_map: &const BufMap,
17861786 argv: []const []const u8) -> &CommandStep
17871787 {
1788 const self = %%builder.allocator.create(CommandStep);
1788 const self = builder.allocator.create(CommandStep) catch unreachable;
17891789 *self = CommandStep {
17901790 .builder = builder,
17911791 .step = Step.init(argv[0], builder.allocator, make),
1792 .argv = %%builder.allocator.alloc([]u8, argv.len),
1792 .argv = builder.allocator.alloc([]u8, argv.len) catch unreachable,
17931793 .cwd = cwd,
17941794 .env_map = env_map,
17951795 };
......@@ -1815,7 +1815,7 @@ const InstallArtifactStep = struct {
18151815 const Self = this;
18161816
18171817 pub fn create(builder: &Builder, artifact: &LibExeObjStep) -> &Self {
1818 const self = %%builder.allocator.create(Self);
1818 const self = builder.allocator.create(Self) catch unreachable;
18191819 const dest_dir = switch (artifact.kind) {
18201820 LibExeObjStep.Kind.Obj => unreachable,
18211821 LibExeObjStep.Kind.Exe => builder.exe_dir,
......@@ -1825,15 +1825,15 @@ const InstallArtifactStep = struct {
18251825 .builder = builder,
18261826 .step = Step.init(builder.fmt("install {}", artifact.step.name), builder.allocator, make),
18271827 .artifact = artifact,
1828 .dest_file = %%os.path.join(builder.allocator, dest_dir, artifact.out_filename),
1828 .dest_file = os.path.join(builder.allocator, dest_dir, artifact.out_filename) catch unreachable,
18291829 };
18301830 self.step.dependOn(&artifact.step);
18311831 builder.pushInstalledFile(self.dest_file);
18321832 if (self.artifact.kind == LibExeObjStep.Kind.Lib and !self.artifact.static) {
1833 builder.pushInstalledFile(%%os.path.join(builder.allocator, builder.lib_dir,
1834 artifact.major_only_filename));
1835 builder.pushInstalledFile(%%os.path.join(builder.allocator, builder.lib_dir,
1836 artifact.name_only_filename));
1833 builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir,
1834 artifact.major_only_filename) catch unreachable);
1835 builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir,
1836 artifact.name_only_filename) catch unreachable);
18371837 }
18381838 return self;
18391839 }
......@@ -1978,7 +1978,7 @@ pub const Step = struct {
19781978 }
19791979
19801980 pub fn dependOn(self: &Step, other: &Step) {
1981 %%self.dependencies.append(other);
1981 self.dependencies.append(other) catch unreachable;
19821982 }
19831983
19841984 fn makeNoOp(self: &Step) -> %void {}
......@@ -1990,13 +1990,13 @@ fn doAtomicSymLinks(allocator: &Allocator, output_path: []const u8, filename_maj
19901990 const out_dir = os.path.dirname(output_path);
19911991 const out_basename = os.path.basename(output_path);
19921992 // sym link for libfoo.so.1 to libfoo.so.1.2.3
1993 const major_only_path = %%os.path.join(allocator, out_dir, filename_major_only);
1993 const major_only_path = os.path.join(allocator, out_dir, filename_major_only) catch unreachable;
19941994 os.atomicSymLink(allocator, out_basename, major_only_path) catch |err| {
19951995 warn("Unable to symlink {} -> {}\n", major_only_path, out_basename);
19961996 return err;
19971997 };
19981998 // sym link for libfoo.so to libfoo.so.1
1999 const name_only_path = %%os.path.join(allocator, out_dir, filename_name_only);
1999 const name_only_path = os.path.join(allocator, out_dir, filename_name_only) catch unreachable;
20002000 os.atomicSymLink(allocator, filename_major_only, name_only_path) catch |err| {
20012001 warn("Unable to symlink {} -> {}\n", name_only_path, filename_major_only);
20022002 return err;
std/fmt/index.zig+24-24
......@@ -123,7 +123,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->%void,
123123 },
124124 State.IntegerWidth => switch (c) {
125125 '}' => {
126 width = comptime %%parseUnsigned(usize, fmt[width_start..i], 10);
126 width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
127127 try formatInt(args[next_arg], radix, uppercase, width, context, output);
128128 next_arg += 1;
129129 state = State.Start;
......@@ -147,7 +147,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->%void,
147147 },
148148 State.FloatWidth => switch (c) {
149149 '}' => {
150 width = comptime %%parseUnsigned(usize, fmt[width_start..i], 10);
150 width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
151151 try formatFloatDecimal(args[next_arg], width, context, output);
152152 next_arg += 1;
153153 state = State.Start;
......@@ -158,7 +158,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->%void,
158158 },
159159 State.BufWidth => switch (c) {
160160 '}' => {
161 width = comptime %%parseUnsigned(usize, fmt[width_start..i], 10);
161 width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
162162 try formatBuf(args[next_arg], width, context, output);
163163 next_arg += 1;
164164 state = State.Start;
......@@ -410,7 +410,7 @@ pub fn formatIntBuf(out_buf: []u8, value: var, base: u8, uppercase: bool, width:
410410 .out_buf = out_buf,
411411 .index = 0,
412412 };
413 %%formatInt(value, base, uppercase, width, &context, formatIntCallback);
413 formatInt(value, base, uppercase, width, &context, formatIntCallback) catch unreachable;
414414 return context.index;
415415}
416416const FormatIntBuf = struct {
......@@ -437,12 +437,12 @@ pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) -> %T {
437437}
438438
439439test "fmt.parseInt" {
440 assert(%%parseInt(i32, "-10", 10) == -10);
441 assert(%%parseInt(i32, "+10", 10) == 10);
440 assert((parseInt(i32, "-10", 10) catch unreachable) == -10);
441 assert((parseInt(i32, "+10", 10) catch unreachable) == 10);
442442 assert(if (parseInt(i32, " 10", 10)) |_| false else |err| err == error.InvalidChar);
443443 assert(if (parseInt(i32, "10 ", 10)) |_| false else |err| err == error.InvalidChar);
444444 assert(if (parseInt(u32, "-10", 10)) |_| false else |err| err == error.InvalidChar);
445 assert(%%parseInt(u8, "255", 10) == 255);
445 assert((parseInt(u8, "255", 10) catch unreachable) == 255);
446446 assert(if (parseInt(u8, "256", 10)) |_| false else |err| err == error.Overflow);
447447}
448448
......@@ -501,7 +501,7 @@ pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: ...) -> %[]u8 {
501501pub fn allocPrint(allocator: &mem.Allocator, comptime fmt: []const u8, args: ...) -> %[]u8 {
502502 var size: usize = 0;
503503 // Cannot fail because `countSize` cannot fail.
504 %%format(&size, countSize, fmt, args);
504 format(&size, countSize, fmt, args) catch unreachable;
505505 const buf = try allocator.alloc(u8, size);
506506 return bufPrint(buf, fmt, args);
507507}
......@@ -542,7 +542,7 @@ test "parse u64 digit too big" {
542542
543543test "parse unsigned comptime" {
544544 comptime {
545 assert(%%parseUnsigned(usize, "2", 10) == 2);
545 assert((try parseUnsigned(usize, "2", 10)) == 2);
546546 }
547547}
548548
......@@ -550,31 +550,31 @@ test "fmt.format" {
550550 {
551551 var buf1: [32]u8 = undefined;
552552 const value: ?i32 = 1234;
553 const result = %%bufPrint(buf1[0..], "nullable: {}\n", value);
553 const result = try bufPrint(buf1[0..], "nullable: {}\n", value);
554554 assert(mem.eql(u8, result, "nullable: 1234\n"));
555555 }
556556 {
557557 var buf1: [32]u8 = undefined;
558558 const value: ?i32 = null;
559 const result = %%bufPrint(buf1[0..], "nullable: {}\n", value);
559 const result = try bufPrint(buf1[0..], "nullable: {}\n", value);
560560 assert(mem.eql(u8, result, "nullable: null\n"));
561561 }
562562 {
563563 var buf1: [32]u8 = undefined;
564564 const value: %i32 = 1234;
565 const result = %%bufPrint(buf1[0..], "error union: {}\n", value);
565 const result = try bufPrint(buf1[0..], "error union: {}\n", value);
566566 assert(mem.eql(u8, result, "error union: 1234\n"));
567567 }
568568 {
569569 var buf1: [32]u8 = undefined;
570570 const value: %i32 = error.InvalidChar;
571 const result = %%bufPrint(buf1[0..], "error union: {}\n", value);
571 const result = try bufPrint(buf1[0..], "error union: {}\n", value);
572572 assert(mem.eql(u8, result, "error union: error.InvalidChar\n"));
573573 }
574574 {
575575 var buf1: [32]u8 = undefined;
576576 const value: u3 = 0b101;
577 const result = %%bufPrint(buf1[0..], "u3: {}\n", value);
577 const result = try bufPrint(buf1[0..], "u3: {}\n", value);
578578 assert(mem.eql(u8, result, "u3: 5\n"));
579579 }
580580
......@@ -584,46 +584,46 @@ test "fmt.format" {
584584 {
585585 var buf1: [32]u8 = undefined;
586586 const value: f32 = 12.34;
587 const result = %%bufPrint(buf1[0..], "f32: {}\n", value);
587 const result = try bufPrint(buf1[0..], "f32: {}\n", value);
588588 assert(mem.eql(u8, result, "f32: 1.23400001e1\n"));
589589 }
590590 {
591591 var buf1: [32]u8 = undefined;
592592 const value: f64 = -12.34e10;
593 const result = %%bufPrint(buf1[0..], "f64: {}\n", value);
593 const result = try bufPrint(buf1[0..], "f64: {}\n", value);
594594 assert(mem.eql(u8, result, "f64: -1.234e11\n"));
595595 }
596596 {
597597 var buf1: [32]u8 = undefined;
598 const result = %%bufPrint(buf1[0..], "f64: {}\n", math.nan_f64);
598 const result = try bufPrint(buf1[0..], "f64: {}\n", math.nan_f64);
599599 assert(mem.eql(u8, result, "f64: NaN\n"));
600600 }
601601 {
602602 var buf1: [32]u8 = undefined;
603 const result = %%bufPrint(buf1[0..], "f64: {}\n", math.inf_f64);
603 const result = try bufPrint(buf1[0..], "f64: {}\n", math.inf_f64);
604604 assert(mem.eql(u8, result, "f64: Infinity\n"));
605605 }
606606 {
607607 var buf1: [32]u8 = undefined;
608 const result = %%bufPrint(buf1[0..], "f64: {}\n", -math.inf_f64);
608 const result = try bufPrint(buf1[0..], "f64: {}\n", -math.inf_f64);
609609 assert(mem.eql(u8, result, "f64: -Infinity\n"));
610610 }
611611 {
612612 var buf1: [32]u8 = undefined;
613613 const value: f32 = 1.1234;
614 const result = %%bufPrint(buf1[0..], "f32: {.1}\n", value);
614 const result = try bufPrint(buf1[0..], "f32: {.1}\n", value);
615615 assert(mem.eql(u8, result, "f32: 1.1\n"));
616616 }
617617 {
618618 var buf1: [32]u8 = undefined;
619619 const value: f32 = 1234.567;
620 const result = %%bufPrint(buf1[0..], "f32: {.2}\n", value);
620 const result = try bufPrint(buf1[0..], "f32: {.2}\n", value);
621621 assert(mem.eql(u8, result, "f32: 1234.56\n"));
622622 }
623623 {
624624 var buf1: [32]u8 = undefined;
625625 const value: f32 = -11.1234;
626 const result = %%bufPrint(buf1[0..], "f32: {.4}\n", value);
626 const result = try bufPrint(buf1[0..], "f32: {.4}\n", value);
627627 // -11.1234 is converted to f64 -11.12339... internally (errol3() function takes f64).
628628 // -11.12339... is truncated to -11.1233
629629 assert(mem.eql(u8, result, "f32: -11.1233\n"));
......@@ -631,13 +631,13 @@ test "fmt.format" {
631631 {
632632 var buf1: [32]u8 = undefined;
633633 const value: f32 = 91.12345;
634 const result = %%bufPrint(buf1[0..], "f32: {.}\n", value);
634 const result = try bufPrint(buf1[0..], "f32: {.}\n", value);
635635 assert(mem.eql(u8, result, "f32: 91.12345\n"));
636636 }
637637 {
638638 var buf1: [32]u8 = undefined;
639639 const value: f64 = 91.12345678901235;
640 const result = %%bufPrint(buf1[0..], "f64: {.10}\n", value);
640 const result = try bufPrint(buf1[0..], "f64: {.10}\n", value);
641641 assert(mem.eql(u8, result, "f64: 91.1234567890\n"));
642642 }
643643
std/hash_map.zig+8-8
......@@ -236,14 +236,14 @@ test "basicHashMapTest" {
236236 var map = HashMap(i32, i32, hash_i32, eql_i32).init(debug.global_allocator);
237237 defer map.deinit();
238238
239 assert(%%map.put(1, 11) == null);
240 assert(%%map.put(2, 22) == null);
241 assert(%%map.put(3, 33) == null);
242 assert(%%map.put(4, 44) == null);
243 assert(%%map.put(5, 55) == null);
244
245 assert(??%%map.put(5, 66) == 55);
246 assert(??%%map.put(5, 55) == 66);
239 assert((map.put(1, 11) catch unreachable) == null);
240 assert((map.put(2, 22) catch unreachable) == null);
241 assert((map.put(3, 33) catch unreachable) == null);
242 assert((map.put(4, 44) catch unreachable) == null);
243 assert((map.put(5, 55) catch unreachable) == null);
244
245 assert(??(map.put(5, 66) catch unreachable) == 55);
246 assert(??(map.put(5, 55) catch unreachable) == 66);
247247
248248 assert((??map.get(2)).value == 22);
249249 _ = map.remove(2);
std/heap.zig+3-3
......@@ -145,14 +145,14 @@ test "c_allocator" {
145145
146146test "IncrementingAllocator" {
147147 const total_bytes = 100 * 1024 * 1024;
148 var inc_allocator = %%IncrementingAllocator.init(total_bytes);
148 var inc_allocator = try IncrementingAllocator.init(total_bytes);
149149 defer inc_allocator.deinit();
150150
151151 const allocator = &inc_allocator.allocator;
152 const slice = %%allocator.alloc(&i32, 100);
152 const slice = try allocator.alloc(&i32, 100);
153153
154154 for (slice) |*item, i| {
155 *item = %%allocator.create(i32);
155 *item = try allocator.create(i32);
156156 **item = i32(i);
157157 }
158158
std/io_test.zig+9-9
......@@ -18,34 +18,34 @@ test "write a file, read it, then delete it" {
1818 rng.fillBytes(data[0..]);
1919 const tmp_file_name = "temp_test_file.txt";
2020 {
21 var file = %%io.File.openWrite(tmp_file_name, allocator);
21 var file = try io.File.openWrite(tmp_file_name, allocator);
2222 defer file.close();
2323
2424 var file_out_stream = io.FileOutStream.init(&file);
2525 var buf_stream = io.BufferedOutStream.init(&file_out_stream.stream);
2626 const st = &buf_stream.stream;
27 %%st.print("begin");
28 %%st.write(data[0..]);
29 %%st.print("end");
30 %%buf_stream.flush();
27 try st.print("begin");
28 try st.write(data[0..]);
29 try st.print("end");
30 try buf_stream.flush();
3131 }
3232 {
33 var file = %%io.File.openRead(tmp_file_name, allocator);
33 var file = try io.File.openRead(tmp_file_name, allocator);
3434 defer file.close();
3535
36 const file_size = %%file.getEndPos();
36 const file_size = try file.getEndPos();
3737 const expected_file_size = "begin".len + data.len + "end".len;
3838 assert(file_size == expected_file_size);
3939
4040 var file_in_stream = io.FileInStream.init(&file);
4141 var buf_stream = io.BufferedInStream.init(&file_in_stream.stream);
4242 const st = &buf_stream.stream;
43 const contents = %%st.readAllAlloc(allocator, 2 * 1024);
43 const contents = try st.readAllAlloc(allocator, 2 * 1024);
4444 defer allocator.free(contents);
4545
4646 assert(mem.eql(u8, contents[0.."begin".len], "begin"));
4747 assert(mem.eql(u8, contents["begin".len..contents.len - "end".len], data));
4848 assert(mem.eql(u8, contents[contents.len - "end".len ..], "end"));
4949 }
50 %%os.deleteFile(allocator, tmp_file_name);
50 try os.deleteFile(allocator, tmp_file_name);
5151}
std/linked_list.zig+5-5
......@@ -199,11 +199,11 @@ test "basic linked list test" {
199199 const allocator = debug.global_allocator;
200200 var list = LinkedList(u32).init();
201201
202 var one = %%list.createNode(1, allocator);
203 var two = %%list.createNode(2, allocator);
204 var three = %%list.createNode(3, allocator);
205 var four = %%list.createNode(4, allocator);
206 var five = %%list.createNode(5, allocator);
202 var one = list.createNode(1, allocator) catch unreachable;
203 var two = list.createNode(2, allocator) catch unreachable;
204 var three = list.createNode(3, allocator) catch unreachable;
205 var four = list.createNode(4, allocator) catch unreachable;
206 var five = list.createNode(5, allocator) catch unreachable;
207207 defer {
208208 list.destroyNode(one, allocator);
209209 list.destroyNode(two, allocator);
std/math/index.zig+30-30
......@@ -277,10 +277,10 @@ test "math overflow functions" {
277277}
278278
279279fn testOverflow() {
280 assert(%%mul(i32, 3, 4) == 12);
281 assert(%%add(i32, 3, 4) == 7);
282 assert(%%sub(i32, 3, 4) == -1);
283 assert(%%shlExact(i32, 0b11, 4) == 0b110000);
280 assert((mul(i32, 3, 4) catch unreachable) == 12);
281 assert((add(i32, 3, 4) catch unreachable) == 7);
282 assert((sub(i32, 3, 4) catch unreachable) == -1);
283 assert((shlExact(i32, 0b11, 4) catch unreachable) == 0b110000);
284284}
285285
286286
......@@ -302,8 +302,8 @@ test "math.absInt" {
302302 comptime testAbsInt();
303303}
304304fn testAbsInt() {
305 assert(%%absInt(i32(-10)) == 10);
306 assert(%%absInt(i32(10)) == 10);
305 assert((absInt(i32(-10)) catch unreachable) == 10);
306 assert((absInt(i32(10)) catch unreachable) == 10);
307307}
308308
309309pub const absFloat = @import("fabs.zig").fabs;
......@@ -329,13 +329,13 @@ test "math.divTrunc" {
329329 comptime testDivTrunc();
330330}
331331fn testDivTrunc() {
332 assert(%%divTrunc(i32, 5, 3) == 1);
333 assert(%%divTrunc(i32, -5, 3) == -1);
332 assert((divTrunc(i32, 5, 3) catch unreachable) == 1);
333 assert((divTrunc(i32, -5, 3) catch unreachable) == -1);
334334 if (divTrunc(i8, -5, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
335335 if (divTrunc(i8, -128, -1)) |_| unreachable else |err| assert(err == error.Overflow);
336336
337 assert(%%divTrunc(f32, 5.0, 3.0) == 1.0);
338 assert(%%divTrunc(f32, -5.0, 3.0) == -1.0);
337 assert((divTrunc(f32, 5.0, 3.0) catch unreachable) == 1.0);
338 assert((divTrunc(f32, -5.0, 3.0) catch unreachable) == -1.0);
339339}
340340
341341error DivisionByZero;
......@@ -359,13 +359,13 @@ test "math.divFloor" {
359359 comptime testDivFloor();
360360}
361361fn testDivFloor() {
362 assert(%%divFloor(i32, 5, 3) == 1);
363 assert(%%divFloor(i32, -5, 3) == -2);
362 assert((divFloor(i32, 5, 3) catch unreachable) == 1);
363 assert((divFloor(i32, -5, 3) catch unreachable) == -2);
364364 if (divFloor(i8, -5, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
365365 if (divFloor(i8, -128, -1)) |_| unreachable else |err| assert(err == error.Overflow);
366366
367 assert(%%divFloor(f32, 5.0, 3.0) == 1.0);
368 assert(%%divFloor(f32, -5.0, 3.0) == -2.0);
367 assert((divFloor(f32, 5.0, 3.0) catch unreachable) == 1.0);
368 assert((divFloor(f32, -5.0, 3.0) catch unreachable) == -2.0);
369369}
370370
371371error DivisionByZero;
......@@ -393,14 +393,14 @@ test "math.divExact" {
393393 comptime testDivExact();
394394}
395395fn testDivExact() {
396 assert(%%divExact(i32, 10, 5) == 2);
397 assert(%%divExact(i32, -10, 5) == -2);
396 assert((divExact(i32, 10, 5) catch unreachable) == 2);
397 assert((divExact(i32, -10, 5) catch unreachable) == -2);
398398 if (divExact(i8, -5, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
399399 if (divExact(i8, -128, -1)) |_| unreachable else |err| assert(err == error.Overflow);
400400 if (divExact(i32, 5, 2)) |_| unreachable else |err| assert(err == error.UnexpectedRemainder);
401401
402 assert(%%divExact(f32, 10.0, 5.0) == 2.0);
403 assert(%%divExact(f32, -10.0, 5.0) == -2.0);
402 assert((divExact(f32, 10.0, 5.0) catch unreachable) == 2.0);
403 assert((divExact(f32, -10.0, 5.0) catch unreachable) == -2.0);
404404 if (divExact(f32, 5.0, 2.0)) |_| unreachable else |err| assert(err == error.UnexpectedRemainder);
405405}
406406
......@@ -420,13 +420,13 @@ test "math.mod" {
420420 comptime testMod();
421421}
422422fn testMod() {
423 assert(%%mod(i32, -5, 3) == 1);
424 assert(%%mod(i32, 5, 3) == 2);
423 assert((mod(i32, -5, 3) catch unreachable) == 1);
424 assert((mod(i32, 5, 3) catch unreachable) == 2);
425425 if (mod(i32, 10, -1)) |_| unreachable else |err| assert(err == error.NegativeDenominator);
426426 if (mod(i32, 10, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
427427
428 assert(%%mod(f32, -5, 3) == 1);
429 assert(%%mod(f32, 5, 3) == 2);
428 assert((mod(f32, -5, 3) catch unreachable) == 1);
429 assert((mod(f32, 5, 3) catch unreachable) == 2);
430430 if (mod(f32, 10, -1)) |_| unreachable else |err| assert(err == error.NegativeDenominator);
431431 if (mod(f32, 10, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
432432}
......@@ -447,13 +447,13 @@ test "math.rem" {
447447 comptime testRem();
448448}
449449fn testRem() {
450 assert(%%rem(i32, -5, 3) == -2);
451 assert(%%rem(i32, 5, 3) == 2);
450 assert((rem(i32, -5, 3) catch unreachable) == -2);
451 assert((rem(i32, 5, 3) catch unreachable) == 2);
452452 if (rem(i32, 10, -1)) |_| unreachable else |err| assert(err == error.NegativeDenominator);
453453 if (rem(i32, 10, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
454454
455 assert(%%rem(f32, -5, 3) == -2);
456 assert(%%rem(f32, 5, 3) == 2);
455 assert((rem(f32, -5, 3) catch unreachable) == -2);
456 assert((rem(f32, 5, 3) catch unreachable) == 2);
457457 if (rem(f32, 10, -1)) |_| unreachable else |err| assert(err == error.NegativeDenominator);
458458 if (rem(f32, 10, 0)) |_| unreachable else |err| assert(err == error.DivisionByZero);
459459}
......@@ -497,11 +497,11 @@ pub fn negateCast(x: var) -> %@IntType(true, @typeOf(x).bit_count) {
497497}
498498
499499test "math.negateCast" {
500 assert(%%negateCast(u32(999)) == -999);
501 assert(@typeOf(%%negateCast(u32(999))) == i32);
500 assert((negateCast(u32(999)) catch unreachable) == -999);
501 assert(@typeOf(negateCast(u32(999)) catch unreachable) == i32);
502502
503 assert(%%negateCast(u32(-@minValue(i32))) == @minValue(i32));
504 assert(@typeOf(%%negateCast(u32(-@minValue(i32)))) == i32);
503 assert((negateCast(u32(-@minValue(i32))) catch unreachable) == @minValue(i32));
504 assert(@typeOf(negateCast(u32(-@minValue(i32))) catch unreachable) == i32);
505505
506506 if (negateCast(u32(@maxValue(i32) + 10))) |_| unreachable else |err| assert(err == error.Overflow);
507507}
std/mem.zig+3-3
......@@ -93,7 +93,7 @@ pub const Allocator = struct {
9393 // n <= old_mem.len and the multiplication didn't overflow for that operation.
9494 const byte_count = @sizeOf(T) * n;
9595
96 const byte_slice = %%self.reallocFn(self, ([]u8)(old_mem), byte_count, alignment);
96 const byte_slice = self.reallocFn(self, ([]u8)(old_mem), byte_count, alignment) catch unreachable;
9797 return ([]align(alignment) T)(@alignCast(alignment, byte_slice));
9898 }
9999
......@@ -446,8 +446,8 @@ pub fn join(allocator: &Allocator, sep: u8, strings: ...) -> %[]u8 {
446446}
447447
448448test "mem.join" {
449 assert(eql(u8, %%join(debug.global_allocator, ',', "a", "b", "c"), "a,b,c"));
450 assert(eql(u8, %%join(debug.global_allocator, ',', "a"), "a"));
449 assert(eql(u8, try join(debug.global_allocator, ',', "a", "b", "c"), "a,b,c"));
450 assert(eql(u8, try join(debug.global_allocator, ',', "a"), "a"));
451451}
452452
453453test "testStringEquality" {
std/net.zig+2-87
......@@ -3,6 +3,8 @@ const linux = std.os.linux;
33const assert = std.debug.assert;
44const endian = std.endian;
55
6// TODO don't trust this file, it bit rotted. start over
7
68error SigInterrupt;
79error Io;
810error TimedOut;
......@@ -67,24 +69,9 @@ const Address = struct {
6769pub fn lookup(hostname: []const u8, out_addrs: []Address) -> %[]Address {
6870 if (hostname.len == 0) {
6971
70//
71// if (family != AF_INET6)
72// buf[cnt++] = (struct address){ .family = AF_INET, .addr = { 127,0,0,1 } };
73// if (family != AF_INET)
74// buf[cnt++] = (struct address){ .family = AF_INET6, .addr = { [15] = 1 } };
75//
7672 unreachable; // TODO
7773 }
7874
79 // TODO
80 //switch (parseIpLiteral(hostname)) {
81 // Ok => |addr| {
82 // out_addrs[0] = addr;
83 // return out_addrs[0..1];
84 // },
85 // else => {},
86 //};
87
8875 unreachable; // TODO
8976}
9077
......@@ -142,23 +129,6 @@ pub fn connect(hostname: []const u8, port: u16) -> %Connection {
142129error InvalidIpLiteral;
143130
144131pub fn parseIpLiteral(buf: []const u8) -> %Address {
145 // TODO
146 //switch (parseIp4(buf)) {
147 // Ok => |ip4| {
148 // var result: Address = undefined;
149 // @memcpy(&result.addr[0], (&u8)(&ip4), @sizeOf(u32));
150 // result.family = linux.AF_INET;
151 // result.scope_id = 0;
152 // return result;
153 // },
154 // else => {},
155 //}
156 //switch (parseIp6(buf)) {
157 // Ok => |addr| {
158 // return addr;
159 // },
160 // else => {},
161 //}
162132
163133 return error.InvalidIpLiteral;
164134}
......@@ -249,21 +219,6 @@ fn parseIp6(buf: []const u8) -> %Address {
249219 return error.Incomplete;
250220 }
251221
252//
253// if (p) {
254// if (isdigit(*++p)) scopeid = strtoull(p, &z, 10);
255// else z = p-1;
256// if (*z) {
257// if (!IN6_IS_ADDR_LINKLOCAL(&a6) and
258// !IN6_IS_ADDR_MC_LINKLOCAL(&a6))
259// return EAI_NONAME;
260// scopeid = if_nametoindex(p);
261// if (!scopeid) return EAI_NONAME;
262// }
263// if (scopeid > UINT_MAX) return EAI_NONAME;
264// }
265//
266
267222 if (scope_id) {
268223 return result;
269224 }
......@@ -316,43 +271,3 @@ fn parseIp4(buf: []const u8) -> %u32 {
316271
317272 return error.Incomplete;
318273}
319
320
321// TODO
322//fn testParseIp4() {
323// @setFnTest(this);
324//
325// assert(%%parseIp4("127.0.0.1") == endian.swapIfLe(u32, 0x7f000001));
326// switch (parseIp4("256.0.0.1")) { Overflow => {}, else => unreachable, }
327// switch (parseIp4("x.0.0.1")) { InvalidChar => {}, else => unreachable, }
328// switch (parseIp4("127.0.0.1.1")) { JunkAtEnd => {}, else => unreachable, }
329// switch (parseIp4("127.0.0.")) { Incomplete => {}, else => unreachable, }
330// switch (parseIp4("100..0.1")) { InvalidChar => {}, else => unreachable, }
331//}
332//
333//fn testParseIp6() {
334// @setFnTest(this);
335//
336// {
337// const addr = %%parseIp6("FF01:0:0:0:0:0:0:FB");
338// assert(addr.addr[0] == 0xff);
339// assert(addr.addr[1] == 0x01);
340// assert(addr.addr[2] == 0x00);
341// }
342//}
343//
344//fn testLookupSimpleIp() {
345// @setFnTest(this);
346//
347// {
348// var addrs_buf: [5]Address = undefined;
349// const addrs = %%lookup("192.168.1.1", addrs_buf);
350// assert(addrs.len == 1);
351// const addr = addrs[0];
352// assert(addr.family == linux.AF_INET);
353// assert(addr.addr[0] == 192);
354// assert(addr.addr[1] == 168);
355// assert(addr.addr[2] == 1);
356// assert(addr.addr[3] == 1);
357// }
358//}
std/os/child_process.zig+1-1
......@@ -191,7 +191,7 @@ pub const ChildProcess = struct {
191191 pub fn exec(allocator: &mem.Allocator, argv: []const []const u8, cwd: ?[]const u8,
192192 env_map: ?&const BufMap, max_output_size: usize) -> %ExecResult
193193 {
194 const child = %%ChildProcess.init(argv, allocator);
194 const child = try ChildProcess.init(argv, allocator);
195195 defer child.deinit();
196196
197197 child.stdin_behavior = ChildProcess.StdIo.Ignore;
std/os/index.zig+2-2
......@@ -121,7 +121,7 @@ pub fn getRandomBytes(buf: []u8) -> %void {
121121
122122test "os.getRandomBytes" {
123123 var buf: [50]u8 = undefined;
124 %%getRandomBytes(buf[0..]);
124 try getRandomBytes(buf[0..]);
125125}
126126
127127/// Raises a signal in the current kernel thread, ending its execution.
......@@ -1489,7 +1489,7 @@ test "windows arg parsing" {
14891489fn testWindowsCmdLine(input_cmd_line: &const u8, expected_args: []const []const u8) {
14901490 var it = ArgIteratorWindows.initWithCmdLine(input_cmd_line);
14911491 for (expected_args) |expected_arg| {
1492 const arg = %%??it.next(debug.global_allocator);
1492 const arg = ??it.next(debug.global_allocator) catch unreachable;
14931493 assert(mem.eql(u8, arg, expected_arg));
14941494 }
14951495 assert(it.next(debug.global_allocator) == null);
std/os/path.zig+19-19
......@@ -49,23 +49,23 @@ pub fn joinPosix(allocator: &Allocator, paths: ...) -> %[]u8 {
4949}
5050
5151test "os.path.join" {
52 assert(mem.eql(u8, %%joinWindows(debug.global_allocator, "c:\\a\\b", "c"), "c:\\a\\b\\c"));
53 assert(mem.eql(u8, %%joinWindows(debug.global_allocator, "c:\\a\\b\\", "c"), "c:\\a\\b\\c"));
52 assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\a\\b", "c"), "c:\\a\\b\\c"));
53 assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\a\\b\\", "c"), "c:\\a\\b\\c"));
5454
55 assert(mem.eql(u8, %%joinWindows(debug.global_allocator, "c:\\", "a", "b\\", "c"), "c:\\a\\b\\c"));
56 assert(mem.eql(u8, %%joinWindows(debug.global_allocator, "c:\\a\\", "b\\", "c"), "c:\\a\\b\\c"));
55 assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\", "a", "b\\", "c"), "c:\\a\\b\\c"));
56 assert(mem.eql(u8, try joinWindows(debug.global_allocator, "c:\\a\\", "b\\", "c"), "c:\\a\\b\\c"));
5757
58 assert(mem.eql(u8, %%joinWindows(debug.global_allocator,
58 assert(mem.eql(u8, try joinWindows(debug.global_allocator,
5959 "c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std", "io.zig"),
6060 "c:\\home\\andy\\dev\\zig\\build\\lib\\zig\\std\\io.zig"));
6161
62 assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/a/b", "c"), "/a/b/c"));
63 assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/a/b/", "c"), "/a/b/c"));
62 assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/a/b", "c"), "/a/b/c"));
63 assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/a/b/", "c"), "/a/b/c"));
6464
65 assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/", "a", "b/", "c"), "/a/b/c"));
66 assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/a/", "b/", "c"), "/a/b/c"));
65 assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/", "a", "b/", "c"), "/a/b/c"));
66 assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/a/", "b/", "c"), "/a/b/c"));
6767
68 assert(mem.eql(u8, %%joinPosix(debug.global_allocator, "/home/andy/dev/zig/build/lib/zig/std", "io.zig"),
68 assert(mem.eql(u8, try joinPosix(debug.global_allocator, "/home/andy/dev/zig/build/lib/zig/std", "io.zig"),
6969 "/home/andy/dev/zig/build/lib/zig/std/io.zig"));
7070}
7171
......@@ -584,7 +584,7 @@ pub fn resolvePosix(allocator: &Allocator, paths: []const []const u8) -> %[]u8 {
584584}
585585
586586test "os.path.resolve" {
587 const cwd = %%os.getCwd(debug.global_allocator);
587 const cwd = try os.getCwd(debug.global_allocator);
588588 if (is_windows) {
589589 if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {
590590 cwd[0] = asciiUpper(cwd[0]);
......@@ -598,11 +598,11 @@ test "os.path.resolve" {
598598
599599test "os.path.resolveWindows" {
600600 if (is_windows) {
601 const cwd = %%os.getCwd(debug.global_allocator);
601 const cwd = try os.getCwd(debug.global_allocator);
602602 const parsed_cwd = windowsParsePath(cwd);
603603 {
604604 const result = testResolveWindows([][]const u8{"/usr/local", "lib\\zig\\std\\array_list.zig"});
605 const expected = %%join(debug.global_allocator,
605 const expected = try join(debug.global_allocator,
606606 parsed_cwd.disk_designator, "usr\\local\\lib\\zig\\std\\array_list.zig");
607607 if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
608608 expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
......@@ -611,7 +611,7 @@ test "os.path.resolveWindows" {
611611 }
612612 {
613613 const result = testResolveWindows([][]const u8{"usr/local", "lib\\zig"});
614 const expected = %%join(debug.global_allocator, cwd, "usr\\local\\lib\\zig");
614 const expected = try join(debug.global_allocator, cwd, "usr\\local\\lib\\zig");
615615 if (parsed_cwd.kind == WindowsPath.Kind.Drive) {
616616 expected[0] = asciiUpper(parsed_cwd.disk_designator[0]);
617617 }
......@@ -649,11 +649,11 @@ test "os.path.resolvePosix" {
649649}
650650
651651fn testResolveWindows(paths: []const []const u8) -> []u8 {
652 return %%resolveWindows(debug.global_allocator, paths);
652 return resolveWindows(debug.global_allocator, paths) catch unreachable;
653653}
654654
655655fn testResolvePosix(paths: []const []const u8) -> []u8 {
656 return %%resolvePosix(debug.global_allocator, paths);
656 return resolvePosix(debug.global_allocator, paths) catch unreachable;
657657}
658658
659659pub fn dirname(path: []const u8) -> []const u8 {
......@@ -1057,12 +1057,12 @@ test "os.path.relative" {
10571057}
10581058
10591059fn testRelativePosix(from: []const u8, to: []const u8, expected_output: []const u8) {
1060 const result = %%relativePosix(debug.global_allocator, from, to);
1060 const result = relativePosix(debug.global_allocator, from, to) catch unreachable;
10611061 assert(mem.eql(u8, result, expected_output));
10621062}
10631063
10641064fn testRelativeWindows(from: []const u8, to: []const u8, expected_output: []const u8) {
1065 const result = %%relativeWindows(debug.global_allocator, from, to);
1065 const result = relativeWindows(debug.global_allocator, from, to) catch unreachable;
10661066 assert(mem.eql(u8, result, expected_output));
10671067}
10681068
......@@ -1172,7 +1172,7 @@ pub fn real(allocator: &Allocator, pathname: []const u8) -> %[]u8 {
11721172 defer os.close(fd);
11731173
11741174 var buf: ["/proc/self/fd/-2147483648".len]u8 = undefined;
1175 const proc_path = %%fmt.bufPrint(buf[0..], "/proc/self/fd/{}", fd);
1175 const proc_path = fmt.bufPrint(buf[0..], "/proc/self/fd/{}", fd) catch unreachable;
11761176
11771177 return os.readLink(allocator, proc_path);
11781178 },
std/rand.zig+2-2
......@@ -74,7 +74,7 @@ pub const Rand = struct {
7474 return T(r.range(uint, uint(start), uint(end)));
7575 } else if (start < 0 and end < 0) {
7676 // Can't overflow because the range is over signed ints
77 return %%math.negateCast(r.range(uint, math.absCast(end), math.absCast(start)) + 1);
77 return math.negateCast(r.range(uint, math.absCast(end), math.absCast(start)) + 1) catch unreachable;
7878 } else if (start < 0 and end >= 0) {
7979 const end_uint = uint(end);
8080 const total_range = math.absCast(start) + end_uint;
......@@ -85,7 +85,7 @@ pub const Rand = struct {
8585 break :x start;
8686 } else x: {
8787 // Can't overflow because the range is over signed ints
88 break :x %%math.negateCast(value - end_uint);
88 break :x math.negateCast(value - end_uint) catch unreachable;
8989 };
9090 return result;
9191 } else {
std/sort.zig+1-1
......@@ -1115,7 +1115,7 @@ var fixed_buffer_mem: [100 * 1024]u8 = undefined;
11151115fn fuzzTest(rng: &std.rand.Rand) {
11161116 const array_size = rng.range(usize, 0, 1000);
11171117 var fixed_allocator = mem.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
1118 var array = %%fixed_allocator.allocator.alloc(IdAndValue, array_size);
1118 var array = fixed_allocator.allocator.alloc(IdAndValue, array_size) catch unreachable;
11191119 // populate with random data
11201120 for (array) |*item, index| {
11211121 item.id = index;
std/special/build_runner.zig+2-2
......@@ -14,7 +14,7 @@ pub fn main() -> %void {
1414 var arg_it = os.args();
1515
1616 // TODO use a more general purpose allocator here
17 var inc_allocator = %%std.heap.IncrementingAllocator.init(40 * 1024 * 1024);
17 var inc_allocator = std.heap.IncrementingAllocator.init(40 * 1024 * 1024) catch unreachable;
1818 defer inc_allocator.deinit();
1919
2020 const allocator = &inc_allocator.allocator;
......@@ -107,7 +107,7 @@ pub fn main() -> %void {
107107 return usageAndErr(&builder, false, try stderr_stream);
108108 }
109109 } else {
110 %%targets.append(arg);
110 targets.append(arg) catch unreachable;
111111 }
112112 }
113113
std/special/test_runner.zig+4-1
......@@ -8,7 +8,10 @@ pub fn main() -> %void {
88 for (test_fn_list) |test_fn, i| {
99 warn("Test {}/{} {}...", i + 1, test_fn_list.len, test_fn.name);
1010
11 test_fn.func();
11 test_fn.func() catch |err| {
12 warn("{}\n", err);
13 return err;
14 };
1215
1316 warn("OK\n");
1417 }
std/unicode.zig+2-2
......@@ -19,7 +19,7 @@ error Utf8EncodesSurrogateHalf;
1919error Utf8CodepointTooLarge;
2020
2121/// Decodes the UTF-8 codepoint encoded in the given slice of bytes.
22/// bytes.len must be equal to %%utf8ByteSequenceLength(bytes[0]).
22/// bytes.len must be equal to utf8ByteSequenceLength(bytes[0]) catch unreachable.
2323/// If you already know the length at comptime, you can call one of
2424/// utf8Decode2,utf8Decode3,utf8Decode4 directly instead of this function.
2525pub fn utf8Decode(bytes: []const u8) -> %u32 {
......@@ -158,7 +158,7 @@ fn testError(bytes: []const u8, expected_err: error) {
158158}
159159
160160fn testValid(bytes: []const u8, expected_codepoint: u32) {
161 std.debug.assert(%%testDecode(bytes) == expected_codepoint);
161 std.debug.assert((testDecode(bytes) catch unreachable) == expected_codepoint);
162162}
163163
164164fn testDecode(bytes: []const u8) -> %u32 {
test/cases/cast.zig+12-12
......@@ -85,14 +85,14 @@ const A = struct {
8585fn castToMaybeTypeError(z: i32) {
8686 const x = i32(1);
8787 const y: %?i32 = x;
88 assert(??%%y == 1);
88 assert(??(try y) == 1);
8989
9090 const f = z;
9191 const g: %?i32 = f;
9292
9393 const a = A{ .a = z };
9494 const b: %?A = a;
95 assert((??%%b).a == 1);
95 assert((??(b catch unreachable)).a == 1);
9696}
9797
9898test "implicitly cast from int to %?T" {
......@@ -108,7 +108,7 @@ fn implicitIntLitToMaybe() {
108108test "return null from fn() -> %?&T" {
109109 const a = returnNullFromMaybeTypeErrorRef();
110110 const b = returnNullLitFromMaybeTypeErrorRef();
111 assert(%%a == null and %%b == null);
111 assert((try a) == null and (try b) == null);
112112}
113113fn returnNullFromMaybeTypeErrorRef() -> %?&A {
114114 const a: ?&A = null;
......@@ -167,7 +167,7 @@ test "implicitly cast from [0]T to %[]T" {
167167}
168168
169169fn testCastZeroArrayToErrSliceMut() {
170 assert((%%gimmeErrOrSlice()).len == 0);
170 assert((gimmeErrOrSlice() catch unreachable).len == 0);
171171}
172172
173173fn gimmeErrOrSlice() -> %[]u8 {
......@@ -178,14 +178,14 @@ test "peer type resolution: [0]u8, []const u8, and %[]u8" {
178178 {
179179 var data = "hi";
180180 const slice = data[0..];
181 assert((%%peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
182 assert((%%peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
181 assert((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
182 assert((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
183183 }
184184 comptime {
185185 var data = "hi";
186186 const slice = data[0..];
187 assert((%%peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
188 assert((%%peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
187 assert((try peerTypeEmptyArrayAndSliceAndError(true, slice)).len == 0);
188 assert((try peerTypeEmptyArrayAndSliceAndError(false, slice)).len == 1);
189189 }
190190}
191191fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) -> %[]u8 {
......@@ -231,11 +231,11 @@ fn foo(args: ...) {
231231
232232test "peer type resolution: error and [N]T" {
233233 // TODO: implicit %T to %U where T can implicitly cast to U
234 //assert(mem.eql(u8, %%testPeerErrorAndArray(0), "OK"));
235 //comptime assert(mem.eql(u8, %%testPeerErrorAndArray(0), "OK"));
234 //assert(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
235 //comptime assert(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
236236
237 assert(mem.eql(u8, %%testPeerErrorAndArray2(1), "OKK"));
238 comptime assert(mem.eql(u8, %%testPeerErrorAndArray2(1), "OKK"));
237 assert(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK"));
238 comptime assert(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK"));
239239}
240240
241241error BadValue;
test/cases/const_slice_child.zig+1-1
......@@ -21,7 +21,7 @@ fn foo(args: [][]const u8) {
2121}
2222
2323fn bar(argc: usize) {
24 const args = %%debug.global_allocator.alloc([]const u8, argc);
24 const args = debug.global_allocator.alloc([]const u8, argc) catch unreachable;
2525 for (args) |_, i| {
2626 const ptr = argv[i];
2727 args[i] = ptr[0..strlen(ptr)];
test/cases/defer.zig+1-1
......@@ -14,7 +14,7 @@ fn runSomeErrorDefers(x: bool) -> %bool {
1414}
1515
1616test "mixing normal and error defers" {
17 assert(%%runSomeErrorDefers(true));
17 assert(runSomeErrorDefers(true) catch unreachable);
1818 assert(result[0] == 'c');
1919 assert(result[1] == 'a');
2020
test/cases/enum_with_members.zig+2-2
......@@ -19,9 +19,9 @@ test "enum with members" {
1919 const b = ET { .UINT = 42 };
2020 var buf: [20]u8 = undefined;
2121
22 assert(%%a.print(buf[0..]) == 3);
22 assert((a.print(buf[0..]) catch unreachable) == 3);
2323 assert(mem.eql(u8, buf[0..3], "-42"));
2424
25 assert(%%b.print(buf[0..]) == 2);
25 assert((b.print(buf[0..]) catch unreachable) == 2);
2626 assert(mem.eql(u8, buf[0..2], "42"));
2727}
test/cases/error.zig+3-3
......@@ -16,7 +16,7 @@ pub fn baz() -> %i32 {
1616}
1717
1818test "error wrapping" {
19 assert(%%baz() == 15);
19 assert((baz() catch unreachable) == 15);
2020}
2121
2222error ItBroke;
......@@ -65,14 +65,14 @@ fn errBinaryOperatorG(x: bool) -> %isize {
6565
6666
6767test "unwrap simple value from error" {
68 const i = %%unwrapSimpleValueFromErrorDo();
68 const i = unwrapSimpleValueFromErrorDo() catch unreachable;
6969 assert(i == 13);
7070}
7171fn unwrapSimpleValueFromErrorDo() -> %isize { return 13; }
7272
7373
7474test "error return in assignment" {
75 %%doErrReturnInAssignment();
75 doErrReturnInAssignment() catch unreachable;
7676}
7777
7878fn doErrReturnInAssignment() -> %void {
test/cases/ir_block_deps.zig+2-2
......@@ -16,6 +16,6 @@ fn getErrInt() -> %i32 { return 0; }
1616error ItBroke;
1717
1818test "ir block deps" {
19 assert(%%foo(1) == 0);
20 assert(%%foo(2) == 0);
19 assert((foo(1) catch unreachable) == 0);
20 assert((foo(2) catch unreachable) == 0);
2121}
test/cases/misc.zig+2-2
......@@ -258,7 +258,7 @@ test "explicit cast maybe pointers" {
258258}
259259
260260test "generic malloc free" {
261 const a = %%memAlloc(u8, 10);
261 const a = memAlloc(u8, 10) catch unreachable;
262262 memFree(u8, a);
263263}
264264const some_mem : [100]u8 = undefined;
......@@ -417,7 +417,7 @@ test "cast slice to u8 slice" {
417417}
418418
419419test "pointer to void return type" {
420 %%testPointerToVoidReturnType();
420 testPointerToVoidReturnType() catch unreachable;
421421}
422422fn testPointerToVoidReturnType() -> %void {
423423 const a = testPointerToVoidReturnType2();
test/cases/switch_prong_err_enum.zig+1-1
......@@ -22,7 +22,7 @@ fn doThing(form_id: u64) -> %FormValue {
2222}
2323
2424test "switch prong returns error enum" {
25 switch (%%doThing(17)) {
25 switch (doThing(17) catch unreachable) {
2626 FormValue.Address => |payload| { assert(payload == 1); },
2727 else => unreachable,
2828 }
test/cases/switch_prong_implicit_cast.zig+1-1
......@@ -16,7 +16,7 @@ fn foo(id: u64) -> %FormValue {
1616}
1717
1818test "switch prong implicit cast" {
19 const result = switch (%%foo(2)) {
19 const result = switch (foo(2) catch unreachable) {
2020 FormValue.One => false,
2121 FormValue.Two => |x| x,
2222 };
test/cases/union.zig+1-1
......@@ -26,7 +26,7 @@ test "unions embedded in aggregate types" {
2626 Value.Array => |arr| assert(arr[4] == 3),
2727 else => unreachable,
2828 }
29 switch((%%err).val1) {
29 switch((err catch unreachable).val1) {
3030 Value.Int => |x| assert(x == 1234),
3131 else => unreachable,
3232 }
test/cases/while.zig+1-1
......@@ -48,7 +48,7 @@ fn runContinueAndBreakTest() {
4848}
4949
5050test "return with implicit cast from while loop" {
51 %%returnWithImplicitCastFromWhileLoopTest();
51 returnWithImplicitCastFromWhileLoopTest() catch unreachable;
5252}
5353fn returnWithImplicitCastFromWhileLoopTest() -> %void {
5454 while (true) {
test/compare_output.zig+44-44
......@@ -17,8 +17,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
1717 \\
1818 \\pub fn main() -> %void {
1919 \\ privateFunction();
20 \\ const stdout = &(FileOutStream.init(&%%getStdOut()).stream);
21 \\ %%stdout.print("OK 2\n");
20 \\ const stdout = &(FileOutStream.init(&(getStdOut() catch unreachable)).stream);
21 \\ stdout.print("OK 2\n") catch unreachable;
2222 \\}
2323 \\
2424 \\fn privateFunction() {
......@@ -32,8 +32,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
3232 \\// purposefully conflicting function with main.zig
3333 \\// but it's private so it should be OK
3434 \\fn privateFunction() {
35 \\ const stdout = &(FileOutStream.init(&%%getStdOut()).stream);
36 \\ %%stdout.print("OK 1\n");
35 \\ const stdout = &(FileOutStream.init(&(getStdOut() catch unreachable)).stream);
36 \\ stdout.print("OK 1\n") catch unreachable;
3737 \\}
3838 \\
3939 \\pub fn printText() {
......@@ -58,8 +58,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
5858 tc.addSourceFile("foo.zig",
5959 \\use @import("std").io;
6060 \\pub fn foo_function() {
61 \\ const stdout = &(FileOutStream.init(&%%getStdOut()).stream);
62 \\ %%stdout.print("OK\n");
61 \\ const stdout = &(FileOutStream.init(&(getStdOut() catch unreachable)).stream);
62 \\ stdout.print("OK\n") catch unreachable;
6363 \\}
6464 );
6565
......@@ -69,8 +69,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
6969 \\
7070 \\pub fn bar_function() {
7171 \\ if (foo_function()) {
72 \\ const stdout = &(FileOutStream.init(&%%getStdOut()).stream);
73 \\ %%stdout.print("OK\n");
72 \\ const stdout = &(FileOutStream.init(&(getStdOut() catch unreachable)).stream);
73 \\ stdout.print("OK\n") catch unreachable;
7474 \\ }
7575 \\}
7676 );
......@@ -101,8 +101,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
101101 \\pub const a_text = "OK\n";
102102 \\
103103 \\pub fn ok() {
104 \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream);
105 \\ %%stdout.print(b_text);
104 \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream);
105 \\ stdout.print(b_text) catch unreachable;
106106 \\}
107107 );
108108
......@@ -119,8 +119,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
119119 \\const io = @import("std").io;
120120 \\
121121 \\pub fn main() -> %void {
122 \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream);
123 \\ %%stdout.print("Hello, world!\n{d4} {x3} {c}\n", u32(12), u16(0x12), u8('a'));
122 \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream);
123 \\ stdout.print("Hello, world!\n{d4} {x3} {c}\n", u32(12), u16(0x12), u8('a')) catch unreachable;
124124 \\}
125125 , "Hello, world!\n0012 012 a\n");
126126
......@@ -272,8 +272,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
272272 \\ var x_local : i32 = print_ok(x);
273273 \\}
274274 \\fn print_ok(val: @typeOf(x)) -> @typeOf(foo) {
275 \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream);
276 \\ %%stdout.print("OK\n");
275 \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream);
276 \\ stdout.print("OK\n") catch unreachable;
277277 \\ return 0;
278278 \\}
279279 \\const foo : i32 = 0;
......@@ -354,26 +354,26 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
354354 \\pub fn main() -> %void {
355355 \\ const bar = Bar {.field2 = 13,};
356356 \\ const foo = Foo {.field1 = bar,};
357 \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream);
357 \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream);
358358 \\ if (!foo.method()) {
359 \\ %%stdout.print("BAD\n");
359 \\ stdout.print("BAD\n") catch unreachable;
360360 \\ }
361361 \\ if (!bar.method()) {
362 \\ %%stdout.print("BAD\n");
362 \\ stdout.print("BAD\n") catch unreachable;
363363 \\ }
364 \\ %%stdout.print("OK\n");
364 \\ stdout.print("OK\n") catch unreachable;
365365 \\}
366366 , "OK\n");
367367
368368 cases.add("defer with only fallthrough",
369369 \\const io = @import("std").io;
370370 \\pub fn main() -> %void {
371 \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream);
372 \\ %%stdout.print("before\n");
373 \\ defer %%stdout.print("defer1\n");
374 \\ defer %%stdout.print("defer2\n");
375 \\ defer %%stdout.print("defer3\n");
376 \\ %%stdout.print("after\n");
371 \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream);
372 \\ stdout.print("before\n") catch unreachable;
373 \\ defer stdout.print("defer1\n") catch unreachable;
374 \\ defer stdout.print("defer2\n") catch unreachable;
375 \\ defer stdout.print("defer3\n") catch unreachable;
376 \\ stdout.print("after\n") catch unreachable;
377377 \\}
378378 , "before\nafter\ndefer3\ndefer2\ndefer1\n");
379379
......@@ -381,14 +381,14 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
381381 \\const io = @import("std").io;
382382 \\const os = @import("std").os;
383383 \\pub fn main() -> %void {
384 \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream);
385 \\ %%stdout.print("before\n");
386 \\ defer %%stdout.print("defer1\n");
387 \\ defer %%stdout.print("defer2\n");
384 \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream);
385 \\ stdout.print("before\n") catch unreachable;
386 \\ defer stdout.print("defer1\n") catch unreachable;
387 \\ defer stdout.print("defer2\n") catch unreachable;
388388 \\ var args_it = @import("std").os.args();
389389 \\ if (args_it.skip() and !args_it.skip()) return;
390 \\ defer %%stdout.print("defer3\n");
391 \\ %%stdout.print("after\n");
390 \\ defer stdout.print("defer3\n") catch unreachable;
391 \\ stdout.print("after\n") catch unreachable;
392392 \\}
393393 , "before\ndefer2\ndefer1\n");
394394
......@@ -398,13 +398,13 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
398398 \\ do_test() catch return;
399399 \\}
400400 \\fn do_test() -> %void {
401 \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream);
402 \\ %%stdout.print("before\n");
403 \\ defer %%stdout.print("defer1\n");
404 \\ %defer %%stdout.print("deferErr\n");
401 \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream);
402 \\ stdout.print("before\n") catch unreachable;
403 \\ defer stdout.print("defer1\n") catch unreachable;
404 \\ %defer stdout.print("deferErr\n") catch unreachable;
405405 \\ try its_gonna_fail();
406 \\ defer %%stdout.print("defer3\n");
407 \\ %%stdout.print("after\n");
406 \\ defer stdout.print("defer3\n") catch unreachable;
407 \\ stdout.print("after\n") catch unreachable;
408408 \\}
409409 \\error IToldYouItWouldFail;
410410 \\fn its_gonna_fail() -> %void {
......@@ -418,13 +418,13 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
418418 \\ do_test() catch return;
419419 \\}
420420 \\fn do_test() -> %void {
421 \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream);
422 \\ %%stdout.print("before\n");
423 \\ defer %%stdout.print("defer1\n");
424 \\ %defer %%stdout.print("deferErr\n");
421 \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream);
422 \\ stdout.print("before\n") catch unreachable;
423 \\ defer stdout.print("defer1\n") catch unreachable;
424 \\ %defer stdout.print("deferErr\n") catch unreachable;
425425 \\ try its_gonna_pass();
426 \\ defer %%stdout.print("defer3\n");
427 \\ %%stdout.print("after\n");
426 \\ defer stdout.print("defer3\n") catch unreachable;
427 \\ stdout.print("after\n") catch unreachable;
428428 \\}
429429 \\fn its_gonna_pass() -> %void { }
430430 , "before\nafter\ndefer3\ndefer1\n");
......@@ -435,8 +435,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
435435 \\const io = @import("std").io;
436436 \\
437437 \\pub fn main() -> %void {
438 \\ const stdout = &(io.FileOutStream.init(&%%io.getStdOut()).stream);
439 \\ %%stdout.print(foo_txt);
438 \\ const stdout = &(io.FileOutStream.init(&(io.getStdOut() catch unreachable)).stream);
439 \\ stdout.print(foo_txt) catch unreachable;
440440 \\}
441441 , "1234\nabcd\n");
442442
test/compile_errors.zig+2-2
......@@ -1423,10 +1423,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
14231423
14241424 cases.add("ignored assert-err-ok return value",
14251425 \\export fn foo() {
1426 \\ %%bar();
1426 \\ bar() catch unreachable;
14271427 \\}
14281428 \\fn bar() -> %i32 { return 0; }
1429 , ".tmp_source.zig:2:5: error: expression value is ignored");
1429 , ".tmp_source.zig:2:11: error: expression value is ignored");
14301430
14311431 cases.add("ignored statement value",
14321432 \\export fn foo() {
test/standalone/issue_339/test.zig+1-1
......@@ -3,5 +3,5 @@ pub fn panic(msg: []const u8) -> noreturn { @breakpoint(); while (true) {} }
33fn bar() -> %void {}
44
55export fn foo() {
6 %%bar();
6 bar() catch unreachable;
77}
test/tests.zig+69-69
......@@ -54,7 +54,7 @@ error TestFailed;
5454const max_stdout_size = 1 * 1024 * 1024; // 1 MB
5555
5656pub fn addCompareOutputTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step {
57 const cases = %%b.allocator.create(CompareOutputContext);
57 const cases = b.allocator.create(CompareOutputContext) catch unreachable;
5858 *cases = CompareOutputContext {
5959 .b = b,
6060 .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
6868}
6969
7070pub fn addDebugSafetyTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step {
71 const cases = %%b.allocator.create(CompareOutputContext);
71 const cases = b.allocator.create(CompareOutputContext) catch unreachable;
7272 *cases = CompareOutputContext {
7373 .b = b,
7474 .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
8282}
8383
8484pub fn addCompileErrorTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step {
85 const cases = %%b.allocator.create(CompileErrorContext);
85 const cases = b.allocator.create(CompileErrorContext) catch unreachable;
8686 *cases = CompileErrorContext {
8787 .b = b,
8888 .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
9696}
9797
9898pub fn addBuildExampleTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step {
99 const cases = %%b.allocator.create(BuildExamplesContext);
99 const cases = b.allocator.create(BuildExamplesContext) catch unreachable;
100100 *cases = BuildExamplesContext {
101101 .b = b,
102102 .step = b.step("test-build-examples", "Build the examples"),
......@@ -110,7 +110,7 @@ pub fn addBuildExampleTests(b: &build.Builder, test_filter: ?[]const u8) -> &bui
110110}
111111
112112pub fn addAssembleAndLinkTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step {
113 const cases = %%b.allocator.create(CompareOutputContext);
113 const cases = b.allocator.create(CompareOutputContext) catch unreachable;
114114 *cases = CompareOutputContext {
115115 .b = b,
116116 .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) -> &
124124}
125125
126126pub fn addTranslateCTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step {
127 const cases = %%b.allocator.create(TranslateCContext);
127 const cases = b.allocator.create(TranslateCContext) catch unreachable;
128128 *cases = TranslateCContext {
129129 .b = b,
130130 .step = b.step("test-translate-c", "Run the C header file parsing tests"),
......@@ -197,10 +197,10 @@ pub const CompareOutputContext = struct {
197197 };
198198
199199 pub fn addSourceFile(self: &TestCase, filename: []const u8, source: []const u8) {
200 %%self.sources.append(SourceFile {
200 self.sources.append(SourceFile {
201201 .filename = filename,
202202 .source = source,
203 });
203 }) catch unreachable;
204204 }
205205
206206 pub fn setCommandLineArgs(self: &TestCase, args: []const []const u8) {
......@@ -222,7 +222,7 @@ pub const CompareOutputContext = struct {
222222 cli_args: []const []const u8) -> &RunCompareOutputStep
223223 {
224224 const allocator = context.b.allocator;
225 const ptr = %%allocator.create(RunCompareOutputStep);
225 const ptr = allocator.create(RunCompareOutputStep) catch unreachable;
226226 *ptr = RunCompareOutputStep {
227227 .context = context,
228228 .exe_path = exe_path,
......@@ -244,14 +244,14 @@ pub const CompareOutputContext = struct {
244244 var args = ArrayList([]const u8).init(b.allocator);
245245 defer args.deinit();
246246
247 %%args.append(full_exe_path);
247 args.append(full_exe_path) catch unreachable;
248248 for (self.cli_args) |arg| {
249 %%args.append(arg);
249 args.append(arg) catch unreachable;
250250 }
251251
252252 warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
253253
254 const child = %%os.ChildProcess.init(args.toSliceConst(), b.allocator);
254 const child = os.ChildProcess.init(args.toSliceConst(), b.allocator) catch unreachable;
255255 defer child.deinit();
256256
257257 child.stdin_behavior = StdIo.Ignore;
......@@ -267,8 +267,8 @@ pub const CompareOutputContext = struct {
267267 var stdout_file_in_stream = io.FileInStream.init(&??child.stdout);
268268 var stderr_file_in_stream = io.FileInStream.init(&??child.stderr);
269269
270 %%stdout_file_in_stream.stream.readAllBuffer(&stdout, max_stdout_size);
271 %%stderr_file_in_stream.stream.readAllBuffer(&stderr, max_stdout_size);
270 stdout_file_in_stream.stream.readAllBuffer(&stdout, max_stdout_size) catch unreachable;
271 stderr_file_in_stream.stream.readAllBuffer(&stderr, max_stdout_size) catch unreachable;
272272
273273 const term = child.wait() catch |err| {
274274 debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
......@@ -313,7 +313,7 @@ pub const CompareOutputContext = struct {
313313 name: []const u8) -> &DebugSafetyRunStep
314314 {
315315 const allocator = context.b.allocator;
316 const ptr = %%allocator.create(DebugSafetyRunStep);
316 const ptr = allocator.create(DebugSafetyRunStep) catch unreachable;
317317 *ptr = DebugSafetyRunStep {
318318 .context = context,
319319 .exe_path = exe_path,
......@@ -333,7 +333,7 @@ pub const CompareOutputContext = struct {
333333
334334 warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
335335
336 const child = %%os.ChildProcess.init([][]u8{full_exe_path}, b.allocator);
336 const child = os.ChildProcess.init([][]u8{full_exe_path}, b.allocator) catch unreachable;
337337 defer child.deinit();
338338
339339 child.env_map = &b.env_map;
......@@ -416,11 +416,11 @@ pub const CompareOutputContext = struct {
416416 pub fn addCase(self: &CompareOutputContext, case: &const TestCase) {
417417 const b = self.b;
418418
419 const root_src = %%os.path.join(b.allocator, b.cache_root, case.sources.items[0].filename);
419 const root_src = os.path.join(b.allocator, b.cache_root, case.sources.items[0].filename) catch unreachable;
420420
421421 switch (case.special) {
422422 Special.Asm => {
423 const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "assemble-and-link {}", case.name);
423 const annotated_case_name = fmt.allocPrint(self.b.allocator, "assemble-and-link {}", case.name) catch unreachable;
424424 if (self.test_filter) |filter| {
425425 if (mem.indexOf(u8, annotated_case_name, filter) == null)
426426 return;
......@@ -430,7 +430,7 @@ pub const CompareOutputContext = struct {
430430 exe.addAssemblyFile(root_src);
431431
432432 for (case.sources.toSliceConst()) |src_file| {
433 const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename);
433 const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
434434 const write_src = b.addWriteFile(expanded_src_path, src_file.source);
435435 exe.step.dependOn(&write_src.step);
436436 }
......@@ -443,8 +443,8 @@ pub const CompareOutputContext = struct {
443443 },
444444 Special.None => {
445445 for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) |mode| {
446 const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "{} {} ({})",
447 "compare-output", case.name, @tagName(mode));
446 const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {} ({})",
447 "compare-output", case.name, @tagName(mode)) catch unreachable;
448448 if (self.test_filter) |filter| {
449449 if (mem.indexOf(u8, annotated_case_name, filter) == null)
450450 continue;
......@@ -457,7 +457,7 @@ pub const CompareOutputContext = struct {
457457 }
458458
459459 for (case.sources.toSliceConst()) |src_file| {
460 const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename);
460 const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
461461 const write_src = b.addWriteFile(expanded_src_path, src_file.source);
462462 exe.step.dependOn(&write_src.step);
463463 }
......@@ -470,7 +470,7 @@ pub const CompareOutputContext = struct {
470470 }
471471 },
472472 Special.DebugSafety => {
473 const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "safety {}", case.name);
473 const annotated_case_name = fmt.allocPrint(self.b.allocator, "safety {}", case.name) catch unreachable;
474474 if (self.test_filter) |filter| {
475475 if (mem.indexOf(u8, annotated_case_name, filter) == null)
476476 return;
......@@ -482,7 +482,7 @@ pub const CompareOutputContext = struct {
482482 }
483483
484484 for (case.sources.toSliceConst()) |src_file| {
485 const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename);
485 const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
486486 const write_src = b.addWriteFile(expanded_src_path, src_file.source);
487487 exe.step.dependOn(&write_src.step);
488488 }
......@@ -515,14 +515,14 @@ pub const CompileErrorContext = struct {
515515 };
516516
517517 pub fn addSourceFile(self: &TestCase, filename: []const u8, source: []const u8) {
518 %%self.sources.append(SourceFile {
518 self.sources.append(SourceFile {
519519 .filename = filename,
520520 .source = source,
521 });
521 }) catch unreachable;
522522 }
523523
524524 pub fn addExpectedError(self: &TestCase, text: []const u8) {
525 %%self.expected_errors.append(text);
525 self.expected_errors.append(text) catch unreachable;
526526 }
527527 };
528528
......@@ -538,7 +538,7 @@ pub const CompileErrorContext = struct {
538538 case: &const TestCase, build_mode: Mode) -> &CompileCmpOutputStep
539539 {
540540 const allocator = context.b.allocator;
541 const ptr = %%allocator.create(CompileCmpOutputStep);
541 const ptr = allocator.create(CompileCmpOutputStep) catch unreachable;
542542 *ptr = CompileCmpOutputStep {
543543 .step = build.Step.init("CompileCmpOutput", allocator, make),
544544 .context = context,
......@@ -555,25 +555,25 @@ pub const CompileErrorContext = struct {
555555 const self = @fieldParentPtr(CompileCmpOutputStep, "step", step);
556556 const b = self.context.b;
557557
558 const root_src = %%os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename);
559 const obj_path = %%os.path.join(b.allocator, b.cache_root, "test.o");
558 const root_src = os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename) catch unreachable;
559 const obj_path = os.path.join(b.allocator, b.cache_root, "test.o") catch unreachable;
560560
561561 var zig_args = ArrayList([]const u8).init(b.allocator);
562 %%zig_args.append(b.zig_exe);
562 zig_args.append(b.zig_exe) catch unreachable;
563563
564 %%zig_args.append(if (self.case.is_exe) "build-exe" else "build-obj");
565 %%zig_args.append(b.pathFromRoot(root_src));
564 zig_args.append(if (self.case.is_exe) "build-exe" else "build-obj") catch unreachable;
565 zig_args.append(b.pathFromRoot(root_src)) catch unreachable;
566566
567 %%zig_args.append("--name");
568 %%zig_args.append("test");
567 zig_args.append("--name") catch unreachable;
568 zig_args.append("test") catch unreachable;
569569
570 %%zig_args.append("--output");
571 %%zig_args.append(b.pathFromRoot(obj_path));
570 zig_args.append("--output") catch unreachable;
571 zig_args.append(b.pathFromRoot(obj_path)) catch unreachable;
572572
573573 switch (self.build_mode) {
574574 Mode.Debug => {},
575 Mode.ReleaseSafe => %%zig_args.append("--release-safe"),
576 Mode.ReleaseFast => %%zig_args.append("--release-fast"),
575 Mode.ReleaseSafe => zig_args.append("--release-safe") catch unreachable,
576 Mode.ReleaseFast => zig_args.append("--release-fast") catch unreachable,
577577 }
578578
579579 warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
......@@ -582,7 +582,7 @@ pub const CompileErrorContext = struct {
582582 printInvocation(zig_args.toSliceConst());
583583 }
584584
585 const child = %%os.ChildProcess.init(zig_args.toSliceConst(), b.allocator);
585 const child = os.ChildProcess.init(zig_args.toSliceConst(), b.allocator) catch unreachable;
586586 defer child.deinit();
587587
588588 child.env_map = &b.env_map;
......@@ -598,8 +598,8 @@ pub const CompileErrorContext = struct {
598598 var stdout_file_in_stream = io.FileInStream.init(&??child.stdout);
599599 var stderr_file_in_stream = io.FileInStream.init(&??child.stderr);
600600
601 %%stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size);
602 %%stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size);
601 stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size) catch unreachable;
602 stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable;
603603
604604 const term = child.wait() catch |err| {
605605 debug.panic("Unable to spawn {}: {}\n", zig_args.items[0], @errorName(err));
......@@ -660,7 +660,7 @@ pub const CompileErrorContext = struct {
660660 pub fn create(self: &CompileErrorContext, name: []const u8, source: []const u8,
661661 expected_lines: ...) -> &TestCase
662662 {
663 const tc = %%self.b.allocator.create(TestCase);
663 const tc = self.b.allocator.create(TestCase) catch unreachable;
664664 *tc = TestCase {
665665 .name = name,
666666 .sources = ArrayList(TestCase.SourceFile).init(self.b.allocator),
......@@ -697,8 +697,8 @@ pub const CompileErrorContext = struct {
697697 const b = self.b;
698698
699699 for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) |mode| {
700 const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "compile-error {} ({})",
701 case.name, @tagName(mode));
700 const annotated_case_name = fmt.allocPrint(self.b.allocator, "compile-error {} ({})",
701 case.name, @tagName(mode)) catch unreachable;
702702 if (self.test_filter) |filter| {
703703 if (mem.indexOf(u8, annotated_case_name, filter) == null)
704704 continue;
......@@ -708,7 +708,7 @@ pub const CompileErrorContext = struct {
708708 self.step.dependOn(&compile_and_cmp_errors.step);
709709
710710 for (case.sources.toSliceConst()) |src_file| {
711 const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename);
711 const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
712712 const write_src = b.addWriteFile(expanded_src_path, src_file.source);
713713 compile_and_cmp_errors.step.dependOn(&write_src.step);
714714 }
......@@ -740,17 +740,17 @@ pub const BuildExamplesContext = struct {
740740 }
741741
742742 var zig_args = ArrayList([]const u8).init(b.allocator);
743 const rel_zig_exe = %%os.path.relative(b.allocator, b.build_root, b.zig_exe);
744 %%zig_args.append(rel_zig_exe);
745 %%zig_args.append("build");
743 const rel_zig_exe = os.path.relative(b.allocator, b.build_root, b.zig_exe) catch unreachable;
744 zig_args.append(rel_zig_exe) catch unreachable;
745 zig_args.append("build") catch unreachable;
746746
747 %%zig_args.append("--build-file");
748 %%zig_args.append(b.pathFromRoot(build_file));
747 zig_args.append("--build-file") catch unreachable;
748 zig_args.append(b.pathFromRoot(build_file)) catch unreachable;
749749
750 %%zig_args.append("test");
750 zig_args.append("test") catch unreachable;
751751
752752 if (b.verbose) {
753 %%zig_args.append("--verbose");
753 zig_args.append("--verbose") catch unreachable;
754754 }
755755
756756 const run_cmd = b.addCommand(null, b.env_map, zig_args.toSliceConst());
......@@ -765,8 +765,8 @@ pub const BuildExamplesContext = struct {
765765 const b = self.b;
766766
767767 for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) |mode| {
768 const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "build {} ({})",
769 root_src, @tagName(mode));
768 const annotated_case_name = fmt.allocPrint(self.b.allocator, "build {} ({})",
769 root_src, @tagName(mode)) catch unreachable;
770770 if (self.test_filter) |filter| {
771771 if (mem.indexOf(u8, annotated_case_name, filter) == null)
772772 continue;
......@@ -804,14 +804,14 @@ pub const TranslateCContext = struct {
804804 };
805805
806806 pub fn addSourceFile(self: &TestCase, filename: []const u8, source: []const u8) {
807 %%self.sources.append(SourceFile {
807 self.sources.append(SourceFile {
808808 .filename = filename,
809809 .source = source,
810 });
810 }) catch unreachable;
811811 }
812812
813813 pub fn addExpectedLine(self: &TestCase, text: []const u8) {
814 %%self.expected_lines.append(text);
814 self.expected_lines.append(text) catch unreachable;
815815 }
816816 };
817817
......@@ -824,7 +824,7 @@ pub const TranslateCContext = struct {
824824
825825 pub fn create(context: &TranslateCContext, name: []const u8, case: &const TestCase) -> &TranslateCCmpOutputStep {
826826 const allocator = context.b.allocator;
827 const ptr = %%allocator.create(TranslateCCmpOutputStep);
827 const ptr = allocator.create(TranslateCCmpOutputStep) catch unreachable;
828828 *ptr = TranslateCCmpOutputStep {
829829 .step = build.Step.init("ParseCCmpOutput", allocator, make),
830830 .context = context,
......@@ -840,13 +840,13 @@ pub const TranslateCContext = struct {
840840 const self = @fieldParentPtr(TranslateCCmpOutputStep, "step", step);
841841 const b = self.context.b;
842842
843 const root_src = %%os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename);
843 const root_src = os.path.join(b.allocator, b.cache_root, self.case.sources.items[0].filename) catch unreachable;
844844
845845 var zig_args = ArrayList([]const u8).init(b.allocator);
846 %%zig_args.append(b.zig_exe);
846 zig_args.append(b.zig_exe) catch unreachable;
847847
848 %%zig_args.append("translate-c");
849 %%zig_args.append(b.pathFromRoot(root_src));
848 zig_args.append("translate-c") catch unreachable;
849 zig_args.append(b.pathFromRoot(root_src)) catch unreachable;
850850
851851 warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
852852
......@@ -854,7 +854,7 @@ pub const TranslateCContext = struct {
854854 printInvocation(zig_args.toSliceConst());
855855 }
856856
857 const child = %%os.ChildProcess.init(zig_args.toSliceConst(), b.allocator);
857 const child = os.ChildProcess.init(zig_args.toSliceConst(), b.allocator) catch unreachable;
858858 defer child.deinit();
859859
860860 child.env_map = &b.env_map;
......@@ -870,8 +870,8 @@ pub const TranslateCContext = struct {
870870 var stdout_file_in_stream = io.FileInStream.init(&??child.stdout);
871871 var stderr_file_in_stream = io.FileInStream.init(&??child.stderr);
872872
873 %%stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size);
874 %%stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size);
873 stdout_file_in_stream.stream.readAllBuffer(&stdout_buf, max_stdout_size) catch unreachable;
874 stderr_file_in_stream.stream.readAllBuffer(&stderr_buf, max_stdout_size) catch unreachable;
875875
876876 const term = child.wait() catch |err| {
877877 debug.panic("Unable to spawn {}: {}\n", zig_args.toSliceConst()[0], @errorName(err));
......@@ -933,7 +933,7 @@ pub const TranslateCContext = struct {
933933 pub fn create(self: &TranslateCContext, allow_warnings: bool, filename: []const u8, name: []const u8,
934934 source: []const u8, expected_lines: ...) -> &TestCase
935935 {
936 const tc = %%self.b.allocator.create(TestCase);
936 const tc = self.b.allocator.create(TestCase) catch unreachable;
937937 *tc = TestCase {
938938 .name = name,
939939 .sources = ArrayList(TestCase.SourceFile).init(self.b.allocator),
......@@ -966,7 +966,7 @@ pub const TranslateCContext = struct {
966966 pub fn addCase(self: &TranslateCContext, case: &const TestCase) {
967967 const b = self.b;
968968
969 const annotated_case_name = %%fmt.allocPrint(self.b.allocator, "translate-c {}", case.name);
969 const annotated_case_name = fmt.allocPrint(self.b.allocator, "translate-c {}", case.name) catch unreachable;
970970 if (self.test_filter) |filter| {
971971 if (mem.indexOf(u8, annotated_case_name, filter) == null)
972972 return;
......@@ -976,7 +976,7 @@ pub const TranslateCContext = struct {
976976 self.step.dependOn(&translate_c_and_cmp.step);
977977
978978 for (case.sources.toSliceConst()) |src_file| {
979 const expanded_src_path = %%os.path.join(b.allocator, b.cache_root, src_file.filename);
979 const expanded_src_path = os.path.join(b.allocator, b.cache_root, src_file.filename) catch unreachable;
980980 const write_src = b.addWriteFile(expanded_src_path, src_file.source);
981981 translate_c_and_cmp.step.dependOn(&write_src.step);
982982 }