Add fictive start nonterminal (#37)

* Add API for any dot input with strings on edges

Author: bachish

solver/src/main/kotlin/org/ucfs/grammar/combinator/Grammar.kt

@@ -12,6 +12,7 @@ open class Grammar {
     val nonTerms = ArrayList<Nt>()
 
     private lateinit var startNt: Nt
+    private lateinit var fictitiousStartNt: Nt
 
     private var _rsm: RsmState? = null
     val rsm: RsmState
@@ -22,12 +23,6 @@ open class Grammar {
             return _rsm!!
         }
 
-    fun setStart(expr: Regexp) {
-        if (expr is Nt) {
-            startNt = expr
-        } else throw IllegalArgumentException("Only NT object can be start state for Grammar")
-    }
-
     fun Nt.asStart(): Nt {
         if (this@Grammar::startNt.isInitialized) {
             throw Exception("Nonterminal ${nonterm.name} is already initialized")
@@ -43,6 +38,8 @@ open class Grammar {
     private fun buildRsm(): RsmState {
         nonTerms.forEach { it.buildRsmBox() }
         //if nonterminal not initialized -- it will be checked in buildRsmBox()
-        return startNt.nonterm.startState
+        fictitiousStartNt = Nt(startNt, "fictiveStart")
+        fictitiousStartNt.buildRsmBox()
+        return fictitiousStartNt.nonterm.startState
     }
 }

solver/src/main/kotlin/org/ucfs/grammar/combinator/regexp/Nt.kt

@@ -10,6 +10,11 @@ open class Nt() : DerivedSymbol {
     constructor(lhs: Regexp) : this() {
         rsmDescription = lhs
     }
+    constructor(lhs: Regexp, name: String) : this() {
+        rsmDescription = lhs
+        this.nonterm = Nonterminal(name)
+    }
+
 
     lateinit var nonterm: Nonterminal
         private set

solver/src/main/kotlin/org/ucfs/parser/Gll.kt

@@ -29,7 +29,8 @@ class Gll<VertexType, LabelType : ILabel> private constructor(
         fun <VertexType, LabelType : ILabel> gll(
             startState: RsmState, inputGraph: IInputGraph<VertexType, LabelType>
         ): Gll<VertexType, LabelType> {
-            return Gll(Context(startState, inputGraph), IntersectionEngine)
+            val finalState = startState.outgoingEdges.get(0).destinationState
+            return Gll(Context(startState, finalState, inputGraph), IntersectionEngine)
         }
     }
 
@@ -66,6 +67,11 @@ class Gll<VertexType, LabelType : ILabel> private constructor(
         ctx.descriptors.add(newDescriptor)
     }
 
+    fun isParseResult(descriptor: Descriptor<VertexType>, matchedRange: RangeSppfNode<VertexType>): Boolean {
+        return matchedRange.inputRange!!.from in ctx.input.getInputStartVertices()
+                && matchedRange.rsmRange!!.from == ctx.fictiveStartState
+                && matchedRange.rsmRange.to == ctx.fictiveFinalState
+    }
     /**
      * Processes descriptor
      * @param descriptor - descriptor to process
@@ -77,7 +83,7 @@ class Gll<VertexType, LabelType : ILabel> private constructor(
                 val node = getEpsilonRange(descriptor)
                 //TODO fix
                 // dirty hack: in fact it's equivavelnt descriptors
-                // but only initial was added in handlet set
+                // but only initial was added in handled set
                 ctx.descriptors.addToHandled(Descriptor(descriptor.inputPosition,
                     descriptor.gssNode, descriptor.rsmState, node))
                 node
@@ -87,11 +93,14 @@ class Gll<VertexType, LabelType : ILabel> private constructor(
             for (poppedEdge in ctx.gss.pop(descriptor, matchedRange)) {
                 handlePoppedGssEdge(poppedEdge, descriptor, matchedRange)
             }
-            if (descriptor.gssNode.outgoingEdges.isEmpty() && descriptor.gssNode.rsm.isStart) {
-                ctx.parseResult = matchedRange
+            if (isParseResult(descriptor, matchedRange)) {
+
+                if(ctx.parseResult == null) {
+                    ctx.parseResult = matchedRange
+                }
+                ctx.parseResults.add(matchedRange)
             }
         }
-
         engine.handleEdges(this, descriptor)
     }
 }

solver/src/main/kotlin/org/ucfs/parser/IGll.kt

@@ -36,7 +36,9 @@ interface IGll<InputNodeType, LabelType : ILabel> {
             curDescriptor = ctx.descriptors.nextToHandle()
         }
 
-        return ctx.parseResult
+       // assert(ctx.parseResult != null)
+       // assert(ctx.parseResult!!.children.size == 1)
+        return ctx.parseResult!!.children.get(0)
     }
 
     /**
@@ -52,9 +54,9 @@ interface IGll<InputNodeType, LabelType : ILabel> {
     fun initDescriptors(input: IInputGraph<InputNodeType, LabelType>) {
         for (startVertex in input.getInputStartVertices()) {
 
-            val gssNode = ctx.gss.getOrCreateNode(startVertex, ctx.startState)
+            val gssNode = ctx.gss.getOrCreateNode(startVertex, ctx.fictiveStartState)
             val startDescriptor = Descriptor(
-                startVertex, gssNode, ctx.startState, getEmptyRange()
+                startVertex, gssNode, ctx.fictiveStartState, getEmptyRange(true)
             )
             ctx.descriptors.add(startDescriptor)
         }

solver/src/main/kotlin/org/ucfs/parser/context/Context.kt

@@ -1,6 +1,5 @@
 package org.ucfs.parser.context
 
-import org.ucfs.descriptors.Descriptor
 import org.ucfs.descriptors.DescriptorsStorage
 import org.ucfs.gss.GraphStructuredStack
 import org.ucfs.input.IInputGraph
@@ -18,7 +17,8 @@ class Context<InputNodeType, LabelType : ILabel> (
     /**
      * Starting state of accepting Nonterminal in RSM
      */
-    val startState: RsmState,
+    val fictiveStartState: RsmState,
+    val fictiveFinalState: RsmState,
     val input: IInputGraph<InputNodeType, LabelType>
 
 
@@ -37,4 +37,5 @@ class Context<InputNodeType, LabelType : ILabel> (
     val gss: GraphStructuredStack<InputNodeType> = GraphStructuredStack()
 
     var parseResult: RangeSppfNode<InputNodeType>? = null
+    var parseResults = ArrayList<RangeSppfNode<InputNodeType>>()
 }

solver/src/main/kotlin/org/ucfs/rsm/RsmWrite.kt

@@ -87,7 +87,7 @@ fun writeRsmToTxt(startState: RsmState, pathToTXT: String) {
 }
 
 fun writeRsmToDot(startState: RsmState, filePath: String) {
-    val states = getAllStates(startState)
+    val states = getAllStates((startState.outgoingEdges.get(0).symbol as Nonterminal).startState)
     val boxes: HashMap<Nonterminal, HashSet<RsmState>> = HashMap()
 
     for (state in states) {

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

@@ -26,7 +26,13 @@ data class RangeSppfNode<VertexType>(
     val children = ArrayList<RangeSppfNode<VertexType>>()
 }
 
-fun <VertexType> getEmptyRange(): RangeSppfNode<VertexType> = 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>(
     val from: VertexType,
@@ -45,4 +51,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
-data class EmptyType(private val id: Int = lastEmptyId++) : RangeType
+class EmptyType : RangeType {
+    var isStart = false
+
+    @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

@@ -27,7 +27,7 @@ fun <InputNode> getSppfDot(sppfNode: RangeSppfNode<InputNode>, label: String = "
         node = queue.removeFirst()
         if (!visited.add(node.hashCode())) continue
 
-        nodeViews[node] = getNodeView(node, )
+        nodeViews[node] = getNodeView(node,)// node.id.toString())
 
         node.children.forEach {
             queue.addLast(it)

test-shared/src/test/kotlin/grammars/SimpleDyck.kt

@@ -1,6 +1,7 @@
 package grammars
 
 import org.ucfs.grammar.combinator.Grammar
+import org.ucfs.grammar.combinator.extension.StringExtension.or
 import org.ucfs.grammar.combinator.extension.StringExtension.times
 import org.ucfs.grammar.combinator.regexp.*
 import org.ucfs.grammar.combinator.regexp.Epsilon
@@ -11,6 +12,7 @@ class SimplifiedDyck : Grammar() {
 
     init {
         S /= Option("(" * S * ")")
+       // S = eps | ( S )
     }
 }
 
@@ -19,13 +21,14 @@ class LoopDyck : Grammar() {
 
     init {
         S /= Many( "(" * S * ")")
+        // S = [ ( S ) ]*
     }
 }
 
 class ABGrammar : Grammar() {
-    val A by Nt(Term("a"))
+    val A by Nt(Term("a")) // A -> a
     val C by Nt(Term("a"))
-    val B by Nt(C)
+    val B by Nt(C)  // C -> B
     val S by Nt(A or B).asStart()
 }
 
@@ -36,4 +39,32 @@ class SALang : Grammar() {
 
 class Epsilon : Grammar() {
     val S by Nt(Epsilon).asStart()
+}
+
+/**
+ * Can parse only one symbol 'a'
+ */
+class AmbiguousAStar1: Grammar() {
+    val S by Nt().asStart()
+
+    init {
+        S /= "a" or S
+    }
+}
+
+class AmbiguousAStar2: Grammar() {
+    val S by Nt().asStart()
+
+    init {
+        S /= "a" or S * S
+    }
+}
+
+
+class AmbiguousAStar3: Grammar() {
+    val S by Nt().asStart()
+
+    init {
+        S /= "a" or S * S
+    }
 }

test-shared/src/test/kotlin/solver/AbstractCorrectnessTest.kt

@@ -13,7 +13,9 @@ abstract class AbstractCorrectnessTest {
 
     abstract fun getRootDataFolder(): Path
 
-    val grammars = listOf(SimplifiedDyck(), ABGrammar(), SALang(), Epsilon(), LoopDyck())
+   val grammars = listOf(SimplifiedDyck(), ABGrammar(), SALang(), Epsilon(), LoopDyck(), AmbiguousAStar2(), AmbiguousAStar1())
+    //TODO return only one result for ambiguous AmbiguousAStar2(), AmbiguousAStar1()
+    // TODO fix worst case for loopdyck
     val regenerate = false
     //@TestFactory
     //TODO make it abstract by used grammar