Clearer distinction between "internal events" and "internally raised events"

src/sccd/cd/cd.py

@@ -29,22 +29,11 @@ class SingleInstanceCD(AbstractCD):
 
   def print(self):
     print("%d states. %d transitions." % (len(self.statechart.tree.state_list), len(self.statechart.tree.transition_list)))
-    for inport, events in self.statechart.inport_events.items():
-      print("Inport \"%s\" events:" % inport)
-      for event_id in events:
-        print("  %s" % self.globals.events.get_name(event_id))
-    # print()
+    print("Internal events:")
+    for event_id in bm_items(self.statechart.internal_events):
+      print("  %s" % self.globals.events.get_name(event_id))
     for outport in self.globals.outports.names:
       print("Outport \"%s\" events:" % outport)
       for event_name, port in self.statechart.event_outport.items():
         if port == outport:
           print("  %s" % event_name)
-    # print()
-    print("Internal events:")
-    for event_id in bm_items(self.statechart.internal_events):
-      print("  %s" % self.globals.events.get_name(event_id))
-    # print()
-    print("All event triggers:")
-    for event_id in bm_items(self.statechart.events):
-      print("  %s" % self.globals.events.get_name(event_id))
-    # print()

src/sccd/statechart/parser/xml.py

@@ -27,8 +27,8 @@ def statechart_parser_rules(globals, path, load_external = True, parse_f = parse
         semantics=SemanticConfiguration(),
         scope=Scope("instance", parent=BuiltIn),
         datamodel=None,
-        events=Bitmap(),
         internal_events=Bitmap(),
+        internally_raised_events=Bitmap(),
         inport_events={},
         event_outport={},
         tree=None,
@@ -64,8 +64,10 @@ def statechart_parser_rules(globals, path, load_external = True, parse_f = parse
       def parse_event(el):
         event_name = require_attribute(el, "name")
         event_id = globals.events.assign_id(event_name)
-        port_events = statechart.inport_events.setdefault(port_name, set())
-        port_events.add(event_id)
+        port_events = statechart.inport_events.setdefault(port_name, Bitmap())
+        port_events |= bit(event_id)
+        statechart.inport_events[port_name] = port_events
+        statechart.internal_events |= bit(event_id)
       return [("event+", parse_event)]
 
     def parse_outport(el):
@@ -103,7 +105,7 @@ def statechart_parser_rules(globals, path, load_external = True, parse_f = parse
             if port is None:
               # internal event
               event_id = globals.events.assign_id(event_name)
-              statechart.internal_events |= bit(event_id)
+              statechart.internally_raised_events |= bit(event_id)
               return RaiseInternalEvent(event_id=event_id, name=event_name, params=params)
             else:
               # output event - no ID in global namespace
@@ -216,9 +218,10 @@ def statechart_parser_rules(globals, path, load_external = True, parse_f = parse
 
             if not negative_events:
               transition.trigger = Trigger(positive_events)
-              statechart.events |= transition.trigger.enabling_bitmap
+              statechart.internal_events |= transition.trigger.enabling_bitmap
             else:
               transition.trigger = NegatedTrigger(positive_events, negative_events)
+              statechart.internal_events |= transition.trigger.enabling_bitmap
 
           def parse_attr_after(after):
             nonlocal after_id

src/sccd/statechart/static/statechart.py

@@ -94,9 +94,9 @@ class SemanticConfiguration:
 
 @dataclass
 class Statechart(Freezable):
-  __slots__ = ["semantics", "scope", "datamodel", "events", "internal_events", "inport_events", "event_outport", "tree"]
+  __slots__ = ["semantics", "scope", "datamodel", "internal_events", "internally_raised_events", "inport_events", "event_outport", "tree"]
 
-  def __init__(self, semantics: SemanticConfiguration, scope: Scope, datamodel: Optional[Block], events: Bitmap, internal_events: Bitmap, inport_events: Dict[str, Set[int]], event_outport: Dict[str, str], tree: StateTree):
+  def __init__(self, semantics: SemanticConfiguration, scope: Scope, datamodel: Optional[Block], internal_events: Bitmap, internally_raised_events: Bitmap, inport_events: Dict[str, Set[int]], event_outport: Dict[str, str], tree: StateTree):
     
     super().__init__()
   
@@ -109,12 +109,13 @@ class Statechart(Freezable):
     # Block of statements setting up the datamodel (variables in instance scope)
     self.datamodel: Optional[Block] = datamodel
 
-    # The union of all positive event triggers in the statechart.
-    self.events: Bitmap = events
-    # All internally raised events in the statechart, may overlap with input events.
+    # Union of internally raised and input events. Basically all the events that a transition could be triggered by.
     self.internal_events: Bitmap = internal_events
-    # Mapping from inport to set of event IDs
-    self.inport_events: Dict[str, Set[int]] = inport_events
+    # All internally raised events in the statechart, may overlap with input events.
+    self.internally_raised_events: Bitmap = internally_raised_events
+
+    # Mapping from inport to set of event IDs - currently unused
+    self.inport_events: Dict[str, Bitmap] = inport_events
     # Mapping from event name to outport
     self.event_outport: Dict[str, str] = event_outport
 

src/sccd/test/xml.py

@@ -93,8 +93,8 @@ def test_parser_rules(statechart_parser_rules):
             #  All other fields remain the same
             scope=statechart.scope,
             datamodel=statechart.datamodel,
-            events=statechart.events,
             internal_events=statechart.internal_events,
+            internally_raised_events=statechart.internally_raised_events,
             inport_events=statechart.inport_events,
             event_outport=statechart.event_outport,
             tree=statechart.tree)),