Add new datapack features and introduce event handler functions

Author: simon816

compiler/asm_extensions.py

@@ -113,6 +113,24 @@ 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:
@@ -161,3 +179,10 @@ def handle_mov_ind_s(self, src, s_off, dest):
             self.add_command(AddFn(Var('memory_address'), abs(offset)))
         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

@@ -16,10 +16,15 @@ def write_statement(self, stmt):
             self.write_instruction(*args)
         elif type == 'local_subroutine':
             self.write_local_sub(*args)
+        elif type == 'directive':
+            self.write_directive(*args)
 
     def write_constant(self, name, value):
         self.write_line('.%s %s' % (name, value))
 
+    def write_directive(self, name, value):
+        self.write_line('#%s %s' % (name, value))
+
     def write_subroutine(self, name):
         if name == '__setup__':
             return

compiler/compiler.py

@@ -40,6 +40,13 @@ def handle_insn(self, insn):
         self.insn_func_map[type(insn)](insn)
 
     def handle_fn_begin(self, insn):
+        if insn.pragma:
+            if 'event_handler' in insn.pragma:
+                handler = insn.pragma['event_handler']
+                conds = ';'.join(map(
+                    lambda i: '%s=%s' % i, handler['conditions'].items()))
+                self.writer.write_directive('event_handler', '%s %s %s' % (
+                    insn.name, handler['event_name'], conds))
         self.writer.write_subroutine(insn.name)
         self.func_name = insn.name
         self.func_store = insn.storage
@@ -472,6 +479,7 @@ def __init__(self, on_instruction):
         self.current_function = None
         self.loop_attacher = LoopAttacher(None, None, self, None)
         self.python_functions = {}
+        self.pragmas = {}
 
     def import_py_lib(self, lib_exports):
         self.python_functions.update(lib_exports)
@@ -525,6 +533,31 @@ def unique_label(self, label):
         self.local_labels[label] += 1
         return IR.Label('%s_%d' %(label, self.local_labels[label]))
 
+    ### Pragmas
+
+    def visit_pragma(self, pragma):
+        name, args = pragma.val.split(' ', 1)
+        pragmas = {
+            'event_handler': self.visit_pragma_event_handler,
+            'event_condition': self.visit_pragma_event_condition,
+        }
+        assert name in pragmas, "Unknown pragma '%s'" % name
+        pragmas[name](args)
+
+    def visit_pragma_event_handler(self, event_name):
+        assert self.current_function is None, "event_handler must be outside of function"
+        assert 'event_handler' not in self.pragmas, "Multiple event handlers"
+        self.pragmas['event_handler'] = {
+            'event_name': event_name,
+            'conditions': {}
+        }
+
+    def visit_pragma_event_condition(self, condition):
+        assert 'event_handler' in self.pragmas, "Not in event_handler context"
+        key, operator, value = condition.split(' ', 2)
+        assert operator == '=='
+        self.pragmas['event_handler']['conditions'][key] = value
+
     ### Declarations
 
     def get_name_and_type(self, type, spec):
@@ -548,10 +581,16 @@ def visit_func_decl(self, decl):
 
         self.local_labels = {}
 
+        pragma = {}
+        # check pragmas
+        if 'event_handler' in self.pragmas:
+            pragma['event_handler'] = self.pragmas['event_handler']
+            del self.pragmas['event_handler']
+
         # Enter function scope
         with self.scope:
             self.emit(IR.FunctionBegin(func_symbol.name,
-                                       self.scope.current_storage))
+                                       self.scope.current_storage, pragma))
 
             params = decl.decl.name_spec.params
             # Declare parameter symbols
@@ -647,7 +686,8 @@ def read_list_data(self, list_type, init_list, read_next_element):
                 child = mem_ref.child
             index, offset, v_type = read_next_element(list_type, index, mem_ref)
             if child is not None:
-                val = self.visit_list_init_data(v_type, [InitSpec(decl=child, val=init_spec.val)])
+                val = self.visit_list_init_data(v_type,
+                            [InitSpec(decl=child, val=init_spec.val)])
             elif type(init_spec.val) == list:
                 val = self.visit_list_init_data(v_type, init_spec.val)
             else:

compiler/ir.py

@@ -6,7 +6,7 @@ class IR:
 
     _counter = 0
 
-    FunctionBegin = namedtuple('FunctionBegin', 'name storage')
+    FunctionBegin = namedtuple('FunctionBegin', 'name storage pragma')
     FunctionEnd = namedtuple('FunctionEnd', '')
 
     Label = namedtuple('Label', 'label')

compiler/nodes.py

@@ -103,6 +103,8 @@ class Literal(Expression): props = ('val',)
 class IntLiteral(Literal): pass
 class StringLiteral(Literal): pass
 
+class Pragma(Node): props = ('val',)
+
 class Token:
 
     class Type:

compiler/parser_.py

@@ -15,6 +15,13 @@ def parse_program(self):
         return stmts
 
     def parse_external_decl(self):
