Added method to convert IRProgram to a set of CFG's

Author: RedDocMD

src/main/kotlin/deep/decaf/low/CFG.kt

@@ -1,6 +1,7 @@
 package deep.decaf.low
 
 import deep.decaf.ir.*
+import java.lang.RuntimeException
 import java.util.*
 
 interface CFGNode {
@@ -67,6 +68,7 @@ class ConditionalNode(
 sealed class ConditionalNodeType
 object IfElse : ConditionalNodeType()
 data class For(val id: Int) : ConditionalNodeType()
+data class MethodEnd(val name: String) : ConditionalNodeType()
 
 sealed class JumpNodes(
     override var next: CFGNode?,
@@ -172,6 +174,12 @@ class CFGCreationInfo {
     }
 }
 
+data class CFGProgram(
+    val mainCFG: CFG,
+    val cfgMap: Map<String, CFG>,
+    val declarations: List<IRFieldDeclaration>
+)
+
 fun constructCFG(statement: IRStatement, info: CFGCreationInfo): CFG {
     return when (statement) {
         is IRAssignStatement -> {
@@ -456,6 +464,62 @@ fun constructCFG(block: IRBlock?, info: CFGCreationInfo): CFG? {
     }
 }
 
+fun constructCFG(program: IRProgram): CFGProgram {
+    val methodCFGMap = mutableMapOf<String, CFG>()
+    var mainCFG: CFG? = null
+    for (method in program.methodDeclarations) {
+        val info = CFGCreationInfo()
+        val cfg = constructCFG(method.block, info)
+        if (cfg != null) {
+            // Rewire returns to point to end of method
+            val endMethod = ExitNoOpNode(mutableListOf(cfg.exit), null, MethodEnd(method.name))
+            cfg.exit.next = endMethod
+
+            val visited = mutableMapOf<String, Boolean>()
+            fun dfs(node: CFGNode) {
+                val done = visited[node.uuid] ?: false
+                if (!done) {
+                    visited[node.uuid] = true
+                    if (node is ReturnNode) {
+                        val next = node.next
+                        if (next != null) {
+                            if (next is SingleInput) {
+                                next.prev = null
+                            } else if (next is NoOpNode) {
+                                next.prevs.remove(node)
+                            }
+                        }
+                        node.next = endMethod
+                        endMethod.prevs.add(node)
+                    } else {
+                        if (node is SingleOutput && node.next != null) {
+                            dfs(node.next!!)
+                        } else if (node is ConditionalNode) {
+                            if (node.truePath != null) {
+                                dfs(node.truePath!!)
+                            }
+                            if (node.falsePath != null) {
+                                dfs(node.falsePath!!)
+                            }
+                        }
+                    }
+                }
+            }
+
+            dfs(cfg.entry)
+            methodCFGMap[method.name] = CFG(cfg.entry, endMethod)
+            if (method.name == "main") {
+                mainCFG = cfg
+            }
+        }
+    }
+    if (mainCFG != null) {
+        return CFGProgram(mainCFG, methodCFGMap, program.fieldDeclarations)
+    } else {
+        throw IllegalStateException("semantic checker screwed up")
+    }
+}
+
 private fun cfgNodeLabel(node: CFGNode): String {
     return when (node) {
         is RegularNode -> node.statements.joinToString("\n") { irToString(it) }

src/main/kotlin/deep/decaf/tester/CFGCreationTester.kt

@@ -6,7 +6,7 @@ import deep.decaf.parser.*
 import org.antlr.v4.runtime.*
 import java.io.*
 
-fun main(args: Array<String>) {
+fun main() {
     val folder = File("/home/deep/work/compiler/cfg_test")
     val files = folder.listFiles()!!.filter { !it.isDirectory }.sorted()
     for (file in files) {
@@ -16,24 +16,19 @@ fun main(args: Array<String>) {
         val errors = checkSemantics(irTree)
         if (errors.isNotEmpty())
             throw RuntimeException("Invalid program")
-        val cfgCreationInfo = CFGCreationInfo()
-        for (method in irTree.methodDeclarations) {
-            if (method.name == "main") {
-                val cfg = constructCFG(method.block, cfgCreationInfo)
-                val dotString = dotFileFromCFG(cfg!!)
-                println(dotString)
-                val processBuilder = ProcessBuilder(
-                    listOf("dot", "-Tpdf", "-o", "${file.name}.pdf")
-                )
-                val outDir = File("/home/deep/work/test")
-                processBuilder.directory(outDir)
-                processBuilder.redirectError(File("${outDir.absolutePath}/${file.name}.log"))
-                val process = processBuilder.start()
-                val inputWriter = BufferedWriter(OutputStreamWriter(process.outputStream))
-                inputWriter.write(dotString)
-                inputWriter.flush()
-                inputWriter.close()
-            }
-        }
+        val programCFG = constructCFG(irTree)
+        val dotString = dotFileFromCFG(programCFG.mainCFG)
+        println(dotString)
+        val processBuilder = ProcessBuilder(
+            listOf("dot", "-Tpdf", "-o", "${file.name}.pdf")
+        )
+        val outDir = File("/home/deep/work/test")
+        processBuilder.directory(outDir)
+        processBuilder.redirectError(File("${outDir.absolutePath}/${file.name}.log"))
+        val process = processBuilder.start()
+        val inputWriter = BufferedWriter(OutputStreamWriter(process.outputStream))
+        inputWriter.write(dotString)
+        inputWriter.flush()
+        inputWriter.close()
     }
 }