bf.py

import sys

with open(sys.argv[1], "r") as f:
    contents = f.read()

class Node(object):
    def __init__(self, value, position, forward=None, backward=None):
        self.forward = forward
        self.backward = backward
        self.value = value
        self.position = position

    def insert(self, obj):
        if self.forward is None:
            self.forward = obj
            obj.backward = self
        else:
            if obj.position > self.forward.position:
                self.forward.insert(obj)
            else:
                self.forward.backward = obj
                obj.forward = self.forward
                self.forward = obj
                obj.backward = self

    def print(self):
        print(str(self.position) + " " + str(self.value))
        if self.forward is not None:
            self.forward.print()

    def get(self, position):
        if self.position == position:
            return self
        else:
            if self.forward is None:
                return None
            else:
                return self.forward.get(position)

    def change(self, position, inc=None, val=None):
        exists = self.get(position)

        if exists is not None:
            if inc is None:
                exists.value = val
            else:
                exists.value += inc
            if exists.value > 255:
                exists.value -= 256
            elif exists.value < 0:
                exists.value += 256
        else:
            if inc is None:
                new_val = val
            else:
                new_val = inc
            self.insert(Node(new_val, position))

    def inc(self, position):
        self.change(position, 1)

    def dec(self, position):
        self.change(position, -1)

class Type(object):
    def __init__(self, char, value):
        self.char = char
        self.value = value

    def print(self, spaces=''):
        print(spaces + self.char)
        if self.value is None:
            return
        for v in self.value:
            v.print(spaces + 4*' ')

root = Type("root", [])
depth = [root]

for c in contents:
    if c in ['+', '-', '>', '<', '.', ',']:
        depth[-1].value.append(Type(c, None))
    elif c == '[':
        v = Type(c, [])
        depth[-1].value.append(v)
        depth.append(v)
    elif c == ']':
        depth[-1].value.append(Type(c, None))
        depth.pop()

print("Tree of tokens")
root.print()
print()
print()
print("------------------------------------------------")

pointer = 0
base = Node(0, 0)
def parse_tokens(tokens):
    global pointer
    global base
    i = 0
    while i < len(tokens):
        token = tokens[i]
        # base.print()
        # print(token.char)
        # print(pointer)
        # print()
        # print()
        if token.char == '>':
            pointer += 1
        elif token.char  == '<':
            pointer -= 1
        elif token.char  == '+':
            base.inc(pointer)
        elif token.char  == '-':
            base.dec(pointer)
        elif token.char  == '.':
            node = base.get(pointer)
            val = 0 if node is None else node.value
            print(chr(val), end='')
        elif token.char  == ',':
            base.change(pointer, val=ord(input()[0]))
        elif token.char == '[':
            if base.get(pointer) is not None and base.get(pointer).value != 0:
                parse_tokens(token.value)
        elif token.char == ']':
            if base.get(pointer) is not None and base.get(pointer).value != 0:
                i = -1

        i += 1

parse_tokens(root.value)
print()
print("----- STATE -----")
base.print()