3

intcode/src/Interpreter.cpp

@@ -2,10 +2,10 @@
 
 namespace intcode {
 
-BadInstruction::BadInstruction(char const* what)
+BadInstruction::BadInstruction(char const* const what)
     : std::runtime_error{what} {}
 
-auto StepInput(Machine & m, ValueType input) -> void {
+auto StepInput(Machine & m, ValueType const input) -> void {
   std::get<Input>(Step(m)).input = input;
 }
 
@@ -15,67 +15,58 @@ auto StepOutput(Machine & m) -> ValueType {
 
 auto Step(Machine & m) -> std::variant<Input, Output, Halt> {
   for (;;) {
-    auto instruction = m.Next();
-    auto modes = instruction / 10;
+    auto next = m.Next();
+    auto const instruction = next % 100; next /= 100;
 
-    auto arg = [&]() -> ValueType & {
+    auto const arg = [&]() -> ValueType & {
       auto &v = m.Next();
-      switch ((modes /= 10) % 10) {
-      case 0:
-        return m.At(v);
-      case 1:
-        return v;
-      case 2:
-        return m.Rel(v);
-      default:
-        throw BadInstruction{"invalid addressing mode"};
+      auto const mode = next % 10; next /= 10;
+      switch (mode) {
+      case 0: return m.At(v);
+      case 1: return v;
+      case 2: return m.Rel(v);
+      default: throw BadInstruction{"invalid addressing mode"};
       }
     };
 
-    switch (instruction % 100) {
-    case 1: {
+    switch (instruction) {
+    case 1:
       arg() = arg() + arg();
       break;
-    }
 
-    case 2: {
+    case 2:
       arg() = arg() * arg();
       break;
-    }
 
-    case 3: {
+    case 3:
       return Input{arg()};
-    }
 
-    case 4: {
+    case 4:
       return Output{arg()};
-    }
 
     case 5: {
-      auto a = arg();
-      auto b = arg();
+      auto const a = arg();
+      auto const b = arg();
       if (a) { m.Goto(b); }
       break;
     }
 
     case 6: {
-      auto a = arg();
-      auto b = arg();
+      auto const a = arg();
+      auto const b = arg();
       if (!a) { m.Goto(b); }
       break;
     }
 
     case 7: {
-      auto a = arg();
-      auto b = arg();
-      arg() = a < b; // order matters
+      auto const a = arg();
+      arg() = a < arg();
       break;
     }
 
-    case 8: {
+    case 8:
       arg() = arg() == arg();
       break;
-    }
 
     case 9:
       m.Rebase(arg());
@@ -85,6 +76,7 @@ auto Step(Machine & m) -> std::variant<Input, Output, Halt> {
       return Halt{};
 
     default:
+    std::cout << instruction << std::endl;
       throw BadInstruction{"invalid opcode"};
     }
   }

intcode/src/Machine.cpp

@@ -5,17 +5,17 @@ namespace intcode {
 Machine::Machine() : rom_{}, ram_{}, pc_{0}, base_{0} {}
 
 Machine::Machine(std::vector<ValueType> program)
-    : rom_{program}, ram_{}, pc_{0}, base_{0} {}
+    : rom_{std::move(program)}, ram_{}, pc_{0}, base_{0} {}
 
-auto Machine::At(std::size_t i) -> ValueType & {
+auto Machine::At(std::size_t const i) -> ValueType & {
   return i < rom_.size() ? rom_[i] : ram_[i];
 }
 
-auto Machine::Rel(std::size_t i) -> ValueType & {
+auto Machine::Rel(std::size_t const i) -> ValueType & {
   return At(base_ + i);
 }
 
-auto Machine::Rebase(std::size_t offset) -> void {
+auto Machine::Rebase(std::size_t const offset) -> void {
   base_ += offset;
 }
 
@@ -23,7 +23,7 @@ auto Machine::Next() -> ValueType & {
   return At(pc_++);
 }
 
-auto Machine::Goto(std::size_t address) -> void {
+auto Machine::Goto(std::size_t const address) -> void {
   pc_ = address;
 }