Add "specific" entity local type. This type of variable holds a value belonging to a specific entity

Author: simon816

asm_reader.py

@@ -113,7 +113,11 @@ def next_constant(self):
 
     def next_entity_local(self):
         name = self.read_symbol()
-        return ('entity_local', name)
+        specific = ''
+        if self.head == ' ':
+            self.read_whitespace()
+            specific = self.read_at_least_once(lambda c: c != '\n', 'non-newline')
+        return ('entity_local', (name, specific))
 
     def next_local_label(self):
         return ('local_label', self.read_label())

assembler.py

@@ -48,24 +48,27 @@ def parse(self, text, 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))
-            elif token == 'entity_local':
-                self.define_entity_local(arg)
-            elif token == 'label':
-                self.handle_label(arg)
-            elif token == 'instruction':
-                if self.curr_func == '__unreachable__':
-                    self.warn("Unreachable code")
-                    continue
-                self.handle_insn(*arg)
-            elif token == 'local_label':
-                self.handle_local_label(arg)
-            elif token == 'directive':
-                self.handle_directive(*arg)
-            elif token == 'eof':
+            if token == 'eof':
                 break
+            self.handle_token(token, arg)
+
+    def handle_token(self, token, arg):
+        if token == 'const':
+            name, ref = arg
+            self.define_const(name, self.resolve_ref(*ref))
+        elif token == 'entity_local':
+            self.define_entity_local(*arg)
+        elif token == 'label':
+            self.handle_label(arg)
+        elif token == 'instruction':
+            if self.curr_func == '__unreachable__':
+                self.warn("Unreachable code")
+                return
+            self.handle_insn(*arg)
+        elif token == 'local_label':
+            self.handle_local_label(arg)
+        elif token == 'directive':
+            self.handle_directive(*arg)
 
     def warn(self, message):
         import warnings
@@ -76,8 +79,8 @@ def define_const(self, name, value):
             raise RuntimeError('Constant %r already defined' % name)
         self.constants[name] = value
 
-    def define_entity_local(self, name):
-        self.define_const(name, EntityLocal(name))
+    def define_entity_local(self, name, specific):
+        self.define_const(name, EntityLocal(name, specific))
 
     def get_const(self, name):
         return self.constants[name]

commands.py

@@ -53,6 +53,10 @@ class Ref(Resolvable):
     def selector(self, where):
         return ETagSelector(where)
 
+    @property
+    def supports_where(self):
+        return True
+
 class Var(Ref):
     def __init__(self, nameref, *args):
         self.name = nameref
@@ -69,13 +73,23 @@ def resolve(self, scope):
         return scope.memory(self.loc)
 
 class EntityLocal(Ref):
-    def __init__(self, name):
+    def __init__(self, name, specific=None):
         self.name = name
+        self.specific = specific
 
     def resolve(self, scope):
         return scope.entity_local(self.name)
 
+    @property
+    def supports_where(self):
+        return not self.specific
+
     def selector(self, where):
+        if self.specific:
+            assert where is None, "Cannot apply selector args to specific " \
+                   + "entity local (%s is specific to %s), tried selector: %s" % (
+                       self.name, self.specific, where)
+            return SimpleResolve(self.specific)
         return Selector('s', where)
 
 class SimpleResolve(Resolvable):
@@ -355,6 +369,8 @@ def __init__(self, varref, value, where=None):
         assert self.allows_negative or value >= 0
         self.var = varref
         self.value = value
+        if where is not None and not varref.supports_where:
+            assert False, "TODO"
         self.selector = varref.selector(where)
 
     def resolve(self, scope):
@@ -396,8 +412,16 @@ def __init__(self, left, right, where=None):
         assert isinstance(right, Ref)
         self.left = left
         self.right = right
