flaremc 0.2.2__tar.gz → 0.2.3__tar.gz

{flaremc-0.2.2 → flaremc-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flaremc
-Version: 0.2.2
+Version: 0.2.3
 Summary: Flare datapack compiler framework
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{flaremc-0.2.2 → flaremc-0.2.3}/flare/cli.py

@@ -96,6 +96,7 @@ def _build_datapack_inner(file_path: str, cli_overrides: dict = None):
         global_env = {"__name__": "__main__", "__file__": abs_path}
         exec(
             "from flare import _flare_assign, _flare_aug_assign, _flare_if, _flare_while, _flare_for, _flare_with, runcommand, _flare_return, _flare_break, _flare_continue\n"
+            "from flare import context as ctx\n"
             "from flare.command_parser import interpolate_command\n"
             "from flare import _flare_print as print, selector, _as, at, positioned, aligned, facing, anchored, rotated, dimension, applyon, on, summon, store\n"
             "from flare import nbt, score, fixed, tagged, ref, getscore, storage, array, byte, boolean, short, long, double\n"
@@ -153,8 +154,14 @@ def _build_datapack_inner(file_path: str, cli_overrides: dict = None):
         if ":" in filename:
             ns, name = filename.split(":", 1)
             file_p = build_dir / "data" / ns / "functions" / f"{name}.mcfunction"
+            is_top_level = "generated_" not in name and "while_" not in name and name not in ("main", "load")
         else:
             file_p = build_dir / "data" / context._current_namespace / "functions" / f"{filename}.mcfunction"
+            is_top_level = "generated_" not in filename and "while_" not in filename and filename not in ("main",
+                                                                                                          "load")
+
+        if is_top_level and lines and lines[-1] in ("return 1", "return 0"):
+            lines.pop()
 
         file_p.parent.mkdir(parents=True, exist_ok=True)
         with open(file_p, "w") as f:

{flaremc-0.2.2 → flaremc-0.2.3}/flare/command_parser.py

@@ -71,7 +71,7 @@ def interpolate_command(command: str, local_vars: dict, global_vars: dict) -> st
             elif not is_key and ident in local_vars:
                 val = local_vars[ident]
                 if hasattr(val, "addr"):
-                    output.append(val.addr)
+                    output.append(val._addr)
                 elif hasattr(val, "target"):
                     output.append(val.target)
                 elif isinstance(val, dict) and output and output[-1].endswith("**"):
@@ -88,7 +88,7 @@ def interpolate_command(command: str, local_vars: dict, global_vars: dict) -> st
             elif not is_key and ident in global_vars:
                 val = global_vars[ident]
                 if hasattr(val, "addr"):
-                    output.append(val.addr)
+                    output.append(val._addr)
                 elif hasattr(val, "target"):
                     output.append(val.target)
                 elif isinstance(val, dict) and output and output[-1].endswith("**"):

{flaremc-0.2.2 → flaremc-0.2.3}/flare/compiler.py

@@ -29,9 +29,9 @@ def _compile_relational(node, invert=False):
 
     if not isinstance(right, score):
         if isinstance(right, (int, float)):
-            right = getscore(right, left.multiplier)
+            right = getscore(right, left._multiplier)
         else:
-            t = score(addr=f"!c{ctx._temp_id} {temp_obj}", multiplier=left.multiplier)
+            t = score(addr=f"!c{ctx._temp_id} {temp_obj}", multiplier=left._multiplier)
             ctx._temp_id += 1
             if isinstance(right, (BinaryOp, UnaryOp)):
                 right._eval_into(t)
@@ -39,42 +39,42 @@ def _compile_relational(node, invert=False):
                 t.__iset__(right)
             right = t
 
-    if left.multiplier != right.multiplier:
-        t = score(addr=f"!c{ctx._temp_id} {temp_obj}", multiplier=left.multiplier)
+    if left._multiplier != right._multiplier:
+        t = score(addr=f"!c{ctx._temp_id} {temp_obj}", multiplier=left._multiplier)
         ctx._temp_id += 1
         t.__iset__(right)
         right = t
 
-    return f"{keyword} score {left.addr} {mcop} {right.addr}"
+    return f"{keyword} score {left._addr} {mcop} {right._addr}"
 
 
 def _eval_to_bool_score(node):
     dest = score(addr=f"!b{ctx._temp_id} {temp_obj}")
     ctx._temp_id += 1
-    runcommand(f"scoreboard players set {dest.addr} 0")
+    runcommand(f"scoreboard players set {dest._addr} 0")
 
     if isinstance(node, BinaryOp) and node.op == "or":
         left_conds = _flatten_and(node.left)
-        runcommand(f"execute {' '.join(left_conds)} run scoreboard players set {dest.addr} 1")
+        runcommand(f"execute {' '.join(left_conds)} run scoreboard players set {dest._addr} 1")
         right_conds = _flatten_and(node.right)
         runcommand(
-            f"execute if score {dest.addr} matches 0 {' '.join(right_conds)} run scoreboard players set {dest.addr} 1")
+            f"execute if score {dest._addr} matches 0 {' '.join(right_conds)} run scoreboard players set {dest._addr} 1")
         return dest
 
     if isinstance(node, UnaryOp) and node.op == "not":
         sub_dest = _eval_to_bool_score(node.operand)
-        runcommand(f"execute if score {sub_dest.addr} matches 0 run scoreboard players set {dest.addr} 1")
+        runcommand(f"execute if score {sub_dest._addr} matches 0 run scoreboard players set {dest._addr} 1")
         return dest
 
     if isinstance(node, (BinaryOp, UnaryOp)):
         t = score(addr=f"!b{ctx._temp_id} {temp_obj}")
         ctx._temp_id += 1
         node._eval_into(t)
-        runcommand(f"execute unless score {t.addr} matches 0 run scoreboard players set {dest.addr} 1")
+        runcommand(f"execute unless score {t._addr} matches 0 run scoreboard players set {dest._addr} 1")
         return dest
 
     if node:
-        runcommand(f"scoreboard players set {dest.addr} 1")
+        runcommand(f"scoreboard players set {dest._addr} 1")
     return dest
 
 
@@ -84,4 +84,4 @@ def _flatten_and(node, invert=False):
 
     dest = _eval_to_bool_score(node)
     keyword = "unless" if invert else "if"
-    return [f"{keyword} score {dest.addr} matches 1"]
+    return [f"{keyword} score {dest._addr} matches 1"]

{flaremc-0.2.2 → flaremc-0.2.3}/flare/context.py

@@ -8,9 +8,39 @@ current_file = "main"
 _current_namespace = "flare"
 functions = {}
 constants = {}
-constant_obj = "__flare__constant__"
-vars_obj = "__flare__vars__"
-temp_obj = "__flare__temp__"
+
+
+class DynamicVar:
+    def __init__(self, fmt):
+        self.fmt = fmt
+
+    def __str__(self):
+        return self.fmt.format(ns=_current_namespace)
+
+    def __format__(self, format_spec):
+        return format(str(self), format_spec)
+
+    def __add__(self, other):
+        return str(self) + other
+
+    def __radd__(self, other):
+        return other + str(self)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __eq__(self, other):
+        return str(self) == str(other)
+
+
+constant_obj = DynamicVar("__{ns}__constant__")
+vars_obj = DynamicVar("__{ns}__vars__")
+temp_obj = DynamicVar("__{ns}__temp__")
+temp_storage = DynamicVar("{ns}:__flare_temp__")
+vars_storage = DynamicVar("{ns}:__flare_vars__")
+args_storage = DynamicVar("{ns}:__flare_args__")
+returns_storage = DynamicVar("{ns}:__flare_returns__")
+
 _temp_id = 0
 _func_id = 0
 _objective_offset = 0
@@ -138,28 +168,28 @@ def _flare_print(*args):
 
         if isinstance(arg, score):
             if getattr(arg, "multiplier", 1.0) != 1.0:
-                scale_str = f"{arg.multiplier:.15f}".rstrip("0")
+                scale_str = f"{arg._multiplier:.15f}".rstrip("0")
                 if scale_str.endswith("."):
                     scale_str += "0"
                 runcommand(
-                    f"execute store result storage flare:temp __flare_debug_{i} double {scale_str} run scoreboard players get {arg.addr}")
-                components.append({"nbt": f"__flare_debug_{i}", "storage": "flare:temp"})
+                    f"execute store result storage {temp_storage} __flare_debug_{i} double {scale_str} run scoreboard players get {arg._addr}")
+                components.append({"nbt": f"__flare_debug_{i}", "storage": str(temp_storage)})
             else:
