make a common lib for non-intcode problems

intcode/include/Overload.hpp

@@ -0,0 +1,7 @@
+#ifndef OVERLOAD_HPP_
+#define OVERLOAD_HPP_
+
+template <class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
+template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
+#endif

intcode/include/intcode/Interpreter.hpp

@@ -0,0 +1,51 @@
+#ifndef INTCODE_INTERPRETER_HPP_
+#define INTCODE_INTERPRETER_HPP_
+
+#include <variant>
+#include <concepts>
+
+#include <intcode/Machine.hpp>
+#include <Overload.hpp>
+namespace intcode {
+
+struct Input {
+ValueType &input;
+};
+
+struct Output {
+ValueType output;
+};
+
+struct Halt {};
+
+auto StepInput(Machine & m, ValueType input) -> void;
+
+auto StepOutput(Machine & m) -> ValueType;
+
+auto Step(Machine & m) -> std::variant<Input, Output, Halt>;
+
+struct BadInstruction : public std::runtime_error {
+  explicit BadInstruction(char const* what);
+};
+
+template <std::invocable<ValueType&> Fin, std::invocable<ValueType> Fout, std::invocable<> Fhalt>
+auto Advance(Machine & machine, Fin input, Fout output, Fhalt halt) {
+  return std::visit(overloaded{
+    [&](Halt) { return halt(); },
+    [&](Input i) { return input(i.input); },
+    [&](Output o) { return output(o.output); },
+    }, Step(machine));
+}
+
+template <std::invocable<> Fin, std::invocable<ValueType> Fout>
+auto Run(Machine & machine, Fin input, Fout output) -> void {
+  while (Advance(machine,
+    [&](ValueType &i) { i = input(); return true; },
+    [&](ValueType o) { output(o); return true; },
+    []() { return false; }
+    )) {}
+}
+
+} // namespace
+
+#endif

intcode/include/intcode/Machine.hpp

@@ -0,0 +1,43 @@
+#ifndef INTCODE_MACHINE_HPP_
+#define INTCODE_MACHINE_HPP_
+
+#include <cstddef>
+#include <unordered_map>
+#include <vector>
+#include <iostream>
+
+namespace intcode {
+
+using ValueType = std::int64_t;
+
+class Machine {
+  std::vector<ValueType> rom_;
+  std::unordered_map<std::size_t, ValueType> ram_;
+  std::size_t pc_;
+  std::size_t base_;
+
+public:
+  Machine();
+
+  /// Initialize a new machine with a given program starting
+  /// execution and program counter 0.
+  explicit Machine(std::vector<ValueType> program);
+
+  /// Access memory at absolute address
+  /// @param address
+  /// @return reference to memory at given address
+  auto At(std::size_t address) -> ValueType &;
+
+  /// Access memory at address relative to base pointer
+  /// @param offset from base pointer
+  /// @return reference to memory at given offset
+  auto Rel(std::size_t offset) -> ValueType &;
+
+  auto Next() -> ValueType &;
+  auto Goto(std::size_t address) -> void;
+  auto Rebase(std::size_t offset) -> void;
+};
+
+} // namespace
+
+#endif

intcode/include/intcode/Parser.hpp

@@ -0,0 +1,15 @@
+#ifndef INTCODE_PARSER_HPP_
+#define INTCODE_PARSER_HPP_
+
+#include <istream>
+#include <vector>
+
+#include "Machine.hpp"
+
+namespace intcode {
+
+auto ParseStream(std::istream &in) -> std::vector<ValueType>;
+
+} // namespace
+
+#endif

intcode/include/intcode/intcode.hpp

@@ -0,0 +1,9 @@
+#ifndef INTCODE_INTCODE_HPP_
+#define INTCODE_INTCODE_HPP_
+
+#include <intcode/Interpreter.hpp>
+#include <intcode/Machine.hpp>
+#include <intcode/Parser.hpp>
+#include <Overload.hpp>
+
+#endif