463 lines
14 KiB
Python
463 lines
14 KiB
Python
import random
|
|
|
|
from rply.token import BaseBox
|
|
|
|
|
|
BUILTIN_ARGS = {
|
|
"print": "*",
|
|
"input" : "*",
|
|
"random": 2,
|
|
"len": 1,
|
|
"int": 1,
|
|
"str": 1,
|
|
"flo": 1
|
|
}
|
|
|
|
def rep_join(l):
|
|
format_string = ',\n'.join(
|
|
[repr(i) if not isinstance(i, str) else i for i in l]
|
|
).replace('\n', '\n ')
|
|
|
|
if format_string != "":
|
|
format_string = f"\n {format_string}\n"
|
|
|
|
return format_string
|
|
class Exp(BaseBox):
|
|
def eval(self, vtable, ftable):
|
|
return vtable, ftable, None
|
|
|
|
def __repr__(self) -> str:
|
|
return "exp()"
|
|
|
|
class ExpInt(Exp):
|
|
def __init__(self, value: int):
|
|
self.value = value
|
|
|
|
def __repr__(self) -> str:
|
|
return f"exp_int({self.value})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
return vtable, ftable, self.value
|
|
|
|
class ExpFloat(Exp):
|
|
def __init__(self, value: int):
|
|
self.value = value
|
|
|
|
def __repr__(self) -> str:
|
|
return f"exp_float({self.value})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
return vtable, ftable, self.value
|
|
|
|
class ExpBool(Exp):
|
|
def __init__(self, value: int):
|
|
self.value = value
|
|
|
|
def __repr__(self) -> str:
|
|
return f"exp_bool({self.value})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
return vtable, ftable, self.value
|
|
|
|
class ExpString(Exp):
|
|
def __init__(self, value: str):
|
|
self.value = value
|
|
|
|
def __repr__(self) -> str:
|
|
return f"exp_string({self.value})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
return vtable, ftable, self.value
|
|
|
|
class ExpVariable(Exp):
|
|
def __init__(self, variable_id: str):
|
|
self.variable_name = variable_id
|
|
|
|
def __repr__(self) -> str:
|
|
return f"variable({self.variable_name})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
return vtable, ftable, vtable[self.variable_name]
|
|
|
|
class ExpABinop(Exp):
|
|
def __init__(self,op: str,exp1: Exp, exp2: Exp):
|
|
self.op = op
|
|
self.exp1 = exp1
|
|
self.exp2 = exp2
|
|
|
|
def __repr__(self) -> str:
|
|
return f"exp_a_binop({self.op}, {self.exp1}, {self.exp2})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
|
|
vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
|
|
|
|
if not (type(r1) is type(r2) or (type(r1) is float and type(r2) is int) or (type(r1) is int and type(r2) is float)):
|
|
print(f"C003: Incorrect type pairing {type(r1)} and {type(r2)} for {self.op}")
|
|
|
|
if self.op == "+":
|
|
return vtable, ftable, r1+r2
|
|
elif self.op == "-":
|
|
return vtable, ftable, r1-r2
|
|
elif self.op == "*":
|
|
return vtable, ftable, r1*r2
|
|
elif self.op == "/":
|
|
return vtable, ftable, r1/r2
|
|
elif self.op == "=":
|
|
return vtable, ftable, r1 == r2
|
|
elif self.op == ">":
|
|
return vtable, ftable, r1 > r2
|
|
elif self.op == "<":
|
|
return vtable, ftable, r1 < r2
|
|
elif self.op == "mod":
|
|
return vtable, ftable, r1 % r2
|
|
else:
|
|
raise Exception(f"Unknown binop {self.op}")
|
|
|
|
class ExpList(Exp):
|
|
def __init__(self, expressions: list[Exp]):
|
|
self.list = expressions
|
|
|
|
def __repr__(self) -> str:
|
|
return f"exp_list([{rep_join(self.list)}])"
|
|
|
|
def eval(self, vtable, ftable):
|
|
results = []
|
|
for element in self.list:
|
|
vtable, ftable, result = element.eval(vtable, ftable)
|
|
results.append(result)
|
|
|
|
return vtable, ftable, results
|
|
|
|
class ExpIndex(Exp):
|
|
def __init__(self, items: ExpList, index: Exp):
|
|
self.list = items
|
|
self.index = index
|
|
|
|
def __repr__(self) -> str:
|
|
return f"exp_index({self.list}, {self.index})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
vtable, ftable, elements = self.list.eval(vtable, ftable)
|
|
vtable, ftable, index = self.index.eval(vtable, ftable)
|
|
|
|
if len(elements) > index:
|
|
result = elements[index]
|
|
else:
|
|
result = None
|
|
|
|
return vtable, ftable, result
|
|
|
|
class ExpArg(Exp):
|
|
def __init__(self, arg: int):
|
|
self.arg = arg
|
|
|
|
def __repr__(self) -> str:
|
|
return f"exp_arg({self.arg})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
n = vtable["#ARGS"] - self.arg
|
|
|
|
return vtable, ftable, vtable[f"#{n}"]
|
|
|
|
class Command(BaseBox):
|
|
def eval(self, vtable, ftable):
|
|
return vtable, ftable, None
|
|
|
|
def __repr__(self) -> str:
|
|
return f"command()"
|
|
|
|
class Builtin(Command):
|
|
def __init__(self, builtin, args: list[Exp]):
|
|
self.builtin = builtin.value[:-1]
|
|
self.args = args
|
|
self.position = builtin.source_pos.lineno
|
|
expected_args = BUILTIN_ARGS[self.builtin]
|
|
|
|
if not (expected_args == "*" or expected_args == len(self.args)):
|
|
print(f"E005: Wrong number of arguments for builtin '{self.builtin}' ({len(self.args)}) at line {self.position}")
|
|
exit()
|
|
|
|
def __repr__(self) -> str:
|
|
return f"builtin({self.builtin}, {self.args})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
if self.builtin == "print":
|
|
prints = []
|
|
for arg in self.args:
|
|
vtable, ftable, result = arg.eval(vtable, ftable)
|
|
if isinstance(result, str) or isinstance(result, int) or isinstance(result, float):
|
|
prints.append(str(result))
|
|
elif isinstance(result, list):
|
|
result = f"{'{'}{''.join([str(i)+';' for i in result])}{'}'}"
|
|
prints.append(str(result))
|
|
else:
|
|
print(f"C003: Incorrect type {type(result)} for builtin print")
|
|
exit()
|
|
|
|
print(" ".join(prints))
|
|
|
|
return vtable, ftable, " ".join(prints)
|
|
elif self.builtin == "input":
|
|
if not self.args == []:
|
|
prints = []
|
|
for arg in self.args:
|
|
vtable, ftable, result = arg.eval(vtable, ftable)
|
|
prints.append(str(result))
|
|
|
|
print(" ".join(prints), end="")
|
|
else:
|
|
print("> ", end="")
|
|
|
|
result = input()
|
|
return vtable, ftable, result
|
|
elif self.builtin == "random":
|
|
vtable, ftable, r1 = self.args[0].eval(vtable, ftable)
|
|
vtable, ftable, r2 = self.args[1].eval(vtable, ftable)
|
|
|
|
r = random.randint(r1, r2)
|
|
|
|
return vtable, ftable, r
|
|
elif self.builtin == "len":
|
|
vtable, ftable, result = self.args[0].eval(vtable,ftable)
|
|
|
|
return vtable, ftable, len(result)
|
|
elif self.builtin == "int":
|
|
vtable, ftable, result = self.args[0].eval(vtable,ftable)
|
|
|
|
return vtable, ftable, int(result)
|
|
elif self.builtin == "str":
|
|
vtable, ftable, result = self.args[0].eval(vtable,ftable)
|
|
|
|
return vtable, ftable, str(result)
|
|
else:
|
|
raise Exception(f"Unknown builtin {self.builtin}")
|
|
|
|
class Do(BaseBox):
|
|
def __init__(self, command: Command):
|
|
self.command = command
|
|
|
|
def __repr__(self) -> str:
|
|
return f"do({self.command})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
return self.command.eval(vtable, ftable)
|
|
|
|
class Statement(BaseBox):
|
|
def eval(self, vtable, ftable):
|
|
return vtable, ftable, None
|
|
|
|
def __repr__(self) -> str:
|
|
return f"statement()"
|
|
|
|
class StatementSkip(Statement):
|
|
def __repr__(self) -> str:
|
|
return f"skip()"
|
|
|
|
class StatementSet(Statement):
|
|
def __init__(self, expression: Exp, variable: str):
|
|
self.expression = expression
|
|
self.variable_name = variable
|
|
|
|
def __repr__(self) -> str:
|
|
return f"set({self.expression}, {self.variable_name})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
vtable, ftable, result = self.expression.eval(
|
|
vtable, ftable
|
|
)
|
|
vtable[self.variable_name] = result
|
|
return vtable, ftable, result
|
|
|
|
class StatementDefine(Statement):
|
|
def __init__(self, function_name : str, parameters: int, statement: Statement):
|
|
self.function_name = function_name
|
|
self.statement = statement
|
|
self.parameters = parameters
|
|
|
|
def __repr__(self) -> str:
|
|
return f"define({self.function_name}, {self.statement}, {self.parameters})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
ftable[self.function_name] = (self.parameters, self.statement)
|
|
return vtable, ftable, (self.parameters, self.statement)
|
|
|
|
class StatementReturn(Statement):
|
|
def __init__(self, expression: Exp):
|
|
self.value = expression
|
|
|
|
def __repr__(self) -> str:
|
|
return f"return({self.value})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
vtable, ftable, result = self.value.eval(vtable, ftable)
|
|
vtable["#return"] = result
|
|
return vtable, ftable, result
|
|
|
|
class Scope(Statement):
|
|
def __init__(self, statements: list[Statement]):
|
|
self.statements = statements
|
|
|
|
def __repr__(self) -> str:
|
|
return f"scope([{rep_join(self.statements)}])"
|
|
|
|
def eval(self, vtable, ftable):
|
|
if "#return" in vtable:
|
|
del vtable["#return"]
|
|
|
|
result = None
|
|
for statement in self.statements:
|
|
# print(statement)
|
|
vtable, ftable, _ = statement.eval(vtable, ftable)
|
|
# print(statement, vtable)
|
|
if "#return" in vtable:
|
|
result = vtable["#return"]
|
|
break
|
|
|
|
return vtable, ftable, result
|
|
|
|
class Call(Statement):
|
|
def __init__(self, function_name: str, arguments: list[Exp]):
|
|
self.function_name = function_name
|
|
self.arguments = arguments
|
|
|
|
def __repr__(self) -> str:
|
|
return f"call({self.function_name}, {self.arguments})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
assert len(self.arguments) == ftable[self.function_name][0]
|
|
|
|
args = []
|
|
for argument in self.arguments:
|
|
vtable, ftable, result = argument.eval(vtable,ftable)
|
|
args.append(result)
|
|
|
|
n = vtable["#ARGS"]-1
|
|
|
|
for i, arg in enumerate(args):
|
|
vtable[f"#{n+len(args)-i}"] = arg
|
|
|
|
vtable["#ARGS"] += len(args)
|
|
|
|
vtable_old, ftable_old = vtable, ftable
|
|
vtable, ftable, result = ftable[self.function_name][1].eval(vtable, ftable)
|
|
|
|
if "#return" in vtable:
|
|
del vtable["#return"]
|
|
|
|
vtable["#ARGS"] -= len(args)
|
|
|
|
print(vtable, vtable_old)
|
|
return vtable_old, ftable_old, result
|
|
|
|
class CommandIf(Command):
|
|
def __init__(self, statement: Statement, condition):
|
|
self.statement = statement
|
|
self.condition = condition
|
|
|
|
def __repr__(self) -> str:
|
|
return f"if({self.statement}, {self.condition})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
vtable, ftable, result = self.condition.eval(vtable, ftable)
|
|
if result:
|
|
return self.statement.eval(vtable, ftable)
|
|
else:
|
|
return vtable, ftable, result
|
|
|
|
class CommandIfElse(Command):
|
|
def __init__(self, statement: Statement, else_statement: Statement, condition):
|
|
self.statement = statement
|
|
self.else_statement = else_statement
|
|
self.condition = condition
|
|
|
|
def __repr__(self) -> str:
|
|
return f"ifelse({self.statement}, {self.condition}, {self.else_statement})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
vtable, ftable, result = self.condition.eval(vtable, ftable)
|
|
if result:
|
|
return self.statement.eval(vtable, ftable)
|
|
else:
|
|
return self.else_statement.eval(vtable, ftable)
|
|
|
|
class CommandBecause(Command):
|
|
def __init__(self, statement: Statement, condition):
|
|
self.statement = statement
|
|
self.condition = condition
|
|
|
|
def __repr__(self) -> str:
|
|
return f"because({self.statement}, {self.condition})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
vtable, ftable, result = self.condition.eval(vtable, ftable)
|
|
if result:
|
|
return self.statement.eval(vtable, ftable)
|
|
else:
|
|
print("C001: Because assertion incorrect")
|
|
exit()
|
|
|
|
class CommandUntil(Command):
|
|
def __init__(self, statement: Statement, condition):
|
|
self.statement = statement
|
|
self.condition = condition
|
|
|
|
def __repr__(self) -> str:
|
|
return f"until({self.statement}, {self.condition})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
if "#return" in vtable:
|
|
del vtable["#return"]
|
|
|
|
while True:
|
|
vtable, ftable, result = self.condition.eval(vtable, ftable)
|
|
if not result:
|
|
vtable, ftable, _ = self.statement.eval(vtable, ftable)
|
|
if "#return" in vtable:
|
|
result = vtable["#return"]
|
|
return vtable, ftable, result
|
|
else:
|
|
return vtable, ftable, result
|
|
|
|
class Maybe(BaseBox):
|
|
def __init__(self, statement : Statement):
|
|
self.statement = statement
|
|
|
|
def __repr__(self) -> str:
|
|
return f"maybe({self.statement})"
|
|
|
|
def eval(self, vtable, ftable):
|
|
if random.randint(0,1) == 1:
|
|
return self.statement.eval(vtable,ftable)
|
|
else:
|
|
return vtable, ftable, False
|
|
|
|
class Program(BaseBox):
|
|
def __init__(self, statements: list[Statement]) -> None:
|
|
self.statements = statements
|
|
random.seed(str(self))
|
|
r = random.randint(1,10)
|
|
if r == 1:
|
|
print("E004: Random compiler error")
|
|
exit()
|
|
random.seed()
|
|
|
|
def __repr__(self) -> str:
|
|
statements_string = f"program([{rep_join(self.statements)}])"
|
|
return statements_string
|
|
|
|
def eval(self, *_):
|
|
vtable = {"#ARGS": 0}
|
|
ftable = {}
|
|
|
|
for statement in self.statements:
|
|
try:
|
|
vtable, ftable, _ = statement.eval(vtable, ftable)
|
|
except Exception as e:
|
|
print(f"C002: Unknown error in statement {statement}")
|
|
raise e
|
|
if "#return" in vtable:
|
|
del vtable["#return"]
|
|
if not isinstance(vtable,Scope):
|
|
break
|