lupine/advent-of-code
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Switch to i64 for words

Browse Source
This commit is contained in:
Nick Thomas
2019-12-09 10:48:40 +00:00
parent 96e35f265e
commit 289aa920d0
4 changed files with 55 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
lib/intcode/intcode.zig
View File

@@ -2,16 +2,17 @@ const std = @import("std");
// We're using pipes as character devices
pub const CharDev = [2]i32;
pub const Word = i64;
pub fn loadFromStream(alloc: *std.mem.Allocator, stream: *std.fs.File.InStream.Stream) anyerror![]i32 {
var program = try alloc.alloc(i32, 1024);
pub fn loadFromStream(alloc: *std.mem.Allocator, stream: *std.fs.File.InStream.Stream) anyerror![]Word {
var program = try alloc.alloc(Word, 1024);
var buf = [_]u8{0} ** 255;
var i: u32 = 0;
while (try stream.readUntilDelimiterOrEof(&buf, ',')) |num| {
var trimmed = std.mem.trimRight(u8, num, "\r\n");
program[i] = try std.fmt.parseInt(i32, trimmed, 10);
program[i] = try std.fmt.parseInt(Word, trimmed, 10);
i += 1;
}
@@ -20,7 +21,7 @@ pub fn loadFromStream(alloc: *std.mem.Allocator, stream: *std.fs.File.InStream.S
return program[0..program.len];
}
pub fn loadFromStdIn(alloc: *std.mem.Allocator) anyerror![]i32 {
pub fn loadFromStdIn(alloc: *std.mem.Allocator) anyerror![]Word {
const file = std.io.getStdIn();
const stream = &file.inStream().stream;
@@ -50,7 +51,7 @@ const Instruction = struct {
// Modes for each parameter of the opcode. Parameter 0 is in position 0, etc
modes: [3]Mode,
pub fn decode(value: i32) !Instruction {
pub fn decode(value: Word) !Instruction {
assert(value > 0 and value < 99999);
var buf: [6]u8 = undefined;
@@ -91,14 +92,14 @@ pub const Machine = struct {
alloc: *std.mem.Allocator,
idx: usize = 0, // handy for debugging
memory: []i32,
memory: []Word,
ip: usize = 0,
input: CharDev,
output: CharDev,
pub fn Run(alloc: *std.mem.Allocator, program: []i32) anyerror!Machine {
pub fn Run(alloc: *std.mem.Allocator, program: []Word) anyerror!Machine {
var machine = try init(alloc, program);
try machine.run();
@@ -106,7 +107,7 @@ pub const Machine = struct {
return machine;
}
pub fn init(alloc: *std.mem.Allocator, program: []i32) anyerror!Machine {
pub fn init(alloc: *std.mem.Allocator, program: []Word) anyerror!Machine {
return Machine{
.alloc = alloc,
.memory = program,
@@ -126,34 +127,34 @@ pub const Machine = struct {
std.os.close(self.output[1]);
}
pub fn readFromInput(self: *Machine) !i32 {
pub fn readFromInput(self: *Machine) !Word {
return self.__in(self.input);
}
pub fn writeToInput(self: *Machine, val: i32) !void {
pub fn writeToInput(self: *Machine, val: Word) !void {
return self.__out(self.input, val);
}
pub fn readFromOutput(self: *Machine) !i32 {
pub fn readFromOutput(self: *Machine) !Word {
return self.__in(self.output);
}
pub fn writeToOutput(self: *Machine, val: i32) !void {
pub fn writeToOutput(self: *Machine, val: Word) !void {
return self.__out(self.output, val);
}
fn __in(self: *Machine, dev: CharDev) !i32 {
fn __in(self: *Machine, dev: CharDev) !Word {
const fd = dev[0]; // Read from the pipe
var store: [4]u8 = undefined;
var store: [8]u8 = undefined;
// std.debug.warn("{}: __in({} <- {})\n", self.idx, dev[0], dev[1]);
var n = try std.os.read(fd, &store);
std.debug.assert(n == 4); // TODO: handle partial reads
std.debug.assert(n == 8); // TODO: handle partial reads
return std.mem.readIntNative(i32, &store);
return std.mem.readIntNative(Word, &store);
}
fn __out(self: *Machine, dev: CharDev, val: i32) !void {
fn __out(self: *Machine, dev: CharDev, val: Word) !void {
const fd = dev[1]; // Write to the pipe
const bytes = std.mem.asBytes(&val);
@@ -163,7 +164,7 @@ pub const Machine = struct {
/// Read an immediate or position value from memory. Parameter determines
/// which field following the current instruction to read from
inline fn __read(self: *Machine, parameter: usize, mode: Mode) i32 {
inline fn __read(self: *Machine, parameter: usize, mode: Mode) Word {
const immediate = self.memory[self.ip + parameter + 1];
return switch (mode) {
@@ -172,7 +173,7 @@ pub const Machine = struct {
};
}
inline fn __write(self: *Machine, parameter: usize, value: i32) void {
inline fn __write(self: *Machine, parameter: usize, value: Word) void {
const dest = self.__read(parameter, .Immediate);
self.memory[@intCast(usize, dest)] = value;
}
@@ -252,54 +253,54 @@ const assert = std.debug.assert;
const test_allocator = std.heap.page_allocator;
test "day 2 example 1" {
var before: [12]i32 = .{ 1, 9, 10, 3, 2, 3, 11, 0, 99, 30, 40, 50 };
var after: [12]i32 = .{ 3500, 9, 10, 70, 2, 3, 11, 0, 99, 30, 40, 50 };
var before: [12]Word = .{ 1, 9, 10, 3, 2, 3, 11, 0, 99, 30, 40, 50 };
var after: [12]Word = .{ 3500, 9, 10, 70, 2, 3, 11, 0, 99, 30, 40, 50 };
var machine = try Machine.Run(test_allocator, before[0..before.len]);
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
assert(std.mem.eql(Word, before[0..before.len], after[0..after.len]));
}
test "day 2 example 2" {
var before: [5]i32 = .{ 1, 0, 0, 0, 99 };
var after: [5]i32 = .{ 2, 0, 0, 0, 99 };
var before: [5]Word = .{ 1, 0, 0, 0, 99 };
var after: [5]Word = .{ 2, 0, 0, 0, 99 };
var machine = try Machine.Run(test_allocator, before[0..before.len]);
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
assert(std.mem.eql(Word, before[0..before.len], after[0..after.len]));
}
test "day 2 example 3" {
var before: [5]i32 = .{ 2, 3, 0, 3, 99 };
var after: [5]i32 = .{ 2, 3, 0, 6, 99 };
var before: [5]Word = .{ 2, 3, 0, 3, 99 };
var after: [5]Word = .{ 2, 3, 0, 6, 99 };
var machine = try Machine.Run(test_allocator, before[0..before.len]);
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
assert(std.mem.eql(Word, before[0..before.len], after[0..after.len]));
}
test "day 2 example 4" {
var before: [6]i32 = .{ 2, 4, 4, 5, 99, 0 };
var after: [6]i32 = .{ 2, 4, 4, 5, 99, 9801 };
var before: [6]Word = .{ 2, 4, 4, 5, 99, 0 };
var after: [6]Word = .{ 2, 4, 4, 5, 99, 9801 };
var machine = try Machine.Run(test_allocator, before[0..before.len]);
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
assert(std.mem.eql(Word, before[0..before.len], after[0..after.len]));
}
test "day 2 example 5" {
var before: [9]i32 = .{ 1, 1, 1, 4, 99, 5, 6, 0, 99 };
var after: [9]i32 = .{ 30, 1, 1, 4, 2, 5, 6, 0, 99 };
var before: [9]Word = .{ 1, 1, 1, 4, 99, 5, 6, 0, 99 };
var after: [9]Word = .{ 30, 1, 1, 4, 2, 5, 6, 0, 99 };
var machine = try Machine.Run(test_allocator, before[0..before.len]);
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
assert(std.mem.eql(Word, before[0..before.len], after[0..after.len]));
}
test "day 5 example 1" {
var before: [5]i32 = .{ 3, 0, 4, 0, 99 };
var after: [5]i32 = .{ 666, 0, 4, 0, 99 };
var before: [5]Word = .{ 3, 0, 4, 0, 99 };
var after: [5]Word = .{ 666, 0, 4, 0, 99 };
var machine = try Machine.init(test_allocator, before[0..before.len]);
try machine.writeToInput(666);
try machine.run();
assert(std.mem.eql(i32, before[0..before.len], after[0..after.len]));
assert(std.mem.eql(Word, before[0..before.len], after[0..after.len]));
assert(666 == try machine.readFromOutput());
}