def interpretTokens(tokens: List[Token]) -> List[Token]:
if not len(tokens):
return succes([])
if tokens[0].type == "jumpeq":
if len(tokens) < 3:
return failed(errors.UnexpectedEndOfFile(None, tokens[0].knotId))
if tokens[1].type == "connector":
if tokens[2].type == "int":
token = Token("jumpeq", tokens[2].value, tokens[0].knotId)
restOfList = interpretTokens(tokens[3:])
else:
return failed(
errors.UnexpectedToken(tokens[2].type, tokens[0].knotId))
else:
return failed(
errors.UnexpectedToken(tokens[1].type, tokens[0].knotId))
elif tokens[0].type == "connector":
return failed(errors.UnexpectedToken(tokens[0].type, tokens[0].knotId))
elif tokens[0].type == "int":
return failed(errors.UnexpectedToken(tokens[0].type, tokens[0].knotId))
else:
token = tokens[0]
restOfList = interpretTokens(tokens[1:])
if restOfList.succeeded:
return succes([token] + restOfList.value)
else:
return restOfList
def parseToken(word: str, id: int) -> expected:
if word == "branch":
token = Token("jumpeq", None, id)
elif word == "->":
token = Token("connector", None, id)
elif word.isdigit():
token = Token("int", word, id)
elif word == "overhand":
token = Token("+", None, id)
elif word == "doubleoverhand":
token = Token("-", None, id)
elif word == "eight":
token = Token("output", None, id)
elif word == "stevedore":
token = Token("p+", None, id)
elif word == "ashley":
token = Token("p-", None, id)
elif word == "barrelknot":
token = Token("input", None, id)
else:
return failed(errors.UnknownToken(word, id))
return succes(token)
def input(oldState: State) -> expected:
if not len(oldState.input):
return failed(errors.InputEmpty(oldState.tokens[oldState.pc].knotId))
newMemory = oldState.memory
newMemory[oldState.pointer] = oldState.input[0]
return succes(
State(oldState.tokens, oldState.pc + 1, newMemory, oldState.pointer,
oldState.input[1:], oldState.output))
def pointerMin(oldState: State) -> expected:
if oldState.pointer - 1 >= 0:
return succes(
State(oldState.tokens, oldState.pc + 1, oldState.memory,
oldState.pointer - 1, oldState.input, oldState.output))
else:
return failed(
errors.MemoryUnderflow(oldState.pointer - 1,
oldState.tokens[oldState.pc].knotId))
def pointerPlus(oldState: expected):
if oldState.pointer + 1 < len(oldState.memory):
return succes(
State(oldState.tokens, oldState.pc + 1, oldState.memory,
oldState.pointer + 1, oldState.input, oldState.output))
else:
return failed(
errors.MemoryOverflow(oldState.pointer + 1,
oldState.tokens[oldState.pc].knotId))
def jump(oldState: State) -> expected:
if oldState.memory[oldState.pointer] > 0:
toJumpTo = int(oldState.tokens[oldState.pc].value) - 1
if toJumpTo < 0:
return failed(
errors.JumpUnderflow(toJumpTo + 1,
oldState.tokens[oldState.pc].knotId))
elif not toJumpTo < len(oldState.tokens):
return failed(
errors.JumpOverflow(toJumpTo + 1,
oldState.tokens[oldState.pc].knotId))
else:
return succes(
State(oldState.tokens, toJumpTo, oldState.memory,
oldState.pointer, oldState.input, oldState.output))
else:
return succes(
State(oldState.tokens, oldState.pc + 1, oldState.memory,
oldState.pointer, oldState.input, oldState.output))
def getOutput(state: State, loggingFunc: Callable[[State, State],
None]) -> expected:
if state.pc == len(state.tokens):
return succes(state)
if state.tokens[state.pc].type == "+":
function = operations.plus
if state.tokens[state.pc].type == "-":
function = operations.min
if state.tokens[state.pc].type == "output":
function = operations.output
if state.tokens[state.pc].type == "p+":
function = operations.pointerPlus
if state.tokens[state.pc].type == "p-":
function = operations.pointerMin
if state.tokens[state.pc].type == "input":
function = operations.input
if state.tokens[state.pc].type == "jumpeq":
function = operations.jump
result = function(state)
if result.succeeded:
# I know this part is not functional but I ran out of time here {
if loggingFunc:
for line in loggingFunc(state, result.value):
print(line)
#}
return getOutput(result.value, loggingFunc)
else:
return result
def output(oldState: State) -> expected:
newOutput = oldState.output + [oldState.memory[oldState.pointer]]
return succes(
State(oldState.tokens, oldState.pc + 1, oldState.memory,
oldState.pointer, oldState.input, newOutput))
def min(oldState: State) -> expected:
newMemory = oldState.memory
newMemory[oldState.pointer] -= 1
return succes(
State(oldState.tokens, oldState.pc + 1, newMemory, oldState.pointer,
oldState.input, oldState.output))