+        if self.lexer.next.type == Token.Type.IDENTIFIER:
+            if self.lexer.next.val == '_Pragma':
+                self.next()
+                self.read(Token.OPEN_PAREN)
+                pragma = self.parse_string()
+                self.read(Token.CLOSE_PAREN)
+                return Pragma(val=pragma.val)
         # TODO using exceptions is bad
         pos, next = self.lexer.ptr, self.lexer.next
         try:
@@ -616,7 +623,8 @@ def can_next_be_expr(self):
 
     def parse_identifier(self):
         token = self.lexer.next_token()
-        assert token.type == Token.Type.IDENTIFIER
+        assert token.type == Token.Type.IDENTIFIER, \
+               'expected identifier, got %r' % token.val
         return IdentifierExpr(val=token.val)
 
     def parse_number(self):

compiler/preprocessor.py

@@ -1,6 +1,8 @@
 from collections import namedtuple
 from .nodes import *
 
+import re
+
 ConditionalBlock = namedtuple('ConditionalBlock', 'parent source output skip_to_end')
 
 class ParamStr(str):
@@ -94,8 +96,9 @@ def substitute(self, line):
                             start = end
                             line += self.next_line()
                     args.append(ParamStr(s, args, arg_num))
-                    line = line[:idx] + replacement.format(*args) + line[end:]
-                    line = line.replace('##', '') # needs ro be done properly
+                    replaced = replacement.format(*args)
+                    line = line[:idx] + replaced + line[end:]
+                    line = re.sub('\s*##\s*', '', line) # needs ro be done properly
                     # Recursively substitute
                     line = self.substitute(line)
         return line
@@ -116,6 +119,7 @@ def process(self, line):
             'endif': self.handle_endif,
             'define': self.handle_define,
             'undef': self.handle_undef,
+            'pragma': self.handle_pragma,
         }
         func = dir_map.get(directive)
         if func is None:
@@ -188,7 +192,6 @@ def handle_endif(self, arg):
     def handle_define(self, arg):
         if not self.block.output:
             return
-        import re
         match = re.match('(\w+)\s*(\((?:\w+\s*,\s*)*(?:(?:\w+|\.\.\.))\s*\))?(?:\s+|$)(.*)', arg)
         if not match:
             raise Exception('invalid #define "%s"' % arg)
@@ -226,7 +229,6 @@ def _get_params(self, param_match):
     def evaluate(self, expr):
         from .lexer import Lexer
         from .parser_ import Parser
-        import re
         # Convert "defined var" into "__defined__(__no_def_var__)"
         expr = re.sub('defined\s+(\w+)', r'__defined__(__no_def_\1__)', expr)
         expr = Parser(Lexer(self.substitute(expr))).parse_constant_expr()
@@ -294,6 +296,9 @@ def handle_undef(self, arg):
             return
         pass
 
+    def handle_pragma(self, arg):
+        self.append("_Pragma(%s)" % ParamStr(arg, None, None).escape)
+
     def next_line(self):
         line = self.lines[self.lineptr]
         self.lineptr += 1

compiler/visitor.py

@@ -42,8 +42,14 @@ def __init__(self):
 
     def visit_program(self, program):
         for decl in program:
+            if isinstance(decl, Pragma):
+                self.visit_pragma(decl)
+                continue
             self.visit_declaration(decl)
 
+    def visit_pragma(self, pragma):
+        pass
+
     def visit_declaration(self, decl):
         if isinstance(decl, Declaration):
             return self.visit_decl(decl)

compiler_main.py

@@ -1,7 +1,7 @@
 import argparse
 import os
 
-from session import FunctionWriter, DummyWriter
+from datapack import DataPackWriter, DummyWriter
 from placer import Rel
 
 from compiler.asm_extensions import CompilerSession, ExtendedAssembler
@@ -14,6 +14,7 @@
     parser = argparse.ArgumentParser()
     parser.add_argument('file', help="C File", type=argparse.FileType('r'))
     parser.add_argument('--world-dir', help="World Directory")
+    parser.add_argument('--as_zip', action='store_true', help="Write datapack as zip file")
     parser.add_argument('--namespace', help="Function namespace", default='c_generated')
     parser.add_argument('--rem-existing', help="Remove existing functions in namespace",
                         action='store_true')
@@ -52,17 +53,19 @@
     x, y, z = map(parse_pos, args.place_location.split(',', 3))
 
     if args.world_dir:
-        world_dir = os.path.realpath(args.world_dir)
-        writer = FunctionWriter(world_dir, args.namespace)
+        data_dir = os.path.join(os.path.realpath(args.world_dir), 'datapacks')
+        writer = DataPackWriter(data_dir, args.namespace, args.as_zip)
         if args.rem_existing:
-            writer.empty_directory()
+            writer.delete_existing()
     else:
         writer = DummyWriter()
+    writer.open()
 
     session = CompilerSession((x, y, z), writer, args.namespace, stack_size=args.stack,
                       args=sargs, debug=args.debug, page_size=args.page_size)
     assembler.write_to_session(session)
     setup, cleanup = session.create_up_down_functions()
+    writer.close()
     print('Generated', writer.command_count, 'commands in',
           writer.func_count, 'functions')
     print('== Setup command ==')