compile based on the fancy new AST

3 files changed, 117 insertions, 131 deletions

diff --git a/crowbar_reference_compiler/__init__.py b/crowbar_reference_compiler/__init__.py
index 53d942f..1410bf7 100644
--- a/crowbar_reference_compiler/__init__.py
+++ b/crowbar_reference_compiler/__init__.py
@@ -1,10 +1,7 @@
-import dataclasses
-from pprint import pprint
-
 from .ast import build_ast
 from .parser import parse_header, parse_implementation
 from .scanner import scan
-from .ssagen import compile_to_ssa
+from .ssagen import build_ssa
 
 
 def main():
@@ -37,9 +34,8 @@ def main():
         return
 
     full_ast = build_ast(parse_tree, args.include_dir)
-    pprint(dataclasses.asdict(full_ast))
 
-    ssa = compile_to_ssa(parse_tree)
+    ssa = build_ssa(full_ast)
     if args.stop_at_qbe_ssa:
         if args.out is None:
             args.out = args.input.replace('.cro', '.ssa')
diff --git a/crowbar_reference_compiler/ast.py b/crowbar_reference_compiler/ast.py
index 2a6963c..bb5a4e1 100644
--- a/crowbar_reference_compiler/ast.py
+++ b/crowbar_reference_compiler/ast.py
@@ -530,7 +530,8 @@ class ASTBuilder(NodeVisitor):
             return ConstantExpression(body.data)
         if body.type in ['true', 'false']:
             return ConstantExpression(body.type)
-        raise NotImplementedError()
+        if body.type == 'string_literal':
+            return ConstantExpression(body.data)
 
     def visit_StructPointerElementSuffix(self, node, visited_children):
         separator, element = visited_children
