Rename class 'Context' to 'Globals'

src/sccd/controller/controller.py

@@ -32,8 +32,8 @@ class Controller:
         self.simulated_time = 0 # integer
         self.initialized = False
 
-        self.model.context.assert_ready()
-        print_debug("model delta is %s" % str(self.model.context.delta))
+        self.model.globals.assert_ready()
+        print_debug("model delta is %s" % str(self.model.globals.delta))
 
     # time_offset: the offset relative to the current simulated time
     # (the timestamp given in the last call to run_until)
@@ -41,12 +41,12 @@ class Controller:
             if input.name == "":
                 raise Exception("Input event can't have an empty name.")
         
-            if input.port not in self.model.context.inports:
+            if input.port not in self.model.globals.inports:
                 raise Exception("No such port: '" + input.port + "'")
 
 
             e = Event(
-                id=self.model.context.get_event_id(input.name),
+                id=self.model.globals.get_event_id(input.name),
                 name=input.name,
                 port=input.port,
                 parameters=input.parameters)
@@ -63,7 +63,7 @@ class Controller:
 
     # Returns duration since start
     def get_simulated_duration(self) -> Duration:
-        return (self.model.context.delta * self.simulated_time).normalize()
+        return (self.model.globals.delta * self.simulated_time).normalize()
 
     # Run until the event queue has no more due events wrt given timestamp and until all instances are stable.
     # If no timestamp is given (now = None), run until event queue is empty.
@@ -140,7 +140,7 @@ class Controller:
                 # run all instances for whom there are events
                 for instance in entry.targets:
                     stable, output = instance.big_step(timestamp, [entry.event])
-                    # print_debug("completed big step (time = %s)" % str(self.model.context.delta * self.simulated_time))
+                    # print_debug("completed big step (time = %s)" % str(self.model.globals.delta * self.simulated_time))
                     process_big_step_output(output)
                     if not stable:
                         unstable.append(instance)

src/sccd/legacy/xml_loader.py

@@ -39,7 +39,7 @@ def load_model(src_file) -> Tuple[MultiInstanceModel, Optional[Test]]:
     default = c.get("default", "")
 
     scxml_node = c.find("scxml", root.nsmap)
-    statechart = load_statechart(scxml_node, model.context)
+    statechart = load_statechart(scxml_node, model.globals)
 
     model.classes[class_name] = statechart
     if default or len(classes) == 1:

src/sccd/model/expression_parser.py

@@ -2,7 +2,7 @@ import os
 from lark import Lark, Transformer
 import sccd.schema
 from sccd.syntax.statement import *
-from sccd.model.context import *
+from sccd.model.globals import *
 
 _schema_dir = os.path.dirname(sccd.schema.__file__)
 
@@ -17,7 +17,7 @@ with open(os.path.join(_schema_dir,"state_ref.g")) as file:
 class _ExpressionTransformer(Transformer):
   def __init__(self):
     super().__init__()
-    self.context: Context = None
+    self.globals: Globals = None
     self.datamodel: DataModel = None
 
   array = Array
@@ -71,7 +71,7 @@ class _ExpressionTransformer(Transformer):
       "h": Hour
     }[node[0].children[1]]
     d = DurationLiteral(Duration(int(node[0].children[0]),unit))
-    self.context.durations.append(d)
+    self.globals.durations.append(d)
     return d
 
 # Global variables so we don't have to rebuild our parser every time
@@ -82,13 +82,13 @@ _state_ref_parser = Lark(_state_ref_grammar, parser="lalr", start=["state_ref"])
 
 # Exported functions:
 
-def parse_expression(context: Context, datamodel, expr: str) -> Expression:
-  _transformer.context = context
+def parse_expression(globals: Globals, datamodel, expr: str) -> Expression:
+  _transformer.globals = globals
   _transformer.datamodel = datamodel
   return _expr_parser.parse(expr, start="expr")
 
-def parse_block(context: Context, datamodel, block: str) -> Statement:
-  _transformer.context = context
+def parse_block(globals: Globals, datamodel, block: str) -> Statement:
+  _transformer.globals = globals
   _transformer.datamodel = datamodel
   return _expr_parser.parse(block, start="block")
 

src/sccd/model/context.py

@@ -5,7 +5,7 @@ from sccd.util.namespace import *
 from sccd.util.duration import *
 
 # @dataclass
-class Context:
+class Globals:
   # max_delta: upper bound on model delta
   def __init__(self, fixed_delta: Optional[Duration] = Duration(100, Microsecond)):
     self.fixed_delta = fixed_delta
@@ -41,4 +41,4 @@ class Context:
 
   def assert_ready(self):
     if self.delta is None:
-      raise Exception("Context not ready: durations not yet processed.")
+      raise Exception("Globals not ready: durations not yet processed.")

src/sccd/model/model.py

@@ -2,11 +2,11 @@ from abc import *
 from dataclasses import *
 from typing import *
 from sccd.syntax.statechart import *
-from sccd.model.context import *
+from sccd.model.globals import *
 
 @dataclass
 class AbstractModel(ABC):
-  context: Context
+  globals: Globals
 
   @abstractmethod
   def get_default_class(self) -> Statechart:

src/sccd/model/statechart_parser.py

@@ -104,30 +104,30 @@ class ActionParser(XmlParser):
 
   def __init__(self):
     super().__init__()
