Refactor GLL algorithm

Author: bachish

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)
   }
 

generator/build.gradle.kts

@@ -9,6 +9,7 @@ repositories {
 dependencies {
     implementation(project(":solver"))
     implementation("com.squareup:kotlinpoet:1.16.0")
+    testImplementation(kotlin("test"))
 }
 
 tasks.test {

generator/src/main/kotlin/org/ucfs/ast/AstExtractor.kt

@@ -1,76 +0,0 @@
-package org.ucfs.ast
-
-import org.ucfs.GeneratorException
-import org.ucfs.rsm.symbol.Nonterminal
-import org.ucfs.sppf.node.*
-
-class AstExtractor(val pkg: String) {
-    val nonterminalToClass = HashMap<Nonterminal, Class<*>>()
-
-    /**
-     * need to handle "many" in rules (many can make cycles in sppf)
-     */
-    val used = HashSet<PackedSppfNode<*>>()
-    fun extract(sppf: ISppfNode?): Node {
-        val root = Node(null, 0)
-        extract(sppf, root, null)
-        return root.children.firstOrNull() ?: root
-    }
-
-    private fun getOffset(left: Node?, parent: Node): Int {
-        return if (left == null) {
-            parent.offset
-        } else {
-            left.offset + left.length
-        }
-    }
-
-    /**
-     * return rightest node of subtree
-     */
-    private fun extract(sppf: ISppfNode?, parent: Node, left: Node?): Node? {
-        when (sppf) {
-            is PackedSppfNode<*> -> {
-                val newLeft = extract(sppf.leftSppfNode, parent, left)
-                return extract(sppf.rightSppfNode, parent, newLeft)
-            }
-
-            is IntermediateSppfNode<*> -> {
-                return extract(sppf.children.firstOrNull(), parent, left)
-            }
-
-            is SymbolSppfNode<*> -> {
-                val nodeClass = getNodeClass(sppf.symbol)
-                val ctor = nodeClass.getConstructor(Node::class.java, Int::class.java)
-
-                val node: Node = ctor.newInstance(parent, getOffset(left, parent)) as Node
-                node.isRecovered = sppf.weight > 0
-                node.left = left
-                parent.children.add(node)
-
-                val packedNode: PackedSppfNode<*> = sppf.children.first { pn -> !used.contains(pn) }
-                used.add(packedNode)
-
-                extract(packedNode, node, null)
-                parent.length += node.length
-                return node
-            }
-
-            is TerminalSppfNode<*> -> {
-                val node = TerminalNode(parent, getOffset(left, parent), sppf.terminal, left)
-                node.isRecovered = sppf.weight > 0
-                parent.children.add(node)
-                parent.length += sppf.terminal.toString().length
-                return node
-            }
-
-            null -> return null
-            else -> throw GeneratorException("Unknown sppf node type : $sppf")
-        }
-    }
-
-    private fun getNodeClass(nt: Nonterminal): Class<*> {
-        return nonterminalToClass.getOrPut(nt)
-        { Class.forName("$pkg.${NodeClassesGenerator.getClassName(nt)}") }
-    }
-}

generator/src/main/kotlin/org/ucfs/examples/Examples.kt

@@ -1,51 +0,0 @@
-package org.ucfs.examples
-
-import org.ucfs.ast.AstExtractor
-import org.ucfs.ast.DotWriter
-import org.ucfs.ast.NodeClassesGenerator
-import org.ucfs.examples.dyck.DyckGrammar
-import org.ucfs.examples.golang.SimpleGolang
-import org.ucfs.grammar.combinator.Grammar
-import org.ucfs.input.LinearInput
-import org.ucfs.parser.Gll
-import org.ucfs.rsm.writeRsmToDot
-import org.ucfs.sppf.writeSppfToDot
-import java.nio.file.Path
-
-
-object Examples {
-    fun generateAst(grammar: Grammar, pkg: String, input: String, name: String) {
-        val grammarClass = grammar::class.java
-        NodeClassesGenerator(grammarClass).generate(Path.of("generator", "src", "main", "kotlin"), pkg)
-        val gll = Gll.gll(grammar.rsm, LinearInput.buildFromString(input))
-        val sppf = gll.parse().first
-        writeSppfToDot(sppf!!, Path.of("${name}.dot").toString(), "${grammarClass.simpleName} SPPF for $input")
-        val ast = AstExtractor(pkg).extract(sppf)
-        val label = "${grammarClass.simpleName} AST for $input"
-        DotWriter().writeToFile(
-            ast,
-            name,
-            label,
-            false
-        )
-        DotWriter().writeToFile(
-            ast,
-            "$name with siblings",
-            label,
-            true
-        )
-
-    }
-}
-
-
-fun main() {
-    writeRsmToDot(DyckGrammar().rsm, "rsm.dot")
-    Examples.generateAst(SimpleGolang(), "org.ucfs.examples.golang", "r 1 + 1 ;", "simple golang")
-    Examples.generateAst(SimpleGolang(), "org.ucfs.examples.golang", "r 1 + 1 ; 1 ; r 1 ;", "simple golang")
-    Examples.generateAst(DyckGrammar(), "org.ucfs.examples.dyck", "[ ( ) ] ", "1_dyck")
-    Examples.generateAst(DyckGrammar(), "org.ucfs.examples.dyck", "[ ( ) ] { }", "2_dyck")
-    Examples.generateAst(DyckGrammar(), "org.ucfs.examples.dyck", "[ ] { } [ ( ) ]", "3_dyck")
-    Examples.generateAst(DyckGrammar(), "org.ucfs.examples.dyck", " [ { } ( ) ] ", "3_dyck")
-    Examples.generateAst(DyckGrammar(), "org.ucfs.examples.dyck", "[ ] { { } ( ) } [ ( ) ]", "3_dyck")
-}