diff --git a/.gitignore b/.gitignore index 94aed75..0326d14 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,5 @@ /answers/ /patches/healed/ *.md +/output/ + diff --git a/build.zig b/build.zig index 8319bb4..7620db0 100644 --- a/build.zig +++ b/build.zig @@ -15,7 +15,7 @@ const print = std.debug.print; // 1) Getting Started // 2) Version Changes comptime { - const required_zig = "0.12.0-dev.3397"; + const required_zig = "0.12.0-dev.3518"; const current_zig = builtin.zig_version; const min_zig = std.SemanticVersion.parse(required_zig) catch unreachable; if (current_zig.order(min_zig) == .lt) { @@ -247,7 +247,7 @@ const ZiglingStep = struct { fn make(step: *Step, prog_node: *std.Progress.Node) !void { // NOTE: Using exit code 2 will prevent the Zig compiler to print the message: // "error: the following build command failed with exit code 1:..." - const self = @fieldParentPtr(ZiglingStep, "step", step); + const self: *ZiglingStep = @alignCast(@fieldParentPtr("step", step)); if (self.exercise.skip) { print("Skipping {s}\n\n", .{self.exercise.main_file}); @@ -495,8 +495,7 @@ const PrintStep = struct { } fn make(step: *Step, _: *std.Progress.Node) !void { - const self = @fieldParentPtr(PrintStep, "step", step); - + const self: *PrintStep = @alignCast(@fieldParentPtr("step", step)); print("{s}", .{self.message}); } }; @@ -1121,6 +1120,17 @@ const exercises = [_]Exercise{ .main_file = "105_threading2.zig", .output = "PI ≈ 3.14159265", }, + .{ + .main_file = "106_files.zig", + .output = "Successfully wrote 18 bytes.", + }, + .{ + .main_file = "107_files2.zig", + .output = + \\AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + \\Successfully Read 18 byte: It's zigling time! + , + }, .{ .main_file = "999_the_end.zig", .output = diff --git a/exercises/104_threading.zig b/exercises/104_threading.zig index 8aeb683..ac40b3c 100644 --- a/exercises/104_threading.zig +++ b/exercises/104_threading.zig @@ -106,7 +106,7 @@ pub fn main() !void { // After the threads have been started, // they run in parallel and we can still do some work in between. - std.time.sleep((1) * std.time.ns_per_s); + std.time.sleep(1500 * std.time.ns_per_ms); std.debug.print("Some weird stuff, after starting the threads.\n", .{}); } // After we have left the closed area, we wait until @@ -117,8 +117,13 @@ pub fn main() !void { // This function is started with every thread that we set up. // In our example, we pass the number of the thread as a parameter. fn thread_function(num: usize) !void { + std.time.sleep(200 * num * std.time.ns_per_ms); std.debug.print("thread {d}: {s}\n", .{ num, "started." }); - std.time.sleep((5 - num % 3) * std.time.ns_per_s); + + // This timer simulates the work of the thread. + const work_time = 3 * ((5 - num % 3) - 2); + std.time.sleep(work_time * std.time.ns_per_s); + std.debug.print("thread {d}: {s}\n", .{ num, "finished." }); } // This is the easiest way to run threads in parallel. diff --git a/exercises/105_threading2.zig b/exercises/105_threading2.zig index 1330999..c85f801 100644 --- a/exercises/105_threading2.zig +++ b/exercises/105_threading2.zig @@ -46,7 +46,7 @@ // 1,000,000,000 partial values. And for each additional digit we have to // add a zero. // Even fast computers - and I mean really fast computers - get a bit warmer -// on the CPU when it comes to really many diggits. But the 8 digits are +// on the CPU when it comes to really many digits. But the 8 digits are // enough for us for now, because we want to understand the principle and // nothing more, right? // diff --git a/exercises/106_files.zig b/exercises/106_files.zig new file mode 100644 index 0000000..aa58ee0 --- /dev/null +++ b/exercises/106_files.zig @@ -0,0 +1,92 @@ +// +// Until now, we've only been printing our output in the console, +// which is good enough for fighting alien and hermit bookkeeping. +// +// However, many other task require some interaction with the file system, +// which is the underlying structure for organizing files on your computer. +// +// The File System provide a hierarchical structure for storing files +// by organizing files into directories, which hold files and other directories, +// thus creating a tree structure for navigating. +// +// Fortunately, zig standard library provide a simple api for interacting +// with the file system, see the detail documentation here +// +// https://ziglang.org/documentation/master/std/#std.fs +// +// In this exercise, we'll try to +// - create a new directory +// - open a file in the directory +// - write to the file. +// +// import std as always +const std = @import("std"); + +pub fn main() !void { + // first we get the current working directory + const cwd: std.fs.Dir = std.fs.cwd(); + + // then we'll try to make a new directory /output/ + // to put our output files. + cwd.makeDir("output") catch |e| switch (e) { + // there are chance you might want to run this + // program more than once and the path might already + // been created, so we'll have to handle this error + // by doing nothing + // + // we want to catch error.PathAlreadyExists and do nothing + ??? => {}, + // if is any other unexpected error we just propagate it through + else => return e, + }; + + // then we'll try to open our freshly created directory + // wait a minute + // opening a directory might fail! + // what should we do here? + var output_dir: std.fs.Dir = cwd.openDir("output", .{}); + defer output_dir.close(); + + // we try to open the file `zigling.txt`, + // and propagate the error up if there are any errors + const file: std.fs.File = try output_dir.createFile("zigling.txt", .{}); + // it is a good habit to close a file after you are done with + // so that other program can read it and prevent data corruption + // but here we are not yet done writing to the file + // if only there are a keyword in zig that + // allow you "defer" code execute to the end of scope... + file.close(); + + // !you are not allow to switch this two lines to before file closing line! + const byte_written = try file.write("It's zigling time!"); + std.debug.print("Successfully wrote {d} bytes.\n", .{byte_written}); +} +// to check if you actually write to the file, you can either, +// 1. open the file on your text editor, or +// 2. print the content of the file in the console with command +// >> cat ./output/zigling.txt +// +// +// More on Creating files +// +// notice in: +// ... try output_dir.createFile("zigling.txt", .{}); +// ^^^ +// we passed this anonymous struct to the function call +// +// this is the struct `CreateFlag` with default fields +// { +// read: bool = false, +// truncate: bool = true, +// exclusive: bool = false, +// lock: Lock = .none, +// lock_nonblocking: bool = false, +// mode: Mode = default_mode +// } +// +// Question: +// - what should you do if you want to also read the file after opening it? +// - go to documentation of the struct `std.fs.Dir` here +// https://ziglang.org/documentation/master/std/#std.fs.Dir +// - can you find a function for opening a file? how about deleting a file? +// - what kind of option can you uses with those function? diff --git a/exercises/107_files2.zig b/exercises/107_files2.zig new file mode 100644 index 0000000..dadfdf6 --- /dev/null +++ b/exercises/107_files2.zig @@ -0,0 +1,52 @@ +// +// Prerequisite : +// - exercise/106_files.zig, or +// - create a file {project_root}/output/zigling.txt +// with content `It's zigling time!`(18 byte total) +// +// Now there no point in writing to a file if we don't read from it am I right? +// let's wrote a program to read the content of the file that we just created. +// +// I am assuming you've created the appropriate files for this to work. +// +// Alright, bud, lean in close here's the game plan. +// - First, we open the {project_root}/output/ directory +// - Secondly, we open file `zigling.txt` in that directory +// - then, we initalize an array of character with all letter 'A', and print it +// - Afte that, we read the content of the file to the array +// - Finally, we print out the read content + +const std = @import("std"); + +pub fn main() !void { + // Get the current working directory + const cwd = std.fs.cwd(); + + // try to open ./output assuming you did your 106_files exercise + var output_dir = try cwd.openDir("output", .{}); + defer output_dir.close(); + + // try to open the file + const file = try output_dir.openFile("zigling.txt", .{}); + defer file.close(); + + // initalize an array of u8 with all letter 'A'. + // we need to pick a size of the array, 64 seems like a good number. + // fix the initalization below + var content = ['A']*64; + // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA` + std.debug.print("{s}\n", .{content}); + + // okay, seem like threat of violence is not the answer in this case + // can you go here to find a way to read the content ? + // https://ziglang.org/documentation/master/std/#std.fs.File + // hint: you might find two answer that are both vaild in this case + const byte_read = zig_read_the_file_or_i_will_fight_you(&content); + + // Woah, too screamy, I know you're excited for zigling time but tone it down a bit + // Can you print only what we read from the file ? + std.debug.print("Successfully Read {d} byte: {s}\n", .{ + byte_read, + content, // change this line only + }); +} diff --git a/images/ziglings.jpg b/images/ziglings.jpg deleted file mode 100644 index ca898d2..0000000 Binary files a/images/ziglings.jpg and /dev/null differ diff --git a/patches/patches/104_threading.patch b/patches/patches/104_threading.patch index 58410a8..1ca46c1 100644 --- a/patches/patches/104_threading.patch +++ b/patches/patches/104_threading.patch @@ -1,5 +1,5 @@ ---- exercises/104_threading.zig 2024-03-05 09:09:04.013974229 +0100 -+++ answers/104_threading.zig 2024-03-05 09:12:03.987162883 +0100 +--- exercises/104_threading.zig 2024-04-10 19:12:29.878856370 +0200 ++++ answers/104_threading.zig 2024-04-10 19:11:22.304265713 +0200 @@ -97,12 +97,12 @@ defer handle.join(); diff --git a/patches/patches/106_files.patch b/patches/patches/106_files.patch new file mode 100644 index 0000000..7927cee --- /dev/null +++ b/patches/patches/106_files.patch @@ -0,0 +1,29 @@ +--- exercises/106_files.zig 2024-03-27 16:52:05.660910200 +0800 ++++ answers/106_files.zig 2024-03-27 16:52:09.649422200 +0800 +@@ -35,7 +35,7 @@ + // by doing nothing + // + // we want to catch error.PathAlreadyExists and do nothing +- ??? => {}, ++ error.PathAlreadyExists => {}, + // if is any other unexpected error we just propagate it through + else => return e, + }; +@@ -44,7 +44,7 @@ + // wait a minute + // opening a directory might fail! + // what should we do here? +- var output_dir: std.fs.Dir = cwd.openDir("output", .{}); ++ var output_dir: std.fs.Dir = try cwd.openDir("output", .{}); + defer output_dir.close(); + + // we try to open the file `zigling.txt`, +@@ -55,7 +55,7 @@ + // but here we are not yet done writing to the file + // if only there are a keyword in zig that + // allow you "defer" code execute to the end of scope... +- file.close(); ++ defer file.close(); + + // !you are not allow to switch this two lines to before file closing line! + const byte_written = try file.write("It's zigling time!"); diff --git a/patches/patches/107_files2.patch b/patches/patches/107_files2.patch new file mode 100644 index 0000000..57e04e7 --- /dev/null +++ b/patches/patches/107_files2.patch @@ -0,0 +1,26 @@ +--- exercises/107_files2.zig 2024-03-27 16:51:56.199719600 +0800 ++++ answers/107_files2.zig 2024-03-27 16:52:01.650935300 +0800 +@@ -33,7 +33,7 @@ + // initalize an array of u8 with all letter 'A'. + // we need to pick a size of the array, 64 seems like a good number. + // fix the initalization below +- var content = ['A']*64; ++ var content = [_]u8{'A'} ** 64; + // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA` + std.debug.print("{s}\n", .{content}); + +@@ -41,12 +41,12 @@ + // can you go here to find a way to read the content ? + // https://ziglang.org/documentation/master/std/#std.fs.File + // hint: you might find two answer that are both vaild in this case +- const byte_read = zig_read_the_file_or_i_will_fight_you(&content); ++ const byte_read = try file.read(&content); + + // Woah, too screamy, I know you're excited for zigling time but tone it down a bit + // Can you print only what we read from the file ? + std.debug.print("Successfully Read {d} byte: {s}\n", .{ + byte_read, +- content, // change this line only ++ content[0..byte_read], // change this line only + }); + } diff --git a/test/tests.zig b/test/tests.zig index 9ab15b3..5ee5365 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -152,7 +152,7 @@ const CheckNamedStep = struct { fn make(step: *Step, _: *std.Progress.Node) !void { const b = step.owner; - const self = @fieldParentPtr(CheckNamedStep, "step", step); + const self: *CheckNamedStep = @alignCast(@fieldParentPtr("step", step)); const ex = self.exercise; const stderr_file = try fs.cwd().openFile( @@ -204,7 +204,7 @@ const CheckStep = struct { fn make(step: *Step, _: *std.Progress.Node) !void { const b = step.owner; - const self = @fieldParentPtr(CheckStep, "step", step); + const self: *CheckStep = @alignCast(@fieldParentPtr("step", step)); const exercises = self.exercises; const stderr_file = try fs.cwd().openFile( @@ -327,7 +327,7 @@ const FailStep = struct { fn make(step: *Step, _: *std.Progress.Node) !void { const b = step.owner; - const self = @fieldParentPtr(FailStep, "step", step); + const self: *FailStep = @alignCast(@fieldParentPtr("step", step)); try step.result_error_msgs.append(b.allocator, self.error_msg); return error.MakeFailed; @@ -370,7 +370,7 @@ const HealStep = struct { fn make(step: *Step, _: *std.Progress.Node) !void { const b = step.owner; - const self = @fieldParentPtr(HealStep, "step", step); + const self: *HealStep = @alignCast(@fieldParentPtr("step", step)); return heal(b.allocator, self.exercises, self.work_path); }