-                name, obj = arg.addr.split(" ", 1)
+                name, obj = arg._addr.split(" ", 1)
                 components.append({"score": {"name": name, "objective": obj}})
         elif isinstance(arg, nbt):
-            nbt_comp = {"nbt": arg.path or "{}"}
-            if arg.path == "":
+            nbt_comp = {"nbt": arg._path or "{}"}
+            if arg._path == "":
                 nbt_comp["nbt"] = "{}"
 
-            if arg.target_type == "storage":
-                nbt_comp["storage"] = arg.target
-            elif arg.target_type == "entity":
-                nbt_comp["entity"] = arg.target
-            elif arg.target_type == "block":
-                nbt_comp["block"] = arg.target
+            if arg._target_type == "storage":
+                nbt_comp["storage"] = arg._target
+            elif arg._target_type == "entity":
+                nbt_comp["entity"] = arg._target
+            elif arg._target_type == "block":
+                nbt_comp["block"] = arg._target
 
-            if arg.path == "":
+            if arg._path == "":
                 nbt_comp["nbt"] = "{}"
 
             components.append(nbt_comp)
@@ -178,15 +208,21 @@ def _flare_print(*args):
     runcommand(f"tellraw @a {cmd_text}")
 
 
-def export(func=None, *, append=False):
+def export(func=None, *, name=None, append=False):
     from flare import score  # avoid circular import
