Merge pull request #933 from nasa/issue-926-framework-constants

Check framework constant values

Author: bocchino

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

@@ -0,0 +1,78 @@
+package fpp.compiler.analysis
+
+import fpp.compiler.ast._
+import fpp.compiler.util._
+
+/** Check F Prime framework constant values */
+object CheckFrameworkConstantValues {
+
+  def check(a: Analysis) =
+    Result.foldLeft (a.frameworkDefinitions.constantMap.toList) (a) (checkMapEntry)
+
+  private def checkMapEntry(a: Analysis, entry: (String, Symbol.Constant)) =
+    val (name, s) = entry
+    checkers.get(name).map(_(a, name, s)).getOrElse(Right(a))
+
+  private def requireNonnegativeIntegerConstant(a: Analysis, name: String, s: Symbol.Constant) =
+    val v = a.getBigIntValue(s.getNodeId)
+    if (v >= 0) then Right(a) else 
+      val valueId = s.node._2.data.value.id
+      Left(
+        SemanticError.InvalidIntValue(
+          Locations.get(valueId),
+          v,
+          s"framework definition $name must be a nonnegative integer constant"
+        )
+      )
+
+  private def requirePositiveIntegerConstant(a: Analysis, name: String, s: Symbol.Constant) =
+    val v = a.getBigIntValue(s.getNodeId)
+    if (v > 0) then Right(a) else 
+      val valueId = s.node._2.data.value.id
+      Left(
+        SemanticError.InvalidIntValue(
+          Locations.get(valueId),
+          v,
+          s"framework definition $name must be a positive integer constant"
+        )
+      )
+
+  private def requireStringSizeConstant(a: Analysis, name: String, s: Symbol.Constant) =
+    val v = a.getBigIntValue(s.getNodeId)
+    if (Type.String.isValidSize(v)) then Right(a) else
+      val valueId = s.node._2.data.value.id
+      val error = Left(
+        SemanticError.InvalidStringSize(
+          Locations.get(valueId),
+          v
+        )
+      )
+      val annotation = s"framework definition $name must be a string size constant"
+      Result.annotateResult(error, annotation)
+
+  private val checkers = Map(
+    "FW_ASSERT_COUNT_MAX" -> requireNonnegativeIntegerConstant,
+    "FW_CMD_ARG_BUFFER_MAX_SIZE" -> requirePositiveIntegerConstant,
+    "FW_CMD_STRING_MAX_SIZE" -> requireStringSizeConstant,
+    "FW_COM_BUFFER_MAX_SIZE" -> requirePositiveIntegerConstant,
+    "FW_FILE_BUFFER_MAX_SIZE" -> requirePositiveIntegerConstant,
+    "FW_FIXED_LENGTH_STRING_SIZE" -> requireStringSizeConstant,
+    "FW_INTERNAL_INTERFACE_STRING_MAX_SIZE" -> requireStringSizeConstant,
+    "FW_LOG_BUFFER_MAX_SIZE" -> requirePositiveIntegerConstant,
+    "FW_LOG_STRING_MAX_SIZE" -> requireStringSizeConstant,
+    "FW_LOG_TEXT_BUFFER_SIZE" -> requirePositiveIntegerConstant,
+    "FW_OBJ_SIMPLE_REG_BUFF_SIZE" -> requirePositiveIntegerConstant,
+    "FW_OBJ_SIMPLE_REG_ENTRIES" -> requirePositiveIntegerConstant,
+    "FW_PARAM_BUFFER_MAX_SIZE" -> requirePositiveIntegerConstant,
+    "FW_PARAM_STRING_MAX_SIZE" -> requireStringSizeConstant,
+    "FW_QUEUE_NAME_BUFFER_SIZE" -> requirePositiveIntegerConstant,
+    "FW_QUEUE_SIMPLE_QUEUE_ENTRIES" -> requirePositiveIntegerConstant,
+    "FW_SM_SIGNAL_BUFFER_MAX_SIZE" -> requirePositiveIntegerConstant,
+    "FW_STATEMENT_ARG_BUFFER_MAX_SIZE" -> requirePositiveIntegerConstant,
+    "FW_TASK_NAME_BUFFER_SIZE" -> requirePositiveIntegerConstant,
+    "FW_TLM_BUFFER_MAX_SIZE" -> requirePositiveIntegerConstant,
+    "FW_TLM_STRING_MAX_SIZE" -> requireStringSizeConstant,
+    "Fw.DpCfg.CONTAINER_USER_DATA_SIZE" -> requirePositiveIntegerConstant
+  )
+
+}

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

@@ -25,7 +25,10 @@ object CheckFrameworkDefs
     val id = aNode._2.id
     constants.get(name) match {
       case Some(checker) =>
-        for a <- checker(a, name, id)
+        for {
+          _ <- checker(a, name, id)
+          _ <- checkModuleQualifiers(a, s)
+        }
         yield a.copy(frameworkDefinitions = a.frameworkDefinitions.addConstant(name, s))
       case None => Right(a)
     }
@@ -94,12 +97,39 @@ object CheckFrameworkDefs
     val id = s.getNodeId
     types.get(name) match {
       case Some(checker) =>
-        for a <- checker(a, name, id)
+        for {
+          _ <- checker(a, name, id)
+          _ <- checkModuleQualifiers(a, s)
+        }
         yield a.copy(frameworkDefinitions = a.frameworkDefinitions.addType(name, s))
       case None => Right(a)
     }
   }
 
