Commit 2f040a23c8b968db56ab4c4725d6651f5ea3418e | zig

build.zig+14-14

 @@ -2,28 +2,28 @@ const builtin = @import("builtin");
 const std = @import("std");
 const Builder = std.build.Builder;
 const tests = @import("test/tests.zig");
-const os = std.os;
 const BufMap = std.BufMap;
 const warn = std.debug.warn;
 const mem = std.mem;
 const ArrayList = std.ArrayList;
 const Buffer = std.Buffer;
 const io = std.io;
+const fs = std.fs;
 pub fn build(b: *Builder) !void {
     const mode = b.standardReleaseOptions();
     var docgen_exe = b.addExecutable("docgen", "doc/docgen.zig");
-    const rel_zig_exe = try os.path.relative(b.allocator, b.build_root, b.zig_exe);
+    const rel_zig_exe = try fs.path.relative(b.allocator, b.build_root, b.zig_exe);
-    const langref_out_path = os.path.join(
+    const langref_out_path = fs.path.join(
         b.allocator,
         [][]const u8{ b.cache_root, "langref.html" },
     ) catch unreachable;
     var docgen_cmd = docgen_exe.run();
     docgen_cmd.addArgs([][]const u8{
         rel_zig_exe,
-        "doc" ++ os.path.sep_str ++ "langref.html.in",
+        "doc" ++ fs.path.sep_str ++ "langref.html.in",
         langref_out_path,
     });
     docgen_cmd.step.dependOn(&docgen_exe.step);
 @@ -137,7 +137,7 @@ fn dependOnLib(b: *Builder, lib_exe_obj: var, dep: LibraryDep) void {
     for (dep.libdirs.toSliceConst()) |lib_dir| {
         lib_exe_obj.addLibPath(lib_dir);
     }
-    const lib_dir = os.path.join(
+    const lib_dir = fs.path.join(
         b.allocator,
         [][]const u8{ dep.prefix, "lib" },
     ) catch unreachable;
 @@ -146,7 +146,7 @@ fn dependOnLib(b: *Builder, lib_exe_obj: var, dep: LibraryDep) void {
             ([]const u8)("libncurses.a")
         else
             b.fmt("lib{}.a", lib);
-        const static_lib_name = os.path.join(
+        const static_lib_name = fs.path.join(
             b.allocator,
             [][]const u8{ lib_dir, static_bare_name },
         ) catch unreachable;
 @@ -166,7 +166,7 @@ fn dependOnLib(b: *Builder, lib_exe_obj: var, dep: LibraryDep) void {
 }
 fn fileExists(filename: []const u8) !bool {
-    os.File.access(filename) catch |err| switch (err) {
+    fs.File.access(filename) catch |err| switch (err) {
         error.PermissionDenied,
         error.FileNotFound,
         => return false,
 @@ -177,7 +177,7 @@ fn fileExists(filename: []const u8) !bool {
 fn addCppLib(b: *Builder, lib_exe_obj: var, cmake_binary_dir: []const u8, lib_name: []const u8) void {
     const lib_prefix = if (lib_exe_obj.target.isWindows()) "" else "lib";
-    lib_exe_obj.addObjectFile(os.path.join(b.allocator, [][]const u8{
+    lib_exe_obj.addObjectFile(fs.path.join(b.allocator, [][]const u8{
         cmake_binary_dir,
         "zig_cpp",
         b.fmt("{}{}{}", lib_prefix, lib_name, lib_exe_obj.target.libFileExt()),
 @@ -223,7 +223,7 @@ fn findLLVM(b: *Builder, llvm_config_exe: []const u8) !LibraryDep {
             if (mem.startsWith(u8, lib_arg, "-l")) {
                 try result.system_libs.append(lib_arg[2..]);
             } else {
-                if (os.path.isAbsolute(lib_arg)) {
+                if (fs.path.isAbsolute(lib_arg)) {
                     try result.libs.append(lib_arg);
                 } else {
                     try result.system_libs.append(lib_arg);
 @@ -257,8 +257,8 @@ fn findLLVM(b: *Builder, llvm_config_exe: []const u8) !LibraryDep {
 pub fn installStdLib(b: *Builder, stdlib_files: []const u8) void {
     var it = mem.tokenize(stdlib_files, ";");
     while (it.next()) |stdlib_file| {
-        const src_path = os.path.join(b.allocator, [][]const u8{ "std", stdlib_file }) catch unreachable;
+        const src_path = fs.path.join(b.allocator, [][]const u8{ "std", stdlib_file }) catch unreachable;
-        const dest_path = os.path.join(
+        const dest_path = fs.path.join(
             b.allocator,
             [][]const u8{ "lib", "zig", "std", stdlib_file },
         ) catch unreachable;
 @@ -269,8 +269,8 @@ pub fn installStdLib(b: *Builder, stdlib_files: []const u8) void {
 pub fn installCHeaders(b: *Builder, c_header_files: []const u8) void {
     var it = mem.tokenize(c_header_files, ";");
     while (it.next()) |c_header_file| {
-        const src_path = os.path.join(b.allocator, [][]const u8{ "c_headers", c_header_file }) catch unreachable;
+        const src_path = fs.path.join(b.allocator, [][]const u8{ "c_headers", c_header_file }) catch unreachable;
-        const dest_path = os.path.join(
+        const dest_path = fs.path.join(
             b.allocator,
             [][]const u8{ "lib", "zig", "include", c_header_file },
         ) catch unreachable;
 @@ -315,7 +315,7 @@ fn configureStage2(b: *Builder, exe: var, ctx: Context) !void {
     }
     dependOnLib(b, exe, ctx.llvm);
-    if (exe.target.getOs() == builtin.Os.linux) {
+    if (exe.target.getOs() == .linux) {
         try addCxxKnownPath(b, ctx, exe, "libstdc++.a",
             \\Unable to determine path to libstdc++.a
             \\On Fedora, install libstdc++-static and try again.

doc/docgen.zig+30-28

...	@@ -1,7 +1,9 @@	...	@@ -1,7 +1,9 @@
1	const builtin = @import("builtin");	1	const builtin = @import("builtin");
2	const std = @import("std");	2	const std = @import("std");
3	const io = std.io;	3	const io = std.io;
4	const os = std.os;	4	const fs = std.fs;
		5	const process = std.process;
		6	const ChildProcess = std.ChildProcess;
5	const warn = std.debug.warn;	7	const warn = std.debug.warn;
6	const mem = std.mem;	8	const mem = std.mem;
7	const testing = std.testing;	9	const testing = std.testing;
...	@@ -11,7 +13,7 @@ const max_doc_file_size = 10 * 1024 * 1024;	...	@@ -11,7 +13,7 @@ const max_doc_file_size = 10 * 1024 * 1024;
11	const exe_ext = std.build.Target(std.build.Target.Native).exeFileExt();	13	const exe_ext = std.build.Target(std.build.Target.Native).exeFileExt();
12	const obj_ext = std.build.Target(std.build.Target.Native).oFileExt();	14	const obj_ext = std.build.Target(std.build.Target.Native).oFileExt();
13	const tmp_dir_name = "docgen_tmp";	15	const tmp_dir_name = "docgen_tmp";
14	const test_out_path = tmp_dir_name ++ os.path.sep_str ++ "test" ++ exe_ext;	16	const test_out_path = tmp_dir_name ++ fs.path.sep_str ++ "test" ++ exe_ext;
15		17
16	pub fn main() !void {	18	pub fn main() !void {
17	var direct_allocator = std.heap.DirectAllocator.init();	19	var direct_allocator = std.heap.DirectAllocator.init();
...	@@ -22,7 +24,7 @@ pub fn main() !void {	...	@@ -22,7 +24,7 @@ pub fn main() !void {
22		24
23	const allocator = &arena.allocator;	25	const allocator = &arena.allocator;
24		26
25	var args_it = os.args();	27	var args_it = process.args();
26		28
27	if (!args_it.skip()) @panic("expected self arg");	29	if (!args_it.skip()) @panic("expected self arg");
28		30
...	@@ -35,10 +37,10 @@ pub fn main() !void {	...	@@ -35,10 +37,10 @@ pub fn main() !void {
35	const out_file_name = try (args_it.next(allocator) orelse @panic("expected output arg"));	37	const out_file_name = try (args_it.next(allocator) orelse @panic("expected output arg"));
36	defer allocator.free(out_file_name);	38	defer allocator.free(out_file_name);
37		39
38	var in_file = try os.File.openRead(in_file_name);	40	var in_file = try fs.File.openRead(in_file_name);
39	defer in_file.close();	41	defer in_file.close();
40		42
41	var out_file = try os.File.openWrite(out_file_name);	43	var out_file = try fs.File.openWrite(out_file_name);
42	defer out_file.close();	44	defer out_file.close();
43		45
44	var file_in_stream = in_file.inStream();	46	var file_in_stream = in_file.inStream();
...	@@ -46,13 +48,13 @@ pub fn main() !void {	...	@@ -46,13 +48,13 @@ pub fn main() !void {
46	const input_file_bytes = try file_in_stream.stream.readAllAlloc(allocator, max_doc_file_size);	48	const input_file_bytes = try file_in_stream.stream.readAllAlloc(allocator, max_doc_file_size);
47		49
48	var file_out_stream = out_file.outStream();	50	var file_out_stream = out_file.outStream();
49	var buffered_out_stream = io.BufferedOutStream(os.File.WriteError).init(&file_out_stream.stream);	51	var buffered_out_stream = io.BufferedOutStream(fs.File.WriteError).init(&file_out_stream.stream);
50		52
51	var tokenizer = Tokenizer.init(in_file_name, input_file_bytes);	53	var tokenizer = Tokenizer.init(in_file_name, input_file_bytes);
52	var toc = try genToc(allocator, &tokenizer);	54	var toc = try genToc(allocator, &tokenizer);
53		55
54	try os.makePath(allocator, tmp_dir_name);	56	try fs.makePath(allocator, tmp_dir_name);
55	defer os.deleteTree(allocator, tmp_dir_name) catch {};	57	defer fs.deleteTree(allocator, tmp_dir_name) catch {};
56		58
57	try genHtml(allocator, &tokenizer, &toc, &buffered_out_stream.stream, zig_exe);	59	try genHtml(allocator, &tokenizer, &toc, &buffered_out_stream.stream, zig_exe);
58	try buffered_out_stream.flush();	60	try buffered_out_stream.flush();
...	@@ -950,7 +952,7 @@ fn tokenizeAndPrint(docgen_tokenizer: *Tokenizer, out: var, source_token: Token)	...	@@ -950,7 +952,7 @@ fn tokenizeAndPrint(docgen_tokenizer: *Tokenizer, out: var, source_token: Token)
950	fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var, zig_exe: []const u8) !void {	952	fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var, zig_exe: []const u8) !void {
951	var code_progress_index: usize = 0;	953	var code_progress_index: usize = 0;
952		954
953	var env_map = try os.getEnvMap(allocator);	955	var env_map = try process.getEnvMap(allocator);
954	try env_map.set("ZIG_DEBUG_COLOR", "1");	956	try env_map.set("ZIG_DEBUG_COLOR", "1");
955		957
956	const builtin_code = try getBuiltinCode(allocator, &env_map, zig_exe);	958	const builtin_code = try getBuiltinCode(allocator, &env_map, zig_exe);
...	@@ -1012,7 +1014,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1012,7 +1014,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1012	try tokenizeAndPrint(tokenizer, out, code.source_token);	1014	try tokenizeAndPrint(tokenizer, out, code.source_token);
1013	try out.write("</pre>");	1015	try out.write("</pre>");
1014	const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name);	1016	const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name);
1015	const tmp_source_file_name = try os.path.join(	1017	const tmp_source_file_name = try fs.path.join(
1016	allocator,	1018	allocator,
1017	[][]const u8{ tmp_dir_name, name_plus_ext },	1019	[][]const u8{ tmp_dir_name, name_plus_ext },
1018	);	1020	);
...	@@ -1021,7 +1023,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1021,7 +1023,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1021	switch (code.id) {	1023	switch (code.id) {
1022	Code.Id.Exe => \|expected_outcome\| code_block: {	1024	Code.Id.Exe => \|expected_outcome\| code_block: {
1023	const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, exe_ext);	1025	const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, exe_ext);
1024	const tmp_bin_file_name = try os.path.join(	1026	const tmp_bin_file_name = try fs.path.join(
1025	allocator,	1027	allocator,
1026	[][]const u8{ tmp_dir_name, name_plus_bin_ext },	1028	[][]const u8{ tmp_dir_name, name_plus_bin_ext },
1027	);	1029	);
...	@@ -1056,7 +1058,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1056,7 +1058,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1056	}	1058	}
1057	for (code.link_objects) \|link_object\| {	1059	for (code.link_objects) \|link_object\| {
1058	const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", link_object, obj_ext);	1060	const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", link_object, obj_ext);
1059	const full_path_object = try os.path.join(	1061	const full_path_object = try fs.path.join(
1060	allocator,	1062	allocator,
1061	[][]const u8{ tmp_dir_name, name_with_ext },	1063	[][]const u8{ tmp_dir_name, name_with_ext },
1062	);	1064	);
...	@@ -1076,7 +1078,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1076,7 +1078,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1076	}	1078	}
1077	}	1079	}
1078	if (expected_outcome == .BuildFail) {	1080	if (expected_outcome == .BuildFail) {
1079	const result = try os.ChildProcess.exec(	1081	const result = try ChildProcess.exec(
1080	allocator,	1082	allocator,
1081	build_args.toSliceConst(),	1083	build_args.toSliceConst(),
1082	null,	1084	null,
...	@@ -1084,7 +1086,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1084,7 +1086,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1084	max_doc_file_size,	1086	max_doc_file_size,
1085	);	1087	);
1086	switch (result.term) {	1088	switch (result.term) {
1087	os.ChildProcess.Term.Exited => \|exit_code\| {	1089	.Exited => \|exit_code\| {
1088	if (exit_code == 0) {	1090	if (exit_code == 0) {
1089	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);	1091	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1090	for (build_args.toSliceConst()) \|arg\|	1092	for (build_args.toSliceConst()) \|arg\|
...	@@ -1113,7 +1115,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1113,7 +1115,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1113	if (code.target_str) \|triple\| {	1115	if (code.target_str) \|triple\| {
1114	if (mem.startsWith(u8, triple, "wasm32") or	1116	if (mem.startsWith(u8, triple, "wasm32") or
1115	mem.startsWith(u8, triple, "x86_64-linux") and	1117	mem.startsWith(u8, triple, "x86_64-linux") and
1116	(builtin.os != builtin.Os.linux or builtin.arch != builtin.Arch.x86_64))	1118	(builtin.os != .linux or builtin.arch != .x86_64))
1117	{	1119	{
1118	// skip execution	1120	// skip execution
1119	try out.print("</code></pre>\n");	1121	try out.print("</code></pre>\n");
...	@@ -1124,9 +1126,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1124,9 +1126,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1124	const run_args = [][]const u8{tmp_bin_file_name};	1126	const run_args = [][]const u8{tmp_bin_file_name};
1125		1127
1126	const result = if (expected_outcome == ExpectedOutcome.Fail) blk: {	1128	const result = if (expected_outcome == ExpectedOutcome.Fail) blk: {
1127	const result = try os.ChildProcess.exec(allocator, run_args, null, &env_map, max_doc_file_size);	1129	const result = try ChildProcess.exec(allocator, run_args, null, &env_map, max_doc_file_size);
1128	switch (result.term) {	1130	switch (result.term) {
1129	os.ChildProcess.Term.Exited => \|exit_code\| {	1131	.Exited => \|exit_code\| {
1130	if (exit_code == 0) {	1132	if (exit_code == 0) {
1131	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);	1133	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1132	for (run_args) \|arg\|	1134	for (run_args) \|arg\|
...	@@ -1216,9 +1218,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1216,9 +1218,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1216	try out.print(" --release-small");	1218	try out.print(" --release-small");
1217	},	1219	},
1218	}	1220	}
1219	const result = try os.ChildProcess.exec(allocator, test_args.toSliceConst(), null, &env_map, max_doc_file_size);	1221	const result = try ChildProcess.exec(allocator, test_args.toSliceConst(), null, &env_map, max_doc_file_size);
1220	switch (result.term) {	1222	switch (result.term) {
1221	os.ChildProcess.Term.Exited => \|exit_code\| {	1223	.Exited => \|exit_code\| {
1222	if (exit_code == 0) {	1224	if (exit_code == 0) {
1223	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);	1225	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1224	for (test_args.toSliceConst()) \|arg\|	1226	for (test_args.toSliceConst()) \|arg\|
...	@@ -1274,9 +1276,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1274,9 +1276,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1274	},	1276	},
1275	}	1277	}
1276		1278
1277	const result = try os.ChildProcess.exec(allocator, test_args.toSliceConst(), null, &env_map, max_doc_file_size);	1279	const result = try ChildProcess.exec(allocator, test_args.toSliceConst(), null, &env_map, max_doc_file_size);
1278	switch (result.term) {	1280	switch (result.term) {
1279	os.ChildProcess.Term.Exited => \|exit_code\| {	1281	.Exited => \|exit_code\| {
1280	if (exit_code == 0) {	1282	if (exit_code == 0) {
1281	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);	1283	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1282	for (test_args.toSliceConst()) \|arg\|	1284	for (test_args.toSliceConst()) \|arg\|
...	@@ -1310,7 +1312,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1310,7 +1312,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1310	},	1312	},
1311	Code.Id.Obj => \|maybe_error_match\| {	1313	Code.Id.Obj => \|maybe_error_match\| {
1312	const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, obj_ext);	1314	const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, obj_ext);
1313	const tmp_obj_file_name = try os.path.join(	1315	const tmp_obj_file_name = try fs.path.join(
1314	allocator,	1316	allocator,
1315	[][]const u8{ tmp_dir_name, name_plus_obj_ext },	1317	[][]const u8{ tmp_dir_name, name_plus_obj_ext },
1316	);	1318	);
...	@@ -1318,7 +1320,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1318,7 +1320,7 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1318	defer build_args.deinit();	1320	defer build_args.deinit();
1319		1321
1320	const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", code.name);	1322	const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", code.name);
1321	const output_h_file_name = try os.path.join(	1323	const output_h_file_name = try fs.path.join(
1322	allocator,	1324	allocator,
1323	[][]const u8{ tmp_dir_name, name_plus_h_ext },	1325	[][]const u8{ tmp_dir_name, name_plus_h_ext },
1324	);	1326	);
...	@@ -1367,9 +1369,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1367,9 +1369,9 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1367	}	1369	}
1368		1370
1369	if (maybe_error_match) \|error_match\| {	1371	if (maybe_error_match) \|error_match\| {
1370	const result = try os.ChildProcess.exec(allocator, build_args.toSliceConst(), null, &env_map, max_doc_file_size);	1372	const result = try ChildProcess.exec(allocator, build_args.toSliceConst(), null, &env_map, max_doc_file_size);
1371	switch (result.term) {	1373	switch (result.term) {
1372	os.ChildProcess.Term.Exited => \|exit_code\| {	1374	.Exited => \|exit_code\| {
1373	if (exit_code == 0) {	1375	if (exit_code == 0) {
1374	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);	1376	warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1375	for (build_args.toSliceConst()) \|arg\|	1377	for (build_args.toSliceConst()) \|arg\|
...	@@ -1448,10 +1450,10 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var	...	@@ -1448,10 +1450,10 @@ fn genHtml(allocator: mem.Allocator, tokenizer: Tokenizer, toc: *Toc, out: var
1448	}	1450	}
1449	}	1451	}
1450		1452
1451	fn exec(allocator: mem.Allocator, env_map: std.BufMap, args: []const []const u8) !os.ChildProcess.ExecResult {	1453	fn exec(allocator: mem.Allocator, env_map: std.BufMap, args: []const []const u8) !ChildProcess.ExecResult {
1452	const result = try os.ChildProcess.exec(allocator, args, null, env_map, max_doc_file_size);	1454	const result = try ChildProcess.exec(allocator, args, null, env_map, max_doc_file_size);
1453	switch (result.term) {	1455	switch (result.term) {
1454	os.ChildProcess.Term.Exited => \|exit_code\| {	1456	.Exited => \|exit_code\| {
1455	if (exit_code != 0) {	1457	if (exit_code != 0) {
1456	warn("{}\nThe following command exited with code {}:\n", result.stderr, exit_code);	1458	warn("{}\nThe following command exited with code {}:\n", result.stderr, exit_code);
1457	for (args) \|arg\|	1459	for (args) \|arg\|

doc/langref.html.in+1-1

...	@@ -195,7 +195,7 @@ const std = @import("std");	...	@@ -195,7 +195,7 @@ const std = @import("std");
195		195
196	pub fn main() !void {	196	pub fn main() !void {
197	// If this program is run without stdout attached, exit with an error.	197	// If this program is run without stdout attached, exit with an error.
198	const stdout_file = try std.os.File.stdout();	198	const stdout_file = try std.io.getStdOut();
199	// If this program encounters pipe failure when printing to stdout, exit	199	// If this program encounters pipe failure when printing to stdout, exit
200	// with an error.	200	// with an error.
201	try stdout_file.write("Hello, world!\n");	201	try stdout_file.write("Hello, world!\n");

src-self-hosted/compilation.zig+11-12

src-self-hosted/errmsg.zig+5-4

...	@@ -1,6 +1,7 @@	...	@@ -1,6 +1,7 @@
1	const std = @import("std");	1	const std = @import("std");
2	const mem = std.mem;	2	const mem = std.mem;
3	const os = std.os;	3	const fs = std.fs;
		4	const process = std.process;
4	const Token = std.zig.Token;	5	const Token = std.zig.Token;
5	const ast = std.zig.ast;	6	const ast = std.zig.ast;
6	const TokenIndex = std.zig.ast.TokenIndex;	7	const TokenIndex = std.zig.ast.TokenIndex;
...	@@ -239,10 +240,10 @@ pub const Msg = struct {	...	@@ -239,10 +240,10 @@ pub const Msg = struct {
239	const allocator = msg.getAllocator();	240	const allocator = msg.getAllocator();
240	const tree = msg.getTree();	241	const tree = msg.getTree();
241		242
242	const cwd = try os.getCwdAlloc(allocator);	243	const cwd = try process.getCwdAlloc(allocator);
243	defer allocator.free(cwd);	244	defer allocator.free(cwd);
244		245
245	const relpath = try os.path.relative(allocator, cwd, msg.realpath);	246	const relpath = try fs.path.relative(allocator, cwd, msg.realpath);
246	defer allocator.free(relpath);	247	defer allocator.free(relpath);
247		248
248	const path = if (relpath.len < msg.realpath.len) relpath else msg.realpath;	249	const path = if (relpath.len < msg.realpath.len) relpath else msg.realpath;
...	@@ -276,7 +277,7 @@ pub const Msg = struct {	...	@@ -276,7 +277,7 @@ pub const Msg = struct {
276	try stream.write("\n");	277	try stream.write("\n");
277	}	278	}
278		279
279	pub fn printToFile(msg: *const Msg, file: os.File, color: Color) !void {	280	pub fn printToFile(msg: *const Msg, file: fs.File, color: Color) !void {
280	const color_on = switch (color) {	281	const color_on = switch (color) {
281	Color.Auto => file.isTty(),	282	Color.Auto => file.isTty(),
282	Color.On => true,	283	Color.On => true,

src-self-hosted/introspect.zig+6-6

...	@@ -2,19 +2,19 @@	...	@@ -2,19 +2,19 @@
2		2
3	const std = @import("std");	3	const std = @import("std");
4	const mem = std.mem;	4	const mem = std.mem;
5	const os = std.os;	5	const fs = std.fs;
6		6
7	const warn = std.debug.warn;	7	const warn = std.debug.warn;
8		8
9	/// Caller must free result	9	/// Caller must free result
10	pub fn testZigInstallPrefix(allocator: *mem.Allocator, test_path: []const u8) ![]u8 {	10	pub fn testZigInstallPrefix(allocator: *mem.Allocator, test_path: []const u8) ![]u8 {
11	const test_zig_dir = try os.path.join(allocator, [][]const u8{ test_path, "lib", "zig" });	11	const test_zig_dir = try fs.path.join(allocator, [][]const u8{ test_path, "lib", "zig" });
12	errdefer allocator.free(test_zig_dir);	12	errdefer allocator.free(test_zig_dir);
13		13
14	const test_index_file = try os.path.join(allocator, [][]const u8{ test_zig_dir, "std", "std.zig" });	14	const test_index_file = try fs.path.join(allocator, [][]const u8{ test_zig_dir, "std", "std.zig" });
15	defer allocator.free(test_index_file);	15	defer allocator.free(test_index_file);
16		16
17	var file = try os.File.openRead(test_index_file);	17	var file = try fs.File.openRead(test_index_file);
18	file.close();	18	file.close();
19		19
20	return test_zig_dir;	20	return test_zig_dir;
...	@@ -22,12 +22,12 @@ pub fn testZigInstallPrefix(allocator: *mem.Allocator, test_path: []const u8) ![	...	@@ -22,12 +22,12 @@ pub fn testZigInstallPrefix(allocator: *mem.Allocator, test_path: []const u8) ![
22		22
23	/// Caller must free result	23	/// Caller must free result
24	pub fn findZigLibDir(allocator: *mem.Allocator) ![]u8 {	24	pub fn findZigLibDir(allocator: *mem.Allocator) ![]u8 {
25	const self_exe_path = try os.selfExeDirPathAlloc(allocator);	25	const self_exe_path = try fs.selfExeDirPathAlloc(allocator);
26	defer allocator.free(self_exe_path);	26	defer allocator.free(self_exe_path);
27		27
28	var cur_path: []const u8 = self_exe_path;	28	var cur_path: []const u8 = self_exe_path;
29	while (true) {	29	while (true) {
30	const test_dir = os.path.dirname(cur_path) orelse ".";	30	const test_dir = fs.path.dirname(cur_path) orelse ".";
31		31
32	if (mem.eql(u8, test_dir, cur_path)) {	32	if (mem.eql(u8, test_dir, cur_path)) {
33	break;	33	break;

src-self-hosted/libc_installation.zig+18-17

src-self-hosted/link.zig+3-3

src-self-hosted/main.zig+41-39

 @@ -4,7 +4,9 @@ const builtin = @import("builtin");
 const event = std.event;
 const os = std.os;
 const io = std.io;
+const fs = std.fs;
 const mem = std.mem;
+const process = std.process;
 const Allocator = mem.Allocator;
 const ArrayList = std.ArrayList;
 const Buffer = std.Buffer;
 @@ -20,9 +22,9 @@ const Target = @import("target.zig").Target;
 const errmsg = @import("errmsg.zig");
 const LibCInstallation = @import("libc_installation.zig").LibCInstallation;
-var stderr_file: os.File = undefined;
+var stderr_file: fs.File = undefined;
-var stderr: *io.OutStream(os.File.WriteError) = undefined;
+var stderr: *io.OutStream(fs.File.WriteError) = undefined;
-var stdout: *io.OutStream(os.File.WriteError) = undefined;
+var stdout: *io.OutStream(fs.File.WriteError) = undefined;
 pub const max_src_size = 2 * 1024 * 1024 * 1024; // 2 GiB
 @@ -62,14 +64,14 @@ pub fn main() !void {
     var stderr_out_stream = stderr_file.outStream();
     stderr = &stderr_out_stream.stream;
-    const args = try os.argsAlloc(allocator);
+    const args = try process.argsAlloc(allocator);
     // TODO I'm getting  unreachable code here, which shouldn't happen
-    //defer os.argsFree(allocator, args);
+    //defer process.argsFree(allocator, args);
     if (args.len <= 1) {
         try stderr.write("expected command argument\n\n");
         try stderr.write(usage);
-        os.exit(1);
+        process.exit(1);
     }
     const commands = []Command{
 @@ -125,7 +127,7 @@ pub fn main() !void {
     try stderr.print("unknown command: {}\n\n", args[1]);
     try stderr.write(usage);
-    os.exit(1);
+    process.exit(1);
 }
 const usage_build_generic =
 @@ -256,7 +258,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
     if (flags.present("help")) {
         try stdout.write(usage_build_generic);
-        os.exit(0);
+        process.exit(0);
     }
     const build_mode = blk: {
 @@ -324,14 +326,14 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
                 cur_pkg = parent;
             } else {
                 try stderr.print("encountered --pkg-end with no matching --pkg-begin\n");
-                os.exit(1);
+                process.exit(1);
             }
         }
     }
     if (cur_pkg.parent != null) {
         try stderr.print("unmatched --pkg-begin\n");
-        os.exit(1);
+        process.exit(1);
     }
     const provided_name = flags.single("name");
 @@ -340,18 +342,18 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
         1 => flags.positionals.at(0),
         else => {
             try stderr.print("unexpected extra parameter: {}\n", flags.positionals.at(1));
-            os.exit(1);
+            process.exit(1);
         },
     };
     const root_name = if (provided_name) |n| n else blk: {
         if (root_source_file) |file| {
-            const basename = os.path.basename(file);
+            const basename = fs.path.basename(file);
             var it = mem.separate(basename, ".");
             break :blk it.next() orelse basename;
         } else {
             try stderr.write("--name [name] not provided and unable to infer\n");
-            os.exit(1);
+            process.exit(1);
         }
     };
 @@ -361,12 +363,12 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
     const link_objects = flags.many("object");
     if (root_source_file == null and link_objects.len == 0 and assembly_files.len == 0) {
         try stderr.write("Expected source file argument or at least one --object or --assembly argument\n");
-        os.exit(1);
+        process.exit(1);
     }
     if (out_type == Compilation.Kind.Obj and link_objects.len != 0) {
         try stderr.write("When building an object file, --object arguments are invalid\n");
-        os.exit(1);
+        process.exit(1);
     }
     var clang_argv_buf = ArrayList([]const u8).init(allocator);
 @@ -379,7 +381,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
     }
     try ZigCompiler.setLlvmArgv(allocator, mllvm_flags);
-    const zig_lib_dir = introspect.resolveZigLibDir(allocator) catch os.exit(1);
+    const zig_lib_dir = introspect.resolveZigLibDir(allocator) catch process.exit(1);
     defer allocator.free(zig_lib_dir);
     var override_libc: LibCInstallation = undefined;
 @@ -448,7 +450,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
     if (flags.single("mmacosx-version-min") != null and flags.single("mios-version-min") != null) {
         try stderr.write("-mmacosx-version-min and -mios-version-min options not allowed together\n");
-        os.exit(1);
+        process.exit(1);
     }
     if (flags.single("mmacosx-version-min")) |ver| {
 @@ -478,16 +480,16 @@ async fn processBuildEvents(comp: *Compilation, color: errmsg.Color) void {
         switch (build_event) {
             Compilation.Event.Ok => {
-                stderr.print("Build {} succeeded\n", count) catch os.exit(1);
+                stderr.print("Build {} succeeded\n", count) catch process.exit(1);
             },
             Compilation.Event.Error => |err| {
-                stderr.print("Build {} failed: {}\n", count, @errorName(err)) catch os.exit(1);
+                stderr.print("Build {} failed: {}\n", count, @errorName(err)) catch process.exit(1);
             },
             Compilation.Event.Fail => |msgs| {
-                stderr.print("Build {} compile errors:\n", count) catch os.exit(1);
+                stderr.print("Build {} compile errors:\n", count) catch process.exit(1);
                 for (msgs) |msg| {
                     defer msg.destroy();
-                    msg.printToFile(stderr_file, color) catch os.exit(1);
+                    msg.printToFile(stderr_file, color) catch process.exit(1);
                 }
             },
         }
 @@ -550,8 +552,8 @@ fn parseLibcPaths(allocator: *Allocator, libc: *LibCInstallation, libc_paths_fil
                 "Try running `zig libc` to see an example for the native target.\n",
             libc_paths_file,
             @errorName(err),
-        ) catch os.exit(1);
+        ) catch process.exit(1);
-        os.exit(1);
+        process.exit(1);
     };
 }
 @@ -565,7 +567,7 @@ fn cmdLibC(allocator: *Allocator, args: []const []const u8) !void {
         },
         else => {
             try stderr.print("unexpected extra parameter: {}\n", args[1]);
-            os.exit(1);
+            process.exit(1);
         },
     }
 @@ -584,10 +586,10 @@ fn cmdLibC(allocator: *Allocator, args: []const []const u8) !void {
 async fn findLibCAsync(zig_compiler: *ZigCompiler) void {
     const libc = (await (async zig_compiler.getNativeLibC() catch unreachable)) catch |err| {
-        stderr.print("unable to find libc: {}\n", @errorName(err)) catch os.exit(1);
+        stderr.print("unable to find libc: {}\n", @errorName(err)) catch process.exit(1);
-        os.exit(1);
+        process.exit(1);
     };
-    libc.render(stdout) catch os.exit(1);
+    libc.render(stdout) catch process.exit(1);
 }
 fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {
 @@ -596,7 +598,7 @@ fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {
     if (flags.present("help")) {
         try stdout.write(usage_fmt);
-        os.exit(0);
+        process.exit(0);
     }
     const color = blk: {
 @@ -616,7 +618,7 @@ fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {
     if (flags.present("stdin")) {
         if (flags.positionals.len != 0) {
             try stderr.write("cannot use --stdin with positional arguments\n");
-            os.exit(1);
+            process.exit(1);
         }
         var stdin_file = try io.getStdIn();
 @@ -627,7 +629,7 @@ fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {
         const tree = std.zig.parse(allocator, source_code) catch |err| {
             try stderr.print("error parsing stdin: {}\n", err);
-            os.exit(1);
+            process.exit(1);
         };
         defer tree.deinit();
 @@ -639,12 +641,12 @@ fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {
             try msg.printToFile(stderr_file, color);
         }
         if (tree.errors.len != 0) {
-            os.exit(1);
+            process.exit(1);
         }
         if (flags.present("check")) {
             const anything_changed = try std.zig.render(allocator, io.null_out_stream, tree);
             const code = if (anything_changed) u8(1) else u8(0);
-            os.exit(code);
+            process.exit(code);
         }
         _ = try std.zig.render(allocator, stdout, tree);
 @@ -653,7 +655,7 @@ fn cmdFmt(allocator: *Allocator, args: []const []const u8) !void {
     if (flags.positionals.len == 0) {
         try stderr.write("expected at least one source file argument\n");
-        os.exit(1);
+        process.exit(1);
     }
     var loop: event.Loop = undefined;
 @@ -700,7 +702,7 @@ const FmtError = error{
     ReadOnlyFileSystem,
     LinkQuotaExceeded,
     FileBusy,
-} || os.File.OpenError;
+} || fs.File.OpenError;
 async fn asyncFmtMain(
     loop: *event.Loop,
 @@ -725,7 +727,7 @@ async fn asyncFmtMain(
     }
     try await (async group.wait() catch unreachable);
     if (fmt.any_error) {
-        os.exit(1);
+        process.exit(1);
     }
 }
 @@ -747,13 +749,13 @@ async fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtErro
     )) catch |err| switch (err) {
         error.IsDir, error.AccessDenied => {
             // TODO make event based (and dir.next())
-            var dir = try std.os.Dir.open(fmt.loop.allocator, file_path);
+            var dir = try fs.Dir.open(fmt.loop.allocator, file_path);
             defer dir.close();
             var group = event.Group(FmtError!void).init(fmt.loop);
             while (try dir.next()) |entry| {
-                if (entry.kind == std.os.Dir.Entry.Kind.Directory or mem.endsWith(u8, entry.name, ".zig")) {
+                if (entry.kind == fs.Dir.Entry.Kind.Directory or mem.endsWith(u8, entry.name, ".zig")) {
-                    const full_path = try os.path.join(fmt.loop.allocator, [][]const u8{ file_path, entry.name });
+                    const full_path = try fs.path.join(fmt.loop.allocator, [][]const u8{ file_path, entry.name });
                     try group.call(fmtPath, fmt, full_path, check_mode);
                 }
             }
 @@ -891,7 +893,7 @@ const usage_internal =
 fn cmdInternal(allocator: *Allocator, args: []const []const u8) !void {
     if (args.len == 0) {
         try stderr.write(usage_internal);
-        os.exit(1);
+        process.exit(1);
     }
     const sub_commands = []Command{Command{

src-self-hosted/stage1.zig+29-30

 @@ -1,8 +1,24 @@
 // This is Zig code that is used by both stage1 and stage2.
 // The prototypes in src/userland.h must match these definitions.
-const std = @import("std");
 const builtin = @import("builtin");
+const std = @import("std");
+const io = std.io;
+const mem = std.mem;
+const fs = std.fs;
+const process = std.process;
+const Allocator = mem.Allocator;
+const ArrayList = std.ArrayList;
+const Buffer = std.Buffer;
+const arg = @import("arg.zig");
+const self_hosted_main = @import("main.zig");
+const Args = arg.Args;
+const Flag = arg.Flag;
+const errmsg = @import("errmsg.zig");
+var stderr_file: fs.File = undefined;
+var stderr: *io.OutStream(fs.File.WriteError) = undefined;
+var stdout: *io.OutStream(fs.File.WriteError) = undefined;
 // ABI warning
 export fn stage2_zen(ptr: *[*]const u8, len: *usize) void {
 @@ -157,7 +173,7 @@ fn fmtMain(argc: c_int, argv: [*]const [*]const u8) !void {
     if (flags.present("help")) {
         try stdout.write(self_hosted_main.usage_fmt);
-        os.exit(0);
+        process.exit(0);
     }
     const color = blk: {
 @@ -177,7 +193,7 @@ fn fmtMain(argc: c_int, argv: [*]const [*]const u8) !void {
     if (flags.present("stdin")) {
         if (flags.positionals.len != 0) {
             try stderr.write("cannot use --stdin with positional arguments\n");
-            os.exit(1);
+            process.exit(1);
         }
         var stdin_file = try io.getStdIn();
 @@ -188,7 +204,7 @@ fn fmtMain(argc: c_int, argv: [*]const [*]const u8) !void {
         const tree = std.zig.parse(allocator, source_code) catch |err| {
             try stderr.print("error parsing stdin: {}\n", err);
-            os.exit(1);
+            process.exit(1);
         };
         defer tree.deinit();
 @@ -197,12 +213,12 @@ fn fmtMain(argc: c_int, argv: [*]const [*]const u8) !void {
             try printErrMsgToFile(allocator, parse_error, tree, "<stdin>", stderr_file, color);
         }
         if (tree.errors.len != 0) {
-            os.exit(1);
+            process.exit(1);
         }
         if (flags.present("check")) {
             const anything_changed = try std.zig.render(allocator, io.null_out_stream, tree);
             const code = if (anything_changed) u8(1) else u8(0);
-            os.exit(code);
+            process.exit(code);
         }
         _ = try std.zig.render(allocator, stdout, tree);
 @@ -211,7 +227,7 @@ fn fmtMain(argc: c_int, argv: [*]const [*]const u8) !void {
     if (flags.positionals.len == 0) {
         try stderr.write("expected at least one source file argument\n");
-        os.exit(1);
+        process.exit(1);
     }
     var fmt = Fmt{
 @@ -227,7 +243,7 @@ fn fmtMain(argc: c_int, argv: [*]const [*]const u8) !void {
         try fmtPath(&fmt, file_path, check_mode);
     }
     if (fmt.any_error) {
-        os.exit(1);
+        process.exit(1);
     }
 }
 @@ -250,7 +266,7 @@ const FmtError = error{
     ReadOnlyFileSystem,
     LinkQuotaExceeded,
     FileBusy,
-} || os.File.OpenError;
+} || fs.File.OpenError;
 fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void {
     const file_path = try std.mem.dupe(fmt.allocator, u8, file_path_ref);
 @@ -261,12 +277,12 @@ fn fmtPath(fmt: *Fmt, file_path_ref: []const u8, check_mode: bool) FmtError!void
     const source_code = io.readFileAlloc(fmt.allocator, file_path) catch |err| switch (err) {
         error.IsDir, error.AccessDenied => {
             // TODO make event based (and dir.next())
-            var dir = try std.os.Dir.open(fmt.allocator, file_path);
+            var dir = try fs.Dir.open(fmt.allocator, file_path);
             defer dir.close();
             while (try dir.next()) |entry| {
-                if (entry.kind == std.os.Dir.Entry.Kind.Directory or mem.endsWith(u8, entry.name, ".zig")) {
+                if (entry.kind == fs.Dir.Entry.Kind.Directory or mem.endsWith(u8, entry.name, ".zig")) {
-                    const full_path = try os.path.join(fmt.allocator, [][]const u8{ file_path, entry.name });
+                    const full_path = try fs.path.join(fmt.allocator, [][]const u8{ file_path, entry.name });
                     try fmtPath(fmt, full_path, check_mode);
                 }
             }
 @@ -329,7 +345,7 @@ fn printErrMsgToFile(
     parse_error: *const ast.Error,
     tree: *ast.Tree,
     path: []const u8,
-    file: os.File,
+    file: fs.File,
     color: errmsg.Color,
 ) !void {
     const color_on = switch (color) {
 @@ -377,20 +393,3 @@ fn printErrMsgToFile(
     try stream.writeByteNTimes('~', last_token.end - first_token.start);
     try stream.write("\n");
 }
-const os = std.os;
-const io = std.io;
-const mem = std.mem;
-const Allocator = mem.Allocator;
-const ArrayList = std.ArrayList;
-const Buffer = std.Buffer;
-const arg = @import("arg.zig");
-const self_hosted_main = @import("main.zig");
-const Args = arg.Args;
-const Flag = arg.Flag;
-const errmsg = @import("errmsg.zig");
-var stderr_file: os.File = undefined;
-var stderr: *io.OutStream(os.File.WriteError) = undefined;
-var stdout: *io.OutStream(os.File.WriteError) = undefined;

src-self-hosted/test.zig+11-11

...	@@ -55,12 +55,12 @@ pub const TestContext = struct {	...	@@ -55,12 +55,12 @@ pub const TestContext = struct {
55	self.zig_lib_dir = try introspect.resolveZigLibDir(allocator);	55	self.zig_lib_dir = try introspect.resolveZigLibDir(allocator);
56	errdefer allocator.free(self.zig_lib_dir);	56	errdefer allocator.free(self.zig_lib_dir);
57		57
58	try std.os.makePath(allocator, tmp_dir_name);	58	try std.fs.makePath(allocator, tmp_dir_name);
59	errdefer std.os.deleteTree(allocator, tmp_dir_name) catch {};	59	errdefer std.fs.deleteTree(allocator, tmp_dir_name) catch {};
60	}	60	}
61		61
62	fn deinit(self: *TestContext) void {	62	fn deinit(self: *TestContext) void {
63	std.os.deleteTree(allocator, tmp_dir_name) catch {};	63	std.fs.deleteTree(allocator, tmp_dir_name) catch {};
64	allocator.free(self.zig_lib_dir);	64	allocator.free(self.zig_lib_dir);
65	self.zig_compiler.deinit();	65	self.zig_compiler.deinit();
66	self.loop.deinit();	66	self.loop.deinit();
...	@@ -87,10 +87,10 @@ pub const TestContext = struct {	...	@@ -87,10 +87,10 @@ pub const TestContext = struct {
87	) !void {	87	) !void {
88	var file_index_buf: [20]u8 = undefined;	88	var file_index_buf: [20]u8 = undefined;
89	const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.incr());	89	const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.incr());
90	const file1_path = try std.os.path.join(allocator, [][]const u8{ tmp_dir_name, file_index, file1 });	90	const file1_path = try std.fs.path.join(allocator, [][]const u8{ tmp_dir_name, file_index, file1 });
91		91
92	if (std.os.path.dirname(file1_path)) \|dirname\| {	92	if (std.fs.path.dirname(file1_path)) \|dirname\| {
93	try std.os.makePath(allocator, dirname);	93	try std.fs.makePath(allocator, dirname);
94	}	94	}
95		95
96	// TODO async I/O	96	// TODO async I/O
...	@@ -120,11 +120,11 @@ pub const TestContext = struct {	...	@@ -120,11 +120,11 @@ pub const TestContext = struct {
120	) !void {	120	) !void {
121	var file_index_buf: [20]u8 = undefined;	121	var file_index_buf: [20]u8 = undefined;
122	const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.incr());	122	const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.incr());
123	const file1_path = try std.os.path.join(allocator, [][]const u8{ tmp_dir_name, file_index, file1 });	123	const file1_path = try std.fs.path.join(allocator, [][]const u8{ tmp_dir_name, file_index, file1 });
124		124
125	const output_file = try std.fmt.allocPrint(allocator, "{}-out{}", file1_path, Target(Target.Native).exeFileExt());	125	const output_file = try std.fmt.allocPrint(allocator, "{}-out{}", file1_path, Target(Target.Native).exeFileExt());
126	if (std.os.path.dirname(file1_path)) \|dirname\| {	126	if (std.fs.path.dirname(file1_path)) \|dirname\| {
127	try std.os.makePath(allocator, dirname);	127	try std.fs.makePath(allocator, dirname);
128	}	128	}
129		129
130	// TODO async I/O	130	// TODO async I/O
...	@@ -164,9 +164,9 @@ pub const TestContext = struct {	...	@@ -164,9 +164,9 @@ pub const TestContext = struct {
164	Compilation.Event.Ok => {	164	Compilation.Event.Ok => {
165	const argv = []const []const u8{exe_file_2};	165	const argv = []const []const u8{exe_file_2};
166	// TODO use event loop	166	// TODO use event loop
167	const child = try std.os.ChildProcess.exec(allocator, argv, null, null, 1024 * 1024);	167	const child = try std.ChildProcess.exec(allocator, argv, null, null, 1024 * 1024);
168	switch (child.term) {	168	switch (child.term) {
169	std.os.ChildProcess.Term.Exited => \|code\| {	169	.Exited => \|code\| {
170	if (code != 0) {	170	if (code != 0) {
171	return error.BadReturnCode;	171	return error.BadReturnCode;
172	}	172	}

std/buffer.zig+1-3

 @@ -139,15 +139,13 @@ pub const Buffer = struct {
 };
 test "simple Buffer" {
-    const cstr = @import("cstr.zig");
     var buf = try Buffer.init(debug.global_allocator, "");
     testing.expect(buf.len() == 0);
     try buf.append("hello");
     try buf.append(" ");
     try buf.append("world");
     testing.expect(buf.eql("hello world"));
-    testing.expect(mem.eql(u8, cstr.toSliceConst(buf.toSliceConst().ptr), buf.toSliceConst()));
+    testing.expect(mem.eql(u8, mem.toSliceConst(u8, buf.toSliceConst().ptr), buf.toSliceConst()));
     var buf2 = try Buffer.initFromBuffer(buf);
     testing.expect(buf.eql(buf2.toSliceConst()));

std/build.zig+82-83

 @@ -1,6 +1,7 @@
 const std = @import("std.zig");
 const builtin = @import("builtin");
 const io = std.io;
+const fs = std.fs;
 const mem = std.mem;
 const debug = std.debug;
 const assert = debug.assert;
 @@ -8,9 +9,7 @@ const warn = std.debug.warn;
 const ArrayList = std.ArrayList;
 const HashMap = std.HashMap;
 const Allocator = mem.Allocator;
-const os = std.os;
+const process = std.process;
-const StdIo = os.ChildProcess.StdIo;
-const Term = os.ChildProcess.Term;
 const BufSet = std.BufSet;
 const BufMap = std.BufMap;
 const fmt_lib = std.fmt;
 @@ -96,11 +95,11 @@ pub const Builder = struct {
     pub fn init(allocator: *Allocator, zig_exe: []const u8, build_root: []const u8, cache_root: []const u8) Builder {
         const env_map = allocator.create(BufMap) catch unreachable;
-        env_map.* = os.getEnvMap(allocator) catch unreachable;
+        env_map.* = process.getEnvMap(allocator) catch unreachable;
         var self = Builder{
             .zig_exe = zig_exe,
             .build_root = build_root,
-            .cache_root = os.path.relative(allocator, build_root, cache_root) catch unreachable,
+            .cache_root = fs.path.relative(allocator, build_root, cache_root) catch unreachable,
             .verbose = false,
             .verbose_tokenize = false,
             .verbose_ast = false,
 @@ -154,8 +153,8 @@ pub const Builder = struct {
     pub fn setInstallPrefix(self: *Builder, maybe_prefix: ?[]const u8) void {
         self.prefix = maybe_prefix orelse "/usr/local"; // TODO better default
-        self.lib_dir = os.path.join(self.allocator, [][]const u8{ self.prefix, "lib" }) catch unreachable;
+        self.lib_dir = fs.path.join(self.allocator, [][]const u8{ self.prefix, "lib" }) catch unreachable;
-        self.exe_dir = os.path.join(self.allocator, [][]const u8{ self.prefix, "bin" }) catch unreachable;
+        self.exe_dir = fs.path.join(self.allocator, [][]const u8{ self.prefix, "bin" }) catch unreachable;
     }
     pub fn addExecutable(self: *Builder, name: []const u8, root_src: ?[]const u8) *LibExeObjStep {
 @@ -287,7 +286,7 @@ pub const Builder = struct {
             if (self.verbose) {
                 warn("rm {}\n", installed_file);
             }
-            os.deleteFile(installed_file) catch {};
+            fs.deleteFile(installed_file) catch {};
         }
         // TODO remove empty directories
 @@ -326,7 +325,7 @@ pub const Builder = struct {
     fn detectNativeSystemPaths(self: *Builder) void {
         var is_nixos = false;
-        if (os.getEnvVarOwned(self.allocator, "NIX_CFLAGS_COMPILE")) |nix_cflags_compile| {
+        if (process.getEnvVarOwned(self.allocator, "NIX_CFLAGS_COMPILE")) |nix_cflags_compile| {
             is_nixos = true;
             var it = mem.tokenize(nix_cflags_compile, " ");
             while (true) {
 @@ -345,7 +344,7 @@ pub const Builder = struct {
         } else |err| {
             assert(err == error.EnvironmentVariableNotFound);
         }
-        if (os.getEnvVarOwned(self.allocator, "NIX_LDFLAGS")) |nix_ldflags| {
+        if (process.getEnvVarOwned(self.allocator, "NIX_LDFLAGS")) |nix_ldflags| {
             is_nixos = true;
             var it = mem.tokenize(nix_ldflags, " ");
             while (true) {
 @@ -369,7 +368,7 @@ pub const Builder = struct {
         }
         if (is_nixos) return;
         switch (builtin.os) {
-            builtin.Os.windows => {},
+            .windows => {},
             else => {
                 const triple = (CrossTarget{
                     .arch = builtin.arch,
 @@ -602,7 +601,7 @@ pub const Builder = struct {
             printCmd(cwd, argv);
         }
-        const child = os.ChildProcess.init(argv, self.allocator) catch unreachable;
+        const child = std.ChildProcess.init(argv, self.allocator) catch unreachable;
         defer child.deinit();
         child.cwd = cwd;
 @@ -614,7 +613,7 @@ pub const Builder = struct {
         };
         switch (term) {
-            Term.Exited => |code| {
+            .Exited => |code| {
                 if (code != 0) {
                     warn("The following command exited with error code {}:\n", code);
                     printCmd(cwd, argv);
 @@ -631,7 +630,7 @@ pub const Builder = struct {
     }
     pub fn makePath(self: *Builder, path: []const u8) !void {
-        os.makePath(self.allocator, self.pathFromRoot(path)) catch |err| {
+        fs.makePath(self.allocator, self.pathFromRoot(path)) catch |err| {
             warn("Unable to create path {}: {}\n", path, @errorName(err));
             return err;
         };
 @@ -652,7 +651,7 @@ pub const Builder = struct {
     ///::dest_rel_path is relative to prefix path or it can be an absolute path
     pub fn addInstallFile(self: *Builder, src_path: []const u8, dest_rel_path: []const u8) *InstallFileStep {
-        const full_dest_path = os.path.resolve(
+        const full_dest_path = fs.path.resolve(
             self.allocator,
             [][]const u8{ self.prefix, dest_rel_path },
         ) catch unreachable;
 @@ -677,20 +676,20 @@ pub const Builder = struct {
             warn("cp {} {}\n", source_path, dest_path);
         }
-        const dirname = os.path.dirname(dest_path) orelse ".";
+        const dirname = fs.path.dirname(dest_path) orelse ".";
         const abs_source_path = self.pathFromRoot(source_path);
-        os.makePath(self.allocator, dirname) catch |err| {
+        fs.makePath(self.allocator, dirname) catch |err| {
             warn("Unable to create path {}: {}\n", dirname, @errorName(err));
             return err;
         };
-        os.copyFileMode(abs_source_path, dest_path, mode) catch |err| {
+        fs.copyFileMode(abs_source_path, dest_path, mode) catch |err| {
             warn("Unable to copy {} to {}: {}\n", abs_source_path, dest_path, @errorName(err));
             return err;
         };
     }
     fn pathFromRoot(self: *Builder, rel_path: []const u8) []u8 {
-        return os.path.resolve(self.allocator, [][]const u8{ self.build_root, rel_path }) catch unreachable;
+        return fs.path.resolve(self.allocator, [][]const u8{ self.build_root, rel_path }) catch unreachable;
     }
     pub fn fmt(self: *Builder, comptime format: []const u8, args: ...) []u8 {
 @@ -702,11 +701,11 @@ pub const Builder = struct {
         const exe_extension = (Target{ .Native = {} }).exeFileExt();
         for (self.search_prefixes.toSliceConst()) |search_prefix| {
             for (names) |name| {
-                if (os.path.isAbsolute(name)) {
+                if (fs.path.isAbsolute(name)) {
                     return name;
                 }
-                const full_path = try os.path.join(self.allocator, [][]const u8{ search_prefix, "bin", self.fmt("{}{}", name, exe_extension) });
+                const full_path = try fs.path.join(self.allocator, [][]const u8{ search_prefix, "bin", self.fmt("{}{}", name, exe_extension) });
-                if (os.path.real(self.allocator, full_path)) |real_path| {
+                if (fs.path.real(self.allocator, full_path)) |real_path| {
                     return real_path;
                 } else |_| {
                     continue;
 @@ -715,13 +714,13 @@ pub const Builder = struct {
         }
         if (self.env_map.get("PATH")) |PATH| {
             for (names) |name| {
-                if (os.path.isAbsolute(name)) {
+                if (fs.path.isAbsolute(name)) {
                     return name;
                 }
-                var it = mem.tokenize(PATH, []u8{os.path.delimiter});
+                var it = mem.tokenize(PATH, []u8{fs.path.delimiter});
                 while (it.next()) |path| {
-                    const full_path = try os.path.join(self.allocator, [][]const u8{ path, self.fmt("{}{}", name, exe_extension) });
+                    const full_path = try fs.path.join(self.allocator, [][]const u8{ path, self.fmt("{}{}", name, exe_extension) });
-                    if (os.path.real(self.allocator, full_path)) |real_path| {
+                    if (fs.path.real(self.allocator, full_path)) |real_path| {
                         return real_path;
                     } else |_| {
                         continue;
 @@ -730,12 +729,12 @@ pub const Builder = struct {
             }
         }
         for (names) |name| {
-            if (os.path.isAbsolute(name)) {
+            if (fs.path.isAbsolute(name)) {
                 return name;
             }
             for (paths) |path| {
-                const full_path = try os.path.join(self.allocator, [][]const u8{ path, self.fmt("{}{}", name, exe_extension) });
+                const full_path = try fs.path.join(self.allocator, [][]const u8{ path, self.fmt("{}{}", name, exe_extension) });
-                if (os.path.real(self.allocator, full_path)) |real_path| {
+                if (fs.path.real(self.allocator, full_path)) |real_path| {
                     return real_path;
                 } else |_| {
                     continue;
 @@ -749,12 +748,12 @@ pub const Builder = struct {
         assert(argv.len != 0);
         const max_output_size = 100 * 1024;
-        const child = try os.ChildProcess.init(argv, self.allocator);
+        const child = try std.ChildProcess.init(argv, self.allocator);
         defer child.deinit();
-        child.stdin_behavior = os.ChildProcess.StdIo.Ignore;
+        child.stdin_behavior = .Ignore;
-        child.stdout_behavior = os.ChildProcess.StdIo.Pipe;
+        child.stdout_behavior = .Pipe;
-        child.stderr_behavior = os.ChildProcess.StdIo.Inherit;
+        child.stderr_behavior = .Inherit;
         try child.spawn();
 @@ -766,7 +765,7 @@ pub const Builder = struct {
         const term = child.wait() catch |err| std.debug.panic("unable to spawn {}: {}", argv[0], err);
         switch (term) {
-            os.ChildProcess.Term.Exited => |code| {
+            .Exited => |code| {
                 if (code != 0) {
                     warn("The following command exited with error code {}:\n", code);
                     printCmd(null, argv);
 @@ -846,7 +845,7 @@ pub const Target = union(enum) {
         }
     }
-    pub fn oFileExt(self: *const Target) []const u8 {
+    pub fn oFileExt(self: Target) []const u8 {
         const abi = switch (self.*) {
             Target.Native => builtin.abi,
             Target.Cross => |t| t.abi,
 @@ -857,49 +856,49 @@ pub const Target = union(enum) {
         };
     }
-    pub fn exeFileExt(self: *const Target) []const u8 {
+    pub fn exeFileExt(self: Target) []const u8 {
         return switch (self.getOs()) {
-            builtin.Os.windows => ".exe",
+            .windows => ".exe",
             else => "",
         };
     }
-    pub fn libFileExt(self: *const Target) []const u8 {
+    pub fn libFileExt(self: Target) []const u8 {
         return switch (self.getOs()) {
-            builtin.Os.windows => ".lib",
+            .windows => ".lib",
             else => ".a",
         };
     }
-    pub fn getOs(self: *const Target) builtin.Os {
+    pub fn getOs(self: Target) builtin.Os {
-        return switch (self.*) {
+        return switch (self) {
             Target.Native => builtin.os,
             Target.Cross => |t| t.os,
         };
     }
-    pub fn isDarwin(self: *const Target) bool {
+    pub fn isDarwin(self: Target) bool {
         return switch (self.getOs()) {
-            builtin.Os.ios, builtin.Os.macosx => true,
+            .ios, .macosx, .watchos, .tvos => true,
             else => false,
         };
     }
-    pub fn isWindows(self: *const Target) bool {
+    pub fn isWindows(self: Target) bool {
         return switch (self.getOs()) {
-            builtin.Os.windows => true,
+            .windows => true,
             else => false,
         };
     }
-    pub fn isFreeBSD(self: *const Target) bool {
+    pub fn isFreeBSD(self: Target) bool {
         return switch (self.getOs()) {
-            builtin.Os.freebsd => true,
+            .freebsd => true,
             else => false,
         };
     }
-    pub fn wantSharedLibSymLinks(self: *const Target) bool {
+    pub fn wantSharedLibSymLinks(self: Target) bool {
         return !self.isWindows();
     }
 };
 @@ -1065,19 +1064,19 @@ pub const LibExeObjStep = struct {
     fn computeOutFileNames(self: *LibExeObjStep) void {
         switch (self.kind) {
-            Kind.Obj => {
+            .Obj => {
                 self.out_filename = self.builder.fmt("{}{}", self.name, self.target.oFileExt());
             },
-            Kind.Exe => {
+            .Exe => {
                 self.out_filename = self.builder.fmt("{}{}", self.name, self.target.exeFileExt());
             },
-            Kind.Test => {
+            .Test => {
                 self.out_filename = self.builder.fmt("test{}", self.target.exeFileExt());
             },
-            Kind.Lib => {
+            .Lib => {
                 if (!self.is_dynamic) {
                     switch (self.target.getOs()) {
-                        builtin.Os.windows => {
+                        .windows => {
                             self.out_filename = self.builder.fmt("{}.lib", self.name);
                         },
                         else => {
 @@ -1087,13 +1086,13 @@ pub const LibExeObjStep = struct {
                     self.out_lib_filename = self.out_filename;
                 } else {
                     switch (self.target.getOs()) {
-                        builtin.Os.ios, builtin.Os.macosx => {
+                        .ios, .macosx => {
                             self.out_filename = self.builder.fmt("lib{}.{d}.{d}.{d}.dylib", self.name, self.version.major, self.version.minor, self.version.patch);
                             self.major_only_filename = self.builder.fmt("lib{}.{d}.dylib", self.name, self.version.major);
                             self.name_only_filename = self.builder.fmt("lib{}.dylib", self.name);
                             self.out_lib_filename = self.out_filename;
                         },
-                        builtin.Os.windows => {
+                        .windows => {
                             self.out_filename = self.builder.fmt("{}.dll", self.name);
                             self.out_lib_filename = self.builder.fmt("{}.lib", self.name);
                         },
 @@ -1228,7 +1227,7 @@ pub const LibExeObjStep = struct {
     /// the make step, from a step that has declared a dependency on this one.
     /// To run an executable built with zig build, use `run`, or create an install step and invoke it.
     pub fn getOutputPath(self: *LibExeObjStep) []const u8 {
-        return os.path.join(
+        return fs.path.join(
             self.builder.allocator,
             [][]const u8{ self.output_dir.?, self.out_filename },
         ) catch unreachable;
 @@ -1238,7 +1237,7 @@ pub const LibExeObjStep = struct {
     /// the make step, from a step that has declared a dependency on this one.
     pub fn getOutputLibPath(self: *LibExeObjStep) []const u8 {
         assert(self.kind == Kind.Lib);
-        return os.path.join(
+        return fs.path.join(
             self.builder.allocator,
             [][]const u8{ self.output_dir.?, self.out_lib_filename },
         ) catch unreachable;
 @@ -1249,7 +1248,7 @@ pub const LibExeObjStep = struct {
     pub fn getOutputHPath(self: *LibExeObjStep) []const u8 {
         assert(self.kind != Kind.Exe);
         assert(!self.disable_gen_h);
-        return os.path.join(
+        return fs.path.join(
             self.builder.allocator,
             [][]const u8{ self.output_dir.?, self.out_h_filename },
         ) catch unreachable;
 @@ -1365,7 +1364,7 @@ pub const LibExeObjStep = struct {
                             try zig_args.append("--library");
                             try zig_args.append(full_path_lib);
-                            if (os.path.dirname(full_path_lib)) |dirname| {
+                            if (fs.path.dirname(full_path_lib)) |dirname| {
                                 try zig_args.append("-rpath");
                                 try zig_args.append(dirname);
                             }
 @@ -1391,7 +1390,7 @@ pub const LibExeObjStep = struct {
         }
         if (self.build_options_contents.len() > 0) {
-            const build_options_file = try os.path.join(
+            const build_options_file = try fs.path.join(
                 builder.allocator,
                 [][]const u8{ builder.cache_root, builder.fmt("{}_build_options.zig", self.name) },
             );
 @@ -1503,7 +1502,7 @@ pub const LibExeObjStep = struct {
                 IncludeDir.OtherStep => |other| {
                     const h_path = other.getOutputHPath();
                     try zig_args.append("-isystem");
-                    try zig_args.append(os.path.dirname(h_path).?);
+                    try zig_args.append(fs.path.dirname(h_path).?);
                 },
             }
         }
 @@ -1576,7 +1575,7 @@ pub const LibExeObjStep = struct {
             const output_path_nl = try builder.exec(zig_args.toSliceConst());
             const output_path = mem.trimRight(u8, output_path_nl, "\r\n");
-            self.output_dir = os.path.dirname(output_path).?;
+            self.output_dir = fs.path.dirname(output_path).?;
         }
         if (self.kind == Kind.Lib and self.is_dynamic and self.target.wantSharedLibSymLinks()) {
 @@ -1637,20 +1636,20 @@ pub const RunStep = struct {
     }
     pub fn addPathDir(self: *RunStep, search_path: []const u8) void {
-        const PATH = if (builtin.os == builtin.Os.windows) "Path" else "PATH";
+        const PATH = if (std.os.windows.is_the_target) "Path" else "PATH";
         const env_map = self.getEnvMap();
         const prev_path = env_map.get(PATH) orelse {
             env_map.set(PATH, search_path) catch unreachable;
             return;
         };
-        const new_path = self.builder.fmt("{}" ++ [1]u8{os.path.delimiter} ++ "{}", prev_path, search_path);
+        const new_path = self.builder.fmt("{}" ++ [1]u8{fs.path.delimiter} ++ "{}", prev_path, search_path);
         env_map.set(PATH, new_path) catch unreachable;
     }
     pub fn getEnvMap(self: *RunStep) *BufMap {
         return self.env_map orelse {
             const env_map = self.builder.allocator.create(BufMap) catch unreachable;
-            env_map.* = os.getEnvMap(self.builder.allocator) catch unreachable;
+            env_map.* = process.getEnvMap(self.builder.allocator) catch unreachable;
             self.env_map = env_map;
             return env_map;
         };
 @@ -1688,7 +1687,7 @@ pub const RunStep = struct {
             switch (link_object) {
                 LibExeObjStep.LinkObject.OtherStep => |other| {
                     if (other.target.isWindows() and other.isDynamicLibrary()) {
-                        self.addPathDir(os.path.dirname(other.getOutputPath()).?);
+                        self.addPathDir(fs.path.dirname(other.getOutputPath()).?);
                         self.addPathForDynLibs(other);
                     }
                 },
 @@ -1718,7 +1717,7 @@ const InstallArtifactStep = struct {
             .builder = builder,
             .step = Step.init(builder.fmt("install {}", artifact.step.name), builder.allocator, make),
             .artifact = artifact,
-            .dest_file = os.path.join(
+            .dest_file = fs.path.join(
                 builder.allocator,
                 [][]const u8{ dest_dir, artifact.out_filename },
             ) catch unreachable,
 @@ -1726,11 +1725,11 @@ const InstallArtifactStep = struct {
         self.step.dependOn(&artifact.step);
         builder.pushInstalledFile(self.dest_file);
         if (self.artifact.kind == LibExeObjStep.Kind.Lib and self.artifact.is_dynamic) {
-            builder.pushInstalledFile(os.path.join(
+            builder.pushInstalledFile(fs.path.join(
                 builder.allocator,
                 [][]const u8{ builder.lib_dir, artifact.major_only_filename },
             ) catch unreachable);
-            builder.pushInstalledFile(os.path.join(
+            builder.pushInstalledFile(fs.path.join(
                 builder.allocator,
                 [][]const u8{ builder.lib_dir, artifact.name_only_filename },
             ) catch unreachable);
 @@ -1743,12 +1742,12 @@ const InstallArtifactStep = struct {
         const builder = self.builder;
         const mode = switch (builtin.os) {
-            builtin.Os.windows => {},
+            .windows => {},
             else => switch (self.artifact.kind) {
-                LibExeObjStep.Kind.Obj => unreachable,
+                .Obj => unreachable,
-                LibExeObjStep.Kind.Test => unreachable,
+                .Test => unreachable,
-                LibExeObjStep.Kind.Exe => u32(0o755),
+                .Exe => u32(0o755),
-                LibExeObjStep.Kind.Lib => if (!self.artifact.is_dynamic) u32(0o666) else u32(0o755),
+                .Lib => if (!self.artifact.is_dynamic) u32(0o666) else u32(0o755),
             },
         };
         try builder.copyFileMode(self.artifact.getOutputPath(), self.dest_file, mode);
 @@ -1797,8 +1796,8 @@ pub const WriteFileStep = struct {
     fn make(step: *Step) !void {
         const self = @fieldParentPtr(WriteFileStep, "step", step);
         const full_path = self.builder.pathFromRoot(self.file_path);
-        const full_path_dir = os.path.dirname(full_path) orelse ".";
+        const full_path_dir = fs.path.dirname(full_path) orelse ".";
-        os.makePath(self.builder.allocator, full_path_dir) catch |err| {
+        fs.makePath(self.builder.allocator, full_path_dir) catch |err| {
             warn("unable to make path {}: {}\n", full_path_dir, @errorName(err));
             return err;
         };
 @@ -1845,7 +1844,7 @@ pub const RemoveDirStep = struct {
         const self = @fieldParentPtr(RemoveDirStep, "step", step);
         const full_path = self.builder.pathFromRoot(self.dir_path);
-        os.deleteTree(self.builder.allocator, full_path) catch |err| {
+        fs.deleteTree(self.builder.allocator, full_path) catch |err| {
             warn("Unable to remove {}: {}\n", full_path, @errorName(err));
             return err;
         };
 @@ -1887,23 +1886,23 @@ pub const Step = struct {
 };
 fn doAtomicSymLinks(allocator: *Allocator, output_path: []const u8, filename_major_only: []const u8, filename_name_only: []const u8) !void {
-    const out_dir = os.path.dirname(output_path) orelse ".";
+    const out_dir = fs.path.dirname(output_path) orelse ".";
-    const out_basename = os.path.basename(output_path);
+    const out_basename = fs.path.basename(output_path);
     // sym link for libfoo.so.1 to libfoo.so.1.2.3
-    const major_only_path = os.path.join(
+    const major_only_path = fs.path.join(
         allocator,
         [][]const u8{ out_dir, filename_major_only },
     ) catch unreachable;
-    os.atomicSymLink(allocator, out_basename, major_only_path) catch |err| {
+    fs.atomicSymLink(allocator, out_basename, major_only_path) catch |err| {
         warn("Unable to symlink {} -> {}\n", major_only_path, out_basename);
         return err;
     };
     // sym link for libfoo.so to libfoo.so.1
-    const name_only_path = os.path.join(
+    const name_only_path = fs.path.join(
         allocator,
         [][]const u8{ out_dir, filename_name_only },
     ) catch unreachable;
-    os.atomicSymLink(allocator, filename_major_only, name_only_path) catch |err| {
+    fs.atomicSymLink(allocator, filename_major_only, name_only_path) catch |err| {
         warn("Unable to symlink {} -> {}\n", name_only_path, filename_major_only);
         return err;
     };

std/child_process.zig+23-25

 @@ -2,7 +2,9 @@ const std = @import("std.zig");
 const cstr = std.cstr;
 const unicode = std.unicode;
 const io = std.io;
+const fs = std.fs;
 const os = std.os;
+const process = std.process;
 const File = std.fs.File;
 const windows = os.windows;
 const mem = std.mem;
 @@ -14,12 +16,10 @@ const Os = builtin.Os;
 const LinkedList = std.LinkedList;
 const maxInt = std.math.maxInt;
-const is_windows = builtin.os == .windows;
 pub const ChildProcess = struct {
-    pub pid: if (is_windows) void else i32,
+    pub pid: if (os.windows.is_the_target) void else i32,
-    pub handle: if (is_windows) windows.HANDLE else void,
+    pub handle: if (os.windows.is_the_target) windows.HANDLE else void,
-    pub thread_handle: if (is_windows) windows.HANDLE else void,
+    pub thread_handle: if (os.windows.is_the_target) windows.HANDLE else void,
     pub allocator: *mem.Allocator,
 @@ -39,16 +39,16 @@ pub const ChildProcess = struct {
     pub stderr_behavior: StdIo,
     /// Set to change the user id when spawning the child process.
-    pub uid: if (is_windows) void else ?u32,
+    pub uid: if (os.windows.is_the_target) void else ?u32,
     /// Set to change the group id when spawning the child process.
-    pub gid: if (is_windows) void else ?u32,
+    pub gid: if (os.windows.is_the_target) void else ?u32,
     /// Set to change the current working directory when spawning the child process.
     pub cwd: ?[]const u8,
-    err_pipe: if (is_windows) void else [2]i32,
+    err_pipe: if (os.windows.is_the_target) void else [2]i32,
-    llnode: if (is_windows) void else LinkedList(*ChildProcess).Node,
+    llnode: if (os.windows.is_the_target) void else LinkedList(*ChildProcess).Node,
     pub const SpawnError = error{
         ProcessFdQuotaExceeded,
 @@ -98,10 +98,8 @@ pub const ChildProcess = struct {
             .term = null,
             .env_map = null,
             .cwd = null,
-            .uid = if (is_windows) {} else
+            .uid = if (os.windows.is_the_target) {} else null,
-                null,
+            .gid = if (os.windows.is_the_target) {} else null,
-            .gid = if (is_windows) {} else
-                null,
             .stdin = null,
             .stdout = null,
             .stderr = null,
 @@ -121,7 +119,7 @@ pub const ChildProcess = struct {
     /// On success must call `kill` or `wait`.
     pub fn spawn(self: *ChildProcess) !void {
-        if (is_windows) {
+        if (os.windows.is_the_target) {
             return self.spawnWindows();
         } else {
             return self.spawnPosix();
 @@ -135,7 +133,7 @@ pub const ChildProcess = struct {
     /// Forcibly terminates child process and then cleans up all resources.
     pub fn kill(self: *ChildProcess) !Term {
-        if (is_windows) {
+        if (os.windows.is_the_target) {
             return self.killWindows(1);
         } else {
             return self.killPosix();
 @@ -165,7 +163,7 @@ pub const ChildProcess = struct {
     /// Blocks until child process terminates and then cleans up all resources.
     pub fn wait(self: *ChildProcess) !Term {
-        if (is_windows) {
+        if (os.windows.is_the_target) {
             return self.waitWindows();
         } else {
             return self.waitPosix();
 @@ -339,7 +337,7 @@ pub const ChildProcess = struct {
             break :x env_map;
         } else x: {
             we_own_env_map = true;
-            env_map_owned = try os.getEnvMap(self.allocator);
+            env_map_owned = try process.getEnvMap(self.allocator);
             break :x &env_map_owned;
         };
         defer {
 @@ -372,15 +370,15 @@ pub const ChildProcess = struct {
             }
             if (self.cwd) |cwd| {
-                os.changeCurDir(cwd) catch |err| forkChildErrReport(err_pipe[1], err);
+                os.chdir(cwd) catch |err| forkChildErrReport(err_pipe[1], err);
             }
             if (self.gid) |gid| {
-                os.posix_setregid(gid, gid) catch |err| forkChildErrReport(err_pipe[1], err);
+                os.setregid(gid, gid) catch |err| forkChildErrReport(err_pipe[1], err);
             }
             if (self.uid) |uid| {
-                os.posix_setreuid(uid, uid) catch |err| forkChildErrReport(err_pipe[1], err);
+                os.setreuid(uid, uid) catch |err| forkChildErrReport(err_pipe[1], err);
             }
             os.execve(self.allocator, self.argv, env_map) catch |err| forkChildErrReport(err_pipe[1], err);
 @@ -541,7 +539,7 @@ pub const ChildProcess = struct {
         // to match posix semantics
         const app_name = x: {
             if (self.cwd) |cwd| {
-                const resolved = try os.path.resolve(self.allocator, [][]const u8{ cwd, self.argv[0] });
+                const resolved = try fs.path.resolve(self.allocator, [][]const u8{ cwd, self.argv[0] });
                 defer self.allocator.free(resolved);
                 break :x try cstr.addNullByte(self.allocator, resolved);
             } else {
 @@ -559,12 +557,12 @@ pub const ChildProcess = struct {
         windowsCreateProcess(app_name_w.ptr, cmd_line_w.ptr, envp_ptr, cwd_w_ptr, &siStartInfo, &piProcInfo) catch |no_path_err| {
             if (no_path_err != error.FileNotFound) return no_path_err;
-            const PATH = try os.getEnvVarOwned(self.allocator, "PATH");
+            const PATH = try process.getEnvVarOwned(self.allocator, "PATH");
             defer self.allocator.free(PATH);
             var it = mem.tokenize(PATH, ";");
             while (it.next()) |search_path| {
-                const joined_path = try os.path.join(self.allocator, [][]const u8{ search_path, app_name });
+                const joined_path = try fs.path.join(self.allocator, [][]const u8{ search_path, app_name });
                 defer self.allocator.free(joined_path);
                 const joined_path_w = try unicode.utf8ToUtf16LeWithNull(self.allocator, joined_path);
 @@ -616,10 +614,10 @@ pub const ChildProcess = struct {
     fn setUpChildIo(stdio: StdIo, pipe_fd: i32, std_fileno: i32, dev_null_fd: i32) !void {
         switch (stdio) {
-            StdIo.Pipe => try os.posixDup2(pipe_fd, std_fileno),
+            StdIo.Pipe => try os.dup2(pipe_fd, std_fileno),
             StdIo.Close => os.close(std_fileno),
             StdIo.Inherit => {},
-            StdIo.Ignore => try os.posixDup2(dev_null_fd, std_fileno),
+            StdIo.Ignore => try os.dup2(dev_null_fd, std_fileno),
         }
     }
 };

std/cstr.zig-15

...	@@ -9,11 +9,6 @@ pub const line_sep = switch (builtin.os) {	...	@@ -9,11 +9,6 @@ pub const line_sep = switch (builtin.os) {
9	else => "\n",	9	else => "\n",
10	};	10	};
11		11
12	/// Deprecated, use mem.len
13	pub fn len(ptr: [*]const u8) usize {
14	return mem.len(u8, ptr);
15	}
16
17	pub fn cmp(a: []const u8, b: []const u8) i8 {	12	pub fn cmp(a: []const u8, b: []const u8) i8 {
18	var index: usize = 0;	13	var index: usize = 0;
19	while (a[index] == b[index] and a[index] != 0) : (index += 1) {}	14	while (a[index] == b[index] and a[index] != 0) : (index += 1) {}
...	@@ -26,16 +21,6 @@ pub fn cmp(a: []const u8, b: []const u8) i8 {	...	@@ -26,16 +21,6 @@ pub fn cmp(a: []const u8, b: []const u8) i8 {
26	}	21	}
27	}	22	}
28		23
29	/// Deprecated, use mem.toSliceConst
30	pub fn toSliceConst(str: [*]const u8) []const u8 {
31	return mem.toSliceConst(u8, str);
32	}
33
34	/// Deprecated, use mem.toSlice
35	pub fn toSlice(str: [*]u8) []u8 {
36	return mem.toSlice(u8, str);
37	}
38
39	test "cstr fns" {	24	test "cstr fns" {
40	comptime testCStrFnsImpl();	25	comptime testCStrFnsImpl();
41	testCStrFnsImpl();	26	testCStrFnsImpl();

std/debug.zig+70-70

 @@ -3,16 +3,18 @@ const math = std.math;
 const mem = std.mem;
 const io = std.io;
 const os = std.os;
+const fs = std.fs;
+const process = std.process;
 const elf = std.elf;
 const DW = std.dwarf;
 const macho = std.macho;
 const coff = std.coff;
 const pdb = std.pdb;
-const windows = os.windows;
 const ArrayList = std.ArrayList;
 const builtin = @import("builtin");
 const maxInt = std.math.maxInt;
 const File = std.fs.File;
+const windows = std.os.windows;
 const leb = @import("debug/leb128.zig");
 @@ -20,8 +22,8 @@ pub const FailingAllocator = @import("debug/failing_allocator.zig").FailingAlloc
 pub const failing_allocator = &FailingAllocator.init(global_allocator, 0).allocator;
 pub const runtime_safety = switch (builtin.mode) {
-    builtin.Mode.Debug, builtin.Mode.ReleaseSafe => true,
+    .Debug, .ReleaseSafe => true,
-    builtin.Mode.ReleaseFast, builtin.Mode.ReleaseSmall => false,
+    .ReleaseFast, .ReleaseSmall => false,
 };
 const Module = struct {
 @@ -76,7 +78,7 @@ pub fn getSelfDebugInfo() !*DebugInfo {
 fn wantTtyColor() bool {
     var bytes: [128]u8 = undefined;
     const allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
-    return if (std.os.getEnvVarOwned(allocator, "ZIG_DEBUG_COLOR")) |_| true else |_| stderr_file.isTty();
+    return if (process.getEnvVarOwned(allocator, "ZIG_DEBUG_COLOR")) |_| true else |_| stderr_file.isTty();
 }
 /// Tries to print the current stack trace to stderr, unbuffered, and ignores any error returned.
 @@ -100,47 +102,44 @@ pub fn dumpCurrentStackTrace(start_addr: ?usize) void {
 /// chopping off the irrelevant frames and shifting so that the returned addresses pointer
 /// equals the passed in addresses pointer.
 pub fn captureStackTrace(first_address: ?usize, stack_trace: *builtin.StackTrace) void {
-    switch (builtin.os) {
+    if (windows.is_the_target) {
-        builtin.Os.windows => {
+        const addrs = stack_trace.instruction_addresses;
-            const addrs = stack_trace.instruction_addresses;
+        const u32_addrs_len = @intCast(u32, addrs.len);
-            const u32_addrs_len = @intCast(u32, addrs.len);
+        const first_addr = first_address orelse {
-            const first_addr = first_address orelse {
+            stack_trace.index = windows.ntdll.RtlCaptureStackBackTrace(
-                stack_trace.index = windows.RtlCaptureStackBackTrace(
+                0,
-                    0,
+                u32_addrs_len,
-                    u32_addrs_len,
+                @ptrCast(**c_void, addrs.ptr),
-                    @ptrCast(**c_void, addrs.ptr),
+                null,
-                    null,
+            );
-                );
+            return;
-                return;
+        };
-            };
+        var addr_buf_stack: [32]usize = undefined;
-            var addr_buf_stack: [32]usize = undefined;
+        const addr_buf = if (addr_buf_stack.len > addrs.len) addr_buf_stack[0..] else addrs;
-            const addr_buf = if (addr_buf_stack.len > addrs.len) addr_buf_stack[0..] else addrs;
+        const n = windows.ntdll.RtlCaptureStackBackTrace(0, u32_addrs_len, @ptrCast(**c_void, addr_buf.ptr), null);
-            const n = windows.RtlCaptureStackBackTrace(0, u32_addrs_len, @ptrCast(**c_void, addr_buf.ptr), null);
+        const first_index = for (addr_buf[0..n]) |addr, i| {
-            const first_index = for (addr_buf[0..n]) |addr, i| {
+            if (addr == first_addr) {
-                if (addr == first_addr) {
+                break i;
-                    break i;
+            }
-                }
+        } else {
-            } else {
+            stack_trace.index = 0;
-                stack_trace.index = 0;
+            return;
+        };
+        const slice = addr_buf[first_index..n];
+        // We use a for loop here because slice and addrs may alias.
+        for (slice) |addr, i| {
+            addrs[i] = addr;
+        }
+        stack_trace.index = slice.len;
+    } else {
+        var it = StackIterator.init(first_address);
+        for (stack_trace.instruction_addresses) |*addr, i| {
+            addr.* = it.next() orelse {
+                stack_trace.index = i;
                 return;
             };
-            const slice = addr_buf[first_index..n];
+        }
-            // We use a for loop here because slice and addrs may alias.
+        stack_trace.index = stack_trace.instruction_addresses.len;
-            for (slice) |addr, i| {
-                addrs[i] = addr;
-            }
-            stack_trace.index = slice.len;
-        },
-        else => {
-            var it = StackIterator.init(first_address);
-            for (stack_trace.instruction_addresses) |*addr, i| {
-                addr.* = it.next() orelse {
-                    stack_trace.index = i;
-                    return;
-                };
-            }
-            stack_trace.index = stack_trace.instruction_addresses.len;
-        },
     }
 }
 @@ -260,9 +259,8 @@ pub const StackIterator = struct {
 };
 pub fn writeCurrentStackTrace(out_stream: var, debug_info: *DebugInfo, tty_color: bool, start_addr: ?usize) !void {
-    switch (builtin.os) {
+    if (windows.is_the_target) {
-        builtin.Os.windows => return writeCurrentStackTraceWindows(out_stream, debug_info, tty_color, start_addr),
+        return writeCurrentStackTraceWindows(out_stream, debug_info, tty_color, start_addr);
-        else => {},
     }
     var it = StackIterator.init(start_addr);
     while (it.next()) |return_address| {
 @@ -277,7 +275,7 @@ pub fn writeCurrentStackTraceWindows(
     start_addr: ?usize,
 ) !void {
     var addr_buf: [1024]usize = undefined;
-    const n = windows.RtlCaptureStackBackTrace(0, addr_buf.len, @ptrCast(**c_void, &addr_buf), null);
+    const n = windows.ntdll.RtlCaptureStackBackTrace(0, addr_buf.len, @ptrCast(**c_void, &addr_buf), null);
     const addrs = addr_buf[0..n];
     var start_i: usize = if (start_addr) |saddr| blk: {
         for (addrs) |addr, i| {
 @@ -291,17 +289,18 @@ pub fn writeCurrentStackTraceWindows(
 }
 pub fn printSourceAtAddress(debug_info: *DebugInfo, out_stream: var, address: usize, tty_color: bool) !void {
-    switch (builtin.os) {
+    if (windows.is_the_target) {
-        builtin.Os.macosx => return printSourceAtAddressMacOs(debug_info, out_stream, address, tty_color),
+        return printSourceAtAddressWindows(debug_info, out_stream, address, tty_color);
-        builtin.Os.linux, builtin.Os.freebsd, builtin.Os.netbsd => return printSourceAtAddressLinux(debug_info, out_stream, address, tty_color),
-        builtin.Os.windows => return printSourceAtAddressWindows(debug_info, out_stream, address, tty_color),
-        else => return error.UnsupportedOperatingSystem,
     }
+    if (os.darwin.is_the_target) {
+        return printSourceAtAddressMacOs(debug_info, out_stream, address, tty_color);
+    }
+    return printSourceAtAddressPosix(debug_info, out_stream, address, tty_color);
 }
 fn printSourceAtAddressWindows(di: *DebugInfo, out_stream: var, relocated_address: usize, tty_color: bool) !void {
     const allocator = getDebugInfoAllocator();
-    const base_address = os.getBaseAddress();
+    const base_address = process.getBaseAddress();
     const relative_address = relocated_address - base_address;
     var coff_section: *coff.Section = undefined;
 @@ -331,7 +330,7 @@ fn printSourceAtAddressWindows(di: *DebugInfo, out_stream: var, relocated_addres
     const mod = &di.modules[mod_index];
     try populateModule(di, mod);
-    const obj_basename = os.path.basename(mod.obj_file_name);
+    const obj_basename = fs.path.basename(mod.obj_file_name);
     var symbol_i: usize = 0;
     const symbol_name = while (symbol_i != mod.symbols.len) {
 @@ -634,7 +633,7 @@ fn machoSearchSymbols(symbols: []const MachoSymbol, address: usize) ?*const Mach
 }
 fn printSourceAtAddressMacOs(di: *DebugInfo, out_stream: var, address: usize, tty_color: bool) !void {
-    const base_addr = std.os.getBaseAddress();
+    const base_addr = process.getBaseAddress();
     const adjusted_addr = 0x100000000 + (address - base_addr);
     const symbol = machoSearchSymbols(di.symbols, adjusted_addr) orelse {
 @@ -649,7 +648,7 @@ fn printSourceAtAddressMacOs(di: *DebugInfo, out_stream: var, address: usize, tt
     const symbol_name = mem.toSliceConst(u8, di.strings.ptr + symbol.nlist.n_strx);
     const compile_unit_name = if (symbol.ofile) |ofile| blk: {
         const ofile_path = mem.toSliceConst(u8, di.strings.ptr + ofile.n_strx);
-        break :blk os.path.basename(ofile_path);
+        break :blk fs.path.basename(ofile_path);
     } else "???";
     if (getLineNumberInfoMacOs(di, symbol.*, adjusted_addr)) |line_info| {
         defer line_info.deinit();
 @@ -716,7 +715,7 @@ pub fn printSourceAtAddressDwarf(
     }
 }
-pub fn printSourceAtAddressLinux(debug_info: *DebugInfo, out_stream: var, address: usize, tty_color: bool) !void {
+pub fn printSourceAtAddressPosix(debug_info: *DebugInfo, out_stream: var, address: usize, tty_color: bool) !void {
     return printSourceAtAddressDwarf(debug_info, out_stream, address, tty_color, printLineFromFileAnyOs);
 }
 @@ -776,16 +775,17 @@ pub const OpenSelfDebugInfoError = error{
 };
 pub fn openSelfDebugInfo(allocator: *mem.Allocator) !DebugInfo {
-    switch (builtin.os) {
+    if (windows.is_the_target) {
-        builtin.Os.linux, builtin.Os.freebsd, builtin.Os.netbsd => return openSelfDebugInfoLinux(allocator),
+        return openSelfDebugInfoWindows(allocator);
-        builtin.Os.macosx, builtin.Os.ios => return openSelfDebugInfoMacOs(allocator),
+    }
-        builtin.Os.windows => return openSelfDebugInfoWindows(allocator),
+    if (os.darwin.is_the_target) {
-        else => return error.UnsupportedOperatingSystem,
+        return openSelfDebugInfoMacOs(allocator);
     }
+    return openSelfDebugInfoPosix(allocator);
 }
 fn openSelfDebugInfoWindows(allocator: *mem.Allocator) !DebugInfo {
-    const self_file = try os.openSelfExe();
+    const self_file = try fs.openSelfExe();
     defer self_file.close();
     const coff_obj = try allocator.create(coff.Coff);
 @@ -812,7 +812,7 @@ fn openSelfDebugInfoWindows(allocator: *mem.Allocator) !DebugInfo {
     const len = try di.coff.getPdbPath(path_buf[0..]);
     const raw_path = path_buf[0..len];
-    const path = try os.path.resolve(allocator, [][]const u8{raw_path});
+    const path = try fs.path.resolve(allocator, [][]const u8{raw_path});
     try di.pdb.openFile(di.coff, path);
 @@ -1002,13 +1002,13 @@ pub fn openElfDebugInfo(
     return di;
 }
-fn openSelfDebugInfoLinux(allocator: *mem.Allocator) !DwarfInfo {
+fn openSelfDebugInfoPosix(allocator: *mem.Allocator) !DwarfInfo {
     const S = struct {
         var self_exe_file: File = undefined;
         var self_exe_mmap_seekable: io.SliceSeekableInStream = undefined;
     };
-    S.self_exe_file = try os.openSelfExe();
+    S.self_exe_file = try fs.openSelfExe();
     errdefer S.self_exe_file.close();
     const self_exe_mmap_len = try S.self_exe_file.getEndPos();
 @@ -1195,7 +1195,7 @@ pub const DwarfInfo = struct {
 };
 pub const DebugInfo = switch (builtin.os) {
-    builtin.Os.macosx, builtin.Os.ios => struct {
+    .macosx, .ios, .watchos, .tvos => struct {
         symbols: []const MachoSymbol,
         strings: []const u8,
         ofiles: OFileTable,
 @@ -1211,13 +1211,13 @@ pub const DebugInfo = switch (builtin.os) {
             return self.ofiles.allocator;
         }
     },
-    builtin.Os.uefi, builtin.Os.windows => struct {
+    .uefi, .windows => struct {
         pdb: pdb.Pdb,
         coff: *coff.Coff,
         sect_contribs: []pdb.SectionContribEntry,
         modules: []Module,
     },
-    builtin.Os.linux, builtin.Os.freebsd, builtin.Os.netbsd => DwarfInfo,
+    .linux, .freebsd, .netbsd => DwarfInfo,
     else => @compileError("Unsupported OS"),
 };
 @@ -1411,7 +1411,7 @@ const LineNumberProgram = struct {
                 return error.InvalidDebugInfo;
             } else
                 self.include_dirs[file_entry.dir_index];
-            const file_name = try os.path.join(self.file_entries.allocator, [][]const u8{ dir_name, file_entry.file_name });
+            const file_name = try fs.path.join(self.file_entries.allocator, [][]const u8{ dir_name, file_entry.file_name });
             errdefer self.file_entries.allocator.free(file_name);
             return LineInfo{
                 .line = if (self.prev_line >= 0) @intCast(u64, self.prev_line) else 0,

std/dynamic_library.zig+2-3

std/event/fs.zig+6-6

std/fmt.zig+1-1

...	@@ -226,7 +226,7 @@ pub fn formatType(	...	@@ -226,7 +226,7 @@ pub fn formatType(
226	builtin.TypeInfo.Pointer.Size.Many => {	226	builtin.TypeInfo.Pointer.Size.Many => {
227	if (ptr_info.child == u8) {	227	if (ptr_info.child == u8) {
228	if (fmt.len > 0 and fmt[0] == 's') {	228	if (fmt.len > 0 and fmt[0] == 's') {
229	const len = std.cstr.len(value);	229	const len = mem.len(u8, value);
230	return formatText(value[0..len], fmt, context, Errors, output);	230	return formatText(value[0..len], fmt, context, Errors, output);
231	}	231	}
232	}	232	}

std/fs.zig+10-10

std/fs/file.zig-24

...	@@ -307,28 +307,4 @@ pub const File = struct {	...	@@ -307,28 +307,4 @@ pub const File = struct {
307	return self.file.getPos();	307	return self.file.getPos();
308	}	308	}
309	};	309	};
310
311	pub fn stdout() !File {
312	if (windows.is_the_target) {
313	const handle = try windows.GetStdHandle(windows.STD_OUTPUT_HANDLE);
314	return openHandle(handle);
315	}
316	return openHandle(os.STDOUT_FILENO);
317	}
318
319	pub fn stderr() !File {
320	if (windows.is_the_target) {
321	const handle = try windows.GetStdHandle(windows.STD_ERROR_HANDLE);
322	return openHandle(handle);
323	}
324	return openHandle(os.STDERR_FILENO);
325	}
326
327	pub fn stdin() !File {
328	if (windows.is_the_target) {
329	const handle = try windows.GetStdHandle(windows.STD_INPUT_HANDLE);
330	return openHandle(handle);
331	}
332	return openHandle(os.STDIN_FILENO);
333	}
334	};	310	};

std/fs/get_app_data_dir.zig+7-6

 @@ -2,6 +2,7 @@ const std = @import("../std.zig");
 const builtin = @import("builtin");
 const unicode = std.unicode;
 const mem = std.mem;
+const fs = std.fs;
 const os = std.os;
 pub const GetAppDataDirError = error{
 @@ -15,7 +16,7 @@ pub fn getAppDataDir(allocator: *mem.Allocator, appname: []const u8) GetAppDataD
     switch (builtin.os) {
         .windows => {
             var dir_path_ptr: [*]u16 = undefined;
-            switch (os.windows.SHGetKnownFolderPath(
+            switch (os.windows.shell32.SHGetKnownFolderPath(
                 &os.windows.FOLDERID_LocalAppData,
                 os.windows.KF_FLAG_CREATE,
                 null,
 @@ -30,25 +31,25 @@ pub fn getAppDataDir(allocator: *mem.Allocator, appname: []const u8) GetAppDataD
                         error.OutOfMemory => return error.OutOfMemory,
                     };
                     defer allocator.free(global_dir);
-                    return os.path.join(allocator, [][]const u8{ global_dir, appname });
+                    return fs.path.join(allocator, [][]const u8{ global_dir, appname });
                 },
                 os.windows.E_OUTOFMEMORY => return error.OutOfMemory,
                 else => return error.AppDataDirUnavailable,
             }
         },
         .macosx => {
-            const home_dir = os.getEnvPosix("HOME") orelse {
+            const home_dir = os.getenv("HOME") orelse {
                 // TODO look in /etc/passwd
                 return error.AppDataDirUnavailable;
             };
-            return os.path.join(allocator, [][]const u8{ home_dir, "Library", "Application Support", appname });
+            return fs.path.join(allocator, [][]const u8{ home_dir, "Library", "Application Support", appname });
         },
         .linux, .freebsd, .netbsd => {
-            const home_dir = os.getEnvPosix("HOME") orelse {
+            const home_dir = os.getenv("HOME") orelse {
                 // TODO look in /etc/passwd
                 return error.AppDataDirUnavailable;
             };
-            return os.path.join(allocator, [][]const u8{ home_dir, ".local", "share", appname });
+            return fs.path.join(allocator, [][]const u8{ home_dir, ".local", "share", appname });
         },
         else => @compileError("Unsupported OS"),
     }

std/fs/path.zig+10-12

...	@@ -1,16 +1,14 @@	...	@@ -1,16 +1,14 @@
1	const std = @import("../std.zig");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const Os = builtin.Os;	2	const std = @import("../std.zig");
4	const debug = std.debug;	3	const debug = std.debug;
5	const assert = debug.assert;	4	const assert = debug.assert;
6	const testing = std.testing;	5	const testing = std.testing;
7	const mem = std.mem;	6	const mem = std.mem;
8	const fmt = std.fmt;	7	const fmt = std.fmt;
9	const Allocator = mem.Allocator;	8	const Allocator = mem.Allocator;
10	const os = std.os;
11	const math = std.math;	9	const math = std.math;
12	const windows = os.windows;	10	const windows = std.os.windows;
13	const cstr = std.cstr;	11	const fs = std.fs;
14		12
15	pub const sep_windows = '\\';	13	pub const sep_windows = '\\';
16	pub const sep_posix = '/';	14	pub const sep_posix = '/';
...	@@ -392,7 +390,7 @@ pub fn resolve(allocator: *Allocator, paths: []const []const u8) ![]u8 {	...	@@ -392,7 +390,7 @@ pub fn resolve(allocator: *Allocator, paths: []const []const u8) ![]u8 {
392	pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {	390	pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
393	if (paths.len == 0) {	391	if (paths.len == 0) {
394	assert(windows.is_the_target); // resolveWindows called on non windows can't use getCwd	392	assert(windows.is_the_target); // resolveWindows called on non windows can't use getCwd
395	return os.getCwdAlloc(allocator);	393	return fs.getCwdAlloc(allocator);
396	}	394	}
397		395
398	// determine which disk designator we will result with, if any	396	// determine which disk designator we will result with, if any
...	@@ -487,7 +485,7 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {	...	@@ -487,7 +485,7 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
487	},	485	},
488	WindowsPath.Kind.None => {	486	WindowsPath.Kind.None => {
489	assert(windows.is_the_target); // resolveWindows called on non windows can't use getCwd	487	assert(windows.is_the_target); // resolveWindows called on non windows can't use getCwd
490	const cwd = try os.getCwdAlloc(allocator);	488	const cwd = try fs.getCwdAlloc(allocator);
491	defer allocator.free(cwd);	489	defer allocator.free(cwd);
492	const parsed_cwd = windowsParsePath(cwd);	490	const parsed_cwd = windowsParsePath(cwd);
493	result = try allocator.alloc(u8, max_size + parsed_cwd.disk_designator.len + 1);	491	result = try allocator.alloc(u8, max_size + parsed_cwd.disk_designator.len + 1);
...	@@ -503,7 +501,7 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {	...	@@ -503,7 +501,7 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
503	} else {	501	} else {
504	assert(windows.is_the_target); // resolveWindows called on non windows can't use getCwd	502	assert(windows.is_the_target); // resolveWindows called on non windows can't use getCwd
505	// TODO call get cwd for the result_disk_designator instead of the global one	503	// TODO call get cwd for the result_disk_designator instead of the global one
506	const cwd = try os.getCwdAlloc(allocator);	504	const cwd = try fs.getCwdAlloc(allocator);
507	defer allocator.free(cwd);	505	defer allocator.free(cwd);
508		506
509	result = try allocator.alloc(u8, max_size + cwd.len + 1);	507	result = try allocator.alloc(u8, max_size + cwd.len + 1);
...	@@ -573,7 +571,7 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {	...	@@ -573,7 +571,7 @@ pub fn resolveWindows(allocator: *Allocator, paths: []const []const u8) ![]u8 {
573	pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {	571	pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
574	if (paths.len == 0) {	572	if (paths.len == 0) {
575	assert(!windows.is_the_target); // resolvePosix called on windows can't use getCwd	573	assert(!windows.is_the_target); // resolvePosix called on windows can't use getCwd
576	return os.getCwdAlloc(allocator);	574	return fs.getCwdAlloc(allocator);
577	}	575	}
578		576
579	var first_index: usize = 0;	577	var first_index: usize = 0;
...	@@ -595,7 +593,7 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {	...	@@ -595,7 +593,7 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
595	result = try allocator.alloc(u8, max_size);	593	result = try allocator.alloc(u8, max_size);
596	} else {	594	} else {
597	assert(!windows.is_the_target); // resolvePosix called on windows can't use getCwd	595	assert(!windows.is_the_target); // resolvePosix called on windows can't use getCwd
598	const cwd = try os.getCwdAlloc(allocator);	596	const cwd = try fs.getCwdAlloc(allocator);
599	defer allocator.free(cwd);	597	defer allocator.free(cwd);
600	result = try allocator.alloc(u8, max_size + cwd.len + 1);	598	result = try allocator.alloc(u8, max_size + cwd.len + 1);
601	mem.copy(u8, result, cwd);	599	mem.copy(u8, result, cwd);
...	@@ -634,7 +632,7 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {	...	@@ -634,7 +632,7 @@ pub fn resolvePosix(allocator: *Allocator, paths: []const []const u8) ![]u8 {
634	}	632	}
635		633
636	test "resolve" {	634	test "resolve" {
637	const cwd = try os.getCwdAlloc(debug.global_allocator);	635	const cwd = try fs.getCwdAlloc(debug.global_allocator);
638	if (windows.is_the_target) {	636	if (windows.is_the_target) {
639	if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {	637	if (windowsParsePath(cwd).kind == WindowsPath.Kind.Drive) {
640	cwd[0] = asciiUpper(cwd[0]);	638	cwd[0] = asciiUpper(cwd[0]);
...	@@ -648,7 +646,7 @@ test "resolve" {	...	@@ -648,7 +646,7 @@ test "resolve" {
648		646
649	test "resolveWindows" {	647	test "resolveWindows" {
650	if (windows.is_the_target) {	648	if (windows.is_the_target) {
651	const cwd = try os.getCwdAlloc(debug.global_allocator);	649	const cwd = try fs.getCwdAlloc(debug.global_allocator);
652	const parsed_cwd = windowsParsePath(cwd);	650	const parsed_cwd = windowsParsePath(cwd);
653	{	651	{
654	const result = testResolveWindows([][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" });	652	const result = testResolveWindows([][]const u8{ "/usr/local", "lib\\zig\\std\\array_list.zig" });

std/heap.zig+18-18

std/io.zig+25-2

...	@@ -15,8 +15,31 @@ const fmt = std.fmt;	...	@@ -15,8 +15,31 @@ const fmt = std.fmt;
15	const File = std.fs.File;	15	const File = std.fs.File;
16	const testing = std.testing;	16	const testing = std.testing;
17		17
18	const is_posix = builtin.os != builtin.Os.windows;	18	pub const GetStdIoError = os.windows.GetStdHandleError;
19	const is_windows = builtin.os == builtin.Os.windows;	19
		20	pub fn getStdOut() GetStdIoError!File {
		21	if (os.windows.is_the_target) {
		22	const handle = try os.windows.GetStdHandle(os.windows.STD_OUTPUT_HANDLE);
		23	return File.openHandle(handle);
		24	}
		25	return File.openHandle(os.STDOUT_FILENO);
		26	}
		27
		28	pub fn getStdErr() GetStdIoError!File {
		29	if (os.windows.is_the_target) {
		30	const handle = try os.windows.GetStdHandle(os.windows.STD_ERROR_HANDLE);
		31	return File.openHandle(handle);
		32	}
		33	return File.openHandle(os.STDERR_FILENO);
		34	}
		35
		36	pub fn getStdIn() GetStdIoError!File {
		37	if (os.windows.is_the_target) {
		38	const handle = try os.windows.GetStdHandle(os.windows.STD_INPUT_HANDLE);
		39	return File.openHandle(handle);
		40	}
		41	return File.openHandle(os.STDIN_FILENO);
		42	}
20		43
21	pub const SeekableStream = @import("io/seekable_stream.zig").SeekableStream;	44	pub const SeekableStream = @import("io/seekable_stream.zig").SeekableStream;
22	pub const SliceSeekableInStream = @import("io/seekable_stream.zig").SliceSeekableInStream;	45	pub const SliceSeekableInStream = @import("io/seekable_stream.zig").SliceSeekableInStream;

std/mem.zig-18

...	@@ -1462,21 +1462,3 @@ test "std.mem.alignForward" {	...	@@ -1462,21 +1462,3 @@ test "std.mem.alignForward" {
1462	testing.expect(alignForward(16, 8) == 16);	1462	testing.expect(alignForward(16, 8) == 16);
1463	testing.expect(alignForward(17, 8) == 24);	1463	testing.expect(alignForward(17, 8) == 24);
1464	}	1464	}
1465
1466	pub fn getBaseAddress() usize {
1467	switch (builtin.os) {
1468	.linux => {
1469	const base = std.os.system.getauxval(std.elf.AT_BASE);
1470	if (base != 0) {
1471	return base;
1472	}
1473	const phdr = std.os.system.getauxval(std.elf.AT_PHDR);
1474	return phdr - @sizeOf(std.elf.Ehdr);
1475	},
1476	.macosx, .freebsd, .netbsd => {
1477	return @ptrToInt(&std.c._mh_execute_header);
1478	},
1479	.windows => return @ptrToInt(windows.kernel32.GetModuleHandleW(null)),
1480	else => @compileError("Unsupported OS"),
1481	}
1482	}

std/os.zig+53-54

 @@ -8,7 +8,7 @@
 //   cross platform abstracting.
 // * When there exists a corresponding libc function and linking libc, the libc
 //   implementation is used. Exceptions are made for known buggy areas of libc.
-//   On Linux libc can be side-stepped by using `std.os.linux.sys`.
+//   On Linux libc can be side-stepped by using `std.os.linux` directly.
 // * For Windows, this file represents the API that libc would provide for
 //   Windows. For thin wrappers around Windows-specific APIs, see `std.os.windows`.
 // Note: The Zig standard library does not support POSIX thread cancellation, and
 @@ -16,7 +16,9 @@
 const std = @import("std.zig");
 const builtin = @import("builtin");
+const assert = std.debug.assert;
 const math = std.math;
+const mem = std.mem;
 const MAX_PATH_BYTES = std.fs.MAX_PATH_BYTES;
 comptime {
 @@ -46,9 +48,14 @@ pub const system = if (builtin.link_libc) std.c else switch (builtin.os) {
 pub use @import("os/bits.zig");
-/// See also `getenv`.
+/// See also `getenv`. Populated by startup code before main().
 pub var environ: [][*]u8 = undefined;
+/// Populated by startup code before main().
+/// Not available on Windows. See `std.process.args`
+/// for obtaining the process arguments.
+pub var argv: [][*]u8 = undefined;
 /// To obtain errno, call this function with the return value of the
 /// system function call. For some systems this will obtain the value directly
 /// from the return code; for others it will use a thread-local errno variable.
 @@ -103,7 +110,7 @@ pub fn getrandom(buf: []u8) GetRandomError!void {
         }
     }
     if (wasi.is_the_target) {
-        switch (os.wasi.random_get(buf.ptr, buf.len)) {
+        switch (wasi.random_get(buf.ptr, buf.len)) {
             0 => return,
             else => |err| return unexpectedErrno(err),
         }
 @@ -138,15 +145,15 @@ pub fn abort() noreturn {
         while (true) {}
     }
-    raise(SIGABRT);
+    raise(SIGABRT) catch {};
     // TODO the rest of the implementation of abort() from musl libc here
-    raise(SIGKILL);
+    raise(SIGKILL) catch {};
     exit(127);
 }
-pub const RaiseError = error{};
+pub const RaiseError = error{Unexpected};
 pub fn raise(sig: u8) RaiseError!void {
     if (builtin.link_libc) {
 @@ -163,19 +170,19 @@ pub fn raise(sig: u8) RaiseError!void {
         }
     }
-    if (windows.is_the_target) {
+    if (linux.is_the_target) {
-        @compileError("TODO implement std.os.raise for Windows");
+        var set: linux.sigset_t = undefined;
+        linux.blockAppSignals(&set);
+        const tid = linux.syscall0(linux.SYS_gettid);
+        const rc = linux.syscall2(linux.SYS_tkill, tid, sig);
+        linux.restoreSignals(&set);
+        switch (errno(rc)) {
+            0 => return,
+            else => |err| return unexpectedErrno(err),
+        }
     }
-    var set: system.sigset_t = undefined;
+    @compileError("std.os.raise unimplemented for this target");
-    system.blockAppSignals(&set);
-    const tid = system.syscall0(system.SYS_gettid);
-    const rc = system.syscall2(system.SYS_tkill, tid, sig);
-    system.restoreSignals(&set);
-    switch (errno(rc)) {
-        0 => return,
-        else => |err| return unexpectedErrno(err),
-    }
 }
 pub const KillError = error{
 @@ -229,13 +236,13 @@ pub fn read(fd: fd_t, buf: []u8) ReadError!usize {
     }
     if (wasi.is_the_target and !builtin.link_libc) {
-        const iovs = [1]was.iovec_t{wasi.iovec_t{
+        const iovs = [1]iovec{iovec{
-            .buf = buf.ptr,
+            .iov_base = buf.ptr,
-            .buf_len = buf.len,
+            .iov_len = buf.len,
         }};
         var nread: usize = undefined;
-        switch (fd_read(fd, &iovs, iovs.len, &nread)) {
+        switch (wasi.fd_read(fd, &iovs, iovs.len, &nread)) {
             0 => return nread,
             else => |err| return unexpectedErrno(err),
         }
 @@ -277,7 +284,7 @@ pub fn read(fd: fd_t, buf: []u8) ReadError!usize {
 /// This function is for blocking file descriptors only. For non-blocking, see
 /// `preadvAsync`.
 pub fn preadv(fd: fd_t, iov: [*]const iovec, count: usize, offset: u64) ReadError!usize {
-    if (os.darwin.is_the_target) {
+    if (darwin.is_the_target) {
         // Darwin does not have preadv but it does have pread.
         var off: usize = 0;
         var iov_i: usize = 0;
 @@ -353,12 +360,12 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!void {
     }
     if (wasi.is_the_target and !builtin.link_libc) {
-        const ciovs = [1]wasi.ciovec_t{wasi.ciovec_t{
+        const ciovs = [1]iovec_const{iovec_const{
-            .buf = bytes.ptr,
+            .iov_base = bytes.ptr,
-            .buf_len = bytes.len,
+            .iov_len = bytes.len,
         }};
         var nwritten: usize = undefined;
-        switch (fd_write(fd, &ciovs, ciovs.len, &nwritten)) {
+        switch (wasi.fd_write(fd, &ciovs, ciovs.len, &nwritten)) {
             0 => return,
             else => |err| return unexpectedErrno(err),
         }
 @@ -538,29 +545,29 @@ pub fn dup2(old_fd: fd_t, new_fd: fd_t) !void {
 /// `argv[0]` is the executable path.
 /// This function also uses the PATH environment variable to get the full path to the executable.
 /// TODO provide execveC which does not take an allocator
-pub fn execve(allocator: *Allocator, argv: []const []const u8, env_map: *const BufMap) !void {
+pub fn execve(allocator: *mem.Allocator, argv_slice: []const []const u8, env_map: *const std.BufMap) !void {
-    const argv_buf = try allocator.alloc(?[*]u8, argv.len + 1);
+    const argv_buf = try allocator.alloc(?[*]u8, argv_slice.len + 1);
     mem.set(?[*]u8, argv_buf, null);
     defer {
         for (argv_buf) |arg| {
-            const arg_buf = if (arg) |ptr| cstr.toSlice(ptr) else break;
+            const arg_buf = if (arg) |ptr| mem.toSlice(u8, ptr) else break;
             allocator.free(arg_buf);
         }
         allocator.free(argv_buf);
     }
-    for (argv) |arg, i| {
+    for (argv_slice) |arg, i| {
         const arg_buf = try allocator.alloc(u8, arg.len + 1);
         @memcpy(arg_buf.ptr, arg.ptr, arg.len);
         arg_buf[arg.len] = 0;
         argv_buf[i] = arg_buf.ptr;
     }
-    argv_buf[argv.len] = null;
+    argv_buf[argv_slice.len] = null;
     const envp_buf = try createNullDelimitedEnvMap(allocator, env_map);
     defer freeNullDelimitedEnvMap(allocator, envp_buf);
-    const exe_path = argv[0];
+    const exe_path = argv_slice[0];
     if (mem.indexOfScalar(u8, exe_path, '/') != null) {
         return execveErrnoToErr(errno(system.execve(argv_buf[0].?, argv_buf.ptr, envp_buf.ptr)));
     }
 @@ -593,7 +600,7 @@ pub fn execve(allocator: *Allocator, argv: []const []const u8, env_map: *const B
     return execveErrnoToErr(err);
 }
-pub fn createNullDelimitedEnvMap(allocator: *Allocator, env_map: *const BufMap) ![]?[*]u8 {
+pub fn createNullDelimitedEnvMap(allocator: *mem.Allocator, env_map: *const std.BufMap) ![]?[*]u8 {
     const envp_count = env_map.count();
     const envp_buf = try allocator.alloc(?[*]u8, envp_count + 1);
     mem.set(?[*]u8, envp_buf, null);
 @@ -616,9 +623,9 @@ pub fn createNullDelimitedEnvMap(allocator: *Allocator, env_map: *const BufMap)
     return envp_buf;
 }
-pub fn freeNullDelimitedEnvMap(allocator: *Allocator, envp_buf: []?[*]u8) void {
+pub fn freeNullDelimitedEnvMap(allocator: *mem.Allocator, envp_buf: []?[*]u8) void {
     for (envp_buf) |env| {
-        const env_buf = if (env) |ptr| ptr[0 .. cstr.len(ptr) + 1] else break;
+        const env_buf = if (env) |ptr| ptr[0 .. mem.len(u8, ptr) + 1] else break;
         allocator.free(env_buf);
     }
     allocator.free(envp_buf);
 @@ -633,6 +640,8 @@ pub const ExecveError = error{
     FileNotFound,
     NotDir,
     FileBusy,
+    ProcessFdQuotaExceeded,
+    NameTooLong,
     Unexpected,
 };
 @@ -703,17 +712,17 @@ pub fn getcwd(out_buffer: []u8) GetCwdError![]u8 {
     }
     const err = if (builtin.link_libc) blk: {
-        break :blk if (system.getcwd(out_buffer.ptr, out_buffer.len)) |_| 0 else system._errno().*;
+        break :blk if (std.c.getcwd(out_buffer.ptr, out_buffer.len)) |_| 0 else std.c._errno().*;
     } else blk: {
-        break :blk errno(system.getcwd(out_buffer, out_buffer.len));
+        break :blk errno(system.getcwd(out_buffer.ptr, out_buffer.len));
     };
     switch (err) {
-        0 => return mem.toSlice(u8, out_buffer),
+        0 => return mem.toSlice(u8, out_buffer.ptr),
         EFAULT => unreachable,
         EINVAL => unreachable,
         ENOENT => return error.CurrentWorkingDirectoryUnlinked,
         ERANGE => return error.NameTooLong,
-        else => |err| return unexpectedErrno(err),
+        else => return unexpectedErrno(err),
     }
 }
 @@ -1711,8 +1720,8 @@ pub const FStatError = error{
 pub fn fstat(fd: fd_t) FStatError!Stat {
     var stat: Stat = undefined;
-    if (os.darwin.is_the_target) {
+    if (darwin.is_the_target) {
-        switch (errno(system.@"fstat$INODE64"(fd, buf))) {
+        switch (errno(system.@"fstat$INODE64"(fd, &stat))) {
             0 => return stat,
             EBADF => unreachable, // Always a race condition.
             ENOMEM => return error.SystemResources,
 @@ -1877,7 +1886,7 @@ pub const ForkError = error{
 pub fn fork() ForkError!pid_t {
     const rc = system.fork();
     switch (errno(rc)) {
-        0 => return rc,
+        0 => return @intCast(pid_t, rc),
         EAGAIN => return error.SystemResources,
         ENOMEM => return error.SystemResources,
         else => |err| return unexpectedErrno(err),
 @@ -1891,6 +1900,7 @@ pub const MMapError = error{
     SystemFdQuotaExceeded,
     MemoryMappingNotSupported,
     OutOfMemory,
+    Unexpected,
 };
 /// Map files or devices into memory.
 @@ -1992,6 +2002,7 @@ pub fn accessC(path: [*]const u8, mode: u32) AccessError!void {
 pub const PipeError = error{
     SystemFdQuotaExceeded,
     ProcessFdQuotaExceeded,
+    Unexpected,
 };
 /// Creates a unidirectional data channel that can be used for interprocess communication.
 @@ -2065,18 +2076,6 @@ pub fn gettimeofday(tv: ?*timeval, tz: ?*timezone) void {
     }
 }
-pub fn nanosleep(req: timespec) void {
-    var rem = req;
-    while (true) {
-        switch (errno(system.nanosleep(&rem, &rem))) {
-            0 => return,
-            EINVAL => unreachable, // Invalid parameters.
-            EFAULT => unreachable,
-            EINTR => continue,
-        }
-    }
-}
 pub const SeekError = error{
     Unseekable,
     Unexpected,

std/os/bits/linux.zig+5-5

...	@@ -692,12 +692,12 @@ pub const winsize = extern struct {	...	@@ -692,12 +692,12 @@ pub const winsize = extern struct {
692	ws_ypixel: u16,	692	ws_ypixel: u16,
693	};	693	};
694		694
695	const NSIG = 65;	695	pub const NSIG = 65;
696	const sigset_t = [128 / @sizeOf(usize)]usize;	696	pub const sigset_t = [128 / @sizeOf(usize)]usize;
697	const all_mask = []u32{ 0xffffffff, 0xffffffff };	697	pub const all_mask = []u32{ 0xffffffff, 0xffffffff };
698	const app_mask = []u32{ 0xfffffffc, 0x7fffffff };	698	pub const app_mask = []u32{ 0xfffffffc, 0x7fffffff };
699		699
700	const k_sigaction = extern struct {	700	pub const k_sigaction = extern struct {
701	handler: extern fn (i32) void,	701	handler: extern fn (i32) void,
702	flags: usize,	702	flags: usize,
703	restorer: extern fn () void,	703	restorer: extern fn () void,

std/os/bits/wasi.zig+2-8

 @@ -13,10 +13,7 @@ pub const ADVICE_WILLNEED: advice_t = 3;
 pub const ADVICE_DONTNEED: advice_t = 4;
 pub const ADVICE_NOREUSE: advice_t = 5;
-pub const ciovec_t = extern struct {
+pub const ciovec_t = iovec_const;
-    buf: [*]const u8,
-    buf_len: usize,
-};
 pub const clockid_t = u32;
 pub const CLOCK_REALTIME: clockid_t = 0;
 @@ -186,10 +183,7 @@ pub const FILESTAT_SET_MTIM_NOW: fstflags_t = 0x0008;
 pub const inode_t = u64;
-pub const iovec_t = extern struct {
+pub const iovec_t = iovec;
-    buf: [*]u8,
-    buf_len: usize,
-};
 pub const linkcount_t = u32;

std/os/linux.zig+4-3

 @@ -20,6 +20,7 @@ pub use switch (builtin.arch) {
     else => struct {},
 };
 pub use @import("bits.zig");
+pub const tls = @import("linux/tls.zig");
 /// Set by startup code, used by `getauxval`.
 pub var elf_aux_maybe: ?[*]std.elf.Auxv = null;
 @@ -539,15 +540,15 @@ pub fn sigaction(sig: u6, noalias act: *const Sigaction, noalias oact: ?*Sigacti
     return 0;
 }
-fn blockAllSignals(set: *sigset_t) void {
+pub fn blockAllSignals(set: *sigset_t) void {
     _ = syscall4(SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&all_mask), @ptrToInt(set), NSIG / 8);
 }
-fn blockAppSignals(set: *sigset_t) void {
+pub fn blockAppSignals(set: *sigset_t) void {
     _ = syscall4(SYS_rt_sigprocmask, SIG_BLOCK, @ptrToInt(&app_mask), @ptrToInt(set), NSIG / 8);
 }
-fn restoreSignals(set: *sigset_t) void {
+pub fn restoreSignals(set: *sigset_t) void {
     _ = syscall4(SYS_rt_sigprocmask, SIG_SETMASK, @ptrToInt(set), 0, NSIG / 8);
 }

std/os/linux/vdso.zig+2-3

...	@@ -1,7 +1,6 @@	...	@@ -1,7 +1,6 @@
1	const std = @import("../../std.zig");	1	const std = @import("../../std.zig");
2	const elf = std.elf;	2	const elf = std.elf;
3	const linux = std.os.linux;	3	const linux = std.os.linux;
4	const cstr = std.cstr;
5	const mem = std.mem;	4	const mem = std.mem;
6	const maxInt = std.math.maxInt;	5	const maxInt = std.math.maxInt;
7		6
...	@@ -66,7 +65,7 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {	...	@@ -66,7 +65,7 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
66	if (0 == (u32(1) << @intCast(u5, syms[i].st_info & 0xf) & OK_TYPES)) continue;	65	if (0 == (u32(1) << @intCast(u5, syms[i].st_info & 0xf) & OK_TYPES)) continue;
67	if (0 == (u32(1) << @intCast(u5, syms[i].st_info >> 4) & OK_BINDS)) continue;	66	if (0 == (u32(1) << @intCast(u5, syms[i].st_info >> 4) & OK_BINDS)) continue;
68	if (0 == syms[i].st_shndx) continue;	67	if (0 == syms[i].st_shndx) continue;
69	if (!mem.eql(u8, name, cstr.toSliceConst(strings + syms[i].st_name))) continue;	68	if (!mem.eql(u8, name, mem.toSliceConst(u8, strings + syms[i].st_name))) continue;
70	if (maybe_versym) \|versym\| {	69	if (maybe_versym) \|versym\| {
71	if (!checkver(maybe_verdef.?, versym[i], vername, strings))	70	if (!checkver(maybe_verdef.?, versym[i], vername, strings))
72	continue;	71	continue;
...	@@ -88,5 +87,5 @@ fn checkver(def_arg: *elf.Verdef, vsym_arg: i32, vername: []const u8, strings: [	...	@@ -88,5 +87,5 @@ fn checkver(def_arg: *elf.Verdef, vsym_arg: i32, vername: []const u8, strings: [
88	def = @intToPtr(*elf.Verdef, @ptrToInt(def) + def.vd_next);	87	def = @intToPtr(*elf.Verdef, @ptrToInt(def) + def.vd_next);
89	}	88	}
90	const aux = @intToPtr(*elf.Verdaux, @ptrToInt(def) + def.vd_aux);	89	const aux = @intToPtr(*elf.Verdaux, @ptrToInt(def) + def.vd_aux);
91	return mem.eql(u8, vername, cstr.toSliceConst(strings + aux.vda_name));	90	return mem.eql(u8, vername, mem.toSliceConst(u8, strings + aux.vda_name));
92	}	91	}

std/os/test.zig+7-6

 @@ -3,6 +3,7 @@ const os = std.os;
 const testing = std.testing;
 const expect = std.testing.expect;
 const io = std.io;
+const fs = std.fs;
 const mem = std.mem;
 const File = std.fs.File;
 const Thread = std.Thread;
 @@ -14,9 +15,9 @@ const AtomicRmwOp = builtin.AtomicRmwOp;
 const AtomicOrder = builtin.AtomicOrder;
 test "makePath, put some files in it, deleteTree" {
-    try os.makePath(a, "os_test_tmp" ++ os.path.sep_str ++ "b" ++ os.path.sep_str ++ "c");
+    try os.makePath(a, "os_test_tmp" ++ fs.path.sep_str ++ "b" ++ fs.path.sep_str ++ "c");
-    try io.writeFile("os_test_tmp" ++ os.path.sep_str ++ "b" ++ os.path.sep_str ++ "c" ++ os.path.sep_str ++ "file.txt", "nonsense");
+    try io.writeFile("os_test_tmp" ++ fs.path.sep_str ++ "b" ++ fs.path.sep_str ++ "c" ++ fs.path.sep_str ++ "file.txt", "nonsense");
-    try io.writeFile("os_test_tmp" ++ os.path.sep_str ++ "b" ++ os.path.sep_str ++ "file2.txt", "blah");
+    try io.writeFile("os_test_tmp" ++ fs.path.sep_str ++ "b" ++ fs.path.sep_str ++ "file2.txt", "blah");
     try os.deleteTree(a, "os_test_tmp");
     if (os.Dir.open(a, "os_test_tmp")) |dir| {
         @panic("expected error");
 @@ -27,14 +28,14 @@ test "makePath, put some files in it, deleteTree" {
 test "access file" {
     try os.makePath(a, "os_test_tmp");
-    if (File.access("os_test_tmp" ++ os.path.sep_str ++ "file.txt")) |ok| {
+    if (File.access("os_test_tmp" ++ fs.path.sep_str ++ "file.txt")) |ok| {
         @panic("expected error");
     } else |err| {
         expect(err == error.FileNotFound);
     }
-    try io.writeFile("os_test_tmp" ++ os.path.sep_str ++ "file.txt", "");
+    try io.writeFile("os_test_tmp" ++ fs.path.sep_str ++ "file.txt", "");
-    try File.access("os_test_tmp" ++ os.path.sep_str ++ "file.txt");
+    try File.access("os_test_tmp" ++ fs.path.sep_str ++ "file.txt");
     try os.deleteTree(a, "os_test_tmp");
 }

std/os/windows.zig+38-1

...	@@ -4,6 +4,7 @@	...	@@ -4,6 +4,7 @@
4	// * When null-terminated or UTF16LE byte buffers are required, provide APIs which accept	4	// * When null-terminated or UTF16LE byte buffers are required, provide APIs which accept
5	// slices as well as APIs which accept null-terminated UTF16LE byte buffers.	5	// slices as well as APIs which accept null-terminated UTF16LE byte buffers.
6		6
		7	const builtin = @import("builtin");
7	const std = @import("../std.zig");	8	const std = @import("../std.zig");
8	const assert = std.debug.assert;	9	const assert = std.debug.assert;
9	const maxInt = std.math.maxInt;	10	const maxInt = std.math.maxInt;
...	@@ -1103,6 +1104,42 @@ pub fn VirtualFree(lpAddress: ?LPVOID, dwSize: usize, dwFreeType: DWORD) void {	...	@@ -1103,6 +1104,42 @@ pub fn VirtualFree(lpAddress: ?LPVOID, dwSize: usize, dwFreeType: DWORD) void {
1103	assert(kernel32.VirtualFree(lpAddress, dwSize, dwFreeType) != 0);	1104	assert(kernel32.VirtualFree(lpAddress, dwSize, dwFreeType) != 0);
1104	}	1105	}
1105		1106
		1107	pub const SetConsoleTextAttributeError = error{Unexpected};
		1108
		1109	pub fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) SetConsoleTextAttributeError!void {
		1110	if (kernel32.SetConsoleTextAttribute(hConsoleOutput, wAttributes) == 0) {
		1111	switch (kernel32.GetLastError()) {
		1112	else => \|err\| return unexpectedError(err),
		1113	}
		1114	}
		1115	}
		1116
		1117	pub const GetEnvironmentStringsError = error{OutOfMemory};
		1118
		1119	pub fn GetEnvironmentStringsW() GetEnvironmentStringsError![*]u16 {
		1120	return kernel32.GetEnvironmentStringsW() orelse return error.OutOfMemory;
		1121	}
		1122
		1123	pub fn FreeEnvironmentStringsW(penv: [*]u16) void {
		1124	assert(kernel32.FreeEnvironmentStringsW(penv) != 0);
		1125	}
		1126
		1127	pub const GetEnvironmentVariableError = error{
		1128	EnvironmentVariableNotFound,
		1129	Unexpected,
		1130	};
		1131
		1132	pub fn GetEnvironmentVariableW(lpName: LPWSTR, lpBuffer: LPWSTR, nSize: DWORD) GetEnvironmentVariableError!DWORD {
		1133	const rc = kernel32.GetEnvironmentVariableW(lpName, lpBuffer, nSize);
		1134	if (rc == 0) {
		1135	switch (kernel32.GetLastError()) {
		1136	ERROR.ENVVAR_NOT_FOUND => return error.EnvironmentVariableNotFound,
		1137	else => \|err\| return unexpectedError(err),
		1138	}
		1139	}
		1140	return rc;
		1141	}
		1142
1106	pub fn cStrToPrefixedFileW(s: [*]const u8) ![PATH_MAX_WIDE + 1]u16 {	1143	pub fn cStrToPrefixedFileW(s: [*]const u8) ![PATH_MAX_WIDE + 1]u16 {
1107	return sliceToPrefixedFileW(mem.toSliceConst(u8, s));	1144	return sliceToPrefixedFileW(mem.toSliceConst(u8, s));
1108	}	1145	}
...	@@ -1127,7 +1164,7 @@ pub fn sliceToPrefixedSuffixedFileW(s: []const u8, comptime suffix: []const u16)	...	@@ -1127,7 +1164,7 @@ pub fn sliceToPrefixedSuffixedFileW(s: []const u8, comptime suffix: []const u16)
1127	else => {},	1164	else => {},
1128	}	1165	}
1129	}	1166	}
1130	const start_index = if (mem.startsWith(u8, s, "\\\\") or !os.path.isAbsolute(s)) 0 else blk: {	1167	const start_index = if (mem.startsWith(u8, s, "\\\\") or !std.fs.path.isAbsolute(s)) 0 else blk: {
1131	const prefix = []u16{ '\\', '\\', '?', '\\' };	1168	const prefix = []u16{ '\\', '\\', '?', '\\' };
1132	mem.copy(u16, result[0..], prefix);	1169	mem.copy(u16, result[0..], prefix);
1133	break :blk prefix.len;	1170	break :blk prefix.len;

std/process.zig+41-27

...	@@ -1,13 +1,17 @@	...	@@ -1,13 +1,17 @@
		1	const builtin = @import("builtin");
1	const std = @import("std.zig");	2	const std = @import("std.zig");
2	const os = std.os;	3	const os = std.os;
3	const BufMap = std.BufMap;	4	const BufMap = std.BufMap;
4	const mem = std.mem;	5	const mem = std.mem;
		6	const math = std.math;
5	const Allocator = mem.Allocator;	7	const Allocator = mem.Allocator;
6	const assert = std.debug.assert;	8	const assert = std.debug.assert;
7	const testing = std.testing;	9	const testing = std.testing;
8		10
9	pub const abort = os.abort;	11	pub const abort = os.abort;
10	pub const exit = os.exit;	12	pub const exit = os.exit;
		13	pub const changeCurDir = os.chdir;
		14	pub const changeCurDirC = os.chdirC;
11		15
12	/// Caller must free result when done.	16	/// Caller must free result when done.
13	/// TODO make this go through libc when we have it	17	/// TODO make this go through libc when we have it
...	@@ -15,9 +19,9 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {	...	@@ -15,9 +19,9 @@ pub fn getEnvMap(allocator: *Allocator) !BufMap {
15	var result = BufMap.init(allocator);	19	var result = BufMap.init(allocator);
16	errdefer result.deinit();	20	errdefer result.deinit();
17		21
18	if (is_windows) {	22	if (os.windows.is_the_target) {
19	const ptr = windows.GetEnvironmentStringsW() orelse return error.OutOfMemory;	23	const ptr = try os.windows.GetEnvironmentStringsW();
20	defer assert(windows.FreeEnvironmentStringsW(ptr) != 0);	24	defer os.windows.FreeEnvironmentStringsW(ptr);
21		25
22	var i: usize = 0;	26	var i: usize = 0;
23	while (true) {	27	while (true) {
...	@@ -105,7 +109,7 @@ pub const GetEnvVarOwnedError = error{	...	@@ -105,7 +109,7 @@ pub const GetEnvVarOwnedError = error{
105	/// Caller must free returned memory.	109	/// Caller must free returned memory.
106	/// TODO make this go through libc when we have it	110	/// TODO make this go through libc when we have it
107	pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwnedError![]u8 {	111	pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwnedError![]u8 {
108	if (is_windows) {	112	if (os.windows.is_the_target) {
109	const key_with_null = try std.unicode.utf8ToUtf16LeWithNull(allocator, key);	113	const key_with_null = try std.unicode.utf8ToUtf16LeWithNull(allocator, key);
110	defer allocator.free(key_with_null);	114	defer allocator.free(key_with_null);
111		115
...	@@ -113,19 +117,15 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned	...	@@ -113,19 +117,15 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned
113	defer allocator.free(buf);	117	defer allocator.free(buf);
114		118
115	while (true) {	119	while (true) {
116	const windows_buf_len = math.cast(windows.DWORD, buf.len) catch return error.OutOfMemory;	120	const windows_buf_len = math.cast(os.windows.DWORD, buf.len) catch return error.OutOfMemory;
117	const result = windows.GetEnvironmentVariableW(key_with_null.ptr, buf.ptr, windows_buf_len);	121	const result = os.windows.GetEnvironmentVariableW(
118		122	key_with_null.ptr,
119	if (result == 0) {	123	buf.ptr,
120	const err = windows.GetLastError();	124	windows_buf_len,
121	return switch (err) {	125	) catch \|err\| switch (err) {
122	windows.ERROR.ENVVAR_NOT_FOUND => error.EnvironmentVariableNotFound,	126	error.Unexpected => return error.EnvironmentVariableNotFound,
123	else => {	127	else => return err,
124	windows.unexpectedError(err) catch {};	128	};
125	return error.EnvironmentVariableNotFound;
126	},
127	};
128	}
129		129
130	if (result > buf.len) {	130	if (result > buf.len) {
131	buf = try allocator.realloc(buf, result);	131	buf = try allocator.realloc(buf, result);
...	@@ -136,11 +136,11 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned	...	@@ -136,11 +136,11 @@ pub fn getEnvVarOwned(allocator: *mem.Allocator, key: []const u8) GetEnvVarOwned
136	error.DanglingSurrogateHalf => return error.InvalidUtf8,	136	error.DanglingSurrogateHalf => return error.InvalidUtf8,
137	error.ExpectedSecondSurrogateHalf => return error.InvalidUtf8,	137	error.ExpectedSecondSurrogateHalf => return error.InvalidUtf8,
138	error.UnexpectedSecondSurrogateHalf => return error.InvalidUtf8,	138	error.UnexpectedSecondSurrogateHalf => return error.InvalidUtf8,
139	error.OutOfMemory => return error.OutOfMemory,	139	else => return err,
140	};	140	};
141	}	141	}
142	} else {	142	} else {
143	const result = getEnvPosix(key) orelse return error.EnvironmentVariableNotFound;	143	const result = os.getenv(key) orelse return error.EnvironmentVariableNotFound;
144	return mem.dupe(allocator, u8, result);	144	return mem.dupe(allocator, u8, result);
145	}	145	}
146	}	146	}
...	@@ -157,16 +157,16 @@ pub const ArgIteratorPosix = struct {	...	@@ -157,16 +157,16 @@ pub const ArgIteratorPosix = struct {
157	pub fn init() ArgIteratorPosix {	157	pub fn init() ArgIteratorPosix {
158	return ArgIteratorPosix{	158	return ArgIteratorPosix{
159	.index = 0,	159	.index = 0,
160	.count = raw.len,	160	.count = os.argv.len,
161	};	161	};
162	}	162	}
163		163
164	pub fn next(self: *ArgIteratorPosix) ?[]const u8 {	164	pub fn next(self: *ArgIteratorPosix) ?[]const u8 {
165	if (self.index == self.count) return null;	165	if (self.index == self.count) return null;
166		166
167	const s = raw[self.index];	167	const s = os.argv[self.index];
168	self.index += 1;	168	self.index += 1;
169	return cstr.toSlice(s);	169	return mem.toSlice(u8, s);
170	}	170	}
171		171
172	pub fn skip(self: *ArgIteratorPosix) bool {	172	pub fn skip(self: *ArgIteratorPosix) bool {
...	@@ -175,10 +175,6 @@ pub const ArgIteratorPosix = struct {	...	@@ -175,10 +175,6 @@ pub const ArgIteratorPosix = struct {
175	self.index += 1;	175	self.index += 1;
176	return true;	176	return true;
177	}	177	}
178
179	/// This is marked as public but actually it's only meant to be used
180	/// internally by zig's startup code.
181	pub var raw: [][*]u8 = undefined;
182	};	178	};
183		179
184	pub const ArgIteratorWindows = struct {	180	pub const ArgIteratorWindows = struct {
...	@@ -191,7 +187,7 @@ pub const ArgIteratorWindows = struct {	...	@@ -191,7 +187,7 @@ pub const ArgIteratorWindows = struct {
191	pub const NextError = error{OutOfMemory};	187	pub const NextError = error{OutOfMemory};
192		188
193	pub fn init() ArgIteratorWindows {	189	pub fn init() ArgIteratorWindows {
194	return initWithCmdLine(windows.GetCommandLineA());	190	return initWithCmdLine(os.windows.kernel32.GetCommandLineA());
195	}	191	}
196		192
197	pub fn initWithCmdLine(cmd_line: [*]const u8) ArgIteratorWindows {	193	pub fn initWithCmdLine(cmd_line: [*]const u8) ArgIteratorWindows {
...	@@ -581,3 +577,21 @@ pub fn posixGetUserInfo(name: []const u8) !UserInfo {	...	@@ -581,3 +577,21 @@ pub fn posixGetUserInfo(name: []const u8) !UserInfo {
581	if (amt_read < buf.len) return error.UserNotFound;	577	if (amt_read < buf.len) return error.UserNotFound;
582	}	578	}
583	}	579	}
		580
		581	pub fn getBaseAddress() usize {
		582	switch (builtin.os) {
		583	.linux => {
		584	const base = os.system.getauxval(std.elf.AT_BASE);
		585	if (base != 0) {
		586	return base;
		587	}
		588	const phdr = os.system.getauxval(std.elf.AT_PHDR);
		589	return phdr - @sizeOf(std.elf.Ehdr);
		590	},
		591	.macosx, .freebsd, .netbsd => {
		592	return @ptrToInt(&std.c._mh_execute_header);
		593	},
		594	.windows => return @ptrToInt(os.windows.kernel32.GetModuleHandleW(null)),
		595	else => @compileError("Unsupported OS"),
		596	}
		597	}

std/special/bootstrap.zig+2-2

...	@@ -78,7 +78,7 @@ fn posixCallMainAndExit() noreturn {	...	@@ -78,7 +78,7 @@ fn posixCallMainAndExit() noreturn {
78	while (envp_optional[envp_count]) \|_\| : (envp_count += 1) {}	78	while (envp_optional[envp_count]) \|_\| : (envp_count += 1) {}
79	const envp = @ptrCast([][]u8, envp_optional)[0..envp_count];	79	const envp = @ptrCast([][]u8, envp_optional)[0..envp_count];
80		80
81	if (builtin.os == builtin.Os.linux) {	81	if (builtin.os == .linux) {
82	// Find the beginning of the auxiliary vector	82	// Find the beginning of the auxiliary vector
83	const auxv = @ptrCast([*]std.elf.Auxv, envp.ptr + envp_count + 1);	83	const auxv = @ptrCast([*]std.elf.Auxv, envp.ptr + envp_count + 1);
84	std.os.linux.elf_aux_maybe = auxv;	84	std.os.linux.elf_aux_maybe = auxv;
...	@@ -98,7 +98,7 @@ fn posixCallMainAndExit() noreturn {	...	@@ -98,7 +98,7 @@ fn posixCallMainAndExit() noreturn {
98	// This is marked inline because for some reason LLVM in release mode fails to inline it,	98	// This is marked inline because for some reason LLVM in release mode fails to inline it,
99	// and we want fewer call frames in stack traces.	99	// and we want fewer call frames in stack traces.
100	inline fn callMainWithArgs(argc: usize, argv: [][]u8, envp: [][*]u8) u8 {	100	inline fn callMainWithArgs(argc: usize, argv: [][]u8, envp: [][*]u8) u8 {
101	std.os.ArgIteratorPosix.raw = argv[0..argc];	101	std.os.argv = argv[0..argc];
102	std.os.environ = envp;	102	std.os.environ = envp;
103	return callMain();	103	return callMain();
104	}	104	}

std/special/build_runner.zig+4-4

 @@ -3,15 +3,15 @@ const std = @import("std");
 const builtin = @import("builtin");
 const io = std.io;
 const fmt = std.fmt;
-const os = std.os;
 const Builder = std.build.Builder;
 const mem = std.mem;
+const process = std.process;
 const ArrayList = std.ArrayList;
 const warn = std.debug.warn;
 const File = std.fs.File;
 pub fn main() !void {
-    var arg_it = os.args();
+    var arg_it = process.args();
     // Here we use an ArenaAllocator backed by a DirectAllocator because a build is a short-lived,
     // one shot program. We don't need to waste time freeing memory and finding places to squish
 @@ -139,7 +139,7 @@ pub fn main() !void {
             error.InvalidStepName => {
                 return usageAndErr(&builder, true, try stderr_stream);
             },
-            error.UncleanExit => os.exit(1),
+            error.UncleanExit => process.exit(1),
             else => return err,
         }
     };
 @@ -215,7 +215,7 @@ fn usage(builder: *Builder, already_ran_build: bool, out_stream: var) !void {
 fn usageAndErr(builder: *Builder, already_ran_build: bool, out_stream: var) void {
     usage(builder, already_ran_build, out_stream) catch {};
-    os.exit(1);
+    process.exit(1);
 }
 const UnwrapArgError = error{OutOfMemory};

std/thread.zig+1-1

...	@@ -227,7 +227,7 @@ pub const Thread = struct {	...	@@ -227,7 +227,7 @@ pub const Thread = struct {
227	var tls_start_offset: usize = undefined;	227	var tls_start_offset: usize = undefined;
228	const mmap_len = blk: {	228	const mmap_len = blk: {
229	// First in memory will be the stack, which grows downwards.	229	// First in memory will be the stack, which grows downwards.
230	var l: usize = mem.alignForward(default_stack_size, os.page_size);	230	var l: usize = mem.alignForward(default_stack_size, mem.page_size);
231	stack_end_offset = l;	231	stack_end_offset = l;
232	// Above the stack, so that it can be in the same mmap call, put the Thread object.	232	// Above the stack, so that it can be in the same mmap call, put the Thread object.
233	l = mem.alignForward(l, @alignOf(Thread));	233	l = mem.alignForward(l, @alignOf(Thread));

test/cli.zig+21-19

 @@ -1,7 +1,9 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const os = std.os;
 const testing = std.testing;
+const process = std.process;
+const fs = std.fs;
+const ChildProcess = std.ChildProcess;
 var a: *std.mem.Allocator = undefined;
 @@ -12,7 +14,7 @@ pub fn main() !void {
     var arena = std.heap.ArenaAllocator.init(&direct_allocator.allocator);
     defer arena.deinit();
-    var arg_it = os.args();
+    var arg_it = process.args();
     // skip my own exe name
     _ = arg_it.skip();
 @@ -27,9 +29,9 @@ pub fn main() !void {
         std.debug.warn("Expected second argument to be cache root directory path\n");
         return error.InvalidArgs;
     });
-    const zig_exe = try os.path.resolve(a, [][]const u8{zig_exe_rel});
+    const zig_exe = try fs.path.resolve(a, [][]const u8{zig_exe_rel});
-    const dir_path = try os.path.join(a, [][]const u8{ cache_root, "clitest" });
+    const dir_path = try fs.path.join(a, [][]const u8{ cache_root, "clitest" });
     const TestFn = fn ([]const u8, []const u8) anyerror!void;
     const test_fns = []TestFn{
         testZigInitLib,
 @@ -37,8 +39,8 @@ pub fn main() !void {
         testGodboltApi,
     };
     for (test_fns) |testFn| {
-        try os.deleteTree(a, dir_path);
+        try fs.deleteTree(a, dir_path);
-        try os.makeDir(dir_path);
+        try fs.makeDir(dir_path);
         try testFn(zig_exe, dir_path);
     }
 }
 @@ -58,15 +60,15 @@ fn printCmd(cwd: []const u8, argv: []const []const u8) void {
     std.debug.warn("\n");
 }
-fn exec(cwd: []const u8, argv: []const []const u8) !os.ChildProcess.ExecResult {
+fn exec(cwd: []const u8, argv: []const []const u8) !ChildProcess.ExecResult {
     const max_output_size = 100 * 1024;
-    const result = os.ChildProcess.exec(a, argv, cwd, null, max_output_size) catch |err| {
+    const result = ChildProcess.exec(a, argv, cwd, null, max_output_size) catch |err| {
         std.debug.warn("The following command failed:\n");
         printCmd(cwd, argv);
         return err;
     };
     switch (result.term) {
-        os.ChildProcess.Term.Exited => |code| {
+        .Exited => |code| {
             if (code != 0) {
                 std.debug.warn("The following command exited with error code {}:\n", code);
                 printCmd(cwd, argv);
 @@ -97,10 +99,10 @@ fn testZigInitExe(zig_exe: []const u8, dir_path: []const u8) !void {
 }
 fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {
-    if (builtin.os != builtin.Os.linux or builtin.arch != builtin.Arch.x86_64) return;
+    if (builtin.os != .linux or builtin.arch != .x86_64) return;
-    const example_zig_path = try os.path.join(a, [][]const u8{ dir_path, "example.zig" });
+    const example_zig_path = try fs.path.join(a, [][]const u8{ dir_path, "example.zig" });
-    const example_s_path = try os.path.join(a, [][]const u8{ dir_path, "example.s" });
+    const example_s_path = try fs.path.join(a, [][]const u8{ dir_path, "example.s" });
     try std.io.writeFile(example_zig_path,
         \\// Type your code here, or load an example.
 @@ -114,13 +116,13 @@ fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {
     );
     const args = [][]const u8{
-        zig_exe, "build-obj",
+        zig_exe,          "build-obj",
-        "--cache-dir", dir_path,
+        "--cache-dir",    dir_path,
-        "--name", "example",
+        "--name",         "example",
-        "--output-dir", dir_path,
+        "--output-dir",   dir_path,
-        "--emit", "asm",
+        "--emit",         "asm",
-        "-mllvm", "--x86-asm-syntax=intel",
+        "-mllvm",         "--x86-asm-syntax=intel",
-        "--strip", "--release-fast",
+        "--strip",        "--release-fast",
         example_zig_path, "--disable-gen-h",
     };
     _ = try exec(dir_path, args);

test/tests.zig+44-46

 @@ -2,11 +2,9 @@ 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;
-const Term = os.ChildProcess.Term;
 const Buffer = std.Buffer;
 const io = std.io;
+const fs = std.fs;
 const mem = std.mem;
 const fmt = std.fmt;
 const ArrayList = std.ArrayList;
 @@ -30,19 +28,19 @@ const TestTarget = struct {
 const test_targets = []TestTarget{
     TestTarget{
-        .os = builtin.Os.linux,
+        .os = .linux,
-        .arch = builtin.Arch.x86_64,
+        .arch = .x86_64,
-        .abi = builtin.Abi.gnu,
+        .abi = .gnu,
     },
     TestTarget{
-        .os = builtin.Os.macosx,
+        .os = .macosx,
-        .arch = builtin.Arch.x86_64,
+        .arch = .x86_64,
-        .abi = builtin.Abi.gnu,
+        .abi = .gnu,
     },
     TestTarget{
-        .os = builtin.Os.windows,
+        .os = .windows,
-        .arch = builtin.Arch.x86_64,
+        .arch = .x86_64,
-        .abi = builtin.Abi.msvc,
+        .abi = .msvc,
     },
 };
 @@ -114,7 +112,7 @@ pub fn addCliTests(b: *build.Builder, test_filter: ?[]const u8, modes: []const M
     const exe = b.addExecutable("test-cli", "test/cli.zig");
     const run_cmd = exe.run();
     run_cmd.addArgs([][]const u8{
-        os.path.realAlloc(b.allocator, b.zig_exe) catch unreachable,
+        fs.path.realAlloc(b.allocator, b.zig_exe) catch unreachable,
         b.pathFromRoot(b.cache_root),
     });
 @@ -301,12 +299,12 @@ pub const CompareOutputContext = struct {
             warn("Test {}/{} {}...", self.test_index + 1, self.context.test_index, self.name);
-            const child = os.ChildProcess.init(args.toSliceConst(), b.allocator) catch unreachable;
+            const child = std.ChildProcess.init(args.toSliceConst(), b.allocator) catch unreachable;
             defer child.deinit();
-            child.stdin_behavior = StdIo.Ignore;
+            child.stdin_behavior = .Ignore;
-            child.stdout_behavior = StdIo.Pipe;
+            child.stdout_behavior = .Pipe;
-            child.stderr_behavior = StdIo.Pipe;
+            child.stderr_behavior = .Pipe;
             child.env_map = b.env_map;
             child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
 @@ -324,7 +322,7 @@ pub const CompareOutputContext = struct {
                 debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
             };
             switch (term) {
-                Term.Exited => |code| {
+                .Exited => |code| {
                     if (code != 0) {
                         warn("Process {} exited with error code {}\n", full_exe_path, code);
                         printInvocation(args.toSliceConst());
 @@ -383,13 +381,13 @@ pub const CompareOutputContext = struct {
             warn("Test {}/{} {}...", self.test_index + 1, self.context.test_index, self.name);
-            const child = os.ChildProcess.init([][]const u8{full_exe_path}, b.allocator) catch unreachable;
+            const child = std.ChildProcess.init([][]const u8{full_exe_path}, b.allocator) catch unreachable;
             defer child.deinit();
             child.env_map = b.env_map;
-            child.stdin_behavior = StdIo.Ignore;
+            child.stdin_behavior = .Ignore;
-            child.stdout_behavior = StdIo.Ignore;
+            child.stdout_behavior = .Ignore;
-            child.stderr_behavior = StdIo.Ignore;
+            child.stderr_behavior = .Ignore;
             const term = child.spawnAndWait() catch |err| {
                 debug.panic("Unable to spawn {}: {}\n", full_exe_path, @errorName(err));
 @@ -397,13 +395,13 @@ pub const CompareOutputContext = struct {
             const expected_exit_code: i32 = 126;
             switch (term) {
-                Term.Exited => |code| {
+                .Exited => |code| {
                     if (code != expected_exit_code) {
                         warn("\nProgram expected to exit with code {} " ++ "but exited with code {}\n", expected_exit_code, code);
                         return error.TestFailed;
                     }
                 },
-                Term.Signal => |sig| {
+                .Signal => |sig| {
                     warn("\nProgram expected to exit with code {} " ++ "but instead signaled {}\n", expected_exit_code, sig);
                     return error.TestFailed;
                 },
 @@ -459,7 +457,7 @@ pub const CompareOutputContext = struct {
     pub fn addCase(self: *CompareOutputContext, case: TestCase) void {
         const b = self.b;
-        const root_src = os.path.join(
+        const root_src = fs.path.join(
             b.allocator,
             [][]const u8{ b.cache_root, case.sources.items[0].filename },
         ) catch unreachable;
 @@ -475,7 +473,7 @@ pub const CompareOutputContext = struct {
                 exe.addAssemblyFile(root_src);
                 for (case.sources.toSliceConst()) |src_file| {
-                    const expanded_src_path = os.path.join(
+                    const expanded_src_path = fs.path.join(
                         b.allocator,
                         [][]const u8{ b.cache_root, src_file.filename },
                     ) catch unreachable;
 @@ -507,7 +505,7 @@ pub const CompareOutputContext = struct {
                     }
                     for (case.sources.toSliceConst()) |src_file| {
-                        const expanded_src_path = os.path.join(
+                        const expanded_src_path = fs.path.join(
                             b.allocator,
                             [][]const u8{ b.cache_root, src_file.filename },
                         ) catch unreachable;
 @@ -538,7 +536,7 @@ pub const CompareOutputContext = struct {
                 }
                 for (case.sources.toSliceConst()) |src_file| {
-                    const expanded_src_path = os.path.join(
+                    const expanded_src_path = fs.path.join(
                         b.allocator,
                         [][]const u8{ b.cache_root, src_file.filename },
                     ) catch unreachable;
 @@ -633,7 +631,7 @@ pub const CompileErrorContext = struct {
             const self = @fieldParentPtr(CompileCmpOutputStep, "step", step);
             const b = self.context.b;
-            const root_src = os.path.join(
+            const root_src = fs.path.join(
                 b.allocator,
                 [][]const u8{ b.cache_root, self.case.sources.items[0].filename },
             ) catch unreachable;
 @@ -669,13 +667,13 @@ pub const CompileErrorContext = struct {
                 printInvocation(zig_args.toSliceConst());
             }
-            const child = os.ChildProcess.init(zig_args.toSliceConst(), b.allocator) catch unreachable;
+            const child = std.ChildProcess.init(zig_args.toSliceConst(), b.allocator) catch unreachable;
             defer child.deinit();
             child.env_map = b.env_map;
-            child.stdin_behavior = StdIo.Ignore;
+            child.stdin_behavior = .Ignore;
-            child.stdout_behavior = StdIo.Pipe;
+            child.stdout_behavior = .Pipe;
-            child.stderr_behavior = StdIo.Pipe;
+            child.stderr_behavior = .Pipe;
             child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", zig_args.items[0], @errorName(err));
 @@ -692,7 +690,7 @@ pub const CompileErrorContext = struct {
                 debug.panic("Unable to spawn {}: {}\n", zig_args.items[0], @errorName(err));
             };
             switch (term) {
-                Term.Exited => |code| {
+                .Exited => |code| {
                     if (code == 0) {
                         printInvocation(zig_args.toSliceConst());
                         return error.CompilationIncorrectlySucceeded;
 @@ -823,7 +821,7 @@ pub const CompileErrorContext = struct {
             self.step.dependOn(&compile_and_cmp_errors.step);
             for (case.sources.toSliceConst()) |src_file| {
-                const expanded_src_path = os.path.join(
+                const expanded_src_path = fs.path.join(
                     b.allocator,
                     [][]const u8{ b.cache_root, src_file.filename },
                 ) catch unreachable;
 @@ -858,7 +856,7 @@ pub const BuildExamplesContext = struct {
         }
         var zig_args = ArrayList([]const u8).init(b.allocator);
-        const rel_zig_exe = os.path.relative(b.allocator, b.build_root, b.zig_exe) catch unreachable;
+        const rel_zig_exe = fs.path.relative(b.allocator, b.build_root, b.zig_exe) catch unreachable;
         zig_args.append(rel_zig_exe) catch unreachable;
         zig_args.append("build") catch unreachable;
 @@ -958,7 +956,7 @@ pub const TranslateCContext = struct {
             const self = @fieldParentPtr(TranslateCCmpOutputStep, "step", step);
             const b = self.context.b;
-            const root_src = os.path.join(
+            const root_src = fs.path.join(
                 b.allocator,
                 [][]const u8{ b.cache_root, self.case.sources.items[0].filename },
             ) catch unreachable;
 @@ -976,13 +974,13 @@ pub const TranslateCContext = struct {
                 printInvocation(zig_args.toSliceConst());
             }
-            const child = os.ChildProcess.init(zig_args.toSliceConst(), b.allocator) catch unreachable;
+            const child = std.ChildProcess.init(zig_args.toSliceConst(), b.allocator) catch unreachable;
             defer child.deinit();
             child.env_map = b.env_map;
-            child.stdin_behavior = StdIo.Ignore;
+            child.stdin_behavior = .Ignore;
-            child.stdout_behavior = StdIo.Pipe;
+            child.stdout_behavior = .Pipe;
-            child.stderr_behavior = StdIo.Pipe;
+            child.stderr_behavior = .Pipe;
             child.spawn() catch |err| debug.panic("Unable to spawn {}: {}\n", zig_args.toSliceConst()[0], @errorName(err));
 @@ -999,14 +997,14 @@ pub const TranslateCContext = struct {
                 debug.panic("Unable to spawn {}: {}\n", zig_args.toSliceConst()[0], @errorName(err));
             };
             switch (term) {
-                Term.Exited => |code| {
+                .Exited => |code| {
                     if (code != 0) {
                         warn("Compilation failed with exit code {}\n", code);
                         printInvocation(zig_args.toSliceConst());
                         return error.TestFailed;
                     }
                 },
-                Term.Signal => |code| {
+                .Signal => |code| {
                     warn("Compilation failed with signal {}\n", code);
                     printInvocation(zig_args.toSliceConst());
                     return error.TestFailed;
 @@ -1131,7 +1129,7 @@ pub const TranslateCContext = struct {
         self.step.dependOn(&translate_c_and_cmp.step);
         for (case.sources.toSliceConst()) |src_file| {
-            const expanded_src_path = os.path.join(
+            const expanded_src_path = fs.path.join(
                 b.allocator,
                 [][]const u8{ b.cache_root, src_file.filename },
             ) catch unreachable;
 @@ -1254,7 +1252,7 @@ pub const GenHContext = struct {
     pub fn addCase(self: *GenHContext, case: *const TestCase) void {
         const b = self.b;
-        const root_src = os.path.join(
+        const root_src = fs.path.join(
             b.allocator,
             [][]const u8{ b.cache_root, case.sources.items[0].filename },
         ) catch unreachable;
 @@ -1269,7 +1267,7 @@ pub const GenHContext = struct {
         obj.setBuildMode(mode);
         for (case.sources.toSliceConst()) |src_file| {
-            const expanded_src_path = os.path.join(
+            const expanded_src_path = fs.path.join(
                 b.allocator,
                 [][]const u8{ b.cache_root, src_file.filename },
             ) catch unreachable;

author	Andrew Kelley <andrew@ziglang.org> 2019-05-26 13:17:34-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-05-26 18:32:44-04:00
log	2f040a23c8b968db56ab4c4725d6651f5ea3418e
tree	58727a1c2ffdf356db2f5c01e84940e4ced0541f
parent	7cb6279ac0cec065234347bda5944be64fe8b3da
signature	Commit is signed but in an unrecognized format.

...	@@ -1,5 +1,4 @@	...	@@ -1,5 +1,4 @@
1	const std = @import("std");	1	const std = @import("std");
2	const os = std.os;
3	const io = std.io;	2	const io = std.io;
4	const mem = std.mem;	3	const mem = std.mem;
5	const Allocator = mem.Allocator;	4	const Allocator = mem.Allocator;
...	@@ -54,7 +53,7 @@ pub const ZigCompiler = struct {	...	@@ -54,7 +53,7 @@ pub const ZigCompiler = struct {
54	};	53	};
55		54
56	var seed_bytes: [@sizeOf(u64)]u8 = undefined;	55	var seed_bytes: [@sizeOf(u64)]u8 = undefined;
57	try std.os.getRandomBytes(seed_bytes[0..]);	56	try std.crypto.randomBytes(seed_bytes[0..]);
58	const seed = mem.readIntNative(u64, &seed_bytes);	57	const seed = mem.readIntNative(u64, &seed_bytes);
59		58
60	return ZigCompiler{	59	return ZigCompiler{
...	@@ -487,7 +486,7 @@ pub const Compilation = struct {	...	@@ -487,7 +486,7 @@ pub const Compilation = struct {
487	comp.name = try Buffer.init(comp.arena(), name);	486	comp.name = try Buffer.init(comp.arena(), name);
488	comp.llvm_triple = try target.getTriple(comp.arena());	487	comp.llvm_triple = try target.getTriple(comp.arena());
489	comp.llvm_target = try Target.llvmTargetFromTriple(comp.llvm_triple);	488	comp.llvm_target = try Target.llvmTargetFromTriple(comp.llvm_triple);
490	comp.zig_std_dir = try std.os.path.join(comp.arena(), [][]const u8{ zig_lib_dir, "std" });	489	comp.zig_std_dir = try std.fs.path.join(comp.arena(), [][]const u8{ zig_lib_dir, "std" });
491		490
492	const opt_level = switch (build_mode) {	491	const opt_level = switch (build_mode) {
493	builtin.Mode.Debug => llvm.CodeGenLevelNone,	492	builtin.Mode.Debug => llvm.CodeGenLevelNone,
...	@@ -529,8 +528,8 @@ pub const Compilation = struct {	...	@@ -529,8 +528,8 @@ pub const Compilation = struct {
529	defer comp.events.destroy();	528	defer comp.events.destroy();
530		529
531	if (root_src_path) \|root_src\| {	530	if (root_src_path) \|root_src\| {
532	const dirname = std.os.path.dirname(root_src) orelse ".";	531	const dirname = std.fs.path.dirname(root_src) orelse ".";
533	const basename = std.os.path.basename(root_src);	532	const basename = std.fs.path.basename(root_src);
534		533
535	comp.root_package = try Package.create(comp.arena(), dirname, basename);	534	comp.root_package = try Package.create(comp.arena(), dirname, basename);
536	comp.std_package = try Package.create(comp.arena(), comp.zig_std_dir, "std.zig");	535	comp.std_package = try Package.create(comp.arena(), comp.zig_std_dir, "std.zig");
...	@@ -558,7 +557,7 @@ pub const Compilation = struct {	...	@@ -558,7 +557,7 @@ pub const Compilation = struct {
558		557
559	if (comp.tmp_dir.getOrNull()) \|tmp_dir_result\| if (tmp_dir_result.*) \|tmp_dir\| {	558	if (comp.tmp_dir.getOrNull()) \|tmp_dir_result\| if (tmp_dir_result.*) \|tmp_dir\| {
560	// TODO evented I/O?	559	// TODO evented I/O?
561	os.deleteTree(comp.arena(), tmp_dir) catch {};	560	std.fs.deleteTree(comp.arena(), tmp_dir) catch {};
562	} else \|_\| {};	561	} else \|_\| {};
563	}	562	}
564		563
...	@@ -970,8 +969,8 @@ pub const Compilation = struct {	...	@@ -970,8 +969,8 @@ pub const Compilation = struct {
970	async fn initialCompile(self: *Compilation) !void {	969	async fn initialCompile(self: *Compilation) !void {
971	if (self.root_src_path) \|root_src_path\| {	970	if (self.root_src_path) \|root_src_path\| {
972	const root_scope = blk: {	971	const root_scope = blk: {
973	// TODO async/await os.path.real	972	// TODO async/await std.fs.realpath
974	const root_src_real_path = os.path.realAlloc(self.gpa(), root_src_path) catch \|err\| {	973	const root_src_real_path = std.fs.realpathAlloc(self.gpa(), root_src_path) catch \|err\| {
975	try self.addCompileErrorCli(root_src_path, "unable to open: {}", @errorName(err));	974	try self.addCompileErrorCli(root_src_path, "unable to open: {}", @errorName(err));
976	return;	975	return;
977	};	976	};
...	@@ -1196,7 +1195,7 @@ pub const Compilation = struct {	...	@@ -1196,7 +1195,7 @@ pub const Compilation = struct {
1196	const file_name = try std.fmt.allocPrint(self.gpa(), "{}{}", file_prefix[0..], suffix);	1195	const file_name = try std.fmt.allocPrint(self.gpa(), "{}{}", file_prefix[0..], suffix);
1197	defer self.gpa().free(file_name);	1196	defer self.gpa().free(file_name);
1198		1197
1199	const full_path = try os.path.join(self.gpa(), [][]const u8{ tmp_dir, file_name[0..] });	1198	const full_path = try std.fs.path.join(self.gpa(), [][]const u8{ tmp_dir, file_name[0..] });
1200	errdefer self.gpa().free(full_path);	1199	errdefer self.gpa().free(full_path);
1201		1200
1202	return Buffer.fromOwnedSlice(self.gpa(), full_path);	1201	return Buffer.fromOwnedSlice(self.gpa(), full_path);
...	@@ -1217,8 +1216,8 @@ pub const Compilation = struct {	...	@@ -1217,8 +1216,8 @@ pub const Compilation = struct {
1217	const zig_dir_path = try getZigDir(self.gpa());	1216	const zig_dir_path = try getZigDir(self.gpa());
1218	defer self.gpa().free(zig_dir_path);	1217	defer self.gpa().free(zig_dir_path);
1219		1218
1220	const tmp_dir = try os.path.join(self.arena(), [][]const u8{ zig_dir_path, comp_dir_name[0..] });	1219	const tmp_dir = try std.fs.path.join(self.arena(), [][]const u8{ zig_dir_path, comp_dir_name[0..] });
1221	try os.makePath(self.gpa(), tmp_dir);	1220	try std.fs.makePath(self.gpa(), tmp_dir);
1222	return tmp_dir;	1221	return tmp_dir;
1223	}	1222	}
1224		1223
...	@@ -1384,7 +1383,7 @@ async fn addFnToLinkSet(comp: Compilation, fn_val: Value.Fn) void {	...	@@ -1384,7 +1383,7 @@ async fn addFnToLinkSet(comp: Compilation, fn_val: Value.Fn) void {
1384	}	1383	}
1385		1384
1386	fn getZigDir(allocator: *mem.Allocator) ![]u8 {	1385	fn getZigDir(allocator: *mem.Allocator) ![]u8 {
1387	return os.getAppDataDir(allocator, "zig");	1386	return std.fs.getAppDataDir(allocator, "zig");
1388	}	1387	}
1389		1388
1390	async fn analyzeFnType(	1389	async fn analyzeFnType(

...	@@ -3,6 +3,7 @@ const builtin = @import("builtin");	...	@@ -3,6 +3,7 @@ const builtin = @import("builtin");
3	const event = std.event;	3	const event = std.event;
4	const Target = @import("target.zig").Target;	4	const Target = @import("target.zig").Target;
5	const c = @import("c.zig");	5	const c = @import("c.zig");
		6	const fs = std.fs;
6		7
7	/// See the render function implementation for documentation of the fields.	8	/// See the render function implementation for documentation of the fields.
8	pub const LibCInstallation = struct {	9	pub const LibCInstallation = struct {
...	@@ -30,7 +31,7 @@ pub const LibCInstallation = struct {	...	@@ -30,7 +31,7 @@ pub const LibCInstallation = struct {
30	self: *LibCInstallation,	31	self: *LibCInstallation,
31	allocator: *std.mem.Allocator,	32	allocator: *std.mem.Allocator,
32	libc_file: []const u8,	33	libc_file: []const u8,
33	stderr: *std.io.OutStream(std.os.File.WriteError),	34	stderr: *std.io.OutStream(fs.File.WriteError),
34	) !void {	35	) !void {
35	self.initEmpty();	36	self.initEmpty();
36		37
...	@@ -100,7 +101,7 @@ pub const LibCInstallation = struct {	...	@@ -100,7 +101,7 @@ pub const LibCInstallation = struct {
100	}	101	}
101	}	102	}
102		103
103	pub fn render(self: const LibCInstallation, out: std.io.OutStream(std.os.File.WriteError)) !void {	104	pub fn render(self: const LibCInstallation, out: std.io.OutStream(fs.File.WriteError)) !void {
104	@setEvalBranchQuota(4000);	105	@setEvalBranchQuota(4000);
105	try out.print(	106	try out.print(
106	\\# The directory that contains `stdlib.h`.	107	\\# The directory that contains `stdlib.h`.
...	@@ -148,7 +149,7 @@ pub const LibCInstallation = struct {	...	@@ -148,7 +149,7 @@ pub const LibCInstallation = struct {
148	errdefer if (windows_sdk) \|sdk\| c.zig_free_windows_sdk(@ptrCast(?[*]c.ZigWindowsSDK, sdk));	149	errdefer if (windows_sdk) \|sdk\| c.zig_free_windows_sdk(@ptrCast(?[*]c.ZigWindowsSDK, sdk));
149		150
150	switch (builtin.os) {	151	switch (builtin.os) {
151	builtin.Os.windows => {	152	.windows => {
152	var sdk: *c.ZigWindowsSDK = undefined;	153	var sdk: *c.ZigWindowsSDK = undefined;
153	switch (c.zig_find_windows_sdk(@ptrCast(?[]?[]c.ZigWindowsSDK, &sdk))) {	154	switch (c.zig_find_windows_sdk(@ptrCast(?[]?[]c.ZigWindowsSDK, &sdk))) {
154	c.ZigFindWindowsSdkError.None => {	155	c.ZigFindWindowsSdkError.None => {
...	@@ -166,13 +167,13 @@ pub const LibCInstallation = struct {	...	@@ -166,13 +167,13 @@ pub const LibCInstallation = struct {
166	c.ZigFindWindowsSdkError.PathTooLong => return error.NotFound,	167	c.ZigFindWindowsSdkError.PathTooLong => return error.NotFound,
167	}	168	}
168	},	169	},
169	builtin.Os.linux => {	170	.linux => {
170	try group.call(findNativeIncludeDirLinux, self, loop);	171	try group.call(findNativeIncludeDirLinux, self, loop);
171	try group.call(findNativeLibDirLinux, self, loop);	172	try group.call(findNativeLibDirLinux, self, loop);
172	try group.call(findNativeStaticLibDir, self, loop);	173	try group.call(findNativeStaticLibDir, self, loop);
173	try group.call(findNativeDynamicLinker, self, loop);	174	try group.call(findNativeDynamicLinker, self, loop);
174	},	175	},
175	builtin.Os.macosx, builtin.Os.freebsd, builtin.Os.netbsd => {	176	.macosx, .freebsd, .netbsd => {
176	self.include_dir = try std.mem.dupe(loop.allocator, u8, "/usr/include");	177	self.include_dir = try std.mem.dupe(loop.allocator, u8, "/usr/include");
177	},	178	},
178	else => @compileError("unimplemented: find libc for this OS"),	179	else => @compileError("unimplemented: find libc for this OS"),
...	@@ -181,7 +182,7 @@ pub const LibCInstallation = struct {	...	@@ -181,7 +182,7 @@ pub const LibCInstallation = struct {
181	}	182	}
182		183
183	async fn findNativeIncludeDirLinux(self: LibCInstallation, loop: event.Loop) !void {	184	async fn findNativeIncludeDirLinux(self: LibCInstallation, loop: event.Loop) !void {
184	const cc_exe = std.os.getEnvPosix("CC") orelse "cc";	185	const cc_exe = std.process.getEnvPosix("CC") orelse "cc";
185	const argv = []const []const u8{	186	const argv = []const []const u8{
186	cc_exe,	187	cc_exe,
187	"-E",	188	"-E",
...	@@ -190,7 +191,7 @@ pub const LibCInstallation = struct {	...	@@ -190,7 +191,7 @@ pub const LibCInstallation = struct {
190	"/dev/null",	191	"/dev/null",
191	};	192	};
192	// TODO make this use event loop	193	// TODO make this use event loop
193	const errorable_result = std.os.ChildProcess.exec(loop.allocator, argv, null, null, 1024 * 1024);	194	const errorable_result = std.ChildProcess.exec(loop.allocator, argv, null, null, 1024 * 1024);
194	const exec_result = if (std.debug.runtime_safety) blk: {	195	const exec_result = if (std.debug.runtime_safety) blk: {
195	break :blk errorable_result catch unreachable;	196	break :blk errorable_result catch unreachable;
196	} else blk: {	197	} else blk: {
...	@@ -205,7 +206,7 @@ pub const LibCInstallation = struct {	...	@@ -205,7 +206,7 @@ pub const LibCInstallation = struct {
205	}	206	}
206		207
207	switch (exec_result.term) {	208	switch (exec_result.term) {
208	std.os.ChildProcess.Term.Exited => \|code\| {	209	std.ChildProcess.Term.Exited => \|code\| {
209	if (code != 0) return error.CCompilerExitCode;	210	if (code != 0) return error.CCompilerExitCode;
210	},	211	},
211	else => {	212	else => {
...	@@ -230,7 +231,7 @@ pub const LibCInstallation = struct {	...	@@ -230,7 +231,7 @@ pub const LibCInstallation = struct {
230	while (path_i < search_paths.len) : (path_i += 1) {	231	while (path_i < search_paths.len) : (path_i += 1) {
231	const search_path_untrimmed = search_paths.at(search_paths.len - path_i - 1);	232	const search_path_untrimmed = search_paths.at(search_paths.len - path_i - 1);
232	const search_path = std.mem.trimLeft(u8, search_path_untrimmed, " ");	233	const search_path = std.mem.trimLeft(u8, search_path_untrimmed, " ");
233	const stdlib_path = try std.os.path.join(loop.allocator, [][]const u8{ search_path, "stdlib.h" });	234	const stdlib_path = try fs.path.join(loop.allocator, [][]const u8{ search_path, "stdlib.h" });
234	defer loop.allocator.free(stdlib_path);	235	defer loop.allocator.free(stdlib_path);
235		236
236	if (try fileExists(stdlib_path)) {	237	if (try fileExists(stdlib_path)) {
...	@@ -254,7 +255,7 @@ pub const LibCInstallation = struct {	...	@@ -254,7 +255,7 @@ pub const LibCInstallation = struct {
254	const stream = &std.io.BufferOutStream.init(&result_buf).stream;	255	const stream = &std.io.BufferOutStream.init(&result_buf).stream;
255	try stream.print("{}\\Include\\{}\\ucrt", search.path, search.version);	256	try stream.print("{}\\Include\\{}\\ucrt", search.path, search.version);
256		257
257	const stdlib_path = try std.os.path.join(	258	const stdlib_path = try fs.path.join(
258	loop.allocator,	259	loop.allocator,
259	[][]const u8{ result_buf.toSliceConst(), "stdlib.h" },	260	[][]const u8{ result_buf.toSliceConst(), "stdlib.h" },
260	);	261	);
...	@@ -286,7 +287,7 @@ pub const LibCInstallation = struct {	...	@@ -286,7 +287,7 @@ pub const LibCInstallation = struct {
286	builtin.Arch.aarch64 => try stream.write("arm"),	287	builtin.Arch.aarch64 => try stream.write("arm"),
287	else => return error.UnsupportedArchitecture,	288	else => return error.UnsupportedArchitecture,
288	}	289	}
289	const ucrt_lib_path = try std.os.path.join(	290	const ucrt_lib_path = try fs.path.join(
290	loop.allocator,	291	loop.allocator,
291	[][]const u8{ result_buf.toSliceConst(), "ucrt.lib" },	292	[][]const u8{ result_buf.toSliceConst(), "ucrt.lib" },
292	);	293	);
...	@@ -364,7 +365,7 @@ pub const LibCInstallation = struct {	...	@@ -364,7 +365,7 @@ pub const LibCInstallation = struct {
364	builtin.Arch.aarch64 => try stream.write("arm\\"),	365	builtin.Arch.aarch64 => try stream.write("arm\\"),
365	else => return error.UnsupportedArchitecture,	366	else => return error.UnsupportedArchitecture,
366	}	367	}
367	const kernel32_path = try std.os.path.join(	368	const kernel32_path = try fs.path.join(
368	loop.allocator,	369	loop.allocator,
369	[][]const u8{ result_buf.toSliceConst(), "kernel32.lib" },	370	[][]const u8{ result_buf.toSliceConst(), "kernel32.lib" },
370	);	371	);
...	@@ -391,14 +392,14 @@ pub const LibCInstallation = struct {	...	@@ -391,14 +392,14 @@ pub const LibCInstallation = struct {
391		392
392	/// caller owns returned memory	393	/// caller owns returned memory
393	async fn ccPrintFileName(loop: *event.Loop, o_file: []const u8, want_dirname: bool) ![]u8 {	394	async fn ccPrintFileName(loop: *event.Loop, o_file: []const u8, want_dirname: bool) ![]u8 {
394	const cc_exe = std.os.getEnvPosix("CC") orelse "cc";	395	const cc_exe = std.process.getEnvPosix("CC") orelse "cc";
395	const arg1 = try std.fmt.allocPrint(loop.allocator, "-print-file-name={}", o_file);	396	const arg1 = try std.fmt.allocPrint(loop.allocator, "-print-file-name={}", o_file);
396	defer loop.allocator.free(arg1);	397	defer loop.allocator.free(arg1);
397	const argv = []const []const u8{ cc_exe, arg1 };	398	const argv = []const []const u8{ cc_exe, arg1 };
398		399
399	// TODO This simulates evented I/O for the child process exec	400	// TODO This simulates evented I/O for the child process exec
400	await (async loop.yield() catch unreachable);	401	await (async loop.yield() catch unreachable);
401	const errorable_result = std.os.ChildProcess.exec(loop.allocator, argv, null, null, 1024 * 1024);	402	const errorable_result = std.ChildProcess.exec(loop.allocator, argv, null, null, 1024 * 1024);
402	const exec_result = if (std.debug.runtime_safety) blk: {	403	const exec_result = if (std.debug.runtime_safety) blk: {
403	break :blk errorable_result catch unreachable;	404	break :blk errorable_result catch unreachable;
404	} else blk: {	405	} else blk: {
...	@@ -412,7 +413,7 @@ async fn ccPrintFileName(loop: *event.Loop, o_file: []const u8, want_dirname: bo	...	@@ -412,7 +413,7 @@ async fn ccPrintFileName(loop: *event.Loop, o_file: []const u8, want_dirname: bo
412	loop.allocator.free(exec_result.stderr);	413	loop.allocator.free(exec_result.stderr);
413	}	414	}
414	switch (exec_result.term) {	415	switch (exec_result.term) {
415	std.os.ChildProcess.Term.Exited => \|code\| {	416	.Exited => \|code\| {
416	if (code != 0) return error.CCompilerExitCode;	417	if (code != 0) return error.CCompilerExitCode;
417	},	418	},
418	else => {	419	else => {
...	@@ -421,7 +422,7 @@ async fn ccPrintFileName(loop: *event.Loop, o_file: []const u8, want_dirname: bo	...	@@ -421,7 +422,7 @@ async fn ccPrintFileName(loop: *event.Loop, o_file: []const u8, want_dirname: bo
421	}	422	}
422	var it = std.mem.tokenize(exec_result.stdout, "\n\r");	423	var it = std.mem.tokenize(exec_result.stdout, "\n\r");
423	const line = it.next() orelse return error.LibCRuntimeNotFound;	424	const line = it.next() orelse return error.LibCRuntimeNotFound;
424	const dirname = std.os.path.dirname(line) orelse return error.LibCRuntimeNotFound;	425	const dirname = fs.path.dirname(line) orelse return error.LibCRuntimeNotFound;
425		426
426	if (want_dirname) {	427	if (want_dirname) {
427	return std.mem.dupe(loop.allocator, u8, dirname);	428	return std.mem.dupe(loop.allocator, u8, dirname);
...	@@ -459,7 +460,7 @@ fn fillSearch(search_buf: [2]Search, sdk: c.ZigWindowsSDK) []Search {	...	@@ -459,7 +460,7 @@ fn fillSearch(search_buf: [2]Search, sdk: c.ZigWindowsSDK) []Search {
459	}	460	}
460		461
461	fn fileExists(path: []const u8) !bool {	462	fn fileExists(path: []const u8) !bool {
462	if (std.os.File.access(path)) \|_\| {	463	if (fs.File.access(path)) \|_\| {
463	return true;	464	return true;
464	} else \|err\| switch (err) {	465	} else \|err\| switch (err) {
465	error.FileNotFound, error.PermissionDenied => return false,	466	error.FileNotFound, error.PermissionDenied => return false,

...	@@ -302,7 +302,7 @@ fn constructLinkerArgsElf(ctx: *Context) !void {	...	@@ -302,7 +302,7 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
302	try ctx.args.append(c"--allow-shlib-undefined");	302	try ctx.args.append(c"--allow-shlib-undefined");
303	}	303	}
304		304
305	if (ctx.comp.target.getOs() == builtin.Os.zen) {	305	if (ctx.comp.target.getOs() == .zen) {
306	try ctx.args.append(c"-e");	306	try ctx.args.append(c"-e");
307	try ctx.args.append(c"_start");	307	try ctx.args.append(c"_start");
308		308
...	@@ -311,7 +311,7 @@ fn constructLinkerArgsElf(ctx: *Context) !void {	...	@@ -311,7 +311,7 @@ fn constructLinkerArgsElf(ctx: *Context) !void {
311	}	311	}
312		312
313	fn addPathJoin(ctx: *Context, dirname: []const u8, basename: []const u8) !void {	313	fn addPathJoin(ctx: *Context, dirname: []const u8, basename: []const u8) !void {
314	const full_path = try std.os.path.join(&ctx.arena.allocator, [][]const u8{ dirname, basename });	314	const full_path = try std.fs.path.join(&ctx.arena.allocator, [][]const u8{ dirname, basename });
315	const full_path_with_null = try std.cstr.addNullByte(&ctx.arena.allocator, full_path);	315	const full_path_with_null = try std.cstr.addNullByte(&ctx.arena.allocator, full_path);
316	try ctx.args.append(full_path_with_null.ptr);	316	try ctx.args.append(full_path_with_null.ptr);
317	}	317	}
...	@@ -668,7 +668,7 @@ const DarwinPlatform = struct {	...	@@ -668,7 +668,7 @@ const DarwinPlatform = struct {
668	break :blk ver;	668	break :blk ver;
669	},	669	},
670	Compilation.DarwinVersionMin.None => blk: {	670	Compilation.DarwinVersionMin.None => blk: {
671	assert(comp.target.getOs() == builtin.Os.macosx);	671	assert(comp.target.getOs() == .macosx);
672	result.kind = Kind.MacOS;	672	result.kind = Kind.MacOS;
673	break :blk "10.10";	673	break :blk "10.10";
674	},	674	},

...	@@ -2,7 +2,6 @@ const builtin = @import("builtin");	...	@@ -2,7 +2,6 @@ const builtin = @import("builtin");
2		2
3	const std = @import("std.zig");	3	const std = @import("std.zig");
4	const mem = std.mem;	4	const mem = std.mem;
5	const cstr = std.cstr;
6	const os = std.os;	5	const os = std.os;
7	const assert = std.debug.assert;	6	const assert = std.debug.assert;
8	const testing = std.testing;	7	const testing = std.testing;
...	@@ -223,7 +222,7 @@ pub const ElfLib = struct {	...	@@ -223,7 +222,7 @@ pub const ElfLib = struct {
223	if (0 == (u32(1) << @intCast(u5, self.syms[i].st_info & 0xf) & OK_TYPES)) continue;	222	if (0 == (u32(1) << @intCast(u5, self.syms[i].st_info & 0xf) & OK_TYPES)) continue;
224	if (0 == (u32(1) << @intCast(u5, self.syms[i].st_info >> 4) & OK_BINDS)) continue;	223	if (0 == (u32(1) << @intCast(u5, self.syms[i].st_info >> 4) & OK_BINDS)) continue;
225	if (0 == self.syms[i].st_shndx) continue;	224	if (0 == self.syms[i].st_shndx) continue;
226	if (!mem.eql(u8, name, cstr.toSliceConst(self.strings + self.syms[i].st_name))) continue;	225	if (!mem.eql(u8, name, mem.toSliceConst(u8, self.strings + self.syms[i].st_name))) continue;
227	if (maybe_versym) \|versym\| {	226	if (maybe_versym) \|versym\| {
228	if (!checkver(self.verdef.?, versym[i], vername, self.strings))	227	if (!checkver(self.verdef.?, versym[i], vername, self.strings))
229	continue;	228	continue;
...	@@ -246,7 +245,7 @@ fn checkver(def_arg: *elf.Verdef, vsym_arg: i32, vername: []const u8, strings: [	...	@@ -246,7 +245,7 @@ fn checkver(def_arg: *elf.Verdef, vsym_arg: i32, vername: []const u8, strings: [
246	def = @intToPtr(*elf.Verdef, @ptrToInt(def) + def.vd_next);	245	def = @intToPtr(*elf.Verdef, @ptrToInt(def) + def.vd_next);
247	}	246	}
248	const aux = @intToPtr(*elf.Verdaux, @ptrToInt(def) + def.vd_aux);	247	const aux = @intToPtr(*elf.Verdaux, @ptrToInt(def) + def.vd_aux);
249	return mem.eql(u8, vername, cstr.toSliceConst(strings + aux.vda_name));	248	return mem.eql(u8, vername, mem.toSliceConst(u8, strings + aux.vda_name));
250	}	249	}
251		250
252	pub const WindowsDynLib = struct {	251	pub const WindowsDynLib = struct {

...	@@ -879,7 +879,7 @@ pub fn Watch(comptime V: type) type {	...	@@ -879,7 +879,7 @@ pub fn Watch(comptime V: type) type {
879	}	879	}
880		880
881	async fn addFileKEvent(self: *Self, file_path: []const u8, value: V) !?V {	881	async fn addFileKEvent(self: *Self, file_path: []const u8, value: V) !?V {
882	const resolved_path = try os.path.resolve(self.channel.loop.allocator, [][]const u8{file_path});	882	const resolved_path = try std.fs.path.resolve(self.channel.loop.allocator, [][]const u8{file_path});
883	var resolved_path_consumed = false;	883	var resolved_path_consumed = false;
884	defer if (!resolved_path_consumed) self.channel.loop.allocator.free(resolved_path);	884	defer if (!resolved_path_consumed) self.channel.loop.allocator.free(resolved_path);
885		885
...	@@ -967,12 +967,12 @@ pub fn Watch(comptime V: type) type {	...	@@ -967,12 +967,12 @@ pub fn Watch(comptime V: type) type {
967	async fn addFileLinux(self: *Self, file_path: []const u8, value: V) !?V {	967	async fn addFileLinux(self: *Self, file_path: []const u8, value: V) !?V {
968	const value_copy = value;	968	const value_copy = value;
969		969
970	const dirname = os.path.dirname(file_path) orelse ".";	970	const dirname = std.fs.path.dirname(file_path) orelse ".";
971	const dirname_with_null = try std.cstr.addNullByte(self.channel.loop.allocator, dirname);	971	const dirname_with_null = try std.cstr.addNullByte(self.channel.loop.allocator, dirname);
972	var dirname_with_null_consumed = false;	972	var dirname_with_null_consumed = false;
973	defer if (!dirname_with_null_consumed) self.channel.loop.allocator.free(dirname_with_null);	973	defer if (!dirname_with_null_consumed) self.channel.loop.allocator.free(dirname_with_null);
974		974
975	const basename = os.path.basename(file_path);	975	const basename = std.fs.path.basename(file_path);
976	const basename_with_null = try std.cstr.addNullByte(self.channel.loop.allocator, basename);	976	const basename_with_null = try std.cstr.addNullByte(self.channel.loop.allocator, basename);
977	var basename_with_null_consumed = false;	977	var basename_with_null_consumed = false;
978	defer if (!basename_with_null_consumed) self.channel.loop.allocator.free(basename_with_null);	978	defer if (!basename_with_null_consumed) self.channel.loop.allocator.free(basename_with_null);
...	@@ -1013,7 +1013,7 @@ pub fn Watch(comptime V: type) type {	...	@@ -1013,7 +1013,7 @@ pub fn Watch(comptime V: type) type {
1013	const value_copy = value;	1013	const value_copy = value;
1014	// TODO we might need to convert dirname and basename to canonical file paths ("short"?)	1014	// TODO we might need to convert dirname and basename to canonical file paths ("short"?)
1015		1015
1016	const dirname = try std.mem.dupe(self.channel.loop.allocator, u8, os.path.dirname(file_path) orelse ".");	1016	const dirname = try std.mem.dupe(self.channel.loop.allocator, u8, std.fs.path.dirname(file_path) orelse ".");
1017	var dirname_consumed = false;	1017	var dirname_consumed = false;
1018	defer if (!dirname_consumed) self.channel.loop.allocator.free(dirname);	1018	defer if (!dirname_consumed) self.channel.loop.allocator.free(dirname);
1019		1019
...	@@ -1021,7 +1021,7 @@ pub fn Watch(comptime V: type) type {	...	@@ -1021,7 +1021,7 @@ pub fn Watch(comptime V: type) type {
1021	defer self.channel.loop.allocator.free(dirname_utf16le);	1021	defer self.channel.loop.allocator.free(dirname_utf16le);
1022		1022
1023	// TODO https://github.com/ziglang/zig/issues/265	1023	// TODO https://github.com/ziglang/zig/issues/265
1024	const basename = os.path.basename(file_path);	1024	const basename = std.fs.path.basename(file_path);
1025	const basename_utf16le_null = try std.unicode.utf8ToUtf16LeWithNull(self.channel.loop.allocator, basename);	1025	const basename_utf16le_null = try std.unicode.utf8ToUtf16LeWithNull(self.channel.loop.allocator, basename);
1026	var basename_utf16le_null_consumed = false;	1026	var basename_utf16le_null_consumed = false;
1027	defer if (!basename_utf16le_null_consumed) self.channel.loop.allocator.free(basename_utf16le_null);	1027	defer if (!basename_utf16le_null_consumed) self.channel.loop.allocator.free(basename_utf16le_null);
...	@@ -1334,7 +1334,7 @@ async fn testFsWatchCantFail(loop: Loop, result: (anyerror!void)) void {	...	@@ -1334,7 +1334,7 @@ async fn testFsWatchCantFail(loop: Loop, result: (anyerror!void)) void {
1334	}	1334	}
1335		1335
1336	async fn testFsWatch(loop: *Loop) !void {	1336	async fn testFsWatch(loop: *Loop) !void {
1337	const file_path = try os.path.join(loop.allocator, [][]const u8{ test_tmp_dir, "file.txt" });	1337	const file_path = try std.fs.path.join(loop.allocator, [][]const u8{ test_tmp_dir, "file.txt" });
1338	defer loop.allocator.free(file_path);	1338	defer loop.allocator.free(file_path);
1339		1339
1340	const contents =	1340	const contents =

...	@@ -1,6 +1,8 @@	...	@@ -1,6 +1,8 @@
		1	const builtin = @import("builtin");
1	const std = @import("std.zig");	2	const std = @import("std.zig");
2	const os = std.os;	3	const os = std.os;
3	const mem = std.mem;	4	const mem = std.mem;
		5	const Allocator = std.mem.Allocator;
4		6
5	pub const path = @import("fs/path.zig");	7	pub const path = @import("fs/path.zig");
6	pub const File = @import("fs/file.zig").File;	8	pub const File = @import("fs/file.zig").File;
...	@@ -12,8 +14,6 @@ pub const deleteFileC = os.unlinkC;	...	@@ -12,8 +14,6 @@ pub const deleteFileC = os.unlinkC;
12	pub const rename = os.rename;	14	pub const rename = os.rename;
13	pub const renameC = os.renameC;	15	pub const renameC = os.renameC;
14	pub const renameW = os.renameW;	16	pub const renameW = os.renameW;
15	pub const changeCurDir = os.chdir;
16	pub const changeCurDirC = os.chdirC;
17	pub const realpath = os.realpath;	17	pub const realpath = os.realpath;
18	pub const realpathC = os.realpathC;	18	pub const realpathC = os.realpathC;
19	pub const realpathW = os.realpathW;	19	pub const realpathW = os.realpathW;
...	@@ -65,13 +65,13 @@ pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path:	...	@@ -65,13 +65,13 @@ pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path:
65	else => return err, // TODO zig should know this set does not include PathAlreadyExists	65	else => return err, // TODO zig should know this set does not include PathAlreadyExists
66	}	66	}
67		67
68	const dirname = os.path.dirname(new_path) orelse ".";	68	const dirname = path.dirname(new_path) orelse ".";
69		69
70	var rand_buf: [12]u8 = undefined;	70	var rand_buf: [12]u8 = undefined;
71	const tmp_path = try allocator.alloc(u8, dirname.len + 1 + base64.Base64Encoder.calcSize(rand_buf.len));	71	const tmp_path = try allocator.alloc(u8, dirname.len + 1 + base64.Base64Encoder.calcSize(rand_buf.len));
72	defer allocator.free(tmp_path);	72	defer allocator.free(tmp_path);
73	mem.copy(u8, tmp_path[0..], dirname);	73	mem.copy(u8, tmp_path[0..], dirname);
74	tmp_path[dirname.len] = os.path.sep;	74	tmp_path[dirname.len] = path.sep;
75	while (true) {	75	while (true) {
76	try getRandomBytes(rand_buf[0..]);	76	try getRandomBytes(rand_buf[0..]);
77	b64_fs_encoder.encode(tmp_path[dirname.len + 1 ..], rand_buf);	77	b64_fs_encoder.encode(tmp_path[dirname.len + 1 ..], rand_buf);
...	@@ -143,7 +143,7 @@ pub const AtomicFile = struct {	...	@@ -143,7 +143,7 @@ pub const AtomicFile = struct {
143	/// TODO once we have null terminated pointers, use the	143	/// TODO once we have null terminated pointers, use the
144	/// openWriteNoClobberN function	144	/// openWriteNoClobberN function
145	pub fn init(dest_path: []const u8, mode: File.Mode) InitError!AtomicFile {	145	pub fn init(dest_path: []const u8, mode: File.Mode) InitError!AtomicFile {
146	const dirname = os.path.dirname(dest_path);	146	const dirname = path.dirname(dest_path);
147	var rand_buf: [12]u8 = undefined;	147	var rand_buf: [12]u8 = undefined;
148	const dirname_component_len = if (dirname) \|d\| d.len + 1 else 0;	148	const dirname_component_len = if (dirname) \|d\| d.len + 1 else 0;
149	const encoded_rand_len = comptime base64.Base64Encoder.calcSize(rand_buf.len);	149	const encoded_rand_len = comptime base64.Base64Encoder.calcSize(rand_buf.len);
...	@@ -153,7 +153,7 @@ pub const AtomicFile = struct {	...	@@ -153,7 +153,7 @@ pub const AtomicFile = struct {
153		153
154	if (dirname) \|dir\| {	154	if (dirname) \|dir\| {
155	mem.copy(u8, tmp_path_buf[0..], dir);	155	mem.copy(u8, tmp_path_buf[0..], dir);
156	tmp_path_buf[dir.len] = os.path.sep;	156	tmp_path_buf[dir.len] = path.sep;
157	}	157	}
158		158
159	tmp_path_buf[tmp_path_len] = 0;	159	tmp_path_buf[tmp_path_len] = 0;
...	@@ -240,7 +240,7 @@ pub fn makePath(allocator: *Allocator, full_path: []const u8) !void {	...	@@ -240,7 +240,7 @@ pub fn makePath(allocator: *Allocator, full_path: []const u8) !void {
240	// march end_index backward until next path component	240	// march end_index backward until next path component
241	while (true) {	241	while (true) {
242	end_index -= 1;	242	end_index -= 1;
243	if (os.path.isSep(resolved_path[end_index])) break;	243	if (path.isSep(resolved_path[end_index])) break;
244	}	244	}
245	continue;	245	continue;
246	},	246	},
...	@@ -250,7 +250,7 @@ pub fn makePath(allocator: *Allocator, full_path: []const u8) !void {	...	@@ -250,7 +250,7 @@ pub fn makePath(allocator: *Allocator, full_path: []const u8) !void {
250	// march end_index forward until next path component	250	// march end_index forward until next path component
251	while (true) {	251	while (true) {
252	end_index += 1;	252	end_index += 1;
253	if (end_index == resolved_path.len or os.path.isSep(resolved_path[end_index])) break;	253	if (end_index == resolved_path.len or path.isSep(resolved_path[end_index])) break;
254	}	254	}
255	}	255	}
256	}	256	}
...	@@ -614,7 +614,7 @@ pub const Dir = struct {	...	@@ -614,7 +614,7 @@ pub const Dir = struct {
614	const next_index = self.handle.index + linux_entry.d_reclen;	614	const next_index = self.handle.index + linux_entry.d_reclen;
615	self.handle.index = next_index;	615	self.handle.index = next_index;
616		616
617	const name = cstr.toSlice(@ptrCast([*]u8, &linux_entry.d_name));	617	const name = mem.toSlice(u8, @ptrCast([*]u8, &linux_entry.d_name));
618		618
619	// skip . and .. entries	619	// skip . and .. entries
620	if (mem.eql(u8, name, ".") or mem.eql(u8, name, "..")) {	620	if (mem.eql(u8, name, ".") or mem.eql(u8, name, "..")) {
...	@@ -709,7 +709,7 @@ pub fn readLinkC(pathname: []const u8, buffer: [os.PATH_MAX]u8) ![]u8 {	...	@@ -709,7 +709,7 @@ pub fn readLinkC(pathname: []const u8, buffer: [os.PATH_MAX]u8) ![]u8 {
709	return os.readlinkC(pathname, buffer);	709	return os.readlinkC(pathname, buffer);
710	}	710	}
711		711
712	pub const OpenSelfExeError = error{};	712	pub const OpenSelfExeError = os.OpenError \|\| os.windows.CreateFileError;
713		713
714	pub fn openSelfExe() OpenSelfExeError!File {	714	pub fn openSelfExe() OpenSelfExeError!File {
715	if (os.linux.is_the_target) {	715	if (os.linux.is_the_target) {

...	@@ -103,7 +103,7 @@ pub const DirectAllocator = struct {	...	@@ -103,7 +103,7 @@ pub const DirectAllocator = struct {
103	return @ptrCast([*]u8, final_addr)[0..n];	103	return @ptrCast([*]u8, final_addr)[0..n];
104	}	104	}
105		105
106	const alloc_size = if (alignment <= os.page_size) n else n + alignment;	106	const alloc_size = if (alignment <= mem.page_size) n else n + alignment;
107	const addr = os.mmap(	107	const addr = os.mmap(
108	null,	108	null,
109	alloc_size,	109	alloc_size,
...	@@ -123,7 +123,7 @@ pub const DirectAllocator = struct {	...	@@ -123,7 +123,7 @@ pub const DirectAllocator = struct {
123	if (unused_start_len != 0) {	123	if (unused_start_len != 0) {
124	os.munmap(addr, unused_start_len);	124	os.munmap(addr, unused_start_len);
125	}	125	}
126	const aligned_end_addr = std.mem.alignForward(aligned_addr + n, os.page_size);	126	const aligned_end_addr = std.mem.alignForward(aligned_addr + n, mem.page_size);
127	const unused_end_len = addr + alloc_size - aligned_end_addr;	127	const unused_end_len = addr + alloc_size - aligned_end_addr;
128	if (unused_end_len != 0) {	128	if (unused_end_len != 0) {
129	os.munmap(aligned_end_addr, unused_end_len);	129	os.munmap(aligned_end_addr, unused_end_len);
...	@@ -147,7 +147,7 @@ pub const DirectAllocator = struct {	...	@@ -147,7 +147,7 @@ pub const DirectAllocator = struct {
147	const base_addr = @ptrToInt(old_mem.ptr);	147	const base_addr = @ptrToInt(old_mem.ptr);
148	const old_addr_end = base_addr + old_mem.len;	148	const old_addr_end = base_addr + old_mem.len;
149	const new_addr_end = base_addr + new_size;	149	const new_addr_end = base_addr + new_size;
150	const new_addr_end_rounded = mem.alignForward(new_addr_end, os.page_size);	150	const new_addr_end_rounded = mem.alignForward(new_addr_end, mem.page_size);
151	if (old_addr_end > new_addr_end_rounded) {	151	if (old_addr_end > new_addr_end_rounded) {
152	// For shrinking that is not releasing, we will only	152	// For shrinking that is not releasing, we will only
153	// decommit the pages not needed anymore.	153	// decommit the pages not needed anymore.
...	@@ -163,7 +163,7 @@ pub const DirectAllocator = struct {	...	@@ -163,7 +163,7 @@ pub const DirectAllocator = struct {
163	const base_addr = @ptrToInt(old_mem.ptr);	163	const base_addr = @ptrToInt(old_mem.ptr);
164	const old_addr_end = base_addr + old_mem.len;	164	const old_addr_end = base_addr + old_mem.len;
165	const new_addr_end = base_addr + new_size;	165	const new_addr_end = base_addr + new_size;
166	const new_addr_end_rounded = mem.alignForward(new_addr_end, os.page_size);	166	const new_addr_end_rounded = mem.alignForward(new_addr_end, mem.page_size);
167	if (old_addr_end > new_addr_end_rounded) {	167	if (old_addr_end > new_addr_end_rounded) {
168	os.munmap(new_addr_end_rounded, old_addr_end - new_addr_end_rounded);	168	os.munmap(new_addr_end_rounded, old_addr_end - new_addr_end_rounded);
169	}	169	}
...	@@ -196,9 +196,9 @@ pub const DirectAllocator = struct {	...	@@ -196,9 +196,9 @@ pub const DirectAllocator = struct {
196	}	196	}
197		197
198	const old_addr_end = base_addr + old_mem.len;	198	const old_addr_end = base_addr + old_mem.len;
199	const old_addr_end_rounded = mem.alignForward(old_addr_end, os.page_size);	199	const old_addr_end_rounded = mem.alignForward(old_addr_end, mem.page_size);
200	const new_addr_end = base_addr + new_size;	200	const new_addr_end = base_addr + new_size;
201	const new_addr_end_rounded = mem.alignForward(new_addr_end, os.page_size);	201	const new_addr_end_rounded = mem.alignForward(new_addr_end, mem.page_size);
202	if (new_addr_end_rounded == old_addr_end_rounded) {	202	if (new_addr_end_rounded == old_addr_end_rounded) {
203	// The reallocation fits in the already allocated pages.	203	// The reallocation fits in the already allocated pages.
204	return @ptrCast([*]u8, old_mem.ptr)[0..new_size];	204	return @ptrCast([*]u8, old_mem.ptr)[0..new_size];
...	@@ -374,7 +374,7 @@ pub const ArenaAllocator = struct {	...	@@ -374,7 +374,7 @@ pub const ArenaAllocator = struct {
374	var len = prev_len;	374	var len = prev_len;
375	while (true) {	375	while (true) {
376	len += len / 2;	376	len += len / 2;
377	len += os.page_size - @rem(len, os.page_size);	377	len += mem.page_size - @rem(len, mem.page_size);
378	if (len >= actual_min_size) break;	378	if (len >= actual_min_size) break;
379	}	379	}
380	const buf = try self.child_allocator.alignedAlloc(u8, @alignOf(BufNode), len);	380	const buf = try self.child_allocator.alignedAlloc(u8, @alignOf(BufNode), len);
...	@@ -520,11 +520,11 @@ const WasmAllocator = struct {	...	@@ -520,11 +520,11 @@ const WasmAllocator = struct {
520	const adjusted_index = self.end_index + (adjusted_addr - addr);	520	const adjusted_index = self.end_index + (adjusted_addr - addr);
521	const new_end_index = adjusted_index + size;	521	const new_end_index = adjusted_index + size;
522		522
523	if (new_end_index > self.num_pages * os.page_size) {	523	if (new_end_index > self.num_pages * mem.page_size) {
524	const required_memory = new_end_index - (self.num_pages * os.page_size);	524	const required_memory = new_end_index - (self.num_pages * mem.page_size);
525		525
526	var num_pages: usize = required_memory / os.page_size;	526	var num_pages: usize = required_memory / mem.page_size;
527	if (required_memory % os.page_size != 0) {	527	if (required_memory % mem.page_size != 0) {
528	num_pages += 1;	528	num_pages += 1;
529	}	529	}
530		530
...	@@ -553,14 +553,14 @@ const WasmAllocator = struct {	...	@@ -553,14 +553,14 @@ const WasmAllocator = struct {
553		553
554	// Initialize start_ptr at the first realloc	554	// Initialize start_ptr at the first realloc
555	if (self.num_pages == 0) {	555	if (self.num_pages == 0) {
556	self.start_ptr = @intToPtr([]u8, @intCast(usize, @"llvm.wasm.memory.size.i32"(0)) os.page_size);	556	self.start_ptr = @intToPtr([]u8, @intCast(usize, @"llvm.wasm.memory.size.i32"(0)) mem.page_size);
557	}	557	}
558		558
559	if (is_last_item(allocator, old_mem, new_align)) {	559	if (is_last_item(allocator, old_mem, new_align)) {
560	const start_index = self.end_index - old_mem.len;	560	const start_index = self.end_index - old_mem.len;
561	const new_end_index = start_index + new_size;	561	const new_end_index = start_index + new_size;
562		562
563	if (new_end_index > self.num_pages * os.page_size) {	563	if (new_end_index > self.num_pages * mem.page_size) {
564	_ = try alloc(allocator, new_end_index - self.end_index, new_align);	564	_ = try alloc(allocator, new_end_index - self.end_index, new_align);
565	}	565	}
566	const result = self.start_ptr[start_index..new_end_index];	566	const result = self.start_ptr[start_index..new_end_index];
...	@@ -876,10 +876,10 @@ fn testAllocatorAligned(allocator: *mem.Allocator, comptime alignment: u29) !voi	...	@@ -876,10 +876,10 @@ fn testAllocatorAligned(allocator: *mem.Allocator, comptime alignment: u29) !voi
876	fn testAllocatorLargeAlignment(allocator: *mem.Allocator) mem.Allocator.Error!void {	876	fn testAllocatorLargeAlignment(allocator: *mem.Allocator) mem.Allocator.Error!void {
877	//Maybe a platform's page_size is actually the same as or	877	//Maybe a platform's page_size is actually the same as or
878	// very near usize?	878	// very near usize?
879	if (os.page_size << 2 > maxInt(usize)) return;	879	if (mem.page_size << 2 > maxInt(usize)) return;
880		880
881	const USizeShift = @IntType(false, std.math.log2(usize.bit_count));	881	const USizeShift = @IntType(false, std.math.log2(usize.bit_count));
882	const large_align = u29(os.page_size << 2);	882	const large_align = u29(mem.page_size << 2);
883		883
884	var align_mask: usize = undefined;	884	var align_mask: usize = undefined;
885	_ = @shlWithOverflow(usize, ~usize(0), USizeShift(@ctz(u29, large_align)), &align_mask);	885	_ = @shlWithOverflow(usize, ~usize(0), USizeShift(@ctz(u29, large_align)), &align_mask);
...	@@ -906,7 +906,7 @@ fn testAllocatorAlignedShrink(allocator: *mem.Allocator) mem.Allocator.Error!voi	...	@@ -906,7 +906,7 @@ fn testAllocatorAlignedShrink(allocator: *mem.Allocator) mem.Allocator.Error!voi
906	var debug_buffer: [1000]u8 = undefined;	906	var debug_buffer: [1000]u8 = undefined;
907	const debug_allocator = &FixedBufferAllocator.init(&debug_buffer).allocator;	907	const debug_allocator = &FixedBufferAllocator.init(&debug_buffer).allocator;
908		908
909	const alloc_size = os.page_size * 2 + 50;	909	const alloc_size = mem.page_size * 2 + 50;
910	var slice = try allocator.alignedAlloc(u8, 16, alloc_size);	910	var slice = try allocator.alignedAlloc(u8, 16, alloc_size);
911	defer allocator.free(slice);	911	defer allocator.free(slice);
912		912
...	@@ -915,7 +915,7 @@ fn testAllocatorAlignedShrink(allocator: *mem.Allocator) mem.Allocator.Error!voi	...	@@ -915,7 +915,7 @@ fn testAllocatorAlignedShrink(allocator: *mem.Allocator) mem.Allocator.Error!voi
915	// which is 16 pages, hence the 32. This test may require to increase	915	// which is 16 pages, hence the 32. This test may require to increase
916	// the size of the allocations feeding the `allocator` parameter if they	916	// the size of the allocations feeding the `allocator` parameter if they
917	// fail, because of this high over-alignment we want to have.	917	// fail, because of this high over-alignment we want to have.
918	while (@ptrToInt(slice.ptr) == mem.alignForward(@ptrToInt(slice.ptr), os.page_size * 32)) {	918	while (@ptrToInt(slice.ptr) == mem.alignForward(@ptrToInt(slice.ptr), mem.page_size * 32)) {
919	try stuff_to_free.append(slice);	919	try stuff_to_free.append(slice);
920	slice = try allocator.alignedAlloc(u8, 16, alloc_size);	920	slice = try allocator.alignedAlloc(u8, 16, alloc_size);
921	}	921	}
...	@@ -926,7 +926,7 @@ fn testAllocatorAlignedShrink(allocator: *mem.Allocator) mem.Allocator.Error!voi	...	@@ -926,7 +926,7 @@ fn testAllocatorAlignedShrink(allocator: *mem.Allocator) mem.Allocator.Error!voi
926	slice[60] = 0x34;	926	slice[60] = 0x34;
927		927
928	// realloc to a smaller size but with a larger alignment	928	// realloc to a smaller size but with a larger alignment
929	slice = try allocator.alignedRealloc(slice, os.page_size * 32, alloc_size / 2);	929	slice = try allocator.alignedRealloc(slice, mem.page_size * 32, alloc_size / 2);
930	testing.expect(slice[0] == 0x12);	930	testing.expect(slice[0] == 0x12);
931	testing.expect(slice[60] == 0x34);	931	testing.expect(slice[60] == 0x34);
932	}	932	}

clean up references to os