fix_sppf_bug: Dot create, without wrong nodes. We dot die on AmbiguiusAStart2

Author: ProALgebra

solver/src/main/kotlin/org/ucfs/sppf/SppfStorage.kt

@@ -16,9 +16,7 @@ open class SppfStorage<InputEdgeType> {
 
 
     private fun addNode(node: RangeSppfNode<InputEdgeType>): RangeSppfNode<InputEdgeType> {
-
-        val sppfNode = createdSppfNodes.getOrPut(node) { node }
-        return sppfNode
+        return createdSppfNodes.getOrPut(node, { node })
     }
 
     /**

solver/src/main/kotlin/org/ucfs/sppf/node/RangeSppfNode.kt

@@ -15,28 +15,23 @@ import org.ucfs.rsm.symbol.ITerminal
  * May be used as extended packed sppfNode.
  * @param VertexType - type of vertex in input graph
  */
+var lastId = 0
+
 data class RangeSppfNode<VertexType>(
     val inputRange: InputRange<VertexType>?,
     val rsmRange: RsmRange?,
     val type: RangeType,
 ) {
     val id: Int = lastId++
     val children = ArrayList<RangeSppfNode<VertexType>>()
-    override fun toString(): String {
-        return when (type) {
-            is TerminalType<*> -> "Terminal `${type.terminal}` $inputRange"
-            is Range -> "Range $inputRange $rsmRange"
-            is NonterminalType -> "Nonterminal ${type.startState.nonterminal.name} $inputRange $rsmRange"
-            is IntermediateType<*> -> "Intermediate input:${type.inputPosition} rsm:${type.grammarSlot.id}"
-            is EpsilonNonterminalType -> "Epsilon ${type.startState.id}"
-            is EmptyType -> "Empty node"
-            else -> "Unknown sppf node type!"
-        }
-    }
 }
 
-fun <VertexType> getEmptyRange(): RangeSppfNode<VertexType> {
-    return RangeSppfNode(null, null, EmptyType())
+fun <VertexType> getEmptyRange(isStart: Boolean = false): RangeSppfNode<VertexType>  {
+    val type = EmptyType()
+    if(isStart) {
+        type.isStart = isStart
+    }
+    return RangeSppfNode(null, null, type)
 }
 
 data class InputRange<VertexType>(
@@ -60,6 +55,16 @@ data class TerminalType<T : ITerminal>(val terminal: T) : RangeType
 data class NonterminalType(val startState: RsmState) : RangeType
 data class EpsilonNonterminalType(val startState: RsmState) : RangeType
 data class IntermediateType<VertexType>(val grammarSlot: RsmState, val inputPosition: VertexType) : RangeType
-class EmptyType : RangeType
+class EmptyType : RangeType {
+    var isStart = false
 
-var lastId = 0
+    @Override
+    override fun equals(other: Any?): Boolean {
+        return other is EmptyType
+    }
+
+    @Override
+    override fun hashCode(): Int {
+        return 12
+    }
+}

solver/src/main/kotlin/org/ucfs/sppf/writeSppfToDot.kt

@@ -80,20 +80,62 @@ enum class NodeShape(val view: String) {
     )
 }
 
-fun getNodeView(node: RangeSppfNode<*>, id: String): String {
-    val shape = getNodeShape(node.type)
-    val idView = if (printWithId) "$id " else ""
-    return "[label = \"$idView${node}\", shape = ${shape.view}]"
+fun fillNodeTemplate(
+    id: String? = null, nodeInfo: String, inputRange: InputRange<*>?, shape: NodeShape, rsmRange: RsmRange? = null
+): String {
+    val inputRangeView = if (inputRange != null) "input: [${inputRange.from}, ${inputRange.to}]" else null
+    val rsmRangeView = if (rsmRange != null) "rsm: [${rsmRange.from.id}, ${rsmRange.to.id}]" else null
+    val view = listOfNotNull(nodeInfo, inputRangeView, rsmRangeView).joinToString(", ")
+    return "[label = \"${id?: ""}${shape.name} $view\", shape = ${shape.view}]"
 }
 
-fun getNodeShape(rangeType: RangeType): NodeShape {
-    return when (rangeType) {
-        is TerminalType<*> -> NodeShape.Terminal
-        is NonterminalType -> NodeShape.Nonterminal
-        is IntermediateType<*> -> NodeShape.Intermediate
-        is EmptyType -> NodeShape.Empty
-        is EpsilonNonterminalType -> NodeShape.Epsilon
-        is Range -> NodeShape.Range
-        else -> throw IllegalStateException("Can't write node type $rangeType to DOT")
+fun <InputNode> getNodeView(node: RangeSppfNode<InputNode>, id: String? = null): String {
+    val type = node.type
+    return when (type) {
+        is TerminalType<*> -> {
+            fillNodeTemplate(
+                id, "'${type.terminal}'", node.inputRange, NodeShape.Terminal
+            )
+        }
+
+        is NonterminalType -> {
+            fillNodeTemplate(
+                id, "${type.startState.nonterminal.name}", node.inputRange, NodeShape.Nonterminal
+            )
+        }
+
+        is IntermediateType<*> -> {
+            fillNodeTemplate(
+                id, "input: ${type.inputPosition}, rsm: ${type.grammarSlot.id}", node.inputRange, NodeShape.Intermediate
+            )
+        }
+
+        is EmptyType -> {
+            fillNodeTemplate(
+                id, "", null, NodeShape.Empty
+            )
+        }
+
+        is EpsilonNonterminalType -> {
+            fillNodeTemplate(
+                id, "RSM: ${type.startState.id}", node.inputRange, NodeShape.Epsilon
+            )
+        }
+
+        is RangeType -> {
+            fillNodeTemplate(
+                id, "", node.inputRange, NodeShape.Range, node.rsmRange
+            )
+        }
+
+        else -> throw IllegalStateException("Can't write node type $type to DOT")
+
     }
+
+
+}
+
+private fun getView(range: RsmRange?): String {
+    if (range == null) return ""
+    return "rsm: [(${range.from.nonterminal.name}:${range.from.numId}), " + "(${range.to.nonterminal.name}:${range.to.numId})]"
 }