+  private def checkModuleQualifiers(a: Analysis, symbol: Symbol) = {
+    def helper(symbolOpt: Option[Symbol]): Result.Result[Analysis] =
+      symbolOpt match {
+        case None => Right(a)
+        case Some(s: Symbol.Module) =>
+          helper(a.parentSymbolMap.get(s))
+        case Some(s) =>
+          val error = Left(
+            SemanticError.InvalidQualifier(
+              a.getQualifiedName(s).toString,
+              Locations.get(symbol.getNodeId),
+              "not a module symbol",
+              Locations.get(s.getNodeId)
+            )
+          )
+          val symbolName = a.getQualifiedName(symbol)
+          Result.annotateResult(
+            error,
+            s"framework definition $symbolName must have module qualifiers"
+          )
+      }
+    helper(a.parentSymbolMap.get(symbol))
+  }
+
   private def requireAliasType(a: Analysis, name: String, id: AstNode.Id) = {
     val t = a.typeMap(id)
     t match {

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

@@ -19,6 +19,7 @@ object CheckSemantics {
       a <- EvalImpliedEnumConsts.visitList(a, tul, EvalImpliedEnumConsts.transUnit)
       a <- EvalConstantExprs.visitList(a, tul, EvalConstantExprs.transUnit)
       a <- FinalizeTypeDefs.visitList(a, tul, FinalizeTypeDefs.transUnit)
+      _ <- CheckFrameworkConstantValues.check(a)
       a <- CheckPortDefs.visitList(a, tul, CheckPortDefs.transUnit)
       a <- CheckInterfaceDefs.visitList(a, tul, CheckInterfaceDefs.transUnit)
       a <- CheckComponentDefs.visitList(a, tul, CheckComponentDefs.transUnit)

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

@@ -219,7 +219,7 @@ object FinalizeTypeDefs
             a.valueMap(id),
             Type.Integer
           )
-          if (size > 0 && size <= Int.MaxValue) Right(t)
+          if Type.String.isValidSize(size) then Right(t)
           else {
             val loc = Locations.get(id)
             Left(SemanticError.InvalidStringSize(loc, size))

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

@@ -169,6 +169,12 @@ object Type {
     override def isDisplayable = true
   }
 
+  object String {
+
+    def isValidSize(size: BigInt) = size > 0 && size <= Int.MaxValue
+
+  }
+
   /** The type of arbitrary-width integers */
   case object Integer extends Type with Int {
     override def getDefaultValue = Some(Value.Integer(0))

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

@@ -230,6 +230,10 @@ sealed trait Error {
         Error.print (Some(loc)) (s"no member $memberName in anonymous struct value")
         System.err.println("symbol is defined here:")
         System.err.println(defLoc)
+      case SemanticError.InvalidQualifier(name, loc, msg, defLoc) =>
+        Error.print (Some(loc)) (s"invalid qualifier $name: $msg")
+        System.err.println("symbol is defined here:")
+        System.err.println(defLoc)
       case SemanticError.InvalidStructMember(memberName, loc, structTypeName, defLoc) =>
         Error.print (Some(loc)) (s"no member $memberName in struct type $structTypeName")
         System.err.println("symbol is defined here:")
@@ -565,6 +569,12 @@ object SemanticError {
     specifiedPath: String,
     actualLoc: Location
   ) extends Error
+  /** No member in anonymous struct type */
+  final case class InvalidAnonStructMember(
+    memberName: String,
+    loc: Location,
+    defLoc: Location
+  ) extends Error
   /** Invalid array size */
   final case class InvalidArraySize(loc: Location, size: BigInt) extends Error
   /** Invalid command */
@@ -651,17 +661,18 @@ object SemanticError {
   final case class InvalidSpecialPort(loc: Location, msg: String) extends Error
   /** Invalid string size */
   final case class InvalidStringSize(loc: Location, size: BigInt) extends Error
-  /** No member in struct type */
-  final case class InvalidStructMember(
-    memberName: String,
+  /** Invalid qualifier */
+  final case class InvalidQualifier(
+    name: String,
     loc: Location,
-    structTypeName: String,
+    msg: String,
     defLoc: Location
   ) extends Error
-  /** No member in anonymous struct type */
-  final case class InvalidAnonStructMember(
+  /** No member in struct type */
+  final case class InvalidStructMember(
     memberName: String,
     loc: Location,
+    structTypeName: String,
     defLoc: Location
   ) extends Error
   /** No member in anonymous struct type */

compiler/tools/fpp-check/test/framework_defs/invalid_nonnegative_integer_constant.fpp

@@ -0,0 +1 @@
+constant FW_ASSERT_COUNT_MAX = -1

compiler/tools/fpp-check/test/framework_defs/invalid_nonnegative_integer_constant.ref

@@ -0,0 +1,6 @@
+fpp-check
+[ local path prefix ]/compiler/tools/fpp-check/test/framework_defs/invalid_positive_integer_constant.fpp:1.32
+constant FW_ASSERT_COUNT_MAX = -1
+                               ^
+error: invalid integer value -1
+framework definition FW_ASSERT_COUNT_MAX must be a positive integer constant

compiler/tools/fpp-check/test/framework_defs/invalid_nonnegative_integer_constant.ref.txt

@@ -0,0 +1,6 @@
+fpp-check
+[ local path prefix ]/compiler/tools/fpp-check/test/framework_defs/invalid_nonnegative_integer_constant.fpp:1.32
+constant FW_ASSERT_COUNT_MAX = -1
+                               ^
+error: invalid integer value -1
+framework definition FW_ASSERT_COUNT_MAX must be a nonnegative integer constant

compiler/tools/fpp-check/test/framework_defs/invalid_positive_integer_constant.fpp

@@ -0,0 +1 @@
+constant FW_CMD_ARG_BUFFER_MAX_SIZE = 0