Merge pull request #602 from nasa/issue-566-packet-semantics

Telemetry packet semantics

Author: bocchino

compiler/lib/src/main/resources/META-INF/native-image/reflect-config.json

@@ -65,6 +65,12 @@ case class Analysis(
   topology: Option[Topology] = None,
   /** The map from state machine symbols to state machines */
   stateMachineMap: Map[Symbol.StateMachine, StateMachine] = Map(),
+  /** The map from topology symbols to dictionaries */
+  dictionaryMap: Map[Symbol.Topology, Dictionary] = Map(),
+  /** The dictionary under construction */
+  dictionary: Option[Dictionary] = None,
+  /** The telemetry packet group under construction */
+  tlmPacketGroup: Option[TlmPacketGroup] = None
 ) {
 
   /** Gets the qualified name of a symbol */
@@ -245,6 +251,11 @@ case class Analysis(
     for (ts <- getTopologySymbol(id))
       yield this.topologyMap(ts)
 
+  /** Gets a dictionary from the dictionary map */
+  def getDictionary(id: AstNode.Id): Result.Result[Dictionary] =
+    for (ts <- getTopologySymbol(id))
+      yield this.dictionaryMap(ts)
+
   /** Gets a BigInt value from an AST node */
   def getBigIntValue(id: AstNode.Id): BigInt = {
     val Value.Integer(v) = Analysis.convertValueToType(
@@ -404,6 +415,48 @@ case class Analysis(
 
 object Analysis {
 
+  /** Adds a dictionary element mapped by ID */
+  def addElementToIdMap[T](
+    map: Map[BigInt, T],
+    id: BigInt,
+    element: T,
+    getLoc: T => Location
+  ): Result.Result[(Map[BigInt,T], BigInt)] = {
+    map.get(id) match {
+      case Some(prevElement) =>
+        // Element already there: report the error
+        val idValue = displayIdValue(id)
+        val loc = getLoc(element)
+        val prevLoc = getLoc(prevElement)
+        Left(SemanticError.DuplicateIdValue(idValue, loc, prevLoc))
+      case None =>
+        // New element: compute the new map and the new default ID
+        Right(map + (id -> element), id + 1)
+    }
+  }
+
+  /** Checks for duplicate names in dictionary */
+  def checkDictionaryNames[Id,Value](
+    dictionary: Map[Id,Value],
+    kind: String,
+    getName: Value => String,
+    getLoc: Value => Location
+  ) = {
+    val initialMap: Map[String, Location] = Map()
+    Result.foldLeft (dictionary.toList) (initialMap) ((map, pair) => {
+      val (_, value) = pair
+      val name = getName(value)
+      val loc = getLoc(value)
+      map.get(name) match {
+        case Some(prevLoc) =>
+          Left(SemanticError.DuplicateDictionaryName(
+            kind, name, loc, prevLoc
+          ))
+        case _ => Right(map + (name -> loc))
+      }
+    })
+  }
+
   /** Compute the common type for two types */
   def commonType(t1: Type, t2: Type, errorLoc: Location): Result.Result[Type] =
     Type.commonType(t1, t2) match {

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

@@ -0,0 +1,18 @@
+package fpp.compiler.analysis
+
+import fpp.compiler.ast._
+import fpp.compiler.util._
+
+/** Analyze telemetry packet group members */
+trait TlmPacketGroupAnalyzer extends Analyzer {
+
+  override def specTlmPacketGroupAnnotatedNode(
+    a: Analysis,
+    node: Ast.Annotated[AstNode[Ast.SpecTlmPacketGroup]]
+  ) = {
+    val (_, node1, _) = node
+    val data = node1.data
+    visitList(a, data.members, matchTlmPacketGroupMember)
+  }
+
+}

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

@@ -9,6 +9,7 @@ trait TypeExpressionAnalyzer
   with ComponentAnalyzer
   with ModuleAnalyzer
   with StateMachineAnalyzer
+  with TlmPacketGroupAnalyzer
   with TopologyAnalyzer
 {
 
@@ -266,4 +267,13 @@ trait TypeExpressionAnalyzer
     } yield a
   }
 
+  override def specTlmPacketAnnotatedNode(a: Analysis, aNode: Ast.Annotated[AstNode[Ast.SpecTlmPacket]]) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    for {
+      a <- opt(exprNode)(a, data.id)
+      a <- exprNode(a, data.level)
+    } yield a
+  }
+
 }

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

@@ -133,6 +133,22 @@ trait UseAnalyzer extends TypeExpressionAnalyzer {
     }
   }
 
+  override def specTlmPacketAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecTlmPacket]]
+  ) = for {
+    a <- super.specTlmPacketAnnotatedNode(a, aNode)
+    a <- visitList(a, aNode._2.data.members, tlmPacketMember)
+  } yield a
+
+  override def specTlmPacketGroupAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecTlmPacketGroup]]
+  ) = for {
+    a <- super.specTlmPacketGroupAnnotatedNode(a, aNode)
+    a <- visitList(a, aNode._2.data.omitted, tlmChannelIdentifierNode)
+  } yield a
+
   override def specTopImportAnnotatedNode(a: Analysis, node: Ast.Annotated[AstNode[Ast.SpecTopImport]]) = {
     val (_, node1, _) = node
     val data = node1.data
@@ -154,4 +170,17 @@ trait UseAnalyzer extends TypeExpressionAnalyzer {
     f(a, qualIdent, use)
   }
 
+  private def tlmChannelIdentifierNode (
+    a: Analysis,
+    node: AstNode[Ast.TlmChannelIdentifier]
+  ): Result =
+    qualIdentNode (componentInstanceUse) (a, node.data.componentInstance)
+
+  private def tlmPacketMember(a: Analysis, member: Ast.TlmPacketMember) =
+    member match {
+      case Ast.TlmPacketMember.SpecInclude(node) => Right(a)
+      case Ast.TlmPacketMember.TlmChannelIdentifier(node) =>
+        tlmChannelIdentifierNode(a, node)
+    }
+
 }

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

