Refactor code generation and some misc changes

Author: simon816

asm_reader.py

@@ -19,7 +19,7 @@ class AsmReader:
     def __init__(self, text='', filename=''):
         self.text = text
         self.lineno = 1
-        self.filename = filename or '<a.asm>'
+        self.filename = filename
 
     def feed(self, text):
         self.text += text

assembler.py

@@ -23,6 +23,7 @@ def __init__(self):
         self.constants = {}
         self.function_subsequences = {}
         self.command_block_lines = []
+        self.event_handlers = []
         self.included_subroutines = set()
         self.enter_subroutine('__main__')
         self.jump_later = None
@@ -33,15 +34,20 @@ def __init__(self):
         self.predef()
         self.init_instructions()
         self.enable_sync = False
-        self.reader = None
+        self.lineno = None
+        self.filename = None
 
     def predef(self):
         self.constants['sp'] = Var('stack_pointer')
         self.constants['sr'] = Var('stack_register')
 
     def parse(self, text, filename=''):
-        reader = self.reader = AsmReader(text, filename)
+        self.filename = filename or '<a.asm>'
+        self.consume_reader(AsmReader(text, self.filename))
+
+    def consume_reader(self, reader):
         for (token, arg) in reader:
+            self.lineno = reader.lineno
             if token == 'const':
                 name, ref = arg
                 self.define_const(name, self.resolve_ref(*ref))
@@ -60,12 +66,10 @@ def parse(self, text, filename=''):
                 self.handle_directive(*arg)
             elif token == 'eof':
                 break
-        self.reader = None
 
     def warn(self, message):
         import warnings
-        r = self.reader
-        warnings.showwarning(message, UserWarning, r.filename, r.lineno)
+        warnings.showwarning(message, UserWarning, self.filename, self.lineno)
 
     def define_const(self, name, value):
         if name in self.constants:
@@ -195,28 +199,42 @@ def add_cast(self, type, cmd, dest):
     def handle_directive(self, directive, value):
         if directive == 'include':
             import os
-            dir = os.path.dirname(self.reader.filename)
+            our_file = self.filename
+            dir = os.path.dirname(our_file)
             path = os.path.join(dir, value)
             with open(path, 'r') as f:
                 data = f.read()
-                old_reader = self.reader
-                self.parse(data, path)
-                self.reader = old_reader
+            self.parse(data, path)
+            self.filename = our_file
         elif directive == 'include_h':
             import os
-            dir = os.path.dirname(self.reader.filename)
+            our_file = self.filename
+            dir = os.path.dirname(our_file)
             path = os.path.join(dir, value)
             with open(path, 'r') as f:
                 data = f.read()
-                assembler = Assembler()
-                assembler.enable_sync = self.enable_sync
-                assembler.parse(data, path)
-                for sub in assembler.subroutines.keys():
-                    if sub.startswith('__'):
-                        continue
-                    self.included_subroutines.add(self.sub_to_func_name(sub))
-                self.constants.update(assembler.constants)
-                self.sync_func_ids.update(assembler.sync_func_ids)
+            assembler = Assembler()
+            assembler.enable_sync = self.enable_sync
+            assembler.parse(data, path)
+            for sub in assembler.subroutines.keys():
+                if sub.startswith('__'):
+                    continue
+                self.included_subroutines.add(self.sub_to_func_name(sub))
+            self.constants.update(assembler.constants)
+            self.sync_func_ids.update(assembler.sync_func_ids)
+        elif directive == 'event_handler':
+            handler, event, conditions = value.split(' ', 2)
+            conds = {}
+            if conditions:
+                for cond in conditions.split(';'):
+                    key, value = cond.split('=', 1)
+                    path = tuple(key.split('.'))
+                    conds[path] = value
+            self.event_handlers.append({
+                'event': event,
+                'conditions': conds,
+                'handler': self.sub_to_func_name(handler)
+            })
 
     def init_instructions(self):
         self.instructions = {
@@ -857,6 +875,7 @@ def write_to_session(self, session):
         for name, sequence in self.function_subsequences.items():
             session.add_subsequence(name, sequence)
         session.add_command_blocks(self.command_block_lines)
+        session.add_event_handlers(self.event_handlers)
 
     def get_sub_jump_command(self, sub_name):
         return Function(self.sub_to_func_name(sub_name))

compiler/asm_extensions.py

@@ -113,24 +113,6 @@ def __init__(self):
             'MOVINDD': self.handle_mov_ind_d,
             'MOVINDS': self.handle_mov_ind_s
         })