+
+    if isinstance(func, str):
+        name = func
+        func = None
+
     if func is None:
         def wrapper(f):
-            return export(f, append=append)
+            return export(f, name=name, append=append)
 
         return wrapper
 
-    func_name = f"{_current_namespace}:{func.__name__}"
+    actual_name = name if name is not None else func.__name__
+    func_name = f"{_current_namespace}:{actual_name}"
     if func_name in files and not append:
         raise ValueError(f"Function {func_name} already exists. Use @export(append=True) to append.")
 
@@ -208,9 +244,9 @@ def export(func=None, *, append=False):
                 kwargs[name] = score(addr=f"{func.__name__}_{name} {vars_obj}")
         elif hasattr(anno, "__name__") and anno.__name__ in ("nbt", "_TypedNBT"):
             if is_recursive:
-                kwargs[name] = anno(addr=f"storage flare:args {func.__name__}_{name}[-1]")
+                kwargs[name] = anno(addr=f"storage {args_storage} {func.__name__}_{name}[-1]")
             else:
-                kwargs[name] = anno(addr=f"storage flare:args {func.__name__}_{name}")
+                kwargs[name] = anno(addr=f"storage {args_storage} {func.__name__}_{name}")
         elif anno is not inspect.Signature.empty:
             raise TypeError(f"Argument '{name}' must be typed as score or nbt, not {anno}")
         else:
@@ -239,20 +275,20 @@ def export(func=None, *, append=False):
                 target = kwargs[arg_name]
 
                 if is_recursive and isinstance(target, nbt):
-                    base_addr = f"storage flare:args {func.__name__}_{arg_name}"
+                    base_addr = f"storage {args_storage} {func.__name__}_{arg_name}"
                     if isinstance(arg_val, (int, float, str)):
                         runcommand(f"data modify {base_addr} append value {json.dumps(arg_val)}")
                     elif isinstance(arg_val, nbt):
-                        runcommand(f"data modify {base_addr} append from {arg_val.addr}")
+                        runcommand(f"data modify {base_addr} append from {arg_val._addr}")
                     elif isinstance(arg_val, score):
                         runcommand(f"data modify {base_addr} append value 0")
                         runcommand(
-                            f"execute store result {base_addr}[-1] int {1 / arg_val.multiplier} run scoreboard players get {arg_val.addr}")
+                            f"execute store result {base_addr}[-1] int {1 / arg_val._multiplier} run scoreboard players get {arg_val._addr}")
                     elif hasattr(type(arg_val), "_eval_into"):
-                        temp = nbt(addr=f"storage flare:temp !t{_temp_id}", datatype=target.type)
+                        temp = nbt(addr=f"storage {temp_storage} !t{_temp_id}", datatype=target._type)
                         _temp_id += 1
                         arg_val._eval_into(temp)
