Allow unmatched connections to matched ports

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

@@ -8,7 +8,8 @@ case class Connection(
   /** The from endpoint */
   from: Connection.Endpoint,
   /** The to endpoint */
-  to: Connection.Endpoint
+  to: Connection.Endpoint,
+  isUnmatched: Boolean = false
 ) extends Ordered[Connection] {
 
   override def toString = s"${from.toString} -> ${to.toString}"
@@ -103,6 +104,19 @@ case class Connection(
     }
   }
 
+  /** Checks to see if a connection is match constrained */
+  def isMatchConstrained: Boolean = {
+    def portMatchingExists(pml: List[Component.PortMatching], pi: PortInstance): Boolean =
+      pml.exists(pm => pi.equals(pm.instance1) || pi.equals(pm.instance2))
+
+    val fromPi = from.port.portInstance
+    val toPi = to.port.portInstance
+    val fromPml = from.port.componentInstance.component.portMatchingList
+    val toPml = to.port.componentInstance.component.portMatchingList
+
+    portMatchingExists(fromPml, fromPi) || portMatchingExists(toPml, toPi)
+  }
+
   /** Compare two connections */
   override def compare(that: Connection) = {
     val fromCompare = this.from.compare(that.from)
@@ -141,10 +155,14 @@ object Connection {
       for {
         from <- Endpoint.fromAst(a, connection.fromPort, connection.fromIndex)
         to <- Endpoint.fromAst(a, connection.toPort, connection.toIndex)
-        connection <- Right(Connection(from, to))
+        connection <- Right(Connection(from, to, connection.isUnmatched))
         _ <- connection.checkDirections
         _ <- connection.checkTypes
         _ <- connection.checkSerialWithTypedInput
+        _ <- 
+          if !connection.isMatchConstrained && connection.isUnmatched 
+          then Left(SemanticError.MissingPortMatching(connection.getLoc))
+          else Right(())
       }
       yield connection
 
@@ -184,7 +202,6 @@ object Connection {
         else Left(SemanticError.InvalidPortNumber(loc, n, name, size, specLoc))
       case None => Right(())
     }
-
   }
 
   object Endpoint {
@@ -204,7 +221,6 @@ object Connection {
         case None => Right(())
       }
     } yield endpoint
-
   }
 
 }

compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/GeneralPortNumbering.scala

