Brainfuck interpreter.

Author: aperez

CMakeLists.txt

@@ -13,3 +13,4 @@ function(add_meta_project arg)
 endfunction(add_meta_project)
 
 add_meta_project(turing-machine)
+add_meta_project(brainfuck)

brainfuck/interpreter.hpp

@@ -0,0 +1,119 @@
+#pragma once
+
+#include "common/conditional.hpp"
+#include "common/string.hpp"
+
+#include "memory.hpp"
+
+namespace meta {
+namespace brainfuck {
+
+template <typename memory = initial_memory,
+          typename input = make_string<>,
+          typename output = make_string<>>
+struct state {
+    using mem = memory;
+    using in = input;
+    using out = output;
+};
+
+template <typename command, typename st>
+struct _interpret_command {
+    using result = st;
+};
+
+template <typename st>
+struct _interpret_command<chr<'>'>, st> {
+    using result = state<typename st::mem::rshift,
+                         typename st::in,
+                         typename st::out>;
+};
+
+template <typename st>
+struct _interpret_command<chr<'<'>, st> {
+    using result = state<typename st::mem::lshift,
+                         typename st::in,
+                         typename st::out>;
+};
+
+template <typename st>
+struct _interpret_command<chr<'+'>, st> {
+    using result = state<call<inc_cursor, typename st::mem>,
+                         typename st::in,
+                         typename st::out>;
+};
+
+template <typename st>
+struct _interpret_command<chr<'-'>, st> {
+    using result = state<call<dec_cursor, typename st::mem>,
+                         typename st::in,
+                         typename st::out>;
+};
+
+template <typename st>
+struct _interpret_command<chr<'.'>, st> {
+    using result = state<typename st::mem,
+                         typename st::in,
+                         append<typename st::mem::get, typename st::out>>;
+};
+
+template <typename st>
+struct _interpret_command<chr<','>, st> {
+    using in_value = peek<typename st::in, chr<>>;
+    using result = state<call<turing::set_cursor, typename st::mem, in_value>,
+                         pop<typename st::in>,
+                         typename st::out>;
+};
+
+CREATE_ALIAS(interpret_command);
+
+template <typename program, typename loop = list<>, int counter = 0>
+struct find_loop :
+        public find_loop<pop<program>, append<peek<program>, loop>, counter> {};
+
+template <typename... cmds, typename loop, int counter>
+struct find_loop<list<chr<'['>, cmds...>, loop, counter> :
+        public find_loop<list<cmds...>, append<chr<'['>, loop>, counter + 1> {};
+
+template <typename... cmds, typename loop, int counter>
+struct find_loop<list<chr<']'>, cmds...>, loop, counter> :
+        public find_loop<list<cmds...>, append<chr<']'>, loop>, counter - 1> {};
+
+template <typename... cmds, typename loop>
+struct find_loop<list<chr<']'>, cmds...>, loop, 0> {
+    using remaining_program = list<cmds...>;
+    using loop_program = loop;
+};
+
+template <typename program, typename st = state<>>
+struct _interpret {
+    using command = peek<program>;
+    using next_state = interpret_command<command, st>;
+    using result = typename _interpret<pop<program>, next_state>::result;
+};
+
+template <typename... commands, typename st>
+struct _interpret<list<chr<'['>, commands...>, st> {
+    using program = list<commands...>;
+    using loop = find_loop<program>;
+    using end_loop = is_same<chr<0>, typename st::mem::get>;
+    using next_state =
+        conditional<end_loop,
+                    st,
+                    typename _interpret<typename loop::loop_program, st>::result>;
+    using next_program =
+        conditional<end_loop,
+                    typename loop::remaining_program,
+                    push<chr<'['>, program>>;
+    using result = typename _interpret<next_program, next_state>::result;
+};
+
+template <typename st>
+struct _interpret<list<>, st> {
+    using result = st;
+};
+
+CREATE_ALIAS(interpret);
+
+}
+}

brainfuck/main.cpp

@@ -0,0 +1,23 @@
+#include "common/string.hpp"
+
+#include "interpreter.hpp"
+
+int main() {
+
+    // from Wikipedia:
+    // https://en.wikipedia.org/wiki/Brainfuck#Hello_World.21
+    using hello_world =
+        meta::make_string<'+','+','+','+','+','+','+','+','[','>','+','+',
+                          '+','+','[','>','+','+','>','+','+','+','>','+',
+                          '+','+','>','+','<','<','<','<','-',']','>','+',
+                          '>','+','>','-','>','>','+','[','<',']','<','-',
+                          ']','>','>','.','>','-','-','-','.','+','+','+',
+                          '+','+','+','+','.','.','+','+','+','.','>','>',
+                          '.','<','-','.','<','.','+','+','+','.','-','-',
+                          '-','-','-','-','.','-','-','-','-','-','-','-',
+                          '-','.','>','>','+','.','>','+','+','.'>;
+
+    using hw_output = meta::brainfuck::interpret<hello_world>::out;
+
+    return 0;
+}

brainfuck/memory.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "common/macros.hpp"
+#include "common/list.hpp"
+#include "common/string.hpp"
+
+#include "turing-machine/tape.hpp"
+
+namespace meta {
+namespace brainfuck {
+
+using initial_memory = meta::turing::tape<chr<>, list<>, list<>, chr<>>;
+
+template <typename c>
+struct __inc_chr;
+
+template <char c>
+struct __inc_chr<chr<c>> {
+    using result = chr<c+1>;
+};
+
+template <>
+struct __inc_chr<chr<(char)255>> {
+    using result = chr<>;
+};
+
+CREATE_ALIAS(_inc_chr);
+using inc_chr = lambda<_inc_chr>;
+
+template <typename c>
+struct __dec_chr;
+
+template <char c>
+struct __dec_chr<chr<c>> {
+    using result = chr<c-1>;
+};
+
+template <>
+struct __dec_chr<chr<(char)0>> {
+    using result = chr<(char)255>;
+};
+
+CREATE_ALIAS(_dec_chr);
+using dec_chr = lambda<_dec_chr>;
+
+template <typename mem>
+using _inc_cursor = typename mem::template set<call<inc_chr, typename mem::get>>;
+using inc_cursor = lambda<_inc_cursor>;
+
+template <typename mem>
+using _dec_cursor = typename mem::template set<call<dec_chr, typename mem::get>>;
+using dec_cursor = lambda<_dec_cursor>;
+
+}
+}

common/string.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "list.hpp"
+
+namespace meta {
+
+template <char c = (char)0>
+struct chr {
+    static constexpr char value { c };
+};
+
+template <char... cs>
+struct _make_string {
+    using result = list<>;
+};
+
+template <char c, char... cs>
+struct _make_string<c, cs...> {
+    using result = push<chr<c>,
+                        typename _make_string<cs...>::result>;
+};
+
+template <char... cs>
+using make_string = typename _make_string<cs...>::result;
+
+}

readme.org

@@ -11,3 +11,4 @@ basic building blocks.
   - [[./common/][common/]]: libraries implementing shared functionality. Contains
     implementations of type lists, conditionals, lambdas, among others.
   - [[./turing-machine][turing-machine/]]: a Turing Machine simulator.
+  - [[./brainfuck/][brainfuck/]]: an interpreter for the Brainfuck programming language.