-                        runcommand(f"data modify {base_addr} append from {temp.addr}")
+                        runcommand(f"data modify {base_addr} append from {temp._addr}")
                 else:
                     target.__iset__(arg_val)
 
@@ -261,7 +297,7 @@ def export(func=None, *, append=False):
             if is_recursive:
                 for arg_name in bound.arguments.keys():
                     if isinstance(kwargs[arg_name], nbt):
-                        base_addr = f"storage flare:args {func.__name__}_{arg_name}"
+                        base_addr = f"storage {args_storage} {func.__name__}_{arg_name}"
                         runcommand(f"data remove {base_addr}[-1]")
 
             ret_anno = return_types.get(func_name, sig.return_annotation)
@@ -272,15 +308,15 @@ def export(func=None, *, append=False):
                     temp_ret = score(addr=f"!ret{_temp_id} {temp_obj}")
                     _temp_id += 1
                     runcommand(
-                        f"scoreboard players operation {temp_ret.addr} = {func_name.replace(":", "_")}_ret {vars_obj}")
+                        f"scoreboard players operation {temp_ret._addr} = {func_name.replace(":", "_")}_ret {vars_obj}")
                     if ret_anno.__name__ in ("fixed", "_PrecisionScore"):
                         pass
                     return temp_ret
                 else:
-                    temp_ret = nbt(addr=f"storage flare:temp !ret{_temp_id}")
+                    temp_ret = nbt(addr=f"storage {temp_storage} !ret{_temp_id}")
                     _temp_id += 1
                     runcommand(
-                        f"data modify {temp_ret.addr} set from storage flare:returns {func_name.replace(":", "_")}")
+                        f"data modify {temp_ret._addr} set from storage {returns_storage} {func_name.replace(':', '_')}")
                     return temp_ret
 
     proxy = ProxyFunction()
@@ -402,12 +438,12 @@ def _flare_return(value):
         target.__iset__(value)
     else:
         if inspect.isclass(ret_anno) and issubclass(ret_anno, nbt):
-            target = ret_anno(addr=f"storage flare:returns {func_name.replace(":", "_")}")
+            target = ret_anno(addr=f"storage {returns_storage} {func_name.replace(':', '_')}")
         else:
             datatype = None
             if hasattr(ret_anno, "__origin__") or isinstance(ret_anno, type):
                 datatype = getattr(ret_anno, "__origin__", ret_anno)
-            target = nbt(addr=f"storage flare:returns {func_name.replace(":", "_")}", datatype=datatype)
+            target = nbt(addr=f"storage {returns_storage} {func_name.replace(':', '_')}", datatype=datatype)
         target.__iset__(value)
 
     runcommand("return 1")

{flaremc-0.2.2 → flaremc-0.2.3}/flare/control_flow.py

@@ -1,9 +1,36 @@
 from . import context as ctx
 from .compiler import _flatten_and
 from .context import push_context, runcommand, temp_obj
+from .execute_modifiers import ExecuteChain
 from .variables import score
 
 
+def _has_early_return(func_name):
+    for cmd in ctx.files.get(func_name, []):
+        if cmd == "return 1" or cmd.endswith(" run return 1"):
+            return True
+    return False
+
+
+def _invoke_block(func_name, cond_str):
+    if _has_early_return(func_name):
+        if not (ctx.files[func_name] and ctx.files[func_name][-1] in ("return 0", "return 1")):
+            ctx.files[func_name].append("return 0")
+        ret_temp = score(addr=f"!ret{ctx._temp_id} {ctx.temp_obj}")
+        ctx._temp_id += 1
+
+        if cond_str:
+            runcommand(f"execute store result score {ret_temp._addr} {cond_str} run function {func_name}")
+        else:
+            runcommand(f"execute store result score {ret_temp._addr} run function {func_name}")
+        runcommand(f"execute if score {ret_temp._addr} matches 1 run return 1")
+    else:
+        if cond_str:
+            runcommand(f"execute {cond_str} run function {func_name}")
+        else:
+            runcommand(f"function {func_name}")
+
+
 def _flare_break():
     runcommand(f"scoreboard players set !break {temp_obj} 1")
     runcommand("return 0")
@@ -24,7 +51,7 @@ def _flare_if(*args):
     if has_else_or_elif:
         sometemp = score(addr=f"!elif{ctx._temp_id} {temp_obj}")
         ctx._temp_id += 1
