FormalLanguageConstrainedPathQuerying · bachish · Jan 19, 2025
diff --git a/benchmarks/src/main/kotlin/org/ucfs/Java8ParserRecovery.kt b/benchmarks/src/main/kotlin/org/ucfs/Java8ParserRecovery.kt
@@ -2,7 +2,6 @@
 
 package org.ucfs
 
-import org.ucfs.JavaToken
 import org.ucfs.descriptors.Descriptor
 import org.ucfs.input.IInputGraph
 import org.ucfs.input.ILabel
@@ -8649,8 +8648,8 @@ public class Java8ParserRecovery<VertexType, LabelType : ILabel> :
     }
   }
 
-  override fun parse(descriptor: Descriptor<VertexType>) {
-    super.parse(descriptor)
+  override fun handleDescriptor(descriptor: Descriptor<VertexType>) {
+    super.handleDescriptor(descriptor)
     org.ucfs.intersection.RecoveryIntersection.handleRecoveryEdges(this, descriptor)
   }
 

diff --git a/generator/src/main/kotlin/org/ucfs/parser/GeneratedParser.kt b/generator/src/main/kotlin/org/ucfs/parser/GeneratedParser.kt
@@ -26,32 +26,20 @@ abstract class GeneratedParser<VertexType, LabelType : ILabel> :
         curSppfNode: SppfNode<VertexType>?
     ): Unit
 