@@ -296,6 +296,19 @@ object CheckExprTypes extends UseAnalyzer {
     yield a
   }
 
+  override def specTlmPacketAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecTlmPacket]]
+  ) = {
+    val (_, node, _) = aNode
+    val data = node.data
+    for {
+      a <- super.specTlmPacketAnnotatedNode(a, aNode)
+      _ <- convertNodeToNumericOpt(a, data.id)
+      _ <- convertNodeToNumeric(a, data.level)
+    } yield a
+  }
+
   override def structTypeMemberAnnotatedNode(
     a: Analysis,
     aNode: Ast.Annotated[AstNode[Ast.StructTypeMember]]

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

@@ -30,6 +30,7 @@ object CheckSemantics {
       _ <- CheckComponentInstanceDefs.checkIdRanges(a)
       a <- CheckStateMachineDefs.visitList(a, tul, CheckStateMachineDefs.transUnit)
       a <- CheckTopologyDefs.visitList(a, tul, CheckTopologyDefs.transUnit)
+      a <- ConstructDictionaryMap.visitList(a, tul, ConstructDictionaryMap.transUnit)
       a <- BuildSpecLocMap.visitList(a, tul, BuildSpecLocMap.transUnit)
       a <- CheckSpecLocs.visitList(a, tul, CheckSpecLocs.transUnit)
     }

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

@@ -0,0 +1,72 @@
+package fpp.compiler.analysis
+
+import fpp.compiler.ast._
+import fpp.compiler.util._
+
+/** Construct the dictionary map */
+object ConstructDictionaryMap
+  extends Analyzer 
+  with ModuleAnalyzer
+  with TopologyAnalyzer
+  with TlmPacketGroupAnalyzer
+{
+
+  override def defTopologyAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.DefTopology]]
+  ) = {
+    val symbol = Symbol.Topology(aNode)
+    val t = a.topologyMap(symbol)
+    val d = {
+      val d1 = Dictionary()
+      val d2 = DictionaryUsedSymbols(a, t).updateUsedSymbols(d1)
+      DictionaryEntries(a, t).updateEntries(d2)
+    }
+    val a1 = a.copy(dictionary = Some(d))
+    for {
+      a <- super.defTopologyAnnotatedNode(a1, aNode)
+    }
+    yield {
+      val d = a.dictionary.get
+      a.copy(dictionaryMap = a.dictionaryMap + (symbol -> d))
+    }
+  }
+
+  override def specTlmPacketGroupAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecTlmPacketGroup]]
+  ) = {
+    val tpgOpt = Some(TlmPacketGroup(aNode))
+    val a1 = a.copy(tlmPacketGroup = tpgOpt)
+    val d = a.dictionary.get
+    for {
+      a <- super.specTlmPacketGroupAnnotatedNode(a1, aNode)
+      tpg <- TlmPacketGroup.complete (
+        a,
+        d,
+        a.topology.get
+      ) (a.tlmPacketGroup.get)
+      d <- d.addTlmPacketGroup(tpg)
+    }
+    yield a.copy(dictionary = Some(d))
+  }
+
+  override def specTlmPacketAnnotatedNode(
+    a: Analysis,
+    aNode: Ast.Annotated[AstNode[Ast.SpecTlmPacket]]
+  ) = {
+    val data = aNode._2.data
+    for {
+      idOpt <- a.getNonnegativeBigIntValueOpt(data.id)
+      packet <- TlmPacket.fromSpecTlmPacket(
+        a,
+        a.dictionary.get,
+        a.topology.get,
+        aNode
+      )
+      g <- a.tlmPacketGroup.get.addPacket(idOpt, packet)
+    }
+    yield a.copy(tlmPacketGroup = Some(g))
+  }
+
+}