-    self.context = XmlParser.Context("context")
+    self.globals = XmlParser.Context("globals")
     self.datamodel = XmlParser.Context("datamodel")
     self.actions = XmlParser.Context("actions")
 
   def end_raise(self, el):
-    context = self.context.require()
+    globals = self.globals.require()
     actions = self.actions.require()
 
     name = el.get("event")
     port = el.get("port")
     if not port:
-      event_id = context.events.assign_id(name)
+      event_id = globals.events.assign_id(name)
       a = RaiseInternalEvent(name=name, parameters=[], event_id=event_id)
     else:
-      context.outports.assign_id(port)
+      globals.outports.assign_id(port)
       a = RaiseOutputEvent(name=name, parameters=[], outport=port, time_offset=0)
     actions.append(a)
 
   def end_code(self, el):
-    context = self.context.require()
+    globals = self.globals.require()
     datamodel = self.datamodel.require()
     actions = self.actions.require()
 
-    block = parse_block(context, datamodel, block=el.text)
+    block = parse_block(globals, datamodel, block=el.text)
     a = Code(block)
     actions.append(a)
 
@@ -256,12 +256,12 @@ class StatechartParser(StateParser):
   # <datamodel>
 
   def end_var(self, el):
-    context = self.context.require()
+    globals = self.globals.require()
     datamodel = self.datamodel.require()
 
     id = el.get("id")
     expr = el.get("expr")
-    parsed = parse_expression(context, datamodel, expr=expr)
+    parsed = parse_expression(globals, datamodel, expr=expr)
     datamodel.create(id, parsed.eval([], datamodel))
 
   def start_datamodel(self, el):
@@ -281,7 +281,7 @@ class StatechartParser(StateParser):
 
   def end_tree(self, el):
     statechart = self.statechart.require()
-    context = self.context.require()
+    globals = self.globals.require()
     datamodel = self.datamodel.pop()
 
     root_states = self.state_children.pop()
@@ -329,14 +329,14 @@ class StatechartParser(StateParser):
 
       # Trigger
       if after is not None:
-        after_expr = parse_expression(context, datamodel, expr=after)
+        after_expr = parse_expression(globals, datamodel, expr=after)
         # print(after_expr)
         event = "_after%d" % next_after_id # transition gets unique event name
         next_after_id += 1
-        trigger = AfterTrigger(context.events.assign_id(event), event, after_expr)
+        trigger = AfterTrigger(globals.events.assign_id(event), event, after_expr)
       elif event is not None:
-        trigger = Trigger(context.events.assign_id(event), event, port)
-        context.inports.assign_id(port)
+        trigger = Trigger(globals.events.assign_id(event), event, port)
+        globals.inports.assign_id(port)
       else:
         trigger = None
       transition.trigger = trigger
@@ -345,7 +345,7 @@ class StatechartParser(StateParser):
       # Guard
       if cond is not None:
         try:
-          expr = parse_expression(context, datamodel, expr=cond)
+          expr = parse_expression(globals, datamodel, expr=cond)
         except Exception as e:
           self._raise(t_el, "Condition '%s': %s" % (cond, str(e)))
         transition.guard = expr

src/sccd/test/test_parser.py

@@ -9,7 +9,7 @@ class TestParser(StatechartParser):
   def __init__(self):
     super().__init__()
     self.tests = XmlParser.Context("tests")
-    self.context = XmlParser.Context("context")
+    self.globals = XmlParser.Context("globals")
     self.test_input = XmlParser.Context("test_input")
     self.test_output = XmlParser.Context("test_output")
     self.big_step = XmlParser.Context("big_step")
@@ -42,7 +42,7 @@ class TestParser(StatechartParser):
     pass
 
   def start_test(self, el):
-    self.context.push(Context(fixed_delta = None))
+    self.globals.push(Globals(fixed_delta = None))
     self.test_input.push([])
     self.test_output.push([])
     self.statecharts.push([])
@@ -54,13 +54,13 @@ class TestParser(StatechartParser):
     statecharts = self.statecharts.pop()
     input = self.test_input.pop()
     output = self.test_output.pop()
-    context = self.context.pop()
+    globals = self.globals.pop()
 
     if len(statecharts) != 1:
       raise Exception("Expected exactly 1 <statechart> node, got %d." % len(statecharts))
     statechart = statecharts[0]
 
-    context.process_durations()
+    globals.process_durations()
 
     def variant_description(i, variant) -> str:
       if not variant:
@@ -72,7 +72,7 @@ class TestParser(StatechartParser):
       Test(
         name=src_file + variant_description(i, variant),
         model=SingleInstanceModel(
-          context,
+          globals,
           Statechart(tree=statechart.tree, datamodel=deepcopy(statechart.datamodel), semantics=dataclasses.replace(statechart.semantics, **variant))),
         input=input,
         output=output)

test/render.py

@@ -39,7 +39,7 @@ if __name__ == '__main__':
       tree_node = statechart_node.find(".//tree")
       if tree_node is None:
         return # no tree here :(
-      tree = load_tree(Context(), tree_node)
+      tree = load_tree(Globals(), tree_node)
 
       target_path = lambda ext: os.path.join(args.output_dir, dropext(src)+ext)
       smcat_target = target_path('.smcat')