-        self.left_sel = left.selector(where)
-        self.right_sel = right.selector(where)
+        where_l = where_r = where
+        if where is not None:
+            if not left.supports_where:
+                where_l = None
+            if not right.supports_where:
+                where_r = None
+            if where_l is None and where_r is None:
+                assert False, "TODO"
+        self.left_sel = left.selector(where_l)
+        self.right_sel = right.selector(where_r)
 
     def resolve(self, scope):
         return 'scoreboard players operation %s %s %s %s %s' % (
@@ -431,6 +455,7 @@ class SelRange(SelectorArgs):
     def __init__(self, varref, min=None, max=None):
         assert min is not None or max is not None
         assert isinstance(varref, Ref)
+        assert varref.supports_where, "TODO"
         self.var = varref
         self.min = min
         self.max = max

compiler/asm_writer.py

@@ -15,15 +15,15 @@ def write_constant(self, name, value):
     def write_directive(self, name, value):
         self.write_line('#%s %s' % (name, value))
 
-    def write_entity_local(self, name):
-        self.write_line('@%s' % name)
+    def write_entity_local(self, name, specific):
+        self.write_line('@%s%s' % (name, ' ' + specific if specific else ''))
 
     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.write_line('\n%s:' % label)
         self.indent = 4
 
     def write_instruction(self, insn, operands, comment=None):
@@ -75,8 +75,8 @@ def write_constant(self, 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_entity_local(self, name, specific):
+        self.add('entity_local', (name, specific))
 
     def write_local_label(self, label):
         self.add('local_label', label)
@@ -146,8 +146,8 @@ def write_constant(self, 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_entity_local(self, name, specific):
+        self.backend.write_entity_local(name, specific)
 
     def write_subroutine(self, name):
         if name == '__setup__':

compiler/compiler.py

@@ -818,10 +818,9 @@ def lookup(self, name):
         return self.current_table.lookup(name)
 
     def declare_symbol(self, name, type, can_redeclare=False):
-        if type is self.compiler.types.types['entity_local']:
+        if type is self.compiler.type('entity_local'):
             # hijack entity_local
             unit = self.entity_local_storage.insert(type)
-            self.compiler.emit(IR.EntityLocalVar(name, unit.offset))
         else:
             unit = self.store(type)
         return self.current_table.declare(name, type, unit,
@@ -1206,15 +1205,26 @@ def visit_decl(self, decl):
             return
         for init in decl.init:
             symbol = self.declare_from_node(decl.type, init.decl)
+            is_entity_local = symbol.type is self.type('entity_local')
             if init.val is not None:
                 if type(init.val) == list:
                     data = self.visit_list_init_data(symbol.type, init.val)
                     loc = self.offset(symbol.storage.store.relative_base,
                                       symbol.storage.offset, symbol.type)
                     self.move_data_array(data, loc)
                 else:
+                    if is_entity_local:
+                        # hijack entity local
+                        val = self.visit_expression(init.val)
+                        assert isinstance(val, IR.LiteralString)
+                        local_name = val.val
+                        self.emit(IR.EntityLocalVar(symbol.name, symbol.storage.offset, local_name))
+                        return
                     self.visit_expression(AssignmentExpr(
                         left=init.decl.name_spec, right=init.val))
+            else:
+                if is_entity_local:
+                        self.emit(IR.EntityLocalVar(symbol.name, symbol.storage.offset, ''))
         else:
             # structs get defined in these functions, make sure it is created
             if isinstance(decl.type, DeclarationSpecifier):

compiler/ir.py

@@ -10,7 +10,7 @@ class IR:
     FunctionEnd = namedtuple('FunctionEnd', '')
 
     Label = namedtuple('Label', 'label')
-    EntityLocalVar = namedtuple('EntityLocalVar', 'name offset')
+    EntityLocalVar = namedtuple('EntityLocalVar', 'name offset specific')
 
     Jump = namedtuple('Jump', 'dest')
     JumpIf = namedtuple('JumpIf', 'dest cond')
@@ -294,19 +294,27 @@ def __init__(self, downstream):
         optimizer = DeadCodeElimination(loop, optimizer)
         super().__init__(optimizer)
         self.loop = loop
-
-    def handle_entity_local(self, insn):
-        # This appears before functions begin, pass straight through
-        self.loop.downstream.handle_insn(insn)
+        self.outside_fn = True
 
     def handle_fn_begin(self, insn):
         self.loop.new_fn()
+        self.outside_fn = False
+        self.emit(insn)
+
+    def handle_fn_end(self, insn):
         self.emit(insn)
+        self.outside_fn = True
 
     def handle_insn(self, insn):
         #print("UPSTREAM", node_debug(insn))
         super().handle_insn(insn)
 
+    def emit(self, insn):
+        if self.outside_fn:
+            self.loop.downstream.handle_insn(insn)
+        else:
+            super().emit(insn)
+
 class OptimizerVisitor(IRVisitor):
 
     def __init__(self, loop, downstream):