Commit 4787127cf6418f7a819c9d6f07a9046d76e0de65 | zig

std/atomic/queue.zig+7-5

 @@ -70,7 +70,7 @@ test "std.atomic.queue" {
     var queue: Queue(i32) = undefined;
     queue.init();
-    var context = Context {
+    var context = Context{
         .allocator = a,
         .queue = &queue,
         .put_sum = 0,
 @@ -81,16 +81,18 @@ test "std.atomic.queue" {
     var putters: [put_thread_count]&std.os.Thread = undefined;
     for (putters) |*t| {
-        *t = try std.os.spawnThread(&context, startPuts);
+        t.* = try std.os.spawnThread(&context, startPuts);
     }
     var getters: [put_thread_count]&std.os.Thread = undefined;
     for (getters) |*t| {
-        *t = try std.os.spawnThread(&context, startGets);
+        t.* = try std.os.spawnThread(&context, startGets);
     }
-    for (putters) |t| t.wait();
+    for (putters) |t|
+        t.wait();
     _ = @atomicRmw(u8, &context.puts_done, builtin.AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst);
-    for (getters) |t| t.wait();
+    for (getters) |t|
+        t.wait();
     std.debug.assert(context.put_sum == context.get_sum);
     std.debug.assert(context.get_count == puts_per_thread * put_thread_count);

std/atomic/stack.zig+8-8

 @@ -14,9 +14,7 @@ pub fn Stack(comptime T: type) type {
         };
         pub fn init() Self {
-            return Self {
+            return Self{ .root = null };
-                .root = null,
-            };
         }
         /// push operation, but only if you are the first item in the stack. if you did not succeed in
 @@ -75,7 +73,7 @@ test "std.atomic.stack" {
     var a = &fixed_buffer_allocator.allocator;
     var stack = Stack(i32).init();
-    var context = Context {
+    var context = Context{
         .allocator = a,
         .stack = &stack,
         .put_sum = 0,
 @@ -86,16 +84,18 @@ test "std.atomic.stack" {
     var putters: [put_thread_count]&std.os.Thread = undefined;
     for (putters) |*t| {
-        *t = try std.os.spawnThread(&context, startPuts);
+        t.* = try std.os.spawnThread(&context, startPuts);
     }
     var getters: [put_thread_count]&std.os.Thread = undefined;
     for (getters) |*t| {
-        *t = try std.os.spawnThread(&context, startGets);
+        t.* = try std.os.spawnThread(&context, startGets);
     }
-    for (putters) |t| t.wait();
+    for (putters) |t|
+        t.wait();
     _ = @atomicRmw(u8, &context.puts_done, builtin.AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst);
-    for (getters) |t| t.wait();
+    for (getters) |t|
+        t.wait();
     std.debug.assert(context.put_sum == context.get_sum);
     std.debug.assert(context.get_count == puts_per_thread * put_thread_count);

std/buffer.zig+3-8

 @@ -31,9 +31,7 @@ pub const Buffer = struct {
     /// * ::replaceContentsBuffer
     /// * ::resize
     pub fn initNull(allocator: &Allocator) Buffer {
-        return Buffer {
+        return Buffer{ .list = ArrayList(u8).init(allocator) };
-            .list = ArrayList(u8).init(allocator),
-        };
     }
     /// Must deinitialize with deinit.
 @@ -45,9 +43,7 @@ pub const Buffer = struct {
     /// allocated with `allocator`.
     /// Must deinitialize with deinit.
     pub fn fromOwnedSlice(allocator: &Allocator, slice: []u8) Buffer {
-        var self = Buffer {
+        var self = Buffer{ .list = ArrayList(u8).fromOwnedSlice(allocator, slice) };
-            .list = ArrayList(u8).fromOwnedSlice(allocator, slice),
-        };
         self.list.append(0);
         return self;
     }
 @@ -57,11 +53,10 @@ pub const Buffer = struct {
     pub fn toOwnedSlice(self: &Buffer) []u8 {
         const allocator = self.list.allocator;
         const result = allocator.shrink(u8, self.list.items, self.len());
-        *self = initNull(allocator);
+        self.* = initNull(allocator);
         return result;
     }
     pub fn deinit(self: &Buffer) void {
         self.list.deinit();
     }

std/build.zig+86-121

 @@ -82,10 +82,8 @@ pub const Builder = struct {
         description: []const u8,
     };
-    pub fn init(allocator: &Allocator, zig_exe: []const u8, build_root: []const u8,
+    pub fn init(allocator: &Allocator, zig_exe: []const u8, build_root: []const u8, cache_root: []const u8) Builder {
-        cache_root: []const u8) Builder
+        var self = Builder{
-    {
-        var self = Builder {
             .zig_exe = zig_exe,
             .build_root = build_root,
             .cache_root = os.path.relative(allocator, build_root, cache_root) catch unreachable,
 @@ -112,12 +110,12 @@ pub const Builder = struct {
             .lib_dir = undefined,
             .exe_dir = undefined,
             .installed_files = ArrayList([]const u8).init(allocator),
-            .uninstall_tls = TopLevelStep {
+            .uninstall_tls = TopLevelStep{
                 .step = Step.init("uninstall", allocator, makeUninstall),
                 .description = "Remove build artifacts from prefix path",
             },
             .have_uninstall_step = false,
-            .install_tls = TopLevelStep {
+            .install_tls = TopLevelStep{
                 .step = Step.initNoOp("install", allocator),
                 .description = "Copy build artifacts to prefix path",
             },
 @@ -151,9 +149,7 @@ pub const Builder = struct {
         return LibExeObjStep.createObject(self, name, root_src);
     }
-    pub fn addSharedLibrary(self: &Builder, name: []const u8, root_src: ?[]const u8,
+    pub fn addSharedLibrary(self: &Builder, name: []const u8, root_src: ?[]const u8, ver: &const Version) &LibExeObjStep {
-        ver: &const Version) &LibExeObjStep
-    {
         return LibExeObjStep.createSharedLibrary(self, name, root_src, ver);
     }
 @@ -163,7 +159,7 @@ pub const Builder = struct {
     pub fn addTest(self: &Builder, root_src: []const u8) &TestStep {
         const test_step = self.allocator.create(TestStep) catch unreachable;
-        *test_step = TestStep.init(self, root_src);
+        test_step.* = TestStep.init(self, root_src);
         return test_step;
     }
 @@ -190,33 +186,31 @@ pub const Builder = struct {
     }
     /// ::argv is copied.
-    pub fn addCommand(self: &Builder, cwd: ?[]const u8, env_map: &const BufMap,
+    pub fn addCommand(self: &Builder, cwd: ?[]const u8, env_map: &const BufMap, argv: []const []const u8) &CommandStep {
-        argv: []const []const u8) &CommandStep
-    {
         return CommandStep.create(self, cwd, env_map, argv);
     }
     pub fn addWriteFile(self: &Builder, file_path: []const u8, data: []const u8) &WriteFileStep {
         const write_file_step = self.allocator.create(WriteFileStep) catch unreachable;
-        *write_file_step = WriteFileStep.init(self, file_path, data);
+        write_file_step.* = WriteFileStep.init(self, file_path, data);
         return write_file_step;
     }
     pub fn addLog(self: &Builder, comptime format: []const u8, args: ...) &LogStep {
         const data = self.fmt(format, args);
         const log_step = self.allocator.create(LogStep) catch unreachable;
-        *log_step = LogStep.init(self, data);
+        log_step.* = LogStep.init(self, data);
         return log_step;
     }
     pub fn addRemoveDirTree(self: &Builder, dir_path: []const u8) &RemoveDirStep {
         const remove_dir_step = self.allocator.create(RemoveDirStep) catch unreachable;
-        *remove_dir_step = RemoveDirStep.init(self, dir_path);
+        remove_dir_step.* = RemoveDirStep.init(self, dir_path);
         return remove_dir_step;
     }
     pub fn version(self: &const Builder, major: u32, minor: u32, patch: u32) Version {
-        return Version {
+        return Version{
             .major = major,
             .minor = minor,
             .patch = patch,
 @@ -254,8 +248,7 @@ pub const Builder = struct {
     }
     pub fn getInstallStep(self: &Builder) &Step {
-        if (self.have_install_step)
+        if (self.have_install_step) return &self.install_tls.step;
-            return &self.install_tls.step;
         self.top_level_steps.append(&self.install_tls) catch unreachable;
         self.have_install_step = true;
 @@ -263,8 +256,7 @@ pub const Builder = struct {
     }
     pub fn getUninstallStep(self: &Builder) &Step {
-        if (self.have_uninstall_step)
+        if (self.have_uninstall_step) return &self.uninstall_tls.step;
-            return &self.uninstall_tls.step;
         self.top_level_steps.append(&self.uninstall_tls) catch unreachable;
         self.have_uninstall_step = true;
 @@ -360,7 +352,7 @@ pub const Builder = struct {
     pub fn option(self: &Builder, comptime T: type, name: []const u8, description: []const u8) ?T {
         const type_id = comptime typeToEnum(T);
-        const available_option = AvailableOption {
+        const available_option = AvailableOption{
             .name = name,
             .type_id = type_id,
             .description = description,
 @@ -413,7 +405,7 @@ pub const Builder = struct {
     pub fn step(self: &Builder, name: []const u8, description: []const u8) &Step {
         const step_info = self.allocator.create(TopLevelStep) catch unreachable;
-        *step_info = TopLevelStep {
+        step_info.* = TopLevelStep{
             .step = Step.initNoOp(name, self.allocator),
             .description = description,
         };
 @@ -446,9 +438,9 @@ pub const Builder = struct {
     }
     pub fn addUserInputOption(self: &Builder, name: []const u8, value: []const u8) bool {
-        if (self.user_input_options.put(name, UserInputOption {
+        if (self.user_input_options.put(name, UserInputOption{
             .name = name,
-            .value = UserValue { .Scalar = value },
+            .value = UserValue{ .Scalar = value },
             .used = false,
         }) catch unreachable) |*prev_value| {
             // option already exists
 @@ -458,18 +450,18 @@ pub const Builder = struct {
                     var list = ArrayList([]const u8).init(self.allocator);
                     list.append(s) catch unreachable;
                     list.append(value) catch unreachable;
-                    _ = self.user_input_options.put(name, UserInputOption {
+                    _ = self.user_input_options.put(name, UserInputOption{
                         .name = name,
-                        .value = UserValue { .List = list },
+                        .value = UserValue{ .List = list },
                         .used = false,
                     }) catch unreachable;
                 },
                 UserValue.List => |*list| {
                     // append to the list
                     list.append(value) catch unreachable;
-                    _ = self.user_input_options.put(name, UserInputOption {
+                    _ = self.user_input_options.put(name, UserInputOption{
                         .name = name,
-                        .value = UserValue { .List = *list },
+                        .value = UserValue{ .List = list.* },
                         .used = false,
                     }) catch unreachable;
                 },
 @@ -483,9 +475,9 @@ pub const Builder = struct {
     }
     pub fn addUserInputFlag(self: &Builder, name: []const u8) bool {
-        if (self.user_input_options.put(name, UserInputOption {
+        if (self.user_input_options.put(name, UserInputOption{
             .name = name,
-            .value = UserValue {.Flag = {} },
+            .value = UserValue{ .Flag = {} },
             .used = false,
         }) catch unreachable) |*prev_value| {
             switch (prev_value.value) {
 @@ -556,9 +548,7 @@ pub const Builder = struct {
         warn("\n");
     }
-    fn spawnChildEnvMap(self: &Builder, cwd: ?[]const u8, env_map: &const BufMap,
+    fn spawnChildEnvMap(self: &Builder, cwd: ?[]const u8, env_map: &const BufMap, argv: []const []const u8) !void {
-        argv: []const []const u8) !void
-    {
         if (self.verbose) {
             printCmd(cwd, argv);
         }
 @@ -617,7 +607,7 @@ pub const Builder = struct {
         self.pushInstalledFile(full_dest_path);
         const install_step = self.allocator.create(InstallFileStep) catch unreachable;
-        *install_step = InstallFileStep.init(self, src_path, full_dest_path);
+        install_step.* = InstallFileStep.init(self, src_path, full_dest_path);
         return install_step;
     }
 @@ -659,25 +649,23 @@ pub const Builder = struct {
         if (builtin.environ == builtin.Environ.msvc) {
             return "cl.exe";
         } else {
             return os.getEnvVarOwned(self.allocator, "CC") catch |err|
                 if (err == error.EnvironmentVariableNotFound)
                     ([]const u8)("cc")
                 else
-                    debug.panic("Unable to get environment variable: {}", err)
+                    debug.panic("Unable to get environment variable: {}", err);
-            ;
         }
     }
     pub fn findProgram(self: &Builder, names: []const []const u8, paths: []const []const u8) ![]const u8 {
         // TODO report error for ambiguous situations
-        const exe_extension = (Target { .Native = {}}).exeFileExt();
+        const exe_extension = (Target{ .Native = {} }).exeFileExt();
         for (self.search_prefixes.toSliceConst()) |search_prefix| {
             for (names) |name| {
                 if (os.path.isAbsolute(name)) {
                     return name;
                 }
-                const full_path = try os.path.join(self.allocator, search_prefix, "bin",
+                const full_path = try os.path.join(self.allocator, search_prefix, "bin", self.fmt("{}{}", name, exe_extension));
-                    self.fmt("{}{}", name, exe_extension));
                 if (os.path.real(self.allocator, full_path)) |real_path| {
                     return real_path;
                 } else |_| {
 @@ -761,7 +749,7 @@ pub const Target = union(enum) {
     Cross: CrossTarget,
     pub fn oFileExt(self: &const Target) []const u8 {
-        const environ = switch (*self) {
+        const environ = switch (self.*) {
             Target.Native => builtin.environ,
             Target.Cross => |t| t.environ,
         };
 @@ -786,7 +774,7 @@ pub const Target = union(enum) {
     }
     pub fn getOs(self: &const Target) builtin.Os {
-        return switch (*self) {
+        return switch (self.*) {
             Target.Native => builtin.os,
             Target.Cross => |t| t.os,
         };
 @@ -794,7 +782,8 @@ pub const Target = union(enum) {
     pub fn isDarwin(self: &const Target) bool {
         return switch (self.getOs()) {
-            builtin.Os.ios, builtin.Os.macosx => true,
+            builtin.Os.ios,
+            builtin.Os.macosx => true,
             else => false,
         };
     }
 @@ -860,61 +849,57 @@ pub const LibExeObjStep = struct {
         Obj,
     };
-    pub fn createSharedLibrary(builder: &Builder, name: []const u8, root_src: ?[]const u8,
+    pub fn createSharedLibrary(builder: &Builder, name: []const u8, root_src: ?[]const u8, ver: &const Version) &LibExeObjStep {
-        ver: &const Version) &LibExeObjStep
-    {
         const self = builder.allocator.create(LibExeObjStep) catch unreachable;
-        *self = initExtraArgs(builder, name, root_src, Kind.Lib, false, ver);
+        self.* = initExtraArgs(builder, name, root_src, Kind.Lib, false, ver);
         return self;
     }
     pub fn createCSharedLibrary(builder: &Builder, name: []const u8, version: &const Version) &LibExeObjStep {
         const self = builder.allocator.create(LibExeObjStep) catch unreachable;
-        *self = initC(builder, name, Kind.Lib, version, false);
+        self.* = initC(builder, name, Kind.Lib, version, false);
         return self;
     }
     pub fn createStaticLibrary(builder: &Builder, name: []const u8, root_src: ?[]const u8) &LibExeObjStep {
         const self = builder.allocator.create(LibExeObjStep) catch unreachable;
-        *self = initExtraArgs(builder, name, root_src, Kind.Lib, true, builder.version(0, 0, 0));
+        self.* = initExtraArgs(builder, name, root_src, Kind.Lib, true, builder.version(0, 0, 0));
         return self;
     }
     pub fn createCStaticLibrary(builder: &Builder, name: []const u8) &LibExeObjStep {
         const self = builder.allocator.create(LibExeObjStep) catch unreachable;
-        *self = initC(builder, name, Kind.Lib, builder.version(0, 0, 0), true);
+        self.* = initC(builder, name, Kind.Lib, builder.version(0, 0, 0), true);
         return self;
     }
     pub fn createObject(builder: &Builder, name: []const u8, root_src: []const u8) &LibExeObjStep {
         const self = builder.allocator.create(LibExeObjStep) catch unreachable;
-        *self = initExtraArgs(builder, name, root_src, Kind.Obj, false, builder.version(0, 0, 0));
+        self.* = initExtraArgs(builder, name, root_src, Kind.Obj, false, builder.version(0, 0, 0));
         return self;
     }
     pub fn createCObject(builder: &Builder, name: []const u8, src: []const u8) &LibExeObjStep {
         const self = builder.allocator.create(LibExeObjStep) catch unreachable;
-        *self = initC(builder, name, Kind.Obj, builder.version(0, 0, 0), false);
+        self.* = initC(builder, name, Kind.Obj, builder.version(0, 0, 0), false);
         self.object_src = src;
         return self;
     }
     pub fn createExecutable(builder: &Builder, name: []const u8, root_src: ?[]const u8) &LibExeObjStep {
         const self = builder.allocator.create(LibExeObjStep) catch unreachable;
-        *self = initExtraArgs(builder, name, root_src, Kind.Exe, false, builder.version(0, 0, 0));
+        self.* = initExtraArgs(builder, name, root_src, Kind.Exe, false, builder.version(0, 0, 0));
         return self;
     }
     pub fn createCExecutable(builder: &Builder, name: []const u8) &LibExeObjStep {
         const self = builder.allocator.create(LibExeObjStep) catch unreachable;
-        *self = initC(builder, name, Kind.Exe, builder.version(0, 0, 0), false);
+        self.* = initC(builder, name, Kind.Exe, builder.version(0, 0, 0), false);
         return self;
     }
-    fn initExtraArgs(builder: &Builder, name: []const u8, root_src: ?[]const u8, kind: Kind,
+    fn initExtraArgs(builder: &Builder, name: []const u8, root_src: ?[]const u8, kind: Kind, static: bool, ver: &const Version) LibExeObjStep {
-        static: bool, ver: &const Version) LibExeObjStep
+        var self = LibExeObjStep{
-    {
-        var self = LibExeObjStep {
             .strip = false,
             .builder = builder,
             .verbose_link = false,
 @@ -930,7 +915,7 @@ pub const LibExeObjStep = struct {
             .step = Step.init(name, builder.allocator, make),
             .output_path = null,
             .output_h_path = null,
-            .version = *ver,
+            .version = ver.*,
             .out_filename = undefined,
             .out_h_filename = builder.fmt("{}.h", name),
             .major_only_filename = undefined,
 @@ -953,11 +938,11 @@ pub const LibExeObjStep = struct {
     }
     fn initC(builder: &Builder, name: []const u8, kind: Kind, version: &const Version, static: bool) LibExeObjStep {
-        var self = LibExeObjStep {
+        var self = LibExeObjStep{
             .builder = builder,
             .name = name,
             .kind = kind,
-            .version = *version,
+            .version = version.*,
             .static = static,
             .target = Target.Native,
             .cflags = ArrayList([]const u8).init(builder.allocator),
 @@ -1005,9 +990,9 @@ pub const LibExeObjStep = struct {
                     self.out_filename = self.builder.fmt("lib{}.a", self.name);
                 } else {
                     switch (self.target.getOs()) {
-                        builtin.Os.ios, builtin.Os.macosx => {
+                        builtin.Os.ios,
-                            self.out_filename = self.builder.fmt("lib{}.{d}.{d}.{d}.dylib",
+                        builtin.Os.macosx => {
-                                self.name, self.version.major, self.version.minor, self.version.patch);
+                            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);
                         },
 @@ -1015,8 +1000,7 @@ pub const LibExeObjStep = struct {
                             self.out_filename = self.builder.fmt("{}.dll", self.name);
                         },
                         else => {
-                            self.out_filename = self.builder.fmt("lib{}.so.{d}.{d}.{d}",
+                            self.out_filename = self.builder.fmt("lib{}.so.{d}.{d}.{d}", self.name, self.version.major, self.version.minor, self.version.patch);
-                                self.name, self.version.major, self.version.minor, self.version.patch);
                             self.major_only_filename = self.builder.fmt("lib{}.so.{d}", self.name, self.version.major);
                             self.name_only_filename = self.builder.fmt("lib{}.so", self.name);
                         },
 @@ -1026,16 +1010,12 @@ pub const LibExeObjStep = struct {
         }
     }
-    pub fn setTarget(self: &LibExeObjStep, target_arch: builtin.Arch, target_os: builtin.Os,
+    pub fn setTarget(self: &LibExeObjStep, target_arch: builtin.Arch, target_os: builtin.Os, target_environ: builtin.Environ) void {
-        target_environ: builtin.Environ) void
+        self.target = Target{ .Cross = CrossTarget{
-    {
+            .arch = target_arch,
-        self.target = Target {
+            .os = target_os,
-            .Cross = CrossTarget {
+            .environ = target_environ,
-                .arch = target_arch,
+        } };
-                .os = target_os,
-                .environ = target_environ,
-            }
-        };
         self.computeOutFileNames();
     }
 @@ -1159,7 +1139,7 @@ pub const LibExeObjStep = struct {
     pub fn addPackagePath(self: &LibExeObjStep, name: []const u8, pkg_index_path: []const u8) void {
         assert(self.is_zig);
-        self.packages.append(Pkg {
+        self.packages.append(Pkg{
             .name = name,
             .path = pkg_index_path,
         }) catch unreachable;
 @@ -1343,8 +1323,7 @@ pub const LibExeObjStep = struct {
         try builder.spawnChild(zig_args.toSliceConst());
         if (self.kind == Kind.Lib and !self.static and self.target.wantSharedLibSymLinks()) {
-            try doAtomicSymLinks(builder.allocator, output_path, self.major_only_filename,
+            try doAtomicSymLinks(builder.allocator, output_path, self.major_only_filename, self.name_only_filename);
-                self.name_only_filename);
         }
     }
 @@ -1373,7 +1352,8 @@ pub const LibExeObjStep = struct {
                     args.append("ssp-buffer-size=4") catch unreachable;
                 }
             },
-            builtin.Mode.ReleaseFast, builtin.Mode.ReleaseSmall => {
+            builtin.Mode.ReleaseFast,
+            builtin.Mode.ReleaseSmall => {
                 args.append("-O2") catch unreachable;
                 args.append("-fno-stack-protector") catch unreachable;
             },
 @@ -1505,8 +1485,7 @@ pub const LibExeObjStep = struct {
                     }
                     if (!is_darwin) {
-                        const rpath_arg = builder.fmt("-Wl,-rpath,{}",
+                        const rpath_arg = builder.fmt("-Wl,-rpath,{}", os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)) catch unreachable);
-                            os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)) catch unreachable);
                         defer builder.allocator.free(rpath_arg);
                         cc_args.append(rpath_arg) catch unreachable;
 @@ -1535,8 +1514,7 @@ pub const LibExeObjStep = struct {
                     try builder.spawnChild(cc_args.toSliceConst());
                     if (self.target.wantSharedLibSymLinks()) {
-                        try doAtomicSymLinks(builder.allocator, output_path, self.major_only_filename,
+                        try doAtomicSymLinks(builder.allocator, output_path, self.major_only_filename, self.name_only_filename);
-                            self.name_only_filename);
                     }
                 }
             },
 @@ -1581,8 +1559,7 @@ pub const LibExeObjStep = struct {
                 cc_args.append("-o") catch unreachable;
                 cc_args.append(output_path) catch unreachable;
-                const rpath_arg = builder.fmt("-Wl,-rpath,{}",
+                const rpath_arg = builder.fmt("-Wl,-rpath,{}", os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)) catch unreachable);
-                    os.path.real(builder.allocator, builder.pathFromRoot(builder.cache_root)) catch unreachable);
                 defer builder.allocator.free(rpath_arg);
                 cc_args.append(rpath_arg) catch unreachable;
 @@ -1635,7 +1612,7 @@ pub const TestStep = struct {
     pub fn init(builder: &Builder, root_src: []const u8) TestStep {
         const step_name = builder.fmt("test {}", root_src);
-        return TestStep {
+        return TestStep{
             .step = Step.init(step_name, builder.allocator, make),
             .builder = builder,
             .root_src = root_src,
 @@ -1644,7 +1621,7 @@ pub const TestStep = struct {
             .name_prefix = "",
             .filter = null,
             .link_libs = BufSet.init(builder.allocator),
-            .target = Target { .Native = {} },
+            .target = Target{ .Native = {} },
             .exec_cmd_args = null,
             .include_dirs = ArrayList([]const u8).init(builder.allocator),
         };
 @@ -1674,16 +1651,12 @@ pub const TestStep = struct {
         self.filter = text;
     }
-    pub fn setTarget(self: &TestStep, target_arch: builtin.Arch, target_os: builtin.Os,
+    pub fn setTarget(self: &TestStep, target_arch: builtin.Arch, target_os: builtin.Os, target_environ: builtin.Environ) void {
-        target_environ: builtin.Environ) void
+        self.target = Target{ .Cross = CrossTarget{
-    {
+            .arch = target_arch,
-        self.target = Target {
+            .os = target_os,
-            .Cross = CrossTarget {
+            .environ = target_environ,
-                .arch = target_arch,
+        } };
-                .os = target_os,
-                .environ = target_environ,
-            }
-        };
     }
     pub fn setExecCmd(self: &TestStep, args: []const ?[]const u8) void {
 @@ -1789,11 +1762,9 @@ pub const CommandStep = struct {
     env_map: &const BufMap,
     /// ::argv is copied.
-    pub fn create(builder: &Builder, cwd: ?[]const u8, env_map: &const BufMap,
+    pub fn create(builder: &Builder, cwd: ?[]const u8, env_map: &const BufMap, argv: []const []const u8) &CommandStep {
-        argv: []const []const u8) &CommandStep
-    {
         const self = builder.allocator.create(CommandStep) catch unreachable;
-        *self = CommandStep {
+        self.* = CommandStep{
             .builder = builder,
             .step = Step.init(argv[0], builder.allocator, make),
             .argv = builder.allocator.alloc([]u8, argv.len) catch unreachable,
 @@ -1828,7 +1799,7 @@ const InstallArtifactStep = struct {
             LibExeObjStep.Kind.Exe => builder.exe_dir,
             LibExeObjStep.Kind.Lib => builder.lib_dir,
         };
-        *self = Self {
+        self.* = Self{
             .builder = builder,
             .step = Step.init(builder.fmt("install {}", artifact.step.name), builder.allocator, make),
             .artifact = artifact,
 @@ -1837,10 +1808,8 @@ const InstallArtifactStep = struct {
         self.step.dependOn(&artifact.step);
         builder.pushInstalledFile(self.dest_file);
         if (self.artifact.kind == LibExeObjStep.Kind.Lib and !self.artifact.static) {
-            builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir,
+            builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir, artifact.major_only_filename) catch unreachable);
-                artifact.major_only_filename) catch unreachable);
+            builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir, artifact.name_only_filename) catch unreachable);
-            builder.pushInstalledFile(os.path.join(builder.allocator, builder.lib_dir,
-                artifact.name_only_filename) catch unreachable);
         }
         return self;
     }
 @@ -1859,8 +1828,7 @@ const InstallArtifactStep = struct {
         };
         try builder.copyFileMode(self.artifact.getOutputPath(), self.dest_file, mode);
         if (self.artifact.kind == LibExeObjStep.Kind.Lib and !self.artifact.static) {
-            try doAtomicSymLinks(builder.allocator, self.dest_file,
+            try doAtomicSymLinks(builder.allocator, self.dest_file, self.artifact.major_only_filename, self.artifact.name_only_filename);
-                self.artifact.major_only_filename, self.artifact.name_only_filename);
         }
     }
 };
 @@ -1872,7 +1840,7 @@ pub const InstallFileStep = struct {
     dest_path: []const u8,
     pub fn init(builder: &Builder, src_path: []const u8, dest_path: []const u8) InstallFileStep {
-        return InstallFileStep {
+        return InstallFileStep{
             .builder = builder,
             .step = Step.init(builder.fmt("install {}", src_path), builder.allocator, make),
             .src_path = src_path,
 @@ -1893,7 +1861,7 @@ pub const WriteFileStep = struct {
     data: []const u8,
     pub fn init(builder: &Builder, file_path: []const u8, data: []const u8) WriteFileStep {
-        return WriteFileStep {
+        return WriteFileStep{
             .builder = builder,
             .step = Step.init(builder.fmt("writefile {}", file_path), builder.allocator, make),
             .file_path = file_path,
 @@ -1922,7 +1890,7 @@ pub const LogStep = struct {
     data: []const u8,
     pub fn init(builder: &Builder, data: []const u8) LogStep {
-        return LogStep {
+        return LogStep{
             .builder = builder,
             .step = Step.init(builder.fmt("log {}", data), builder.allocator, make),
             .data = data,
 @@ -1941,7 +1909,7 @@ pub const RemoveDirStep = struct {
     dir_path: []const u8,
     pub fn init(builder: &Builder, dir_path: []const u8) RemoveDirStep {
-        return RemoveDirStep {
+        return RemoveDirStep{
             .builder = builder,
             .step = Step.init(builder.fmt("RemoveDir {}", dir_path), builder.allocator, make),
             .dir_path = dir_path,
 @@ -1966,8 +1934,8 @@ pub const Step = struct {
     loop_flag: bool,
     done_flag: bool,
-    pub fn init(name: []const u8, allocator: &Allocator, makeFn: fn (&Step)error!void) Step {
+    pub fn init(name: []const u8, allocator: &Allocator, makeFn: fn(&Step) error!void) Step {
-        return Step {
+        return Step{
             .name = name,
             .makeFn = makeFn,
             .dependencies = ArrayList(&Step).init(allocator),
 @@ -1980,8 +1948,7 @@ pub const Step = struct {
     }
     pub fn make(self: &Step) !void {
-        if (self.done_flag)
+        if (self.done_flag) return;
-            return;
         try self.makeFn(self);
         self.done_flag = true;
 @@ -1994,9 +1961,7 @@ pub const Step = struct {
     fn makeNoOp(self: &Step) error!void {}
 };
-fn doAtomicSymLinks(allocator: &Allocator, output_path: []const u8, filename_major_only: []const u8,
+fn doAtomicSymLinks(allocator: &Allocator, output_path: []const u8, filename_major_only: []const u8, filename_name_only: []const u8) !void {
-    filename_name_only: []const u8) !void
-{
     const out_dir = os.path.dirname(output_path);
     const out_basename = os.path.basename(output_path);
     // sym link for libfoo.so.1 to libfoo.so.1.2.3

std/crypto/blake2.zig+470-241

...	@@ -6,11 +6,23 @@ const builtin = @import("builtin");	...	@@ -6,11 +6,23 @@ const builtin = @import("builtin");
6	const htest = @import("test.zig");	6	const htest = @import("test.zig");
7		7
8	const RoundParam = struct {	8	const RoundParam = struct {
9	a: usize, b: usize, c: usize, d: usize, x: usize, y: usize,	9	a: usize,
		10	b: usize,
		11	c: usize,
		12	d: usize,
		13	x: usize,
		14	y: usize,
10	};	15	};
11		16
12	fn Rp(a: usize, b: usize, c: usize, d: usize, x: usize, y: usize) RoundParam {	17	fn Rp(a: usize, b: usize, c: usize, d: usize, x: usize, y: usize) RoundParam {
13	return RoundParam { .a = a, .b = b, .c = c, .d = d, .x = x, .y = y, };	18	return RoundParam{
		19	.a = a,
		20	.b = b,
		21	.c = c,
		22	.d = d,
		23	.x = x,
		24	.y = y,
		25	};
14	}	26	}
15		27
16	/////////////////////	28	/////////////////////
...	@@ -19,145 +31,153 @@ fn Rp(a: usize, b: usize, c: usize, d: usize, x: usize, y: usize) RoundParam {	...	@@ -19,145 +31,153 @@ fn Rp(a: usize, b: usize, c: usize, d: usize, x: usize, y: usize) RoundParam {
19	pub const Blake2s224 = Blake2s(224);	31	pub const Blake2s224 = Blake2s(224);
20	pub const Blake2s256 = Blake2s(256);	32	pub const Blake2s256 = Blake2s(256);
21		33
22	fn Blake2s(comptime out_len: usize) type { return struct {	34	fn Blake2s(comptime out_len: usize) type {
23	const Self = this;	35	return struct {
24	const block_size = 64;	36	const Self = this;
25	const digest_size = out_len / 8;	37	const block_size = 64;
		38	const digest_size = out_len / 8;
		39
		40	const iv = [8]u32{
		41	0x6A09E667,
		42	0xBB67AE85,
		43	0x3C6EF372,
		44	0xA54FF53A,
		45	0x510E527F,
		46	0x9B05688C,
		47	0x1F83D9AB,
		48	0x5BE0CD19,
		49	};
26		50
27	const iv = [8]u32 {	51	const sigma = [10][16]u8{
28	0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,	52	[]const u8 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
29	0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19,	53	[]const u8 { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
30	};	54	[]const u8 { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
		55	[]const u8 { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
		56	[]const u8 { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
		57	[]const u8 { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
		58	[]const u8 { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
		59	[]const u8 { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
		60	[]const u8 { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
		61	[]const u8 { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
		62	};
31		63
32	const sigma = [10][16]u8 {	64	h: [8]u32,
33	[]const u8 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },	65	t: u64,
34	[]const u8 { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },	66	// Streaming cache
35	[]const u8 { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },	67	buf: [64]u8,
36	[]const u8 { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },	68	buf_len: u8,
37	[]const u8 { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
38	[]const u8 { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
39	[]const u8 { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
40	[]const u8 { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
41	[]const u8 { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
42	[]const u8 { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
43	};
44		69
45	h: [8]u32,	70	pub fn init() Self {
46	t: u64,	71	debug.assert(8 <= out_len and out_len <= 512);
47	// Streaming cache	72
48	buf: [64]u8,	73	var s: Self = undefined;
49	buf_len: u8,	74	s.reset();
50		75	return s;
51	pub fn init() Self {
52	debug.assert(8 <= out_len and out_len <= 512);
53
54	var s: Self = undefined;
55	s.reset();
56	return s;
57	}
58
59	pub fn reset(d: &Self) void {
60	mem.copy(u32, d.h[0..], iv[0..]);
61
62	// No key plus default parameters
63	d.h[0] ^= 0x01010000 ^ u32(out_len >> 3);
64	d.t = 0;
65	d.buf_len = 0;
66	}
67
68	pub fn hash(b: []const u8, out: []u8) void {
69	var d = Self.init();
70	d.update(b);
71	d.final(out);
72	}
73
74	pub fn update(d: &Self, b: []const u8) void {
75	var off: usize = 0;
76
77	// Partial buffer exists from previous update. Copy into buffer then hash.
78	if (d.buf_len != 0 and d.buf_len + b.len > 64) {
79	off += 64 - d.buf_len;
80	mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
81	d.t += 64;
82	d.round(d.buf[0..], false);
83	d.buf_len = 0;
84	}	76	}
85		77
86	// Full middle blocks.	78	pub fn reset(d: &Self) void {
87	while (off + 64 <= b.len) : (off += 64) {	79	mem.copy(u32, d.h[0..], iv[0..]);
88	d.t += 64;	80
89	d.round(b[off..off + 64], false);	81	// No key plus default parameters
		82	d.h[0] ^= 0x01010000 ^ u32(out_len >> 3);
		83	d.t = 0;
		84	d.buf_len = 0;
90	}	85	}
91		86
92	// Copy any remainder for next pass.	87	pub fn hash(b: []const u8, out: []u8) void {
93	mem.copy(u8, d.buf[d.buf_len..], b[off..]);	88	var d = Self.init();
94	d.buf_len += u8(b[off..].len);	89	d.update(b);
95	}	90	d.final(out);
		91	}
96		92
97	pub fn final(d: &Self, out: []u8) void {	93	pub fn update(d: &Self, b: []const u8) void {
98	debug.assert(out.len >= out_len / 8);	94	var off: usize = 0;
99		95
100	mem.set(u8, d.buf[d.buf_len..], 0);	96	// Partial buffer exists from previous update. Copy into buffer then hash.
101	d.t += d.buf_len;	97	if (d.buf_len != 0 and d.buf_len + b.len > 64) {
102	d.round(d.buf[0..], true);	98	off += 64 - d.buf_len;
		99	mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
		100	d.t += 64;
		101	d.round(d.buf[0..], false);
		102	d.buf_len = 0;
		103	}
103		104
104	const rr = d.h[0 .. out_len / 32];	105	// Full middle blocks.
		106	while (off + 64 <= b.len) : (off += 64) {
		107	d.t += 64;
		108	d.round(b[off..off + 64], false);
		109	}
105		110
106	for (rr) \|s, j\| {	111	// Copy any remainder for next pass.
107	mem.writeInt(out[4j .. 4j + 4], s, builtin.Endian.Little);	112	mem.copy(u8, d.buf[d.buf_len..], b[off..]);
		113	d.buf_len += u8(b[off..].len);
108	}	114	}
109	}
110		115
111	fn round(d: &Self, b: []const u8, last: bool) void {	116	pub fn final(d: &Self, out: []u8) void {
112	debug.assert(b.len == 64);	117	debug.assert(out.len >= out_len / 8);
113		118
114	var m: [16]u32 = undefined;	119	mem.set(u8, d.buf[d.buf_len..], 0);
115	var v: [16]u32 = undefined;	120	d.t += d.buf_len;
		121	d.round(d.buf[0..], true);
116		122
117	for (m) \|*r, i\| {	123	const rr = d.h[0..out_len / 32];
118	r = mem.readIntLE(u32, b[4i .. 4*i + 4]);
119	}
120		124
121	var k: usize = 0;	125	for (rr) \|s, j\| {
122	while (k < 8) : (k += 1) {	126	mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Little);
123	v[k] = d.h[k];	127	}
124	v[k+8] = iv[k];
125	}	128	}
126		129
127	v[12] ^= @truncate(u32, d.t);	130	fn round(d: &Self, b: []const u8, last: bool) void {
128	v[13] ^= u32(d.t >> 32);	131	debug.assert(b.len == 64);
129	if (last) v[14] = ~v[14];
130
131	const rounds = comptime []RoundParam {
132	Rp(0, 4, 8, 12, 0, 1),
133	Rp(1, 5, 9, 13, 2, 3),
134	Rp(2, 6, 10, 14, 4, 5),
135	Rp(3, 7, 11, 15, 6, 7),
136	Rp(0, 5, 10, 15, 8, 9),
137	Rp(1, 6, 11, 12, 10, 11),
138	Rp(2, 7, 8, 13, 12, 13),
139	Rp(3, 4, 9, 14, 14, 15),
140	};
141		132
142	comptime var j: usize = 0;	133	var m: [16]u32 = undefined;
143	inline while (j < 10) : (j += 1) {	134	var v: [16]u32 = undefined;
144	inline for (rounds) \|r\| {	135
145	v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.x]];	136	for (m) \|*r, i\| {
146	v[r.d] = math.rotr(u32, v[r.d] ^ v[r.a], usize(16));	137	r.* = mem.readIntLE(u32, b[4 * i..4 * i + 4]);
147	v[r.c] = v[r.c] +% v[r.d];
148	v[r.b] = math.rotr(u32, v[r.b] ^ v[r.c], usize(12));
149	v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.y]];
150	v[r.d] = math.rotr(u32, v[r.d] ^ v[r.a], usize(8));
151	v[r.c] = v[r.c] +% v[r.d];
152	v[r.b] = math.rotr(u32, v[r.b] ^ v[r.c], usize(7));
153	}	138	}
154	}
155		139
156	for (d.h) \|*r, i\| {	140	var k: usize = 0;
157	*r ^= v[i] ^ v[i + 8];	141	while (k < 8) : (k += 1) {
		142	v[k] = d.h[k];
		143	v[k + 8] = iv[k];
		144	}
		145
		146	v[12] ^= @truncate(u32, d.t);
		147	v[13] ^= u32(d.t >> 32);
		148	if (last) v[14] = ~v[14];
		149
		150	const rounds = comptime []RoundParam{
		151	Rp(0, 4, 8, 12, 0, 1),
		152	Rp(1, 5, 9, 13, 2, 3),
		153	Rp(2, 6, 10, 14, 4, 5),
		154	Rp(3, 7, 11, 15, 6, 7),
		155	Rp(0, 5, 10, 15, 8, 9),
		156	Rp(1, 6, 11, 12, 10, 11),
		157	Rp(2, 7, 8, 13, 12, 13),
		158	Rp(3, 4, 9, 14, 14, 15),
		159	};
		160
		161	comptime var j: usize = 0;
		162	inline while (j < 10) : (j += 1) {
		163	inline for (rounds) \|r\| {
		164	v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.x]];
		165	v[r.d] = math.rotr(u32, v[r.d] ^ v[r.a], usize(16));
		166	v[r.c] = v[r.c] +% v[r.d];
		167	v[r.b] = math.rotr(u32, v[r.b] ^ v[r.c], usize(12));
		168	v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.y]];
		169	v[r.d] = math.rotr(u32, v[r.d] ^ v[r.a], usize(8));
		170	v[r.c] = v[r.c] +% v[r.d];
		171	v[r.b] = math.rotr(u32, v[r.b] ^ v[r.c], usize(7));
		172	}
		173	}
		174
		175	for (d.h) \|*r, i\| {
		176	r.* ^= v[i] ^ v[i + 8];
		177	}
158	}	178	}
159	}	179	};
160	};}	180	}
161		181
162	test "blake2s224 single" {	182	test "blake2s224 single" {
163	const h1 = "1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4";	183	const h1 = "1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4";
...	@@ -230,7 +250,7 @@ test "blake2s256 streaming" {	...	@@ -230,7 +250,7 @@ test "blake2s256 streaming" {
230	}	250	}
231		251
232	test "blake2s256 aligned final" {	252	test "blake2s256 aligned final" {
233	var block = []u8 {0} ** Blake2s256.block_size;	253	var block = []u8{0} ** Blake2s256.block_size;
234	var out: [Blake2s256.digest_size]u8 = undefined;	254	var out: [Blake2s256.digest_size]u8 = undefined;
235		255
236	var h = Blake2s256.init();	256	var h = Blake2s256.init();
...	@@ -238,154 +258,363 @@ test "blake2s256 aligned final" {	...	@@ -238,154 +258,363 @@ test "blake2s256 aligned final" {
238	h.final(out[0..]);	258	h.final(out[0..]);
239	}	259	}
240		260
241
242	/////////////////////	261	/////////////////////
243	// Blake2b	262	// Blake2b
244		263
245	pub const Blake2b384 = Blake2b(384);	264	pub const Blake2b384 = Blake2b(384);
246	pub const Blake2b512 = Blake2b(512);	265	pub const Blake2b512 = Blake2b(512);
247		266
248	fn Blake2b(comptime out_len: usize) type { return struct {	267	fn Blake2b(comptime out_len: usize) type {
249	const Self = this;	268	return struct {
250	const block_size = 128;	269	const Self = this;
251	const digest_size = out_len / 8;	270	const block_size = 128;
		271	const digest_size = out_len / 8;
		272
		273	const iv = [8]u64{
		274	0x6a09e667f3bcc908,
		275	0xbb67ae8584caa73b,
		276	0x3c6ef372fe94f82b,
		277	0xa54ff53a5f1d36f1,
		278	0x510e527fade682d1,
		279	0x9b05688c2b3e6c1f,
		280	0x1f83d9abfb41bd6b,
		281	0x5be0cd19137e2179,
		282	};
252		283
253	const iv = [8]u64 {	284	const sigma = [12][16]u8{
254	0x6a09e667f3bcc908, 0xbb67ae8584caa73b,	285	[]const u8{
255	0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,	286	0,
256	0x510e527fade682d1, 0x9b05688c2b3e6c1f,	287	1,
257	0x1f83d9abfb41bd6b, 0x5be0cd19137e2179,	288	2,
258	};	289	3,
		290	4,
		291	5,
		292	6,
		293	7,
		294	8,
		295	9,
		296	10,
		297	11,
		298	12,
		299	13,
		300	14,
		301	15,
		302	},
		303	[]const u8{
		304	14,
		305	10,
		306	4,
		307	8,
		308	9,
		309	15,
		310	13,
		311	6,
		312	1,
		313	12,
		314	0,
		315	2,
		316	11,
		317	7,
		318	5,
		319	3,
		320	},
		321	[]const u8{
		322	11,
		323	8,
		324	12,
		325	0,
		326	5,
		327	2,
		328	15,
		329	13,
		330	10,
		331	14,
		332	3,
		333	6,
		334	7,
		335	1,
		336	9,
		337	4,
		338	},
		339	[]const u8{
		340	7,
		341	9,
		342	3,
		343	1,
		344	13,
		345	12,
		346	11,
		347	14,
		348	2,
		349	6,
		350	5,
		351	10,
		352	4,
		353	0,
		354	15,
		355	8,
		356	},
		357	[]const u8{
		358	9,
		359	0,
		360	5,
		361	7,
		362	2,
		363	4,
		364	10,
		365	15,
		366	14,
		367	1,
		368	11,
		369	12,
		370	6,
		371	8,
		372	3,
		373	13,
		374	},
		375	[]const u8{
		376	2,
		377	12,
		378	6,
		379	10,
		380	0,
		381	11,
		382	8,
		383	3,
		384	4,
		385	13,
		386	7,
		387	5,
		388	15,
		389	14,
		390	1,
		391	9,
		392	},
		393	[]const u8{
		394	12,
		395	5,
		396	1,
		397	15,
		398	14,
		399	13,
		400	4,
		401	10,
		402	0,
		403	7,
		404	6,
		405	3,
		406	9,
		407	2,
		408	8,
		409	11,
		410	},
		411	[]const u8{
		412	13,
		413	11,
		414	7,
		415	14,
		416	12,
		417	1,
		418	3,
		419	9,
		420	5,
		421	0,
		422	15,
		423	4,
		424	8,
		425	6,
		426	2,
		427	10,
		428	},
		429	[]const u8{
		430	6,
		431	15,
		432	14,
		433	9,
		434	11,
		435	3,
		436	0,
		437	8,
		438	12,
		439	2,
		440	13,
		441	7,
		442	1,
		443	4,
		444	10,
		445	5,
		446	},
		447	[]const u8{
		448	10,
		449	2,
		450	8,
		451	4,
		452	7,
		453	6,
		454	1,
		455	5,
		456	15,
		457	11,
		458	9,
		459	14,
		460	3,
		461	12,
		462	13,
		463	0,
		464	},
		465	[]const u8{
		466	0,
		467	1,
		468	2,
		469	3,
		470	4,
		471	5,
		472	6,
		473	7,
		474	8,
		475	9,
		476	10,
		477	11,
		478	12,
		479	13,
		480	14,
		481	15,
		482	},
		483	[]const u8{
		484	14,
		485	10,
		486	4,
		487	8,
		488	9,
		489	15,
		490	13,
		491	6,
		492	1,
		493	12,
		494	0,
		495	2,
		496	11,
		497	7,
		498	5,
		499	3,
		500	},
		501	};
259		502
260	const sigma = [12][16]u8 {	503	h: [8]u64,
261	[]const u8 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },	504	t: u128,
262	[]const u8 { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },	505	// Streaming cache
263	[]const u8 { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },	506	buf: [128]u8,
264	[]const u8 { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },	507	buf_len: u8,
265	[]const u8 { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
266	[]const u8 { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
267	[]const u8 { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
268	[]const u8 { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
269	[]const u8 { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
270	[]const u8 { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 },
271	[]const u8 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
272	[]const u8 { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
273	};
274		508
275	h: [8]u64,	509	pub fn init() Self {
276	t: u128,	510	debug.assert(8 <= out_len and out_len <= 512);
277	// Streaming cache	511
278	buf: [128]u8,	512	var s: Self = undefined;
279	buf_len: u8,	513	s.reset();
280		514	return s;
281	pub fn init() Self {	515	}
282	debug.assert(8 <= out_len and out_len <= 512);	516
283		517	pub fn reset(d: &Self) void {
284	var s: Self = undefined;	518	mem.copy(u64, d.h[0..], iv[0..]);
285	s.reset();	519
286	return s;	520	// No key plus default parameters
287	}	521	d.h[0] ^= 0x01010000 ^ (out_len >> 3);
288		522	d.t = 0;
289	pub fn reset(d: &Self) void {
290	mem.copy(u64, d.h[0..], iv[0..]);
291
292	// No key plus default parameters
293	d.h[0] ^= 0x01010000 ^ (out_len >> 3);
294	d.t = 0;
295	d.buf_len = 0;
296	}
297
298	pub fn hash(b: []const u8, out: []u8) void {
299	var d = Self.init();
300	d.update(b);
301	d.final(out);
302	}
303
304	pub fn update(d: &Self, b: []const u8) void {
305	var off: usize = 0;
306
307	// Partial buffer exists from previous update. Copy into buffer then hash.
308	if (d.buf_len != 0 and d.buf_len + b.len > 128) {
309	off += 128 - d.buf_len;
310	mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
311	d.t += 128;
312	d.round(d.buf[0..], false);
313	d.buf_len = 0;	523	d.buf_len = 0;
314	}	524	}
315		525
316	// Full middle blocks.	526	pub fn hash(b: []const u8, out: []u8) void {
317	while (off + 128 <= b.len) : (off += 128) {	527	var d = Self.init();
318	d.t += 128;	528	d.update(b);
319	d.round(b[off..off + 128], false);	529	d.final(out);
320	}	530	}
321		531
322	// Copy any remainder for next pass.	532	pub fn update(d: &Self, b: []const u8) void {
323	mem.copy(u8, d.buf[d.buf_len..], b[off..]);	533	var off: usize = 0;
324	d.buf_len += u8(b[off..].len);
325	}
326		534
327	pub fn final(d: &Self, out: []u8) void {	535	// Partial buffer exists from previous update. Copy into buffer then hash.
328	mem.set(u8, d.buf[d.buf_len..], 0);	536	if (d.buf_len != 0 and d.buf_len + b.len > 128) {
329	d.t += d.buf_len;	537	off += 128 - d.buf_len;
330	d.round(d.buf[0..], true);	538	mem.copy(u8, d.buf[d.buf_len..], b[0..off]);
		539	d.t += 128;
		540	d.round(d.buf[0..], false);
		541	d.buf_len = 0;
		542	}
331		543
332	const rr = d.h[0 .. out_len / 64];	544	// Full middle blocks.
		545	while (off + 128 <= b.len) : (off += 128) {
		546	d.t += 128;
		547	d.round(b[off..off + 128], false);
		548	}
333		549
334	for (rr) \|s, j\| {	550	// Copy any remainder for next pass.
335	mem.writeInt(out[8j .. 8j + 8], s, builtin.Endian.Little);	551	mem.copy(u8, d.buf[d.buf_len..], b[off..]);
		552	d.buf_len += u8(b[off..].len);
336	}	553	}
337	}
338		554
339	fn round(d: &Self, b: []const u8, last: bool) void {	555	pub fn final(d: &Self, out: []u8) void {
340	debug.assert(b.len == 128);	556	mem.set(u8, d.buf[d.buf_len..], 0);
		557	d.t += d.buf_len;
		558	d.round(d.buf[0..], true);
341		559
342	var m: [16]u64 = undefined;	560	const rr = d.h[0..out_len / 64];
343	var v: [16]u64 = undefined;
344		561
345	for (m) \|*r, i\| {	562	for (rr) \|s, j\| {
346	r = mem.readIntLE(u64, b[8i .. 8*i + 8]);	563	mem.writeInt(out[8 * j..8 * j + 8], s, builtin.Endian.Little);
		564	}
347	}	565	}
348		566
349	var k: usize = 0;	567	fn round(d: &Self, b: []const u8, last: bool) void {
350	while (k < 8) : (k += 1) {	568	debug.assert(b.len == 128);
351	v[k] = d.h[k];
352	v[k+8] = iv[k];
353	}
354		569
355	v[12] ^= @truncate(u64, d.t);	570	var m: [16]u64 = undefined;
356	v[13] ^= u64(d.t >> 64);	571	var v: [16]u64 = undefined;
357	if (last) v[14] = ~v[14];
358
359	const rounds = comptime []RoundParam {
360	Rp(0, 4, 8, 12, 0, 1),
361	Rp(1, 5, 9, 13, 2, 3),
362	Rp(2, 6, 10, 14, 4, 5),
363	Rp(3, 7, 11, 15, 6, 7),
364	Rp(0, 5, 10, 15, 8, 9),
365	Rp(1, 6, 11, 12, 10, 11),
366	Rp(2, 7, 8, 13, 12, 13),
367	Rp(3, 4, 9, 14, 14, 15),
368	};
369		572
370	comptime var j: usize = 0;	573	for (m) \|*r, i\| {
371	inline while (j < 12) : (j += 1) {	574	r.* = mem.readIntLE(u64, b[8 * i..8 * i + 8]);
372	inline for (rounds) \|r\| {	575	}
373	v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.x]];	576
374	v[r.d] = math.rotr(u64, v[r.d] ^ v[r.a], usize(32));	577	var k: usize = 0;
375	v[r.c] = v[r.c] +% v[r.d];	578	while (k < 8) : (k += 1) {
376	v[r.b] = math.rotr(u64, v[r.b] ^ v[r.c], usize(24));	579	v[k] = d.h[k];
377	v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.y]];	580	v[k + 8] = iv[k];
378	v[r.d] = math.rotr(u64, v[r.d] ^ v[r.a], usize(16));
379	v[r.c] = v[r.c] +% v[r.d];
380	v[r.b] = math.rotr(u64, v[r.b] ^ v[r.c], usize(63));
381	}	581	}
382	}
383		582
384	for (d.h) \|*r, i\| {	583	v[12] ^= @truncate(u64, d.t);
385	*r ^= v[i] ^ v[i + 8];	584	v[13] ^= u64(d.t >> 64);
		585	if (last) v[14] = ~v[14];
		586
		587	const rounds = comptime []RoundParam{
		588	Rp(0, 4, 8, 12, 0, 1),
		589	Rp(1, 5, 9, 13, 2, 3),
		590	Rp(2, 6, 10, 14, 4, 5),
		591	Rp(3, 7, 11, 15, 6, 7),
		592	Rp(0, 5, 10, 15, 8, 9),
		593	Rp(1, 6, 11, 12, 10, 11),
		594	Rp(2, 7, 8, 13, 12, 13),
		595	Rp(3, 4, 9, 14, 14, 15),
		596	};
		597
		598	comptime var j: usize = 0;
		599	inline while (j < 12) : (j += 1) {
		600	inline for (rounds) \|r\| {
		601	v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.x]];
		602	v[r.d] = math.rotr(u64, v[r.d] ^ v[r.a], usize(32));
		603	v[r.c] = v[r.c] +% v[r.d];
		604	v[r.b] = math.rotr(u64, v[r.b] ^ v[r.c], usize(24));
		605	v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.y]];
		606	v[r.d] = math.rotr(u64, v[r.d] ^ v[r.a], usize(16));
		607	v[r.c] = v[r.c] +% v[r.d];
		608	v[r.b] = math.rotr(u64, v[r.b] ^ v[r.c], usize(63));
		609	}
		610	}
		611
		612	for (d.h) \|*r, i\| {
		613	r.* ^= v[i] ^ v[i + 8];
		614	}
386	}	615	}
387	}	616	};
388	};}	617	}
389		618
390	test "blake2b384 single" {	619	test "blake2b384 single" {
391	const h1 = "b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100";	620	const h1 = "b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100";
...	@@ -458,7 +687,7 @@ test "blake2b512 streaming" {	...	@@ -458,7 +687,7 @@ test "blake2b512 streaming" {
458	}	687	}
459		688
460	test "blake2b512 aligned final" {	689	test "blake2b512 aligned final" {
461	var block = []u8 {0} ** Blake2b512.block_size;	690	var block = []u8{0} ** Blake2b512.block_size;
462	var out: [Blake2b512.digest_size]u8 = undefined;	691	var out: [Blake2b512.digest_size]u8 = undefined;
463		692
464	var h = Blake2b512.init();	693	var h = Blake2b512.init();

std/crypto/hmac.zig+2-2

...	@@ -29,12 +29,12 @@ pub fn Hmac(comptime H: type) type {	...	@@ -29,12 +29,12 @@ pub fn Hmac(comptime H: type) type {
29		29
30	var o_key_pad: [H.block_size]u8 = undefined;	30	var o_key_pad: [H.block_size]u8 = undefined;
31	for (o_key_pad) \|*b, i\| {	31	for (o_key_pad) \|*b, i\| {
32	*b = scratch[i] ^ 0x5c;	32	b.* = scratch[i] ^ 0x5c;
33	}	33	}
34		34
35	var i_key_pad: [H.block_size]u8 = undefined;	35	var i_key_pad: [H.block_size]u8 = undefined;
36	for (i_key_pad) \|*b, i\| {	36	for (i_key_pad) \|*b, i\| {
37	*b = scratch[i] ^ 0x36;	37	b.* = scratch[i] ^ 0x36;
38	}	38	}
39		39
40	// HMAC(k, m) = H(o_key_pad \| H(i_key_pad \| message)) where \| is concatenation	40	// HMAC(k, m) = H(o_key_pad \| H(i_key_pad \| message)) where \| is concatenation

std/crypto/sha3.zig+180-101

...	@@ -10,148 +10,228 @@ pub const Sha3_256 = Keccak(256, 0x06);	...	@@ -10,148 +10,228 @@ pub const Sha3_256 = Keccak(256, 0x06);
10	pub const Sha3_384 = Keccak(384, 0x06);	10	pub const Sha3_384 = Keccak(384, 0x06);
11	pub const Sha3_512 = Keccak(512, 0x06);	11	pub const Sha3_512 = Keccak(512, 0x06);
12		12
13	fn Keccak(comptime bits: usize, comptime delim: u8) type { return struct {	13	fn Keccak(comptime bits: usize, comptime delim: u8) type {
14	const Self = this;	14	return struct {
15	const block_size = 200;	15	const Self = this;
16	const digest_size = bits / 8;	16	const block_size = 200;
17		17	const digest_size = bits / 8;
18	s: [200]u8,	18
19	offset: usize,	19	s: [200]u8,
20	rate: usize,	20	offset: usize,
21		21	rate: usize,
22	pub fn init() Self {	22
23	var d: Self = undefined;	23	pub fn init() Self {
24	d.reset();	24	var d: Self = undefined;
25	return d;	25	d.reset();
26	}	26	return d;
		27	}
27		28
28	pub fn reset(d: &Self) void {	29	pub fn reset(d: &Self) void {
29	mem.set(u8, d.s[0..], 0);	30	mem.set(u8, d.s[0..], 0);
30	d.offset = 0;	31	d.offset = 0;
31	d.rate = 200 - (bits / 4);	32	d.rate = 200 - (bits / 4);
32	}	33	}
33		34
34	pub fn hash(b: []const u8, out: []u8) void {	35	pub fn hash(b: []const u8, out: []u8) void {
35	var d = Self.init();	36	var d = Self.init();
36	d.update(b);	37	d.update(b);
37	d.final(out);	38	d.final(out);
38	}	39	}
39		40
40	pub fn update(d: &Self, b: []const u8) void {	41	pub fn update(d: &Self, b: []const u8) void {
41	var ip: usize = 0;	42	var ip: usize = 0;
42	var len = b.len;	43	var len = b.len;
43	var rate = d.rate - d.offset;	44	var rate = d.rate - d.offset;
44	var offset = d.offset;	45	var offset = d.offset;
45		46
46	// absorb	47	// absorb
47	while (len >= rate) {	48	while (len >= rate) {
48	for (d.s[offset .. offset + rate]) \|*r, i\|	49	for (d.s[offset..offset + rate]) \|*r, i\|
49	*r ^= b[ip..][i];	50	r.* ^= b[ip..][i];
50		51
51	keccak_f(1600, d.s[0..]);	52	keccak_f(1600, d.s[0..]);
52		53
53	ip += rate;	54	ip += rate;
54	len -= rate;	55	len -= rate;
55	rate = d.rate;	56	rate = d.rate;
56	offset = 0;	57	offset = 0;
57	}	58	}
58		59
59	for (d.s[offset .. offset + len]) \|*r, i\|	60	for (d.s[offset..offset + len]) \|*r, i\|
60	*r ^= b[ip..][i];	61	r.* ^= b[ip..][i];
61		62
62	d.offset = offset + len;	63	d.offset = offset + len;
63	}	64	}
64		65
65	pub fn final(d: &Self, out: []u8) void {	66	pub fn final(d: &Self, out: []u8) void {
66	// padding	67	// padding
67	d.s[d.offset] ^= delim;	68	d.s[d.offset] ^= delim;
68	d.s[d.rate - 1] ^= 0x80;	69	d.s[d.rate - 1] ^= 0x80;
69		70
70	keccak_f(1600, d.s[0..]);	71	keccak_f(1600, d.s[0..]);
71		72
72	// squeeze	73	// squeeze
73	var op: usize = 0;	74	var op: usize = 0;
74	var len: usize = bits / 8;	75	var len: usize = bits / 8;
75		76
76	while (len >= d.rate) {	77	while (len >= d.rate) {
77	mem.copy(u8, out[op..], d.s[0..d.rate]);	78	mem.copy(u8, out[op..], d.s[0..d.rate]);
78	keccak_f(1600, d.s[0..]);	79	keccak_f(1600, d.s[0..]);
79	op += d.rate;	80	op += d.rate;
80	len -= d.rate;	81	len -= d.rate;
		82	}
		83
		84	mem.copy(u8, out[op..], d.s[0..len]);
81	}	85	}
		86	};
		87	}
82		88
83	mem.copy(u8, out[op..], d.s[0..len]);	89	const RC = []const u64{
84	}	90	0x0000000000000001,
85	};}	91	0x0000000000008082,
86		92	0x800000000000808a,
87	const RC = []const u64 {	93	0x8000000080008000,
88	0x0000000000000001, 0x0000000000008082, 0x800000000000808a, 0x8000000080008000,	94	0x000000000000808b,
89	0x000000000000808b, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009,	95	0x0000000080000001,
90	0x000000000000008a, 0x0000000000000088, 0x0000000080008009, 0x000000008000000a,	96	0x8000000080008081,
91	0x000000008000808b, 0x800000000000008b, 0x8000000000008089, 0x8000000000008003,	97	0x8000000000008009,
92	0x8000000000008002, 0x8000000000000080, 0x000000000000800a, 0x800000008000000a,	98	0x000000000000008a,
93	0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008,	99	0x0000000000000088,
		100	0x0000000080008009,
		101	0x000000008000000a,
		102	0x000000008000808b,
		103	0x800000000000008b,
		104	0x8000000000008089,
		105	0x8000000000008003,
		106	0x8000000000008002,
		107	0x8000000000000080,
		108	0x000000000000800a,
		109	0x800000008000000a,
		110	0x8000000080008081,
		111	0x8000000000008080,
		112	0x0000000080000001,
		113	0x8000000080008008,
94	};	114	};
95		115
96	const ROTC = []const usize {	116	const ROTC = []const usize{
97	1, 3, 6, 10, 15, 21, 28, 36,	117	1,
98	45, 55, 2, 14, 27, 41, 56, 8,	118	3,
99	25, 43, 62, 18, 39, 61, 20, 44	119	6,
		120	10,
		121	15,
		122	21,
		123	28,
		124	36,
		125	45,
		126	55,
		127	2,
		128	14,
		129	27,
		130	41,
		131	56,
		132	8,
		133	25,
		134	43,
		135	62,
		136	18,
		137	39,
		138	61,
		139	20,
		140	44,
100	};	141	};
101		142
102	const PIL = []const usize {	143	const PIL = []const usize{
103	10, 7, 11, 17, 18, 3, 5, 16,	144	10,
104	8, 21, 24, 4, 15, 23, 19, 13,	145	7,
105	12, 2, 20, 14, 22, 9, 6, 1	146	11,
		147	17,
		148	18,
		149	3,
		150	5,
		151	16,
		152	8,
		153	21,
		154	24,
		155	4,
		156	15,
		157	23,
		158	19,
		159	13,
		160	12,
		161	2,
		162	20,
		163	14,
		164	22,
		165	9,
		166	6,
		167	1,
106	};	168	};
107		169
108	const M5 = []const usize {	170	const M5 = []const usize{
109	0, 1, 2, 3, 4, 0, 1, 2, 3, 4	171	0,
		172	1,
		173	2,
		174	3,
		175	4,
		176	0,
		177	1,
		178	2,
		179	3,
		180	4,
110	};	181	};
111		182
112	fn keccak_f(comptime F: usize, d: []u8) void {	183	fn keccak_f(comptime F: usize, d: []u8) void {
113	debug.assert(d.len == F / 8);	184	debug.assert(d.len == F / 8);
114		185
115	const B = F / 25;	186	const B = F / 25;
116	const no_rounds = comptime x: { break :x 12 + 2 * math.log2(B); };	187	const no_rounds = comptime x: {
		188	break :x 12 + 2 * math.log2(B);
		189	};
117		190
118	var s = []const u64 {0} ** 25;	191	var s = []const u64{0} ** 25;
119	var t = []const u64 {0} ** 1;	192	var t = []const u64{0} ** 1;
120	var c = []const u64 {0} ** 5;	193	var c = []const u64{0} ** 5;
121		194
122	for (s) \|*r, i\| {	195	for (s) \|*r, i\| {
123	r = mem.readIntLE(u64, d[8i .. 8*i + 8]);	196	r.* = mem.readIntLE(u64, d[8 * i..8 * i + 8]);
124	}	197	}
125		198
126	comptime var x: usize = 0;	199	comptime var x: usize = 0;
127	comptime var y: usize = 0;	200	comptime var y: usize = 0;
128	for (RC[0..no_rounds]) \|round\| {	201	for (RC[0..no_rounds]) \|round\| {
129	// theta	202	// theta
130	x = 0; inline while (x < 5) : (x += 1) {	203	x = 0;
131	c[x] = s[x] ^ s[x+5] ^ s[x+10] ^ s[x+15] ^ s[x+20];	204	inline while (x < 5) : (x += 1) {
		205	c[x] = s[x] ^ s[x + 5] ^ s[x + 10] ^ s[x + 15] ^ s[x + 20];
132	}	206	}
133	x = 0; inline while (x < 5) : (x += 1) {	207	x = 0;
134	t[0] = c[M5[x+4]] ^ math.rotl(u64, c[M5[x+1]], usize(1));	208	inline while (x < 5) : (x += 1) {
135	y = 0; inline while (y < 5) : (y += 1) {	209	t[0] = c[M5[x + 4]] ^ math.rotl(u64, c[M5[x + 1]], usize(1));
136	s[x + y*5] ^= t[0];	210	y = 0;
		211	inline while (y < 5) : (y += 1) {
		212	s[x + y * 5] ^= t[0];
137	}	213	}
138	}	214	}
139		215
140	// rho+pi	216	// rho+pi
141	t[0] = s[1];	217	t[0] = s[1];
142	x = 0; inline while (x < 24) : (x += 1) {	218	x = 0;
		219	inline while (x < 24) : (x += 1) {
143	c[0] = s[PIL[x]];	220	c[0] = s[PIL[x]];
144	s[PIL[x]] = math.rotl(u64, t[0], ROTC[x]);	221	s[PIL[x]] = math.rotl(u64, t[0], ROTC[x]);
145	t[0] = c[0];	222	t[0] = c[0];
146	}	223	}
147		224
148	// chi	225	// chi
149	y = 0; inline while (y < 5) : (y += 1) {	226	y = 0;
150	x = 0; inline while (x < 5) : (x += 1) {	227	inline while (y < 5) : (y += 1) {
151	c[x] = s[x + y*5];	228	x = 0;
		229	inline while (x < 5) : (x += 1) {
		230	c[x] = s[x + y * 5];
152	}	231	}
153	x = 0; inline while (x < 5) : (x += 1) {	232	x = 0;
154	s[x + y*5] = c[x] ^ (~c[M5[x+1]] & c[M5[x+2]]);	233	inline while (x < 5) : (x += 1) {
		234	s[x + y * 5] = c[x] ^ (~c[M5[x + 1]] & c[M5[x + 2]]);
155	}	235	}
156	}	236	}
157		237
...	@@ -160,11 +240,10 @@ fn keccak_f(comptime F: usize, d: []u8) void {	...	@@ -160,11 +240,10 @@ fn keccak_f(comptime F: usize, d: []u8) void {
160	}	240	}
161		241
162	for (s) \|r, i\| {	242	for (s) \|r, i\| {
163	mem.writeInt(d[8i .. 8i + 8], r, builtin.Endian.Little);	243	mem.writeInt(d[8 * i..8 * i + 8], r, builtin.Endian.Little);
164	}	244	}
165	}	245	}
166		246
167
168	test "sha3-224 single" {	247	test "sha3-224 single" {
169	htest.assertEqualHash(Sha3_224, "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", "");	248	htest.assertEqualHash(Sha3_224, "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7", "");
170	htest.assertEqualHash(Sha3_224, "e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", "abc");	249	htest.assertEqualHash(Sha3_224, "e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf", "abc");
...	@@ -192,7 +271,7 @@ test "sha3-224 streaming" {	...	@@ -192,7 +271,7 @@ test "sha3-224 streaming" {
192	}	271	}
193		272
194	test "sha3-256 single" {	273	test "sha3-256 single" {
195	htest.assertEqualHash(Sha3_256, "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a" , "");	274	htest.assertEqualHash(Sha3_256, "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", "");
196	htest.assertEqualHash(Sha3_256, "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", "abc");	275	htest.assertEqualHash(Sha3_256, "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", "abc");
197	htest.assertEqualHash(Sha3_256, "916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");	276	htest.assertEqualHash(Sha3_256, "916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18", "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu");
198	}	277	}
...	@@ -218,7 +297,7 @@ test "sha3-256 streaming" {	...	@@ -218,7 +297,7 @@ test "sha3-256 streaming" {
218	}	297	}
219		298
220	test "sha3-256 aligned final" {	299	test "sha3-256 aligned final" {
221	var block = []u8 {0} ** Sha3_256.block_size;	300	var block = []u8{0} ** Sha3_256.block_size;
222	var out: [Sha3_256.digest_size]u8 = undefined;	301	var out: [Sha3_256.digest_size]u8 = undefined;
223		302
224	var h = Sha3_256.init();	303	var h = Sha3_256.init();
...	@@ -228,7 +307,7 @@ test "sha3-256 aligned final" {	...	@@ -228,7 +307,7 @@ test "sha3-256 aligned final" {
228		307
229	test "sha3-384 single" {	308	test "sha3-384 single" {
230	const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004";	309	const h1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004";
231	htest.assertEqualHash(Sha3_384, h1 , "");	310	htest.assertEqualHash(Sha3_384, h1, "");
232	const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25";	311	const h2 = "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25";
233	htest.assertEqualHash(Sha3_384, h2, "abc");	312	htest.assertEqualHash(Sha3_384, h2, "abc");
234	const h3 = "79407d3b5916b59c3e30b09822974791c313fb9ecc849e406f23592d04f625dc8c709b98b43b3852b337216179aa7fc7";	313	const h3 = "79407d3b5916b59c3e30b09822974791c313fb9ecc849e406f23592d04f625dc8c709b98b43b3852b337216179aa7fc7";
...	@@ -259,7 +338,7 @@ test "sha3-384 streaming" {	...	@@ -259,7 +338,7 @@ test "sha3-384 streaming" {
259		338
260	test "sha3-512 single" {	339	test "sha3-512 single" {
261	const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26";	340	const h1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26";
262	htest.assertEqualHash(Sha3_512, h1 , "");	341	htest.assertEqualHash(Sha3_512, h1, "");
263	const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0";	342	const h2 = "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0";
264	htest.assertEqualHash(Sha3_512, h2, "abc");	343	htest.assertEqualHash(Sha3_512, h2, "abc");
265	const h3 = "afebb2ef542e6579c50cad06d2e578f9f8dd6881d7dc824d26360feebf18a4fa73e3261122948efcfd492e74e82e2189ed0fb440d187f382270cb455f21dd185";	344	const h3 = "afebb2ef542e6579c50cad06d2e578f9f8dd6881d7dc824d26360feebf18a4fa73e3261122948efcfd492e74e82e2189ed0fb440d187f382270cb455f21dd185";
...	@@ -289,7 +368,7 @@ test "sha3-512 streaming" {	...	@@ -289,7 +368,7 @@ test "sha3-512 streaming" {
289	}	368	}
290		369
291	test "sha3-512 aligned final" {	370	test "sha3-512 aligned final" {
292	var block = []u8 {0} ** Sha3_512.block_size;	371	var block = []u8{0} ** Sha3_512.block_size;
293	var out: [Sha3_512.digest_size]u8 = undefined;	372	var out: [Sha3_512.digest_size]u8 = undefined;
294		373
295	var h = Sha3_512.init();	374	var h = Sha3_512.init();

std/event.zig+20-33

 @@ -6,7 +6,7 @@ const mem = std.mem;
 const posix = std.os.posix;
 pub const TcpServer = struct {
-    handleRequestFn: async<&mem.Allocator> fn (&TcpServer, &const std.net.Address, &const std.os.File) void,
+    handleRequestFn: async<&mem.Allocator> fn(&TcpServer, &const std.net.Address, &const std.os.File) void,
     loop: &Loop,
     sockfd: i32,
 @@ -18,13 +18,11 @@ pub const TcpServer = struct {
     const PromiseNode = std.LinkedList(promise).Node;
     pub fn init(loop: &Loop) !TcpServer {
-        const sockfd = try std.os.posixSocket(posix.AF_INET,
+        const sockfd = try std.os.posixSocket(posix.AF_INET, posix.SOCK_STREAM | posix.SOCK_CLOEXEC | posix.SOCK_NONBLOCK, posix.PROTO_tcp);
-            posix.SOCK_STREAM|posix.SOCK_CLOEXEC|posix.SOCK_NONBLOCK,
-            posix.PROTO_tcp);
         errdefer std.os.close(sockfd);
         // TODO can't initialize handler coroutine here because we need well defined copy elision
-        return TcpServer {
+        return TcpServer{
             .loop = loop,
             .sockfd = sockfd,
             .accept_coro = null,
 @@ -34,9 +32,7 @@ pub const TcpServer = struct {
         };
     }
-    pub fn listen(self: &TcpServer, address: &const std.net.Address,
+    pub fn listen(self: &TcpServer, address: &const std.net.Address, handleRequestFn: async<&mem.Allocator> fn(&TcpServer, &const std.net.Address, &const std.os.File) void) !void {
-        handleRequestFn: async<&mem.Allocator> fn (&TcpServer, &const std.net.Address, &const std.os.File)void) !void
-    {
         self.handleRequestFn = handleRequestFn;
         try std.os.posixBind(self.sockfd, &address.os_addr);
 @@ -48,7 +44,6 @@ pub const TcpServer = struct {
         try self.loop.addFd(self.sockfd, ??self.accept_coro);
         errdefer self.loop.removeFd(self.sockfd);
     }
     pub fn deinit(self: &TcpServer) void {
 @@ -60,9 +55,7 @@ pub const TcpServer = struct {
     pub async fn handler(self: &TcpServer) void {
         while (true) {
             var accepted_addr: std.net.Address = undefined;
-            if (std.os.posixAccept(self.sockfd, &accepted_addr.os_addr,
+            if (std.os.posixAccept(self.sockfd, &accepted_addr.os_addr, posix.SOCK_NONBLOCK | posix.SOCK_CLOEXEC)) |accepted_fd| {
-                posix.SOCK_NONBLOCK | posix.SOCK_CLOEXEC)) |accepted_fd|
-            {
                 var socket = std.os.File.openHandle(accepted_fd);
                 _ = async<self.loop.allocator> self.handleRequestFn(self, accepted_addr, socket) catch |err| switch (err) {
                     error.OutOfMemory => {
 @@ -110,7 +103,7 @@ pub const Loop = struct {
     fn init(allocator: &mem.Allocator) !Loop {
         const epollfd = try std.os.linuxEpollCreate(std.os.linux.EPOLL_CLOEXEC);
-        return Loop {
+        return Loop{
             .keep_running = true,
             .allocator = allocator,
             .epollfd = epollfd,
 @@ -118,11 +111,9 @@ pub const Loop = struct {
     }
     pub fn addFd(self: &Loop, fd: i32, prom: promise) !void {
-        var ev = std.os.linux.epoll_event {
+        var ev = std.os.linux.epoll_event{
-            .events = std.os.linux.EPOLLIN|std.os.linux.EPOLLOUT|std.os.linux.EPOLLET,
+            .events = std.os.linux.EPOLLIN | std.os.linux.EPOLLOUT | std.os.linux.EPOLLET,
-            .data = std.os.linux.epoll_data {
+            .data = std.os.linux.epoll_data{ .ptr = @ptrToInt(prom) },
-                .ptr = @ptrToInt(prom),
-            },
         };
         try std.os.linuxEpollCtl(self.epollfd, std.os.linux.EPOLL_CTL_ADD, fd, &ev);
     }
 @@ -157,9 +148,9 @@ pub const Loop = struct {
 };
 pub async fn connect(loop: &Loop, _address: &const std.net.Address) !std.os.File {
-    var address = *_address; // TODO https://github.com/zig-lang/zig/issues/733
+    var address = _address.*; // TODO https://github.com/zig-lang/zig/issues/733
-    const sockfd = try std.os.posixSocket(posix.AF_INET, posix.SOCK_STREAM|posix.SOCK_CLOEXEC|posix.SOCK_NONBLOCK, posix.PROTO_tcp);
+    const sockfd = try std.os.posixSocket(posix.AF_INET, posix.SOCK_STREAM | posix.SOCK_CLOEXEC | posix.SOCK_NONBLOCK, posix.PROTO_tcp);
     errdefer std.os.close(sockfd);
     try std.os.posixConnectAsync(sockfd, &address.os_addr);
 @@ -179,11 +170,9 @@ test "listen on a port, send bytes, receive bytes" {
         const Self = this;
-        async<&mem.Allocator> fn handler(tcp_server: &TcpServer, _addr: &const std.net.Address,
+        async<&mem.Allocator> fn handler(tcp_server: &TcpServer, _addr: &const std.net.Address, _socket: &const std.os.File) void {
-            _socket: &const std.os.File) void
-        {
             const self = @fieldParentPtr(Self, "tcp_server", tcp_server);
-            var socket = *_socket; // TODO https://github.com/zig-lang/zig/issues/733
+            var socket = _socket.*; // TODO https://github.com/zig-lang/zig/issues/733
             defer socket.close();
             const next_handler = async errorableHandler(self, _addr, socket) catch |err| switch (err) {
                 error.OutOfMemory => @panic("unable to handle connection: out of memory"),
 @@ -191,14 +180,14 @@ test "listen on a port, send bytes, receive bytes" {
             (await next_handler) catch |err| {
                 std.debug.panic("unable to handle connection: {}\n", err);
             };
-            suspend |p| { cancel p; }
+            suspend |p| {
+                cancel p;
+            }
         }
-        async fn errorableHandler(self: &Self, _addr: &const std.net.Address,
+        async fn errorableHandler(self: &Self, _addr: &const std.net.Address, _socket: &const std.os.File) !void {
-            _socket: &const std.os.File) !void
+            const addr = _addr.*; // TODO https://github.com/zig-lang/zig/issues/733
-        {
+            var socket = _socket.*; // TODO https://github.com/zig-lang/zig/issues/733
-            const addr = *_addr; // TODO https://github.com/zig-lang/zig/issues/733
-            var socket = *_socket; // TODO https://github.com/zig-lang/zig/issues/733
             var adapter = std.io.FileOutStream.init(&socket);
             var stream = &adapter.stream;
 @@ -210,9 +199,7 @@ test "listen on a port, send bytes, receive bytes" {
     const addr = std.net.Address.initIp4(ip4addr, 0);
     var loop = try Loop.init(std.debug.global_allocator);
-    var server = MyServer {
+    var server = MyServer{ .tcp_server = try TcpServer.init(&loop) };
-        .tcp_server = try TcpServer.init(&loop),
-    };
     defer server.tcp_server.deinit();
     try server.tcp_server.listen(addr, MyServer.handler);

std/hash/crc.zig+16-16

 @@ -9,9 +9,9 @@ const std = @import("../index.zig");
 const debug = std.debug;
 pub const Polynomial = struct {
-    const IEEE       = 0xedb88320;
+    const IEEE = 0xedb88320;
     const Castagnoli = 0x82f63b78;
-    const Koopman    = 0xeb31d82e;
+    const Koopman = 0xeb31d82e;
 };
 // IEEE is by far the most common CRC and so is aliased by default.
 @@ -27,20 +27,22 @@ pub fn Crc32WithPoly(comptime poly: u32) type {
             for (tables[0]) |*e, i| {
                 var crc = u32(i);
-                var j: usize = 0; while (j < 8) : (j += 1) {
+                var j: usize = 0;
+                while (j < 8) : (j += 1) {
                     if (crc & 1 == 1) {
                         crc = (crc >> 1) ^ poly;
                     } else {
                         crc = (crc >> 1);
                     }
                 }
-                *e = crc;
+                e.* = crc;
             }
             var i: usize = 0;
             while (i < 256) : (i += 1) {
                 var crc = tables[0][i];
-                var j: usize = 1; while (j < 8) : (j += 1) {
+                var j: usize = 1;
+                while (j < 8) : (j += 1) {
                     const index = @truncate(u8, crc);
                     crc = tables[0][index] ^ (crc >> 8);
                     tables[j][i] = crc;
 @@ -53,22 +55,21 @@ pub fn Crc32WithPoly(comptime poly: u32) type {
         crc: u32,
         pub fn init() Self {
-            return Self {
+            return Self{ .crc = 0xffffffff };
-                .crc = 0xffffffff,
-            };
         }
         pub fn update(self: &Self, input: []const u8) void {
             var i: usize = 0;
             while (i + 8 <= input.len) : (i += 8) {
-                const p = input[i..i+8];
+                const p = input[i..i + 8];
                 // Unrolling this way gives ~50Mb/s increase
-                self.crc ^= (u32(p[0]) <<  0);
+                self.crc ^= (u32(p[0]) << 0);
-                self.crc ^= (u32(p[1]) <<  8);
+                self.crc ^= (u32(p[1]) << 8);
                 self.crc ^= (u32(p[2]) << 16);
                 self.crc ^= (u32(p[3]) << 24);
                 self.crc =
                     lookup_tables[0][p[7]] ^
                     lookup_tables[1][p[6]] ^
 @@ -123,14 +124,15 @@ pub fn Crc32SmallWithPoly(comptime poly: u32) type {
             for (table) |*e, i| {
                 var crc = u32(i * 16);
-                var j: usize = 0; while (j < 8) : (j += 1) {
+                var j: usize = 0;
+                while (j < 8) : (j += 1) {
                     if (crc & 1 == 1) {
                         crc = (crc >> 1) ^ poly;
                     } else {
                         crc = (crc >> 1);
                     }
                 }
-                *e = crc;
+                e.* = crc;
             }
             break :block table;
 @@ -139,9 +141,7 @@ pub fn Crc32SmallWithPoly(comptime poly: u32) type {
         crc: u32,
         pub fn init() Self {
-            return Self {
+            return Self{ .crc = 0xffffffff };
-                .crc = 0xffffffff,
-            };
         }
         pub fn update(self: &Self, input: []const u8) void {

std/hash_map.zig+57-45

...	@@ -9,10 +9,7 @@ const builtin = @import("builtin");	...	@@ -9,10 +9,7 @@ const builtin = @import("builtin");
9	const want_modification_safety = builtin.mode != builtin.Mode.ReleaseFast;	9	const want_modification_safety = builtin.mode != builtin.Mode.ReleaseFast;
10	const debug_u32 = if (want_modification_safety) u32 else void;	10	const debug_u32 = if (want_modification_safety) u32 else void;
11		11
12	pub fn HashMap(comptime K: type, comptime V: type,	12	pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn(key: K) u32, comptime eql: fn(a: K, b: K) bool) type {
13	comptime hash: fn(key: K)u32,
14	comptime eql: fn(a: K, b: K)bool) type
15	{
16	return struct {	13	return struct {
17	entries: []Entry,	14	entries: []Entry,
18	size: usize,	15	size: usize,
...	@@ -65,7 +62,7 @@ pub fn HashMap(comptime K: type, comptime V: type,	...	@@ -65,7 +62,7 @@ pub fn HashMap(comptime K: type, comptime V: type,
65	};	62	};
66		63
67	pub fn init(allocator: &Allocator) Self {	64	pub fn init(allocator: &Allocator) Self {
68	return Self {	65	return Self{
69	.entries = []Entry{},	66	.entries = []Entry{},
70	.allocator = allocator,	67	.allocator = allocator,
71	.size = 0,	68	.size = 0,
...	@@ -129,34 +126,36 @@ pub fn HashMap(comptime K: type, comptime V: type,	...	@@ -129,34 +126,36 @@ pub fn HashMap(comptime K: type, comptime V: type,
129	if (hm.entries.len == 0) return null;	126	if (hm.entries.len == 0) return null;
130	hm.incrementModificationCount();	127	hm.incrementModificationCount();
131	const start_index = hm.keyToIndex(key);	128	const start_index = hm.keyToIndex(key);
132	{var roll_over: usize = 0; while (roll_over <= hm.max_distance_from_start_index) : (roll_over += 1) {	129	{
133	const index = (start_index + roll_over) % hm.entries.len;	130	var roll_over: usize = 0;
134	var entry = &hm.entries[index];	131	while (roll_over <= hm.max_distance_from_start_index) : (roll_over += 1) {
135		132	const index = (start_index + roll_over) % hm.entries.len;
136	if (!entry.used)	133	var entry = &hm.entries[index];
137	return null;	134
138		135	if (!entry.used) return null;
139	if (!eql(entry.key, key)) continue;	136
140		137	if (!eql(entry.key, key)) continue;
141	while (roll_over < hm.entries.len) : (roll_over += 1) {	138
142	const next_index = (start_index + roll_over + 1) % hm.entries.len;	139	while (roll_over < hm.entries.len) : (roll_over += 1) {
143	const next_entry = &hm.entries[next_index];	140	const next_index = (start_index + roll_over + 1) % hm.entries.len;
144	if (!next_entry.used or next_entry.distance_from_start_index == 0) {	141	const next_entry = &hm.entries[next_index];
145	entry.used = false;	142	if (!next_entry.used or next_entry.distance_from_start_index == 0) {
146	hm.size -= 1;	143	entry.used = false;
147	return entry;	144	hm.size -= 1;
		145	return entry;
		146	}
		147	entry.* = next_entry.*;
		148	entry.distance_from_start_index -= 1;
		149	entry = next_entry;
148	}	150	}
149	entry = next_entry;	151	unreachable; // shifting everything in the table
150	entry.distance_from_start_index -= 1;
151	entry = next_entry;
152	}	152	}
153	unreachable; // shifting everything in the table	153	}
154	}}
155	return null;	154	return null;
156	}	155	}
157		156
158	pub fn iterator(hm: &const Self) Iterator {	157	pub fn iterator(hm: &const Self) Iterator {
159	return Iterator {	158	return Iterator{
160	.hm = hm,	159	.hm = hm,
161	.count = 0,	160	.count = 0,
162	.index = 0,	161	.index = 0,
...	@@ -182,21 +181,23 @@ pub fn HashMap(comptime K: type, comptime V: type,	...	@@ -182,21 +181,23 @@ pub fn HashMap(comptime K: type, comptime V: type,
182	/// Returns the value that was already there.	181	/// Returns the value that was already there.
183	fn internalPut(hm: &Self, orig_key: K, orig_value: &const V) ?V {	182	fn internalPut(hm: &Self, orig_key: K, orig_value: &const V) ?V {
184	var key = orig_key;	183	var key = orig_key;
185	var value = *orig_value;	184	var value = orig_value.*;
186	const start_index = hm.keyToIndex(key);	185	const start_index = hm.keyToIndex(key);
187	var roll_over: usize = 0;	186	var roll_over: usize = 0;
188	var distance_from_start_index: usize = 0;	187	var distance_from_start_index: usize = 0;
189	while (roll_over < hm.entries.len) : ({roll_over += 1; distance_from_start_index += 1;}) {	188	while (roll_over < hm.entries.len) : ({
		189	roll_over += 1;
		190	distance_from_start_index += 1;
		191	}) {
190	const index = (start_index + roll_over) % hm.entries.len;	192	const index = (start_index + roll_over) % hm.entries.len;
191	const entry = &hm.entries[index];	193	const entry = &hm.entries[index];
192		194
193	if (entry.used and !eql(entry.key, key)) {	195	if (entry.used and !eql(entry.key, key)) {
194	if (entry.distance_from_start_index < distance_from_start_index) {	196	if (entry.distance_from_start_index < distance_from_start_index) {
195	// robin hood to the rescue	197	// robin hood to the rescue
196	const tmp = *entry;	198	const tmp = entry.*;
197	hm.max_distance_from_start_index = math.max(hm.max_distance_from_start_index,	199	hm.max_distance_from_start_index = math.max(hm.max_distance_from_start_index, distance_from_start_index);
198	distance_from_start_index);	200	entry.* = Entry{
199	*entry = Entry {
200	.used = true,	201	.used = true,
201	.distance_from_start_index = distance_from_start_index,	202	.distance_from_start_index = distance_from_start_index,
202	.key = key,	203	.key = key,
...	@@ -219,7 +220,7 @@ pub fn HashMap(comptime K: type, comptime V: type,	...	@@ -219,7 +220,7 @@ pub fn HashMap(comptime K: type, comptime V: type,
219	}	220	}
220		221
221	hm.max_distance_from_start_index = math.max(distance_from_start_index, hm.max_distance_from_start_index);	222	hm.max_distance_from_start_index = math.max(distance_from_start_index, hm.max_distance_from_start_index);
222	*entry = Entry {	223	entry.* = Entry{
223	.used = true,	224	.used = true,
224	.distance_from_start_index = distance_from_start_index,	225	.distance_from_start_index = distance_from_start_index,
225	.key = key,	226	.key = key,
...	@@ -232,13 +233,16 @@ pub fn HashMap(comptime K: type, comptime V: type,	...	@@ -232,13 +233,16 @@ pub fn HashMap(comptime K: type, comptime V: type,
232		233
233	fn internalGet(hm: &const Self, key: K) ?&Entry {	234	fn internalGet(hm: &const Self, key: K) ?&Entry {
234	const start_index = hm.keyToIndex(key);	235	const start_index = hm.keyToIndex(key);
235	{var roll_over: usize = 0; while (roll_over <= hm.max_distance_from_start_index) : (roll_over += 1) {	236	{
236	const index = (start_index + roll_over) % hm.entries.len;	237	var roll_over: usize = 0;
237	const entry = &hm.entries[index];	238	while (roll_over <= hm.max_distance_from_start_index) : (roll_over += 1) {
238		239	const index = (start_index + roll_over) % hm.entries.len;
239	if (!entry.used) return null;	240	const entry = &hm.entries[index];
240	if (eql(entry.key, key)) return entry;	241
241	}}	242	if (!entry.used) return null;
		243	if (eql(entry.key, key)) return entry;
		244	}
		245	}
242	return null;	246	return null;
243	}	247	}
244		248
...	@@ -282,11 +286,19 @@ test "iterator hash map" {	...	@@ -282,11 +286,19 @@ test "iterator hash map" {
282	assert((reset_map.put(2, 22) catch unreachable) == null);	286	assert((reset_map.put(2, 22) catch unreachable) == null);
283	assert((reset_map.put(3, 33) catch unreachable) == null);	287	assert((reset_map.put(3, 33) catch unreachable) == null);
284		288
285	var keys = []i32 { 1, 2, 3 };	289	var keys = []i32{
286	var values = []i32 { 11, 22, 33 };	290	1,
		291	2,
		292	3,
		293	};
		294	var values = []i32{
		295	11,
		296	22,
		297	33,
		298	};
287		299
288	var it = reset_map.iterator();	300	var it = reset_map.iterator();
289	var count : usize = 0;	301	var count: usize = 0;
290	while (it.next()) \|next\| {	302	while (it.next()) \|next\| {
291	assert(next.key == keys[count]);	303	assert(next.key == keys[count]);
292	assert(next.value == values[count]);	304	assert(next.value == values[count]);
...	@@ -305,7 +317,7 @@ test "iterator hash map" {	...	@@ -305,7 +317,7 @@ test "iterator hash map" {
305	}	317	}
306		318
307	it.reset();	319	it.reset();
308	var entry = ?? it.next();	320	var entry = ??it.next();
309	assert(entry.key == keys[0]);	321	assert(entry.key == keys[0]);
310	assert(entry.value == values[0]);	322	assert(entry.value == values[0]);
311	}	323	}

std/json.zig+124-83

 @@ -35,7 +35,7 @@ pub const Token = struct {
     };
     pub fn init(id: Id, count: usize, offset: u1) Token {
-        return Token {
+        return Token{
             .id = id,
             .offset = offset,
             .string_has_escape = false,
 @@ -45,7 +45,7 @@ pub const Token = struct {
     }
     pub fn initString(count: usize, has_unicode_escape: bool) Token {
-        return Token {
+        return Token{
             .id = Id.String,
             .offset = 0,
             .string_has_escape = has_unicode_escape,
 @@ -55,7 +55,7 @@ pub const Token = struct {
     }
     pub fn initNumber(count: usize, number_is_integer: bool) Token {
-        return Token {
+        return Token{
             .id = Id.Number,
             .offset = 0,
             .string_has_escape = false,
 @@ -66,7 +66,7 @@ pub const Token = struct {
     // A marker token is a zero-length
     pub fn initMarker(id: Id) Token {
-        return Token {
+        return Token{
             .id = id,
             .offset = 0,
             .string_has_escape = false,
 @@ -77,7 +77,7 @@ pub const Token = struct {
     // Slice into the underlying input string.
     pub fn slice(self: &const Token, input: []const u8, i: usize) []const u8 {
-        return input[i + self.offset - self.count .. i + self.offset];
+        return input[i + self.offset - self.count..i + self.offset];
     }
 };
 @@ -105,8 +105,8 @@ const StreamingJsonParser = struct {
     stack: u256,
     stack_used: u8,
-    const object_bit     = 0;
+    const object_bit = 0;
-    const array_bit      = 1;
+    const array_bit = 1;
     const max_stack_size = @maxValue(u8);
     pub fn init() StreamingJsonParser {
 @@ -120,7 +120,7 @@ const StreamingJsonParser = struct {
         p.count = 0;
         // Set before ever read in main transition function
         p.after_string_state = undefined;
-        p.after_value_state = State.ValueEnd;   // handle end of values normally
+        p.after_value_state = State.ValueEnd; // handle end of values normally
         p.stack = 0;
         p.stack_used = 0;
         p.complete = false;
 @@ -181,7 +181,7 @@ const StreamingJsonParser = struct {
         }
     };
-    pub const Error = error {
+    pub const Error = error{
         InvalidTopLevel,
         TooManyNestedItems,
         TooManyClosingItems,
 @@ -206,8 +206,8 @@ const StreamingJsonParser = struct {
     //
     // There is currently no error recovery on a bad stream.
     pub fn feed(p: &StreamingJsonParser, c: u8, token1: &?Token, token2: &?Token) Error!void {
-        *token1 = null;
+        token1.* = null;
-        *token2 = null;
+        token2.* = null;
         p.count += 1;
         // unlikely
 @@ -228,7 +228,7 @@ const StreamingJsonParser = struct {
                     p.state = State.ValueBegin;
                     p.after_string_state = State.ObjectSeparator;
-                    *token = Token.initMarker(Token.Id.ObjectBegin);
+                    token.* = Token.initMarker(Token.Id.ObjectBegin);
                 },
                 '[' => {
                     p.stack <<= 1;
 @@ -238,7 +238,7 @@ const StreamingJsonParser = struct {
                     p.state = State.ValueBegin;
                     p.after_string_state = State.ValueEnd;
-                    *token = Token.initMarker(Token.Id.ArrayBegin);
+                    token.* = Token.initMarker(Token.Id.ArrayBegin);
                 },
                 '-' => {
                     p.number_is_integer = true;
 @@ -281,7 +281,10 @@ const StreamingJsonParser = struct {
                     p.after_value_state = State.TopLevelEnd;
                     p.count = 0;
                 },
-                0x09, 0x0A, 0x0D, 0x20 => {
+                0x09,
+                0x0A,
+                0x0D,
+                0x20 => {
                     // whitespace
                 },
                 else => {
 @@ -290,7 +293,10 @@ const StreamingJsonParser = struct {
             },
             State.TopLevelEnd => switch (c) {
-                0x09, 0x0A, 0x0D, 0x20 => {
+                0x09,
+                0x0A,
+                0x0D,
+                0x20 => {
                     // whitespace
                 },
                 else => {
 @@ -324,7 +330,7 @@ const StreamingJsonParser = struct {
                         else => {},
                     }
-                    *token = Token.initMarker(Token.Id.ObjectEnd);
+                    token.* = Token.initMarker(Token.Id.ObjectEnd);
                 },
                 ']' => {
                     if (p.stack & 1 != array_bit) {
 @@ -348,7 +354,7 @@ const StreamingJsonParser = struct {
                         else => {},
                     }
-                    *token = Token.initMarker(Token.Id.ArrayEnd);
+                    token.* = Token.initMarker(Token.Id.ArrayEnd);
                 },
                 '{' => {
                     if (p.stack_used == max_stack_size) {
 @@ -362,7 +368,7 @@ const StreamingJsonParser = struct {
                     p.state = State.ValueBegin;
                     p.after_string_state = State.ObjectSeparator;
-                    *token = Token.initMarker(Token.Id.ObjectBegin);
+                    token.* = Token.initMarker(Token.Id.ObjectBegin);
                 },
                 '[' => {
                     if (p.stack_used == max_stack_size) {
 @@ -376,7 +382,7 @@ const StreamingJsonParser = struct {
                     p.state = State.ValueBegin;
                     p.after_string_state = State.ValueEnd;
-                    *token = Token.initMarker(Token.Id.ArrayBegin);
+                    token.* = Token.initMarker(Token.Id.ArrayBegin);
                 },
                 '-' => {
                     p.state = State.Number;
 @@ -406,7 +412,10 @@ const StreamingJsonParser = struct {
                     p.state = State.NullLiteral1;
                     p.count = 0;
                 },
-                0x09, 0x0A, 0x0D, 0x20 => {
+                0x09,
+                0x0A,
+                0x0D,
+                0x20 => {
                     // whitespace
                 },
                 else => {
 @@ -428,7 +437,7 @@ const StreamingJsonParser = struct {
                     p.state = State.ValueBegin;
                     p.after_string_state = State.ObjectSeparator;
-                    *token = Token.initMarker(Token.Id.ObjectBegin);
+                    token.* = Token.initMarker(Token.Id.ObjectBegin);
                 },
                 '[' => {
                     if (p.stack_used == max_stack_size) {
 @@ -442,7 +451,7 @@ const StreamingJsonParser = struct {
                     p.state = State.ValueBegin;
                     p.after_string_state = State.ValueEnd;
-                    *token = Token.initMarker(Token.Id.ArrayBegin);
+                    token.* = Token.initMarker(Token.Id.ArrayBegin);
                 },
                 '-' => {
                     p.state = State.Number;
 @@ -472,7 +481,10 @@ const StreamingJsonParser = struct {
                     p.state = State.NullLiteral1;
                     p.count = 0;
                 },
-                0x09, 0x0A, 0x0D, 0x20 => {
+                0x09,
+                0x0A,
+                0x0D,
+                0x20 => {
                     // whitespace
                 },
                 else => {
 @@ -501,7 +513,7 @@ const StreamingJsonParser = struct {
                         p.state = State.TopLevelEnd;
                     }
-                    *token = Token.initMarker(Token.Id.ArrayEnd);
+                    token.* = Token.initMarker(Token.Id.ArrayEnd);
                 },
                 '}' => {
                     if (p.stack_used == 0) {
 @@ -519,9 +531,12 @@ const StreamingJsonParser = struct {
                         p.state = State.TopLevelEnd;
                     }
-                    *token = Token.initMarker(Token.Id.ObjectEnd);
+                    token.* = Token.initMarker(Token.Id.ObjectEnd);
                 },
-                0x09, 0x0A, 0x0D, 0x20 => {
+                0x09,
+                0x0A,
+                0x0D,
+                0x20 => {
                     // whitespace
                 },
                 else => {
 @@ -534,7 +549,10 @@ const StreamingJsonParser = struct {
                     p.state = State.ValueBegin;
                     p.after_string_state = State.ValueEnd;
                 },
-                0x09, 0x0A, 0x0D, 0x20 => {
+                0x09,
+                0x0A,
+                0x0D,
+                0x20 => {
                     // whitespace
                 },
                 else => {
 @@ -553,12 +571,15 @@ const StreamingJsonParser = struct {
                         p.complete = true;
                     }
-                    *token = Token.initString(p.count - 1, p.string_has_escape);
+                    token.* = Token.initString(p.count - 1, p.string_has_escape);
                 },
                 '\\' => {
                     p.state = State.StringEscapeCharacter;
                 },
-                0x20, 0x21, 0x23 ... 0x5B, 0x5D ... 0x7F => {
+                0x20,
+                0x21,
+                0x23 ... 0x5B,
+                0x5D ... 0x7F => {
                     // non-control ascii
                 },
                 0xC0 ... 0xDF => {
 @@ -599,7 +620,14 @@ const StreamingJsonParser = struct {
                 // The current JSONTestSuite tests rely on both of this behaviour being present
                 // however, so we default to the status quo where both are accepted until this
                 // is further clarified.
-                '"', '\\', '/', 'b', 'f', 'n', 'r', 't' => {
+                '"',
+                '\\',
+                '/',
+                'b',
+                'f',
+                'n',
+                'r',
+                't' => {
                     p.string_has_escape = true;
                     p.state = State.String;
                 },
 @@ -613,28 +641,36 @@ const StreamingJsonParser = struct {
             },
             State.StringEscapeHexUnicode4 => switch (c) {
-                '0' ... '9', 'A' ... 'F', 'a' ... 'f' => {
+                '0' ... '9',
+                'A' ... 'F',
+                'a' ... 'f' => {
                     p.state = State.StringEscapeHexUnicode3;
                 },
                 else => return error.InvalidUnicodeHexSymbol,
             },
             State.StringEscapeHexUnicode3 => switch (c) {
-                '0' ... '9', 'A' ... 'F', 'a' ... 'f' => {
+                '0' ... '9',
+                'A' ... 'F',
+                'a' ... 'f' => {
                     p.state = State.StringEscapeHexUnicode2;
                 },
                 else => return error.InvalidUnicodeHexSymbol,
             },
             State.StringEscapeHexUnicode2 => switch (c) {
-                '0' ... '9', 'A' ... 'F', 'a' ... 'f' => {
+                '0' ... '9',
+                'A' ... 'F',
+                'a' ... 'f' => {
                     p.state = State.StringEscapeHexUnicode1;
                 },
                 else => return error.InvalidUnicodeHexSymbol,
             },
             State.StringEscapeHexUnicode1 => switch (c) {
-                '0' ... '9', 'A' ... 'F', 'a' ... 'f' => {
+                '0' ... '9',
+                'A' ... 'F',
+                'a' ... 'f' => {
                     p.state = State.String;
                 },
                 else => return error.InvalidUnicodeHexSymbol,
 @@ -662,13 +698,14 @@ const StreamingJsonParser = struct {
                         p.number_is_integer = false;
                         p.state = State.NumberFractionalRequired;
                     },
-                    'e', 'E' => {
+                    'e',
+                    'E' => {
                         p.number_is_integer = false;
                         p.state = State.NumberExponent;
                     },
                     else => {
                         p.state = p.after_value_state;
-                        *token = Token.initNumber(p.count, p.number_is_integer);
+                        token.* = Token.initNumber(p.count, p.number_is_integer);
                         return true;
                     },
                 }
 @@ -681,7 +718,8 @@ const StreamingJsonParser = struct {
                         p.number_is_integer = false;
                         p.state = State.NumberFractionalRequired;
                     },
-                    'e', 'E' => {
+                    'e',
+                    'E' => {
                         p.number_is_integer = false;
                         p.state = State.NumberExponent;
                     },
 @@ -690,7 +728,7 @@ const StreamingJsonParser = struct {
                     },
                     else => {
                         p.state = p.after_value_state;
-                        *token = Token.initNumber(p.count, p.number_is_integer);
+                        token.* = Token.initNumber(p.count, p.number_is_integer);
                         return true;
                     },
                 }
 @@ -714,13 +752,14 @@ const StreamingJsonParser = struct {
                     '0' ... '9' => {
                         // another digit
                     },
-                    'e', 'E' => {
+                    'e',
+                    'E' => {
                         p.number_is_integer = false;
                         p.state = State.NumberExponent;
                     },
                     else => {
                         p.state = p.after_value_state;
-                        *token = Token.initNumber(p.count, p.number_is_integer);
+                        token.* = Token.initNumber(p.count, p.number_is_integer);
                         return true;
                     },
                 }
 @@ -729,20 +768,22 @@ const StreamingJsonParser = struct {
             State.NumberMaybeExponent => {
                 p.complete = p.after_value_state == State.TopLevelEnd;
                 switch (c) {
-                    'e', 'E' => {
+                    'e',
+                    'E' => {
                         p.number_is_integer = false;
                         p.state = State.NumberExponent;
                     },
                     else => {
                         p.state = p.after_value_state;
-                        *token = Token.initNumber(p.count, p.number_is_integer);
+                        token.* = Token.initNumber(p.count, p.number_is_integer);
                         return true;
                     },
                 }
             },
             State.NumberExponent => switch (c) {
-                '-', '+', => {
+                '-',
+                '+' => {
                     p.complete = false;
                     p.state = State.NumberExponentDigitsRequired;
                 },
 @@ -773,7 +814,7 @@ const StreamingJsonParser = struct {
                     },
                     else => {
                         p.state = p.after_value_state;
-                        *token = Token.initNumber(p.count, p.number_is_integer);
+                        token.* = Token.initNumber(p.count, p.number_is_integer);
                         return true;
                     },
                 }
 @@ -793,7 +834,7 @@ const StreamingJsonParser = struct {
                 'e' => {
                     p.state = p.after_value_state;
                     p.complete = p.state == State.TopLevelEnd;
-                    *token = Token.init(Token.Id.True, p.count + 1, 1);
+                    token.* = Token.init(Token.Id.True, p.count + 1, 1);
                 },
                 else => {
                     return error.InvalidLiteral;
 @@ -819,7 +860,7 @@ const StreamingJsonParser = struct {
                 'e' => {
                     p.state = p.after_value_state;
                     p.complete = p.state == State.TopLevelEnd;
-                    *token = Token.init(Token.Id.False, p.count + 1, 1);
+                    token.* = Token.init(Token.Id.False, p.count + 1, 1);
                 },
                 else => {
                     return error.InvalidLiteral;
 @@ -840,7 +881,7 @@ const StreamingJsonParser = struct {
                 'l' => {
                     p.state = p.after_value_state;
                     p.complete = p.state == State.TopLevelEnd;
-                    *token = Token.init(Token.Id.Null, p.count + 1, 1);
+                    token.* = Token.init(Token.Id.Null, p.count + 1, 1);
                 },
                 else => {
                     return error.InvalidLiteral;
 @@ -895,7 +936,7 @@ pub const Value = union(enum) {
     Object: ObjectMap,
     pub fn dump(self: &const Value) void {
-        switch (*self) {
+        switch (self.*) {
             Value.Null => {
                 std.debug.warn("null");
             },
 @@ -950,7 +991,7 @@ pub const Value = union(enum) {
     }
     fn dumpIndentLevel(self: &const Value, indent: usize, level: usize) void {
-        switch (*self) {
+        switch (self.*) {
             Value.Null => {
                 std.debug.warn("null");
             },
 @@ -1027,7 +1068,7 @@ const JsonParser = struct {
     };
     pub fn init(allocator: &Allocator, copy_strings: bool) JsonParser {
-        return JsonParser {
+        return JsonParser{
             .allocator = allocator,
             .state = State.Simple,
             .copy_strings = copy_strings,
 @@ -1082,7 +1123,7 @@ const JsonParser = struct {
         std.debug.assert(p.stack.len == 1);
-        return ValueTree {
+        return ValueTree{
             .arena = arena,
             .root = p.stack.at(0),
         };
 @@ -1115,11 +1156,11 @@ const JsonParser = struct {
                 switch (token.id) {
                     Token.Id.ObjectBegin => {
-                        try p.stack.append(Value { .Object = ObjectMap.init(allocator) });
+                        try p.stack.append(Value{ .Object = ObjectMap.init(allocator) });
                         p.state = State.ObjectKey;
                     },
                     Token.Id.ArrayBegin => {
-                        try p.stack.append(Value { .Array = ArrayList(Value).init(allocator) });
+                        try p.stack.append(Value{ .Array = ArrayList(Value).init(allocator) });
                         p.state = State.ArrayValue;
                     },
                     Token.Id.String => {
 @@ -1133,12 +1174,12 @@ const JsonParser = struct {
                         p.state = State.ObjectKey;
                     },
                     Token.Id.True => {
-                        _ = try object.put(key, Value { .Bool = true });
+                        _ = try object.put(key, Value{ .Bool = true });
                         _ = p.stack.pop();
                         p.state = State.ObjectKey;
                     },
                     Token.Id.False => {
-                        _ = try object.put(key, Value { .Bool = false });
+                        _ = try object.put(key, Value{ .Bool = false });
                         _ = p.stack.pop();
                         p.state = State.ObjectKey;
                     },
 @@ -1165,11 +1206,11 @@ const JsonParser = struct {
                         try p.pushToParent(value);
                     },
                     Token.Id.ObjectBegin => {
-                        try p.stack.append(Value { .Object = ObjectMap.init(allocator) });
+                        try p.stack.append(Value{ .Object = ObjectMap.init(allocator) });
                         p.state = State.ObjectKey;
                     },
                     Token.Id.ArrayBegin => {
-                        try p.stack.append(Value { .Array = ArrayList(Value).init(allocator) });
+                        try p.stack.append(Value{ .Array = ArrayList(Value).init(allocator) });
                         p.state = State.ArrayValue;
                     },
                     Token.Id.String => {
 @@ -1179,10 +1220,10 @@ const JsonParser = struct {
                         try array.append(try p.parseNumber(token, input, i));
                     },
                     Token.Id.True => {
-                        try array.append(Value { .Bool = true });
+                        try array.append(Value{ .Bool = true });
                     },
                     Token.Id.False => {
-                        try array.append(Value { .Bool = false });
+                        try array.append(Value{ .Bool = false });
                     },
                     Token.Id.Null => {
                         try array.append(Value.Null);
 @@ -1194,11 +1235,11 @@ const JsonParser = struct {
             },
             State.Simple => switch (token.id) {
                 Token.Id.ObjectBegin => {
-                    try p.stack.append(Value { .Object = ObjectMap.init(allocator) });
+                    try p.stack.append(Value{ .Object = ObjectMap.init(allocator) });
                     p.state = State.ObjectKey;
                 },
                 Token.Id.ArrayBegin => {
-                    try p.stack.append(Value { .Array = ArrayList(Value).init(allocator) });
+                    try p.stack.append(Value{ .Array = ArrayList(Value).init(allocator) });
                     p.state = State.ArrayValue;
                 },
                 Token.Id.String => {
 @@ -1208,15 +1249,16 @@ const JsonParser = struct {
                     try p.stack.append(try p.parseNumber(token, input, i));
                 },
                 Token.Id.True => {
-                    try p.stack.append(Value { .Bool = true });
+                    try p.stack.append(Value{ .Bool = true });
                 },
                 Token.Id.False => {
-                    try p.stack.append(Value { .Bool = false });
+                    try p.stack.append(Value{ .Bool = false });
                 },
                 Token.Id.Null => {
                     try p.stack.append(Value.Null);
                 },
-                Token.Id.ObjectEnd, Token.Id.ArrayEnd => {
+                Token.Id.ObjectEnd,
+                Token.Id.ArrayEnd => {
                     unreachable;
                 },
             },
 @@ -1248,15 +1290,14 @@ const JsonParser = struct {
         // TODO: We don't strictly have to copy values which do not contain any escape
         // characters if flagged with the option.
         const slice = token.slice(input, i);
-        return Value { .String = try mem.dupe(p.allocator, u8, slice) };
+        return Value{ .String = try mem.dupe(p.allocator, u8, slice) };
     }
     fn parseNumber(p: &JsonParser, token: &const Token, input: []const u8, i: usize) !Value {
         return if (token.number_is_integer)
-            Value { .Integer = try std.fmt.parseInt(i64, token.slice(input, i), 10) }
+            Value{ .Integer = try std.fmt.parseInt(i64, token.slice(input, i), 10) }
         else
-            @panic("TODO: fmt.parseFloat not yet implemented")
+            @panic("TODO: fmt.parseFloat not yet implemented");
-        ;
     }
 };
 @@ -1267,21 +1308,21 @@ test "json parser dynamic" {
     defer p.deinit();
     const s =
-      \\{
+        \\{
-      \\  "Image": {
+        \\  "Image": {
-      \\      "Width":  800,
+        \\      "Width":  800,
-      \\      "Height": 600,
+        \\      "Height": 600,
-      \\      "Title":  "View from 15th Floor",
+        \\      "Title":  "View from 15th Floor",
-      \\      "Thumbnail": {
+        \\      "Thumbnail": {
-      \\          "Url":    "http://www.example.com/image/481989943",
+        \\          "Url":    "http://www.example.com/image/481989943",
-      \\          "Height": 125,
+        \\          "Height": 125,
-      \\          "Width":  100
+        \\          "Width":  100
-      \\      },
+        \\      },
-      \\      "Animated" : false,
+        \\      "Animated" : false,
-      \\      "IDs": [116, 943, 234, 38793]
+        \\      "IDs": [116, 943, 234, 38793]
-      \\    }
+        \\    }
-      \\}
+        \\}
-      ;
+    ;
     var tree = try p.parse(s);
     defer tree.deinit();

std/math/acos.zig+7-7

std/math/asin.zig+9-9

std/math/atan2.zig+34-32

 @@ -31,7 +31,7 @@ pub fn atan2(comptime T: type, x: T, y: T) T {
 }
 fn atan2_32(y: f32, x: f32) f32 {
-    const pi: f32    =  3.1415927410e+00;
+    const pi: f32 = 3.1415927410e+00;
     const pi_lo: f32 = -8.7422776573e-08;
     if (math.isNan(x) or math.isNan(y)) {
 @@ -53,9 +53,10 @@ fn atan2_32(y: f32, x: f32) f32 {
     if (iy == 0) {
         switch (m) {
-            0, 1 => return  y,          // atan(+-0, +...)
+            0,
-            2    => return  pi,         // atan(+0, -...)
+            1 => return y, // atan(+-0, +...)
-            3    => return -pi,         // atan(-0, -...)
+            2 => return pi, // atan(+0, -...)
+            3 => return -pi, // atan(-0, -...)
             else => unreachable,
         }
     }
 @@ -71,18 +72,18 @@ fn atan2_32(y: f32, x: f32) f32 {
     if (ix == 0x7F800000) {
         if (iy == 0x7F800000) {
             switch (m) {
-                0    => return    pi / 4,   // atan(+inf, +inf)
+                0 => return pi / 4, // atan(+inf, +inf)
-                1    => return   -pi / 4,   // atan(-inf, +inf)
+                1 => return -pi / 4, // atan(-inf, +inf)
-                2    => return  3*pi / 4,   // atan(+inf, -inf)
+                2 => return 3 * pi / 4, // atan(+inf, -inf)
-                3    => return -3*pi / 4,   // atan(-inf, -inf)
+                3 => return -3 * pi / 4, // atan(-inf, -inf)
                 else => unreachable,
             }
         } else {
             switch (m) {
-                0    => return  0.0,   // atan(+..., +inf)
+                0 => return 0.0, // atan(+..., +inf)
-                1    => return -0.0,   // atan(-..., +inf)
+                1 => return -0.0, // atan(-..., +inf)
-                2    => return   pi,   // atan(+..., -inf)
+                2 => return pi, // atan(+..., -inf)
-                3    => return  -pi,   // atan(-...f, -inf)
+                3 => return -pi, // atan(-...f, -inf)
                 else => unreachable,
             }
         }
 @@ -107,16 +108,16 @@ fn atan2_32(y: f32, x: f32) f32 {
     };
     switch (m) {
-        0    => return  z,                  // atan(+, +)
+        0 => return z, // atan(+, +)
-        1    => return -z,                  // atan(-, +)
+        1 => return -z, // atan(-, +)
-        2    => return pi - (z - pi_lo),    // atan(+, -)
+        2 => return pi - (z - pi_lo), // atan(+, -)
-        3    => return (z - pi_lo) - pi,    // atan(-, -)
+        3 => return (z - pi_lo) - pi, // atan(-, -)
         else => unreachable,
     }
 }
 fn atan2_64(y: f64, x: f64) f64 {
-    const pi: f64    = 3.1415926535897931160E+00;
+    const pi: f64 = 3.1415926535897931160E+00;
     const pi_lo: f64 = 1.2246467991473531772E-16;
     if (math.isNan(x) or math.isNan(y)) {
 @@ -143,9 +144,10 @@ fn atan2_64(y: f64, x: f64) f64 {
     if (iy | ly == 0) {
         switch (m) {
-            0, 1 => return  y,          // atan(+-0, +...)
+            0,
-            2    => return  pi,         // atan(+0, -...)
+            1 => return y, // atan(+-0, +...)
-            3    => return -pi,         // atan(-0, -...)
+            2 => return pi, // atan(+0, -...)
+            3 => return -pi, // atan(-0, -...)
             else => unreachable,
         }
     }
 @@ -161,18 +163,18 @@ fn atan2_64(y: f64, x: f64) f64 {
     if (ix == 0x7FF00000) {
         if (iy == 0x7FF00000) {
             switch (m) {
-                0    => return    pi / 4,   // atan(+inf, +inf)
+                0 => return pi / 4, // atan(+inf, +inf)
-                1    => return   -pi / 4,   // atan(-inf, +inf)
+                1 => return -pi / 4, // atan(-inf, +inf)
-                2    => return  3*pi / 4,   // atan(+inf, -inf)
+                2 => return 3 * pi / 4, // atan(+inf, -inf)
-                3    => return -3*pi / 4,   // atan(-inf, -inf)
+                3 => return -3 * pi / 4, // atan(-inf, -inf)
                 else => unreachable,
             }
         } else {
             switch (m) {
-                0    => return  0.0,   // atan(+..., +inf)
+                0 => return 0.0, // atan(+..., +inf)
-                1    => return -0.0,   // atan(-..., +inf)
+                1 => return -0.0, // atan(-..., +inf)
-                2    => return   pi,   // atan(+..., -inf)
+                2 => return pi, // atan(+..., -inf)
-                3    => return  -pi,   // atan(-...f, -inf)
+                3 => return -pi, // atan(-...f, -inf)
                 else => unreachable,
             }
         }
 @@ -197,10 +199,10 @@ fn atan2_64(y: f64, x: f64) f64 {
     };
     switch (m) {
-        0    => return  z,                  // atan(+, +)
+        0 => return z, // atan(+, +)
-        1    => return -z,                  // atan(-, +)
+        1 => return -z, // atan(-, +)
-        2    => return pi - (z - pi_lo),    // atan(+, -)
+        2 => return pi - (z - pi_lo), // atan(+, -)
-        3    => return (z - pi_lo) - pi,    // atan(-, -)
+        3 => return (z - pi_lo) - pi, // atan(-, -)
         else => unreachable,
     }
 }

std/math/cbrt.zig+5-5

...	@@ -58,15 +58,15 @@ fn cbrt32(x: f32) f32 {	...	@@ -58,15 +58,15 @@ fn cbrt32(x: f32) f32 {
58	}	58	}
59		59
60	fn cbrt64(x: f64) f64 {	60	fn cbrt64(x: f64) f64 {
61	const B1: u32 = 715094163; // (1023 - 1023 / 3 - 0.03306235651 * 2^20	61	const B1: u32 = 715094163; // (1023 - 1023 / 3 - 0.03306235651 * 2^20
62	const B2: u32 = 696219795; // (1023 - 1023 / 3 - 54 / 3 - 0.03306235651 * 2^20	62	const B2: u32 = 696219795; // (1023 - 1023 / 3 - 54 / 3 - 0.03306235651 * 2^20
63		63
64	// \|1 / cbrt(x) - p(x)\| < 2^(23.5)	64	// \|1 / cbrt(x) - p(x)\| < 2^(23.5)
65	const P0: f64 = 1.87595182427177009643;	65	const P0: f64 = 1.87595182427177009643;
66	const P1: f64 = -1.88497979543377169875;	66	const P1: f64 = -1.88497979543377169875;
67	const P2: f64 = 1.621429720105354466140;	67	const P2: f64 = 1.621429720105354466140;
68	const P3: f64 = -0.758397934778766047437;	68	const P3: f64 = -0.758397934778766047437;
69	const P4: f64 = 0.145996192886612446982;	69	const P4: f64 = 0.145996192886612446982;
70		70
71	var u = @bitCast(u64, x);	71	var u = @bitCast(u64, x);
72	var hx = u32(u >> 32) & 0x7FFFFFFF;	72	var hx = u32(u >> 32) & 0x7FFFFFFF;

std/math/ceil.zig+2-2

...	@@ -56,7 +56,7 @@ fn ceil64(x: f64) f64 {	...	@@ -56,7 +56,7 @@ fn ceil64(x: f64) f64 {
56	const e = (u >> 52) & 0x7FF;	56	const e = (u >> 52) & 0x7FF;
57	var y: f64 = undefined;	57	var y: f64 = undefined;
58		58
59	if (e >= 0x3FF+52 or x == 0) {	59	if (e >= 0x3FF + 52 or x == 0) {
60	return x;	60	return x;
61	}	61	}
62		62
...	@@ -68,7 +68,7 @@ fn ceil64(x: f64) f64 {	...	@@ -68,7 +68,7 @@ fn ceil64(x: f64) f64 {
68	y = x + math.f64_toint - math.f64_toint - x;	68	y = x + math.f64_toint - math.f64_toint - x;
69	}	69	}
70		70
71	if (e <= 0x3FF-1) {	71	if (e <= 0x3FF - 1) {
72	math.forceEval(y);	72	math.forceEval(y);
73	if (u >> 63 != 0) {	73	if (u >> 63 != 0) {
74	return -0.0;	74	return -0.0;

std/math/cos.zig+6-6

std/math/floor.zig+2-2

...	@@ -57,7 +57,7 @@ fn floor64(x: f64) f64 {	...	@@ -57,7 +57,7 @@ fn floor64(x: f64) f64 {
57	const e = (u >> 52) & 0x7FF;	57	const e = (u >> 52) & 0x7FF;
58	var y: f64 = undefined;	58	var y: f64 = undefined;
59		59
60	if (e >= 0x3FF+52 or x == 0) {	60	if (e >= 0x3FF + 52 or x == 0) {
61	return x;	61	return x;
62	}	62	}
63		63
...	@@ -69,7 +69,7 @@ fn floor64(x: f64) f64 {	...	@@ -69,7 +69,7 @@ fn floor64(x: f64) f64 {
69	y = x + math.f64_toint - math.f64_toint - x;	69	y = x + math.f64_toint - math.f64_toint - x;
70	}	70	}
71		71
72	if (e <= 0x3FF-1) {	72	if (e <= 0x3FF - 1) {
73	math.forceEval(y);	73	math.forceEval(y);
74	if (u >> 63 != 0) {	74	if (u >> 63 != 0) {
75	return -1.0;	75	return -1.0;

std/math/fma.zig+5-2

...	@@ -5,7 +5,7 @@ const assert = std.debug.assert;	...	@@ -5,7 +5,7 @@ const assert = std.debug.assert;
5	pub fn fma(comptime T: type, x: T, y: T, z: T) T {	5	pub fn fma(comptime T: type, x: T, y: T, z: T) T {
6	return switch (T) {	6	return switch (T) {
7	f32 => fma32(x, y, z),	7	f32 => fma32(x, y, z),
8	f64 => fma64(x, y ,z),	8	f64 => fma64(x, y, z),
9	else => @compileError("fma not implemented for " ++ @typeName(T)),	9	else => @compileError("fma not implemented for " ++ @typeName(T)),
10	};	10	};
11	}	11	}
...	@@ -71,7 +71,10 @@ fn fma64(x: f64, y: f64, z: f64) f64 {	...	@@ -71,7 +71,10 @@ fn fma64(x: f64, y: f64, z: f64) f64 {
71	}	71	}
72	}	72	}
73		73
74	const dd = struct { hi: f64, lo: f64, };	74	const dd = struct {
		75	hi: f64,
		76	lo: f64,
		77	};
75		78
76	fn dd_add(a: f64, b: f64) dd {	79	fn dd_add(a: f64, b: f64) dd {
77	var ret: dd = undefined;	80	var ret: dd = undefined;

std/math/hypot.zig+4-4

...	@@ -39,11 +39,11 @@ fn hypot32(x: f32, y: f32) f32 {	...	@@ -39,11 +39,11 @@ fn hypot32(x: f32, y: f32) f32 {
39	}	39	}
40		40
41	var z: f32 = 1.0;	41	var z: f32 = 1.0;
42	if (ux >= (0x7F+60) << 23) {	42	if (ux >= (0x7F + 60) << 23) {
43	z = 0x1.0p90;	43	z = 0x1.0p90;
44	xx *= 0x1.0p-90;	44	xx *= 0x1.0p-90;
45	yy *= 0x1.0p-90;	45	yy *= 0x1.0p-90;
46	} else if (uy < (0x7F-60) << 23) {	46	} else if (uy < (0x7F - 60) << 23) {
47	z = 0x1.0p-90;	47	z = 0x1.0p-90;
48	xx *= 0x1.0p-90;	48	xx *= 0x1.0p-90;
49	yy *= 0x1.0p-90;	49	yy *= 0x1.0p-90;
...	@@ -57,8 +57,8 @@ fn sq(hi: &f64, lo: &f64, x: f64) void {	...	@@ -57,8 +57,8 @@ fn sq(hi: &f64, lo: &f64, x: f64) void {
57	const xc = x * split;	57	const xc = x * split;
58	const xh = x - xc + xc;	58	const xh = x - xc + xc;
59	const xl = x - xh;	59	const xl = x - xh;
60	hi = x x;	60	hi.* = x * x;
61	lo = xh xh - hi + 2 xh * xl + xl * xl;	61	lo.* = xh * xh - hi.* + 2 * xh * xl + xl * xl;
62	}	62	}
63		63
64	fn hypot64(x: f64, y: f64) f64 {	64	fn hypot64(x: f64, y: f64) f64 {

std/math/ln.zig+2-4

 @@ -120,11 +120,9 @@ pub fn ln_64(x_: f64) f64 {
         k -= 54;
         x *= 0x1.0p54;
         hx = u32(@bitCast(u64, ix) >> 32);
-    }
+    } else if (hx >= 0x7FF00000) {
-    else if (hx >= 0x7FF00000) {
         return x;
-    }
+    } else if (hx == 0x3FF00000 and ix << 32 == 0) {
-    else if (hx == 0x3FF00000 and ix << 32 == 0) {
         return 0;
     }

std/math/log10.zig+8-10

 @@ -35,10 +35,10 @@ pub fn log10(x: var) @typeOf(x) {
 }
 pub fn log10_32(x_: f32) f32 {
-    const ivln10hi: f32  =  4.3432617188e-01;
+    const ivln10hi: f32 = 4.3432617188e-01;
-    const ivln10lo: f32  = -3.1689971365e-05;
+    const ivln10lo: f32 = -3.1689971365e-05;
-    const log10_2hi: f32 =  3.0102920532e-01;
+    const log10_2hi: f32 = 3.0102920532e-01;
-    const log10_2lo: f32 =  7.9034151668e-07;
+    const log10_2lo: f32 = 7.9034151668e-07;
     const Lg1: f32 = 0xaaaaaa.0p-24;
     const Lg2: f32 = 0xccce13.0p-25;
     const Lg3: f32 = 0x91e9ee.0p-25;
 @@ -95,8 +95,8 @@ pub fn log10_32(x_: f32) f32 {
 }
 pub fn log10_64(x_: f64) f64 {
-    const ivln10hi: f64  = 4.34294481878168880939e-01;
+    const ivln10hi: f64 = 4.34294481878168880939e-01;
-    const ivln10lo: f64  = 2.50829467116452752298e-11;
+    const ivln10lo: f64 = 2.50829467116452752298e-11;
     const log10_2hi: f64 = 3.01029995663611771306e-01;
     const log10_2lo: f64 = 3.69423907715893078616e-13;
     const Lg1: f64 = 6.666666666666735130e-01;
 @@ -126,11 +126,9 @@ pub fn log10_64(x_: f64) f64 {
         k -= 54;
         x *= 0x1.0p54;
         hx = u32(@bitCast(u64, x) >> 32);
-    }
+    } else if (hx >= 0x7FF00000) {
-    else if (hx >= 0x7FF00000) {
         return x;
-    }
+    } else if (hx == 0x3FF00000 and ix << 32 == 0) {
-    else if (hx == 0x3FF00000 and ix << 32 == 0) {
         return 0;
     }

std/math/log2.zig+5-2

...	@@ -27,7 +27,10 @@ pub fn log2(x: var) @typeOf(x) {	...	@@ -27,7 +27,10 @@ pub fn log2(x: var) @typeOf(x) {
27	TypeId.IntLiteral => comptime {	27	TypeId.IntLiteral => comptime {
28	var result = 0;	28	var result = 0;
29	var x_shifted = x;	29	var x_shifted = x;
30	while (b: {x_shifted >>= 1; break :b x_shifted != 0;}) : (result += 1) {}	30	while (b: {
		31	x_shifted >>= 1;
		32	break :b x_shifted != 0;
		33	}) : (result += 1) {}
31	return result;	34	return result;
32	},	35	},
33	TypeId.Int => {	36	TypeId.Int => {
...	@@ -38,7 +41,7 @@ pub fn log2(x: var) @typeOf(x) {	...	@@ -38,7 +41,7 @@ pub fn log2(x: var) @typeOf(x) {
38	}	41	}
39		42
40	pub fn log2_32(x_: f32) f32 {	43	pub fn log2_32(x_: f32) f32 {
41	const ivln2hi: f32 = 1.4428710938e+00;	44	const ivln2hi: f32 = 1.4428710938e+00;
42	const ivln2lo: f32 = -1.7605285393e-04;	45	const ivln2lo: f32 = -1.7605285393e-04;
43	const Lg1: f32 = 0xaaaaaa.0p-24;	46	const Lg1: f32 = 0xaaaaaa.0p-24;
44	const Lg2: f32 = 0xccce13.0p-25;	47	const Lg2: f32 = 0xccce13.0p-25;

std/math/round.zig+4-4

...	@@ -24,13 +24,13 @@ fn round32(x_: f32) f32 {	...	@@ -24,13 +24,13 @@ fn round32(x_: f32) f32 {
24	const e = (u >> 23) & 0xFF;	24	const e = (u >> 23) & 0xFF;
25	var y: f32 = undefined;	25	var y: f32 = undefined;
26		26
27	if (e >= 0x7F+23) {	27	if (e >= 0x7F + 23) {
28	return x;	28	return x;
29	}	29	}
30	if (u >> 31 != 0) {	30	if (u >> 31 != 0) {
31	x = -x;	31	x = -x;
32	}	32	}
33	if (e < 0x7F-1) {	33	if (e < 0x7F - 1) {
34	math.forceEval(x + math.f32_toint);	34	math.forceEval(x + math.f32_toint);
35	return 0 * @bitCast(f32, u);	35	return 0 * @bitCast(f32, u);
36	}	36	}
...	@@ -61,13 +61,13 @@ fn round64(x_: f64) f64 {	...	@@ -61,13 +61,13 @@ fn round64(x_: f64) f64 {
61	const e = (u >> 52) & 0x7FF;	61	const e = (u >> 52) & 0x7FF;
62	var y: f64 = undefined;	62	var y: f64 = undefined;
63		63
64	if (e >= 0x3FF+52) {	64	if (e >= 0x3FF + 52) {
65	return x;	65	return x;
66	}	66	}
67	if (u >> 63 != 0) {	67	if (u >> 63 != 0) {
68	x = -x;	68	x = -x;
69	}	69	}
70	if (e < 0x3ff-1) {	70	if (e < 0x3ff - 1) {
71	math.forceEval(x + math.f64_toint);	71	math.forceEval(x + math.f64_toint);
72	return 0 * @bitCast(f64, u);	72	return 0 * @bitCast(f64, u);
73	}	73	}

std/math/sin.zig+6-6

std/math/tan.zig+3-3

...	@@ -19,12 +19,12 @@ pub fn tan(x: var) @typeOf(x) {	...	@@ -19,12 +19,12 @@ pub fn tan(x: var) @typeOf(x) {
19	}	19	}
20		20
21	const Tp0 = -1.30936939181383777646E4;	21	const Tp0 = -1.30936939181383777646E4;
22	const Tp1 = 1.15351664838587416140E6;	22	const Tp1 = 1.15351664838587416140E6;
23	const Tp2 = -1.79565251976484877988E7;	23	const Tp2 = -1.79565251976484877988E7;
24		24
25	const Tq1 = 1.36812963470692954678E4;	25	const Tq1 = 1.36812963470692954678E4;
26	const Tq2 = -1.32089234440210967447E6;	26	const Tq2 = -1.32089234440210967447E6;
27	const Tq3 = 2.50083801823357915839E7;	27	const Tq3 = 2.50083801823357915839E7;
28	const Tq4 = -5.38695755929454629881E7;	28	const Tq4 = -5.38695755929454629881E7;
29		29
30	// NOTE: This is taken from the go stdlib. The musl implementation is much more complex.	30	// NOTE: This is taken from the go stdlib. The musl implementation is much more complex.

std/net.zig+16-24

 @@ -19,37 +19,29 @@ pub const Address = struct {
     os_addr: OsAddress,
     pub fn initIp4(ip4: u32, port: u16) Address {
-        return Address {
+        return Address{ .os_addr = posix.sockaddr{ .in = posix.sockaddr_in{
-            .os_addr = posix.sockaddr {
+            .family = posix.AF_INET,
-                .in = posix.sockaddr_in {
+            .port = std.mem.endianSwapIfLe(u16, port),
-                    .family = posix.AF_INET,
+            .addr = ip4,
-                    .port = std.mem.endianSwapIfLe(u16, port),
+            .zero = []u8{0} ** 8,
-                    .addr = ip4,
+        } } };
-                    .zero = []u8{0} ** 8,
-                },
-            },
-        };
     }
     pub fn initIp6(ip6: &const Ip6Addr, port: u16) Address {
-        return Address {
+        return Address{
             .family = posix.AF_INET6,
-            .os_addr = posix.sockaddr {
+            .os_addr = posix.sockaddr{ .in6 = posix.sockaddr_in6{
-                .in6 = posix.sockaddr_in6 {
+                .family = posix.AF_INET6,
-                    .family = posix.AF_INET6,
+                .port = std.mem.endianSwapIfLe(u16, port),
-                    .port = std.mem.endianSwapIfLe(u16, port),
+                .flowinfo = 0,
-                    .flowinfo = 0,
+                .addr = ip6.addr,
-                    .addr = ip6.addr,
+                .scope_id = ip6.scope_id,
-                    .scope_id = ip6.scope_id,
+            } },
-                },
-            },
         };
     }
     pub fn initPosix(addr: &const posix.sockaddr) Address {
-        return Address {
+        return Address{ .os_addr = addr.* };
-            .os_addr = *addr,
-        };
     }
     pub fn format(self: &const Address, out_stream: var) !void {
 @@ -98,7 +90,7 @@ pub fn parseIp4(buf: []const u8) !u32 {
             }
         } else {
             return error.InvalidCharacter;
         }
     }
     if (index == 3 and saw_any_digits) {
         out_ptr[index] = x;

std/os/child_process.zig+101-91

 @@ -49,7 +49,7 @@ pub const ChildProcess = struct {
     err_pipe: if (is_windows) void else [2]i32,
     llnode: if (is_windows) void else LinkedList(&ChildProcess).Node,
-    pub const SpawnError = error {
+    pub const SpawnError = error{
         ProcessFdQuotaExceeded,
         Unexpected,
         NotDir,
 @@ -88,7 +88,7 @@ pub const ChildProcess = struct {
         const child = try allocator.create(ChildProcess);
         errdefer allocator.destroy(child);
-        *child = ChildProcess {
+        child.* = ChildProcess{
             .allocator = allocator,
             .argv = argv,
             .pid = undefined,
 @@ -99,8 +99,10 @@ pub const ChildProcess = struct {
             .term = null,
             .env_map = null,
             .cwd = null,
-            .uid = if (is_windows) {} else null,
+            .uid = if (is_windows) {} else
-            .gid = if (is_windows) {} else null,
+                null,
+            .gid = if (is_windows) {} else
+                null,
             .stdin = null,
             .stdout = null,
             .stderr = null,
 @@ -193,9 +195,7 @@ pub const ChildProcess = struct {
     /// Spawns a child process, waits for it, collecting stdout and stderr, and then returns.
     /// If it succeeds, the caller owns result.stdout and result.stderr memory.
-    pub fn exec(allocator: &mem.Allocator, argv: []const []const u8, cwd: ?[]const u8,
+    pub fn exec(allocator: &mem.Allocator, argv: []const []const u8, cwd: ?[]const u8, env_map: ?&const BufMap, max_output_size: usize) !ExecResult {
-        env_map: ?&const BufMap, max_output_size: usize) !ExecResult
-    {
         const child = try ChildProcess.init(argv, allocator);
         defer child.deinit();
 @@ -218,7 +218,7 @@ pub const ChildProcess = struct {
         try stdout_file_in_stream.stream.readAllBuffer(&stdout, max_output_size);
         try stderr_file_in_stream.stream.readAllBuffer(&stderr, max_output_size);
-        return ExecResult {
+        return ExecResult{
             .term = try child.wait(),
             .stdout = stdout.toOwnedSlice(),
             .stderr = stderr.toOwnedSlice(),
 @@ -255,9 +255,9 @@ pub const ChildProcess = struct {
         self.term = (SpawnError!Term)(x: {
             var exit_code: windows.DWORD = undefined;
             if (windows.GetExitCodeProcess(self.handle, &exit_code) == 0) {
-                break :x Term { .Unknown = 0 };
+                break :x Term{ .Unknown = 0 };
             } else {
-                break :x Term { .Exited = @bitCast(i32, exit_code)};
+                break :x Term{ .Exited = @bitCast(i32, exit_code) };
             }
         });
 @@ -288,9 +288,18 @@ pub const ChildProcess = struct {
     }
     fn cleanupStreams(self: &ChildProcess) void {
-        if (self.stdin) |*stdin| { stdin.close(); self.stdin = null; }
+        if (self.stdin) |*stdin| {
-        if (self.stdout) |*stdout| { stdout.close(); self.stdout = null; }
+            stdin.close();
-        if (self.stderr) |*stderr| { stderr.close(); self.stderr = null; }
+            self.stdin = null;
+        }
+        if (self.stdout) |*stdout| {
+            stdout.close();
+            self.stdout = null;
+        }
+        if (self.stderr) |*stderr| {
+            stderr.close();
+            self.stderr = null;
+        }
     }
     fn cleanupAfterWait(self: &ChildProcess, status: i32) !Term {
 @@ -317,25 +326,30 @@ pub const ChildProcess = struct {
     fn statusToTerm(status: i32) Term {
         return if (posix.WIFEXITED(status))
-            Term { .Exited = posix.WEXITSTATUS(status) }
+            Term{ .Exited = posix.WEXITSTATUS(status) }
         else if (posix.WIFSIGNALED(status))
-            Term { .Signal = posix.WTERMSIG(status) }
+            Term{ .Signal = posix.WTERMSIG(status) }
         else if (posix.WIFSTOPPED(status))
-            Term { .Stopped = posix.WSTOPSIG(status) }
+            Term{ .Stopped = posix.WSTOPSIG(status) }
         else
-            Term { .Unknown = status }
+            Term{ .Unknown = status };
-        ;
     }
     fn spawnPosix(self: &ChildProcess) !void {
         const stdin_pipe = if (self.stdin_behavior == StdIo.Pipe) try makePipe() else undefined;
-        errdefer if (self.stdin_behavior == StdIo.Pipe) { destroyPipe(stdin_pipe); };
+        errdefer if (self.stdin_behavior == StdIo.Pipe) {
+            destroyPipe(stdin_pipe);
+        };
         const stdout_pipe = if (self.stdout_behavior == StdIo.Pipe) try makePipe() else undefined;
-        errdefer if (self.stdout_behavior == StdIo.Pipe) { destroyPipe(stdout_pipe); };
+        errdefer if (self.stdout_behavior == StdIo.Pipe) {
+            destroyPipe(stdout_pipe);
+        };
         const stderr_pipe = if (self.stderr_behavior == StdIo.Pipe) try makePipe() else undefined;
-        errdefer if (self.stderr_behavior == StdIo.Pipe) { destroyPipe(stderr_pipe); };
+        errdefer if (self.stderr_behavior == StdIo.Pipe) {
+            destroyPipe(stderr_pipe);
+        };
         const any_ignore = (self.stdin_behavior == StdIo.Ignore or self.stdout_behavior == StdIo.Ignore or self.stderr_behavior == StdIo.Ignore);
         const dev_null_fd = if (any_ignore) blk: {
 @@ -346,7 +360,9 @@ pub const ChildProcess = struct {
         } else blk: {
             break :blk undefined;
         };
-        defer { if (any_ignore) os.close(dev_null_fd); }
+        defer {
+            if (any_ignore) os.close(dev_null_fd);
+        }
         var env_map_owned: BufMap = undefined;
         var we_own_env_map: bool = undefined;
 @@ -358,7 +374,9 @@ pub const ChildProcess = struct {
             env_map_owned = try os.getEnvMap(self.allocator);
             break :x &env_map_owned;
         };
-        defer { if (we_own_env_map) env_map_owned.deinit(); }
+        defer {
+            if (we_own_env_map) env_map_owned.deinit();
+        }
         // This pipe is used to communicate errors between the time of fork
         // and execve from the child process to the parent process.
 @@ -369,23 +387,21 @@ pub const ChildProcess = struct {
         const pid_err = posix.getErrno(pid_result);
         if (pid_err > 0) {
             return switch (pid_err) {
-                posix.EAGAIN, posix.ENOMEM, posix.ENOSYS => error.SystemResources,
+                posix.EAGAIN,
+                posix.ENOMEM,
+                posix.ENOSYS => error.SystemResources,
                 else => os.unexpectedErrorPosix(pid_err),
             };
         }
         if (pid_result == 0) {
             // we are the child
-            setUpChildIo(self.stdin_behavior, stdin_pipe[0], posix.STDIN_FILENO, dev_null_fd) catch
+            setUpChildIo(self.stdin_behavior, stdin_pipe[0], posix.STDIN_FILENO, dev_null_fd) catch |err| forkChildErrReport(err_pipe[1], err);
-                |err| forkChildErrReport(err_pipe[1], err);
+            setUpChildIo(self.stdout_behavior, stdout_pipe[1], posix.STDOUT_FILENO, dev_null_fd) catch |err| forkChildErrReport(err_pipe[1], err);
-            setUpChildIo(self.stdout_behavior, stdout_pipe[1], posix.STDOUT_FILENO, dev_null_fd) catch
+            setUpChildIo(self.stderr_behavior, stderr_pipe[1], posix.STDERR_FILENO, dev_null_fd) catch |err| forkChildErrReport(err_pipe[1], err);
-                |err| forkChildErrReport(err_pipe[1], err);
-            setUpChildIo(self.stderr_behavior, stderr_pipe[1], posix.STDERR_FILENO, dev_null_fd) catch
-                |err| forkChildErrReport(err_pipe[1], err);
             if (self.cwd) |cwd| {
-                os.changeCurDir(self.allocator, cwd) catch
+                os.changeCurDir(self.allocator, cwd) catch |err| forkChildErrReport(err_pipe[1], err);
-                    |err| forkChildErrReport(err_pipe[1], err);
             }
             if (self.gid) |gid| {
 @@ -396,8 +412,7 @@ pub const ChildProcess = struct {
                 os.posix_setreuid(uid, uid) catch |err| forkChildErrReport(err_pipe[1], err);
             }
-            os.posixExecve(self.argv, env_map, self.allocator) catch
+            os.posixExecve(self.argv, env_map, self.allocator) catch |err| forkChildErrReport(err_pipe[1], err);
-                |err| forkChildErrReport(err_pipe[1], err);
         }
         // we are the parent
 @@ -423,37 +438,41 @@ pub const ChildProcess = struct {
         self.llnode = LinkedList(&ChildProcess).Node.init(self);
         self.term = null;
-        if (self.stdin_behavior == StdIo.Pipe) { os.close(stdin_pipe[0]); }
+        if (self.stdin_behavior == StdIo.Pipe) {
-        if (self.stdout_behavior == StdIo.Pipe) { os.close(stdout_pipe[1]); }
+            os.close(stdin_pipe[0]);
-        if (self.stderr_behavior == StdIo.Pipe) { os.close(stderr_pipe[1]); }
+        }
+        if (self.stdout_behavior == StdIo.Pipe) {
+            os.close(stdout_pipe[1]);
+        }
+        if (self.stderr_behavior == StdIo.Pipe) {
+            os.close(stderr_pipe[1]);
+        }
     }
     fn spawnWindows(self: &ChildProcess) !void {
-        const saAttr = windows.SECURITY_ATTRIBUTES {
+        const saAttr = windows.SECURITY_ATTRIBUTES{
             .nLength = @sizeOf(windows.SECURITY_ATTRIBUTES),
             .bInheritHandle = windows.TRUE,
             .lpSecurityDescriptor = null,
         };
-        const any_ignore = (self.stdin_behavior == StdIo.Ignore or
+        const any_ignore = (self.stdin_behavior == StdIo.Ignore or self.stdout_behavior == StdIo.Ignore or self.stderr_behavior == StdIo.Ignore);
-            self.stdout_behavior == StdIo.Ignore or
-            self.stderr_behavior == StdIo.Ignore);
         const nul_handle = if (any_ignore) blk: {
             const nul_file_path = "NUL";
             var fixed_buffer_mem: [nul_file_path.len + 1]u8 = undefined;
             var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
-            break :blk try os.windowsOpen(&fixed_allocator.allocator, "NUL", windows.GENERIC_READ, windows.FILE_SHARE_READ,
+            break :blk try os.windowsOpen(&fixed_allocator.allocator, "NUL", windows.GENERIC_READ, windows.FILE_SHARE_READ, windows.OPEN_EXISTING, windows.FILE_ATTRIBUTE_NORMAL);
-                windows.OPEN_EXISTING, windows.FILE_ATTRIBUTE_NORMAL);
         } else blk: {
             break :blk undefined;
         };
-        defer { if (any_ignore) os.close(nul_handle); }
+        defer {
+            if (any_ignore) os.close(nul_handle);
+        }
         if (any_ignore) {
             try windowsSetHandleInfo(nul_handle, windows.HANDLE_FLAG_INHERIT, 0);
         }
         var g_hChildStd_IN_Rd: ?windows.HANDLE = null;
         var g_hChildStd_IN_Wr: ?windows.HANDLE = null;
         switch (self.stdin_behavior) {
 @@ -470,7 +489,9 @@ pub const ChildProcess = struct {
                 g_hChildStd_IN_Rd = null;
             },
         }
-        errdefer if (self.stdin_behavior == StdIo.Pipe) { windowsDestroyPipe(g_hChildStd_IN_Rd, g_hChildStd_IN_Wr); };
+        errdefer if (self.stdin_behavior == StdIo.Pipe) {
+            windowsDestroyPipe(g_hChildStd_IN_Rd, g_hChildStd_IN_Wr);
+        };
         var g_hChildStd_OUT_Rd: ?windows.HANDLE = null;
         var g_hChildStd_OUT_Wr: ?windows.HANDLE = null;
 @@ -488,7 +509,9 @@ pub const ChildProcess = struct {
                 g_hChildStd_OUT_Wr = null;
             },
         }
-        errdefer if (self.stdin_behavior == StdIo.Pipe) { windowsDestroyPipe(g_hChildStd_OUT_Rd, g_hChildStd_OUT_Wr); };
+        errdefer if (self.stdin_behavior == StdIo.Pipe) {
+            windowsDestroyPipe(g_hChildStd_OUT_Rd, g_hChildStd_OUT_Wr);
+        };
         var g_hChildStd_ERR_Rd: ?windows.HANDLE = null;
         var g_hChildStd_ERR_Wr: ?windows.HANDLE = null;
 @@ -506,12 +529,14 @@ pub const ChildProcess = struct {
                 g_hChildStd_ERR_Wr = null;
             },
         }
-        errdefer if (self.stdin_behavior == StdIo.Pipe) { windowsDestroyPipe(g_hChildStd_ERR_Rd, g_hChildStd_ERR_Wr); };
+        errdefer if (self.stdin_behavior == StdIo.Pipe) {
+            windowsDestroyPipe(g_hChildStd_ERR_Rd, g_hChildStd_ERR_Wr);
+        };
         const cmd_line = try windowsCreateCommandLine(self.allocator, self.argv);
         defer self.allocator.free(cmd_line);
-        var siStartInfo = windows.STARTUPINFOA {
+        var siStartInfo = windows.STARTUPINFOA{
             .cb = @sizeOf(windows.STARTUPINFOA),
             .hStdError = g_hChildStd_ERR_Wr,
             .hStdOutput = g_hChildStd_OUT_Wr,
 @@ -534,19 +559,11 @@ pub const ChildProcess = struct {
         };
         var piProcInfo: windows.PROCESS_INFORMATION = undefined;
-        const cwd_slice = if (self.cwd) |cwd|
+        const cwd_slice = if (self.cwd) |cwd| try cstr.addNullByte(self.allocator, cwd) else null;
-            try cstr.addNullByte(self.allocator, cwd)
-        else
-            null
-        ;
         defer if (cwd_slice) |cwd| self.allocator.free(cwd);
         const cwd_ptr = if (cwd_slice) |cwd| cwd.ptr else null;
-        const maybe_envp_buf = if (self.env_map) |env_map|
+        const maybe_envp_buf = if (self.env_map) |env_map| try os.createWindowsEnvBlock(self.allocator, env_map) else null;
-            try os.createWindowsEnvBlock(self.allocator, env_map)
-        else
-            null
-        ;
         defer if (maybe_envp_buf) |envp_buf| self.allocator.free(envp_buf);
         const envp_ptr = if (maybe_envp_buf) |envp_buf| envp_buf.ptr else null;
 @@ -563,11 +580,8 @@ pub const ChildProcess = struct {
         };
         defer self.allocator.free(app_name);
-        windowsCreateProcess(app_name.ptr, cmd_line.ptr, envp_ptr, cwd_ptr,
+        windowsCreateProcess(app_name.ptr, cmd_line.ptr, envp_ptr, cwd_ptr, &siStartInfo, &piProcInfo) catch |no_path_err| {
-            &siStartInfo, &piProcInfo) catch |no_path_err|
+            if (no_path_err != error.FileNotFound) return no_path_err;
-        {
-            if (no_path_err != error.FileNotFound)
-                return no_path_err;
             const PATH = try os.getEnvVarOwned(self.allocator, "PATH");
             defer self.allocator.free(PATH);
 @@ -577,9 +591,7 @@ pub const ChildProcess = struct {
                 const joined_path = try os.path.join(self.allocator, search_path, app_name);
                 defer self.allocator.free(joined_path);
-                if (windowsCreateProcess(joined_path.ptr, cmd_line.ptr, envp_ptr, cwd_ptr,
+                if (windowsCreateProcess(joined_path.ptr, cmd_line.ptr, envp_ptr, cwd_ptr, &siStartInfo, &piProcInfo)) |_| {
-                    &siStartInfo, &piProcInfo)) |_|
-                {
                     break;
                 } else |err| if (err == error.FileNotFound) {
                     continue;
 @@ -609,9 +621,15 @@ pub const ChildProcess = struct {
         self.thread_handle = piProcInfo.hThread;
         self.term = null;
-        if (self.stdin_behavior == StdIo.Pipe) { os.close(??g_hChildStd_IN_Rd); }
+        if (self.stdin_behavior == StdIo.Pipe) {
-        if (self.stderr_behavior == StdIo.Pipe) { os.close(??g_hChildStd_ERR_Wr); }
+            os.close(??g_hChildStd_IN_Rd);
-        if (self.stdout_behavior == StdIo.Pipe) { os.close(??g_hChildStd_OUT_Wr); }
+        }
+        if (self.stderr_behavior == StdIo.Pipe) {
+            os.close(??g_hChildStd_ERR_Wr);
+        }
+        if (self.stdout_behavior == StdIo.Pipe) {
+            os.close(??g_hChildStd_OUT_Wr);
+        }
     }
     fn setUpChildIo(stdio: StdIo, pipe_fd: i32, std_fileno: i32, dev_null_fd: i32) !void {
 @@ -622,18 +640,14 @@ pub const ChildProcess = struct {
             StdIo.Ignore => try os.posixDup2(dev_null_fd, std_fileno),
         }
     }
 };
-fn windowsCreateProcess(app_name: &u8, cmd_line: &u8, envp_ptr: ?&u8, cwd_ptr: ?&u8,
+fn windowsCreateProcess(app_name: &u8, cmd_line: &u8, envp_ptr: ?&u8, cwd_ptr: ?&u8, lpStartupInfo: &windows.STARTUPINFOA, lpProcessInformation: &windows.PROCESS_INFORMATION) !void {
-    lpStartupInfo: &windows.STARTUPINFOA, lpProcessInformation: &windows.PROCESS_INFORMATION) !void
+    if (windows.CreateProcessA(app_name, cmd_line, null, null, windows.TRUE, 0, @ptrCast(?&c_void, envp_ptr), cwd_ptr, lpStartupInfo, lpProcessInformation) == 0) {
-{
-    if (windows.CreateProcessA(app_name, cmd_line, null, null, windows.TRUE, 0,
-        @ptrCast(?&c_void, envp_ptr), cwd_ptr, lpStartupInfo, lpProcessInformation) == 0)
-    {
         const err = windows.GetLastError();
         return switch (err) {
-            windows.ERROR.FILE_NOT_FOUND, windows.ERROR.PATH_NOT_FOUND => error.FileNotFound,
+            windows.ERROR.FILE_NOT_FOUND,
+            windows.ERROR.PATH_NOT_FOUND => error.FileNotFound,
             windows.ERROR.INVALID_PARAMETER => unreachable,
             windows.ERROR.INVALID_NAME => error.InvalidName,
             else => os.unexpectedErrorWindows(err),
 @@ -641,9 +655,6 @@ fn windowsCreateProcess(app_name: &u8, cmd_line: &u8, envp_ptr: ?&u8, cwd_ptr: ?
     }
 }
 /// Caller must dealloc.
 /// Guarantees a null byte at result[result.len].
 fn windowsCreateCommandLine(allocator: &mem.Allocator, argv: []const []const u8) ![]u8 {
 @@ -651,8 +662,7 @@ fn windowsCreateCommandLine(allocator: &mem.Allocator, argv: []const []const u8)
     defer buf.deinit();
     for (argv) |arg, arg_i| {
-        if (arg_i != 0)
+        if (arg_i != 0) try buf.appendByte(' ');
-            try buf.appendByte(' ');
         if (mem.indexOfAny(u8, arg, " \t\n\"") == null) {
             try buf.append(arg);
             continue;
 @@ -686,7 +696,6 @@ fn windowsDestroyPipe(rd: ?windows.HANDLE, wr: ?windows.HANDLE) void {
     if (wr) |h| os.close(h);
 }
 // TODO: workaround for bug where the `const` from `&const` is dropped when the type is
 // a namespace field lookup
 const SECURITY_ATTRIBUTES = windows.SECURITY_ATTRIBUTES;
 @@ -715,8 +724,8 @@ fn windowsMakePipeIn(rd: &?windows.HANDLE, wr: &?windows.HANDLE, sattr: &const S
     try windowsMakePipe(&rd_h, &wr_h, sattr);
     errdefer windowsDestroyPipe(rd_h, wr_h);
     try windowsSetHandleInfo(wr_h, windows.HANDLE_FLAG_INHERIT, 0);
-    *rd = rd_h;
+    rd.* = rd_h;
-    *wr = wr_h;
+    wr.* = wr_h;
 }
 fn windowsMakePipeOut(rd: &?windows.HANDLE, wr: &?windows.HANDLE, sattr: &const SECURITY_ATTRIBUTES) !void {
 @@ -725,8 +734,8 @@ fn windowsMakePipeOut(rd: &?windows.HANDLE, wr: &?windows.HANDLE, sattr: &const
     try windowsMakePipe(&rd_h, &wr_h, sattr);
     errdefer windowsDestroyPipe(rd_h, wr_h);
     try windowsSetHandleInfo(rd_h, windows.HANDLE_FLAG_INHERIT, 0);
-    *rd = rd_h;
+    rd.* = rd_h;
-    *wr = wr_h;
+    wr.* = wr_h;
 }
 fn makePipe() ![2]i32 {
 @@ -734,7 +743,8 @@ fn makePipe() ![2]i32 {
     const err = posix.getErrno(posix.pipe(&fds));
     if (err > 0) {
         return switch (err) {
-            posix.EMFILE, posix.ENFILE => error.SystemResources,
+            posix.EMFILE,
+            posix.ENFILE => error.SystemResources,
             else => os.unexpectedErrorPosix(err),
         };
     }
 @@ -742,8 +752,8 @@ fn makePipe() ![2]i32 {
 }
 fn destroyPipe(pipe: &const [2]i32) void {
-    os.close((*pipe)[0]);
+    os.close((pipe.*)[0]);
-    os.close((*pipe)[1]);
+    os.close((pipe.*)[1]);
 }
 // Child of fork calls this to report an error to the fork parent.

std/segmented_list.zig+30-24

 @@ -93,7 +93,7 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
         /// Deinitialize with `deinit`
         pub fn init(allocator: &Allocator) Self {
-            return Self {
+            return Self{
                 .allocator = allocator,
                 .len = 0,
                 .prealloc_segment = undefined,
 @@ -104,7 +104,7 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
         pub fn deinit(self: &Self) void {
             self.freeShelves(ShelfIndex(self.dynamic_segments.len), 0);
             self.allocator.free(self.dynamic_segments);
-            *self = undefined;
+            self.* = undefined;
         }
         pub fn at(self: &Self, i: usize) &T {
 @@ -118,7 +118,7 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
         pub fn push(self: &Self, item: &const T) !void {
             const new_item_ptr = try self.addOne();
-            *new_item_ptr = *item;
+            new_item_ptr.* = item.*;
         }
         pub fn pushMany(self: &Self, items: []const T) !void {
 @@ -128,11 +128,10 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
         }
         pub fn pop(self: &Self) ?T {
-            if (self.len == 0)
+            if (self.len == 0) return null;
-                return null;
             const index = self.len - 1;
-            const result = *self.uncheckedAt(index);
+            const result = self.uncheckedAt(index).*;
             self.len = index;
             return result;
         }
 @@ -245,8 +244,7 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
             shelf_size: usize,
             pub fn next(it: &Iterator) ?&T {
-                if (it.index >= it.list.len)
+                if (it.index >= it.list.len) return null;
-                    return null;
                 if (it.index < prealloc_item_count) {
                     const ptr = &it.list.prealloc_segment[it.index];
                     it.index += 1;
 @@ -270,12 +268,10 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
             }
             pub fn prev(it: &Iterator) ?&T {
-                if (it.index == 0)
+                if (it.index == 0) return null;
-                    return null;
                 it.index -= 1;
-                if (it.index < prealloc_item_count)
+                if (it.index < prealloc_item_count) return &it.list.prealloc_segment[it.index];
-                    return &it.list.prealloc_segment[it.index];
                 if (it.box_index == 0) {
                     it.shelf_index -= 1;
 @@ -290,7 +286,7 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
         };
         pub fn iterator(self: &Self, start_index: usize) Iterator {
-            var it = Iterator {
+            var it = Iterator{
                 .list = self,
                 .index = start_index,
                 .shelf_index = undefined,
 @@ -324,25 +320,31 @@ fn testSegmentedList(comptime prealloc: usize, allocator: &Allocator) !void {
     var list = SegmentedList(i32, prealloc).init(allocator);
     defer list.deinit();
-    {var i: usize = 0; while (i < 100) : (i += 1) {
+    {
-        try list.push(i32(i + 1));
+        var i: usize = 0;
-        assert(list.len == i + 1);
+        while (i < 100) : (i += 1) {
-    }}
+            try list.push(i32(i + 1));
+            assert(list.len == i + 1);
+        }
+    }
-    {var i: usize = 0; while (i < 100) : (i += 1) {
+    {
-        assert(*list.at(i) == i32(i + 1));
+        var i: usize = 0;
-    }}
+        while (i < 100) : (i += 1) {
+            assert(list.at(i).* == i32(i + 1));
+        }
+    }
     {
         var it = list.iterator(0);
         var x: i32 = 0;
         while (it.next()) |item| {
             x += 1;
-            assert(*item == x);
+            assert(item.* == x);
         }
         assert(x == 100);
         while (it.prev()) |item| : (x -= 1) {
-            assert(*item == x);
+            assert(item.* == x);
         }
         assert(x == 0);
     }
 @@ -350,14 +352,18 @@ fn testSegmentedList(comptime prealloc: usize, allocator: &Allocator) !void {
     assert(??list.pop() == 100);
     assert(list.len == 99);
-    try list.pushMany([]i32 { 1, 2, 3 });
+    try list.pushMany([]i32{
+        1,
+        2,
+        3,
+    });
     assert(list.len == 102);
     assert(??list.pop() == 3);
     assert(??list.pop() == 2);
     assert(??list.pop() == 1);
     assert(list.len == 99);
-    try list.pushMany([]const i32 {});
+    try list.pushMany([]const i32{});
     assert(list.len == 99);
     var i: i32 = 99;

std/sort.zig+398-164

 @@ -5,15 +5,18 @@ const math = std.math;
 const builtin = @import("builtin");
 /// Stable in-place sort. O(n) best case, O(pow(n, 2)) worst case. O(1) memory (no allocator required).
-pub fn insertionSort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T)bool) void {
+pub fn insertionSort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool) void {
-    {var i: usize = 1; while (i < items.len) : (i += 1) {
+    {
-        const x = items[i];
+        var i: usize = 1;
-        var j: usize = i;
+        while (i < items.len) : (i += 1) {
-        while (j > 0 and lessThan(x, items[j - 1])) : (j -= 1) {
+            const x = items[i];
-            items[j] = items[j - 1];
+            var j: usize = i;
+            while (j > 0 and lessThan(x, items[j - 1])) : (j -= 1) {
+                items[j] = items[j - 1];
+            }
+            items[j] = x;
         }
-        items[j] = x;
+    }
-    }}
 }
 const Range = struct {
 @@ -21,7 +24,10 @@ const Range = struct {
     end: usize,
     fn init(start: usize, end: usize) Range {
-        return Range { .start = start, .end = end };
+        return Range{
+            .start = start,
+            .end = end,
+        };
     }
     fn length(self: &const Range) usize {
 @@ -29,7 +35,6 @@ const Range = struct {
     }
 };
 const Iterator = struct {
     size: usize,
     power_of_two: usize,
 @@ -42,7 +47,7 @@ const Iterator = struct {
     fn init(size2: usize, min_level: usize) Iterator {
         const power_of_two = math.floorPowerOfTwo(usize, size2);
         const denominator = power_of_two / min_level;
-        return Iterator {
+        return Iterator{
             .numerator = 0,
             .decimal = 0,
             .size = size2,
 @@ -68,7 +73,10 @@ const Iterator = struct {
             self.decimal += 1;
         }
-        return Range {.start = start, .end = self.decimal};
+        return Range{
+            .start = start,
+            .end = self.decimal,
+        };
     }
     fn finished(self: &Iterator) bool {
 @@ -100,7 +108,7 @@ const Pull = struct {
 /// Stable in-place sort. O(n) best case, O(n*log(n)) worst case and average case. O(1) memory (no allocator required).
 /// Currently implemented as block sort.
-pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T)bool) void {
+pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool) void {
     // Implementation ported from https://github.com/BonzaiThePenguin/WikiSort/blob/master/WikiSort.c
     var cache: [512]T = undefined;
 @@ -123,7 +131,16 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
     // http://pages.ripco.net/~jgamble/nw.html
     var iterator = Iterator.init(items.len, 4);
     while (!iterator.finished()) {
-        var order = []u8{0, 1, 2, 3, 4, 5, 6, 7};
+        var order = []u8{
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+        };
         const range = iterator.nextRange();
         const sliced_items = items[range.start..];
 @@ -149,56 +166,56 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                 swap(T, sliced_items, lessThan, &order, 3, 5);
                 swap(T, sliced_items, lessThan, &order, 3, 4);
             },
-              7 => {
+            7 => {
-                  swap(T, sliced_items, lessThan, &order, 1, 2);
+                swap(T, sliced_items, lessThan, &order, 1, 2);
-                  swap(T, sliced_items, lessThan, &order, 3, 4);
+                swap(T, sliced_items, lessThan, &order, 3, 4);
-                  swap(T, sliced_items, lessThan, &order, 5, 6);
+                swap(T, sliced_items, lessThan, &order, 5, 6);
-                  swap(T, sliced_items, lessThan, &order, 0, 2);
+                swap(T, sliced_items, lessThan, &order, 0, 2);
-                  swap(T, sliced_items, lessThan, &order, 3, 5);
+                swap(T, sliced_items, lessThan, &order, 3, 5);
-                  swap(T, sliced_items, lessThan, &order, 4, 6);
+                swap(T, sliced_items, lessThan, &order, 4, 6);
-                  swap(T, sliced_items, lessThan, &order, 0, 1);
+                swap(T, sliced_items, lessThan, &order, 0, 1);
-                  swap(T, sliced_items, lessThan, &order, 4, 5);
+                swap(T, sliced_items, lessThan, &order, 4, 5);
-                  swap(T, sliced_items, lessThan, &order, 2, 6);
+                swap(T, sliced_items, lessThan, &order, 2, 6);
-                  swap(T, sliced_items, lessThan, &order, 0, 4);
+                swap(T, sliced_items, lessThan, &order, 0, 4);
-                  swap(T, sliced_items, lessThan, &order, 1, 5);
+                swap(T, sliced_items, lessThan, &order, 1, 5);
-                  swap(T, sliced_items, lessThan, &order, 0, 3);
+                swap(T, sliced_items, lessThan, &order, 0, 3);
-                  swap(T, sliced_items, lessThan, &order, 2, 5);
+                swap(T, sliced_items, lessThan, &order, 2, 5);
-                  swap(T, sliced_items, lessThan, &order, 1, 3);
+                swap(T, sliced_items, lessThan, &order, 1, 3);
-                  swap(T, sliced_items, lessThan, &order, 2, 4);
+                swap(T, sliced_items, lessThan, &order, 2, 4);
-                  swap(T, sliced_items, lessThan, &order, 2, 3);
+                swap(T, sliced_items, lessThan, &order, 2, 3);
-              },
+            },
-              6 => {
+            6 => {
-                  swap(T, sliced_items, lessThan, &order, 1, 2);
+                swap(T, sliced_items, lessThan, &order, 1, 2);
-                  swap(T, sliced_items, lessThan, &order, 4, 5);
+                swap(T, sliced_items, lessThan, &order, 4, 5);
-                  swap(T, sliced_items, lessThan, &order, 0, 2);
+                swap(T, sliced_items, lessThan, &order, 0, 2);
-                  swap(T, sliced_items, lessThan, &order, 3, 5);
+                swap(T, sliced_items, lessThan, &order, 3, 5);
-                  swap(T, sliced_items, lessThan, &order, 0, 1);
+                swap(T, sliced_items, lessThan, &order, 0, 1);
-                  swap(T, sliced_items, lessThan, &order, 3, 4);
+                swap(T, sliced_items, lessThan, &order, 3, 4);
-                  swap(T, sliced_items, lessThan, &order, 2, 5);
+                swap(T, sliced_items, lessThan, &order, 2, 5);
-                  swap(T, sliced_items, lessThan, &order, 0, 3);
+                swap(T, sliced_items, lessThan, &order, 0, 3);
-                  swap(T, sliced_items, lessThan, &order, 1, 4);
+                swap(T, sliced_items, lessThan, &order, 1, 4);
-                  swap(T, sliced_items, lessThan, &order, 2, 4);
+                swap(T, sliced_items, lessThan, &order, 2, 4);
-                  swap(T, sliced_items, lessThan, &order, 1, 3);
+                swap(T, sliced_items, lessThan, &order, 1, 3);
-                  swap(T, sliced_items, lessThan, &order, 2, 3);
+                swap(T, sliced_items, lessThan, &order, 2, 3);
-              },
+            },
-              5 => {
+            5 => {
-                  swap(T, sliced_items, lessThan, &order, 0, 1);
+                swap(T, sliced_items, lessThan, &order, 0, 1);
-                  swap(T, sliced_items, lessThan, &order, 3, 4);
+                swap(T, sliced_items, lessThan, &order, 3, 4);
-                  swap(T, sliced_items, lessThan, &order, 2, 4);
+                swap(T, sliced_items, lessThan, &order, 2, 4);
-                  swap(T, sliced_items, lessThan, &order, 2, 3);
+                swap(T, sliced_items, lessThan, &order, 2, 3);
-                  swap(T, sliced_items, lessThan, &order, 1, 4);
+                swap(T, sliced_items, lessThan, &order, 1, 4);
-                  swap(T, sliced_items, lessThan, &order, 0, 3);
+                swap(T, sliced_items, lessThan, &order, 0, 3);
-                  swap(T, sliced_items, lessThan, &order, 0, 2);
+                swap(T, sliced_items, lessThan, &order, 0, 2);
-                  swap(T, sliced_items, lessThan, &order, 1, 3);
+                swap(T, sliced_items, lessThan, &order, 1, 3);
-                  swap(T, sliced_items, lessThan, &order, 1, 2);
+                swap(T, sliced_items, lessThan, &order, 1, 2);
-              },
+            },
-              4 => {
+            4 => {
-                  swap(T, sliced_items, lessThan, &order, 0, 1);
+                swap(T, sliced_items, lessThan, &order, 0, 1);
-                  swap(T, sliced_items, lessThan, &order, 2, 3);
+                swap(T, sliced_items, lessThan, &order, 2, 3);
-                  swap(T, sliced_items, lessThan, &order, 0, 2);
+                swap(T, sliced_items, lessThan, &order, 0, 2);
-                  swap(T, sliced_items, lessThan, &order, 1, 3);
+                swap(T, sliced_items, lessThan, &order, 1, 3);
-                  swap(T, sliced_items, lessThan, &order, 1, 2);
+                swap(T, sliced_items, lessThan, &order, 1, 2);
-              },
+            },
             else => {},
         }
     }
 @@ -273,7 +290,6 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                 // we merged two levels at the same time, so we're done with this level already
                 // (iterator.nextLevel() is called again at the bottom of this outer merge loop)
                 _ = iterator.nextLevel();
             } else {
                 iterator.begin();
                 while (!iterator.finished()) {
 @@ -303,7 +319,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
             // 8. redistribute the two internal buffers back into the items
             var block_size: usize = math.sqrt(iterator.length());
-            var buffer_size = iterator.length()/block_size + 1;
+            var buffer_size = iterator.length() / block_size + 1;
             // as an optimization, we really only need to pull out the internal buffers once for each level of merges
             // after that we can reuse the same buffers over and over, then redistribute it when we're finished with this level
 @@ -316,8 +332,18 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
             var start: usize = 0;
             var pull_index: usize = 0;
             var pull = []Pull{
-                Pull {.from = 0, .to = 0, .count = 0, .range = Range.init(0, 0),},
+                Pull{
-                Pull {.from = 0, .to = 0, .count = 0, .range = Range.init(0, 0),},
+                    .from = 0,
+                    .to = 0,
+                    .count = 0,
+                    .range = Range.init(0, 0),
+                },
+                Pull{
+                    .from = 0,
+                    .to = 0,
+                    .count = 0,
+                    .range = Range.init(0, 0),
+                },
             };
             var buffer1 = Range.init(0, 0);
 @@ -355,7 +381,10 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                 // these values will be pulled out to the start of A
                 last = A.start;
                 count = 1;
-                while (count < find) : ({last = index; count += 1;}) {
+                while (count < find) : ({
+                    last = index;
+                    count += 1;
+                }) {
                     index = findLastForward(T, items, items[last], Range.init(last + 1, A.end), lessThan, find - count);
                     if (index == A.end) break;
                 }
 @@ -363,7 +392,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                 if (count >= buffer_size) {
                     // keep track of the range within the items where we'll need to "pull out" these values to create the internal buffer
-                    pull[pull_index] = Pull {
+                    pull[pull_index] = Pull{
                         .range = Range.init(A.start, B.end),
                         .count = count,
                         .from = index,
 @@ -398,7 +427,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                 } else if (pull_index == 0 and count > buffer1.length()) {
                     // keep track of the largest buffer we were able to find
                     buffer1 = Range.init(A.start, A.start + count);
-                    pull[pull_index] = Pull {
+                    pull[pull_index] = Pull{
                         .range = Range.init(A.start, B.end),
                         .count = count,
                         .from = index,
 @@ -410,7 +439,10 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                 // these values will be pulled out to the end of B
                 last = B.end - 1;
                 count = 1;
-                while (count < find) : ({last = index - 1; count += 1;}) {
+                while (count < find) : ({
+                    last = index - 1;
+                    count += 1;
+                }) {
                     index = findFirstBackward(T, items, items[last], Range.init(B.start, last), lessThan, find - count);
                     if (index == B.start) break;
                 }
 @@ -418,7 +450,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                 if (count >= buffer_size) {
                     // keep track of the range within the items where we'll need to "pull out" these values to create the internal buffe
-                    pull[pull_index] = Pull {
+                    pull[pull_index] = Pull{
                         .range = Range.init(A.start, B.end),
                         .count = count,
                         .from = index,
 @@ -457,7 +489,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                 } else if (pull_index == 0 and count > buffer1.length()) {
                     // keep track of the largest buffer we were able to find
                     buffer1 = Range.init(B.end - count, B.end);
-                    pull[pull_index] = Pull {
+                    pull[pull_index] = Pull{
                         .range = Range.init(A.start, B.end),
                         .count = count,
                         .from = index,
 @@ -496,7 +528,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
             // adjust block_size and buffer_size based on the values we were able to pull out
             buffer_size = buffer1.length();
-            block_size = iterator.length()/buffer_size + 1;
+            block_size = iterator.length() / buffer_size + 1;
             // the first buffer NEEDS to be large enough to tag each of the evenly sized A blocks,
             // so this was originally here to test the math for adjusting block_size above
 @@ -547,7 +579,10 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                     // swap the first value of each A block with the value in buffer1
                     var indexA = buffer1.start;
                     index = firstA.end;
-                    while (index < blockA.end) : ({indexA += 1; index += block_size;}) {
+                    while (index < blockA.end) : ({
+                        indexA += 1;
+                        index += block_size;
+                    }) {
                         mem.swap(T, &items[indexA], &items[index]);
                     }
 @@ -626,9 +661,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
                                 // if there are no more A blocks remaining, this step is finished!
                                 blockA.start += block_size;
-                                if (blockA.length() == 0)
+                                if (blockA.length() == 0) break;
-                                    break;
                             } else if (blockB.length() < block_size) {
                                 // move the last B block, which is unevenly sized, to before the remaining A blocks, by using a rotation
                                 // the cache is disabled here since it might contain the contents of the previous A block
 @@ -709,7 +742,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
 }
 // merge operation without a buffer
-fn mergeInPlace(comptime T: type, items: []T, A_arg: &const Range, B_arg: &const Range, lessThan: fn(&const T,&const T)bool) void {
+fn mergeInPlace(comptime T: type, items: []T, A_arg: &const Range, B_arg: &const Range, lessThan: fn(&const T, &const T) bool) void {
     if (A_arg.length() == 0 or B_arg.length() == 0) return;
     // this just repeatedly binary searches into B and rotates A into position.
 @@ -730,8 +763,8 @@ fn mergeInPlace(comptime T: type, items: []T, A_arg: &const Range, B_arg: &const
     // again, this is NOT a general-purpose solution – it only works well in this case!
     // kind of like how the O(n^2) insertion sort is used in some places
-    var A = *A_arg;
+    var A = A_arg.*;
-    var B = *B_arg;
+    var B = B_arg.*;
     while (true) {
         // find the first place in B where the first item in A needs to be inserted
 @@ -751,7 +784,7 @@ fn mergeInPlace(comptime T: type, items: []T, A_arg: &const Range, B_arg: &const
 }
 // merge operation using an internal buffer
-fn mergeInternal(comptime T: type, items: []T, A: &const Range, B: &const Range, lessThan: fn(&const T,&const T)bool, buffer: &const Range) void {
+fn mergeInternal(comptime T: type, items: []T, A: &const Range, B: &const Range, lessThan: fn(&const T, &const T) bool, buffer: &const Range) void {
     // whenever we find a value to add to the final array, swap it with the value that's already in that spot
     // when this algorithm is finished, 'buffer' will contain its original contents, but in a different order
     var A_count: usize = 0;
 @@ -787,9 +820,9 @@ fn blockSwap(comptime T: type, items: []T, start1: usize, start2: usize, block_s
 // combine a linear search with a binary search to reduce the number of comparisons in situations
 // where have some idea as to how many unique values there are and where the next value might be
-fn findFirstForward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T,&const T)bool, unique: usize) usize {
+fn findFirstForward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool, unique: usize) usize {
     if (range.length() == 0) return range.start;
-    const skip = math.max(range.length()/unique, usize(1));
+    const skip = math.max(range.length() / unique, usize(1));
     var index = range.start + skip;
     while (lessThan(items[index - 1], value)) : (index += skip) {
 @@ -801,9 +834,9 @@ fn findFirstForward(comptime T: type, items: []T, value: &const T, range: &const
     return binaryFirst(T, items, value, Range.init(index - skip, index), lessThan);
 }
-fn findFirstBackward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T,&const T)bool, unique: usize) usize {
+fn findFirstBackward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool, unique: usize) usize {
     if (range.length() == 0) return range.start;
-    const skip = math.max(range.length()/unique, usize(1));
+    const skip = math.max(range.length() / unique, usize(1));
     var index = range.end - skip;
     while (index > range.start and !lessThan(items[index - 1], value)) : (index -= skip) {
 @@ -815,9 +848,9 @@ fn findFirstBackward(comptime T: type, items: []T, value: &const T, range: &cons
     return binaryFirst(T, items, value, Range.init(index, index + skip), lessThan);
 }
-fn findLastForward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T,&const T)bool, unique: usize) usize {
+fn findLastForward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool, unique: usize) usize {
     if (range.length() == 0) return range.start;
-    const skip = math.max(range.length()/unique, usize(1));
+    const skip = math.max(range.length() / unique, usize(1));
     var index = range.start + skip;
     while (!lessThan(value, items[index - 1])) : (index += skip) {
 @@ -829,9 +862,9 @@ fn findLastForward(comptime T: type, items: []T, value: &const T, range: &const
     return binaryLast(T, items, value, Range.init(index - skip, index), lessThan);
 }
-fn findLastBackward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T,&const T)bool, unique: usize) usize {
+fn findLastBackward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool, unique: usize) usize {
     if (range.length() == 0) return range.start;
-    const skip = math.max(range.length()/unique, usize(1));
+    const skip = math.max(range.length() / unique, usize(1));
     var index = range.end - skip;
     while (index > range.start and lessThan(value, items[index - 1])) : (index -= skip) {
 @@ -843,12 +876,12 @@ fn findLastBackward(comptime T: type, items: []T, value: &const T, range: &const
     return binaryLast(T, items, value, Range.init(index, index + skip), lessThan);
 }
-fn binaryFirst(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T,&const T)bool) usize {
+fn binaryFirst(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool) usize {
     var start = range.start;
     var end = range.end - 1;
     if (range.start >= range.end) return range.end;
     while (start < end) {
-        const mid = start + (end - start)/2;
+        const mid = start + (end - start) / 2;
         if (lessThan(items[mid], value)) {
             start = mid + 1;
         } else {
 @@ -861,12 +894,12 @@ fn binaryFirst(comptime T: type, items: []T, value: &const T, range: &const Rang
     return start;
 }
-fn binaryLast(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T,&const T)bool) usize {
+fn binaryLast(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool) usize {
     var start = range.start;
     var end = range.end - 1;
     if (range.start >= range.end) return range.end;
     while (start < end) {
-        const mid = start + (end - start)/2;
+        const mid = start + (end - start) / 2;
         if (!lessThan(value, items[mid])) {
             start = mid + 1;
         } else {
 @@ -879,7 +912,7 @@ fn binaryLast(comptime T: type, items: []T, value: &const T, range: &const Range
     return start;
 }
-fn mergeInto(comptime T: type, from: []T, A: &const Range, B: &const Range, lessThan: fn(&const T,&const T)bool, into: []T) void {
+fn mergeInto(comptime T: type, from: []T, A: &const Range, B: &const Range, lessThan: fn(&const T, &const T) bool, into: []T) void {
     var A_index: usize = A.start;
     var B_index: usize = B.start;
     const A_last = A.end;
 @@ -909,7 +942,7 @@ fn mergeInto(comptime T: type, from: []T, A: &const Range, B: &const Range, less
     }
 }
-fn mergeExternal(comptime T: type, items: []T, A: &const Range, B: &const Range, lessThan: fn(&const T,&const T)bool, cache: []T) void {
+fn mergeExternal(comptime T: type, items: []T, A: &const Range, B: &const Range, lessThan: fn(&const T, &const T) bool, cache: []T) void {
     // A fits into the cache, so use that instead of the internal buffer
     var A_index: usize = 0;
     var B_index: usize = B.start;
 @@ -937,29 +970,27 @@ fn mergeExternal(comptime T: type, items: []T, A: &const Range, B: &const Range,
     mem.copy(T, items[insert_index..], cache[A_index..A_last]);
 }
-fn swap(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T)bool, order: &[8]u8, x: usize, y: usize) void {
+fn swap(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool, order: &[8]u8, x: usize, y: usize) void {
-    if (lessThan(items[y], items[x]) or
+    if (lessThan(items[y], items[x]) or ((order.*)[x] > (order.*)[y] and !lessThan(items[x], items[y]))) {
-        ((*order)[x] > (*order)[y] and !lessThan(items[x], items[y])))
-    {
         mem.swap(T, &items[x], &items[y]);
-        mem.swap(u8, &(*order)[x], &(*order)[y]);
+        mem.swap(u8, &(order.*)[x], &(order.*)[y]);
     }
 }
 fn i32asc(lhs: &const i32, rhs: &const i32) bool {
-    return *lhs < *rhs;
+    return lhs.* < rhs.*;
 }
 fn i32desc(lhs: &const i32, rhs: &const i32) bool {
-    return *rhs < *lhs;
+    return rhs.* < lhs.*;
 }
 fn u8asc(lhs: &const u8, rhs: &const u8) bool {
-    return *lhs < *rhs;
+    return lhs.* < rhs.*;
 }
 fn u8desc(lhs: &const u8, rhs: &const u8) bool {
-    return *rhs < *lhs;
+    return rhs.* < lhs.*;
 }
 test "stable sort" {
 @@ -967,44 +998,125 @@ test "stable sort" {
     comptime testStableSort();
 }
 fn testStableSort() void {
-    var expected = []IdAndValue {
+    var expected = []IdAndValue{
-        IdAndValue{.id = 0, .value = 0},
+        IdAndValue{
-        IdAndValue{.id = 1, .value = 0},
+            .id = 0,
-        IdAndValue{.id = 2, .value = 0},
+            .value = 0,
-        IdAndValue{.id = 0, .value = 1},
+        },
-        IdAndValue{.id = 1, .value = 1},
+        IdAndValue{
-        IdAndValue{.id = 2, .value = 1},
+            .id = 1,
-        IdAndValue{.id = 0, .value = 2},
+            .value = 0,
-        IdAndValue{.id = 1, .value = 2},
+        },
-        IdAndValue{.id = 2, .value = 2},
+        IdAndValue{
+            .id = 2,
+            .value = 0,
+        },
+        IdAndValue{
+            .id = 0,
+            .value = 1,
+        },
+        IdAndValue{
+            .id = 1,
+            .value = 1,
+        },
+        IdAndValue{
+            .id = 2,
+            .value = 1,
+        },
+        IdAndValue{
+            .id = 0,
+            .value = 2,
+        },
+        IdAndValue{
+            .id = 1,
+            .value = 2,
+        },
+        IdAndValue{
+            .id = 2,
+            .value = 2,
+        },
     };
-    var cases = [][9]IdAndValue {
+    var cases = [][9]IdAndValue{
-        []IdAndValue {
+        []IdAndValue{
-            IdAndValue{.id = 0, .value = 0},
+            IdAndValue{
-            IdAndValue{.id = 0, .value = 1},
+                .id = 0,
-            IdAndValue{.id = 0, .value = 2},
+                .value = 0,
-            IdAndValue{.id = 1, .value = 0},
+            },
-            IdAndValue{.id = 1, .value = 1},
+            IdAndValue{
-            IdAndValue{.id = 1, .value = 2},
+                .id = 0,
-            IdAndValue{.id = 2, .value = 0},
+                .value = 1,
-            IdAndValue{.id = 2, .value = 1},
+            },
-            IdAndValue{.id = 2, .value = 2},
+            IdAndValue{
+                .id = 0,
+                .value = 2,
+            },
+            IdAndValue{
+                .id = 1,
+                .value = 0,
+            },
+            IdAndValue{
+                .id = 1,
+                .value = 1,
+            },
+            IdAndValue{
+                .id = 1,
+                .value = 2,
+            },
+            IdAndValue{
+                .id = 2,
+                .value = 0,
+            },
+            IdAndValue{
+                .id = 2,
+                .value = 1,
+            },
+            IdAndValue{
+                .id = 2,
+                .value = 2,
+            },
         },
-        []IdAndValue {
+        []IdAndValue{
-            IdAndValue{.id = 0, .value = 2},
+            IdAndValue{
-            IdAndValue{.id = 0, .value = 1},
+                .id = 0,
-            IdAndValue{.id = 0, .value = 0},
+                .value = 2,
-            IdAndValue{.id = 1, .value = 2},
+            },
-            IdAndValue{.id = 1, .value = 1},
+            IdAndValue{
-            IdAndValue{.id = 1, .value = 0},
+                .id = 0,
-            IdAndValue{.id = 2, .value = 2},
+                .value = 1,
-            IdAndValue{.id = 2, .value = 1},
+            },
-            IdAndValue{.id = 2, .value = 0},
+            IdAndValue{
+                .id = 0,
+                .value = 0,
+            },
+            IdAndValue{
+                .id = 1,
+                .value = 2,
+            },
+            IdAndValue{
+                .id = 1,
+                .value = 1,
+            },
+            IdAndValue{
+                .id = 1,
+                .value = 0,
+            },
+            IdAndValue{
+                .id = 2,
+                .value = 2,
+            },
+            IdAndValue{
+                .id = 2,
+                .value = 1,
+            },
+            IdAndValue{
+                .id = 2,
+                .value = 0,
+            },
         },
     };
     for (cases) |*case| {
-        insertionSort(IdAndValue, (*case)[0..], cmpByValue);
+        insertionSort(IdAndValue, (case.*)[0..], cmpByValue);
-        for (*case) |item, i| {
+        for (case.*) |item, i| {
             assert(item.id == expected[i].id);
             assert(item.value == expected[i].value);
         }
 @@ -1019,13 +1131,31 @@ fn cmpByValue(a: &const IdAndValue, b: &const IdAndValue) bool {
 }
 test "std.sort" {
-    const u8cases = [][]const []const u8 {
+    const u8cases = [][]const []const u8{
-        [][]const u8{"", ""},
+        [][]const u8{
-        [][]const u8{"a", "a"},
+            "",
-        [][]const u8{"az", "az"},
+            "",
-        [][]const u8{"za", "az"},
+        },
-        [][]const u8{"asdf", "adfs"},
+        [][]const u8{
-        [][]const u8{"one", "eno"},
+            "a",
+            "a",
+        },
+        [][]const u8{
+            "az",
+            "az",
+        },
+        [][]const u8{
+            "za",
+            "az",
+        },
+        [][]const u8{
+            "asdf",
+            "adfs",
+        },
+        [][]const u8{
+            "one",
+            "eno",
+        },
     };
     for (u8cases) |case| {
 @@ -1036,13 +1166,59 @@ test "std.sort" {
         assert(mem.eql(u8, slice, case[1]));
     }
-    const i32cases = [][]const []const i32 {
+    const i32cases = [][]const []const i32{
-        [][]const i32{[]i32{}, []i32{}},
+        [][]const i32{
-        [][]const i32{[]i32{1}, []i32{1}},
+            []i32{},
-        [][]const i32{[]i32{0, 1}, []i32{0, 1}},
+            []i32{},
-        [][]const i32{[]i32{1, 0}, []i32{0, 1}},
+        },
-        [][]const i32{[]i32{1, -1, 0}, []i32{-1, 0, 1}},
+        [][]const i32{
-        [][]const i32{[]i32{2, 1, 3}, []i32{1, 2, 3}},
+            []i32{1},
+            []i32{1},
+        },
+        [][]const i32{
+            []i32{
+                0,
+                1,
+            },
+            []i32{
+                0,
+                1,
+            },
+        },
+        [][]const i32{
+            []i32{
+                1,
+                0,
+            },
+            []i32{
+                0,
+                1,
+            },
+        },
+        [][]const i32{
+            []i32{
+                1,
+                -1,
+                0,
+            },
+            []i32{
+                -1,
+                0,
+                1,
+            },
+        },
+        [][]const i32{
+            []i32{
+                2,
+                1,
+                3,
+            },
+            []i32{
+                1,
+                2,
+                3,
+            },
+        },
     };
     for (i32cases) |case| {
 @@ -1055,13 +1231,59 @@ test "std.sort" {
 }
 test "std.sort descending" {
-    const rev_cases = [][]const []const i32 {
+    const rev_cases = [][]const []const i32{
-        [][]const i32{[]i32{}, []i32{}},
+        [][]const i32{
-        [][]const i32{[]i32{1}, []i32{1}},
+            []i32{},
-        [][]const i32{[]i32{0, 1}, []i32{1, 0}},
+            []i32{},
-        [][]const i32{[]i32{1, 0}, []i32{1, 0}},
+        },
-        [][]const i32{[]i32{1, -1, 0}, []i32{1, 0, -1}},
+        [][]const i32{
-        [][]const i32{[]i32{2, 1, 3}, []i32{3, 2, 1}},
+            []i32{1},
+            []i32{1},
+        },
+        [][]const i32{
+            []i32{
+                0,
+                1,
+            },
+            []i32{
+                1,
+                0,
+            },
+        },
+        [][]const i32{
+            []i32{
+                1,
+                0,
+            },
+            []i32{
+                1,
+                0,
+            },
+        },
+        [][]const i32{
+            []i32{
+                1,
+                -1,
+                0,
+            },
+            []i32{
+                1,
+                0,
+                -1,
+            },
+        },
+        [][]const i32{
+            []i32{
+                2,
+                1,
+                3,
+            },
+            []i32{
+                3,
+                2,
+                1,
+            },
+        },
     };
     for (rev_cases) |case| {
 @@ -1074,10 +1296,22 @@ test "std.sort descending" {
 }
 test "another sort case" {
-    var arr = []i32{ 5, 3, 1, 2, 4 };
+    var arr = []i32{
+        5,
+        3,
+        1,
+        2,
+        4,
+    };
     sort(i32, arr[0..], i32asc);
-    assert(mem.eql(i32, arr, []i32{ 1, 2, 3, 4, 5 }));
+    assert(mem.eql(i32, arr, []i32{
+        1,
+        2,
+        3,
+        4,
+        5,
+    }));
 }
 test "sort fuzz testing" {
 @@ -1112,7 +1346,7 @@ fn fuzzTest(rng: &std.rand.Random) void {
     }
 }
-pub fn min(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T)bool) T {
+pub fn min(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool) T {
     var i: usize = 0;
     var smallest = items[0];
     for (items[1..]) |item| {
 @@ -1123,7 +1357,7 @@ pub fn min(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const
     return smallest;
 }
-pub fn max(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T)bool) T {
+pub fn max(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool) T {
     var i: usize = 0;
     var biggest = items[0];
     for (items[1..]) |item| {

author	Andrew Kelley <andrew@ziglang.org> 2018-05-10 00:29:49-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-05-10 00:29:49-04:00
log	4787127cf6418f7a819c9d6f07a9046d76e0de65
tree	05e2a1d04722ec0a364a5c87278175c27ff7400d
parent	6928badd850f9fcebdcc0b13287db2c81d2293c0

...	@@ -16,7 +16,7 @@ pub fn acos(x: var) @typeOf(x) {	...	@@ -16,7 +16,7 @@ pub fn acos(x: var) @typeOf(x) {
16	}	16	}
17		17
18	fn r32(z: f32) f32 {	18	fn r32(z: f32) f32 {
19	const pS0 = 1.6666586697e-01;	19	const pS0 = 1.6666586697e-01;
20	const pS1 = -4.2743422091e-02;	20	const pS1 = -4.2743422091e-02;
21	const pS2 = -8.6563630030e-03;	21	const pS2 = -8.6563630030e-03;
22	const qS1 = -7.0662963390e-01;	22	const qS1 = -7.0662963390e-01;
...	@@ -74,16 +74,16 @@ fn acos32(x: f32) f32 {	...	@@ -74,16 +74,16 @@ fn acos32(x: f32) f32 {
74	}	74	}
75		75
76	fn r64(z: f64) f64 {	76	fn r64(z: f64) f64 {
77	const pS0: f64 = 1.66666666666666657415e-01;	77	const pS0: f64 = 1.66666666666666657415e-01;
78	const pS1: f64 = -3.25565818622400915405e-01;	78	const pS1: f64 = -3.25565818622400915405e-01;
79	const pS2: f64 = 2.01212532134862925881e-01;	79	const pS2: f64 = 2.01212532134862925881e-01;
80	const pS3: f64 = -4.00555345006794114027e-02;	80	const pS3: f64 = -4.00555345006794114027e-02;
81	const pS4: f64 = 7.91534994289814532176e-04;	81	const pS4: f64 = 7.91534994289814532176e-04;
82	const pS5: f64 = 3.47933107596021167570e-05;	82	const pS5: f64 = 3.47933107596021167570e-05;
83	const qS1: f64 = -2.40339491173441421878e+00;	83	const qS1: f64 = -2.40339491173441421878e+00;
84	const qS2: f64 = 2.02094576023350569471e+00;	84	const qS2: f64 = 2.02094576023350569471e+00;
85	const qS3: f64 = -6.88283971605453293030e-01;	85	const qS3: f64 = -6.88283971605453293030e-01;
86	const qS4: f64 = 7.70381505559019352791e-02;	86	const qS4: f64 = 7.70381505559019352791e-02;
87		87
88	const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));	88	const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));
89	const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));	89	const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));

...	@@ -17,7 +17,7 @@ pub fn asin(x: var) @typeOf(x) {	...	@@ -17,7 +17,7 @@ pub fn asin(x: var) @typeOf(x) {
17	}	17	}
18		18
19	fn r32(z: f32) f32 {	19	fn r32(z: f32) f32 {
20	const pS0 = 1.6666586697e-01;	20	const pS0 = 1.6666586697e-01;
21	const pS1 = -4.2743422091e-02;	21	const pS1 = -4.2743422091e-02;
22	const pS2 = -8.6563630030e-03;	22	const pS2 = -8.6563630030e-03;
23	const qS1 = -7.0662963390e-01;	23	const qS1 = -7.0662963390e-01;
...	@@ -37,9 +37,9 @@ fn asin32(x: f32) f32 {	...	@@ -37,9 +37,9 @@ fn asin32(x: f32) f32 {
37	if (ix >= 0x3F800000) {	37	if (ix >= 0x3F800000) {
38	// \|x\| >= 1	38	// \|x\| >= 1
39	if (ix == 0x3F800000) {	39	if (ix == 0x3F800000) {
40	return x * pio2 + 0x1.0p-120; // asin(+-1) = +-pi/2 with inexact	40	return x * pio2 + 0x1.0p-120; // asin(+-1) = +-pi/2 with inexact
41	} else {	41	} else {
42	return math.nan(f32); // asin(\|x\| > 1) is nan	42	return math.nan(f32); // asin(\|x\| > 1) is nan
43	}	43	}
44	}	44	}
45		45
...	@@ -66,16 +66,16 @@ fn asin32(x: f32) f32 {	...	@@ -66,16 +66,16 @@ fn asin32(x: f32) f32 {
66	}	66	}
67		67
68	fn r64(z: f64) f64 {	68	fn r64(z: f64) f64 {
69	const pS0: f64 = 1.66666666666666657415e-01;	69	const pS0: f64 = 1.66666666666666657415e-01;
70	const pS1: f64 = -3.25565818622400915405e-01;	70	const pS1: f64 = -3.25565818622400915405e-01;
71	const pS2: f64 = 2.01212532134862925881e-01;	71	const pS2: f64 = 2.01212532134862925881e-01;
72	const pS3: f64 = -4.00555345006794114027e-02;	72	const pS3: f64 = -4.00555345006794114027e-02;
73	const pS4: f64 = 7.91534994289814532176e-04;	73	const pS4: f64 = 7.91534994289814532176e-04;
74	const pS5: f64 = 3.47933107596021167570e-05;	74	const pS5: f64 = 3.47933107596021167570e-05;
75	const qS1: f64 = -2.40339491173441421878e+00;	75	const qS1: f64 = -2.40339491173441421878e+00;
76	const qS2: f64 = 2.02094576023350569471e+00;	76	const qS2: f64 = 2.02094576023350569471e+00;
77	const qS3: f64 = -6.88283971605453293030e-01;	77	const qS3: f64 = -6.88283971605453293030e-01;
78	const qS4: f64 = 7.70381505559019352791e-02;	78	const qS4: f64 = 7.70381505559019352791e-02;
79		79
80	const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));	80	const p = z * (pS0 + z * (pS1 + z * (pS2 + z * (pS3 + z * (pS4 + z * pS5)))));
81	const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));	81	const q = 1.0 + z * (qS1 + z * (qS2 + z * (qS3 + z * qS4)));

...	@@ -18,20 +18,20 @@ pub fn cos(x: var) @typeOf(x) {	...	@@ -18,20 +18,20 @@ pub fn cos(x: var) @typeOf(x) {
18	}	18	}
19		19
20	// sin polynomial coefficients	20	// sin polynomial coefficients
21	const S0 = 1.58962301576546568060E-10;	21	const S0 = 1.58962301576546568060E-10;
22	const S1 = -2.50507477628578072866E-8;	22	const S1 = -2.50507477628578072866E-8;
23	const S2 = 2.75573136213857245213E-6;	23	const S2 = 2.75573136213857245213E-6;
24	const S3 = -1.98412698295895385996E-4;	24	const S3 = -1.98412698295895385996E-4;
25	const S4 = 8.33333333332211858878E-3;	25	const S4 = 8.33333333332211858878E-3;
26	const S5 = -1.66666666666666307295E-1;	26	const S5 = -1.66666666666666307295E-1;
27		27
28	// cos polynomial coeffiecients	28	// cos polynomial coeffiecients
29	const C0 = -1.13585365213876817300E-11;	29	const C0 = -1.13585365213876817300E-11;
30	const C1 = 2.08757008419747316778E-9;	30	const C1 = 2.08757008419747316778E-9;
31	const C2 = -2.75573141792967388112E-7;	31	const C2 = -2.75573141792967388112E-7;
32	const C3 = 2.48015872888517045348E-5;	32	const C3 = 2.48015872888517045348E-5;
33	const C4 = -1.38888888888730564116E-3;	33	const C4 = -1.38888888888730564116E-3;
34	const C5 = 4.16666666666665929218E-2;	34	const C5 = 4.16666666666665929218E-2;
35		35
36	// NOTE: This is taken from the go stdlib. The musl implementation is much more complex.	36	// NOTE: This is taken from the go stdlib. The musl implementation is much more complex.
37	//	37	//

...	@@ -19,20 +19,20 @@ pub fn sin(x: var) @typeOf(x) {	...	@@ -19,20 +19,20 @@ pub fn sin(x: var) @typeOf(x) {
19	}	19	}
20		20
21	// sin polynomial coefficients	21	// sin polynomial coefficients
22	const S0 = 1.58962301576546568060E-10;	22	const S0 = 1.58962301576546568060E-10;
23	const S1 = -2.50507477628578072866E-8;	23	const S1 = -2.50507477628578072866E-8;
24	const S2 = 2.75573136213857245213E-6;	24	const S2 = 2.75573136213857245213E-6;
25	const S3 = -1.98412698295895385996E-4;	25	const S3 = -1.98412698295895385996E-4;
26	const S4 = 8.33333333332211858878E-3;	26	const S4 = 8.33333333332211858878E-3;
27	const S5 = -1.66666666666666307295E-1;	27	const S5 = -1.66666666666666307295E-1;
28		28
29	// cos polynomial coeffiecients	29	// cos polynomial coeffiecients
30	const C0 = -1.13585365213876817300E-11;	30	const C0 = -1.13585365213876817300E-11;
31	const C1 = 2.08757008419747316778E-9;	31	const C1 = 2.08757008419747316778E-9;
32	const C2 = -2.75573141792967388112E-7;	32	const C2 = -2.75573141792967388112E-7;
33	const C3 = 2.48015872888517045348E-5;	33	const C3 = 2.48015872888517045348E-5;
34	const C4 = -1.38888888888730564116E-3;	34	const C4 = -1.38888888888730564116E-3;
35	const C5 = 4.16666666666665929218E-2;	35	const C5 = 4.16666666666665929218E-2;
36		36
37	// NOTE: This is taken from the go stdlib. The musl implementation is much more complex.	37	// NOTE: This is taken from the go stdlib. The musl implementation is much more complex.
38	//	38	//

partial conversion to post-fix pointer deref using zig fmt