-        self.event_handlers = []
-
-    def handle_directive(self, directive, value):
-        if directive == 'event_handler':
-            handler, event, conditions = value.split(' ', 2)
-            conds = {}
-            if conditions:
-                for cond in conditions.split(';'):
-                    key, value = cond.split('=', 1)
-                    path = tuple(key.split('.'))
-                    conds[path] = value
-            self.event_handlers.append({
-                'event': event,
-                'conditions': conds,
-                'handler': self.sub_to_func_name(handler)
-            })
-            return
-        super().handle_directive(directive, value)
 
     def handle_ret(self):
         if not self.enable_sync:
@@ -180,9 +162,3 @@ def handle_mov_ind_s(self, src, s_off, dest):
         self.add_command(Function('mem_get'))
         self.add_command(OpAssign(dest, Var('memory_buffer')))
 
-    def write_to_session(self, session):
-        super().write_to_session(session)
-        for event_handler in self.event_handlers:
-            session.add_event_handler(event_handler['event'],
-                                      event_handler['conditions'],
-                                      event_handler['handler'])

compiler/asm_writer.py

@@ -1,25 +1,13 @@
-class AsmWriter:
+from asm_reader import AsmReader
+
+class AsmStringBackend:
 
     def __init__(self):
         self.output = ''
         self.indent = 0
-        self.sub = False
-        self._setup = []
-        self.after_sub = []
 
-    # TODO unused
-    def write_statement(self, stmt):
-        type, *args = stmt
-        if type == 'constant':
-            self.write_constant(*args)
-        elif type == 'subroutine':
-            self.write_subroutine(*args)
-        elif type == 'instruction':
-            self.write_instruction(*args)
-        elif type == 'local_subroutine':
-            self.write_local_sub(*args)
-        elif type == 'directive':
-            self.write_directive(*args)
+    def get_output(self):
+        return self.output
 
     def write_constant(self, name, value):
         self.write_line('.%s %s' % (name, value))
@@ -30,48 +18,168 @@ def write_directive(self, name, value):
     def write_entity_local(self, name):
         self.write_line('@%s' % name)
 
