Merge branch 'master' into zen_stdlib

4 files changed, 46 insertions, 54 deletions

diff --git a/std/hash/adler.zig b/std/hash/adler.zig
index c77a5aaf50..9c5966f89b 100644
--- a/std/hash/adler.zig
+++ b/std/hash/adler.zig
@@ -13,14 +13,12 @@ pub const Adler32 = struct {
     adler: u32,
 
     pub fn init() Adler32 {
-        return Adler32 {
-            .adler = 1,
-        };
+        return Adler32{ .adler = 1 };
     }
 
     // This fast variant is taken from zlib. It reduces the required modulos and unrolls longer
     // buffer inputs and should be much quicker.
-    pub fn update(self: &Adler32, input: []const u8) void {
+    pub fn update(self: *Adler32, input: []const u8) void {
         var s1 = self.adler & 0xffff;
         var s2 = (self.adler >> 16) & 0xffff;
 
@@ -33,8 +31,7 @@ pub const Adler32 = struct {
             if (s2 >= base) {
                 s2 -= base;
             }
-        }
-        else if (input.len < 16) {
+        } else if (input.len < 16) {
             for (input) |b| {
                 s1 +%= b;
                 s2 +%= s1;
@@ -44,8 +41,7 @@ pub const Adler32 = struct {
             }
 
             s2 %= base;
-        }
-        else {
+        } else {
             var i: usize = 0;
             while (i + nmax <= input.len) : (i += nmax) {
                 const n = nmax / 16; // note: 16 | nmax
@@ -81,7 +77,7 @@ pub const Adler32 = struct {
         self.adler = s1 | (s2 << 16);
     }
 
-    pub fn final(self: &Adler32) u32 {
+    pub fn final(self: *Adler32) u32 {
         return self.adler;
     }
 
@@ -98,15 +94,14 @@ test "adler32 sanity" {
 }
 
 test "adler32 long" {
-    const long1 = []u8 {1} ** 1024;
+    const long1 = []u8{1} ** 1024;
     debug.assert(Adler32.hash(long1[0..]) == 0x06780401);
 
-    const long2 = []u8 {1} ** 1025;
+    const long2 = []u8{1} ** 1025;
     debug.assert(Adler32.hash(long2[0..]) == 0x0a7a0402);
 }
 
 test "adler32 very long" {
-    const long = []u8 {1} ** 5553;
+    const long = []u8{1} ** 5553;
     debug.assert(Adler32.hash(long[0..]) == 0x707f15b2);
 }
-
diff --git a/std/hash/crc.zig b/std/hash/crc.zig
index f88069ce3c..c455140785 100644
--- a/std/hash/crc.zig
+++ b/std/hash/crc.zig
@@ -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.
@@ -26,21 +26,23 @@ pub fn Crc32WithPoly(comptime poly: u32) type {
             var tables: [8][256]u32 = undefined;
 
             for (tables[0]) |*e, i| {
-                var crc = u32(i);
-                var j: usize = 0; while (j < 8) : (j += 1) {
+                var crc = @intCast(u32, i);
+                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,19 +55,17 @@ pub fn Crc32WithPoly(comptime poly: u32) type {
         crc: u32,
 
         pub fn init() Self {
-            return Self {
-                .crc = 0xffffffff,
-            };
+            return Self{ .crc = 0xffffffff };
         }
 
-        pub fn update(self: &Self, input: []const u8) void {
+        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[1]) <<  8);
+                self.crc ^= (u32(p[0]) << 0);
+                self.crc ^= (u32(p[1]) << 8);
                 self.crc ^= (u32(p[2]) << 16);
                 self.crc ^= (u32(p[3]) << 24);
 
@@ -76,8 +76,8 @@ pub fn Crc32WithPoly(comptime poly: u32) type {
                     lookup_tables[3][p[4]] ^
                     lookup_tables[4][@truncate(u8, self.crc >> 24)] ^
                     lookup_tables[5][@truncate(u8, self.crc >> 16)] ^
-                    lookup_tables[6][@truncate(u8, self.crc >>  8)] ^
-                    lookup_tables[7][@truncate(u8, self.crc >>  0)];
+                    lookup_tables[6][@truncate(u8, self.crc >> 8)] ^
+                    lookup_tables[7][@truncate(u8, self.crc >> 0)];
             }
 
             while (i < input.len) : (i += 1) {
@@ -86,7 +86,7 @@ pub fn Crc32WithPoly(comptime poly: u32) type {
             }
         }
 
-        pub fn final(self: &Self) u32 {
+        pub fn final(self: *Self) u32 {
             return ~self.crc;
         }
 
@@ -122,15 +122,16 @@ pub fn Crc32SmallWithPoly(comptime poly: u32) type {
             var table: [16]u32 = undefined;
 
             for (table) |*e, i| {
-                var crc = u32(i * 16);
-                var j: usize = 0; while (j < 8) : (j += 1) {
+                var crc = @intCast(u32, i * 16);
+                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,19 +140,17 @@ pub fn Crc32SmallWithPoly(comptime poly: u32) type {
         crc: u32,
 
         pub fn init() Self {
-            return Self {
-                .crc = 0xffffffff,
-            };
+            return Self{ .crc = 0xffffffff };
         }
 
-        pub fn update(self: &Self, input: []const u8) void {
+        pub fn update(self: *Self, input: []const u8) void {
             for (input) |b| {
                 self.crc = lookup_table[@truncate(u4, self.crc ^ (b >> 0))] ^ (self.crc >> 4);
                 self.crc = lookup_table[@truncate(u4, self.crc ^ (b >> 4))] ^ (self.crc >> 4);
             }
         }
 
-        pub fn final(self: &Self) u32 {
+        pub fn final(self: *Self) u32 {
             return ~self.crc;
         }
 
diff --git a/std/hash/fnv.zig b/std/hash/fnv.zig
index 88b965b76a..447c996772 100644
--- a/std/hash/fnv.zig
+++ b/std/hash/fnv.zig
@@ -7,7 +7,7 @@
 const std = @import("../index.zig");
 const debug = std.debug;
 
-pub const Fnv1a_32 = Fnv1a(u32, 0x01000193 , 0x811c9dc5);
+pub const Fnv1a_32 = Fnv1a(u32, 0x01000193, 0x811c9dc5);
 pub const Fnv1a_64 = Fnv1a(u64, 0x100000001b3, 0xcbf29ce484222325);
 pub const Fnv1a_128 = Fnv1a(u128, 0x1000000000000000000013b, 0x6c62272e07bb014262b821756295c58d);
 
@@ -18,19 +18,17 @@ fn Fnv1a(comptime T: type, comptime prime: T, comptime offset: T) type {
         value: T,
 
         pub fn init() Self {
-            return Self {
-                .value = offset,
-            };
+            return Self{ .value = offset };
         }
 
-        pub fn update(self: &Self, input: []const u8) void {
+        pub fn update(self: *Self, input: []const u8) void {
             for (input) |b| {
                 self.value ^= b;
                 self.value *%= prime;
             }
         }
 
-        pub fn final(self: &Self) T {
+        pub fn final(self: *Self) T {
             return self.value;
         }
 
diff --git a/std/hash/siphash.zig b/std/hash/siphash.zig
index 301c35cf05..cdad77e59e 100644
--- a/std/hash/siphash.zig
+++ b/std/hash/siphash.zig
@@ -45,7 +45,7 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)
             const k0 = mem.readInt(key[0..8], u64, Endian.Little);
             const k1 = mem.readInt(key[8..16], u64, Endian.Little);
 
-            var d = Self {
+            var d = Self{
                 .v0 = k0 ^ 0x736f6d6570736575,
                 .v1 = k1 ^ 0x646f72616e646f6d,
                 .v2 = k0 ^ 0x6c7967656e657261,
@@ -63,7 +63,7 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)
             return d;
         }
 
-        pub fn update(d: &Self, b: []const u8) void {
+        pub fn update(d: *Self, b: []const u8) void {
             var off: usize = 0;
 
             // Partial from previous.
@@ -76,16 +76,16 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)
 
             // Full middle blocks.
             while (off + 8 <= b.len) : (off += 8) {
-                d.round(b[off..off + 8]);
+                d.round(b[off .. off + 8]);
             }
 
             // Remainder for next pass.
             mem.copy(u8, d.buf[d.buf_len..], b[off..]);
-            d.buf_len += u8(b[off..].len);
+            d.buf_len += @intCast(u8, b[off..].len);
             d.msg_len +%= @truncate(u8, b.len);
         }
 
-        pub fn final(d: &Self) T {
+        pub fn final(d: *Self) T {
             // Padding
             mem.set(u8, d.buf[d.buf_len..], 0);
             d.buf[7] = d.msg_len;
@@ -118,7 +118,7 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)
             return (u128(b2) << 64) | b1;
         }
 
-        fn round(d: &Self, b: []const u8) void {
+        fn round(d: *Self, b: []const u8) void {
             debug.assert(b.len == 8);
 
             const m = mem.readInt(b[0..], u64, Endian.Little);
@@ -132,7 +132,7 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)
             d.v0 ^= m;
         }
 
-        fn sipRound(d: &Self) void {
+        fn sipRound(d: *Self) void {
             d.v0 +%= d.v1;
             d.v1 = math.rotl(u64, d.v1, u64(13));
             d.v1 ^= d.v0;
@@ -162,7 +162,7 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)
 const test_key = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f";
 
 test "siphash64-2-4 sanity" {
-    const vectors = [][]const u8 {
+    const vectors = [][]const u8{
         "\x31\x0e\x0e\xdd\x47\xdb\x6f\x72", // ""
         "\xfd\x67\xdc\x93\xc5\x39\xf8\x74", // "\x00"
         "\x5a\x4f\xa9\xd9\x09\x80\x6c\x0d", // "\x00\x01" ... etc
@@ -233,7 +233,7 @@ test "siphash64-2-4 sanity" {
 
     var buffer: [64]u8 = undefined;
     for (vectors) |vector, i| {
-        buffer[i] = u8(i);
+        buffer[i] = @intCast(u8, i);
 
         const expected = mem.readInt(vector, u64, Endian.Little);
         debug.assert(siphash.hash(test_key, buffer[0..i]) == expected);
@@ -241,7 +241,7 @@ test "siphash64-2-4 sanity" {
 }
 
 test "siphash128-2-4 sanity" {
-    const vectors = [][]const u8 {
+    const vectors = [][]const u8{
         "\xa3\x81\x7f\x04\xba\x25\xa8\xe6\x6d\xf6\x72\x14\xc7\x55\x02\x93",
         "\xda\x87\xc1\xd8\x6b\x99\xaf\x44\x34\x76\x59\x11\x9b\x22\xfc\x45",
         "\x81\x77\x22\x8d\xa4\xa4\x5d\xc7\xfc\xa3\x8b\xde\xf6\x0a\xff\xe4",
@@ -312,7 +312,7 @@ test "siphash128-2-4 sanity" {
 
     var buffer: [64]u8 = undefined;
     for (vectors) |vector, i| {
-        buffer[i] = u8(i);
+        buffer[i] = @intCast(u8, i);
 
         const expected = mem.readInt(vector, u128, Endian.Little);
         debug.assert(siphash.hash(test_key, buffer[0..i]) == expected);