✨

plthy_impl/ast_nodes.py

@@ -16,10 +16,16 @@ class Exp(BaseBox):
     def eval(self, vtable, ftable):
         return vtable, ftable, None
 
-class ExpNumeral(Exp):
+    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
 
@@ -27,6 +33,9 @@ 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
 
@@ -34,6 +43,9 @@ class ExpVariable(Exp):
     def __init__(self, variable_id: str):
         self.variable_name = variable_id
 
+    def __repr__(self) -> str:
+        return f"exp_variable({self.variable_name})"
+
     def eval(self, vtable, ftable):
         return vtable, ftable, vtable[self.variable_name]
 
@@ -43,34 +55,81 @@ class ExpABinop(Exp):
         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)
+        if isinstance(r1,str):
+            if r1.isdigit():
+                r1 = int(r1)
+            else:
+                r1 = float(r1)
+        vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
+        if isinstance(r2,str):
+            if r2.isdigit():
+                r2 = int(r2)
+            else:
+                r2 = float(r2)
         if self.op == "+":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1+r2
         elif self.op == "-":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1-r2
         elif self.op == "*":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1*r2
         elif self.op == "/":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1/r2
         elif self.op == "=":
-            vtable, ftable, r1 = self.exp1.eval(vtable, ftable)
-            vtable, ftable, r2 = self.exp2.eval(vtable, ftable)
             return vtable, ftable, r1 == r2
+        elif self.op == ">":
+            return vtable, ftable, r1 > r2
+        elif self.op == "<":
+            return vtable, ftable, r1 < r2
         else:
-            raise Exception(f"Binop {self.op} not implemented")
+            print(f"E007: Unknown binop {self.op}")
+            exit()
+
+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
 
@@ -80,11 +139,17 @@ 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: str, args: list[Exp]):
         self.builtin = builtin
         self.args = args
 
+    def __repr__(self) -> str:
+        return f"builtin({self.builtin}, {self.args})"
+
     def eval(self, vtable, ftable):
         if self.builtin == "print":
             prints = []
@@ -94,14 +159,41 @@ class Builtin(Command):
 
             print("   ".join(prints))
 
-            return vtable, ftable, None
+            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":
+            if not len(self.args) == 2:
+                print(f"E006: Wrong number of arguments for builtin '{self.builtin}' ({len(self.args)})")
+                exit()
+
+            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
         else:
-            raise Exception(f"Unknown builtin {self.builtin}")
+            raise Exception(f"E005: 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)
 
@@ -109,17 +201,23 @@ class Statement(BaseBox):
     def eval(self, vtable, ftable):
         return vtable, ftable, None
 
+    def __repr__(self) -> str:
+        return f"statement()"
+
 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, None
+        return vtable, ftable, result
 
 class StatementDefine(Statement):
     def __init__(self, function_name : str, parameters: int, statement: Statement):
@@ -127,14 +225,20 @@ class StatementDefine(Statement):
         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, None
+        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
@@ -144,6 +248,9 @@ 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):
         result = None
         for statement in self.statements:
@@ -160,6 +267,9 @@ class Call(Statement):
         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]
 
@@ -189,29 +299,61 @@ class StatementIf(Statement):
         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, None
+            return vtable, ftable, result
+
+class StatementUntil(Statement):
+    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):
+        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"]
+                    del 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, None
+            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,20)
+        if r == 1:
+            print("E004: Random compiler error")
+            exit()
+        random.seed()
 
     def __repr__(self) -> str:
-        statements_string = f"statements([{rep_join(self.statements)}])"
+        statements_string = f"program([{rep_join(self.statements)}])"
         return statements_string
 
     def eval(self, *_):

plthy_impl/lexer.py

