Commit 9e234d4208725b818812765740b474f049d69788 | zig

CMakeLists.txt+2-1

 @@ -521,6 +521,7 @@ install(FILES "${CMAKE_SOURCE_DIR}/std/fmt/errol/index.zig" DESTINATION "${ZIG_S
 install(FILES "${CMAKE_SOURCE_DIR}/std/fmt/errol/lookup.zig" DESTINATION "${ZIG_STD_DEST}/fmt/errol")
 install(FILES "${CMAKE_SOURCE_DIR}/std/fmt/index.zig" DESTINATION "${ZIG_STD_DEST}/fmt")
 install(FILES "${CMAKE_SOURCE_DIR}/std/hash_map.zig" DESTINATION "${ZIG_STD_DEST}")
+install(FILES "${CMAKE_SOURCE_DIR}/std/heap.zig" DESTINATION "${ZIG_STD_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/std/index.zig" DESTINATION "${ZIG_STD_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/std/io.zig" DESTINATION "${ZIG_STD_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/std/linked_list.zig" DESTINATION "${ZIG_STD_DEST}")
 @@ -605,10 +606,10 @@ install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/fixunstfdi.zig" DESTI
 install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/fixunstfsi.zig" DESTINATION "${ZIG_STD_DEST}/special/compiler_rt")
 install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/fixunstfti.zig" DESTINATION "${ZIG_STD_DEST}/special/compiler_rt")
 install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/index.zig" DESTINATION "${ZIG_STD_DEST}/special/compiler_rt")
-install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/udivti3.zig" DESTINATION "${ZIG_STD_DEST}/special/compiler_rt")
 install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/udivmod.zig" DESTINATION "${ZIG_STD_DEST}/special/compiler_rt")
 install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/udivmoddi4.zig" DESTINATION "${ZIG_STD_DEST}/special/compiler_rt")
 install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/udivmodti4.zig" DESTINATION "${ZIG_STD_DEST}/special/compiler_rt")
+install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/udivti3.zig" DESTINATION "${ZIG_STD_DEST}/special/compiler_rt")
 install(FILES "${CMAKE_SOURCE_DIR}/std/special/compiler_rt/umodti3.zig" DESTINATION "${ZIG_STD_DEST}/special/compiler_rt")
 install(FILES "${CMAKE_SOURCE_DIR}/std/special/panic.zig" DESTINATION "${ZIG_STD_DEST}/special")
 install(FILES "${CMAKE_SOURCE_DIR}/std/special/test_runner.zig" DESTINATION "${ZIG_STD_DEST}/special")

example/cat/main.zig+18-13

 @@ -2,47 +2,52 @@ const std = @import("std");
 const io = std.io;
 const mem = std.mem;
 const os = std.os;
+const warn = std.debug.warn;
 pub fn main() -> %void {
     const allocator = &std.debug.global_allocator;
     var args_it = os.args();
     const exe = %return unwrapArg(??args_it.next(allocator));
     var catted_anything = false;
+    var stdout_file = %return io.getStdOut();
+    const stdout = &stdout_file.out_stream;
     while (args_it.next(allocator)) |arg_or_err| {
         const arg = %return unwrapArg(arg_or_err);
         if (mem.eql(u8, arg, "-")) {
             catted_anything = true;
-            %return cat_stream(&io.stdin);
+            var stdin_file = %return io.getStdIn();
+            %return cat_stream(stdout, &stdin_file.in_stream);
         } else if (arg[0] == '-') {
             return usage(exe);
         } else {
-            var is = io.InStream.open(arg, null) %% |err| {
+            var file = io.File.openRead(arg, null) %% |err| {
-                %%io.stderr.printf("Unable to open file: {}\n", @errorName(err));
+                warn("Unable to open file: {}\n", @errorName(err));
                 return err;
             };
-            defer is.close();
+            defer file.close();
             catted_anything = true;
-            %return cat_stream(&is);
+            %return cat_stream(stdout, &file.in_stream);
         }
     }
     if (!catted_anything) {
-        %return cat_stream(&io.stdin);
+        var stdin_file = %return io.getStdIn();
+        %return cat_stream(stdout, &stdin_file.in_stream);
     }
-    %return io.stdout.flush();
 }
 fn usage(exe: []const u8) -> %void {
-    %%io.stderr.printf("Usage: {} [FILE]...\n", exe);
+    warn("Usage: {} [FILE]...\n", exe);
     return error.Invalid;
 }
-fn cat_stream(is: &io.InStream) -> %void {
+fn cat_stream(stdout: &io.OutStream, is: &io.InStream) -> %void {
     var buf: [1024 * 4]u8 = undefined;
     while (true) {
         const bytes_read = is.read(buf[0..]) %% |err| {
-            %%io.stderr.printf("Unable to read from stream: {}\n", @errorName(err));
+            warn("Unable to read from stream: {}\n", @errorName(err));
             return err;
         };
 @@ -50,8 +55,8 @@ fn cat_stream(is: &io.InStream) -> %void {
             break;
         }
-        io.stdout.write(buf[0..bytes_read]) %% |err| {
+        stdout.write(buf[0..bytes_read]) %% |err| {
-            %%io.stderr.printf("Unable to write to stdout: {}\n", @errorName(err));
+            warn("Unable to write to stdout: {}\n", @errorName(err));
             return err;
         };
     }
 @@ -59,7 +64,7 @@ fn cat_stream(is: &io.InStream) -> %void {
 fn unwrapArg(arg: %[]u8) -> %[]u8 {
     return arg %% |err| {
-        %%io.stderr.printf("Unable to parse command line: {}\n", err);
+        warn("Unable to parse command line: {}\n", err);
         return err;
     };
 }

example/guess_number/main.zig+14-8

 @@ -5,7 +5,13 @@ const Rand = std.rand.Rand;
 const os = std.os;
 pub fn main() -> %void {
-    %%io.stdout.printf("Welcome to the Guess Number Game in Zig.\n");
+    var stdout_file = %return io.getStdOut();
+    const stdout = &stdout_file.out_stream;
+    var stdin_file = %return io.getStdIn();
+    const stdin = &stdin_file.in_stream;
+    %return stdout.print("Welcome to the Guess Number Game in Zig.\n");
     var seed_bytes: [@sizeOf(usize)]u8 = undefined;
     %%os.getRandomBytes(seed_bytes[0..]);
 @@ -15,24 +21,24 @@ pub fn main() -> %void {
     const answer = rand.range(u8, 0, 100) + 1;
     while (true) {
-        %%io.stdout.printf("\nGuess a number between 1 and 100: ");
+        %return stdout.print("\nGuess a number between 1 and 100: ");
         var line_buf : [20]u8 = undefined;
-        const line_len = io.stdin.read(line_buf[0..]) %% |err| {
+        const line_len = stdin.read(line_buf[0..]) %% |err| {
-            %%io.stdout.printf("Unable to read from stdin: {}\n", @errorName(err));
+            %return stdout.print("Unable to read from stdin: {}\n", @errorName(err));
             return err;
         };
         const guess = fmt.parseUnsigned(u8, line_buf[0..line_len - 1], 10) %% {
-            %%io.stdout.printf("Invalid number.\n");
+            %return stdout.print("Invalid number.\n");
             continue;
         };
         if (guess > answer) {
-            %%io.stdout.printf("Guess lower.\n");
+            %return stdout.print("Guess lower.\n");
         } else if (guess < answer) {
-            %%io.stdout.printf("Guess higher.\n");
+            %return stdout.print("Guess higher.\n");
         } else {
-            %%io.stdout.printf("You win!\n");
+            %return stdout.print("You win!\n");
             return;
         }
     }

example/hello_world/hello.zig+7-2

...	@@ -1,5 +1,10 @@	...	@@ -1,5 +1,10 @@
1	const io = @import("std").io;	1	const std = @import("std");
2		2
3	pub fn main() -> %void {	3	pub fn main() -> %void {
4	%return io.stdout.printf("Hello, world!\n");	4	// If this program is run without stdout attached, exit with an error.
		5	var stdout_file = %return std.io.getStdOut();
		6	const stdout = &stdout_file.out_stream;
		7	// If this program encounters pipe failure when printing to stdout, exit
		8	// with an error.
		9	%return stdout.print("Hello, world!\n");
5	}	10	}

std/array_list.zig+1-1

...	@@ -70,7 +70,7 @@ pub fn ArrayList(comptime T: type) -> type{	...	@@ -70,7 +70,7 @@ pub fn ArrayList(comptime T: type) -> type{
70	l.len = new_len;	70	l.len = new_len;
71	}	71	}
72		72
73	pub fn resizeDown(l: &Self, new_len: usize) {	73	pub fn shrink(l: &Self, new_len: usize) {
74	assert(new_len <= l.len);	74	assert(new_len <= l.len);
75	l.len = new_len;	75	l.len = new_len;
76	}	76	}

std/buffer.zig+6

...	@@ -71,6 +71,12 @@ pub const Buffer = struct {	...	@@ -71,6 +71,12 @@ pub const Buffer = struct {
71	return self.list.toSliceConst()[0..self.len()];	71	return self.list.toSliceConst()[0..self.len()];
72	}	72	}
73		73
		74	pub fn shrink(self: &Buffer, new_len: usize) {
		75	assert(new_len <= self.len());
		76	self.list.shrink(new_len + 1);
		77	self.list.items[self.len()] = 0;
		78	}
		79
74	pub fn resize(self: &Buffer, new_len: usize) -> %void {	80	pub fn resize(self: &Buffer, new_len: usize) -> %void {
75	%return self.list.resize(new_len + 1);	81	%return self.list.resize(new_len + 1);
76	self.list.items[self.len()] = 0;	82	self.list.items[self.len()] = 0;

std/build.zig+46-45

 @@ -1,17 +1,19 @@
+const std = @import("index.zig");
 const builtin = @import("builtin");
-const io = @import("io.zig");
+const io = std.io;
-const mem = @import("mem.zig");
+const mem = std.mem;
-const debug = @import("debug.zig");
+const debug = std.debug;
 const assert = debug.assert;
-const ArrayList = @import("array_list.zig").ArrayList;
+const warn = std.debug.warn;
-const HashMap = @import("hash_map.zig").HashMap;
+const ArrayList = std.ArrayList;
-const Allocator = @import("mem.zig").Allocator;
+const HashMap = std.HashMap;
-const os = @import("os/index.zig");
+const Allocator = mem.Allocator;
+const os = std.os;
 const StdIo = os.ChildProcess.StdIo;
 const Term = os.ChildProcess.Term;
-const BufSet = @import("buf_set.zig").BufSet;
+const BufSet = std.BufSet;
-const BufMap = @import("buf_map.zig").BufMap;
+const BufMap = std.BufMap;
-const fmt_lib = @import("fmt/index.zig");
+const fmt_lib = std.fmt;
 error ExtraArg;
 error UncleanExit;
 @@ -280,7 +282,7 @@ pub const Builder = struct {
         for (self.installed_files.toSliceConst()) |installed_file| {
             if (self.verbose) {
-                %%io.stderr.printf("rm {}\n", installed_file);
+                warn("rm {}\n", installed_file);
             }
             _ = os.deleteFile(self.allocator, installed_file);
         }
 @@ -290,7 +292,7 @@ pub const Builder = struct {
     fn makeOneStep(self: &Builder, s: &Step) -> %void {
         if (s.loop_flag) {
-            %%io.stderr.printf("Dependency loop detected:\n  {}\n", s.name);
+            warn("Dependency loop detected:\n  {}\n", s.name);
             return error.DependencyLoopDetected;
         }
         s.loop_flag = true;
 @@ -298,7 +300,7 @@ pub const Builder = struct {
         for (s.dependencies.toSlice()) |dep| {
             self.makeOneStep(dep) %% |err| {
                 if (err == error.DependencyLoopDetected) {
-                    %%io.stderr.printf("  {}\n", s.name);
+                    warn("  {}\n", s.name);
                 }
                 return err;
             };
 @@ -315,7 +317,7 @@ pub const Builder = struct {
                 return &top_level_step.step;
             }
         }
-        %%io.stderr.printf("Cannot run step '{}' because it does not exist\n", name);
+        warn("Cannot run step '{}' because it does not exist\n", name);
         return error.InvalidStepName;
     }
 @@ -326,12 +328,12 @@ pub const Builder = struct {
                 const word = it.next() ?? break;
                 if (mem.eql(u8, word, "-isystem")) {
                     const include_path = it.next() ?? {
-                        %%io.stderr.printf("Expected argument after -isystem in NIX_CFLAGS_COMPILE\n");
+                        warn("Expected argument after -isystem in NIX_CFLAGS_COMPILE\n");
                         break;
                     };
                     self.addCIncludePath(include_path);
                 } else {
-                    %%io.stderr.printf("Unrecognized C flag from NIX_CFLAGS_COMPILE: {}\n", word);
+                    warn("Unrecognized C flag from NIX_CFLAGS_COMPILE: {}\n", word);
                     break;
                 }
             }
 @@ -344,7 +346,7 @@ pub const Builder = struct {
                 const word = it.next() ?? break;
                 if (mem.eql(u8, word, "-rpath")) {
                     const rpath = it.next() ?? {
-                        %%io.stderr.printf("Expected argument after -rpath in NIX_LDFLAGS\n");
+                        warn("Expected argument after -rpath in NIX_LDFLAGS\n");
                         break;
                     };
                     self.addRPath(rpath);
 @@ -352,7 +354,7 @@ pub const Builder = struct {
                     const lib_path = word[2..];
                     self.addLibPath(lib_path);
                 } else {
-                    %%io.stderr.printf("Unrecognized C flag from NIX_LDFLAGS: {}\n", word);
+                    warn("Unrecognized C flag from NIX_LDFLAGS: {}\n", word);
                     break;
                 }
             }
 @@ -384,13 +386,13 @@ pub const Builder = struct {
                     } else if (mem.eql(u8, s, "false")) {
                         return false;
                     } else {
-                        %%io.stderr.printf("Expected -D{} to be a boolean, but received '{}'\n", name, s);
+                        warn("Expected -D{} to be a boolean, but received '{}'\n", name, s);
                         self.markInvalidUserInput();
                         return null;
                     }
                 },
                 UserValue.List => {
-                    %%io.stderr.printf("Expected -D{} to be a boolean, but received a list.\n", name);
+                    warn("Expected -D{} to be a boolean, but received a list.\n", name);
                     self.markInvalidUserInput();
                     return null;
                 },
 @@ -399,12 +401,12 @@ pub const Builder = struct {
             TypeId.Float => debug.panic("TODO float options to build script"),
             TypeId.String => switch (entry.value.value) {
                 UserValue.Flag => {
-                    %%io.stderr.printf("Expected -D{} to be a string, but received a boolean.\n", name);
+                    warn("Expected -D{} to be a string, but received a boolean.\n", name);
                     self.markInvalidUserInput();
                     return null;
                 },
                 UserValue.List => {
-                    %%io.stderr.printf("Expected -D{} to be a string, but received a list.\n", name);
+                    warn("Expected -D{} to be a string, but received a list.\n", name);
                     self.markInvalidUserInput();
                     return null;
                 },
 @@ -437,7 +439,7 @@ pub const Builder = struct {
         } else if (!release_fast and !release_safe) {
             builtin.Mode.Debug
         } else {
-            %%io.stderr.printf("Both -Drelease-safe and -Drelease-fast specified");
+            warn("Both -Drelease-safe and -Drelease-fast specified");
             self.markInvalidUserInput();
             builtin.Mode.Debug
         };
 @@ -474,7 +476,7 @@ pub const Builder = struct {
                     });
                 },
                 UserValue.Flag => {
-                    %%io.stderr.printf("Option '-D{}={}' conflicts with flag '-D{}'.\n", name, value, name);
+                    warn("Option '-D{}={}' conflicts with flag '-D{}'.\n", name, value, name);
                     return true;
                 },
             }
 @@ -490,11 +492,11 @@ pub const Builder = struct {
         })) |*prev_value| {
             switch (prev_value.value) {
                 UserValue.Scalar => |s| {
-                    %%io.stderr.printf("Flag '-D{}' conflicts with option '-D{}={}'.\n", name, name, s);
+                    warn("Flag '-D{}' conflicts with option '-D{}={}'.\n", name, name, s);
                     return true;
                 },
                 UserValue.List => {
-                    %%io.stderr.printf("Flag '-D{}' conflicts with multiple options of the same name.\n", name);
+                    warn("Flag '-D{}' conflicts with multiple options of the same name.\n", name);
                     return true;
                 },
                 UserValue.Flag => {},
 @@ -536,7 +538,7 @@ pub const Builder = struct {
         while (true) {
             const entry = it.next() ?? break;
             if (!entry.value.used) {
-                %%io.stderr.printf("Invalid option: -D{}\n\n", entry.key);
+                warn("Invalid option: -D{}\n\n", entry.key);
                 self.markInvalidUserInput();
             }
         }
 @@ -549,11 +551,11 @@ pub const Builder = struct {
     }
     fn printCmd(cwd: ?[]const u8, argv: []const []const u8) {
-        if (cwd) |yes_cwd| %%io.stderr.print("cd {} && ", yes_cwd);
+        if (cwd) |yes_cwd| warn("cd {} && ", yes_cwd);
         for (argv) |arg| {
-            %%io.stderr.print("{} ", arg);
+            warn("{} ", arg);
         }
-        %%io.stderr.printf("\n");
+        warn("\n");
     }
     fn spawnChildEnvMap(self: &Builder, cwd: ?[]const u8, env_map: &const BufMap,
 @@ -570,20 +572,20 @@ pub const Builder = struct {
         child.env_map = env_map;
         const term = child.spawnAndWait() %% |err| {
-            %%io.stderr.printf("Unable to spawn {}: {}\n", argv[0], @errorName(err));
+            warn("Unable to spawn {}: {}\n", argv[0], @errorName(err));
             return err;
         };
         switch (term) {
             Term.Exited => |code| {
                 if (code != 0) {
-                    %%io.stderr.printf("The following command exited with error code {}:\n", code);
+                    warn("The following command exited with error code {}:\n", code);
                     printCmd(cwd, argv);
                     return error.UncleanExit;
                 }
             },
             else => {
-                %%io.stderr.printf("The following command terminated unexpectedly:\n");
+                warn("The following command terminated unexpectedly:\n");
                 printCmd(cwd, argv);
                 return error.UncleanExit;
 @@ -594,7 +596,7 @@ pub const Builder = struct {
     pub fn makePath(self: &Builder, path: []const u8) -> %void {
         os.makePath(self.allocator, self.pathFromRoot(path)) %% |err| {
-            %%io.stderr.printf("Unable to create path {}: {}\n", path, @errorName(err));
+            warn("Unable to create path {}: {}\n", path, @errorName(err));
             return err;
         };
     }
 @@ -633,17 +635,17 @@ pub const Builder = struct {
     fn copyFileMode(self: &Builder, source_path: []const u8, dest_path: []const u8, mode: usize) -> %void {
         if (self.verbose) {
-            %%io.stderr.printf("cp {} {}\n", source_path, dest_path);
+            warn("cp {} {}\n", source_path, dest_path);
         }
         const dirname = os.path.dirname(dest_path);
         const abs_source_path = self.pathFromRoot(source_path);
         os.makePath(self.allocator, dirname) %% |err| {
-            %%io.stderr.printf("Unable to create path {}: {}\n", dirname, @errorName(err));
+            warn("Unable to create path {}: {}\n", dirname, @errorName(err));
             return err;
         };
         os.copyFileMode(self.allocator, abs_source_path, dest_path, mode) %% |err| {
-            %%io.stderr.printf("Unable to copy {} to {}: {}\n", abs_source_path, dest_path, @errorName(err));
+            warn("Unable to copy {} to {}: {}\n", abs_source_path, dest_path, @errorName(err));
             return err;
         };
     }
 @@ -1103,7 +1105,7 @@ pub const LibExeObjStep = struct {
         assert(self.is_zig);
         if (self.root_src == null and self.object_files.len == 0 and self.assembly_files.len == 0) {
-            %%io.stderr.printf("{}: linker needs 1 or more objects to link\n", self.step.name);
+            warn("{}: linker needs 1 or more objects to link\n", self.step.name);
             return error.NeedAnObject;
         }
 @@ -1799,11 +1801,11 @@ pub const WriteFileStep = struct {
         const full_path = self.builder.pathFromRoot(self.file_path);
         const full_path_dir = os.path.dirname(full_path);
         os.makePath(self.builder.allocator, full_path_dir) %% |err| {
-            %%io.stderr.printf("unable to make path {}: {}\n", full_path_dir, @errorName(err));
+            warn("unable to make path {}: {}\n", full_path_dir, @errorName(err));
             return err;
         };
         io.writeFile(full_path, self.data, self.builder.allocator) %% |err| {
-            %%io.stderr.printf("unable to write {}: {}\n", full_path, @errorName(err));
+            warn("unable to write {}: {}\n", full_path, @errorName(err));
             return err;
         };
     }
 @@ -1824,8 +1826,7 @@ pub const LogStep = struct {
     fn make(step: &Step) -> %void {
         const self = @fieldParentPtr(LogStep, "step", step);
-        %%io.stderr.write(self.data);
+        warn("{}", self.data);
-        %%io.stderr.flush();
     }
 };
 @@ -1847,7 +1848,7 @@ pub const RemoveDirStep = struct {
         const full_path = self.builder.pathFromRoot(self.dir_path);
         os.deleteTree(self.builder.allocator, full_path) %% |err| {
-            %%io.stderr.printf("Unable to remove {}: {}\n", full_path, @errorName(err));
+            warn("Unable to remove {}: {}\n", full_path, @errorName(err));
             return err;
         };
     }
 @@ -1896,13 +1897,13 @@ fn doAtomicSymLinks(allocator: &Allocator, output_path: []const u8, filename_maj
     // sym link for libfoo.so.1 to libfoo.so.1.2.3
     const major_only_path = %%os.path.join(allocator, out_dir, filename_major_only);
     os.atomicSymLink(allocator, out_basename, major_only_path) %% |err| {
-        %%io.stderr.printf("Unable to symlink {} -> {}\n", major_only_path, out_basename);
+        warn("Unable to symlink {} -> {}\n", major_only_path, out_basename);
         return err;
     };
     // sym link for libfoo.so to libfoo.so.1
     const name_only_path = %%os.path.join(allocator, out_dir, filename_name_only);
     os.atomicSymLink(allocator, filename_major_only, name_only_path) %% |err| {
-        %%io.stderr.printf("Unable to symlink {} -> {}\n", name_only_path, filename_major_only);
+        warn("Unable to symlink {} -> {}\n", name_only_path, filename_major_only);
         return err;
     };
 }

std/debug.zig+101-98

 @@ -1,10 +1,11 @@
-const math = @import("math/index.zig");
+const std = @import("index.zig");
-const mem = @import("mem.zig");
+const math = std.math;
-const io = @import("io.zig");
+const mem = std.mem;
-const os = @import("os/index.zig");
+const io = std.io;
+const os = std.os;
 const elf = @import("elf.zig");
 const DW = @import("dwarf.zig");
-const ArrayList = @import("array_list.zig").ArrayList;
+const ArrayList = std.ArrayList;
 const builtin = @import("builtin");
 error MissingDebugInfo;
 @@ -12,10 +13,42 @@ error InvalidDebugInfo;
 error UnsupportedDebugInfo;
+/// Tries to write to stderr, unbuffered, and ignores any error returned.
+/// Does not append a newline.
+/// TODO atomic/multithread support
+var stderr_file: io.File = undefined;
+var stderr_stream: ?&io.OutStream = null;
+pub fn warn(comptime fmt: []const u8, args: ...) {
+    const stderr = getStderrStream() %% return;
+    stderr.print(fmt, args) %% return;
+}
+fn getStderrStream() -> %&io.OutStream {
+    if (stderr_stream) |st| {
+        return st;
+    } else {
+        stderr_file = %return io.getStdErr();
+        const st = &stderr_file.out_stream;
+        stderr_stream = st;
+        return st;
+    };
+}
+/// Tries to print a stack trace to stderr, unbuffered, and ignores any error returned.
+pub fn dumpStackTrace() {
+    const stderr = getStderrStream() %% return;
+    writeStackTrace(stderr, &global_allocator, stderr_file.isTty(), 1) %% return;
+}
+/// This function invokes undefined behavior when `ok` is `false`.
+/// In Debug and ReleaseSafe modes, calls to this function are always
+/// generated, and the `unreachable` statement triggers a panic.
+/// In ReleaseFast and ReleaseSmall modes, calls to this function can be
+/// optimized away.
 pub fn assert(ok: bool) {
     if (!ok) {
         // In ReleaseFast test mode, we still want assert(false) to crash, so
         // we insert an explicit call to @panic instead of unreachable.
+        // TODO we should use `assertOrPanic` in tests and remove this logic.
         if (builtin.is_test) {
             @panic("assertion failure")
         } else {
 @@ -24,6 +57,14 @@ pub fn assert(ok: bool) {
     }
 }
+/// Call this function when you want to panic if the condition is not true.
+/// If `ok` is `false`, this function will panic in every release mode.
+pub fn assertOrPanic(ok: bool) {
+    if (!ok) {
+        @panic("assertion failure");
+    }
+}
 var panicking = false;
 /// This is the default panic implementation.
 pub fn panic(comptime format: []const u8, args: ...) -> noreturn {
 @@ -41,18 +82,13 @@ pub fn panic(comptime format: []const u8, args: ...) -> noreturn {
         panicking = true;
     }
-    %%io.stderr.printf(format ++ "\n", args);
+    const stderr = getStderrStream() %% os.abort();
-    %%writeStackTrace(&io.stderr, &global_allocator, io.stderr.isTty() %% false, 1);
+    stderr.print(format ++ "\n", args) %% os.abort();
-    %%io.stderr.flush();
+    writeStackTrace(stderr, &global_allocator, stderr_file.isTty(), 1) %% os.abort();
     os.abort();
 }
-pub fn printStackTrace() -> %void {
-    %return writeStackTrace(&io.stderr, &global_allocator, io.stderr.isTty() %% false, 1);
-    %return io.stderr.flush();
-}
 const GREEN = "\x1b[32;1m";
 const WHITE = "\x1b[37;1m";
 const DIM = "\x1b[2m";
 @@ -69,7 +105,7 @@ pub fn writeStackTrace(out_stream: &io.OutStream, allocator: &mem.Allocator, tty
     switch (builtin.object_format) {
         builtin.ObjectFormat.elf => {
             var stack_trace = ElfStackTrace {
-                .self_exe_stream = undefined,
+                .self_exe_file = undefined,
                 .elf = undefined,
                 .debug_info = undefined,
                 .debug_abbrev = undefined,
 @@ -79,10 +115,10 @@ pub fn writeStackTrace(out_stream: &io.OutStream, allocator: &mem.Allocator, tty
                 .compile_unit_list = ArrayList(CompileUnit).init(allocator),
             };
             const st = &stack_trace;
-            st.self_exe_stream = %return io.openSelfExe();
+            st.self_exe_file = %return os.openSelfExe();
-            defer st.self_exe_stream.close();
+            defer st.self_exe_file.close();
-            %return st.elf.openStream(allocator, &st.self_exe_stream);
+            %return st.elf.openFile(allocator, &st.self_exe_file);
             defer st.elf.close();
             st.debug_info = (%return st.elf.findSection(".debug_info")) ?? return error.MissingDebugInfo;
 @@ -109,7 +145,6 @@ pub fn writeStackTrace(out_stream: &io.OutStream, allocator: &mem.Allocator, tty
                 const compile_unit = findCompileUnit(st, return_address) ?? {
                     %return out_stream.print("???:?:?: " ++ DIM ++ ptr_hex ++ " in ??? (???)" ++ RESET ++ "\n    ???\n\n",
                         return_address);
-                    %return out_stream.flush();
                     continue;
                 };
                 const compile_unit_name = %return compile_unit.die.getAttrString(st, DW.AT_name);
 @@ -139,7 +174,6 @@ pub fn writeStackTrace(out_stream: &io.OutStream, allocator: &mem.Allocator, tty
                     },
                     else => return err,
                 };
-                %return out_stream.flush();
             }
         },
         builtin.ObjectFormat.coff => {
 @@ -158,7 +192,7 @@ pub fn writeStackTrace(out_stream: &io.OutStream, allocator: &mem.Allocator, tty
 }
 fn printLineFromFile(allocator: &mem.Allocator, out_stream: &io.OutStream, line_info: &const LineInfo) -> %void {
-    var f = %return io.InStream.open(line_info.file_name, allocator);
+    var f = %return io.File.openRead(line_info.file_name, allocator);
     defer f.close();
     // TODO fstat and make sure that the file has the correct size
 @@ -167,7 +201,7 @@ fn printLineFromFile(allocator: &mem.Allocator, out_stream: &io.OutStream, line_
     var column: usize = 1;
     var abs_index: usize = 0;
     while (true) {
-        const amt_read = %return f.read(buf[0..]);
+        const amt_read = %return f.in_stream.read(buf[0..]);
         const slice = buf[0..amt_read];
         for (slice) |byte| {
 @@ -191,7 +225,7 @@ fn printLineFromFile(allocator: &mem.Allocator, out_stream: &io.OutStream, line_
 }
 const ElfStackTrace = struct {
-    self_exe_stream: io.InStream,
+    self_exe_file: io.File,
     elf: elf.Elf,
     debug_info: &elf.SectionHeader,
     debug_abbrev: &elf.SectionHeader,
 @@ -205,7 +239,7 @@ const ElfStackTrace = struct {
     }
     pub fn readString(self: &ElfStackTrace) -> %[]u8 {
-        return readStringRaw(self.allocator(), &self.self_exe_stream);
+        return readStringRaw(self.allocator(), &self.self_exe_file.in_stream);
     }
 };
 @@ -424,7 +458,7 @@ fn readStringRaw(allocator: &mem.Allocator, in_stream: &io.InStream) -> %[]u8 {
 fn getString(st: &ElfStackTrace, offset: u64) -> %[]u8 {
     const pos = st.debug_str.offset + offset;
-    %return st.self_exe_stream.seekTo(pos);
+    %return st.self_exe_file.seekTo(pos);
     return st.readString();
 }
 @@ -533,7 +567,7 @@ fn parseFormValue(allocator: &mem.Allocator, in_stream: &io.InStream, form_id: u
 }
 fn parseAbbrevTable(st: &ElfStackTrace) -> %AbbrevTable {
-    const in_stream = &st.self_exe_stream;
+    const in_stream = &st.self_exe_file.in_stream;
     var result = AbbrevTable.init(st.allocator());
     while (true) {
         const abbrev_code = %return readULeb128(in_stream);
 @@ -568,7 +602,7 @@ fn getAbbrevTable(st: &ElfStackTrace, abbrev_offset: u64) -> %&const AbbrevTable
             return &header.table;
         }
     }
-    %return st.self_exe_stream.seekTo(st.debug_abbrev.offset + abbrev_offset);
+    %return st.self_exe_file.seekTo(st.debug_abbrev.offset + abbrev_offset);
     %return st.abbrev_table_list.append(AbbrevTableHeader {
         .offset = abbrev_offset,
         .table = %return parseAbbrevTable(st),
 @@ -585,8 +619,8 @@ fn getAbbrevTableEntry(abbrev_table: &const AbbrevTable, abbrev_code: u64) -> ?&
 }
 fn parseDie(st: &ElfStackTrace, abbrev_table: &const AbbrevTable, is_64: bool) -> %Die {
-    const in_stream = &st.self_exe_stream;
+    const in_file = &st.self_exe_file;
-    const abbrev_code = %return readULeb128(in_stream);
+    const abbrev_code = %return readULeb128(&in_file.in_stream);
     const table_entry = getAbbrevTableEntry(abbrev_table, abbrev_code) ?? return error.InvalidDebugInfo;
     var result = Die {
 @@ -598,7 +632,7 @@ fn parseDie(st: &ElfStackTrace, abbrev_table: &const AbbrevTable, is_64: bool) -
     for (table_entry.attrs.toSliceConst()) |attr, i| {
         result.attrs.items[i] = Die.Attr {
             .id = attr.attr_id,
-            .value = %return parseFormValue(st.allocator(), &st.self_exe_stream, attr.form_id, is_64),
+            .value = %return parseFormValue(st.allocator(), &st.self_exe_file.in_stream, attr.form_id, is_64),
         };
     }
     return result;
 @@ -607,16 +641,16 @@ fn parseDie(st: &ElfStackTrace, abbrev_table: &const AbbrevTable, is_64: bool) -
 fn getLineNumberInfo(st: &ElfStackTrace, compile_unit: &const CompileUnit, target_address: usize) -> %LineInfo {
     const compile_unit_cwd = %return compile_unit.die.getAttrString(st, DW.AT_comp_dir);
-    const in_stream = &st.self_exe_stream;
+    const in_file = &st.self_exe_file;
     const debug_line_end = st.debug_line.offset + st.debug_line.size;
     var this_offset = st.debug_line.offset;
     var this_index: usize = 0;
     while (this_offset < debug_line_end) : (this_index += 1) {
-        %return in_stream.seekTo(this_offset);
+        %return in_file.seekTo(this_offset);
         var is_64: bool = undefined;
-        const unit_length = %return readInitialLength(in_stream, &is_64);
+        const unit_length = %return readInitialLength(&in_file.in_stream, &is_64);
         if (unit_length == 0)
             return error.MissingDebugInfo;
         const next_offset = unit_length + (if (is_64) usize(12) else usize(4));
 @@ -626,28 +660,28 @@ fn getLineNumberInfo(st: &ElfStackTrace, compile_unit: &const CompileUnit, targe
             continue;
         }
-        const version = %return in_stream.readInt(st.elf.is_big_endian, u16);
+        const version = %return in_file.in_stream.readInt(st.elf.is_big_endian, u16);
         if (version != 2) return error.InvalidDebugInfo;
-        const prologue_length = %return in_stream.readInt(st.elf.is_big_endian, u32);
+        const prologue_length = %return in_file.in_stream.readInt(st.elf.is_big_endian, u32);
-        const prog_start_offset = (%return in_stream.getPos()) + prologue_length;
+        const prog_start_offset = (%return in_file.getPos()) + prologue_length;
-        const minimum_instruction_length = %return in_stream.readByte();
+        const minimum_instruction_length = %return in_file.in_stream.readByte();
         if (minimum_instruction_length == 0) return error.InvalidDebugInfo;
-        const default_is_stmt = (%return in_stream.readByte()) != 0;
+        const default_is_stmt = (%return in_file.in_stream.readByte()) != 0;
-        const line_base = %return in_stream.readByteSigned();
+        const line_base = %return in_file.in_stream.readByteSigned();
-        const line_range = %return in_stream.readByte();
+        const line_range = %return in_file.in_stream.readByte();
         if (line_range == 0)
             return error.InvalidDebugInfo;
-        const opcode_base = %return in_stream.readByte();
+        const opcode_base = %return in_file.in_stream.readByte();
         const standard_opcode_lengths = %return st.allocator().alloc(u8, opcode_base - 1);
         {var i: usize = 0; while (i < opcode_base - 1) : (i += 1) {
-            standard_opcode_lengths[i] = %return in_stream.readByte();
+            standard_opcode_lengths[i] = %return in_file.in_stream.readByte();
         }}
         var include_directories = ArrayList([]u8).init(st.allocator());
 @@ -667,9 +701,9 @@ fn getLineNumberInfo(st: &ElfStackTrace, compile_unit: &const CompileUnit, targe
             const file_name = %return st.readString();
             if (file_name.len == 0)
                 break;
-            const dir_index = %return readULeb128(in_stream);
+            const dir_index = %return readULeb128(&in_file.in_stream);
-            const mtime = %return readULeb128(in_stream);
+            const mtime = %return readULeb128(&in_file.in_stream);
-            const len_bytes = %return readULeb128(in_stream);
+            const len_bytes = %return readULeb128(&in_file.in_stream);
             %return file_entries.append(FileEntry {
                 .file_name = file_name,
                 .dir_index = dir_index,
 @@ -678,42 +712,32 @@ fn getLineNumberInfo(st: &ElfStackTrace, compile_unit: &const CompileUnit, targe
             });
         }
-        %return in_stream.seekTo(prog_start_offset);
+        %return in_file.seekTo(prog_start_offset);
         while (true) {
-            //const pos = (%return in_stream.getPos()) - this_offset;
+            const opcode = %return in_file.in_stream.readByte();
-            //if (pos == 0x1a3) @breakpoint();
-            //%%io.stderr.printf("\n{x8}\n", pos);
-            const opcode = %return in_stream.readByte();
             var sub_op: u8 = undefined; // TODO move this to the correct scope and fix the compiler crash
             if (opcode == DW.LNS_extended_op) {
-                const op_size = %return readULeb128(in_stream);
+                const op_size = %return readULeb128(&in_file.in_stream);
                 if (op_size < 1)
                     return error.InvalidDebugInfo;
-                sub_op = %return in_stream.readByte();
+                sub_op = %return in_file.in_stream.readByte();
                 switch (sub_op) {
                     DW.LNE_end_sequence => {
-                        //%%io.stdout.printf("  [0x{x8}]  End Sequence\n", pos);
                         prog.end_sequence = true;
                         if (%return prog.checkLineMatch()) |info| return info;
                         return error.MissingDebugInfo;
                     },
                     DW.LNE_set_address => {
-                        const addr = %return in_stream.readInt(st.elf.is_big_endian, usize);
+                        const addr = %return in_file.in_stream.readInt(st.elf.is_big_endian, usize);
                         prog.address = addr;
-                        //%%io.stdout.printf("  [0x{x8}]  Extended opcode {}: set Address to 0x{x}\n",
-                        //    pos, sub_op, addr);
                     },
                     DW.LNE_define_file => {
-                        //%%io.stdout.printf("  [0x{x8}]  Define File\n", pos);
                         const file_name = %return st.readString();
-                        const dir_index = %return readULeb128(in_stream);
+                        const dir_index = %return readULeb128(&in_file.in_stream);
-                        const mtime = %return readULeb128(in_stream);
+                        const mtime = %return readULeb128(&in_file.in_stream);
-                        const len_bytes = %return readULeb128(in_stream);
+                        const len_bytes = %return readULeb128(&in_file.in_stream);
                         %return file_entries.append(FileEntry {
                             .file_name = file_name,
                             .dir_index = dir_index,
 @@ -723,7 +747,7 @@ fn getLineNumberInfo(st: &ElfStackTrace, compile_unit: &const CompileUnit, targe
                     },
                     else => {
                         const fwd_amt = math.cast(isize, op_size - 1) %% return error.InvalidDebugInfo;
-                        %return in_stream.seekForward(fwd_amt);
+                        %return in_file.seekForward(fwd_amt);
                     },
                 }
             } else if (opcode >= opcode_base) {
 @@ -733,48 +757,32 @@ fn getLineNumberInfo(st: &ElfStackTrace, compile_unit: &const CompileUnit, targe
                 const inc_line = i32(line_base) + i32(adjusted_opcode % line_range);
                 prog.line += inc_line;
                 prog.address += inc_addr;
-                //%%io.stdout.printf(
-                //    "  [0x{x8}]  Special opcode {}: advance Address by {} to 0x{x} and Line by {} to {}\n",
-                //    pos, adjusted_opcode, inc_addr, prog.address, inc_line, prog.line);
                 if (%return prog.checkLineMatch()) |info| return info;
                 prog.basic_block = false;
             } else {
                 switch (opcode) {
                     DW.LNS_copy => {
-                        //%%io.stdout.printf("  [0x{x8}]  Copy\n", pos);
                         if (%return prog.checkLineMatch()) |info| return info;
                         prog.basic_block = false;
                     },
                     DW.LNS_advance_pc => {
-                        const arg = %return readULeb128(in_stream);
+                        const arg = %return readULeb128(&in_file.in_stream);
                         prog.address += arg * minimum_instruction_length;
-                        //%%io.stdout.printf("  [0x{x8}]  Advance PC by {} to 0x{x}\n", pos, arg, prog.address);
                     },
                     DW.LNS_advance_line => {
-                        const arg = %return readILeb128(in_stream);
+                        const arg = %return readILeb128(&in_file.in_stream);
                         prog.line += arg;
-                        //%%io.stdout.printf("  [0x{x8}]  Advance Line by {} to {}\n", pos, arg, prog.line);
                     },
                     DW.LNS_set_file => {
-                        const arg = %return readULeb128(in_stream);
+                        const arg = %return readULeb128(&in_file.in_stream);
                         prog.file = arg;
-                        //%%io.stdout.printf("  [0x{x8}]  Set File Name to entry {} in the File Name Table\n",
-                        //    pos, arg);
                     },
                     DW.LNS_set_column => {
-                        const arg = %return readULeb128(in_stream);
+                        const arg = %return readULeb128(&in_file.in_stream);
                         prog.column = arg;
-                        //%%io.stdout.printf("  [0x{x8}]  Set column to {}\n", pos, arg);
                     },
                     DW.LNS_negate_stmt => {
                         prog.is_stmt = !prog.is_stmt;
-                        //%%io.stdout.printf("  [0x{x8}]  Set is_stmt to {}\n", pos, if (prog.is_stmt) u8(1) else u8(0));
                     },
                     DW.LNS_set_basic_block => {
                         prog.basic_block = true;
 @@ -782,23 +790,18 @@ fn getLineNumberInfo(st: &ElfStackTrace, compile_unit: &const CompileUnit, targe
                     DW.LNS_const_add_pc => {
                         const inc_addr = minimum_instruction_length * ((255 - opcode_base) / line_range);
                         prog.address += inc_addr;
-                        //%%io.stdout.printf("  [0x{x8}]  Advance PC by constant {} to 0x{x}\n",
-                        //    pos, inc_addr, prog.address);
                     },
                     DW.LNS_fixed_advance_pc => {
-                        const arg = %return in_stream.readInt(st.elf.is_big_endian, u16);
+                        const arg = %return in_file.in_stream.readInt(st.elf.is_big_endian, u16);
                         prog.address += arg;
                     },
                     DW.LNS_set_prologue_end => {
-                        //%%io.stdout.printf("  [0x{x8}]  Set prologue_end to true\n", pos);
                     },
                     else => {
                         if (opcode - 1 >= standard_opcode_lengths.len)
                             return error.InvalidDebugInfo;
-                        //%%io.stdout.printf("  [0x{x8}]  unknown op code {}\n", pos, opcode);
                         const len_bytes = standard_opcode_lengths[opcode - 1];
-                        %return in_stream.seekForward(len_bytes);
+                        %return in_file.seekForward(len_bytes);
                     },
                 }
             }
 @@ -815,30 +818,30 @@ fn scanAllCompileUnits(st: &ElfStackTrace) -> %void {
     var this_unit_offset = st.debug_info.offset;
     var cu_index: usize = 0;
     while (this_unit_offset < debug_info_end) {
-        %return st.self_exe_stream.seekTo(this_unit_offset);
+        %return st.self_exe_file.seekTo(this_unit_offset);
         var is_64: bool = undefined;
-        const unit_length = %return readInitialLength(&st.self_exe_stream, &is_64);
+        const unit_length = %return readInitialLength(&st.self_exe_file.in_stream, &is_64);
         if (unit_length == 0)
             return;
         const next_offset = unit_length + (if (is_64) usize(12) else usize(4));
-        const version = %return st.self_exe_stream.readInt(st.elf.is_big_endian, u16);
+        const version = %return st.self_exe_file.in_stream.readInt(st.elf.is_big_endian, u16);
         if (version < 2 or version > 5) return error.InvalidDebugInfo;
         const debug_abbrev_offset = if (is_64) {
-            %return st.self_exe_stream.readInt(st.elf.is_big_endian, u64)
+            %return st.self_exe_file.in_stream.readInt(st.elf.is_big_endian, u64)
         } else {
-            %return st.self_exe_stream.readInt(st.elf.is_big_endian, u32)
+            %return st.self_exe_file.in_stream.readInt(st.elf.is_big_endian, u32)
         };
-        const address_size = %return st.self_exe_stream.readByte();
+        const address_size = %return st.self_exe_file.in_stream.readByte();
         if (address_size != @sizeOf(usize)) return error.InvalidDebugInfo;
-        const compile_unit_pos = %return st.self_exe_stream.getPos();
+        const compile_unit_pos = %return st.self_exe_file.getPos();
         const abbrev_table = %return getAbbrevTable(st, debug_abbrev_offset);
-        %return st.self_exe_stream.seekTo(compile_unit_pos);
+        %return st.self_exe_file.seekTo(compile_unit_pos);
         const compile_unit_die = %return st.allocator().create(Die);
         *compile_unit_die = %return parseDie(st, abbrev_table, is_64);

std/elf.zig+61-59

 @@ -1,7 +1,9 @@
-const io = @import("io.zig");
+const std = @import("index.zig");
-const math = @import("math/index.zig");
+const io = std.io;
-const mem = @import("mem.zig");
+const math = std.math;
-const debug = @import("debug.zig");
+const mem = std.mem;
+const debug = std.debug;
+const InStream = std.stream.InStream;
 error InvalidFormat;
 @@ -62,7 +64,7 @@ pub const SectionHeader = struct {
 };
 pub const Elf = struct {
-    in_stream: &io.InStream,
+    in_file: &io.File,
     auto_close_stream: bool,
     is_64: bool,
     is_big_endian: bool,
 @@ -75,44 +77,44 @@ pub const Elf = struct {
     string_section: &SectionHeader,
     section_headers: []SectionHeader,
     allocator: &mem.Allocator,
-    prealloc_stream: io.InStream,
+    prealloc_file: io.File,
     /// Call close when done.
-    pub fn openFile(elf: &Elf, allocator: &mem.Allocator, path: []const u8) -> %void {
+    pub fn openPath(elf: &Elf, allocator: &mem.Allocator, path: []const u8) -> %void {
-        %return elf.prealloc_stream.open(path);
+        %return elf.prealloc_file.open(path);
-        %return elf.openStream(allocator, &elf.prealloc_stream);
+        %return elf.openFile(allocator, &elf.prealloc_file);
         elf.auto_close_stream = true;
     }
     /// Call close when done.
-    pub fn openStream(elf: &Elf, allocator: &mem.Allocator, stream: &io.InStream) -> %void {
+    pub fn openFile(elf: &Elf, allocator: &mem.Allocator, file: &io.File) -> %void {
         elf.allocator = allocator;
-        elf.in_stream = stream;
+        elf.in_file = file;
         elf.auto_close_stream = false;
         var magic: [4]u8 = undefined;
-        %return elf.in_stream.readNoEof(magic[0..]);
+        %return elf.in_file.in_stream.readNoEof(magic[0..]);
         if (!mem.eql(u8, magic, "\x7fELF")) return error.InvalidFormat;
-        elf.is_64 = switch (%return elf.in_stream.readByte()) {
+        elf.is_64 = switch (%return elf.in_file.in_stream.readByte()) {
             1 => false,
             2 => true,
             else => return error.InvalidFormat,
         };
-        elf.is_big_endian = switch (%return elf.in_stream.readByte()) {
+        elf.is_big_endian = switch (%return elf.in_file.in_stream.readByte()) {
             1 => false,
             2 => true,
             else => return error.InvalidFormat,
         };
-        const version_byte = %return elf.in_stream.readByte();
+        const version_byte = %return elf.in_file.in_stream.readByte();
         if (version_byte != 1) return error.InvalidFormat;
         // skip over padding
-        %return elf.in_stream.seekForward(9);
+        %return elf.in_file.seekForward(9);
-        elf.file_type = switch (%return elf.in_stream.readInt(elf.is_big_endian, u16)) {
+        elf.file_type = switch (%return elf.in_file.in_stream.readInt(elf.is_big_endian, u16)) {
             1 => FileType.Relocatable,
             2 => FileType.Executable,
             3 => FileType.Shared,
 @@ -120,7 +122,7 @@ pub const Elf = struct {
             else => return error.InvalidFormat,
         };
-        elf.arch = switch (%return elf.in_stream.readInt(elf.is_big_endian, u16)) {
+        elf.arch = switch (%return elf.in_file.in_stream.readInt(elf.is_big_endian, u16)) {
             0x02 => Arch.Sparc,
             0x03 => Arch.x86,
             0x08 => Arch.Mips,
 @@ -133,34 +135,34 @@ pub const Elf = struct {
             else => return error.InvalidFormat,
         };
-        const elf_version = %return elf.in_stream.readInt(elf.is_big_endian, u32);
+        const elf_version = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u32);
         if (elf_version != 1) return error.InvalidFormat;
         if (elf.is_64) {
-            elf.entry_addr = %return elf.in_stream.readInt(elf.is_big_endian, u64);
+            elf.entry_addr = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u64);
-            elf.program_header_offset = %return elf.in_stream.readInt(elf.is_big_endian, u64);
+            elf.program_header_offset = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u64);
-            elf.section_header_offset = %return elf.in_stream.readInt(elf.is_big_endian, u64);
+            elf.section_header_offset = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u64);
         } else {
-            elf.entry_addr = u64(%return elf.in_stream.readInt(elf.is_big_endian, u32));
+            elf.entry_addr = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u32));
-            elf.program_header_offset = u64(%return elf.in_stream.readInt(elf.is_big_endian, u32));
+            elf.program_header_offset = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u32));
-            elf.section_header_offset = u64(%return elf.in_stream.readInt(elf.is_big_endian, u32));
+            elf.section_header_offset = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u32));
         }
         // skip over flags
-        %return elf.in_stream.seekForward(4);
+        %return elf.in_file.seekForward(4);
-        const header_size = %return elf.in_stream.readInt(elf.is_big_endian, u16);
+        const header_size = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u16);
         if ((elf.is_64 and header_size != 64) or
             (!elf.is_64 and header_size != 52))
         {
             return error.InvalidFormat;
         }
-        const ph_entry_size = %return elf.in_stream.readInt(elf.is_big_endian, u16);
+        const ph_entry_size = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u16);
-        const ph_entry_count = %return elf.in_stream.readInt(elf.is_big_endian, u16);
+        const ph_entry_count = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u16);
-        const sh_entry_size = %return elf.in_stream.readInt(elf.is_big_endian, u16);
+        const sh_entry_size = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u16);
-        const sh_entry_count = %return elf.in_stream.readInt(elf.is_big_endian, u16);
+        const sh_entry_count = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u16);
-        elf.string_section_index = u64(%return elf.in_stream.readInt(elf.is_big_endian, u16));
+        elf.string_section_index = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u16));
         if (elf.string_section_index >= sh_entry_count) return error.InvalidFormat;
 @@ -169,12 +171,12 @@ pub const Elf = struct {
         const ph_byte_count = u64(ph_entry_size) * u64(ph_entry_count);
         const end_ph = %return math.add(u64, elf.program_header_offset, ph_byte_count);
-        const stream_end = %return elf.in_stream.getEndPos();
+        const stream_end = %return elf.in_file.getEndPos();
         if (stream_end < end_sh or stream_end < end_ph) {
             return error.InvalidFormat;
         }
-        %return elf.in_stream.seekTo(elf.section_header_offset);
+        %return elf.in_file.seekTo(elf.section_header_offset);
         elf.section_headers = %return elf.allocator.alloc(SectionHeader, sh_entry_count);
         %defer elf.allocator.free(elf.section_headers);
 @@ -183,32 +185,32 @@ pub const Elf = struct {
             if (sh_entry_size != 64) return error.InvalidFormat;
             for (elf.section_headers) |*section| {
-                section.name         = %return elf.in_stream.readInt(elf.is_big_endian, u32);
+                section.name         = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u32);
-                section.sh_type      = %return elf.in_stream.readInt(elf.is_big_endian, u32);
+                section.sh_type      = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u32);
-                section.flags        = %return elf.in_stream.readInt(elf.is_big_endian, u64);
+                section.flags        = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u64);
-                section.addr         = %return elf.in_stream.readInt(elf.is_big_endian, u64);
+                section.addr         = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u64);
-                section.offset       = %return elf.in_stream.readInt(elf.is_big_endian, u64);
+                section.offset       = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u64);
-                section.size         = %return elf.in_stream.readInt(elf.is_big_endian, u64);
+                section.size         = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u64);
-                section.link         = %return elf.in_stream.readInt(elf.is_big_endian, u32);
+                section.link         = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u32);
-                section.info         = %return elf.in_stream.readInt(elf.is_big_endian, u32);
+                section.info         = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u32);
-                section.addr_align   = %return elf.in_stream.readInt(elf.is_big_endian, u64);
+                section.addr_align   = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u64);
-                section.ent_size     = %return elf.in_stream.readInt(elf.is_big_endian, u64);
+                section.ent_size     = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u64);
             }
         } else {
             if (sh_entry_size != 40) return error.InvalidFormat;
             for (elf.section_headers) |*section| {
                 // TODO (multiple occurences) allow implicit cast from %u32 -> %u64 ?
-                section.name = %return elf.in_stream.readInt(elf.is_big_endian, u32);
+                section.name = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u32);
-                section.sh_type = %return elf.in_stream.readInt(elf.is_big_endian, u32);
+                section.sh_type = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u32);
-                section.flags = u64(%return elf.in_stream.readInt(elf.is_big_endian, u32));
+                section.flags = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u32));
-                section.addr = u64(%return elf.in_stream.readInt(elf.is_big_endian, u32));
+                section.addr = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u32));
-                section.offset = u64(%return elf.in_stream.readInt(elf.is_big_endian, u32));
+                section.offset = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u32));
-                section.size = u64(%return elf.in_stream.readInt(elf.is_big_endian, u32));
+                section.size = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u32));
-                section.link = %return elf.in_stream.readInt(elf.is_big_endian, u32);
+                section.link = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u32);
-                section.info = %return elf.in_stream.readInt(elf.is_big_endian, u32);
+                section.info = %return elf.in_file.in_stream.readInt(elf.is_big_endian, u32);
-                section.addr_align = u64(%return elf.in_stream.readInt(elf.is_big_endian, u32));
+                section.addr_align = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u32));
-                section.ent_size = u64(%return elf.in_stream.readInt(elf.is_big_endian, u32));
+                section.ent_size = u64(%return elf.in_file.in_stream.readInt(elf.is_big_endian, u32));
             }
         }
 @@ -230,7 +232,7 @@ pub const Elf = struct {
         elf.allocator.free(elf.section_headers);
         if (elf.auto_close_stream)
-            elf.in_stream.close();
+            elf.in_file.close();
     }
     pub fn findSection(elf: &Elf, name: []const u8) -> %?&SectionHeader {
 @@ -238,15 +240,15 @@ pub const Elf = struct {
             if (section.sh_type == SHT_NULL) continue;
             const name_offset = elf.string_section.offset + section.name;
-            %return elf.in_stream.seekTo(name_offset);
+            %return elf.in_file.seekTo(name_offset);
             for (name) |expected_c| {
-                const target_c = %return elf.in_stream.readByte();
+                const target_c = %return elf.in_file.in_stream.readByte();
                 if (target_c == 0 or expected_c != target_c) goto next_section;
             }
             {
-                const null_byte = %return elf.in_stream.readByte();
+                const null_byte = %return elf.in_file.in_stream.readByte();
                 if (null_byte == 0) return section;
             }
 @@ -257,6 +259,6 @@ pub const Elf = struct {
     }
     pub fn seekToSection(elf: &Elf, section: &SectionHeader) -> %void {
-        %return elf.in_stream.seekTo(section.offset);
+        %return elf.in_file.seekTo(section.offset);
     }
 };

std/fmt/index.zig+40-68

 @@ -19,10 +19,10 @@ const State = enum { // TODO put inside format function and make sure the name a
 };
 /// Renders fmt string with args, calling output with slices of bytes.
-/// Return false from output function and output will not be called again.
+/// If `output` returns an error, the error is returned from `format` and
-/// Returns false if output ever returned false, true otherwise.
+/// `output` is not called again.
-pub fn format(context: var, output: fn(@typeOf(context), []const u8)->bool,
+pub fn format(context: var, output: fn(@typeOf(context), []const u8)->%void,
-    comptime fmt: []const u8, args: ...) -> bool
+    comptime fmt: []const u8, args: ...) -> %void
 {
     comptime var start_index = 0;
     comptime var state = State.Start;
 @@ -38,15 +38,13 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->bool,
                 '{' => {
                     // TODO if you make this an if statement with `and` then it breaks
                     if (start_index < i) {
-                        if (!output(context, fmt[start_index..i]))
+                        %return output(context, fmt[start_index..i]);
-                            return false;
                     }
                     state = State.OpenBrace;
                 },
                 '}' => {
                     if (start_index < i) {
-                        if (!output(context, fmt[start_index..i]))
+                        %return output(context, fmt[start_index..i]);
-                            return false;
                     }
                     state = State.CloseBrace;
                 },
 @@ -58,8 +56,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->bool,
                     start_index = i;
                 },
                 '}' => {
-                    if (!formatValue(args[next_arg], context, output))
+                    %return formatValue(args[next_arg], context, output);
-                        return false;
                     next_arg += 1;
                     state = State.Start;
                     start_index = i + 1;
 @@ -109,8 +106,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->bool,
             },
             State.Integer => switch (c) {
                 '}' => {
-                    if (!formatInt(args[next_arg], radix, uppercase, width, context, output))
+                    %return formatInt(args[next_arg], radix, uppercase, width, context, output);
-                        return false;
                     next_arg += 1;
                     state = State.Start;
                     start_index = i + 1;
 @@ -124,8 +120,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->bool,
             State.IntegerWidth => switch (c) {
                 '}' => {
                     width = comptime %%parseUnsigned(usize, fmt[width_start..i], 10);
-                    if (!formatInt(args[next_arg], radix, uppercase, width, context, output))
+                    %return formatInt(args[next_arg], radix, uppercase, width, context, output);
-                        return false;
                     next_arg += 1;
                     state = State.Start;
                     start_index = i + 1;
 @@ -136,8 +131,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->bool,
             State.BufWidth => switch (c) {
                 '}' => {
                     width = comptime %%parseUnsigned(usize, fmt[width_start..i], 10);
-                    if (!formatBuf(args[next_arg], width, context, output))
+                    %return formatBuf(args[next_arg], width, context, output);
-                        return false;
                     next_arg += 1;
                     state = State.Start;
                     start_index = i + 1;
 @@ -147,8 +141,7 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->bool,
             },
             State.Character => switch (c) {
                 '}' => {
-                    if (!formatAsciiChar(args[next_arg], context, output))
+                    %return formatAsciiChar(args[next_arg], context, output);
-                        return false;
                     next_arg += 1;
                     state = State.Start;
                     start_index = i + 1;
 @@ -166,14 +159,11 @@ pub fn format(context: var, output: fn(@typeOf(context), []const u8)->bool,
         }
     }
     if (start_index < fmt.len) {
-        if (!output(context, fmt[start_index..]))
+        %return output(context, fmt[start_index..]);
-            return false;
     }
-    return true;
 }
-pub fn formatValue(value: var, context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool {
+pub fn formatValue(value: var, context: var, output: fn(@typeOf(context), []const u8)->%void) -> %void {
     const T = @typeOf(value);
     switch (@typeId(T)) {
         builtin.TypeId.Int => {
 @@ -203,8 +193,7 @@ pub fn formatValue(value: var, context: var, output: fn(@typeOf(context), []cons
             }
         },
         builtin.TypeId.Error => {
-            if (!output(context, "error."))
+            %return output(context, "error.");
-                return false;
             return output(context, @errorName(value));
         },
         builtin.TypeId.Pointer => {
 @@ -223,27 +212,23 @@ pub fn formatValue(value: var, context: var, output: fn(@typeOf(context), []cons
     }
 }
-pub fn formatAsciiChar(c: u8, context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool {
+pub fn formatAsciiChar(c: u8, context: var, output: fn(@typeOf(context), []const u8)->%void) -> %void {
     return output(context, (&c)[0..1]);
 }
 pub fn formatBuf(buf: []const u8, width: usize,
-    context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool
+    context: var, output: fn(@typeOf(context), []const u8)->%void) -> %void
 {
-    if (!output(context, buf))
+    %return output(context, buf);
-        return false;
-    var leftover_padding = if (width > buf.len) (width - buf.len) else return true;
+    var leftover_padding = if (width > buf.len) (width - buf.len) else return;
     const pad_byte: u8 = ' ';
     while (leftover_padding > 0) : (leftover_padding -= 1) {
-        if (!output(context, (&pad_byte)[0..1]))
+        %return output(context, (&pad_byte)[0..1]);
-            return false;
     }
-    return true;
 }
-pub fn formatFloat(value: var, context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool {
+pub fn formatFloat(value: var, context: var, output: fn(@typeOf(context), []const u8)->%void) -> %void {
     var x = f64(value);
     // Errol doesn't handle these special cases.
 @@ -251,8 +236,7 @@ pub fn formatFloat(value: var, context: var, output: fn(@typeOf(context), []cons
         return output(context, "NaN");
     }
     if (math.signbit(x)) {
-        if (!output(context, "-"))
+        %return output(context, "-");
-            return false;
         x = -x;
     }
     if (math.isPositiveInf(x)) {
 @@ -264,34 +248,27 @@ pub fn formatFloat(value: var, context: var, output: fn(@typeOf(context), []cons
     var buffer: [32]u8 = undefined;
     const float_decimal = errol3(x, buffer[0..]);
-    if (!output(context, float_decimal.digits[0..1]))
+    %return output(context, float_decimal.digits[0..1]);
-        return false;
+    %return output(context, ".");
-    if (!output(context, "."))
-        return false;
     if (float_decimal.digits.len > 1) {
         const num_digits = if (@typeOf(value) == f32) {
             math.min(usize(9), float_decimal.digits.len)
         } else {
             float_decimal.digits.len
         };
-        if (!output(context, float_decimal.digits[1 .. num_digits]))
+        %return output(context, float_decimal.digits[1 .. num_digits]);
-            return false;
     } else {
-        if (!output(context, "0"))
+        %return output(context, "0");
-            return false;
     }
     if (float_decimal.exp != 1) {
-        if (!output(context, "e"))
+        %return output(context, "e");
-            return false;
+        %return formatInt(float_decimal.exp - 1, 10, false, 0, context, output);
-        if (!formatInt(float_decimal.exp - 1, 10, false, 0, context, output))
-            return false;
     }
-    return true;
 }
 pub fn formatInt(value: var, base: u8, uppercase: bool, width: usize,
-    context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool
+    context: var, output: fn(@typeOf(context), []const u8)->%void) -> %void
 {
     if (@typeOf(value).is_signed) {
         return formatIntSigned(value, base, uppercase, width, context, output);
 @@ -301,13 +278,12 @@ pub fn formatInt(value: var, base: u8, uppercase: bool, width: usize,
 }
 fn formatIntSigned(value: var, base: u8, uppercase: bool, width: usize,
-    context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool
+    context: var, output: fn(@typeOf(context), []const u8)->%void) -> %void
 {
     const uint = @IntType(false, @typeOf(value).bit_count);
     if (value < 0) {
         const minus_sign: u8 = '-';
-        if (!output(context, (&minus_sign)[0..1]))
+        %return output(context, (&minus_sign)[0..1]);
-            return false;
         const new_value = uint(-(value + 1)) + 1;
         const new_width = if (width == 0) 0 else (width - 1);
         return formatIntUnsigned(new_value, base, uppercase, new_width, context, output);
 @@ -315,8 +291,7 @@ fn formatIntSigned(value: var, base: u8, uppercase: bool, width: usize,
         return formatIntUnsigned(uint(value), base, uppercase, width, context, output);
     } else {
         const plus_sign: u8 = '+';
-        if (!output(context, (&plus_sign)[0..1]))
+        %return output(context, (&plus_sign)[0..1]);
-            return false;
         const new_value = uint(value);
         const new_width = if (width == 0) 0 else (width - 1);
         return formatIntUnsigned(new_value, base, uppercase, new_width, context, output);
 @@ -324,7 +299,7 @@ fn formatIntSigned(value: var, base: u8, uppercase: bool, width: usize,
 }
 fn formatIntUnsigned(value: var, base: u8, uppercase: bool, width: usize,
-    context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool
+    context: var, output: fn(@typeOf(context), []const u8)->%void) -> %void
 {
     // max_int_digits accounts for the minus sign. when printing an unsigned
     // number we don't need to do that.
 @@ -348,8 +323,7 @@ fn formatIntUnsigned(value: var, base: u8, uppercase: bool, width: usize,
         const zero_byte: u8 = '0';
         var leftover_padding = padding - index;
         while (true) {
-            if (!output(context, (&zero_byte)[0..1]))
+            %return output(context, (&zero_byte)[0..1]);
-                return false;
             leftover_padding -= 1;
             if (leftover_padding == 0)
                 break;
 @@ -368,17 +342,16 @@ pub fn formatIntBuf(out_buf: []u8, value: var, base: u8, uppercase: bool, width:
         .out_buf = out_buf,
         .index = 0,
     };
-    _ = formatInt(value, base, uppercase, width, &context, formatIntCallback);
+    %%formatInt(value, base, uppercase, width, &context, formatIntCallback);
     return context.index;
 }
 const FormatIntBuf = struct {
     out_buf: []u8,
     index: usize,
 };
-fn formatIntCallback(context: &FormatIntBuf, bytes: []const u8) -> bool {
+fn formatIntCallback(context: &FormatIntBuf, bytes: []const u8) -> %void {
     mem.copy(u8, context.out_buf[context.index..], bytes);
     context.index += bytes.len;
-    return true;
 }
 pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) -> %T {
 @@ -440,28 +413,27 @@ const BufPrintContext = struct {
     remaining: []u8,
 };
-fn bufPrintWrite(context: &BufPrintContext, bytes: []const u8) -> bool {
+fn bufPrintWrite(context: &BufPrintContext, bytes: []const u8) -> %void {
     mem.copy(u8, context.remaining, bytes);
     context.remaining = context.remaining[bytes.len..];
-    return true;
 }
 pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: ...) -> []u8 {
     var context = BufPrintContext { .remaining = buf, };
-    _ = format(&context, bufPrintWrite, fmt, args);
+    %%format(&context, bufPrintWrite, fmt, args);
     return buf[0..buf.len - context.remaining.len];
 }
 pub fn allocPrint(allocator: &mem.Allocator, comptime fmt: []const u8, args: ...) -> %[]u8 {
     var size: usize = 0;
-    _ = format(&size, countSize, fmt, args);
+    // Cannot fail because `countSize` cannot fail.
+    %%format(&size, countSize, fmt, args);
     const buf = %return allocator.alloc(u8, size);
     return bufPrint(buf, fmt, args);
 }
-fn countSize(size: &usize, bytes: []const u8) -> bool {
+fn countSize(size: &usize, bytes: []const u8) -> %void {
     *size += bytes.len;
-    return true;
 }
 test "buf print int" {

std/heap.zig created+158

...	@@ -0,0 +1,158 @@
1	const debug = @import("debug.zig");
2	const assert = debug.assert;
3	const mem = @import("mem.zig");
4	const os = @import("os/index.zig");
5	const builtin = @import("builtin");
6	const Os = builtin.Os;
7	const c = @import("c/index.zig");
8
9	const Allocator = mem.Allocator;
10
11	error OutOfMemory;
12
13	pub var c_allocator = Allocator {
14	.allocFn = cAlloc,
15	.reallocFn = cRealloc,
16	.freeFn = cFree,
17	};
18
19	fn cAlloc(self: &Allocator, n: usize, alignment: usize) -> %[]u8 {
20	if (c.malloc(usize(n))) \|mem\| {
21	@ptrCast(&u8, mem)[0..n]
22	} else {
23	error.OutOfMemory
24	}
25	}
26
27	fn cRealloc(self: &Allocator, old_mem: []u8, new_size: usize, alignment: usize) -> %[]u8 {
28	if (new_size <= old_mem.len) {
29	old_mem[0..new_size]
30	} else {
31	const old_ptr = @ptrCast(&c_void, old_mem.ptr);
32	if (c.realloc(old_ptr, usize(new_size))) \|mem\| {
33	@ptrCast(&u8, mem)[0..new_size]
34	} else {
35	error.OutOfMemory
36	}
37	}
38	}
39
40	fn cFree(self: &Allocator, old_mem: []u8) {
41	const old_ptr = @ptrCast(&c_void, old_mem.ptr);
42	c.free(old_ptr);
43	}
44
45	pub const IncrementingAllocator = struct {
46	allocator: Allocator,
47	bytes: []u8,
48	end_index: usize,
49	heap_handle: if (builtin.os == Os.windows) os.windows.HANDLE else void,
50
51	fn init(capacity: usize) -> %IncrementingAllocator {
52	switch (builtin.os) {
53	Os.linux, Os.darwin, Os.macosx, Os.ios => {
54	const p = os.posix;
55	const addr = p.mmap(null, capacity, p.PROT_READ\|p.PROT_WRITE,
56	p.MAP_PRIVATE\|p.MAP_ANONYMOUS\|p.MAP_NORESERVE, -1, 0);
57	if (addr == p.MAP_FAILED) {
58	return error.OutOfMemory;
59	}
60	return IncrementingAllocator {
61	.allocator = Allocator {
62	.allocFn = alloc,
63	.reallocFn = realloc,
64	.freeFn = free,
65	},
66	.bytes = @intToPtr(&u8, addr)[0..capacity],
67	.end_index = 0,
68	.heap_handle = {},
69	};
70	},
71	Os.windows => {
72	const heap_handle = os.windows.GetProcessHeap() ?? return error.OutOfMemory;
73	const ptr = os.windows.HeapAlloc(heap_handle, 0, capacity) ?? return error.OutOfMemory;
74	return IncrementingAllocator {
75	.allocator = Allocator {
76	.allocFn = alloc,
77	.reallocFn = realloc,
78	.freeFn = free,
79	},
80	.bytes = @ptrCast(&u8, ptr)[0..capacity],
81	.end_index = 0,
82	.heap_handle = heap_handle,
83	};
84	},
85	else => @compileError("Unsupported OS"),
86	}
87	}
88
89	fn deinit(self: &IncrementingAllocator) {
90	switch (builtin.os) {
91	Os.linux, Os.darwin, Os.macosx, Os.ios => {
92	_ = os.posix.munmap(self.bytes.ptr, self.bytes.len);
93	},
94	Os.windows => {
95	_ = os.windows.HeapFree(self.heap_handle, 0, @ptrCast(os.windows.LPVOID, self.bytes.ptr));
96	},
97	else => @compileError("Unsupported OS"),
98	}
99	}
100
101	fn reset(self: &IncrementingAllocator) {
102	self.end_index = 0;
103	}
104
105	fn bytesLeft(self: &const IncrementingAllocator) -> usize {
106	return self.bytes.len - self.end_index;
107	}
108
109	fn alloc(allocator: &Allocator, n: usize, alignment: usize) -> %[]u8 {
110	const self = @fieldParentPtr(IncrementingAllocator, "allocator", allocator);
111	const addr = @ptrToInt(&self.bytes[self.end_index]);
112	const rem = @rem(addr, alignment);
113	const march_forward_bytes = if (rem == 0) 0 else (alignment - rem);
114	const adjusted_index = self.end_index + march_forward_bytes;
115	const new_end_index = adjusted_index + n;
116	if (new_end_index > self.bytes.len) {
117	return error.OutOfMemory;
118	}
119	const result = self.bytes[adjusted_index .. new_end_index];
120	self.end_index = new_end_index;
121	return result;
122	}
123
124	fn realloc(allocator: &Allocator, old_mem: []u8, new_size: usize, alignment: usize) -> %[]u8 {
125	if (new_size <= old_mem.len) {
126	return old_mem[0..new_size];
127	} else {
128	const result = %return alloc(allocator, new_size, alignment);
129	mem.copy(u8, result, old_mem);
130	return result;
131	}
132	}
133
134	fn free(allocator: &Allocator, bytes: []u8) {
135	// Do nothing. That's the point of an incrementing allocator.
136	}
137	};
138
139	test "IncrementingAllocator" {
140	const total_bytes = 100 * 1024 * 1024;
141	var inc_allocator = %%IncrementingAllocator.init(total_bytes);
142	defer inc_allocator.deinit();
143
144	const allocator = &inc_allocator.allocator;
145	const slice = %%allocator.alloc(&i32, 100);
146
147	for (slice) \|*item, i\| {
148	*item = %%allocator.create(i32);
149	**item = i32(i);
150	}
151
152	assert(inc_allocator.bytesLeft() == total_bytes - @sizeOf(i32) * 100 - @sizeOf(usize) * 100);
153
154	inc_allocator.reset();
155
156	assert(inc_allocator.bytesLeft() == total_bytes);
157	}
158

std/index.zig+2

...	@@ -15,6 +15,7 @@ pub const elf = @import("elf.zig");	...	@@ -15,6 +15,7 @@ pub const elf = @import("elf.zig");
15	pub const empty_import = @import("empty.zig");	15	pub const empty_import = @import("empty.zig");
16	pub const endian = @import("endian.zig");	16	pub const endian = @import("endian.zig");
17	pub const fmt = @import("fmt/index.zig");	17	pub const fmt = @import("fmt/index.zig");
		18	pub const heap = @import("heap.zig");
18	pub const io = @import("io.zig");	19	pub const io = @import("io.zig");
19	pub const math = @import("math/index.zig");	20	pub const math = @import("math/index.zig");
20	pub const mem = @import("mem.zig");	21	pub const mem = @import("mem.zig");
...	@@ -45,6 +46,7 @@ test "std" {	...	@@ -45,6 +46,7 @@ test "std" {
45	_ = @import("io.zig");	46	_ = @import("io.zig");
46	_ = @import("math/index.zig");	47	_ = @import("math/index.zig");
47	_ = @import("mem.zig");	48	_ = @import("mem.zig");
		49	_ = @import("heap.zig");
48	_ = @import("net.zig");	50	_ = @import("net.zig");
49	_ = @import("os/index.zig");	51	_ = @import("os/index.zig");
50	_ = @import("rand.zig");	52	_ = @import("rand.zig");

std/io.zig+278-352

...	@@ -1,3 +1,4 @@	...	@@ -1,3 +1,4 @@
		1	const std = @import("index.zig");
1	const builtin = @import("builtin");	2	const builtin = @import("builtin");
2	const Os = builtin.Os;	3	const Os = builtin.Os;
3	const system = switch(builtin.os) {	4	const system = switch(builtin.os) {
...	@@ -6,41 +7,19 @@ const system = switch(builtin.os) {	...	@@ -6,41 +7,19 @@ const system = switch(builtin.os) {
6	Os.windows => @import("os/windows/index.zig"),	7	Os.windows => @import("os/windows/index.zig"),
7	else => @compileError("Unsupported OS"),	8	else => @compileError("Unsupported OS"),
8	};	9	};
9	const c = @import("c/index.zig");	10	const c = std.c;
10		11
11	const math = @import("math/index.zig");	12	const math = std.math;
12	const debug = @import("debug.zig");	13	const debug = std.debug;
13	const assert = debug.assert;	14	const assert = debug.assert;
14	const os = @import("os/index.zig");	15	const os = std.os;
15	const mem = @import("mem.zig");	16	const mem = std.mem;
16	const Buffer = @import("buffer.zig").Buffer;	17	const Buffer = std.Buffer;
17	const fmt = @import("fmt/index.zig");	18	const fmt = std.fmt;
18		19
19	const is_posix = builtin.os != builtin.Os.windows;	20	const is_posix = builtin.os != builtin.Os.windows;
20	const is_windows = builtin.os == builtin.Os.windows;	21	const is_windows = builtin.os == builtin.Os.windows;
21		22
22	pub var stdin = InStream {
23	.fd = if (is_posix) system.STDIN_FILENO else {},
24	.handle_id = if (is_windows) system.STD_INPUT_HANDLE else {},
25	.handle = if (is_windows) null else {},
26	};
27
28	pub var stdout = OutStream {
29	.fd = if (is_posix) system.STDOUT_FILENO else {},
30	.handle_id = if (is_windows) system.STD_OUTPUT_HANDLE else {},
31	.handle = if (is_windows) null else {},
32	.buffer = undefined,
33	.index = 0,
34	};
35
36	pub var stderr = OutStream {
37	.fd = if (is_posix) system.STDERR_FILENO else {},
38	.handle_id = if (is_windows) system.STD_ERROR_HANDLE else {},
39	.handle = if (is_windows) null else {},
40	.buffer = undefined,
41	.index = 0,
42	};
43
44	/// The function received invalid input at runtime. An Invalid error means a	23	/// The function received invalid input at runtime. An Invalid error means a
45	/// bug in the program that called the function.	24	/// bug in the program that called the function.
46	error Invalid;	25	error Invalid;
...	@@ -63,306 +42,125 @@ error PathNotFound;	...	@@ -63,306 +42,125 @@ error PathNotFound;
63	error OutOfMemory;	42	error OutOfMemory;
64	error Unseekable;	43	error Unseekable;
65	error EndOfFile;	44	error EndOfFile;
66	error NoStdHandles;
67
68	pub const OutStream = struct {
69	fd: if (is_posix) i32 else void,
70	handle_id: if (is_windows) system.DWORD else void,
71	handle: if (is_windows) ?system.HANDLE else void,
72	buffer: [os.page_size]u8,
73	index: usize,
74
75	/// Calls ::openMode with 0o666 for the mode.
76	pub fn open(path: []const u8, allocator: ?&mem.Allocator) -> %OutStream {
77	return openMode(path, 0o666, allocator);
78		45
79	}	46	pub fn getStdErr() -> %File {
80		47	const handle = if (is_windows) {
81	/// `path` may need to be copied in memory to add a null terminating byte. In this case	48	%return os.windowsGetStdHandle(system.STD_ERROR_HANDLE)
82	/// a fixed size buffer of size std.os.max_noalloc_path_len is an attempted solution. If the fixed	49	} else if (is_posix) {
83	/// size buffer is too small, and the provided allocator is null, error.NameTooLong is returned.	50	system.STDERR_FILENO
84	/// otherwise if the fixed size buffer is too small, allocator is used to obtain the needed memory.	51	} else {
85	/// Call close to clean up.	52	unreachable
86	pub fn openMode(path: []const u8, mode: usize, allocator: ?&mem.Allocator) -> %OutStream {
87	if (is_posix) {
88	const flags = system.O_LARGEFILE\|system.O_WRONLY\|system.O_CREAT\|system.O_CLOEXEC\|system.O_TRUNC;
89	const fd = %return os.posixOpen(path, flags, mode, allocator);
90	return OutStream {
91	.fd = fd,
92	.handle = {},
93	.handle_id = {},
94	.index = 0,
95	.buffer = undefined,
96	};
97	} else if (is_windows) {
98	const handle = %return os.windowsOpen(path, system.GENERIC_WRITE,
99	system.FILE_SHARE_WRITE\|system.FILE_SHARE_READ\|system.FILE_SHARE_DELETE,
100	system.CREATE_ALWAYS, system.FILE_ATTRIBUTE_NORMAL, allocator);
101	return OutStream {
102	.fd = {},
103	.handle = handle,
104	.handle_id = undefined,
105	.index = 0,
106	.buffer = undefined,
107	};
108
109	} else {
110	unreachable;
111	}
112
113	}
114
115	pub fn writeByte(self: &OutStream, b: u8) -> %void {
116	if (self.buffer.len == self.index) %return self.flush();
117	self.buffer[self.index] = b;
118	self.index += 1;
119	}
120
121	pub fn write(self: &OutStream, bytes: []const u8) -> %void {
122	if (bytes.len >= self.buffer.len) {
123	%return self.flush();
124	return self.unbufferedWrite(bytes);
125	}
126
127	var src_index: usize = 0;
128
129	while (src_index < bytes.len) {
130	const dest_space_left = self.buffer.len - self.index;
131	const copy_amt = math.min(dest_space_left, bytes.len - src_index);
132	mem.copy(u8, self.buffer[self.index..], bytes[src_index..src_index + copy_amt]);
133	self.index += copy_amt;
134	assert(self.index <= self.buffer.len);
135	if (self.index == self.buffer.len) {
136	%return self.flush();
137	}
138	src_index += copy_amt;
139	}
140	}
141
142	/// Calls print and then flushes the buffer.
143	pub fn printf(self: &OutStream, comptime format: []const u8, args: ...) -> %void {
144	%return self.print(format, args);
145	%return self.flush();
146	}
147
148	/// Does not flush the buffer.
149	pub fn print(self: &OutStream, comptime format: []const u8, args: ...) -> %void {
150	var context = PrintContext {
151	.self = self,
152	.result = {},
153	};
154	_ = fmt.format(&context, printOutput, format, args);
155	return context.result;
156	}
157	const PrintContext = struct {
158	self: &OutStream,
159	result: %void,
160	};	53	};
161	fn printOutput(context: &PrintContext, bytes: []const u8) -> bool {	54	return File.openHandle(handle);
162	context.self.write(bytes) %% \|err\| {	55	}
163	context.result = err;
164	return false;
165	};
166	return true;
167	}
168
169	pub fn flush(self: &OutStream) -> %void {
170	if (self.index == 0)
171	return;
172
173	%return self.unbufferedWrite(self.buffer[0..self.index]);
174	self.index = 0;
175	}
176
177	pub fn close(self: &OutStream) {
178	assert(self.index == 0); // unflushed buffer
179	if (is_posix) {
180	os.posixClose(self.fd);
181	} else if (is_windows) {
182	os.windowsClose(%%self.getHandle());
183	} else {
184	unreachable;
185	}
186	}
187		56
188	pub fn isTty(self: &OutStream) -> %bool {	57	pub fn getStdOut() -> %File {
189	if (is_posix) {	58	const handle = if (is_windows) {
190	if (builtin.link_libc) {	59	%return os.windowsGetStdHandle(system.STD_OUTPUT_HANDLE)
191	return c.isatty(self.fd) != 0;	60	} else if (is_posix) {
192	} else {	61	system.STDOUT_FILENO
193	return system.isatty(self.fd);	62	} else {
194	}	63	unreachable
195	} else if (is_windows) {	64	};
196	return os.windowsIsTty(%return self.getHandle());	65	return File.openHandle(handle);
197	} else {	66	}
198	unreachable;
199	}
200	}
201		67
202	fn getHandle(self: &OutStream) -> %system.HANDLE {	68	pub fn getStdIn() -> %File {
203	if (self.handle) \|handle\| return handle;	69	const handle = if (is_windows) {
204	if (system.GetStdHandle(self.handle_id)) \|handle\| {	70	%return os.windowsGetStdHandle(system.STD_INPUT_HANDLE)
205	if (handle == system.INVALID_HANDLE_VALUE) {	71	} else if (is_posix) {
206	const err = system.GetLastError();	72	system.STDIN_FILENO
207	return switch (err) {	73	} else {
208	else => os.unexpectedErrorWindows(err),	74	unreachable
209	};	75	};
210	}	76	return File.openHandle(handle);
211	self.handle = handle;	77	}
212	return handle;
213	} else {
214	return error.NoStdHandles;
215	}
216	}
217		78
218	fn unbufferedWrite(self: &OutStream, bytes: []const u8) -> %void {	79	pub const File = struct {
219	if (is_posix) {	80	/// The OS-specific file descriptor or file handle.
220	%return os.posixWrite(self.fd, bytes);	81	handle: os.FileHandle,
221	} else if (is_windows) {
222	const handle = %return self.getHandle();
223	%return os.windowsWrite(handle, bytes);
224	} else {
225	@compileError("Unsupported OS");
226	}
227	}
228		82
229	};	83	/// A file has the `InStream` trait
		84	in_stream: InStream,
230		85
231	// TODO created a BufferedInStream struct and move some of this code there	86	/// A file has the `OutStream` trait
232	// BufferedInStream API goes on top of minimal InStream API.	87	out_stream: OutStream,
233	pub const InStream = struct {
234	fd: if (is_posix) i32 else void,
235	handle_id: if (is_windows) system.DWORD else void,
236	handle: if (is_windows) ?system.HANDLE else void,
237		88
238	/// `path` may need to be copied in memory to add a null terminating byte. In this case	89	/// `path` may need to be copied in memory to add a null terminating byte. In this case
239	/// a fixed size buffer of size std.os.max_noalloc_path_len is an attempted solution. If the fixed	90	/// a fixed size buffer of size std.os.max_noalloc_path_len is an attempted solution. If the fixed
240	/// size buffer is too small, and the provided allocator is null, error.NameTooLong is returned.	91	/// size buffer is too small, and the provided allocator is null, error.NameTooLong is returned.
241	/// otherwise if the fixed size buffer is too small, allocator is used to obtain the needed memory.	92	/// otherwise if the fixed size buffer is too small, allocator is used to obtain the needed memory.
242	/// Call close to clean up.	93	/// Call close to clean up.
243	pub fn open(path: []const u8, allocator: ?&mem.Allocator) -> %InStream {	94	pub fn openRead(path: []const u8, allocator: ?&mem.Allocator) -> %File {
244	if (is_posix) {	95	if (is_posix) {
245	const flags = system.O_LARGEFILE\|system.O_RDONLY;	96	const flags = system.O_LARGEFILE\|system.O_RDONLY;
246	const fd = %return os.posixOpen(path, flags, 0, allocator);	97	const fd = %return os.posixOpen(path, flags, 0, allocator);
247	return InStream {	98	return openHandle(fd);
248	.fd = fd,
249	.handle_id = {},
250	.handle = {},
251	};
252	} else if (is_windows) {	99	} else if (is_windows) {
253	const handle = %return os.windowsOpen(path, system.GENERIC_READ, system.FILE_SHARE_READ,	100	const handle = %return os.windowsOpen(path, system.GENERIC_READ, system.FILE_SHARE_READ,
254	system.OPEN_EXISTING, system.FILE_ATTRIBUTE_NORMAL, allocator);	101	system.OPEN_EXISTING, system.FILE_ATTRIBUTE_NORMAL, allocator);
255	return InStream {	102	return openHandle(handle);
256	.fd = {},
257	.handle_id = undefined,
258	.handle = handle,
259	};
260	} else {	103	} else {
261	unreachable;	104	unreachable;
262	}	105	}
263	}	106	}
264		107
265	/// Upon success, the stream is in an uninitialized state. To continue using it,	108	/// Calls `openWriteMode` with 0o666 for the mode.
266	/// you must use the open() function.	109	pub fn openWrite(path: []const u8, allocator: ?&mem.Allocator) -> %File {
267	pub fn close(self: &InStream) {	110	return openWriteMode(path, 0o666, allocator);
268	if (is_posix) {	111
269	os.posixClose(self.fd);
270	} else if (is_windows) {
271	os.windowsClose(%%self.getHandle());
272	} else {
273	unreachable;
274	}
275	}	112	}
276		113
277	/// Returns the number of bytes read. If the number read is smaller than buf.len, then	114	/// `path` may need to be copied in memory to add a null terminating byte. In this case
278	/// the stream reached End Of File.	115	/// a fixed size buffer of size std.os.max_noalloc_path_len is an attempted solution. If the fixed
279	pub fn read(self: &InStream, buf: []u8) -> %usize {	116	/// size buffer is too small, and the provided allocator is null, error.NameTooLong is returned.
		117	/// otherwise if the fixed size buffer is too small, allocator is used to obtain the needed memory.
		118	/// Call close to clean up.
		119	pub fn openWriteMode(path: []const u8, mode: usize, allocator: ?&mem.Allocator) -> %File {
280	if (is_posix) {	120	if (is_posix) {
281	var index: usize = 0;	121	const flags = system.O_LARGEFILE\|system.O_WRONLY\|system.O_CREAT\|system.O_CLOEXEC\|system.O_TRUNC;
282	while (index < buf.len) {	122	const fd = %return os.posixOpen(path, flags, mode, allocator);
283	const amt_read = system.read(self.fd, &buf[index], buf.len - index);	123	return openHandle(fd);
284	const read_err = system.getErrno(amt_read);
285	if (read_err > 0) {
286	switch (read_err) {
287	system.EINTR => continue,
288	system.EINVAL => unreachable,
289	system.EFAULT => unreachable,
290	system.EBADF => return error.BadFd,
291	system.EIO => return error.Io,
292	else => return os.unexpectedErrorPosix(read_err),
293	}
294	}
295	if (amt_read == 0) return index;
296	index += amt_read;
297	}
298	return index;
299	} else if (is_windows) {	124	} else if (is_windows) {
300	const handle = %return self.getHandle();	125	const handle = %return os.windowsOpen(path, system.GENERIC_WRITE,
301	var index: usize = 0;	126	system.FILE_SHARE_WRITE\|system.FILE_SHARE_READ\|system.FILE_SHARE_DELETE,
302	while (index < buf.len) {	127	system.CREATE_ALWAYS, system.FILE_ATTRIBUTE_NORMAL, allocator);
303	const want_read_count = system.DWORD(math.min(system.DWORD(@maxValue(system.DWORD)), buf.len - index));	128	return openHandle(handle);
304	var amt_read: system.DWORD = undefined;
305	if (system.ReadFile(handle, @ptrCast(&c_void, &buf[index]), want_read_count, &amt_read, null) == 0) {
306	const err = system.GetLastError();
307	return switch (err) {
308	system.ERROR.OPERATION_ABORTED => continue,
309	system.ERROR.BROKEN_PIPE => return index,
310	else => os.unexpectedErrorWindows(err),
311	};
312	}
313	if (amt_read == 0) return index;
314	index += amt_read;
315	}
316	return index;
317	} else {	129	} else {
318	unreachable;	130	unreachable;
319	}	131	}
320	}
321		132
322	pub fn readNoEof(is: &InStream, buf: []u8) -> %void {
323	const amt_read = %return is.read(buf);
324	if (amt_read < buf.len) return error.EndOfFile;
325	}	133	}
326		134
327	pub fn readByte(is: &InStream) -> %u8 {	135	pub fn openHandle(handle: os.FileHandle) -> File {
328	var result: [1]u8 = undefined;	136	return File {
329	%return is.readNoEof(result[0..]);	137	.handle = handle,
330	return result[0];	138	.out_stream = OutStream {
331	}	139	.writeFn = writeFn,
332		140	},
333	pub fn readByteSigned(is: &InStream) -> %i8 {	141	.in_stream = InStream {
334	var result: [1]i8 = undefined;	142	.readFn = readFn,
335	%return is.readNoEof(([]u8)(result[0..]));	143	},
336	return result[0];	144	};
337	}
338
339	pub fn readIntLe(is: &InStream, comptime T: type) -> %T {
340	is.readInt(false, T)
341	}	145	}
342		146
343	pub fn readIntBe(is: &InStream, comptime T: type) -> %T {
344	is.readInt(true, T)
345	}
346		147
347	pub fn readInt(is: &InStream, is_be: bool, comptime T: type) -> %T {	148	/// Upon success, the stream is in an uninitialized state. To continue using it,
348	var bytes: [@sizeOf(T)]u8 = undefined;	149	/// you must use the open() function.
349	%return is.readNoEof(bytes[0..]);	150	pub fn close(self: &File) {
350	return mem.readInt(bytes, T, is_be);	151	os.close(self.handle);
		152	self.handle = undefined;
351	}	153	}
352		154
353	pub fn readVarInt(is: &InStream, is_be: bool, comptime T: type, size: usize) -> %T {	155	/// Calls `os.isTty` on `self.handle`.
354	assert(size <= @sizeOf(T));	156	pub fn isTty(self: &File) -> bool {
355	assert(size <= 8);	157	return os.isTty(self.handle);
356	var input_buf: [8]u8 = undefined;
357	const input_slice = input_buf[0..size];
358	%return is.readNoEof(input_slice);
359	return mem.readInt(input_slice, T, is_be);
360	}	158	}
361		159
362	pub fn seekForward(is: &InStream, amount: isize) -> %void {	160	pub fn seekForward(self: &File, amount: isize) -> %void {
363	switch (builtin.os) {	161	switch (builtin.os) {
364	Os.linux, Os.darwin => {	162	Os.linux, Os.darwin => {
365	const result = system.lseek(is.fd, amount, system.SEEK_CUR);	163	const result = system.lseek(self.handle, amount, system.SEEK_CUR);
366	const err = system.getErrno(result);	164	const err = system.getErrno(result);
367	if (err > 0) {	165	if (err > 0) {
368	return switch (err) {	166	return switch (err) {
...	@@ -379,10 +177,10 @@ pub const InStream = struct {	...	@@ -379,10 +177,10 @@ pub const InStream = struct {
379	}	177	}
380	}	178	}
381		179
382	pub fn seekTo(is: &InStream, pos: usize) -> %void {	180	pub fn seekTo(self: &File, pos: usize) -> %void {
383	switch (builtin.os) {	181	switch (builtin.os) {
384	Os.linux, Os.darwin => {	182	Os.linux, Os.darwin => {
385	const result = system.lseek(is.fd, @bitCast(isize, pos), system.SEEK_SET);	183	const result = system.lseek(self.handle, @bitCast(isize, pos), system.SEEK_SET);
386	const err = system.getErrno(result);	184	const err = system.getErrno(result);
387	if (err > 0) {	185	if (err > 0) {
388	return switch (err) {	186	return switch (err) {
...	@@ -399,10 +197,10 @@ pub const InStream = struct {	...	@@ -399,10 +197,10 @@ pub const InStream = struct {
399	}	197	}
400	}	198	}
401		199
402	pub fn getPos(is: &InStream) -> %usize {	200	pub fn getPos(self: &File) -> %usize {
403	switch (builtin.os) {	201	switch (builtin.os) {
404	Os.linux, Os.darwin => {	202	Os.linux, Os.darwin => {
405	const result = system.lseek(is.fd, 0, system.SEEK_CUR);	203	const result = system.lseek(self.handle, 0, system.SEEK_CUR);
406	const err = system.getErrno(result);	204	const err = system.getErrno(result);
407	if (err > 0) {	205	if (err > 0) {
408	return switch (err) {	206	return switch (err) {
...	@@ -420,9 +218,9 @@ pub const InStream = struct {	...	@@ -420,9 +218,9 @@ pub const InStream = struct {
420	}	218	}
421	}	219	}
422		220
423	pub fn getEndPos(is: &InStream) -> %usize {	221	pub fn getEndPos(self: &File) -> %usize {
424	var stat: system.Stat = undefined;	222	var stat: system.Stat = undefined;
425	const err = system.getErrno(system.fstat(is.fd, &stat));	223	const err = system.getErrno(system.fstat(self.handle, &stat));
426	if (err > 0) {	224	if (err > 0) {
427	return switch (err) {	225	return switch (err) {
428	system.EBADF => error.BadFd,	226	system.EBADF => error.BadFd,
...	@@ -434,89 +232,217 @@ pub const InStream = struct {	...	@@ -434,89 +232,217 @@ pub const InStream = struct {
434	return usize(stat.size);	232	return usize(stat.size);
435	}	233	}
436		234
437	pub fn readAll(is: &InStream, buf: &Buffer) -> %void {	235	fn readFn(in_stream: &InStream, buffer: []u8) -> %usize {
438	%return buf.resize(os.page_size);	236	const self = @fieldParentPtr(File, "in_stream", in_stream);
		237	if (is_posix) {
		238	var index: usize = 0;
		239	while (index < buffer.len) {
		240	const amt_read = system.read(self.handle, &buffer[index], buffer.len - index);
		241	const read_err = system.getErrno(amt_read);
		242	if (read_err > 0) {
		243	switch (read_err) {
		244	system.EINTR => continue,
		245	system.EINVAL => unreachable,
		246	system.EFAULT => unreachable,
		247	system.EBADF => return error.BadFd,
		248	system.EIO => return error.Io,
		249	else => return os.unexpectedErrorPosix(read_err),
		250	}
		251	}
		252	if (amt_read == 0) return index;
		253	index += amt_read;
		254	}
		255	return index;
		256	} else if (is_windows) {
		257	var index: usize = 0;
		258	while (index < buffer.len) {
		259	const want_read_count = system.DWORD(math.min(system.DWORD(@maxValue(system.DWORD)), buffer.len - index));
		260	var amt_read: system.DWORD = undefined;
		261	if (system.ReadFile(self.handle, @ptrCast(&c_void, &buffer[index]), want_read_count, &amt_read, null) == 0) {
		262	const err = system.GetLastError();
		263	return switch (err) {
		264	system.ERROR.OPERATION_ABORTED => continue,
		265	system.ERROR.BROKEN_PIPE => return index,
		266	else => os.unexpectedErrorWindows(err),
		267	};
		268	}
		269	if (amt_read == 0) return index;
		270	index += amt_read;
		271	}
		272	return index;
		273	} else {
		274	unreachable;
		275	}
		276	}
		277
		278	fn writeFn(out_stream: &OutStream, bytes: []const u8) -> %void {
		279	const self = @fieldParentPtr(File, "out_stream", out_stream);
		280	if (is_posix) {
		281	%return os.posixWrite(self.handle, bytes);
		282	} else if (is_windows) {
		283	%return os.windowsWrite(self.handle, bytes);
		284	} else {
		285	@compileError("Unsupported OS");
		286	}
		287	}
		288
		289	};
		290
		291	/// `path` may need to be copied in memory to add a null terminating byte. In this case
		292	/// a fixed size buffer of size `std.os.max_noalloc_path_len` is an attempted solution. If the fixed
		293	/// size buffer is too small, and the provided allocator is null, `error.NameTooLong` is returned.
		294	/// otherwise if the fixed size buffer is too small, allocator is used to obtain the needed memory.
		295	pub fn writeFile(path: []const u8, data: []const u8, allocator: ?&mem.Allocator) -> %void {
		296	var file = %return File.openWrite(path, allocator);
		297	defer file.close();
		298	%return file.out_stream.write(data);
		299	}
		300
		301	error StreamTooLong;
		302	error EndOfStream;
		303
		304	pub const InStream = struct {
		305	/// Return the number of bytes read. If the number read is smaller than buf.len, it
		306	/// means the stream reached the end. Reaching the end of a stream is not an error
		307	/// condition.
		308	readFn: fn(self: &InStream, buffer: []u8) -> %usize,
		309
		310	/// Replaces `buffer` contents by reading from the stream until it is finished.
		311	/// If `buffer.len()` woould exceed `max_size`, `error.StreamTooLong` is returned and
		312	/// the contents read from the stream are lost.
		313	pub fn readAllBuffer(self: &InStream, buffer: &Buffer, max_size: usize) -> %void {
		314	%return buffer.resize(0);
439		315
440	var actual_buf_len: usize = 0;	316	var actual_buf_len: usize = 0;
441	while (true) {	317	while (true) {
442	const dest_slice = buf.toSlice()[actual_buf_len..];	318	const dest_slice = buffer.toSlice()[actual_buf_len..];
443	const bytes_read = %return is.read(dest_slice);	319	const bytes_read = %return self.readFn(self, dest_slice);
444	actual_buf_len += bytes_read;	320	actual_buf_len += bytes_read;
445		321
446	if (bytes_read != dest_slice.len) {	322	if (bytes_read != dest_slice.len) {
447	return buf.resize(actual_buf_len);	323	buffer.shrink(actual_buf_len);
		324	return;
448	}	325	}
449		326
450	%return buf.resize(actual_buf_len + os.page_size);	327	const new_buf_size = math.min(max_size, actual_buf_len + os.page_size);
		328	if (new_buf_size == actual_buf_len)
		329	return error.StreamTooLong;
		330	%return buffer.resize(new_buf_size);
451	}	331	}
452	}	332	}
453		333
454	pub fn readLine(is: &InStream, buf: &Buffer) -> %void {	334	/// Allocates enough memory to hold all the contents of the stream. If the allocated
		335	/// memory would be greater than `max_size`, returns `error.StreamTooLong`.
		336	/// Caller owns returned memory.
		337	/// If this function returns an error, the contents from the stream read so far are lost.
		338	pub fn readAllAlloc(self: &InStream, allocator: &mem.Allocator, max_size: usize) -> %[]u8 {
		339	var buf = Buffer.initNull(allocator);
		340	defer buf.deinit();
		341
		342	%return self.readAllBuffer(self, &buf, max_size);
		343	return buf.toOwnedSlice();
		344	}
		345
		346	/// Replaces `buffer` contents by reading from the stream until `delimiter` is found.
		347	/// Does not include the delimiter in the result.
		348	/// If `buffer.len()` would exceed `max_size`, `error.StreamTooLong` is returned and the contents
		349	/// read from the stream so far are lost.
		350	pub fn readUntilDelimiterBuffer(self: &InStream, buffer: &Buffer, delimiter: u8, max_size: usize) -> %void {
455	%return buf.resize(0);	351	%return buf.resize(0);
456		352
457	while (true) {	353	while (true) {
458	var byte: u8 = %return is.readByte();	354	var byte: u8 = %return self.readByte();
459	%return buf.appendByte(byte);
460		355
461	if (buf.endsWith(os.line_sep)) {	356	if (byte == delimiter) {
462	break;	357	return;
463	}	358	}
464	}
465	}
466		359
467	pub fn isTty(self: &InStream) -> %bool {	360	if (buf.len() == max_size) {
468	if (is_posix) {	361	return error.StreamTooLong;
469	if (builtin.link_libc) {
470	return c.isatty(self.fd) != 0;
471	} else {
472	return system.isatty(self.fd);
473	}	362	}
474	} else if (is_windows) {	363
475	return os.windowsIsTty(%return self.getHandle());	364	%return buf.appendByte(byte);
476	} else {
477	@compileError("Unsupported OS");
478	}	365	}
479	}	366	}
480		367
481	fn getHandle(self: &InStream) -> %system.HANDLE {	368	/// Allocates enough memory to read until `delimiter`. If the allocated
482	if (self.handle) \|handle\| return handle;	369	/// memory would be greater than `max_size`, returns `error.StreamTooLong`.
483	if (system.GetStdHandle(self.handle_id)) \|handle\| {	370	/// Caller owns returned memory.
484	if (handle == system.INVALID_HANDLE_VALUE) {	371	/// If this function returns an error, the contents from the stream read so far are lost.
485	const err = system.GetLastError();	372	pub fn readUntilDelimiterAlloc(self: &InStream, allocator: &mem.Allocator,
486	return switch (err) {	373	delimiter: u8, max_size: usize) -> %[]u8
487	else => os.unexpectedErrorWindows(err),	374	{
488	};	375	var buf = Buffer.initNull(allocator);
489	}	376	defer buf.deinit();
490	self.handle = handle;	377
491	return handle;	378	%return self.readUntilDelimiterBuffer(self, &buf, delimiter, max_size);
492	} else {	379	return buf.toOwnedSlice();
493	return error.NoStdHandles;	380	}
494	}	381
		382	/// Returns the number of bytes read. If the number read is smaller than buf.len, it
		383	/// means the stream reached the end. Reaching the end of a stream is not an error
		384	/// condition.
		385	pub fn read(self: &InStream, buffer: []u8) -> %usize {
		386	return self.readFn(self, buffer);
		387	}
		388
		389	/// Same as `read` but end of stream returns `error.EndOfStream`.
		390	pub fn readNoEof(self: &InStream, buf: []u8) -> %void {
		391	const amt_read = %return self.read(buf);
		392	if (amt_read < buf.len) return error.EndOfStream;
		393	}
		394
		395	/// Reads 1 byte from the stream or returns `error.EndOfStream`.
		396	pub fn readByte(self: &InStream) -> %u8 {
		397	var result: [1]u8 = undefined;
		398	%return self.readNoEof(result[0..]);
		399	return result[0];
495	}	400	}
		401
		402	/// Same as `readByte` except the returned byte is signed.
		403	pub fn readByteSigned(self: &InStream) -> %i8 {
		404	return @bitCast(i8, %return self.readByte());
		405	}
		406
		407	pub fn readIntLe(self: &InStream, comptime T: type) -> %T {
		408	return self.readInt(false, T);
		409	}
		410
		411	pub fn readIntBe(self: &InStream, comptime T: type) -> %T {
		412	return self.readInt(true, T);
		413	}
		414
		415	pub fn readInt(self: &InStream, is_be: bool, comptime T: type) -> %T {
		416	var bytes: [@sizeOf(T)]u8 = undefined;
		417	%return self.readNoEof(bytes[0..]);
		418	return mem.readInt(bytes, T, is_be);
		419	}
		420
		421	pub fn readVarInt(self: &InStream, is_be: bool, comptime T: type, size: usize) -> %T {
		422	assert(size <= @sizeOf(T));
		423	assert(size <= 8);
		424	var input_buf: [8]u8 = undefined;
		425	const input_slice = input_buf[0..size];
		426	%return self.readNoEof(input_slice);
		427	return mem.readInt(input_slice, T, is_be);
		428	}
		429
		430
496	};	431	};
497		432
498	pub fn openSelfExe() -> %InStream {	433	pub const OutStream = struct {
499	switch (builtin.os) {	434	writeFn: fn(self: &OutStream, bytes: []const u8) -> %void,
500	Os.linux => {	435
501	return InStream.open("/proc/self/exe", null);	436	pub fn print(self: &OutStream, comptime format: []const u8, args: ...) -> %void {
502	},	437	return std.fmt.format(self, self.writeFn, format, args);
503	Os.darwin => {
504	debug.panic("TODO: openSelfExe on Darwin");
505	},
506	else => @compileError("Unsupported OS"),
507	}	438	}
508	}
509		439
510	/// `path` may need to be copied in memory to add a null terminating byte. In this case	440	pub fn write(self: &OutStream, bytes: []const u8) -> %void {
511	/// a fixed size buffer of size std.os.max_noalloc_path_len is an attempted solution. If the fixed	441	return self.writeFn(self, bytes);
512	/// size buffer is too small, and the provided allocator is null, error.NameTooLong is returned.	442	}
513	/// otherwise if the fixed size buffer is too small, allocator is used to obtain the needed memory.	443
514	pub fn writeFile(path: []const u8, data: []const u8, allocator: ?&mem.Allocator) -> %void {	444	pub fn writeByte(self: &OutStream, byte: u8) -> %void {
515	// TODO have an unbuffered File abstraction and use that here.	445	const slice = (&byte)[0..1];
516	// Then a buffered out stream abstraction can go on top of that for	446	return self.writeFn(self, slice);
517	// use cases like stdout and stderr.	447	}
518	var out_stream = %return OutStream.open(path, allocator);	448	};
519	defer out_stream.close();
520	%return out_stream.write(data);
521	%return out_stream.flush();
522	}

std/mem.zig-152

...	@@ -1,16 +1,9 @@	...	@@ -1,16 +1,9 @@
1	const debug = @import("debug.zig");	1	const debug = @import("debug.zig");
2	const assert = debug.assert;	2	const assert = debug.assert;
3	const math = @import("math/index.zig");	3	const math = @import("math/index.zig");
4	const os = @import("os/index.zig");
5	const io = @import("io.zig");
6	const builtin = @import("builtin");
7	const Os = builtin.Os;
8	const c = @import("c/index.zig");
9		4
10	pub const Cmp = math.Cmp;	5	pub const Cmp = math.Cmp;
11		6
12	error OutOfMemory;
13
14	pub const Allocator = struct {	7	pub const Allocator = struct {
15	/// Allocate byte_count bytes and return them in a slice, with the	8	/// Allocate byte_count bytes and return them in a slice, with the
16	/// slicer's pointer aligned at least to alignment bytes.	9	/// slicer's pointer aligned at least to alignment bytes.
...	@@ -85,151 +78,6 @@ pub const Allocator = struct {	...	@@ -85,151 +78,6 @@ pub const Allocator = struct {
85	}	78	}
86	};	79	};
87		80
88	pub var c_allocator = Allocator {
89	.allocFn = cAlloc,
90	.reallocFn = cRealloc,
91	.freeFn = cFree,
92	};
93
94	fn cAlloc(self: &Allocator, n: usize, alignment: usize) -> %[]u8 {
95	if (c.malloc(usize(n))) \|mem\| {
96	@ptrCast(&u8, mem)[0..n]
97	} else {
98	error.OutOfMemory
99	}
100	}
101
102	fn cRealloc(self: &Allocator, old_mem: []u8, new_size: usize, alignment: usize) -> %[]u8 {
103	if (new_size <= old_mem.len) {
104	old_mem[0..new_size]
105	} else {
106	const old_ptr = @ptrCast(&c_void, old_mem.ptr);
107	if (c.realloc(old_ptr, usize(new_size))) \|mem\| {
108	@ptrCast(&u8, mem)[0..new_size]
109	} else {
110	error.OutOfMemory
111	}
112	}
113	}
114
115	fn cFree(self: &Allocator, old_mem: []u8) {
116	const old_ptr = @ptrCast(&c_void, old_mem.ptr);
117	c.free(old_ptr);
118	}
119
120	pub const IncrementingAllocator = struct {
121	allocator: Allocator,
122	bytes: []u8,
123	end_index: usize,
124	heap_handle: if (builtin.os == Os.windows) os.windows.HANDLE else void,
125
126	fn init(capacity: usize) -> %IncrementingAllocator {
127	switch (builtin.os) {
128	Os.linux, Os.darwin, Os.macosx, Os.ios => {
129	const p = os.posix;
130	const addr = p.mmap(null, capacity, p.PROT_READ\|p.PROT_WRITE,
131	p.MAP_PRIVATE\|p.MAP_ANONYMOUS\|p.MAP_NORESERVE, -1, 0);
132	if (addr == p.MAP_FAILED) {
133	return error.OutOfMemory;
134	}
135	return IncrementingAllocator {
136	.allocator = Allocator {
137	.allocFn = alloc,
138	.reallocFn = realloc,
139	.freeFn = free,
140	},
141	.bytes = @intToPtr(&u8, addr)[0..capacity],
142	.end_index = 0,
143	.heap_handle = {},
144	};
145	},
146	Os.windows => {
147	const heap_handle = os.windows.GetProcessHeap() ?? return error.OutOfMemory;
148	const ptr = os.windows.HeapAlloc(heap_handle, 0, capacity) ?? return error.OutOfMemory;
149	return IncrementingAllocator {
150	.allocator = Allocator {
151	.allocFn = alloc,
152	.reallocFn = realloc,
153	.freeFn = free,
154	},
155	.bytes = @ptrCast(&u8, ptr)[0..capacity],
156	.end_index = 0,
157	.heap_handle = heap_handle,
158	};
159	},
160	else => @compileError("Unsupported OS"),
161	}
162	}
163
164	fn deinit(self: &IncrementingAllocator) {
165	switch (builtin.os) {
166	Os.linux, Os.darwin, Os.macosx, Os.ios => {
167	_ = os.posix.munmap(self.bytes.ptr, self.bytes.len);
168	},
169	Os.windows => {
170	_ = os.windows.HeapFree(self.heap_handle, 0, @ptrCast(os.windows.LPVOID, self.bytes.ptr));
171	},
172	else => @compileError("Unsupported OS"),
173	}
174	}
175
176	fn reset(self: &IncrementingAllocator) {
177	self.end_index = 0;
178	}
179
180	fn bytesLeft(self: &const IncrementingAllocator) -> usize {
181	return self.bytes.len - self.end_index;
182	}
183
184	fn alloc(allocator: &Allocator, n: usize, alignment: usize) -> %[]u8 {
185	const self = @fieldParentPtr(IncrementingAllocator, "allocator", allocator);
186	const addr = @ptrToInt(&self.bytes[self.end_index]);
187	const rem = @rem(addr, alignment);
188	const march_forward_bytes = if (rem == 0) 0 else (alignment - rem);
189	const adjusted_index = self.end_index + march_forward_bytes;
190	const new_end_index = adjusted_index + n;
191	if (new_end_index > self.bytes.len) {
192	return error.OutOfMemory;
193	}
194	const result = self.bytes[adjusted_index .. new_end_index];
195	self.end_index = new_end_index;
196	return result;
197	}
198
199	fn realloc(allocator: &Allocator, old_mem: []u8, new_size: usize, alignment: usize) -> %[]u8 {
200	if (new_size <= old_mem.len) {
201	return old_mem[0..new_size];
202	} else {
203	const result = %return alloc(allocator, new_size, alignment);
204	copy(u8, result, old_mem);
205	return result;
206	}
207	}
208
209	fn free(allocator: &Allocator, bytes: []u8) {
210	// Do nothing. That's the point of an incrementing allocator.
211	}
212	};
213
214	test "mem.IncrementingAllocator" {
215	const total_bytes = 100 * 1024 * 1024;
216	var inc_allocator = %%IncrementingAllocator.init(total_bytes);
217	defer inc_allocator.deinit();
218
219	const allocator = &inc_allocator.allocator;
220	const slice = %%allocator.alloc(&i32, 100);
221
222	for (slice) \|*item, i\| {
223	*item = %%allocator.create(i32);
224	**item = i32(i);
225	}
226
227	assert(inc_allocator.bytesLeft() == total_bytes - @sizeOf(i32) * 100 - @sizeOf(usize) * 100);
228
229	inc_allocator.reset();
230
231	assert(inc_allocator.bytesLeft() == total_bytes);
232	}
233		81
234	/// Copy all of source into dest at position 0.	82	/// Copy all of source into dest at position 0.
235	/// dest.len must be >= source.len.	83	/// dest.len must be >= source.len.

std/os/child_process.zig+39-103

 @@ -28,9 +28,9 @@ pub const ChildProcess = struct {
     pub allocator: &mem.Allocator,
-    pub stdin: ?&io.OutStream,
+    pub stdin: ?io.File,
-    pub stdout: ?&io.InStream,
+    pub stdout: ?io.File,
-    pub stderr: ?&io.InStream,
+    pub stderr: ?io.File,
     pub term: ?%Term,
 @@ -250,17 +250,17 @@ pub const ChildProcess = struct {
     }
     fn cleanupStreams(self: &ChildProcess) {
-        if (self.stdin) |stdin| { stdin.close(); self.allocator.destroy(stdin); self.stdin = null; }
+        if (self.stdin) |*stdin| { stdin.close(); self.stdin = null; }
-        if (self.stdout) |stdout| { stdout.close(); self.allocator.destroy(stdout); self.stdout = null; }
+        if (self.stdout) |*stdout| { stdout.close(); self.stdout = null; }
-        if (self.stderr) |stderr| { stderr.close(); self.allocator.destroy(stderr); self.stderr = null; }
+        if (self.stderr) |*stderr| { stderr.close(); self.stderr = null; }
     }
     fn cleanupAfterWait(self: &ChildProcess, status: i32) -> %Term {
         children_nodes.remove(&self.llnode);
         defer {
-            os.posixClose(self.err_pipe[0]);
+            os.close(self.err_pipe[0]);
-            os.posixClose(self.err_pipe[1]);
+            os.close(self.err_pipe[1]);
         };
         // Write @maxValue(ErrInt) to the write end of the err_pipe. This is after
 @@ -310,7 +310,7 @@ pub const ChildProcess = struct {
         } else {
             undefined
         };
-        defer { if (any_ignore) os.posixClose(dev_null_fd); };
+        defer { if (any_ignore) os.close(dev_null_fd); };
         var env_map_owned: BufMap = undefined;
         var we_own_env_map: bool = undefined;
 @@ -329,27 +329,6 @@ pub const ChildProcess = struct {
         const err_pipe = %return makePipe();
         %defer destroyPipe(err_pipe);
-        const stdin_ptr = if (self.stdin_behavior == StdIo.Pipe) {
-            %return self.allocator.create(io.OutStream)
-        } else {
-            null
-        };
-        %defer if (stdin_ptr) |ptr| self.allocator.destroy(ptr);
-        const stdout_ptr = if (self.stdout_behavior == StdIo.Pipe) {
-            %return self.allocator.create(io.InStream)
-        } else {
-            null
-        };
-        %defer if (stdout_ptr) |ptr| self.allocator.destroy(ptr);
-        const stderr_ptr = if (self.stderr_behavior == StdIo.Pipe) {
-            %return self.allocator.create(io.InStream)
-        } else {
-            null
-        };
-        %defer if (stderr_ptr) |ptr| self.allocator.destroy(ptr);
         block_SIGCHLD();
         const pid_result = posix.fork();
         const pid_err = posix.getErrno(pid_result);
 @@ -390,46 +369,35 @@ pub const ChildProcess = struct {
         // we are the parent
         const pid = i32(pid_result);
-        if (stdin_ptr) |outstream| {
+        if (self.stdin_behavior == StdIo.Pipe) {
-            *outstream = io.OutStream {
+            self.stdin = io.File.openHandle(stdin_pipe[1]);
-                .fd = stdin_pipe[1],
+        } else {
-                .handle = {},
+            self.stdin = null;
-                .handle_id = {},
-                .buffer = undefined,
-                .index = 0,
-            };
         }
-        if (stdout_ptr) |instream| {
+        if (self.stdout_behavior == StdIo.Pipe) {
-            *instream = io.InStream {
+            self.stdout = io.File.openHandle(stdout_pipe[0]);
-                .fd = stdout_pipe[0],
+        } else {
-                .handle = {},
+            self.stdout = null;
-                .handle_id = {},
-            };
         }
-        if (stderr_ptr) |instream| {
+        if (self.stderr_behavior == StdIo.Pipe) {
-            *instream = io.InStream {
+            self.stderr = io.File.openHandle(stderr_pipe[0]);
-                .fd = stderr_pipe[0],
+        } else {
-                .handle = {},
+            self.stderr = null;
-                .handle_id = {},
-            };
         }
         self.pid = pid;
         self.err_pipe = err_pipe;
         self.llnode = LinkedList(&ChildProcess).Node.init(self);
         self.term = null;
-        self.stdin = stdin_ptr;
-        self.stdout = stdout_ptr;
-        self.stderr = stderr_ptr;
         // TODO make this atomic so it works even with threads
         children_nodes.prepend(&self.llnode);
         restore_SIGCHLD();
-        if (self.stdin_behavior == StdIo.Pipe) { os.posixClose(stdin_pipe[0]); }
+        if (self.stdin_behavior == StdIo.Pipe) { os.close(stdin_pipe[0]); }
-        if (self.stdout_behavior == StdIo.Pipe) { os.posixClose(stdout_pipe[1]); }
+        if (self.stdout_behavior == StdIo.Pipe) { os.close(stdout_pipe[1]); }
-        if (self.stderr_behavior == StdIo.Pipe) { os.posixClose(stderr_pipe[1]); }
+        if (self.stderr_behavior == StdIo.Pipe) { os.close(stderr_pipe[1]); }
     }
     fn spawnWindows(self: &ChildProcess) -> %void {
 @@ -509,27 +477,6 @@ pub const ChildProcess = struct {
         }
         %defer if (self.stdin_behavior == StdIo.Pipe) { windowsDestroyPipe(g_hChildStd_ERR_Rd, g_hChildStd_ERR_Wr); };
-        const stdin_ptr = if (self.stdin_behavior == StdIo.Pipe) {
-            %return self.allocator.create(io.OutStream)
-        } else {
-            null
-        };
-        %defer if (stdin_ptr) |ptr| self.allocator.destroy(ptr);
-        const stdout_ptr = if (self.stdout_behavior == StdIo.Pipe) {
-            %return self.allocator.create(io.InStream)
-        } else {
-            null
-        };
-        %defer if (stdout_ptr) |ptr| self.allocator.destroy(ptr);
-        const stderr_ptr = if (self.stderr_behavior == StdIo.Pipe) {
-            %return self.allocator.create(io.InStream)
-        } else {
-            null
-        };
-        %defer if (stderr_ptr) |ptr| self.allocator.destroy(ptr);
         const cmd_line = %return windowsCreateCommandLine(self.allocator, self.argv);
         defer self.allocator.free(cmd_line);
 @@ -609,36 +556,25 @@ pub const ChildProcess = struct {
             }
         };
-        if (stdin_ptr) |outstream| {
+        if (self.stdin_behavior == StdIo.Pipe) {
-            *outstream = io.OutStream {
+            self.stdin = io.File.openHandle(g_hChildStd_IN_Wr);
-                .fd = {},
+        } else {
-                .handle = g_hChildStd_IN_Wr,
+            self.stdin = null;
-                .handle_id = undefined,
-                .buffer = undefined,
-                .index = 0,
-            };
         }
-        if (stdout_ptr) |instream| {
+        if (self.stdout_behavior == StdIo.Pipe) {
-            *instream = io.InStream {
+            self.stdout = io.File.openHandle(g_hChildStd_OUT_Rd);
-                .fd = {},
+        } else {
-                .handle = g_hChildStd_OUT_Rd,
+            self.stdout = null;
-                .handle_id = undefined,
-            };
         }
-        if (stderr_ptr) |instream| {
+        if (self.stderr_behavior == StdIo.Pipe) {
-            *instream = io.InStream {
+            self.stderr = io.File.openHandle(g_hChildStd_ERR_Rd);
-                .fd = {},
+        } else {
-                .handle = g_hChildStd_ERR_Rd,
+            self.stderr = null;
-                .handle_id = undefined,
-            };
         }
         self.handle = piProcInfo.hProcess;
         self.thread_handle = piProcInfo.hThread;
         self.term = null;
-        self.stdin = stdin_ptr;
-        self.stdout = stdout_ptr;
-        self.stderr = stderr_ptr;
         if (self.stdin_behavior == StdIo.Pipe) { os.windowsClose(??g_hChildStd_IN_Rd); }
         if (self.stderr_behavior == StdIo.Pipe) { os.windowsClose(??g_hChildStd_ERR_Wr); }
 @@ -648,7 +584,7 @@ pub const ChildProcess = struct {
     fn setUpChildIo(stdio: StdIo, pipe_fd: i32, std_fileno: i32, dev_null_fd: i32) -> %void {
         switch (stdio) {
             StdIo.Pipe => %return os.posixDup2(pipe_fd, std_fileno),
-            StdIo.Close => os.posixClose(std_fileno),
+            StdIo.Close => os.close(std_fileno),
             StdIo.Inherit => {},
             StdIo.Ignore => %return os.posixDup2(dev_null_fd, std_fileno),
         }
 @@ -771,8 +707,8 @@ fn makePipe() -> %[2]i32 {
 }
 fn destroyPipe(pipe: &const [2]i32) {
-    os.posixClose((*pipe)[0]);
+    os.close((*pipe)[0]);
-    os.posixClose((*pipe)[1]);
+    os.close((*pipe)[1]);
 }
 // Child of fork calls this to report an error to the fork parent.

std/os/index.zig+65-22

 @@ -1,6 +1,7 @@
 const builtin = @import("builtin");
 const Os = builtin.Os;
 const is_windows = builtin.os == Os.windows;
+const os = this;
 pub const windows = @import("windows/index.zig");
 pub const darwin = @import("darwin.zig");
 @@ -26,14 +27,14 @@ pub const UserInfo = @import("get_user_id.zig").UserInfo;
 pub const getUserInfo = @import("get_user_id.zig").getUserInfo;
 const windows_util = @import("windows/util.zig");
-pub const windowsClose = windows_util.windowsClose;
 pub const windowsWaitSingle = windows_util.windowsWaitSingle;
 pub const windowsWrite = windows_util.windowsWrite;
-pub const windowsIsTty = windows_util.windowsIsTty;
 pub const windowsIsCygwinPty = windows_util.windowsIsCygwinPty;
 pub const windowsOpen = windows_util.windowsOpen;
 pub const createWindowsEnvBlock = windows_util.createWindowsEnvBlock;
+pub const FileHandle = if (is_windows) windows.HANDLE else i32;
 const debug = @import("../debug.zig");
 const assert = debug.assert;
 @@ -88,7 +89,7 @@ pub fn getRandomBytes(buf: []u8) -> %void {
         Os.darwin, Os.macosx, Os.ios => {
             const fd = %return posixOpen("/dev/urandom", posix.O_RDONLY|posix.O_CLOEXEC,
                 0, null);
-            defer posixClose(fd);
+            defer close(fd);
             %return posixRead(fd, buf);
         },
 @@ -165,14 +166,18 @@ pub coldcc fn exit(status: i32) -> noreturn {
     }
 }
-/// Calls POSIX close, and keeps trying if it gets interrupted.
+/// Closes the file handle. Keeps trying if it gets interrupted by a signal.
-pub fn posixClose(fd: i32) {
+pub fn close(handle: FileHandle) {
-    while (true) {
+    if (is_windows) {
-        const err = posix.getErrno(posix.close(fd));
+        windows_util.windowsClose(handle);
-        if (err == posix.EINTR) {
+    } else {
-            continue;
+        while (true) {
-        } else {
+            const err = posix.getErrno(posix.close(handle));
-            return;
+            if (err == posix.EINTR) {
+                continue;
+            } else {
+                return;
+            }
         }
     }
 }
 @@ -716,19 +721,18 @@ pub fn copyFileMode(allocator: &Allocator, source_path: []const u8, dest_path: [
     %return getRandomBytes(rand_buf[0..]);
     _ = base64.encodeWithAlphabet(tmp_path[dest_path.len..], rand_buf, b64_fs_alphabet);
-    var out_stream = %return io.OutStream.openMode(tmp_path, mode, allocator);
+    var out_file = %return io.File.openWriteMode(tmp_path, mode, allocator);
-    defer out_stream.close();
+    defer out_file.close();
     %defer _ = deleteFile(allocator, tmp_path);
-    var in_stream = %return io.InStream.open(source_path, allocator);
+    var in_file = %return io.File.openRead(source_path, allocator);
-    defer in_stream.close();
+    defer in_file.close();
-    const buf = out_stream.buffer[0..];
+    var buf: [page_size]u8 = undefined;
     while (true) {
-        const amt = %return in_stream.read(buf);
+        const amt = %return in_file.in_stream.read(buf[0..]);
-        out_stream.index = amt;
+        %return out_file.out_stream.write(buf[0..amt]);
-        %return out_stream.flush();
+        if (amt != buf.len)
-        if (amt != out_stream.buffer.len)
             return rename(allocator, tmp_path, dest_path);
     }
 }
 @@ -973,7 +977,7 @@ pub const Dir = struct {
     pub fn close(self: &Dir) {
         self.allocator.free(self.buf);
-        posixClose(self.fd);
+        close(self.fd);
     }
     /// Memory such as file names referenced in this returned entry becomes invalid
 @@ -1135,7 +1139,6 @@ test "os.sleep" {
     sleep(0, 1);
 }
 error ResourceLimitReached;
 error InvalidUserId;
 error PermissionDenied;
 @@ -1184,6 +1187,21 @@ pub fn posix_setregid(rgid: u32, egid: u32) -> %void {
     };
 }
+error NoStdHandles;
+pub fn windowsGetStdHandle(handle_id: windows.DWORD) -> %windows.HANDLE {
+    if (windows.GetStdHandle(handle_id)) |handle| {
+        if (handle == windows.INVALID_HANDLE_VALUE) {
+            const err = windows.GetLastError();
+            return switch (err) {
+                else => os.unexpectedErrorWindows(err),
+            };
+        }
+        return handle;
+    } else {
+        return error.NoStdHandles;
+    }
+}
 pub const ArgIteratorPosix = struct {
     index: usize,
     count: usize,
 @@ -1458,3 +1476,28 @@ pub fn unexpectedErrorWindows(err: windows.DWORD) -> error {
     }
     return error.Unexpected;
 }
+pub fn openSelfExe() -> %io.File {
+    switch (builtin.os) {
+        Os.linux => {
+            return io.File.openRead("/proc/self/exe", null);
+        },
+        Os.darwin => {
+            @panic("TODO: openSelfExe on Darwin");
+        },
+        else => @compileError("Unsupported OS"),
+    }
+}
+pub fn isTty(handle: FileHandle) -> bool {
+    if (is_windows) {
+        return windows_util.windowsIsTty(handle);
+    } else {
+        if (builtin.link_libc) {
+            return c.isatty(handle) != 0;
+        } else {
+            return posix.isatty(handle);
+        }
+    }
+}

std/os/path.zig+2-2

...	@@ -940,7 +940,7 @@ pub fn real(allocator: &Allocator, pathname: []const u8) -> %[]u8 {	...	@@ -940,7 +940,7 @@ pub fn real(allocator: &Allocator, pathname: []const u8) -> %[]u8 {
940	else => os.unexpectedErrorWindows(err),	940	else => os.unexpectedErrorWindows(err),
941	};	941	};
942	}	942	}
943	defer os.windowsClose(h_file);	943	defer os.close(h_file);
944	var buf = %return allocator.alloc(u8, 256);	944	var buf = %return allocator.alloc(u8, 256);
945	%defer allocator.free(buf);	945	%defer allocator.free(buf);
946	while (true) {	946	while (true) {
...	@@ -1009,7 +1009,7 @@ pub fn real(allocator: &Allocator, pathname: []const u8) -> %[]u8 {	...	@@ -1009,7 +1009,7 @@ pub fn real(allocator: &Allocator, pathname: []const u8) -> %[]u8 {
1009	},	1009	},
1010	Os.linux => {	1010	Os.linux => {
1011	const fd = %return os.posixOpen(pathname, posix.O_PATH\|posix.O_NONBLOCK\|posix.O_CLOEXEC, 0, allocator);	1011	const fd = %return os.posixOpen(pathname, posix.O_PATH\|posix.O_NONBLOCK\|posix.O_CLOEXEC, 0, allocator);
1012	defer os.posixClose(fd);	1012	defer os.close(fd);
1013		1013
1014	var buf: ["/proc/self/fd/-2147483648".len]u8 = undefined;	1014	var buf: ["/proc/self/fd/-2147483648".len]u8 = undefined;
1015	const proc_path = fmt.bufPrint(buf[0..], "/proc/self/fd/{}", fd);	1015	const proc_path = fmt.bufPrint(buf[0..], "/proc/self/fd/{}", fd);

std/special/build_runner.zig+33-27

...	@@ -6,6 +6,7 @@ const os = std.os;	...	@@ -6,6 +6,7 @@ const os = std.os;
6	const Builder = std.build.Builder;	6	const Builder = std.build.Builder;
7	const mem = std.mem;	7	const mem = std.mem;
8	const ArrayList = std.ArrayList;	8	const ArrayList = std.ArrayList;
		9	const warn = std.debug.warn;
9		10
10	error InvalidArgs;	11	error InvalidArgs;
11		12
...	@@ -13,7 +14,7 @@ pub fn main() -> %void {	...	@@ -13,7 +14,7 @@ pub fn main() -> %void {
13	var arg_it = os.args();	14	var arg_it = os.args();
14		15
15	// TODO use a more general purpose allocator here	16	// TODO use a more general purpose allocator here
16	var inc_allocator = %%mem.IncrementingAllocator.init(20 * 1024 * 1024);	17	var inc_allocator = %%std.heap.IncrementingAllocator.init(20 * 1024 * 1024);
17	defer inc_allocator.deinit();	18	defer inc_allocator.deinit();
18		19
19	const allocator = &inc_allocator.allocator;	20	const allocator = &inc_allocator.allocator;
...	@@ -23,15 +24,15 @@ pub fn main() -> %void {	...	@@ -23,15 +24,15 @@ pub fn main() -> %void {
23	_ = arg_it.skip();	24	_ = arg_it.skip();
24		25
25	const zig_exe = %return unwrapArg(arg_it.next(allocator) ?? {	26	const zig_exe = %return unwrapArg(arg_it.next(allocator) ?? {
26	%%io.stderr.printf("Expected first argument to be path to zig compiler\n");	27	warn("Expected first argument to be path to zig compiler\n");
27	return error.InvalidArgs;	28	return error.InvalidArgs;
28	});	29	});
29	const build_root = %return unwrapArg(arg_it.next(allocator) ?? {	30	const build_root = %return unwrapArg(arg_it.next(allocator) ?? {
30	%%io.stderr.printf("Expected second argument to be build root directory path\n");	31	warn("Expected second argument to be build root directory path\n");
31	return error.InvalidArgs;	32	return error.InvalidArgs;
32	});	33	});
33	const cache_root = %return unwrapArg(arg_it.next(allocator) ?? {	34	const cache_root = %return unwrapArg(arg_it.next(allocator) ?? {
34	%%io.stderr.printf("Expected third argument to be cache root directory path\n");	35	warn("Expected third argument to be cache root directory path\n");
35	return error.InvalidArgs;	36	return error.InvalidArgs;
36	});	37	});
37		38
...	@@ -42,32 +43,37 @@ pub fn main() -> %void {	...	@@ -42,32 +43,37 @@ pub fn main() -> %void {
42		43
43	var prefix: ?[]const u8 = null;	44	var prefix: ?[]const u8 = null;
44		45
		46	var stderr_file = io.getStdErr();
		47	var stderr_stream: %&io.OutStream = if (stderr_file) \|*f\| &f.out_stream else \|err\| err;
		48	var stdout_file = io.getStdOut();
		49	var stdout_stream: %&io.OutStream = if (stdout_file) \|*f\| &f.out_stream else \|err\| err;
		50
45	while (arg_it.next(allocator)) \|err_or_arg\| {	51	while (arg_it.next(allocator)) \|err_or_arg\| {
46	const arg = %return unwrapArg(err_or_arg);	52	const arg = %return unwrapArg(err_or_arg);
47	if (mem.startsWith(u8, arg, "-D")) {	53	if (mem.startsWith(u8, arg, "-D")) {
48	const option_contents = arg[2..];	54	const option_contents = arg[2..];
49	if (option_contents.len == 0) {	55	if (option_contents.len == 0) {
50	%%io.stderr.printf("Expected option name after '-D'\n\n");	56	warn("Expected option name after '-D'\n\n");
51	return usage(&builder, false, &io.stderr);	57	return usageAndErr(&builder, false, %return stderr_stream);
52	}	58	}
53	if (mem.indexOfScalar(u8, option_contents, '=')) \|name_end\| {	59	if (mem.indexOfScalar(u8, option_contents, '=')) \|name_end\| {
54	const option_name = option_contents[0..name_end];	60	const option_name = option_contents[0..name_end];
55	const option_value = option_contents[name_end + 1..];	61	const option_value = option_contents[name_end + 1..];
56	if (builder.addUserInputOption(option_name, option_value))	62	if (builder.addUserInputOption(option_name, option_value))
57	return usage(&builder, false, &io.stderr);	63	return usageAndErr(&builder, false, %return stderr_stream);
58	} else {	64	} else {
59	if (builder.addUserInputFlag(option_contents))	65	if (builder.addUserInputFlag(option_contents))
60	return usage(&builder, false, &io.stderr);	66	return usageAndErr(&builder, false, %return stderr_stream);
61	}	67	}
62	} else if (mem.startsWith(u8, arg, "-")) {	68	} else if (mem.startsWith(u8, arg, "-")) {
63	if (mem.eql(u8, arg, "--verbose")) {	69	if (mem.eql(u8, arg, "--verbose")) {
64	builder.verbose = true;	70	builder.verbose = true;
65	} else if (mem.eql(u8, arg, "--help")) {	71	} else if (mem.eql(u8, arg, "--help")) {
66	return usage(&builder, false, &io.stdout);	72	return usage(&builder, false, %return stdout_stream);
67	} else if (mem.eql(u8, arg, "--prefix")) {	73	} else if (mem.eql(u8, arg, "--prefix")) {
68	prefix = %return unwrapArg(arg_it.next(allocator) ?? {	74	prefix = %return unwrapArg(arg_it.next(allocator) ?? {
69	%%io.stderr.printf("Expected argument after --prefix\n\n");	75	warn("Expected argument after --prefix\n\n");
70	return usage(&builder, false, &io.stderr);	76	return usageAndErr(&builder, false, %return stderr_stream);
71	});	77	});
72	} else if (mem.eql(u8, arg, "--verbose-tokenize")) {	78	} else if (mem.eql(u8, arg, "--verbose-tokenize")) {
73	builder.verbose_tokenize = true;	79	builder.verbose_tokenize = true;
...	@@ -82,8 +88,8 @@ pub fn main() -> %void {	...	@@ -82,8 +88,8 @@ pub fn main() -> %void {
82	} else if (mem.eql(u8, arg, "--verbose-cimport")) {	88	} else if (mem.eql(u8, arg, "--verbose-cimport")) {
83	builder.verbose_cimport = true;	89	builder.verbose_cimport = true;
84	} else {	90	} else {
85	%%io.stderr.printf("Unrecognized argument: {}\n\n", arg);	91	warn("Unrecognized argument: {}\n\n", arg);
86	return usage(&builder, false, &io.stderr);	92	return usageAndErr(&builder, false, %return stderr_stream);
87	}	93	}
88	} else {	94	} else {
89	%%targets.append(arg);	95	%%targets.append(arg);
...	@@ -94,11 +100,11 @@ pub fn main() -> %void {	...	@@ -94,11 +100,11 @@ pub fn main() -> %void {
94	root.build(&builder);	100	root.build(&builder);
95		101
96	if (builder.validateUserInputDidItFail())	102	if (builder.validateUserInputDidItFail())
97	return usage(&builder, true, &io.stderr);	103	return usageAndErr(&builder, true, %return stderr_stream);
98		104
99	builder.make(targets.toSliceConst()) %% \|err\| {	105	builder.make(targets.toSliceConst()) %% \|err\| {
100	if (err == error.InvalidStepName) {	106	if (err == error.InvalidStepName) {
101	return usage(&builder, true, &io.stderr);	107	return usageAndErr(&builder, true, %return stderr_stream);
102	}	108	}
103	return err;	109	return err;
104	};	110	};
...	@@ -112,7 +118,7 @@ fn usage(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream)	...	@@ -112,7 +118,7 @@ fn usage(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream)
112	}	118	}
113		119
114	// This usage text has to be synchronized with src/main.cpp	120	// This usage text has to be synchronized with src/main.cpp
115	%%out_stream.printf(	121	%return out_stream.print(
116	\\Usage: {} build [steps] [options]	122	\\Usage: {} build [steps] [options]
117	\\	123	\\
118	\\Steps:	124	\\Steps:
...	@@ -121,10 +127,10 @@ fn usage(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream)	...	@@ -121,10 +127,10 @@ fn usage(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream)
121		127
122	const allocator = builder.allocator;	128	const allocator = builder.allocator;
123	for (builder.top_level_steps.toSliceConst()) \|top_level_step\| {	129	for (builder.top_level_steps.toSliceConst()) \|top_level_step\| {
124	%%out_stream.printf(" {s22} {}\n", top_level_step.step.name, top_level_step.description);	130	%return out_stream.print(" {s22} {}\n", top_level_step.step.name, top_level_step.description);
125	}	131	}
126		132
127	%%out_stream.write(	133	%return out_stream.write(
128	\\	134	\\
129	\\General Options:	135	\\General Options:
130	\\ --help Print this help and exit	136	\\ --help Print this help and exit
...	@@ -136,17 +142,17 @@ fn usage(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream)	...	@@ -136,17 +142,17 @@ fn usage(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream)
136	);	142	);
137		143
138	if (builder.available_options_list.len == 0) {	144	if (builder.available_options_list.len == 0) {
139	%%out_stream.print(" (none)\n");	145	%return out_stream.print(" (none)\n");
140	} else {	146	} else {
141	for (builder.available_options_list.toSliceConst()) \|option\| {	147	for (builder.available_options_list.toSliceConst()) \|option\| {
142	const name = %%fmt.allocPrint(allocator,	148	const name = %return fmt.allocPrint(allocator,
143	" -D{}=${}", option.name, Builder.typeIdName(option.type_id));	149	" -D{}=${}", option.name, Builder.typeIdName(option.type_id));
144	defer allocator.free(name);	150	defer allocator.free(name);
145	%%out_stream.print("{s24} {}\n", name, option.description);	151	%return out_stream.print("{s24} {}\n", name, option.description);
146	}	152	}
147	}	153	}
148		154
149	%%out_stream.write(	155	%return out_stream.write(
150	\\	156	\\
151	\\Advanced Options:	157	\\Advanced Options:
152	\\ --build-file $file Override path to build.zig	158	\\ --build-file $file Override path to build.zig
...	@@ -159,16 +165,16 @@ fn usage(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream)	...	@@ -159,16 +165,16 @@ fn usage(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream)
159	\\ --verbose-cimport Enable compiler debug output for C imports	165	\\ --verbose-cimport Enable compiler debug output for C imports
160	\\	166	\\
161	);	167	);
		168	}
162		169
163	%%out_stream.flush();	170	fn usageAndErr(builder: &Builder, already_ran_build: bool, out_stream: &io.OutStream) -> error {
164		171	usage(builder, already_ran_build, out_stream) %% {};
165	if (out_stream == &io.stderr)	172	return error.InvalidArgs;
166	return error.InvalidArgs;
167	}	173	}
168		174
169	fn unwrapArg(arg: %[]u8) -> %[]u8 {	175	fn unwrapArg(arg: %[]u8) -> %[]u8 {
170	return arg %% \|err\| {	176	return arg %% \|err\| {
171	%%io.stderr.printf("Unable to parse command line: {}\n", err);	177	warn("Unable to parse command line: {}\n", err);
172	return err;	178	return err;
173	};	179	};
174	}	180	}

std/special/test_runner.zig+5-3

 @@ -1,13 +1,15 @@
-const io = @import("std").io;
+const std = @import("std");
+const io = std.io;
 const builtin = @import("builtin");
 const test_fn_list = builtin.__zig_test_fn_slice;
+const warn = std.debug.warn;
 pub fn main() -> %void {
     for (test_fn_list) |test_fn, i| {
-        %%io.stderr.printf("Test {}/{} {}...", i + 1, test_fn_list.len, test_fn.name);
+        warn("Test {}/{} {}...", i + 1, test_fn_list.len, test_fn.name);
         test_fn.func();
-        %%io.stderr.printf("OK\n");
+        warn("OK\n");
     }
 }

test/compare_output.zig+44-31

 @@ -17,7 +17,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
             \\
             \\pub fn main() -> %void {
             \\    privateFunction();
-            \\    %%stdout.printf("OK 2\n");
+            \\    const stdout = &(%%getStdOut()).out_stream;
+            \\    %%stdout.print("OK 2\n");
             \\}
             \\
             \\fn privateFunction() {
 @@ -31,7 +32,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
             \\// purposefully conflicting function with main.zig
             \\// but it's private so it should be OK
             \\fn privateFunction() {
-            \\    %%stdout.printf("OK 1\n");
+            \\    const stdout = &(%%getStdOut()).out_stream;
+            \\    %%stdout.print("OK 1\n");
             \\}
             \\
             \\pub fn printText() {
 @@ -56,7 +58,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
         tc.addSourceFile("foo.zig",
             \\use @import("std").io;
             \\pub fn foo_function() {
-            \\    %%stdout.printf("OK\n");
+            \\    const stdout = &(%%getStdOut()).out_stream;
+            \\    %%stdout.print("OK\n");
             \\}
         );
 @@ -66,7 +69,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
             \\
             \\pub fn bar_function() {
             \\    if (foo_function()) {
-            \\        %%stdout.printf("OK\n");
+            \\        const stdout = &(%%getStdOut()).out_stream;
+            \\        %%stdout.print("OK\n");
             \\    }
             \\}
         );
 @@ -97,7 +101,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
             \\pub const a_text = "OK\n";
             \\
             \\pub fn ok() {
-            \\    %%io.stdout.printf(b_text);
+            \\    const stdout = &(%%io.getStdOut()).out_stream;
+            \\    %%stdout.print(b_text);
             \\}
         );
 @@ -114,7 +119,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
         \\const io = @import("std").io;
         \\
         \\pub fn main() -> %void {
-        \\    %%io.stdout.printf("Hello, world!\n{d4} {x3} {c}\n", u32(12), u16(0x12), u8('a'));
+        \\    const stdout = &(%%io.getStdOut()).out_stream;
+        \\    %%stdout.print("Hello, world!\n{d4} {x3} {c}\n", u32(12), u16(0x12), u8('a'));
         \\}
     , "Hello, world!\n0012 012 a\n");
 @@ -266,7 +272,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
         \\    var x_local : i32 = print_ok(x);
         \\}
         \\fn print_ok(val: @typeOf(x)) -> @typeOf(foo) {
-        \\    %%io.stdout.printf("OK\n");
+        \\    const stdout = &(%%io.getStdOut()).out_stream;
+        \\    %%stdout.print("OK\n");
         \\    return 0;
         \\}
         \\const foo : i32 = 0;
 @@ -347,24 +354,26 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
         \\pub fn main() -> %void {
         \\    const bar = Bar {.field2 = 13,};
         \\    const foo = Foo {.field1 = bar,};
+        \\    const stdout = &(%%io.getStdOut()).out_stream;
         \\    if (!foo.method()) {
-        \\        %%io.stdout.printf("BAD\n");
+        \\        %%stdout.print("BAD\n");
         \\    }
         \\    if (!bar.method()) {
-        \\        %%io.stdout.printf("BAD\n");
+        \\        %%stdout.print("BAD\n");
         \\    }
-        \\    %%io.stdout.printf("OK\n");
+        \\    %%stdout.print("OK\n");
         \\}
     , "OK\n");
     cases.add("defer with only fallthrough",
         \\const io = @import("std").io;
         \\pub fn main() -> %void {
-        \\    %%io.stdout.printf("before\n");
+        \\    const stdout = &(%%io.getStdOut()).out_stream;
-        \\    defer %%io.stdout.printf("defer1\n");
+        \\    %%stdout.print("before\n");
-        \\    defer %%io.stdout.printf("defer2\n");
+        \\    defer %%stdout.print("defer1\n");
-        \\    defer %%io.stdout.printf("defer3\n");
+        \\    defer %%stdout.print("defer2\n");
-        \\    %%io.stdout.printf("after\n");
+        \\    defer %%stdout.print("defer3\n");
+        \\    %%stdout.print("after\n");
         \\}
     , "before\nafter\ndefer3\ndefer2\ndefer1\n");
 @@ -372,13 +381,14 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
         \\const io = @import("std").io;
         \\const os = @import("std").os;
         \\pub fn main() -> %void {
-        \\    %%io.stdout.printf("before\n");
+        \\    const stdout = &(%%io.getStdOut()).out_stream;
-        \\    defer %%io.stdout.printf("defer1\n");
+        \\    %%stdout.print("before\n");
-        \\    defer %%io.stdout.printf("defer2\n");
+        \\    defer %%stdout.print("defer1\n");
+        \\    defer %%stdout.print("defer2\n");
         \\    var args_it = @import("std").os.args();
         \\    if (args_it.skip() and !args_it.skip()) return;
-        \\    defer %%io.stdout.printf("defer3\n");
+        \\    defer %%stdout.print("defer3\n");
-        \\    %%io.stdout.printf("after\n");
+        \\    %%stdout.print("after\n");
         \\}
     , "before\ndefer2\ndefer1\n");
 @@ -388,12 +398,13 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
         \\    do_test() %% return;
         \\}
         \\fn do_test() -> %void {
-        \\    %%io.stdout.printf("before\n");
+        \\    const stdout = &(%%io.getStdOut()).out_stream;
-        \\    defer %%io.stdout.printf("defer1\n");
+        \\    %%stdout.print("before\n");
-        \\    %defer %%io.stdout.printf("deferErr\n");
+        \\    defer %%stdout.print("defer1\n");
+        \\    %defer %%stdout.print("deferErr\n");
         \\    %return its_gonna_fail();
-        \\    defer %%io.stdout.printf("defer3\n");
+        \\    defer %%stdout.print("defer3\n");
-        \\    %%io.stdout.printf("after\n");
+        \\    %%stdout.print("after\n");
         \\}
         \\error IToldYouItWouldFail;
         \\fn its_gonna_fail() -> %void {
 @@ -407,12 +418,13 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
         \\    do_test() %% return;
         \\}
         \\fn do_test() -> %void {
-        \\    %%io.stdout.printf("before\n");
+        \\    const stdout = &(%%io.getStdOut()).out_stream;
-        \\    defer %%io.stdout.printf("defer1\n");
+        \\    %%stdout.print("before\n");
-        \\    %defer %%io.stdout.printf("deferErr\n");
+        \\    defer %%stdout.print("defer1\n");
+        \\    %defer %%stdout.print("deferErr\n");
         \\    %return its_gonna_pass();
-        \\    defer %%io.stdout.printf("defer3\n");
+        \\    defer %%stdout.print("defer3\n");
-        \\    %%io.stdout.printf("after\n");
+        \\    %%stdout.print("after\n");
         \\}
         \\fn its_gonna_pass() -> %void { }
     , "before\nafter\ndefer3\ndefer1\n");
 @@ -423,7 +435,8 @@ pub fn addCases(cases: &tests.CompareOutputContext) {
             \\const io = @import("std").io;
             \\
             \\pub fn main() -> %void {
-            \\    %%io.stdout.printf(foo_txt);
+            \\    const stdout = &(%%io.getStdOut()).out_stream;
+            \\    %%stdout.print(foo_txt);
             \\}
         , "1234\nabcd\n");

test/tests.zig+36-33

 @@ -1,5 +1,6 @@
 const std = @import("std");
 const debug = std.debug;
+const warn = debug.warn;
 const build = std.build;
 const os = std.os;
 const StdIo = os.ChildProcess.StdIo;
 @@ -50,6 +51,8 @@ const test_targets = []TestTarget {
 error TestFailed;
+const max_stdout_size = 1 * 1024 * 1024; // 1 MB
 pub fn addCompareOutputTests(b: &build.Builder, test_filter: ?[]const u8) -> &build.Step {
     const cases = %%b.allocator.create(CompareOutputContext);
     *cases = CompareOutputContext {
 @@ -231,7 +234,7 @@ pub const CompareOutputContext = struct {
             const full_exe_path = b.pathFromRoot(self.exe_path);
-            %%io.stderr.printf("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
             const child = %%os.ChildProcess.init([][]u8{full_exe_path}, b.allocator);
             defer child.deinit();
 @@ -246,8 +249,8 @@ pub const CompareOutputContext = struct {
             var stdout = Buffer.initNull(b.allocator);
             var stderr = Buffer.initNull(b.allocator);
-            %%(??child.stdout).readAll(&stdout);
+            %%(??child.stdout).in_stream.readAllBuffer(&stdout, max_stdout_size);
-            %%(??child.stderr).readAll(&stderr);
+            %%(??child.stderr).in_stream.readAllBuffer(&stderr, max_stdout_size);
             const term = child.wait() %% |err| {
                 debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
 @@ -255,19 +258,19 @@ pub const CompareOutputContext = struct {
             switch (term) {
                 Term.Exited => |code| {
                     if (code != 0) {
-                        %%io.stderr.printf("Process {} exited with error code {}\n", full_exe_path, code);
+                        warn("Process {} exited with error code {}\n", full_exe_path, code);
                         return error.TestFailed;
                     }
                 },
                 else => {
-                    %%io.stderr.printf("Process {} terminated unexpectedly\n", full_exe_path);
+                    warn("Process {} terminated unexpectedly\n", full_exe_path);
                     return error.TestFailed;
                 },
             };
             if (!mem.eql(u8, self.expected_output, stdout.toSliceConst())) {
-                %%io.stderr.printf(
+                warn(
                     \\
                     \\========= Expected this output: =========
                     \\{}
 @@ -277,7 +280,7 @@ pub const CompareOutputContext = struct {
                 , self.expected_output, stdout.toSliceConst());
                 return error.TestFailed;
             }
-            %%io.stderr.printf("OK\n");
+            warn("OK\n");
         }
     };
 @@ -310,7 +313,7 @@ pub const CompareOutputContext = struct {
             const full_exe_path = b.pathFromRoot(self.exe_path);
-            %%io.stderr.printf("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
             const child = %%os.ChildProcess.init([][]u8{full_exe_path}, b.allocator);
             defer child.deinit();
 @@ -328,24 +331,24 @@ pub const CompareOutputContext = struct {
             switch (term) {
                 Term.Exited => |code| {
                     if (code != expected_exit_code) {
-                        %%io.stderr.printf("\nProgram expected to exit with code {} " ++
+                        warn("\nProgram expected to exit with code {} " ++
                             "but exited with code {}\n", expected_exit_code, code);
                         return error.TestFailed;
                     }
                 },
                 Term.Signal => |sig| {
-                    %%io.stderr.printf("\nProgram expected to exit with code {} " ++
+                    warn("\nProgram expected to exit with code {} " ++
                         "but instead signaled {}\n", expected_exit_code, sig);
                     return error.TestFailed;
                 },
                 else => {
-                    %%io.stderr.printf("\nProgram expected to exit with code {}" ++
+                    warn("\nProgram expected to exit with code {}" ++
                         " but exited in an unexpected way\n", expected_exit_code);
                     return error.TestFailed;
                 },
             }
-            %%io.stderr.printf("OK\n");
+            warn("OK\n");
         }
     };
 @@ -554,7 +557,7 @@ pub const CompileErrorContext = struct {
                 Mode.ReleaseFast => %%zig_args.append("--release-fast"),
             }
-            %%io.stderr.printf("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
             if (b.verbose) {
                 printInvocation(zig_args.toSliceConst());
 @@ -573,8 +576,8 @@ pub const CompileErrorContext = struct {
             var stdout_buf = Buffer.initNull(b.allocator);
             var stderr_buf = Buffer.initNull(b.allocator);
-            %%(??child.stdout).readAll(&stdout_buf);
+            %%(??child.stdout).in_stream.readAllBuffer(&stdout_buf, max_stdout_size);
-            %%(??child.stderr).readAll(&stderr_buf);
+            %%(??child.stderr).in_stream.readAllBuffer(&stderr_buf, max_stdout_size);
             const term = child.wait() %% |err| {
                 debug.panic("Unable to spawn {}: {}\n", zig_args.items[0], @errorName(err));
 @@ -582,12 +585,12 @@ pub const CompileErrorContext = struct {
             switch (term) {
                 Term.Exited => |code| {
                     if (code == 0) {
-                        %%io.stderr.printf("Compilation incorrectly succeeded\n");
+                        warn("Compilation incorrectly succeeded\n");
                         return error.TestFailed;
                     }
                 },
                 else => {
-                    %%io.stderr.printf("Process {} terminated unexpectedly\n", b.zig_exe);
+                    warn("Process {} terminated unexpectedly\n", b.zig_exe);
                     return error.TestFailed;
                 },
             };
 @@ -597,7 +600,7 @@ pub const CompileErrorContext = struct {
             const stderr = stderr_buf.toSliceConst();
             if (stdout.len != 0) {
-                %%io.stderr.printf(
+                warn(
                     \\
                     \\Expected empty stdout, instead found:
                     \\================================================
 @@ -610,7 +613,7 @@ pub const CompileErrorContext = struct {
             for (self.case.expected_errors.toSliceConst()) |expected_error| {
                 if (mem.indexOf(u8, stderr, expected_error) == null) {
-                    %%io.stderr.printf(
+                    warn(
                         \\
                         \\========= Expected this compile error: =========
                         \\{}
 @@ -621,15 +624,15 @@ pub const CompileErrorContext = struct {
                     return error.TestFailed;
                 }
             }
-            %%io.stderr.printf("OK\n");
+            warn("OK\n");
         }
     };
     fn printInvocation(args: []const []const u8) {
         for (args) |arg| {
-            %%io.stderr.printf("{} ", arg);
+            warn("{} ", arg);
         }
-        %%io.stderr.printf("\n");
+        warn("\n");
     }
     pub fn create(self: &CompileErrorContext, name: []const u8, source: []const u8,
 @@ -822,7 +825,7 @@ pub const ParseCContext = struct {
             %%zig_args.append("parsec");
             %%zig_args.append(b.pathFromRoot(root_src));
-            %%io.stderr.printf("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
+            warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
             if (b.verbose) {
                 printInvocation(zig_args.toSliceConst());
 @@ -841,8 +844,8 @@ pub const ParseCContext = struct {
             var stdout_buf = Buffer.initNull(b.allocator);
             var stderr_buf = Buffer.initNull(b.allocator);
-            %%(??child.stdout).readAll(&stdout_buf);
+            %%(??child.stdout).in_stream.readAllBuffer(&stdout_buf, max_stdout_size);
-            %%(??child.stderr).readAll(&stderr_buf);
+            %%(??child.stderr).in_stream.readAllBuffer(&stderr_buf, max_stdout_size);
             const term = child.wait() %% |err| {
                 debug.panic("Unable to spawn {}: {}\n", zig_args.toSliceConst()[0], @errorName(err));
 @@ -850,16 +853,16 @@ pub const ParseCContext = struct {
             switch (term) {
                 Term.Exited => |code| {
                     if (code != 0) {
-                        %%io.stderr.printf("Compilation failed with exit code {}\n", code);
+                        warn("Compilation failed with exit code {}\n", code);
                         return error.TestFailed;
                     }
                 },
                 Term.Signal => |code| {
-                    %%io.stderr.printf("Compilation failed with signal {}\n", code);
+                    warn("Compilation failed with signal {}\n", code);
                     return error.TestFailed;
                 },
                 else => {
-                    %%io.stderr.printf("Compilation terminated unexpectedly\n");
+                    warn("Compilation terminated unexpectedly\n");
                     return error.TestFailed;
                 },
             };
 @@ -868,7 +871,7 @@ pub const ParseCContext = struct {
             const stderr = stderr_buf.toSliceConst();
             if (stderr.len != 0 and !self.case.allow_warnings) {
-                %%io.stderr.printf(
+                warn(
                     \\====== parsec emitted warnings: ============
                     \\{}
                     \\============================================
 @@ -879,7 +882,7 @@ pub const ParseCContext = struct {
             for (self.case.expected_lines.toSliceConst()) |expected_line| {
                 if (mem.indexOf(u8, stdout, expected_line) == null) {
-                    %%io.stderr.printf(
+                    warn(
                         \\
                         \\========= Expected this output: ================
                         \\{}
 @@ -890,15 +893,15 @@ pub const ParseCContext = struct {
                     return error.TestFailed;
                 }
             }
-            %%io.stderr.printf("OK\n");
+            warn("OK\n");
         }
     };
     fn printInvocation(args: []const []const u8) {
         for (args) |arg| {
-            %%io.stderr.printf("{} ", arg);
+            warn("{} ", arg);
         }
-        %%io.stderr.printf("\n");
+        warn("\n");
     }
     pub fn create(self: &ParseCContext, allow_warnings: bool, filename: []const u8, name: []const u8,

author	Andrew Kelley <andrew@ziglang.org> 2017-10-31 04:47:55-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2017-10-31 04:47:55-04:00
log	9e234d4208725b818812765740b474f049d69788
tree	cfb7b0602d8d5c4219797ef95cc763a970e53586
parent	7a96aca39e8eabccf69f5c65cd60a96aa4a7666c

breaking change to std.io API