154 lines
3.6 KiB
Python
154 lines
3.6 KiB
Python
from .trinary import *
|
|
|
|
|
|
class Machine:
|
|
|
|
def run(self, program):
|
|
"""Run Malbolge code passed as a string."""
|
|
|
|
#Accumulator
|
|
self.a = trin(0)
|
|
|
|
#Registers
|
|
self.d = trinlist()
|
|
self.c = trinlist()
|
|
|
|
#Pointers
|
|
self.pointer_c = trin(0)
|
|
self.pointer_d = trin(0)
|
|
|
|
statements = {
|
|
"j": self.__swap_d,
|
|
"i": self.__swap_c,
|
|
"*": self.__rotate,
|
|
"p": self.__crazy,
|
|
"<": self.__read,
|
|
"/": self.__print,
|
|
"v": self.__exit,
|
|
"o": self.__nop
|
|
}
|
|
|
|
#Check max lenght
|
|
if len(program) > 3 ** 10:
|
|
raise MemoryError("Out of memory. 3^10 words limit exceeded.")
|
|
|
|
#Copy the program in register c
|
|
for index, word in enumerate(program):
|
|
if word not in ("\n", " "):
|
|
if trinord(word) not in range(32, 127):
|
|
raise SyntaxError("Invalid character:'%c' a %d."
|
|
% (word, index))
|
|
else:
|
|
self.c[index] = trinord(word)
|
|
|
|
#Program execution
|
|
while self.pointer_c < len(program):
|
|
#Calculate current instruction
|
|
statement = self.__calculate_statement(trinchr(self.c[self.pointer_c]))
|
|
try:
|
|
statements[statement]()
|
|
except KeyError:
|
|
statements["o"]()
|
|
|
|
#Operations for each statement
|
|
self.c[self.pointer_c] -= 33
|
|
self.__translate()
|
|
self.pointer_c += 1
|
|
self.pointer_d += 1
|
|
|
|
def __calculate_statement(self, character):
|
|
"""
|
|
Calculates the instruction to be executed
|
|
based on the character in the pointer.
|
|
"""
|
|
table = "+b(29e*j1VMEKLyC})8&m#~W>qxdRp0wkr \
|
|
Uo[D7,XTcA\"lI.v%{gJh4G\-=O@5`_3i< \
|
|
?Z';FNQuY]szf$!BS/|t:Pn6^Ha"
|
|
statement = (trinord(character) - 33 + self.pointer_c) % 94
|
|
return table[statement.decimal]
|
|
|
|
def __translate(self):
|
|
"""
|
|
Write the statement in the code register
|
|
following the conversion table.
|
|
"""
|
|
trans = str.maketrans(
|
|
'!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN \
|
|
OPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~',
|
|
'5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72FhOA1 \
|
|
CB6v^=I_0/8|jsb9m<.TVac`uY*MK\'X~xDl}REokN:#?G"i@'
|
|
)
|
|
statement = str.translate(trinchr(self.c[self.pointer_c]), trans)
|
|
self.c[self.pointer_c] = trinord(statement)
|
|
|
|
#Statements
|
|
|
|
def __swap_d(self):
|
|
"""
|
|
Malbolge statement "j"
|
|
Assign the data pointer the value it points to.
|
|
"""
|
|
self.pointer_d = self.d[self.pointer_d]
|
|
|
|
def __swap_c(self):
|
|
"""
|
|
Malbolge statement "i"
|
|
Assign to the code pointer the value pointed by the data pointer.
|
|
"""
|
|
self.pointer_c = self.d[self.pointer_d]
|
|
|
|
def __rotate(self):
|
|
"""
|
|
Malbolge statement "*"
|
|
Rotate the word pointed by the pointer by a trit to the right.
|
|
"""
|
|
self.d[self.pointer_d] = trin(self.a[-1] + self.a[0:-1])
|
|
|
|
def __crazy(self):
|
|
"""
|
|
Malbolge statement "p"
|
|
Performs the operation crazy with the value in the accumulator
|
|
and the value pointed by the data pointer. Then stores the result
|
|
in the accumulator and log data.
|
|
"""
|
|
operation = [[1, 0, 0], [1, 0, 2], [2, 2, 1]]
|
|
result = []
|
|
for i, j in zip(self.a, self.d[self.pointer_d]):
|
|
result += operation[i][j],
|
|
self.d[self.pointer_d] = trin(result)
|
|
self.a = trin(result)
|
|
|
|
def __read(self):
|
|
"""
|
|
Malbolge statement "<"
|
|
Reads a character from stdin and stores it in the accumulator.
|
|
"""
|
|
character = input()
|
|
if len(character) > 1:
|
|
raise TypeError("Expected a character: read a string.")
|
|
elif len(character) == 0:
|
|
raise TypeError("Expected a character: read an empty string.")
|
|
else:
|
|
self.a = trinord(character)
|
|
|
|
def __print(self):
|
|
"""
|
|
Malbolge statement "/"
|
|
Print the character present in the accumulator.
|
|
"""
|
|
print(trinchr(self.a), end="")
|
|
|
|
def __exit(self):
|
|
"""
|
|
Malbolge statement "v"
|
|
Terminate the program.
|
|
"""
|
|
exit()
|
|
|
|
def __nop(self):
|
|
"""
|
|
Malbolge statement "o"
|
|
Performs the nop operation.
|
|
"""
|
|
pass
|