@@ -9,7 +9,7 @@ KEYWORD_TOKENS = [("KEYWORD_"+i.upper(), i) for i in [
     "maybe",
     "do",
     "if",
-    "because",
+#    "because",
     "until",
     "define",
     "as",
@@ -19,18 +19,21 @@ KEYWORD_TOKENS = [("KEYWORD_"+i.upper(), i) for i in [
 ]]
 
 BUILTIN_TOKENS = [("BUILTIN", i) for i in [
-    "print"
+    "print",
+    "input",
+    "random"
 ]]
 
 DATA_TOKENS = [
     ("DATA_STRING", r"\'.*?\'"),
-    ("DATA_NUMERAL", r"\d+(\.\d+)?")
+    ("DATA_INT", r"\d+"),
+    ("DATA_FLOAT", r"\d+(\.\d+)")
 ]
 
 SYMBOL_TOKENS = [
     ("SYMBOL_SET", r"\-\>"),
-    ("SYMBOL_LPARENS", r"\("),
-    ("SYMBOL_RPARENS", r"\)"),
+#    ("SYMBOL_LPARENS", r"\("),
+#    ("SYMBOL_RPARENS", r"\)"),
     ("SYMBOL_LBRACKET", r"\["),
     ("SYMBOL_RBRACKET", r"\]"),
     ("SYMBOL_LCURL", r"\{"),
@@ -39,8 +42,8 @@ SYMBOL_TOKENS = [
     ("SYMBOL_MINUS", r"\-"),
     ("SYMBOL_TIMES", r"\*"),
     ("SYMBOL_DIVIDE", r"\/"),
-    ("SYMBOL_COMMA", r"\,"),
-    ("SYMBOL_COLON", r"\:"),
+#    ("SYMBOL_COMMA", r"\,"),
+#    ("SYMBOL_COLON", r"\:"),
     ("SYMBOL_SEMICOLON", r"\;"),
     ("SYMBOL_PIPE", r"\|"),
     ("SYMBOL_QUOTE", r"\""),

plthy_impl/parser.py

@@ -9,11 +9,11 @@ class Parser():
             [i[0] for i in ALL_TOKENS],
             precedence=[
                 ('left', ["KEYWORD_MAYBE", "KEYWORD_RETURN"]),
-                ('left', ["KEYWORD_IF", "KEYWORD_DEFINE", "KEYWORD_AS"]),
+                ('left', ["KEYWORD_IF", "KEYWORD_UNTIL", "KEYWORD_DEFINE", "KEYWORD_AS"]),
                 ('left', ["KEYWORD_DO", "BUILTIN"]),
                 ('left', ["SYMBOL_EQUALS", "SYMBOL_SET"]),
                 ('left', ["SYMBOL_PLUS", "SYMBOL_MINUS"]),
-                ('left', ["SYMBOL_TIMES", "SYMBOL_DIVIDE"])
+                ('left', ["SYMBOL_TIMES", "SYMBOL_DIVIDE", "SYMBOL_LT","SYMBOL_GT"])
             ]
         )
 
@@ -49,7 +49,11 @@ class Parser():
         def statement_if(tokens):
             return ast_nodes.StatementIf(tokens[0], tokens[2])
 
-        @self.pg.production('statement : KEYWORD_DEFINE ID SYMBOL_LT DATA_NUMERAL SYMBOL_GT KEYWORD_AS statement', precedence="KEYWORD_DEFINE")
+        @self.pg.production('statement : KEYWORD_UNTIL expression statement')
+        def statement_until(tokens):
+            return ast_nodes.StatementUntil(tokens[2],tokens[1])
+
+        @self.pg.production('statement : KEYWORD_DEFINE ID SYMBOL_LT DATA_INT SYMBOL_GT KEYWORD_AS statement', precedence="KEYWORD_DEFINE")
         def statement_define(tokens):
             return ast_nodes.StatementDefine(tokens[1].value, int(tokens[3].value), tokens[6])
 
@@ -80,9 +84,13 @@ class Parser():
             return [tokens[0]] + tokens[2]
 
         ## expression ##
-        @self.pg.production('expression : DATA_NUMERAL')
-        def exp_numeral(tokens):
-            return ast_nodes.ExpNumeral(float(tokens[0].value))
+        @self.pg.production('expression : DATA_INT')
+        def exp_int(tokens):
+            return ast_nodes.ExpInt(int(tokens[0].value))
+
+        @self.pg.production('expression : DATA_FLOAT')
+        def exp_int(tokens):
+            return ast_nodes.ExpInt(float(tokens[0].value))
 
         @self.pg.production('expression : DATA_STRING')
         def exp_string(tokens):
@@ -101,6 +109,8 @@ class Parser():
         @self.pg.production('expression : expression SYMBOL_TIMES expression')
         @self.pg.production('expression : expression SYMBOL_DIVIDE expression')
         @self.pg.production('expression : expression SYMBOL_EQUALS expression')
+        @self.pg.production('expression : expression SYMBOL_LT expression')
+        @self.pg.production('expression : expression SYMBOL_GT expression')
         def exp_a_binop(tokens):
             return ast_nodes.ExpABinop(tokens[1].value,tokens[0],tokens[2])
 
@@ -108,10 +118,24 @@ class Parser():
         def exp_arg(tokens):
             return ast_nodes.ExpArg(int(tokens[1].value[1:]))
 
+        @self.pg.production('expression : SYMBOL_LCURL expressions SYMBOL_RCURL')
+        def exp_list(tokens):
+            return ast_nodes.ExpList(tokens[1])
+
+        @self.pg.production('expression : expression SYMBOL_LCURL expression SYMBOL_RCURL')
+        def exp_index(tokens):
+            return ast_nodes.ExpIndex(tokens[0],tokens[2])
+
         ## Error Handling ##
         @self.pg.error
         def error_handle(token):
-            raise Exception(token.name, token.value, token.source_pos)
+            if token.source_pos is None:
+                print("E002: No valediction")
+            elif token.source_pos.lineno == 1 and token.source_pos.colno == 1:
+                print("E001: No greeting")
+            else:
+                print(f"E003: Unexpected token '{token.value}' ({token.name}) at line {token.source_pos.lineno}, column {token.source_pos.colno}.")
+            exit()
 
         ## Finish ##
         parser = self.pg.build()