Refactor instructions into separate files

Author: simon816

cmd_ir/core.py

@@ -5,6 +5,9 @@
 
 from .core_types import FunctionLike, PosUtilEntity
 
+from .variables import (Variable, VarType, ParameterVariable, ReturnVariable,
+                        LocalStackVariable, LocalVariable, NbtOffsetVariable)
+
 class FuncWriter(metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
@@ -229,7 +232,6 @@ def transform_scope(self, func):
         return changed
 
     def reset_var_usage(self):
-        from .variables import Variable
         for var in self.scope.values():
             if isinstance(var, Variable):
                 var.reset_usage()
@@ -250,7 +252,6 @@ def _create_func(self, name):
 
     def create_global(self, namehint, vartype):
         def create(name):
-            from .instructions import DefineGlobal
             return self.preamble.add(DefineGlobal(vartype))
         return self.uniq(namehint, create)
 
@@ -315,7 +316,6 @@ def writeout(self, writer, temp_gen):
 
     def validate_args(self, args, retvars):
         assert self.finished
-        from .variables import Variable, VarType
         if self.params:
             assert args is not None
             assert len(args) == len(self.params)
@@ -345,11 +345,10 @@ def extern_visibility(self):
 
 class ExternFunction(VisibleFunction):
 
-    def __init__(self, global_name):
+    def __init__(self, global_name, params=None, returns=None):
         self._gname = global_name
-        # TODO
-        self.params = []
-        self.returns = []
+        self.params = params or []
+        self.returns = returns or []
 
     @property
     def finished(self):
@@ -373,7 +372,13 @@ def is_empty(self):
         return False
 
     def serialize(self):
-        return 'extern function %s\n' % self._gname
+        def serialize(typelist):
+            if not typelist:
+                return 'NULL'
+            return '(%s)' % ', '.join(t.name for t in typelist)
+        return 'extern function %s %s %s\n' % (self._gname,
+                                               serialize(self.params),
+                                               serialize(self.returns))
 
 class IRFunction(VisibleFunction, VariableHolder):
 
@@ -466,7 +471,6 @@ def create_block(self, namehint):
 
     def create_var(self, namehint, vartype):
         def create(name):
-            from .instructions import DefineVariable
             return self.preamble.add(DefineVariable(vartype))
         return self.uniq(namehint, create)
 
@@ -490,7 +494,6 @@ def writeout(self, writer, temp_gen):
 
     def get_registers(self):
         assert self._varsfinalized
-        from .variables import Variable
         return [var for var in self.scope.values() \
                 if isinstance(var, Variable) and var._direct_ref() \
                 and not var.is_entity_local]
@@ -499,8 +502,6 @@ def is_closed(self):
         return all(b.is_terminated() for b in self.blocks)
 
     def configure_parameters(self, hasownstackframe):
-        from .variables import ParameterVariable, ReturnVariable, \
-                                 LocalStackVariable
         # Linked to InvokeInsn
         offset = 0
         rets = []
@@ -534,8 +535,6 @@ def variables_finalized(self):
         self._varsfinalized = True
 
     def add_entry_exit(self):
-        from .variables import LocalVariable, NbtOffsetVariable
-        from .instructions import PushNewStackFrame, PopStack, Branch
         # sorted from head to tail of stack
         vars = sorted([var.var for var in self.scope.values() \
                 if isinstance(var, LocalVariable) \
@@ -555,7 +554,6 @@ def add_entry_exit(self):
         return vars
 
     def add_advancement_revoke(self, event):
-        from .instructions import RevokeEventAdvancement
         self._entryblock.add(RevokeEventAdvancement(self))
 
     def serialize(self):
@@ -614,7 +612,6 @@ def add(self, insn):
         if not self.force and self.insns and self.insns[-1].terminator():
             assert False, "Block %s is terminated by %s. Tried adding %s" % (
                 self, self.insns[-1], insn)
-        from .instructions import Return, Branch
         if isinstance(insn, Return):
             return super().add(Branch(self._func._exitblock))
         return super().add(insn)
@@ -666,3 +663,9 @@ def is_empty(self):
     def reset(self):
         if self._clear:
             super().reset()
+
+# Load these after everything has been defined - otherwise it is a recursive
+# dependency
+from .instructions import (DefineGlobal, DefineVariable, PushNewStackFrame,
+                           PopStack, Branch, RevokeEventAdvancement, Return,
+                           Branch)

cmd_ir/core_types.py

@@ -1,6 +1,6 @@
 import abc
 
-from commands import *
+import commands as c
 
 class InsnArg:
 
@@ -39,7 +39,7 @@ class EntityLocal(NativeType):
 
     def __init__(self, name):
         self.name = name
-        self.obj_ref = ObjectiveRef(name)
+        self.obj_ref = c.ObjectiveRef(name)
 
 class VirtualString(NativeType):
 
@@ -65,7 +65,7 @@ def __init__(self, name):
         self.player = name
 
     def as_resolve(self):
-        return NameRef(self.player)
+        return c.NameRef(self.player)
 
 class SelectorType(InsnArg):
 
@@ -96,8 +96,7 @@ def _init_from_parser(cls, name):
 SelectorType.NEAREST_PLAYER = SelectorType('p', 1)
 SelectorType.RANDOM_PLAYER = SelectorType('r', 1)
 
-# Name conflict with commands.Selector
-class SelectorTy(EntitySelection):
+class Selector(EntitySelection):
 
     def __new__(cls, type):
         if type.max_limit == 1:
@@ -114,24 +113,24 @@ def set(self, key, value):
         self.simple_args[key] = value
 
     def set_score_range(self, objective, min, max):
-        self.other_args.append(SelRange(objective, min, max))
+        self.other_args.append(c.SelRange(objective, min, max))
 
     def set_nbt(self, path, value):
         parts = path.split('.') if path else []
-        self.other_args.append(SelNbt(parts, value))
+        self.other_args.append(c.SelNbt(parts, value))
 
     @property
     def is_only_one(self):
         return 'limit' in self.simple_args and self.simple_args['limit'] == '1'
 
     def as_resolve(self):
-        args = SimpleSelectorArgs(self.simple_args)
+        args = c.SimpleSelectorArgs(self.simple_args)
         for other in self.other_args:
-            args = ComboSelectorArgs.new(args, other)
-        return Selector(self.type.letter, args)
+            args = c.ComboSelectorArgs.new(args, other)
+        return c.Selector(self.type.letter, args)
 
 # Same as Selector but is also an EntityRef so can be used in more places
-class SingleEntitySelector(SelectorTy, EntityRef):
+class SingleEntitySelector(Selector, EntityRef):
 
     def __new__(cls, type):
         return object.__new__(cls)
@@ -143,7 +142,7 @@ def is_only_one(self):
 class PosUtilEntity(EntityRef):
 
     def as_resolve(self):
-        return PosUtil
+        return c.PosUtil
 
 class Position(NativeType):
 
@@ -158,30 +157,30 @@ def internal(val):
         self._x, self._y, self._z = map(internal, (x, y, z))
 
     def as_blockpos(self):
-        return WorldPos(self._x, self._y, self._z, block_pos=True)
+        return c.WorldPos(self._x, self._y, self._z, block_pos=True)
 
     def as_worldpos(self):
-        return WorldPos(self._x, self._y, self._z)
+        return c.WorldPos(self._x, self._y, self._z)
 
 class RelPosVal(NativeType):
 
     def __init__(self, val):
         self.val = val
-        self.as_coord = WorldRelCoord(val)
+        self.as_coord = c.WorldRelCoord(val)
 
 class AncPosVal(NativeType):
 
     def __init__(self, val):
         self.val = val
-        self.as_coord = AnchorRelCoord(val)
+        self.as_coord = c.AnchorRelCoord(val)
 
 class CmdFunction(NativeType, metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def as_cmd(self):
         pass
 
-class BlockType(Resolvable, NativeType):
+class BlockType(c.Resolvable, NativeType):
 
     def __init__(self, block_id):
         self.block_id = block_id
@@ -200,7 +199,7 @@ def resolve(self, scope):
         nbt = self.nbt.resolve(scope) if self.nbt is not None else ''
         return '%s%s%s' % (self.block_id, '[%s]' % props if props else '', nbt)
 
-class ItemType(Resolvable, NativeType):
+class ItemType(c.Resolvable, NativeType):
 
     def __init__(self, item_id):
         self.item_id = item_id
@@ -216,3 +215,79 @@ def resolve(self, scope):
             nbt = NBTCompound(self.nbt_props.items())
             props = nbt.resolve(scope)
         return '%s%s' % (self.item_id, props)
+
+class TeamRef(NativeType):
+
+    def __init__(self, name):
+        self.name = name
+        self.ref = c.TeamName(name)
+
+class TextColor(InsnArg):
+
+    __lookup = {}
+
+    def __init__(self, name):
+        self.name = name
+        self.__lookup[name] = self
+
+    @classmethod
+    def _init_from_parser(cls, value):
+        return cls.__lookup[value]
+
+    black = None
+    dark_blue = None
+    dark_green = None
+    dark_aqua = None
+    dark_red = None
+    dark_purple = None
+    gold = None
+    gray = None
+    dark_gray = None
+    blue = None
+    green = None
+    aqua = None
+    red = None
+    light_purple = None
+    yellow = None
+    white = None
+    reset = None
+
+TextColor.black = TextColor('black')
+TextColor.dark_blue = TextColor('dark_blue')
+TextColor.dark_green = TextColor('dark_green')
+TextColor.dark_aqua = TextColor('dark_aqua')
+TextColor.dark_red = TextColor('dark_red')
+TextColor.dark_purple = TextColor('dark_purple')
+TextColor.gold = TextColor('gold')
+TextColor.gray = TextColor('gray')
+TextColor.dark_gray = TextColor('dark_gray')
+TextColor.blue = TextColor('blue')
+TextColor.green = TextColor('green')
+TextColor.aqua = TextColor('aqua')
+TextColor.red = TextColor('red')
+TextColor.light_purple = TextColor('light_purple')
+TextColor.yellow = TextColor('yellow')
+TextColor.white = TextColor('white')
+TextColor.reset = TextColor('reset')
+
+class BossbarRef(NativeType):
+
+    def __init__(self, name):
+        self.name = name
+        self.ref = c.Bossbar(name)
+
+PosType = (int, float, RelPosVal, AncPosVal)
+
+def Opt(optype):
+    return (type(None), optype)
+
+class EventRef(NativeType):
+
+    def __init__(self, name):
+        self.name = name
+        self.conditions = {}
+
+    def add_condition(self, path, value):
+        self.conditions[path] = value
+
+RelPosType = (int, float, RelPosVal)

cmd_ir/grammar.lark

@@ -4,7 +4,7 @@ preamble: "preamble" "{" instruction* "}"
 
 ?body: function | extern_func
 
-extern_func: "extern" "function" FUNC_NAME NEWLINE
+extern_func: "extern" "function" FUNC_NAME (typelist|NULL) (typelist|NULL) NEWLINE
 
 function: "function" FUNC_NAME "{" function_body "}"
 
@@ -25,6 +25,7 @@ operand: IDENT | atom | tuple
 
 tuple: "(" atom ["," atom] ")"
 
+typelist: "(" IDENT ["," IDENT] ")"
 
 LABEL: CNAME ":"
 IDENT: CNAME