diff --git a/crowbar_reference_compiler/ssagen.py b/crowbar_reference_compiler/ssagen.py
index 8d4b6be..3c12c85 100644
--- a/crowbar_reference_compiler/ssagen.py
+++ b/crowbar_reference_compiler/ssagen.py
@@ -1,124 +1,113 @@
-from parsimonious import NodeVisitor  # type: ignore
-from parsimonious.nodes import Node  # type: ignore
-
-
-class SsaGenVisitor(NodeVisitor):
-    def __init__(self):
-        self.data = []
-
-    def visit_ImplementationFile(self, node, visited_children):
-        data = '\n'.join(self.data)
-        functions = '\n'.join(visited_children)
-        return data + '\n' + functions
-
-    def visit_IncludeStatement(self, node, visited_children):
-        include, included_header, semicolon = visited_children
-        assert include.text[0].type == 'include'
-        assert included_header.type == 'string_literal'
-        included_header = included_header.data
-        assert semicolon.text[0].type == ';'
-        return ''
-
-    def visit_FunctionDefinition(self, node, visited_children):
-        signature, body = visited_children
-        return_type, name, args = signature
-        body = '\n'.join('    ' + instr for instr in body)
-        return f"export function w ${name}() {{\n@start\n{body}\n}}"
-
-    def visit_FunctionSignature(self, node, visited_children):
-        return_type, name, lparen, args, rparen = visited_children
-        assert name.type == 'identifier'
-        name = name.data
-        assert lparen.text[0].type == '('
-        assert rparen.text[0].type == ')'
-        return return_type, name, args
-
-    def visit_Block(self, node, visited_children):
-        lbrace, statements, rbrace = visited_children
-        return statements
-
-    def visit_Statement(self, node, visited_children):
-        return visited_children[0]
-
-    def visit_ExpressionStatement(self, node, visited_children):
-        expression, semicolon = visited_children
-        assert semicolon.text[0].type == ';'
-        return expression
-
-    def visit_Expression(self, node, visited_children):
-        # TODO handle logical and/or
-        return visited_children[0]
-
-    def visit_ComparisonExpression(self, node, visited_children):
-        # TODO handle comparisons
-        return visited_children[0]
-
-    def visit_BitwiseOpExpression(self, node, visited_children):
-        # TODO handle bitwise operations
-        return visited_children[0]
-
-    def visit_ArithmeticExpression(self, node, visited_children):
-        # TODO handle addition/subtraction
-        return visited_children[0]
-
-    def visit_TermExpression(self, node, visited_children):
-        # TODO handle multiplication/division/modulus
-        return visited_children[0]
-
-    def visit_FactorExpression(self, node, visited_children):
-        # TODO handle casts/address-of/pointer-dereference/unary ops/sizeof
-        return visited_children[0]
-
-    def visit_ObjectExpression(self, node, visited_children):
-        # TODO handle array literals
-        # TODO handle struct literals
-        base, suffices = visited_children[0]
-        if isinstance(suffices, Node):
-            suffices = suffices.children
-        if len(suffices) == 0:
-            return base
-        if base.type == 'identifier' and suffices[0].text[0].type == '(':
-            arguments = suffices[1]
-            if arguments[0].type == 'string_literal':
-                data = arguments[0].data
-                name = f"$data{len(self.data)}"
-                # TODO handle non-variadic functions
-                arguments = [f"l {name}", '...']
-                self.data.append(f"data {name} = {{ b {data}, b 0 }}")
-            return f"call ${base.data}({', '.join(arguments)})"
-        print(base)
-        print(suffices[0])
-
-    def visit_AtomicExpression(self, node, visited_children):
-        # TODO handle parenthesized subexpressions
-        return visited_children[0]
-
-    def visit_FlowControlStatement(self, node, visited_children):
-        # TODO handle break/continue
-        ret, arg, semicolon = visited_children[0]
-        assert ret.text[0].type == 'return'
-        assert semicolon.text[0].type == ';'
-        if arg.type == 'constant':
-            return f"ret {arg.data}"
-
-    def visit_constant(self, node, visited_children):
-        return node.text[0]
-
-    def visit_string_literal(self, node, visited_children):
-        return node.text[0]
-
-    def visit_identifier(self, node, visited_children):
-        return node.text[0]
-
-    def generic_visit(self, node, visited_children):
-        """ The generic visit method. """
-        if not visited_children:
-            return node
-        if len(visited_children) == 1:
-            return visited_children[0]
-        return visited_children
-
-
-def compile_to_ssa(parse_tree):
-    ssa_gen = SsaGenVisitor()
-    return ssa_gen.visit(parse_tree)
+from dataclasses import dataclass
+from functools import singledispatch
+from typing import Dict, List
+
+from .ast import ImplementationFile, FunctionDefinition, ExpressionStatement, FunctionCallExpression, \
+    VariableExpression, ConstantExpression, ReturnStatement, BasicType
+
+
+@dataclass
+class SsaResult:
+    data: List[str]
+    code: List[str]
+
+
+@dataclass
+class CompileContext:
+    next_data: int = 0
+    next_temp: int = 0
+
+
+def build_ssa(file: ImplementationFile) -> str:
+    result = compile_to_ssa(file, CompileContext())
+    data = '\n'.join(result.data)
+    code = '\n'.join(result.code)
+    return data + '\n\n' + code
+
+
+@singledispatch
+def compile_to_ssa(target, context: CompileContext) -> SsaResult:
+    raise NotImplementedError('unannotated compile on ' + str(type(target)))
+
+
+@compile_to_ssa.register
+def _(target: ImplementationFile, context: CompileContext):
+    data = []
+    code = []
+    for target in target.contents:
+        result = compile_to_ssa(target, context)
+        data += result.data
+        code += result.code
+    return SsaResult(data, code)
+
+
+@compile_to_ssa.register
+def _(target: FunctionDefinition, context: CompileContext) -> SsaResult:
+    data = []
+    code = []
+    for statement in target.body:
+        result = compile_to_ssa(statement, context)
+        data += result.data
+        code += result.code
+    code = ['    ' + instr for instr in code]
+    assert len(target.args) == 0
+    assert target.return_type == BasicType('int32')
+    code = [f"export function w ${target.name}() {{", "@start", *code, "}"]
+    return SsaResult(data, code)
+
+
+@compile_to_ssa.register
+def _(target: ExpressionStatement, context: CompileContext) -> SsaResult:
+    return compile_to_ssa(target.body, context)
+
+
+@compile_to_ssa.register
+def _(target: FunctionCallExpression, context: CompileContext) -> SsaResult:
+    assert isinstance(target.function, VariableExpression)
+    data = []
+    code = []
+    args = []
+    for i, expr in enumerate(target.arguments):
+        arg_dest = context.next_temp
+        result = compile_to_ssa(expr, context)
+        data += result.data
+        code += result.code
+        args += [f"l %t{arg_dest}"]
+    code += [f"call ${target.function.name}({','.join(args)}, ...)"]
+    return SsaResult(data, code)
+
+
+@compile_to_ssa.register
+def _(target: ConstantExpression, context: CompileContext) -> SsaResult:
+    if target.value.startswith('"'):
+        data_dest = context.next_data
+        context.next_data += 1
+        data = [f"data $data{data_dest} = {{ b {target.value}, b 0 }}"]
+        temp = context.next_temp
+        context.next_temp += 1
+        code = [f"%t{temp} =l copy $data{data_dest}"]
+    else:
+        assert not target.value.startswith('0b')
+        assert not target.value.startswith('0B')
+        assert not target.value.startswith('0o')
+        assert not target.value.startswith('0x')
+        assert not target.value.startswith('0X')
+        assert not target.value.startswith('0f')
+        assert not target.value.startswith('0F')
+        assert '.' not in target.value
+        assert not target.value.startswith("'")
+        data = []
+        temp = context.next_temp
+        context.next_temp += 1
+        code = [f"%t{temp} =w copy {target.value}"]
+    return SsaResult(data, code)
+
+
+@compile_to_ssa.register
+def _(target: ReturnStatement, context: CompileContext) -> SsaResult:
+    if target.body is None:
+        return SsaResult([], ['ret'])
+    ret_val_dest = context.next_temp
+    result = compile_to_ssa(target.body, context)
+    result.code.append(f"ret %t{ret_val_dest}")
+    return result