+    def write_local_label(self, label):
+        self.write_line('_%s:' % label)
+
+    def write_label(self, label):
+        self.indent = 0
+        self.write_line('%s:' % label)
+        self.indent = 4
+
+    def write_instruction(self, insn, operands, comment=None):
+        line = '%s%s' % (insn, (' ' + ', '.join(operands)) if operands else '')
+        line = line.replace('\n', '\\n')
+        if comment:
+            line += ' ; ' + comment
+        self.write_line(line)
+
+    def write_raw_asm(self, asm):
+        self.write_line(asm)
+
+    def inject(self, block):
+        self.output += block
+
+    def write_line(self, line):
+        self.output += (' ' * self.indent) + line + '\n'
+
+    def ref_literal(self, number):
+        return '#%d' % number
+
+    def ref_address(self, number):
+        return '%d' % number
+
+    def ref_string(self, string):
+        return '"%s"' % string.replace('\\', '\\\\').replace('"', '\\"')
+
+    def ref_symbol(self, symbol):
+        return str(symbol)
+
+    def ref_raw(self, text):
+        return str(text)
+
+class AsmTokenBackend:
+
+    def __init__(self):
+        self.tokens = []
+        self.asm_reader = AsmReader()
+
+    def get_output(self):
+        return self.tokens
+
+    def add(self, key, value):
+        self.tokens.append((key, value))
+
+    def write_constant(self, name, value):
+        self.add('const', (name, value))
+
+    def write_directive(self, name, value):
+        self.add('directive', (name, value))
+
+    def write_entity_local(self, name):
+        self.add('entity_local', name)
+
+    def write_local_label(self, label):
+        self.add('local_label', label)
+
+    def write_label(self, label):
+        self.add('label', label)
+
+    def write_instruction(self, insn, operands, comment=None):
+        self.add('instruction', (insn, operands))
+
+    def write_raw_asm(self, asm):
+        self.asm_reader.feed(asm)
+        for token in self.asm_reader:
+            self.tokens.append(token)
+
+    def inject(self, block):
+        self.tokens.extend(block)
+
+    def ref_literal(self, number):
+        return ('literal', number)
+
+    def ref_address(self, number):
+        return ('address', number)
+
+    def ref_string(self, string):
+        return ('string', string)
+
+    def ref_symbol(self, symbol):
+        return ('symbol', symbol)
+
+    def ref_raw(self, text):
+        return str(text)
+
+class AsmWriter:
+
+    def __init__(self, backend='string'):
+        self.backend = {
+            'string': AsmStringBackend,
+            'token': AsmTokenBackend
+        }[backend]()
+        self.backend_type = backend
+        self.sub = False
+        self._setup = []
+        self.after_sub = []
+
+    def fork(self):
+        return AsmWriter(self.backend_type)
+
+    def ref_literal(self, number):
+        return self.backend.ref_literal(number)
+
+    def ref_address(self, number):
+        return self.backend.ref_address(number)
+
+    def ref_string(self, string):
+        return self.backend.ref_string(string)
+
+    def ref_symbol(self, symbol):
+        return self.backend.ref_symbol(symbol)
+
+    def ref_raw(self, text):
+        return self.backend.ref_raw(text)
+
+    def write_constant(self, name, value):
+        self.backend.write_constant(name, value)
+
+    def write_directive(self, name, value):
+        self.backend.write_directive(name, value)
+
+    def write_entity_local(self, name):
+        self.backend.write_entity_local(name)
+
     def write_subroutine(self, name):
         if name == '__setup__':
             return
-        self.write_line('%s:' % name)
-        self.indent = 4
         self.sub = True
+        self.backend.write_label(name)
 
     def end_subroutine(self):
-        self.indent = 0
-        self.write_line('')
         self.sub = False
         for after in self.after_sub:
-            self.output += after
+            self.backend.inject(after)
         self.after_sub = []
 
     def write_after_subroutine(self, block):
         self.after_sub.append(block)
 
-    def write_instruction(self, insn, *args, comment=None, raw=False):
-        if raw:
-            line = '%s%s' % (insn, ''.join(args))
+    def write_instruction(self, insn, *args, comment=None):
+        if self.sub:
+            self.backend.write_instruction(insn, args, comment)
         else:
-            line = '%s%s' % (insn, (' ' + ', '.join(args)) if args else  '')
-            line = line.replace('\n', '\\n')
-        if comment:
-            line += ' ; ' + comment
-        if not self.sub:
-            self._setup.append(line)
-        else:
-            self.write_line(line)
+            self._setup.append((insn, args, comment))
 
     def write_local_sub(self, label):
-        self.write_line('_%s:' % label)
+        self.backend.write_local_label(label)
 
-    def write_line(self, line):
-        self.output += (' ' * self.indent) + line + '\n'
+    def write_raw_asm(self, asm):
+        self.backend.write_raw_asm(asm)
 
     def get_output(self):
         assert not self.sub
-        setup = ''
         if self._setup:
-            setup = '__setup__:\n    '
-            setup += '\n    '.join(self._setup)
-            setup += '\n\n'
-        return self.output + setup
+            self.backend.write_label('__setup__')
+            for (insn, args, comment) in self._setup:
+                self.backend.write_instruction(insn, args, comment)
+        return self.backend.get_output()