Merge pull request #199 from pedropark99/dev-fix-chap4

Update book to Zig 0.16

Author: pedropark99

Assets/contributors.txt

@@ -28,3 +28,6 @@ _blf_,@bengtfrost
 Karl Gaissmaier,@gaissmai
 Ben Scheirman,@subdigital
 Ariel Otilibili,@ariel-anieli
+kitajusSus,@kitajusSus
+Luciogi,@Luciogi
+Anish Gowda,@anishgowda21

Chapters/01-base64.qmd

@@ -170,7 +170,6 @@ to complete the window of 24 bits that the base64 algorithm likes to work on. Th
 the algorithm does, is to check how to divide the input bytes into groups of 6 bits.
 
 If the algorithm notices that there is a group of 6 bits that it's not complete, meaning that, this group contains $nbits$, where $0 < nbits < 6$,
-
 the algorithm simply adds extra zeros in this group to fill the space that it needs.
 That is why in @fig-base64-algo1, in the third group after the 6-bit transformation,
 2 extra zeros were added to fill the gap.
@@ -701,14 +700,17 @@ for brevity reasons.
 fn _char_index(self: Base64, char: u8) u8 {
     if (char == '=')
         return 64;
-    var index: u8 = 0;
-    for (0..63) |i| {
+
+    var i: u8 = 0;
+    var output_index: u8 = 0;
+
+    while (i < 64) : (i += 1) {
         if (self._char_at(i) == char)
             break;
-        index += 1;
+        output_index += 1;
     }
 
-    return index;
+    return output_index;
 }
 ```
 

Chapters/01-memory.qmd

@@ -16,7 +16,7 @@ knitr::opts_chunk$set(
 
 
 
-# Memory and Allocators
+# Memory and Allocators {#sec-memory-chap}
 
 
 In this chapter, we will talk about memory. How does Zig control memory? What
@@ -685,7 +685,7 @@ _ = in1; _ = in2; _ = in3;
 
 In the code example below, we are accessing the `stdin`, which is
 the standard input channel, to receive an input from the
-user. We read the input given by the user with the `readSliceAll()`
+user. We read the next line of input given by the user with the `takeDelimiterExclusive()`
 method.
 
 Now, after reading the input of the user, we need to store this input somewhere in
@@ -715,24 +715,25 @@ can allocate the same array in the heap by using the expression `var input = try
 #| auto_main: false
 #| build_type: "lib"
 const std = @import("std");
+const io = std.testing.io;
 var stdin_buffer: [1024]u8 = undefined;
-var stdin_reader = std.fs.File.stdin().reader(&stdin_buffer);
+var stdin_reader = std.fs.File.stdin().reader(io, &stdin_buffer);
 const stdin = &stdin_reader.interface;
 
 pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     const allocator = gpa.allocator();
+
     var input = try allocator.alloc(u8, 50);
     defer allocator.free(input);
     @memset(input[0..], 0);
 
-    // Read user input
-    stdin.readSliceAll(input[0..]) catch |err| switch(err) {
-        // Reached end of input, do nothing else
-        error.EndOfStream => {},
-        // If it's other kind of error, then return it
-        else => return err,
-    };
+    // Read user input until a line break is found.
+    const stream = try stdin.takeDelimiterExclusive('\n');
+    // Store the input into our heap memory.
+    @memcpy(input[0..stream.len], stream[0..]);
+    // Print our heap memory, so that we can see what
+    // was stored in it.
     std.debug.print("{s}\n", .{input});
 }
 ```

Chapters/01-zig-weird.qmd

@@ -1101,14 +1101,13 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 fn read_file(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
-    var file_buffer = try allocator.alloc(u8, 1024);
-    @memset(file_buffer[0..], 0);
-
     const file = try std.fs.cwd().openFile(path, .{});
     defer file.close();
 
-    var reader = file.reader();
-    const nbytes = try reader.read(file_buffer[0..]);
+    var file_buffer = try allocator.alloc(u8, 1024);
+    @memset(file_buffer[0..], 0);
+
+    const nbytes = try file.read(file_buffer[0..]);
     return file_buffer[0..nbytes];
 }