Implement most of the compiler

Author: simon816

assembler.py

@@ -84,7 +84,7 @@ def next_instruction(self):
         instr = self.read_symbol().upper()
         whitespace = self.skip_whitespace()
         if self.text and self.head not in '\n;' and not whitespace:
-            self.syntax_error('Expected newline, got %r' % head)
+            self.syntax_error('Expected newline, got %r' % self.head)
         operands = []
         if instr in ['CMD', 'TEST']: # special case
             operands.append(self.read_at_least_once(lambda c: c != '\n', 'non-newline'))
@@ -130,20 +130,23 @@ def read_ref(self):
             return ('symbol', self.read_symbol())
 
     def read_number(self):
+        mul = -1 if self.head == '-' else 1
+        if mul == -1: # Read negative sign
+            self.skip(1)
         if self.head == '0':
             type = self.peek()
             if type == 'x':
                 self.skip(2)
-                return int(self.read_at_least_once(chr_is_hex, 'hex char'), 16)
+                return mul*int(self.read_at_least_once(chr_is_hex, 'hex char'), 16)
             elif type == 'b':
                 self.skip(2)
-                return int(self.read_at_least_once(chr_is_bin, 'bin char'), 2)
+                return mul*int(self.read_at_least_once(chr_is_bin, 'bin char'), 2)
             elif type == 'o':
                 self.skip(2)
-                return int(self.read_at_least_once(chr_is_oct, 'oct char'), 8)
+                return mul*int(self.read_at_least_once(chr_is_oct, 'oct char'), 8)
             # fall through to read as decimal number
 
-        return int(self.read_at_least_once(str.isdecimal, 'decimal char'))
+        return mul*int(self.read_at_least_once(str.isdecimal, 'decimal char'))
 
     def read_string(self):
         self.read('"')
@@ -332,6 +335,11 @@ def sub_to_func_name(self, sub_name):
         return 'sub_' + sub_name
 
     def handle_local_label(self, name):
+        if name.startswith('_'):
+            if name not in ['_setup__']:
+                raise RuntimeError('Unknown special function name: %r' % name)
+            self.enter_subroutine('_' + name)
+            return
         func_name = self.local_to_func_name(name)
         self.split_to_subsequence(func_name)
 
@@ -839,6 +847,9 @@ def add_lookup_table(self, session):
             session.add_subsequence(prev, table)
 
     def write_to_session(self, session):
+        setup = self.subroutines.get('__setup__')
+        if setup is not None:
+            session.set_setup_hook(setup)
         session.load_subroutine_table(self.function_subsequences.keys())
         session.load_subroutine_table(self.included_subroutines)
         if self.enable_sync:

compiler/asm_extensions.py

@@ -0,0 +1,95 @@
+from session import Session
+from assembler import Assembler
+from commands import *
+
+class CompilerSession(Session):
+
+    def __init__(self, pos, writer, namespace, page_size=64, **kwargs):
+        self.page_size = page_size
+        super(CompilerSession, self).__init__(pos, writer, namespace, **kwargs)
+        self.scope.variables.update({
+            'memory_address': 'ma',
+            'memory_buffer': 'mb',
+            'memory_slot': ('ms_%d', range(self.page_size))
+        })
+        self.add_page()
+
+    def add_page(self):
+        setter = Subsequence()
+        getter = Subsequence()
+        dump = ["["]
+
+        mbr = Var('memory_buffer')
+        mar = Var('memory_address')
+
+        for i in range(self.page_size):
+            slot = Var('memory_slot', i)
+            dump.append(slot)
+            if i != self.page_size - 1:
+                dump.append(",")
+
+            setter.add_command(OpAssign(slot, mbr).where(SelEquals(mar, i)))
+            getter.add_command(OpAssign(mbr, slot).where(SelEquals(mar, i)))
+
+        self.scope.add_function_names(('mem_set', 'mem_get', 'mem_dump'))
+        self.add_subsequence('mem_set', setter)
+        self.add_subsequence('mem_get', getter)
+        s = Subsequence()
+        dump.append("]")
+        s.add_command(Tellraw(dump, 'a'))
+        self.add_subsequence('mem_dump', s)
+
+    def extended_setup(self, up, down):
+        # temp
+        up.append(SetConst(Var('stack_pointer'), 0).resolve(self.scope))
+        for i in range(self.page_size):
+            slot = Var('memory_slot', i)
+            up.append(SetConst(slot, 0).resolve(self.scope))
+
+class ExtendedAssembler(Assembler):
+
+    def __init__(self):
+        super(ExtendedAssembler, self).__init__()
+        self.instructions.update({
+            'MOVIND': self.handle_mov_ind,
+            'MOVINDD': self.handle_mov_ind_d,
+            'MOVINDS': self.handle_mov_ind_s
+        })
+
+    def handle_mov_ind(self, src, s_off, dest, d_off):
+        """Move indirect src to indirect dest"""
+        src, dest = self.get_src_dest(src, dest)
+        s_off = self.resolve_ref(*s_off)
+        d_off = self.resolve_ref(*d_off)
+        assert type(s_off) == int
+        assert type(d_off) == int
+        self.add_command(OpAssign(Var('memory_address'), src))
+        if s_off != 0:
+            self.add_command(AddConst(Var('memory_address'), s_off))
+        self.add_command(Function('mem_get'))
+        self.add_command(OpAssign(Var('memory_address'), dest))
+        if d_off != 0:
+            self.add_command(AddConst(Var('memory_address'), d_off))
+        self.add_command(Function('mem_set'))
+
+    def handle_mov_ind_d(self, src, dest, d_off):
+        """Move src to indirect dest"""
+        src, dest = self.get_src_dest(src, dest)
+        offset = self.resolve_ref(*d_off)
+        assert type(offset) == int
+        self.add_command(self.assign_op(Var('memory_buffer'), src))
+        self.add_command(OpAssign(Var('memory_address'), dest))
+        if offset != 0:
+            self.add_command(AddConst(Var('memory_address'), offset))
+        self.add_command(Function('mem_set'))
+
+    def handle_mov_ind_s(self, src, s_off, dest):
+        """Move indirect src to dest"""
+        src, dest = self.get_src_dest(src, dest)
+        offset = self.resolve_ref(*s_off)
+        assert type(offset) == int
+        self.add_command(self.assign_op(Var('memory_address'), src))
+        if offset != 0:
+            self.add_command(AddConst(Var('memory_address'), offset))
+        self.add_command(Function('mem_get'))
+        self.add_command(OpAssign(dest, Var('memory_buffer')))