-        runcommand(f"scoreboard players set {sometemp.addr} 0")
+        runcommand(f"scoreboard players set {sometemp._addr} 0")
 
     for cond_func, body_func in zip(conditions, bodies):
         if cond_func is None:
@@ -38,16 +65,11 @@ def _flare_if(*args):
                         cmd = ctx.files[func_name][0]
                         del ctx.files[func_name]
                         if cmd.startswith("execute "):
-                            runcommand(f"execute if score {sometemp.addr} matches 0 {cmd[8:]}")
+                            runcommand(f"execute if score {sometemp._addr} matches 0 {cmd[8:]}")
                         else:
-                            runcommand(f"execute if score {sometemp.addr} matches 0 run {cmd}")
+                            runcommand(f"execute if score {sometemp._addr} matches 0 run {cmd}")
                     else:
-                        ctx.files[func_name].append("return 0")
-                        ret_temp = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
-                        ctx._temp_id += 1
-                        runcommand(
-                            f"execute store result score {ret_temp.addr} if score {sometemp.addr} matches 0 run function {func_name}")
-                        runcommand(f"execute if score {ret_temp.addr} matches 1 run return 1")
+                        _invoke_block(func_name, f"if score {sometemp._addr} matches 0")
             else:
                 body_func()
             break
@@ -67,16 +89,11 @@ def _flare_if(*args):
                             cmd = ctx.files[func_name][0]
                             del ctx.files[func_name]
                             if cmd.startswith("execute "):
-                                runcommand(f"execute if score {sometemp.addr} matches 0 {cmd[8:]}")
+                                runcommand(f"execute if score {sometemp._addr} matches 0 {cmd[8:]}")
                             else:
-                                runcommand(f"execute if score {sometemp.addr} matches 0 run {cmd}")
+                                runcommand(f"execute if score {sometemp._addr} matches 0 run {cmd}")
                         else:
-                            ctx.files[func_name].append("return 0")
-                            ret_temp = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
-                            ctx._temp_id += 1
-                            runcommand(
-                                f"execute store result score {ret_temp.addr} if score {sometemp.addr} matches 0 run function {func_name}")
-                            runcommand(f"execute if score {ret_temp.addr} matches 1 run return 1")
+                            _invoke_block(func_name, f"if score {sometemp._addr} matches 0")
                 else:
                     body_func()
                 break
@@ -85,13 +102,13 @@ def _flare_if(*args):
         prefix = f"execute {' '.join(conds)}"
 
         if sometemp is not None:
-            prefix = f"execute if score {sometemp.addr} matches 0 {' '.join(conds)}"
+            prefix = f"execute if score {sometemp._addr} matches 0 {' '.join(conds)}"
 
         func_name = f"{ctx._current_namespace}:generated_{ctx._func_id}"
         ctx._func_id += 1
         with push_context(func_name):
             if sometemp is not None:
-                runcommand(f"scoreboard players set {sometemp.addr} 1")
+                runcommand(f"scoreboard players set {sometemp._addr} 1")
             body_func()
 
         if ctx.files.get(func_name):
@@ -103,14 +120,7 @@ def _flare_if(*args):
                 else:
                     runcommand(f"{prefix} run {cmd}")
             else:
-                ctx.files[func_name].append("return 0")
-                ret_temp = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
-                ctx._temp_id += 1
-                if prefix.startswith("execute "):
-                    runcommand(f"execute store result score {ret_temp.addr} {prefix[8:]} run function {func_name}")
-                else:
-                    runcommand(f"execute store result score {ret_temp.addr} run function {func_name}")
-                runcommand(f"execute if score {ret_temp.addr} matches 1 run return 1")
+                _invoke_block(func_name, prefix[8:] if prefix.startswith("execute ") else "")
 
 
 def _flare_while(cond_func, body_func, orelse_func=None, has_break=False, has_continue=False):
