Constants are now tracked in globals

Author: willgebhardt

ngcsimlib/_src/parser/contextTransformer.py

@@ -16,6 +16,7 @@ def __init__(self, obj, method, subMethod=False):
         self.needed_keys = set()
         self.needed_methods = {}
         self.subMethod = subMethod
+        self.needed_globals = {}
 
     def visit_Return(self, node):
         if self.subMethod:
@@ -73,9 +74,15 @@ def visit_Attribute(self, node):
 
                 return ast.fix_missing_locations(new_node)
 
-            method_name = f"{self.obj.name}_{node.attr}"
-            new_node = ast.copy_location(ast.Name(id=method_name, ctx=node.ctx), node)
-            self.needed_methods[method_name] = node.attr
+            if callable(stateVal):
+                method_name = f"{self.obj.name}_{node.attr}"
+                new_node = ast.copy_location(ast.Name(id=method_name, ctx=node.ctx), node)
+                self.needed_methods[method_name] = node.attr
+                return ast.fix_missing_locations(new_node)
+
+            attr_name = f"{self.obj.name}_{node.attr}"
+            new_node = ast.copy_location(ast.Name(id=attr_name, ctx=node.ctx), node)
+            self.needed_globals[attr_name] = stateVal
             return ast.fix_missing_locations(new_node)
 
         return node
@@ -90,6 +97,19 @@ def visit_Call(self, node):
 
         return node
 
+    # def visit_Assign(self, node):
+    #     for target in node.targets:
+    #         if isinstance(target, ast.Name):
+    #             target.id = f"{self.obj.name}_{target.id}"
+    #             self.local_vars.add(target.id)
+    #     return self.generic_visit(node)
+    #
+    #
+    # def visit_Name(self, node):
+    #     # if node.id in self.local_vars:
+    #     #     node.id = f"{self.obj.name}_{node.id}"
+    #     return node
+
     def visit_Expr(self, node):
         node = self.generic_visit(node)
         if isinstance(node.value, ast.Call):
@@ -163,7 +183,7 @@ def visit_If(self, node):
         try:
             value = eval(compiled, {}, {"self": self.obj})
         except Exception as e:
-            raise RuntimeError("Can not evaluate conditional")
+            raise RuntimeError(f"On {self.obj.name}:{self.method.__name__} can not evaluate conditional\n{ast.unparse(node)}")
 
         case = (node.body if value else node.orelse)
         new_body = []

ngcsimlib/_src/parser/utils.py

@@ -96,8 +96,9 @@ def parse_method(obj, method):
             values need to be pulled from the global state)
         method: The method to compile
     """
-    transformer, transformed, extra_namespace, auxiliary_ast = _sub_parse(obj, method)
+    transformer, transformed, extra_namespace, auxiliary_ast, extra_globals = _sub_parse(obj, method)
     namespace = method.__globals__.copy()
+    namespace.update(extra_globals)
     for method_name, module in extra_namespace.items():
         code = compile(module, filename=f"{method_name}_compiled", mode='exec')
         exec(code, namespace)
@@ -112,15 +113,18 @@ def _sub_parse(obj, method, sub=False):
     transformed = transformer.visit(tree)
     ast.fix_missing_locations(transformed)
 
+    extra_globals = transformer.needed_globals.copy()
     auxiliary_ast = []
     extra_namespace = {}
+
     for bound_name, method_name in transformer.needed_methods.items():
-        _, method, e, m = _sub_parse(obj, getattr(obj, method_name), sub=True)
+        _, method, e, m, g = _sub_parse(obj, getattr(obj, method_name), sub=True)
         extra_namespace[bound_name] = method
         extra_namespace.update(e)
+        extra_globals.update(g)
         auxiliary_ast.append(method)
         auxiliary_ast.extend(m)
-    return transformer, transformed, extra_namespace, auxiliary_ast
+    return transformer, transformed, extra_namespace, auxiliary_ast, extra_globals
 
 
 def compileObject(obj):