@@ -28,7 +28,10 @@ object GeneralPortNumbering {
     val pi = pii.portInstance
     val cs = t.getConnectionsFrom(pii).toArray.sorted
     val usedPortNumbers = t.getUsedPortNumbers(pi, cs)
-    val state = PortNumberingState.initial(usedPortNumbers)
+    // Initialize the PortNumberingState with an empty set as one 
+    // of its args since in GeneralPortNumbering we are only 
+    // working with one set of port numbers at a time
+    val state = PortNumberingState.initial(Set(), usedPortNumbers)
     val (_, t1) = cs.foldLeft ((state, t)) ({ case ((s,t), c) =>
       t.getPortNumber(pi, c) match {
         case Some(n) => (s, t)

compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/MatchedPortNumbering.scala

@@ -60,18 +60,45 @@ object MatchedPortNumbering {
           }
         case (Some(n1), None) =>
           // Only pi1 has a number: assign it to pi2
-          val t1 = t.assignPortNumber(pi2, c2, n1)
-          Right(state.copy(t = t1))
+          // Check to see if the port number is already in use
+          if PortNumberingState.checkPortNumberInUse(n1, state.numbering.usedPorts2)
+            then Left(SemanticError.PortNumberAlreadyInUse(n1))
+          else {
+            val t1 = t.assignPortNumber(pi2, c2, n1)
+            // Update the set of used ports so that the new port number is tracked
+            val num = state.numbering.setUsedPorts(state.numbering.usedPorts1, state.numbering.usedPorts2 + n1)
+            Right(state.copy(t = t1, numbering = num))
+          }
         case (None, Some(n2)) =>
           // Only pi2 has a number: assign it to pi1
-          val t1 = t.assignPortNumber(pi1, c1, n2)
-          Right(state.copy(t = t1))
+          // Check to see if the port number is already in use
+          if PortNumberingState.checkPortNumberInUse(n2, state.numbering.usedPorts1)
+            then Left(SemanticError.PortNumberAlreadyInUse(n2))
+          else {
+            val t1 = t.assignPortNumber(pi1, c1, n2)
+            // Update the set of used ports so that the new port number is tracked
+            val num = state.numbering.setUsedPorts(state.numbering.usedPorts1 + n2, state.numbering.usedPorts2)
+            Right(state.copy(t = t1, numbering = num))
+          }
         case (None, None) =>
           // Neither port has a number: assign a new one
+          val maxSize1 = pi1.getArraySize
+          val maxSize2 = pi2.getArraySize
           val (numbering, n) = state.numbering.getPortNumber
-          val t1 = t.assignPortNumber(pi1, c1, n).
-            assignPortNumber(pi2, c2, n)
-          Right(state.copy(t = t1, numbering = numbering))
+          // Check to see if the port number is out of range for either of the port array sizes
+          if(n > maxSize1 - 1)
+            then Left(SemanticError.InvalidPortNumber(pi1.getLoc, n, pi1.toString, maxSize1, pi1.getLoc))
+          else if(n > maxSize2 - 1)
+            then Left(SemanticError.InvalidPortNumber(pi2.getLoc, n, pi2.toString, maxSize2, pi2.getLoc))
+          // Check to see if the port number is already in use
+          else if PortNumberingState.checkPortNumberInUse(n, state.numbering.usedPortNumbers)
+            then Left(SemanticError.PortNumberAlreadyInUse(n))
+          else {
+            val t1 = t.assignPortNumber(pi1, c1, n).assignPortNumber(pi2, c2, n)
+            // Update the set of used ports so that the new port number is tracked
+            val num = state.numbering.setUsedPorts(state.numbering.usedPorts1 + n, state.numbering.usedPorts2 + n)
+            Right(state.copy(t = t1, numbering = num))
+          }
       }
     }
 
@@ -99,18 +126,17 @@ object MatchedPortNumbering {
       pi1: PortInstance,
       map1: ConnectionMap,
       pi2: PortInstance,
-      map2: ConnectionMap
+      map2: ConnectionMap,
+      usedPorts1: Set[Int],
+      usedPorts2: Set[Int]
     ): State = {
-      // Compute the used port numbers
-      val usedPortNumbers = t.getUsedPortNumbers(pi1, map1.values) ++
-        t.getUsedPortNumbers(pi2, map2.values)
       State(
         t,
         pi1,
         map1,
         pi2,
         map2,
-        PortNumberingState.initial(usedPortNumbers)
+        PortNumberingState.initial(usedPorts1, usedPorts2)
       )
     }
 
@@ -161,29 +187,52 @@ object MatchedPortNumbering {
       val pii = PortInstanceIdentifier(ci, pi)
       val cs = t.getConnectionsAt(pii).toList.sorted
       Result.foldLeft (cs) (empty) ((m, c) => {
-        val piiRemote = c.getOtherEndpoint(pi).port
-        val ciRemote = piiRemote.componentInstance
-        m.get(ciRemote) match {
-          case Some(cPrev) => Left(
-            SemanticError.DuplicateMatchedConnection(
-              c.getLoc,
-              cPrev.getLoc,
-              portMatching.getLoc
+        if(c.isUnmatched)
+          Right(m)
+        else {
+          val piiRemote = c.getOtherEndpoint(pi).port
+          val ciRemote = piiRemote.componentInstance
+          m.get(ciRemote) match {
+            case Some(cPrev) => Left(
+              SemanticError.DuplicateMatchedConnection(
+                c.getLoc,
+                cPrev.getLoc,
+                portMatching.getLoc
+              )
             )
-          )
-          case None => Right(m + (ciRemote -> c))
+            case None => Right(m + (ciRemote -> c))
+          }
         }
       })
     }
+
+    // Computes the set of used ports for all connections at a specific port instance
+    def computeUsedPortNumbers(pi: PortInstance): Result.Result[Set[Int]] = {
+      val empty: Set[Int] = Set()
+      val pii = PortInstanceIdentifier(ci, pi)
+      val cs = t.getConnectionsAt(pii).toList.sorted
+      Result.foldLeft (cs) (empty) ((s, c) => {
+        val used = t.getUsedPortNumbers(pi, List(c))
+        val intersection = s.intersect(used)
+        // Do not allow duplicate port numbers
+        if intersection.nonEmpty
+          then Left(SemanticError.MultipleConnectionsAtPortIndex(intersection.mkString(", ")))
+        else
+          Right(s ++ used)
+      })
+    }
+
     val pi1 = portMatching.instance1
     val pi2 = portMatching.instance2
     val loc = portMatching.getLoc
     for {
       map1 <- constructMap(loc, pi1)
       map2 <- constructMap(loc, pi2)
+      usedPorts1 <- computeUsedPortNumbers(pi1)
+      usedPorts2 <- computeUsedPortNumbers(pi2)
       _ <- checkForMissingConnections(loc, map1, map2)
       state <- {
-        val state = State.initial(t, pi1, map1, pi2, map2)
+        val state = State.initial(t, pi1, map1, pi2, map2, usedPorts1, usedPorts2)
         State.assignNumbers(loc, state)
       }
     }

compiler/lib/src/main/scala/analysis/Semantics/ResolveTopology/PortNumberingState.scala

@@ -5,6 +5,10 @@ import fpp.compiler.util._
 
 /** Port numbering state */
 case class PortNumberingState private (
+  /** First set of used ports */
+  usedPorts1: Set[Int],
+  /** Second set of used ports */
+  usedPorts2: Set[Int],
   /** The used port numbers */
   usedPortNumbers: Set[Int],
   /** The next port number */
@@ -19,7 +23,7 @@ case class PortNumberingState private (
       nextPortNumber,
       s
     )
-    PortNumberingState(s, n)
+    PortNumberingState(usedPorts1, usedPorts2, s, n)
   }
 
   /** Gets the next port number and updates the state */
@@ -28,14 +32,26 @@ case class PortNumberingState private (
     (s, nextPortNumber)
   }
 
+  // Takes in the updated sets, updated the usedPortNumbers set 
+  // (ie: union of usedPorts1 and usedPorts2) and figure out the new next port number 
+  def setUsedPorts(u1: Set[Int], u2: Set[Int]): PortNumberingState = {
+    val updatedUsedPortNumbers = u1 ++ u2
+    val updatedNextPortNumber = PortNumberingState.getNextNumber(
+      nextPortNumber,
+      updatedUsedPortNumbers
+    )
+    PortNumberingState(u1, u2, updatedUsedPortNumbers, updatedNextPortNumber)
+  }
+
 }
 
 object PortNumberingState {
 
   /** Construct an initial state */
-  def initial(usedPortNumbers: Set[Int]): PortNumberingState = {
+  def initial(usedPorts1: Set[Int], usedPorts2: Set[Int]): PortNumberingState = {
+    val usedPortNumbers = usedPorts1 ++ usedPorts2
     val nextPortNumber = getNextNumber(0, usedPortNumbers)
-    PortNumberingState(usedPortNumbers, nextPortNumber)
+    PortNumberingState(usedPorts1, usedPorts2, usedPortNumbers, nextPortNumber)
   }
 
   /** Gets the next available port number */
@@ -47,4 +63,8 @@ object PortNumberingState {
     helper(from)
   }
 
+  // Checks to see if a port number is already in use
+  def checkPortNumberInUse(n: Int, used: Set[Int]) =
+    used.contains(n)
+
 }

compiler/lib/src/main/scala/ast/Ast.scala

@@ -382,6 +382,7 @@ object Ast {
 
     /** Connection */
     final case class Connection(
+      isUnmatched: Boolean,
       fromPort: AstNode[PortInstanceIdentifier],
       fromIndex: Option[AstNode[Expr]],
       toPort: AstNode[PortInstanceIdentifier],
@@ -724,5 +725,4 @@ object Ast {
       override def toString = "public"
     }
   }
-
 }

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

@@ -278,7 +278,7 @@ object AstWriter extends AstVisitor with LineUtils {
   ) =  {
     def direct(g: Ast.SpecConnectionGraph.Direct) = {
       def connection(c: Ast.SpecConnectionGraph.Connection) = {
-        lines("connection") ++ (
+        lines(if c.isUnmatched then "unmatched connection" else "connection") ++ (
           addPrefix("from port", portInstanceIdentifier) (c.fromPort.data) ++
           linesOpt(addPrefix("index", exprNode), c.fromIndex) ++
           addPrefix("to port", portInstanceIdentifier) (c.toPort.data) ++

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

@@ -575,10 +575,11 @@ object FppWriter extends AstVisitor with LineUtils {
     Line.addPrefixAndSuffix("[", exprNode(en), "]")
 
   private def connection(c: Ast.SpecConnectionGraph.Connection) =
-    portInstanceId(c.fromPort.data).
-    joinOpt (c.fromIndex) ("") (bracketExprNode).
-    join (" -> ") (portInstanceId(c.toPort.data)).
-    joinOpt (c.toIndex) ("") (bracketExprNode)
+    lines(if c.isUnmatched then "unmatched " else "").
+      join ("") (portInstanceId(c.fromPort.data)).
+      joinOpt (c.fromIndex) ("") (bracketExprNode).
+      join (" -> ") (portInstanceId(c.toPort.data)).
+      joinOpt (c.toIndex) ("") (bracketExprNode)
 
   private def defEnumConstant(dec: Ast.DefEnumConstant) =
     lines(ident(dec.name)).joinOpt (dec.value) (" = ") (exprNode)

compiler/lib/src/main/scala/codegen/XmlFppWriter/TopologyXmlFppWriter.scala

@@ -129,6 +129,7 @@ object TopologyXmlFppWriter extends LineUtils {
       }
       yield {
         Ast.SpecConnectionGraph.Connection(
+          false,
           from._1,
           from._2,
           to._1,

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

@@ -326,6 +326,7 @@ object Lexer extends RegexParsers {
     ("topology", (u: Unit) => Token.TOPOLOGY()),
     ("true", (u: Unit) => Token.TRUE()),
     ("type", (u: Unit) => Token.TYPE()),
+    ("unmatched", (u: Unit) => Token.UNMATCHED()),
     ("update", (u: Unit) => Token.UPDATE()),
     ("warning", (u: Unit) => Token.WARNING()),
     ("with", (u: Unit) => Token.WITH()),

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

@@ -48,9 +48,10 @@ object Parser extends Parsers {
 
   def connection: Parser[Ast.SpecConnectionGraph.Connection] = {
     def connectionPort = node(portInstanceIdentifier) ~! opt(index)
-    connectionPort ~! (rarrow ~>! connectionPort) ^^ {
-      case (fromPort ~ fromIndex) ~ (toPort ~ toIndex) => {
+    opt(unmatched) ~ connectionPort ~! (rarrow ~>! connectionPort) ^^ {
+      case unmatched ~ (fromPort ~ fromIndex) ~ (toPort ~ toIndex) => {
         Ast.SpecConnectionGraph.Connection(
+          unmatched.isDefined,
           fromPort,
           fromIndex,
           toPort,
@@ -397,7 +398,9 @@ object Parser extends Parsers {
   def specConnectionGraph: Parser[Ast.SpecConnectionGraph] = {
     def directGraph = {
       (connections ~> ident) ~! (lbrace ~>! elementSequence(connection, comma) <~! rbrace) ^^ {
-        case ident ~ connections => Ast.SpecConnectionGraph.Direct(ident, connections)
+        case ident ~ connections => {
+          Ast.SpecConnectionGraph.Direct(ident, connections)
+        }
       }
     }
     def patternGraph = {
@@ -934,6 +937,8 @@ object Parser extends Parsers {
 
   private def typeToken = accept("type", { case t : Token.TYPE => t })
 
+  private def unmatched = accept("unmatched", { case t : Token.UNMATCHED => t })
+
   private def update = accept("update", { case t : Token.UPDATE => t })
 
   private def warning = accept("warning", { case t : Token.WARNING => t })

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

@@ -117,6 +117,7 @@ object Token {
   final case class U32() extends Token
   final case class U64() extends Token
   final case class U8() extends Token
+  final case class UNMATCHED() extends Token
   final case class UNUSED() extends Token
   final case class UPDATE() extends Token
   final case class WARNING() extends Token