@@ -124,10 +134,7 @@ def _flare_while(cond_func, body_func, orelse_func=None, has_break=False, has_co
             with push_context(func_body):
                 body_func()
 
-            ret_body = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
-            ctx._temp_id += 1
-            runcommand(f"execute store result score {ret_body.addr} run function {func_body}")
-            runcommand(f"execute if score {ret_body.addr} matches 1 run return 1")
+            _invoke_block(func_body, "")
 
             if has_break:
                 runcommand(f"execute if score !break {temp_obj} matches 1 run return 0")
@@ -137,11 +144,7 @@ def _flare_while(cond_func, body_func, orelse_func=None, has_break=False, has_co
         cond = cond_func()
         conds = _flatten_and(cond)
         prefix = f"execute {' '.join(conds)}"
-        ctx.files[func_name].append("return 0")
-        ret_temp = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
-        ctx._temp_id += 1
-        runcommand(f"execute store result score {ret_temp.addr} {' '.join(conds)} run function {func_name}")
-        runcommand(f"execute if score {ret_temp.addr} matches 1 run return 1")
+        _invoke_block(func_name, " ".join(conds))
 
     if has_break:
         runcommand(f"scoreboard players set !break {temp_obj} 0")
@@ -151,8 +154,8 @@ def _flare_while(cond_func, body_func, orelse_func=None, has_break=False, has_co
     prefix_init = f"execute {' '.join(conds_init)}"
     ret_temp_init = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
     ctx._temp_id += 1
-    runcommand(f"execute store result score {ret_temp_init.addr} {' '.join(conds_init)} run function {func_name}")
-    runcommand(f"execute if score {ret_temp_init.addr} matches 1 run return 1")
+    runcommand(f"execute store result score {ret_temp_init._addr} {' '.join(conds_init)} run function {func_name}")
+    runcommand(f"execute if score {ret_temp_init._addr} matches 1 run return 1")
 
     if orelse_func:
         if has_break:
@@ -185,7 +188,6 @@ def _flare_with(*args):
             if hasattr(obj, "__with__"):
                 obj.__with__(lambda: wrap(idx + 1))
             elif isinstance(obj, str):
-                from .execute_modifiers import ExecuteChain
                 ExecuteChain(obj).__with__(lambda: wrap(idx + 1))
             else:
                 raise TypeError(f"Object of type {type(obj).__name__} does not support __with__")

{flaremc-0.2.2 → flaremc-0.2.3}/flare/execute_modifiers.py

@@ -64,7 +64,7 @@ class ExecuteChain:
     def store(self, target: Union[score, nbt, str]) -> ExecuteChain:
         if isinstance(target, score):
             target._check_addr()
-            return self._add(f"store result score {target.addr}")
+            return self._add(f"store result score {target._addr}")
         elif isinstance(target, nbt):
             target._check_addr()
             return StoreExecuteChain(self.fragments.copy(), target)
@@ -101,23 +101,23 @@ class ExecuteChain:
                 ret_temp = score(addr=f"!ret{ctx._temp_id} {ctx.temp_obj}")
                 ctx._temp_id += 1
                 if prefix.startswith("execute "):
-                    ctx.runcommand(f"execute store result score {ret_temp.addr} {prefix[8:]} run function {func_name}")
+                    ctx.runcommand(f"execute store result score {ret_temp._addr} {prefix[8:]} run function {func_name}")
                 else:
-                    ctx.runcommand(f"execute store result score {ret_temp.addr} run function {func_name}")
-                ctx.runcommand(f"execute if score {ret_temp.addr} matches 1 run return 1")
+                    ctx.runcommand(f"execute store result score {ret_temp._addr} run function {func_name}")
+                ctx.runcommand(f"execute if score {ret_temp._addr} matches 1 run return 1")
 
 
 class StoreExecuteChain(ExecuteChain):
     def __init__(self, fragments: list[str], target: nbt):
         super().__init__("")
         self.fragments = fragments
-        self.target = target
-        self._datatype = target.type.name.lower() if target.type else "double"
+        self._target = target
+        self._datatype = target._type.name.lower() if target._type else "double"
         self._multiplier = 1.0
         self._update_frag()
 
     def _update_frag(self):
-        frag = f"store result storage {self.target.target} {self.target.path} {self._datatype} {self._multiplier}"
+        frag = f"store result storage {self._target.target} {self._target.path} {self._datatype} {self._multiplier}"
         if self.fragments and self.fragments[-1].startswith("store result "):
             self.fragments[-1] = frag
         else:

{flaremc-0.2.2 → flaremc-0.2.3}/flare/preprocessor.py

@@ -59,7 +59,28 @@ class FlareTransformer(ast.NodeTransformer):
         self.counter += 1
         return f"__flare_{self.counter}"
 
+    def visit_FunctionDef(self, node):
+        is_exported = any(
+            isinstance(dec, ast.Name) and dec.id in ("export", "macro") or isinstance(dec, ast.Call) and getattr(
+                dec.func, "id", "") in ("export", "macro") for dec in node.decorator_list)
+
+        is_generated = node.name.startswith("__flare_")
+        prev_in_flare = getattr(self, "in_flare_func", False)
+
+        if is_exported or is_generated:
+            self.in_flare_func = True
+        else:
+            self.in_flare_func = False
+
+        self.generic_visit(node)
+        self.in_flare_func = prev_in_flare
+        return node
+
     def visit_If(self, node):
+        if not getattr(self, "in_flare_func", False):
+            self.generic_visit(node)
+            return node
+
         funcs = []
         cond_args = []
         body_args = []
@@ -106,11 +127,15 @@ class FlareTransformer(ast.NodeTransformer):
         return funcs
 
     def visit_Break(self, node):
+        if not getattr(self, "in_flare_func", False):
+            return node
         call_expr = ast.Expr(value=ast.Call(func=ast.Name(id="_flare_break", ctx=ast.Load()), args=[], keywords=[]))
         ast.copy_location(call_expr, node)
         return call_expr
 
     def visit_Continue(self, node):
+        if not getattr(self, "in_flare_func", False):
+            return node
         call_expr = ast.Expr(value=ast.Call(func=ast.Name(id="_flare_continue", ctx=ast.Load()), args=[], keywords=[]))
         ast.copy_location(call_expr, node)
         return call_expr
@@ -120,6 +145,10 @@ class FlareTransformer(ast.NodeTransformer):
         return node
 
     def visit_While(self, node):
+        if not getattr(self, "in_flare_func", False):
+            self.generic_visit(node)
+            return node
+
         class BreakContinueVisitor(ast.NodeVisitor):
             def __init__(self):
                 self.has_break = False
@@ -184,6 +213,10 @@ class FlareTransformer(ast.NodeTransformer):
         return funcs
 
     def visit_For(self, node):
+        if not getattr(self, "in_flare_func", False):
+            self.generic_visit(node)
+            return node
+
         class BreakContinueVisitor(ast.NodeVisitor):
             def __init__(self):
                 self.has_break = False
@@ -286,20 +319,28 @@ class FlareTransformer(ast.NodeTransformer):
         return node
 
     def visit_Return(self, node):
+        if not getattr(self, "in_flare_func", False):
+            self.generic_visit(node)
+            return node
+
         self.generic_visit(node)
 
         value = node.value if node.value is not None else ast.Constant(value=None)
 
-        call_expr = ast.Expr(
-            value=ast.Call(func=ast.Name(id="_flare_return", ctx=ast.Load()), args=[value], keywords=[]))
-        ast.copy_location(call_expr, node)
-
-        new_return = ast.Return(value=None)
-        ast.copy_location(new_return, node)
+        if_node = ast.If(test=ast.Compare(
+            left=ast.Attribute(value=ast.Name(id="ctx", ctx=ast.Load()), attr="current_file", ctx=ast.Load()),
+            ops=[ast.IsNot()], comparators=[ast.Constant(value=None)]), body=[
+            ast.Expr(value=ast.Call(func=ast.Name(id="_flare_return", ctx=ast.Load()), args=[value], keywords=[])),
+            ast.Return(value=None)], orelse=[ast.Return(value=value)])
+        ast.copy_location(if_node, node)
 
-        return [call_expr, new_return]
+        return if_node
 
     def visit_With(self, node):
+        if not getattr(self, "in_flare_func", False):
+            self.generic_visit(node)
+            return node
+
         self.generic_visit(node)
 
         name_body = self.gen_name()
@@ -414,6 +455,10 @@ def preprocess_minecraft_commands(source: str) -> str:
 
         match = COMMAND_RE.match(line)
         if match:
+            if re.match(r"^\s*(?:" + COMMAND_KEYWORDS + r")\s*(?:[+\-*/%&|^]?=|\()", line):
+                i += 1
+                continue
+
             indent = match.group(1)
             cmd = match.group(2) + match.group(3)
             if cmd.startswith("/"):