Statemachine check

compiler/lib/src/main/scala/analysis/Analyzers/UseAnalyzer.scala

@@ -24,6 +24,9 @@ trait UseAnalyzer extends TypeExpressionAnalyzer {
   /** A use of a type definition */
   def typeUse(a: Analysis, node: AstNode[Ast.TypeName], use: Name.Qualified): Result = default(a)
 
+  /** A use of a state machine definition*/
+  def stateMachineUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified): Result = default(a)
+
   override def defComponentInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.DefComponentInstance]]) = {
     val (_, node1, _) = node
     val data = node1.data
@@ -62,6 +65,13 @@ trait UseAnalyzer extends TypeExpressionAnalyzer {
     qualIdentNode (componentInstanceUse) (a, data.instance)
   }
 
+  override def specStateMachineInstanceAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecStateMachineInstance]]) = {
+    val (_, node1, _) = node
+    val data = node1.data
+    qualIdentNode(stateMachineUse)(a, data.stateMachine)
+  }
+
+
   override def specConnectionGraphAnnotatedNode(
     a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecConnectionGraph]]) = {
     def connection(a: Analysis, connection: Ast.SpecConnectionGraph.Connection): Result = {

compiler/lib/src/main/scala/analysis/CheckSemantics/CheckComponentDefs.scala

@@ -127,6 +127,17 @@ object CheckComponentDefs
     yield a.copy(component = Some(component))
   }
 
+  override def specStateMachineInstanceAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecStateMachineInstance]]
+  ): Result.Result[Analysis] = {
+    for {
+      stateMachineInstance <- StateMachineInstance.fromSpecStateMachine(a, aNode)
+      component <- a.component.get.addStateMachineInstance(stateMachineInstance)
+    } yield a.copy(component = Some(component))
+  }
+
+
   override def specTlmChannelAnnotatedNode(
     a: Analysis,
     aNode: Ast.Annotated[AstNode[Ast.SpecTlmChannel]]

compiler/lib/src/main/scala/analysis/CheckSemantics/CheckUses.scala

@@ -12,6 +12,9 @@ object CheckUses extends UseAnalyzer {
   override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) =
     visitQualIdentNode (NameGroup.Component) (a, node)
 
+  override def stateMachineUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) =
+    visitQualIdentNode (NameGroup.StateMachine) (a, node)
+
   override def constantUse(a: Analysis, node: AstNode[Ast.Expr], use: Name.Qualified) = {
     def visitExprNode(a: Analysis, node: AstNode[Ast.Expr]): Result = {
       def visitExprIdent(a: Analysis, node: AstNode[Ast.Expr], name: Name.Unqualified) = {

compiler/lib/src/main/scala/analysis/CheckSemantics/EnterSymbols.scala

@@ -49,6 +49,7 @@ object EnterSymbols
     val symbol = Symbol.Component(aNode)
     for {
       nestedScope <- a.nestedScope.put(NameGroup.Component)(name, symbol)
+      nestedScope <- nestedScope.put(NameGroup.StateMachine)(name, symbol)
       nestedScope <- nestedScope.put(NameGroup.Type)(name, symbol)
       nestedScope <- nestedScope.put(NameGroup.Value)(name, symbol)
       a <- {
@@ -217,6 +218,19 @@ object EnterSymbols
       yield updateMap(a, symbol).copy(nestedScope = nestedScope)
   }
 
+  override def defStateMachineAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.DefStateMachine]]
+  ) = { 
+    val (_, node, _) = aNode
+    val data = node.data
+    val name = data.name
+    val symbol = Symbol.StateMachine(aNode)
+    val nestedScope = a.nestedScope
+    for (nestedScope <- nestedScope.put(NameGroup.StateMachine)(name, symbol))
+      yield updateMap(a, symbol).copy(nestedScope = nestedScope)
+  }
+
   override def defStructAnnotatedNode(
     a: Analysis,
     aNode: Ast.Annotated[AstNode[Ast.DefStruct]]

compiler/lib/src/main/scala/analysis/ComputeDependencies/MapUsesToLocs.scala

@@ -11,6 +11,9 @@ object MapUsesToLocs extends UseAnalyzer {
   override def componentInstanceUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) =
     analyzeUse(a, Ast.SpecLoc.ComponentInstance, use)
 
+  override def stateMachineUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) =
+    analyzeUse(a, Ast.SpecLoc.StateMachine, use)
+
   override def componentUse(a: Analysis, node: AstNode[Ast.QualIdent], use: Name.Qualified) =
     analyzeUse(a, Ast.SpecLoc.Component, use)
 

compiler/lib/src/main/scala/analysis/Semantics/Component.scala

@@ -27,6 +27,8 @@ case class Component(
   paramMap: Map[Param.Id, Param] = Map(),
   /** The list of port matching specifiers */
   specPortMatchingList: List[Ast.Annotated[AstNode[Ast.SpecPortMatching]]] = Nil,
+  /** The map from state machine instance names to state machine instances */
+  stateMachineInstanceMap: Map[Name.Unqualified, StateMachineInstance] = Map(),
   /** The list of port matching constraints */
   portMatchingList: List[Component.PortMatching] = Nil,
   /** The next default parameter ID */
@@ -113,6 +115,33 @@ case class Component(
     }
     yield c
 
+
+  def addStateMachineInstance(instance: StateMachineInstance): Result.Result[Component] =
+    for {
+      c <- updateStateMachineInstanceMap(instance)
+      c <- instance match {
+        case _ => Right(c)
+      }
+    }
+    yield c
+
+
+  /** Add a port instance to the port map */
+  private def updateStateMachineInstanceMap(instance: StateMachineInstance):
+  Result.Result[Component] = {
+    val name = instance.getUnqualifiedName
+    stateMachineInstanceMap.get(name) match {
+      case Some(prevInstance) =>
+        val loc = instance.getLoc
+        val prevLoc = prevInstance.getLoc
+        Left(SemanticError.DuplicateStateMachineInstance(name, loc, prevLoc))
+      case None => 
+        val stateMachineInstanceMap = this.stateMachineInstanceMap + (name -> instance)
+        val component = this.copy(stateMachineInstanceMap = stateMachineInstanceMap)
+        Right(component)
+    }
+  }
+
   /** Add a port instance to the port map */
   private def updatePortMap(instance: PortInstance):
   Result.Result[Component] = {
@@ -403,10 +432,19 @@ case class Component(
             Left(SemanticError.PassiveAsync(command.getLoc))
           case _ => Right(())
         }
+      )
+      def checkStateMachines() = Result.map(
+        this.stateMachineInstanceMap.values.toList,
+        (instance: StateMachineInstance) => {
+          val loc = instance.getLoc
+          val error = SemanticError.PassiveStateMachine(loc)
+          Left(error)
+        }
       ) 
       for {
         _ <- checkPortInstances()
         _ <- checkCommands()
+        _ <- checkStateMachines()
       }
       yield ()
     }

compiler/lib/src/main/scala/analysis/Semantics/NameGroup.scala

@@ -7,6 +7,7 @@ object NameGroup {
   case object ComponentInstance extends NameGroup
   case object Component extends NameGroup
   case object Port extends NameGroup
+  case object StateMachine extends NameGroup
   case object Topology extends NameGroup
   case object Type extends NameGroup
   case object Value extends NameGroup
@@ -15,6 +16,7 @@ object NameGroup {
     ComponentInstance,
     Component,
     Port,
+    StateMachine,
     Topology,
     Type,
     Value

compiler/lib/src/main/scala/analysis/Semantics/StateMachineInstance.scala

@@ -0,0 +1,55 @@
+package fpp.compiler.analysis
+
+import fpp.compiler.ast._
+import fpp.compiler.util._
+
+/** An FPP state machine instance */
+final case class StateMachineInstance(
+  aNode: Ast.Annotated[AstNode[Ast.SpecStateMachineInstance]],
+  specifier: Ast.SpecStateMachineInstance
+) {
+
+  /** Gets the location of the state machine instance*/
+  def getLoc: Location = Locations.get(aNode._2.id)
+
+  def getNodeId = aNode._2.id
+
+  /** Gets the unqualified name of the state machine instance */
+  def getUnqualifiedName = aNode._2.data.name
+
+}
+
+object StateMachineInstance {
+
+  /** Creates a state machine instance from a state machine instance specifier */
+  def fromSpecStateMachine(a: Analysis, 
+                           aNode: Ast.Annotated[AstNode[Ast.SpecStateMachineInstance]]
+  ) :
+    Result.Result[StateMachineInstance] = {
+      val node = aNode._2
+      val data = node.data
+      data match {
+          case specifier: Ast.SpecStateMachineInstance =>
+              createStateMachineInstance(a, aNode, specifier)
+        }
+    }
+
+  private def createStateMachineInstance(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecStateMachineInstance]],
+    specifier: Ast.SpecStateMachineInstance
+  ): Result.Result[StateMachineInstance] = {
+    val qid = specifier.stateMachine
+    a.useDefMap(qid.id) match {
+      case symbol @ Symbol.StateMachine(_) =>
+        Right(StateMachineInstance(aNode, specifier))
+      case symbol => Left(SemanticError.InvalidSymbol(
+        symbol.getUnqualifiedName,
+        Locations.get(qid.id),
+        "not a state machine symbol",
+        symbol.getLoc
+      ))
+    }
+  }
+
+}

compiler/lib/src/main/scala/analysis/Semantics/Symbol.scala

@@ -55,6 +55,10 @@ object Symbol {
     override def getNodeId = node._2.id
     override def getUnqualifiedName = node._2.data.name
   }
+  final case class StateMachine(node: Ast.Annotated[AstNode[Ast.DefStateMachine]]) extends Symbol {
+    override def getNodeId = node._2.id
+    override def getUnqualifiedName = node._2.data.name
+  }
   final case class Struct(node: Ast.Annotated[AstNode[Ast.DefStruct]]) extends Symbol {
     override def getNodeId = node._2.id
     override def getUnqualifiedName = node._2.data.name

compiler/lib/src/main/scala/analysis/UsedSymbols.scala

@@ -12,6 +12,12 @@ object UsedSymbols extends UseAnalyzer {
     use: Name.Qualified
   ) = addSymbol(a, node)
 
+  override def stateMachineUse(
+    a: Analysis,
+    node: AstNode[Ast.QualIdent],
+    use: Name.Qualified
+  ) = addSymbol(a, node)
+
   override def componentInstanceUse(
     a: Analysis,
     node: AstNode[Ast.QualIdent],
@@ -61,6 +67,7 @@ object UsedSymbols extends UseAnalyzer {
         case Symbol.EnumConstant(node) => defEnumConstantAnnotatedNode(a1, node)
         case Symbol.Module(node) => defModuleAnnotatedNode(a1, node)
         case Symbol.Port(node) => defPortAnnotatedNode(a1, node)
+        case Symbol.StateMachine(node) => defStateMachineAnnotatedNode(a1, node)
         case Symbol.Struct(node) => defStructAnnotatedNode(a1, node)
         case Symbol.Topology(node) => defTopologyAnnotatedNode(a1, node)
       }

compiler/lib/src/main/scala/codegen/LocateDefsFppWriter.scala

@@ -50,6 +50,15 @@ object LocateDefsFppWriter extends AstVisitor with LineUtils {
       data.members.flatMap(matchComponentMember(s1, _))
   }
 
+  override def defStateMachineAnnotatedNode(
+    s: State,
+    aNode: Ast.Annotated[AstNode[Ast.DefStateMachine]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    writeSpecLoc(s, Ast.SpecLoc.StateMachine, data.name, node)
+  }
+
   override def defComponentInstanceAnnotatedNode(
     s: State,
     aNode: Ast.Annotated[AstNode[Ast.DefComponentInstance]]

compiler/lib/src/main/scala/syntax/Parser.scala

@@ -471,6 +471,7 @@ object Parser extends Parsers {
       constant ^^ { case _ => Ast.SpecLoc.Constant } |
       instance ^^ { case _ => Ast.SpecLoc.ComponentInstance } |
       port ^^ { case _ => Ast.SpecLoc.Port } |
+      state ~! machine ^^ { case _ => Ast.SpecLoc.StateMachine } |
       topology ^^ { case _ => Ast.SpecLoc.Topology } |
       typeToken ^^ { case _ => Ast.SpecLoc.Type } |
       failure("location kind expected")
@@ -577,7 +578,7 @@ object Parser extends Parsers {
   }
 
   def specStateMachineInstance: Parser[Ast.SpecStateMachineInstance] = {
-    (state ~> machine ~> (instance ~> ident) ~ (colon ~>! node(qualIdent))) ^^ {
+    (state ~> machine ~> (instance ~> ident) ~! (colon ~>! node(qualIdent))) ^^ {
       case name ~ statemachine => Ast.SpecStateMachineInstance(name, statemachine)
     }
   }

compiler/lib/src/main/scala/util/Error.scala

@@ -89,6 +89,9 @@ sealed trait Error {
         Error.print (Some(loc)) (s"duplicate port instance ${name}")
         System.err.println("previous instance is here:")
         System.err.println(prevLoc)
+      case SemanticError.DuplicateStateMachineInstance(name, loc, prevLoc) =>
+        Error.print (Some(loc)) (s"duplicate state machine instance name ${name}")
+        printPrevLoc(prevLoc)
       case SemanticError.DuplicateStructMember(name, loc, prevLoc) =>
         Error.print (Some(loc)) (s"duplicate struct member ${name}")
         System.err.println("previous member is here:")
@@ -206,6 +209,8 @@ sealed trait Error {
         System.err.println(loc2)
       case SemanticError.PassiveAsync(loc) =>
         Error.print (Some(loc)) ("passive component may not have async input")
+      case SemanticError.PassiveStateMachine(loc) =>
+        Error.print (Some(loc)) ("passive component may not have a state machine instance")
       case SemanticError.RedefinedSymbol(name, loc, prevLoc) =>
         Error.print (Some(loc)) (s"redefinition of symbol ${name}")
         System.err.println("previous definition is here:")
@@ -332,6 +337,12 @@ object SemanticError {
     loc: Location,
     prevLoc: Location
   ) extends Error
+  /** Duplicate state machine instance */
+  final case class DuplicateStateMachineInstance(
+    name: String,
+    loc: Location,
+    prevLoc: Location
+  ) extends Error
   /** Duplicate struct member */
   final case class DuplicateStructMember(
     name: String,
@@ -483,6 +494,7 @@ object SemanticError {
   ) extends Error
   /** Passive async input */
   final case class PassiveAsync(loc: Location) extends Error
+  final case class PassiveStateMachine(loc: Location) extends Error
   /** Redefined symbol */
   final case class RedefinedSymbol(
     name: String,

compiler/tools/fpp-check/test/component/ok.fpp

@@ -39,4 +39,7 @@ active component C {
 
   telemetry port tlmOut
 
+  state machine S
+  state machine instance s: S
+
 }

compiler/tools/fpp-check/test/defs/ok.fpp

@@ -12,6 +12,8 @@ struct S2 { x: [3] U32 }
 enum E1 { X, Y }
 enum E2 { X, Y }
 
+state machine S
+
 module M {
 
   type a
@@ -28,5 +30,6 @@ module M {
   enum E1 { X, Y }
   enum E2 { X, Y }
 
-}
+  state machine S
 
+}

compiler/tools/fpp-check/test/invalid_symbols/module_as_state_machine.fpp

@@ -0,0 +1,5 @@
+module M {}
+
+active component C {
+    state machine instance s1: M 
+}

compiler/tools/fpp-check/test/invalid_symbols/module_as_state_machine.ref.txt

@@ -0,0 +1,9 @@
+fpp-check
+[ local path prefix ]/compiler/tools/fpp-check/test/invalid_symbols/module_as_state_machine.fpp:4.32
+    state machine instance s1: M 
+                               ^
+error: invalid symbol M: not a state machine symbol
+symbol is defined here:
+[ local path prefix ]/compiler/tools/fpp-check/test/invalid_symbols/module_as_state_machine.fpp:1.1
+module M {}
+^

compiler/tools/fpp-check/test/invalid_symbols/state_machine_as_qualifier.fpp

@@ -0,0 +1,4 @@
+state machine S
+active component C {
+  state machine instance s: S.s
+}

compiler/tools/fpp-check/test/invalid_symbols/state_machine_as_qualifier.ref.txt

@@ -0,0 +1,9 @@
+fpp-check
+[ local path prefix ]/compiler/tools/fpp-check/test/invalid_symbols/state_machine_as_qualifier.fpp:3.29
+  state machine instance s: S.s
+                            ^
+error: invalid symbol S: not a qualifier
+symbol is defined here:
+[ local path prefix ]/compiler/tools/fpp-check/test/invalid_symbols/state_machine_as_qualifier.fpp:1.1
+state machine S
+^

compiler/tools/fpp-check/test/invalid_symbols/tests.sh

@@ -5,9 +5,11 @@ module_as_component
 module_as_component_instance
 module_as_constant
 module_as_port
+module_as_state_machine
 module_as_topology
 module_as_type
 module_hides_constant
+state_machine_as_qualifier
 topology_as_qualifier
 type_as_constant
 "