-    override fun parse(descriptor: Descriptor<VertexType>) {
+    override fun handleDescriptor(descriptor: Descriptor<VertexType>) {
         val state = descriptor.rsmState
         val nt = state.nonterminal
 
         val pos = descriptor.inputPosition
         val curSppfNode = descriptor.sppfNode
         val epsilonSppfNode = ctx.sppf.getEpsilonSppfNode(descriptor)
-        val leftExtent = curSppfNode?.leftExtent
-        val rightExtent = curSppfNode?.rightExtent
 
         if (state.isFinal) {
             pop(descriptor.gssNode, curSppfNode ?: epsilonSppfNode, pos)
         }
 
         ctx.descriptors.addToHandled(descriptor)
 
-        if (state.isStart && state.isFinal) {
-            checkAcceptance(
-                epsilonSppfNode,
-                epsilonSppfNode!!.leftExtent,
-                epsilonSppfNode!!.rightExtent,
-                nt
-            )
-        }
-        checkAcceptance(curSppfNode, leftExtent, rightExtent, nt)
-
         callNtFuncs(nt, descriptor, curSppfNode)
     }
 

diff --git a/solver/src/main/kotlin/org/ucfs/gss/GssNode.kt b/solver/src/main/kotlin/org/ucfs/gss/GssNode.kt
@@ -28,7 +28,7 @@ class GssNode<VertexType>(
     /**
      * Maps edge label (rsmState, sppfNode) to destination gssNode
      */
-    val edges: HashMap<Pair<RsmState, SppfNode<VertexType>?>, HashSet<GssNode<VertexType>>> = HashMap()
+    val edges: HashMap<Pair<RsmState, SppfNode<VertexType>?>, GssNode<VertexType>> = HashMap()
 
     /**
      * Stores handled descriptors, which contained current gssNode as value of corresponding field
@@ -40,12 +40,10 @@ class GssNode<VertexType>(
      * @param rsmState - rsmState to store on the edge
      * @param sppfNode - sppfNode to store on the edge
      * @param gssNode - destination gssNode
-     * @return true if creation was successful, false otherwise
      */
     fun addEdge(rsmState: RsmState, sppfNode: SppfNode<VertexType>?, gssNode: GssNode<VertexType>): Boolean {
         val label = Pair(rsmState, sppfNode)
-
-        return edges.computeIfAbsent(label) { HashSet() }.add(gssNode)
+        return edges.put(label, gssNode) == null
     }
 
     override fun toString() = "GSSNode(nonterminal=$nonterminal, inputPosition=$inputPosition)"

diff --git a/solver/src/main/kotlin/org/ucfs/parser/Gll.kt b/solver/src/main/kotlin/org/ucfs/parser/Gll.kt
@@ -66,26 +66,25 @@ class Gll<VertexType, LabelType : ILabel> private constructor(
      * Processes descriptor
      * @param descriptor - descriptor to process
      */
-    override fun parse(descriptor: Descriptor<VertexType>) {
+    override fun handleDescriptor(descriptor: Descriptor<VertexType>) {
         val state = descriptor.rsmState
         val pos = descriptor.inputPosition
         val sppfNode = descriptor.sppfNode
-        val epsilonSppfNode = ctx.sppf.getEpsilonSppfNode(descriptor)
         val leftExtent = sppfNode?.leftExtent
         val rightExtent = sppfNode?.rightExtent
 
         if (state.isFinal) {
-            pop(descriptor.gssNode, sppfNode ?: epsilonSppfNode, pos)
+            pop(descriptor.gssNode, sppfNode ?: ctx.sppf.getEpsilonSppfNode(descriptor), pos)
         }
 
         ctx.descriptors.addToHandled(descriptor)
-
-        if (state.isStart && state.isFinal) {
-            checkAcceptance(
-                epsilonSppfNode, epsilonSppfNode!!.leftExtent, epsilonSppfNode!!.rightExtent, state.nonterminal
-            )
-        }
-        checkAcceptance(sppfNode, leftExtent, rightExtent, state.nonterminal)
+//
+//        if (state.isStart && state.isFinal) {
+//            checkAcceptance(
+//                epsilonSppfNode, epsilonSppfNode!!.leftExtent, epsilonSppfNode!!.rightExtent, state.nonterminal
+//            )
+//        }
+//      checkAcceptance(sppfNode, leftExtent, rightExtent, state.nonterminal)
 
         engine.handleEdges(this, descriptor, sppfNode)
     }

diff --git a/solver/src/main/kotlin/org/ucfs/parser/IGll.kt b/solver/src/main/kotlin/org/ucfs/parser/IGll.kt
@@ -32,7 +32,7 @@ interface IGll<VertexType, LabelType : ILabel> {
         // Continue parsing until all default descriptors processed
         var curDescriptor = ctx.nextDescriptorToHandle()
         while (curDescriptor != null) {
-            parse(curDescriptor)
+            handleDescriptor(curDescriptor)
             curDescriptor = ctx.nextDescriptorToHandle()
         }
 
@@ -43,7 +43,7 @@ interface IGll<VertexType, LabelType : ILabel> {
      * Processes descriptor
      * @param descriptor - descriptor to process
      */
-    fun parse(descriptor: Descriptor<VertexType>)
+    fun handleDescriptor(descriptor: Descriptor<VertexType>)
 
     /**
      * Creates descriptors for all starting vertices in input graph
@@ -104,7 +104,10 @@ interface IGll<VertexType, LabelType : ILabel> {
             if (ctx.poppedGssNodes.containsKey(newNode)) {
                 for (popped in ctx.poppedGssNodes[newNode]!!) {
                     val descriptor = Descriptor(
-                        rsmState, gssNode, ctx.sppf.getParentNodeAfterTerminal(rsmState, sppfNode, popped!!), popped.rightExtent
+                        rsmState,
+                        gssNode,
+                        ctx.sppf.getOrCreateIntermediateNode(rsmState, sppfNode, popped!!),
+                        popped.rightExtent
                     )
                     addDescriptor(descriptor)
                 }
@@ -126,21 +129,26 @@ interface IGll<VertexType, LabelType : ILabel> {
      * Iterates over all outgoing edges from current gssNode, collects derivation trees, stored on edges and
      * combines them with current derivation tree, given as sppfNode
      * @param gssNode - current node in top layer of Graph Structured Stack
-     * @param sppfNode - derivation tree, corresponding to parsed portion of input
+     * @param sppfNode - derivation tree, corresponding to parsed portion of input for current nonterminal
      * @param inputPosition - vertex in input graph
      */
-    fun pop(gssNode: GssNode<VertexType>, sppfNode: SppfNode<VertexType>?, inputPosition: VertexType) {
-        if (!ctx.poppedGssNodes.containsKey(gssNode)) ctx.poppedGssNodes[gssNode] = HashSet()
+    fun pop(gssNode: GssNode<VertexType>, sppfNode: SppfNode<VertexType>, inputPosition: VertexType) {
+        if (!ctx.poppedGssNodes.containsKey(gssNode)) {
+            ctx.poppedGssNodes[gssNode] = HashSet()
+        }
         ctx.poppedGssNodes.getValue(gssNode).add(sppfNode)
 
-        for ((label, target) in gssNode.edges) {
-            for (node in target) {
-                val descriptor = Descriptor(
-                    label.first, node, ctx.sppf.getParentNodeAfterTerminal(label.first, label.second, sppfNode!!), inputPosition
-                )
-                addDescriptor(descriptor)
-            }
+        val symbolSppfNode = ctx.sppf.getOrCreateSymbolSppfNode(gssNode.nonterminal, sppfNode)
+
+        for ((label, node) in gssNode.edges) {
+            val (rsmTo, leftSppf) = label
+            val descriptor = Descriptor(
+                rsmTo, node, ctx.sppf.getOrCreateIntermediateNode(rsmTo, leftSppf, symbolSppfNode), inputPosition
+            )
+            addDescriptor(descriptor)
         }
+
+        checkAcceptance(symbolSppfNode)
     }
 
     /**
@@ -151,19 +159,18 @@ interface IGll<VertexType, LabelType : ILabel> {
      * @param rightExtent - right limit of the range
      * @param nonterminal - nonterminal, which defines language we check belonging to
      */
-    fun checkAcceptance(
-        sppfNode: SppfNode<VertexType>?, leftExtent: VertexType?, rightExtent: VertexType?, nonterminal: Nonterminal
-    ) {
-        if (sppfNode is SymbolSppfNode<VertexType> && nonterminal == ctx.startState.nonterminal && ctx.input.isStart(
-                leftExtent!!
-            ) && ctx.input.isFinal(rightExtent!!)
+    fun checkAcceptance(sppfNode: SppfNode<VertexType>) {
+        if (sppfNode is SymbolSppfNode<VertexType>
+            && sppfNode.symbol == ctx.startState.nonterminal
+            && ctx.input.isStart(sppfNode.leftExtent)
+            && ctx.input.isFinal(sppfNode.rightExtent)
         ) {
             if (ctx.parseResult == null || ctx.parseResult!!.weight > sppfNode.weight) {
                 ctx.parseResult = sppfNode
             }
 
             //update reachability
-            val pair = Pair(leftExtent, rightExtent)
+            val pair = Pair(sppfNode.leftExtent, sppfNode.rightExtent)
             val distance = ctx.sppf.minDistance(sppfNode)
 
             ctx.reachabilityPairs[pair] = if (ctx.reachabilityPairs.containsKey(pair)) {
@@ -217,7 +224,7 @@ interface IGll<VertexType, LabelType : ILabel> {
         targetWeight: Int,
     ) {
         val terminalNode = ctx.sppf.getOrCreateTerminalSppfNode(terminal, descriptor.inputPosition, targetVertex, targetWeight)
-        val parentNode = ctx.sppf.getParentNodeAfterTerminal(targetState, sppfNode, terminalNode)
+        val parentNode = ctx.sppf.getOrCreateIntermediateNode(targetState, sppfNode, terminalNode)
         val newDescriptor = Descriptor(targetState, descriptor.gssNode, parentNode, targetVertex)
         addDescriptor(newDescriptor)
     }

diff --git a/solver/src/main/kotlin/org/ucfs/parser/context/IContext.kt b/solver/src/main/kotlin/org/ucfs/parser/context/IContext.kt
@@ -73,12 +73,14 @@ interface IContext<VertexType, LabelType : ILabel> {
         val leftExtent = sppfNode?.leftExtent
         val rightExtent = sppfNode?.rightExtent
 
-        if (parseResult == null && sppfNode is SymbolSppfNode<*> && state.nonterminal == startState.nonterminal && input.isStart(
-                leftExtent!!
-            ) && input.isFinal(rightExtent!!)
-        ) {
-            descriptors.removeFromHandled(descriptor)
-        }
+//        if (parseResult == null
+//            && sppfNode is SymbolSppfNode<*>
+//            && state.nonterminal == startState.nonterminal
+//            && input.isStart(leftExtent!!)
+//            && input.isFinal(rightExtent!!)
+//        ) {
+//            descriptors.removeFromHandled(descriptor)
+//        }
         descriptors.addToHandling(descriptor)
     }
 

diff --git a/solver/src/main/kotlin/org/ucfs/sppf/RecoverySppf.kt b/solver/src/main/kotlin/org/ucfs/sppf/RecoverySppf.kt
@@ -18,12 +18,12 @@ class RecoverySppf<VertexType> : Sppf<VertexType>() {
      * @param nextSppfNode - right subtree
      * @return ParentNode, which has combined subtree as alternative derivation
      */
-    override fun getParentNodeAfterTerminal(
+    override fun getOrCreateIntermediateNode(
         rsmState: RsmState,
         sppfNode: SppfNode<VertexType>?,
         nextSppfNode: SppfNode<VertexType>,
     ): SppfNode<VertexType> {
-        val parent = super.getParentNodeAfterTerminal(rsmState, sppfNode, nextSppfNode)
+        val parent = super.getOrCreateIntermediateNode(rsmState, sppfNode, nextSppfNode)
         updateWeights(parent)
         return parent
     }