update the code to run in v13

Author: g11tech

.github/workflows/ci.yml

@@ -13,5 +13,5 @@ jobs:
       - name: Zig test
         uses: goto-bus-stop/setup-zig@v2
         with:
-          version: 0.11.0
+          version: 0.13.0
       - run: make

.gitignore

@@ -1,3 +1,4 @@
 main*
 !main.zig
 zig-cache/
+.zig-cache/

main.zig

@@ -9,7 +9,7 @@ fn readFile(allocator: Allocator, path: []const u8) ![]u8 {
     var f = try fs.cwd().openFile(path, file.OpenFlags{ .mode = file.OpenMode.read_only });
     const fMetadata = try f.stat();
 
-    var output = try allocator.alloc(u8, fMetadata.size);
+    const output = try allocator.alloc(u8, fMetadata.size);
     errdefer allocator.free(output);
 
     _ = try f.readAll(output);
@@ -30,7 +30,7 @@ pub fn main() !void {
 
     // try stdout.print("{}", .{decoded});
 
-    var encInput = try readFile(allocator, "encode");
+    const encInput = try readFile(allocator, "encode");
     defer allocator.free(encInput);
 
     const encoded = try snappy.encode(allocator, encInput);

snappy.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-const crc32 = std.hash.crc;
+const crc32 = std.hash.crc.Crc32Iscsi;
 const mem = std.mem;
 const testing = std.testing;
 
@@ -38,8 +38,9 @@ const SnappyError = error{
 // Perform the CRC hash per the snappy documentation. We must use wrapping addition since this is
 // the default behavior in other languages.
 fn crc(b: []const u8) u32 {
-    const c = crc32.Crc32SmallWithPoly(.Castagnoli);
-    const hash = c.hash(b);
+    var c = crc32.init();
+    c.update(b);
+    const hash = c.final();
     return @as(u32, hash >> 15 | hash << 17) +% 0xa282ead8;
 }
 
@@ -172,7 +173,7 @@ fn runDecode(dst: []u8, src: []const u8) u8 {
                     return 1;
                 }
 
-                mem.copy(u8, dst[d..], src[s .. s + @as(usize, @intCast(length))]);
+                std.mem.copyForwards(u8, dst[d..], src[s .. s + @as(usize, @intCast(length))]);
                 const l = @as(usize, @intCast(length));
                 d += l;
                 s += l;
@@ -217,14 +218,14 @@ fn runDecode(dst: []u8, src: []const u8) u8 {
 
         if (offset >= length) {
             const upper_bound = d - @as(usize, @intCast(offset)) + @as(usize, @intCast(length));
-            mem.copy(u8, dst[d .. d + @as(usize, @intCast(length))], dst[d - @as(usize, @intCast(offset)) .. upper_bound]);
+            std.mem.copyForwards(u8, dst[d .. d + @as(usize, @intCast(length))], dst[d - @as(usize, @intCast(offset)) .. upper_bound]);
             d += @as(usize, @intCast(length));
             continue;
         }
 
         var a = dst[d .. d + @as(usize, @intCast(length))];
         var b = dst[d - @as(usize, @intCast(offset)) ..];
-        var aLen = a.len;
+        const aLen = a.len;
         b = b[0..aLen];
         for (a, 0..) |_, i| {
             a[i] = b[i];
@@ -244,11 +245,11 @@ fn runDecode(dst: []u8, src: []const u8) u8 {
 pub fn decode(allocator: Allocator, src: []const u8) ![]u8 {
     const block = try decodedLen(src);
 
-    var dst = try allocator.alloc(u8, block.blockLen);
+    const dst = try allocator.alloc(u8, block.blockLen);
     errdefer allocator.free(dst);
 
     // Skip past how many bytes we read to get the length.
-    var s = src[block.headerLen..];
+    const s = src[block.headerLen..];
 
     if (runDecode(dst, s) != 0) {
         return SnappyError.Corrupt;
@@ -278,7 +279,7 @@ fn emitLiteral(dst: []u8, lit: []const u8) usize {
             i = 3;
         },
     }
-    mem.copy(u8, dst[i..], lit);
+    std.mem.copyForwards(u8, dst[i..], lit);
 
     return i + @min(dst.len, lit.len);
 }
@@ -346,7 +347,7 @@ fn encodeBlock(dst: []u8, src: []u8) usize {
     }
 
     var table = mem.zeroes([maxTableSize]u16);
-    var sLimit = src.len - inputMargin;
+    const sLimit = src.len - inputMargin;
     var nextEmit: usize = 0;
     var s: usize = 1;
     var nextHash = snappyHash(load32(src, @as(isize, @intCast(s))), shift);
@@ -358,7 +359,7 @@ fn encodeBlock(dst: []u8, src: []u8) usize {
 
         inner: while (true) {
             s = nextS;
-            var bytesBetweenHashLookups = skip >> 5;
+            const bytesBetweenHashLookups = skip >> 5;
             nextS = s + @as(usize, @intCast(bytesBetweenHashLookups));
             skip += bytesBetweenHashLookups;
             if (nextS > sLimit) {
@@ -375,7 +376,7 @@ fn encodeBlock(dst: []u8, src: []u8) usize {
         d += emitLiteral(dst[d..], src[nextEmit..s]);
 
         while (true) {
-            var base = s;
+            const base = s;
             s += 4;
             var i = @as(usize, @intCast(candidate + 4));
             while (s < src.len and src[i] == src[s]) {
@@ -389,10 +390,10 @@ fn encodeBlock(dst: []u8, src: []u8) usize {
                 break :outer;
             }
 
-            var x = load64(src, @as(isize, @intCast(s - 1)));
-            var prevHash = snappyHash(@as(u32, @truncate(x >> 0)), shift);
+            const x = load64(src, @as(isize, @intCast(s - 1)));
+            const prevHash = snappyHash(@as(u32, @truncate(x >> 0)), shift);
             table[prevHash & tableMask] = @as(u16, @intCast(s - 1));
-            var currHash = snappyHash(@as(u32, @truncate(x >> 8)), shift);
+            const currHash = snappyHash(@as(u32, @truncate(x >> 8)), shift);
             candidate = @as(isize, @intCast(table[currHash & tableMask]));
             table[currHash & tableMask] = @as(u16, @intCast(s));
             if (@as(u32, @truncate(x >> 8)) != load32(src, candidate)) {
@@ -425,7 +426,7 @@ pub fn encode(allocator: Allocator, src: []u8) ![]u8 {
 
     while (mutSrc.len > 0) {
         var p = try allocator.alloc(u8, mutSrc.len);
-        mem.copy(u8, p, mutSrc);
+        std.mem.copyForwards(u8, p, mutSrc);
         var empty = [_]u8{};
         mutSrc = empty[0..];
         if (p.len > maxBlockSize) {
@@ -440,8 +441,8 @@ pub fn encode(allocator: Allocator, src: []u8) ![]u8 {
         allocator.free(p);
     }
 
-    var output = try allocator.alloc(u8, d);
-    mem.copy(u8, output, dst[0..d]);
+    const output = try allocator.alloc(u8, d);
+    std.mem.copyForwards(u8, output, dst[0..d]);
     allocator.free(dst);
 
     return output;
@@ -463,7 +464,8 @@ pub fn maxEncodedLen(srcLen: usize) isize {
 }
 
 test "snappy crc" {
-    try testing.expect(crc("snappy") == 0x293d0c23);
+    const snappycrc = crc("snappy");
+    try testing.expect(snappycrc == 0x293d0c23);
 }
 
 test "decoding variable integers" {
@@ -481,17 +483,18 @@ test "simple encode" {
     const allocator = testing.allocator;
 
     var input: [4]u8 = [_]u8{ 't', 'h', 'i', 's' };
-    var i: []u8 = &input;
-    var output = try encode(allocator, i);
+    const i: []u8 = &input;
+    const output = try encode(allocator, i);
+
     defer allocator.free(output);
 
     try testing.expectEqualSlices(u8, output, "\x04\x0cthis");
 }
 
 test "simple decode" {
     const allocator = testing.allocator;
-
-    const decoded = try decode(allocator, "\x19\x1coh snap,\x05\x06,py is cool!\x0a");
+    const encodedbytes = "\x19\x1coh snap,\x05\x06,py is cool!\x0a";
+    const decoded = try decode(allocator, encodedbytes);
     defer allocator.free(decoded);
 
     try testing.expectEqualSlices(u8, decoded, "oh snap, snappy is cool!\n");