add classes for AST nodes

- add Reader.expect, Reader.next_safe
 - fix fn_read_args, use TypedVar
 - use Reader.expect in read_function's post-fn check
 - use Function in read_function
 - add basics of blocks using { and } in read_start

jortsc/parser/ast_nodes.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+@dataclass
+class TypedVar:
+    type_: str
+    name: str
+
+
+@dataclass
+class Function:
+    name: str
+    arguments: str
+    block: list

jortsc/parser/syntatic.py

@@ -1,6 +1,7 @@
 from typing import Optional, Any, List
 
 from jortsc.parser.lexer import Token, TokenType
+from jortsc.parser.ast_nodes import Function, TypedVar
 
 
 class ParseError(Exception):
@@ -24,36 +25,60 @@ class Reader:
         self.cur += 1
         return token
 
+    def expect(self, token_type: TokenType) -> Token:
+        """Check for a specific token type and error if it fails"""
+        token = self.next()
+
+        if token.type_ != token_type:
+            raise ParseError(f'Expected {token_type}, got {token.type_}')
+
+        return token
+
+    def next_safe(self) -> Token:
+        """'Safe' version of next().
+
+        Raises an 'Unexpected EOF' error if next() returns None.
+        """
+        token = self.next()
+
+        if token is None:
+            raise ParseError('Unexpected EOF')
+
+        return token
+
 
 def _fn_read_args(reader: Reader, cur: List = None) -> List:
     """Recursively read the arguments of the function."""
     if cur is None:
         cur = []
 
-    token = reader.next()
+    # it can be an identifier for the arguments' type, OR a RPAREN
+    # if it is rparen, we stop
+    # if it isnt, we keep going until that happens
+    token = reader.next_safe()
 
     if token.value == ')':
         return cur
 
-    argtype, argname = reader.next(), reader.next()
+    argtype = token
-    cur.append((argtype, argname))
+    reader.expect(TokenType.whitespace)
+    argname = reader.next_safe()
+
+    cur.append(TypedVar(argtype.value, argname.value))
     return _fn_read_args(reader, cur)
 
 
 def read_function(reader: Reader):
     """Read a function block."""
-    token = reader.next()
+    reader.expect(TokenType.whitespace)
-
-    if token.type_ == TokenType.whitespace:
-        pass
-    else:
-        raise ParseError('Expected whitespace')
 
     token = reader.next()
 
     fn_name = '_anonymous'
     fn_args = []
 
+    print('function token', token)
+
     if token.type_ == TokenType.identifier:
         fn_name = token.value
         fn_args = _fn_read_args(reader)
@@ -62,7 +87,7 @@ def read_function(reader: Reader):
         fn_args = _fn_read_args(reader)
         block = read_start(reader)
 
-    return (fn_name, fn_args, block)
+    return Function(fn_name, fn_args, block)
 
 
 def read_reserved(token: Token, reader: Reader):
@@ -73,16 +98,29 @@ def read_reserved(token: Token, reader: Reader):
 
 def read_start(reader: Reader):
     """Read the start of a program."""
+    print('reader', reader)
+
     token = reader.next()
     ast = []
     res = []
 
     print('cur', token)
 
+    # TODO: statement handling
     if token.type_ == TokenType.reserved:
         res = read_reserved(token, reader)
 
-    ast.extend(res)
+    # handle blocks
+    elif token.value == '{':
+        while True:
+            token = reader.peek()
+
+            if token.value == '}':
+                break
+
+            res.extend(read_start(reader))
+
+    ast.append(res)
     return ast