examples/hello.jt

@@ -5,7 +5,6 @@ import io
 
 // main can return int or void, void mains are handled by jortsc
 fn main () -> int {
-    // todo: put it back to io.puts
-    ioputs("pants")
+    io.puts("pants")
     0
 }

jortsc/parser/ast_nodes.py

@@ -27,19 +27,3 @@ class Identifier:
 @dataclass
 class Import:
     module: str
-
-
-@dataclass
-class String:
-    value: str
-
-
-@dataclass
-class Number:
-    value: str
-
-
-@dataclass
-class FunctionCall:
-    function: str
-    args: list

jortsc/parser/lexer.py

@@ -13,7 +13,6 @@ class TokenType(Enum):
     comment_end = auto()
     whitespace = auto()
     number = auto()
-    string = auto()
 
 
 @dataclass
@@ -51,7 +50,7 @@ TOKENS = [
     (r'\-\>', TokenType.reserved),
     (r'\.', TokenType.reserved),
 
-    (r'\"[^\n]*\"', TokenType.string),
+    (r'\"[^\n]*\"', TokenType.reserved),
 
     # basic math ops
     (r'[\+\-\/\*]', TokenType.reserved),

jortsc/parser/syntatic.py

@@ -2,8 +2,7 @@ from typing import Optional, Any, List
 
 from jortsc.parser.lexer import Token, TokenType
 from jortsc.parser.ast_nodes import (
-    Function, TypedVar, Identifier, Import, ReturnType, String, Number,
-    FunctionCall
+    Function, TypedVar, Identifier, Import, ReturnType
 )
 
 
@@ -19,8 +18,7 @@ class Reader:
         self.cur = 0
 
     def __repr__(self):
-        return (f'<Reader cur={self.cur} tot={len(self.tokens)} '
-                f'cur_tok={self.peek()}>')
+        return f'<Reader cur={self.cur} cur_tok={self.peek()}>'
 
     def peek(self) -> Optional[Token]:
         """Peek at the current token."""
@@ -170,34 +168,6 @@ def read_reserved(token: Token, reader: Reader):
     return handler(reader)
 
 
-def read_value(token: Token, _reader: Reader):
-    """Read a given value"""
-    if token.type_ == TokenType.string:
-        return String(token.value)
-    elif token.type_ == TokenType.number:
-        return Number(token.value)
-
-
-def read_statement(token: Token, reader: Reader):
-    """Read a statement"""
-    # token is an identifier, so first check for a function call
-
-    # TODO: handle more things than a function call
-    call_fn_name = token.value
-    token = reader.expect_val('(')
-    res = []
-
-    while True:
-        token = reader.next_safe()
-
-        if token.value == ')':
-            break
-
-        res.append(read_value(token, reader))
-
-    return FunctionCall(call_fn_name, res)
-
-
 def read_start(reader: Reader):
     """Read the start of a program."""
     print('reader', reader)
@@ -205,33 +175,22 @@ def read_start(reader: Reader):
     token = reader.next()
 
     if token is None:
-        print('eof!')
-        return None
+        return []
 
     ast = []
     res = []
 
+    print('cur', token)
+
     # handle blocks
     if token.value == '{':
-        # next can be a whitespace, or a }
-        token = reader.next()
+        while True:
+            token = reader.next()
 
-        print('block start!, next:', token)
+            if token.value == '}':
+                break
 
-        if token.type_ == TokenType.whitespace:
-            # keep going on reading
-            while True:
-                token = reader.peek()
-                print('block append', token)
-
-                if token.value == '}':
-                    print('block end')
-                    reader.next()
-                    break
-
-                res.extend(read_start(reader))
-        elif token.value == '}':
-            res = []
+            res.extend(read_start(reader))
 
     # import, fn, etc
     elif token.type_ == TokenType.reserved:
@@ -241,26 +200,24 @@ def read_start(reader: Reader):
         return []
 
     elif token.type_ == TokenType.identifier:
-        res = read_statement(token, reader)
-    else:
-        res = read_value(token, reader)
+        res = [Identifier(token.value)]
 
     ast.append(res)
     return ast
 
-
 def read_loop(reader: Reader):
-    """Read the AST."""
     final_ast = []
 
     while True:
         ast = read_start(reader)
 
-        # break when eof
-        if ast is None:
+        if not ast:
             break
 
-        # TODO: better ast cleanup
+        inner = ast[0]
+
+        if not inner:
+            break
 
         final_ast.append(ast)