编译原理实验-自上而下语法分析-2 预测分析法

有头发的琦玉

已于 2023-12-04 16:37:29 修改

阅读量302

点赞数

分类专栏：编译原理文章标签： kotlin 编译原理计算机软件工程

于 2023-12-04 16:29:59 首次发布

--simon

本文链接：https://blog.csdn.net/qq_38177830/article/details/134787697

版权

编译原理专栏收录该内容

1 篇文章 0 订阅

订阅专栏

用预测分析法（表驱动）分析文法 G 的正确句子和错误句子

不如直接给一个例子，根据例子了解预测分析法的分析过程

产生式和它的SELECT集

对应的预测分析表

分析过程

代码实现

好久没写Kotlin了，正好复习Kotlin语法

Main.kt

fun main() {
    (
            mutableMapOf(
                "E" infer symStr("T", "E'") select symStr("(", "id"),
                "E'" infer symStr("+", "T", "E'") select symStr("+"),
                "E'" infer symStr("ε") select symStr("#", ")"),
                "T" infer symStr("F", "T'") select symStr("(", "id"),
                "T'" infer symStr("*", "F", "T'") select symStr("*"),
                "T'" infer symStr("ε") select symStr("+", "#", ")"),
                "F" infer symStr("(", "E", ")") select symStr("("),
                "F" infer symStr("id") select symStr("id"),
            )
                    fuck mkGrammar("E".also { print("开始符$it\n待分析串") })
            ).analyze(symStr("id", "+", "id", "*", "id", "#").also(::println))
        { symbolStr, grammar, stack ->
            val mutableSymbolStr = symbolStr.toMutableList()
            println("序号" + "\t".repeat(2) + "符号栈" + "\t".repeat(6) + "输入串" + "\t".repeat(6) + "所用产生式")
            stack.repeatWhile({ it.isNotEmpty() }) { _, index ->
                val peek = stack.peek()
                val currentSymbol = mutableSymbolStr[0]
                var findProduct: Product? = null

                println(
                    "$index" + "\t".repeat(2)  + "$stack" + "\t".repeat(8 - stack.size) + "$mutableSymbolStr" + "\t".repeat(8 - mutableSymbolStr.size) +
                            when {
                                peek != currentSymbol -> {
                                    // 如果不可以匹配，则找表达式
                                    findProduct = grammar.findProduct(peek, currentSymbol)
                                    findProduct
                                }

                                else -> {
                                    // 如果可以匹配，则栈和串同时去掉一位
                                    mutableSymbolStr.removeAt(0)
                                    "“$currentSymbol”匹配"
                                }
                            }
                )

                stack.pop()
                findProduct?.apply {
                    right.takeIf { right[0] != "ε" }?.let {
                        it.reversed().forEach { sym ->
                            stack.push(sym)
                        }
                    }
                }

            }

        }
}

SimonGrammar.kt

import java.util.*

typealias Symbol = String // 符号
typealias SymbolStr = List<String> // 符号串

fun symStr(vararg elements: Symbol) = elements.asList() // 快速将多个符号组成符号串

data class Product(val left: Symbol, val right: SymbolStr) {
    override fun toString(): String {
        return "$left->$right"
    }
} // 产生式

infix fun Symbol.infer(right: SymbolStr) = Product(this, right) // 生成一个产生式

data class SimonGrammar(val startSymbol: Symbol) {
    val selectMap: MutableMap<Product, SymbolStr> = mutableMapOf()
}

fun mkGrammar(startSymbol: String) = SimonGrammar(startSymbol)

infix fun <R> Product.select(that: R): Pair<Product, R> {
    return Pair(this, that)
}

infix fun MutableMap<Product, SymbolStr>.fuck(target: SimonGrammar): SimonGrammar {
    target.selectMap.putAll(this)
    return target
}

fun SimonGrammar.analyze(symbolStr: SymbolStr, block: (SymbolStr, SimonGrammar, Stack<Symbol>) -> Unit) {
    val stack = Stack<Symbol>()
    stack.push("#") // 结束符入栈
    stack.push(this.startSymbol)  // 开始符入栈
    block.invoke(symbolStr, this, stack)
}

fun <T> Stack<T>.repeatWhile(condition: (Stack<T>) -> Boolean, action: (Stack<T>, index: Int) -> Unit) {
    var index = 0
    while (condition.invoke(this)) {
        action.invoke(this, ++index)
    }
}

fun SimonGrammar.findProduct(left: Symbol, target: Symbol): Product? {
    // 如果values中包含了target，那就判断该values对应的产生式的左部是不是你要的
    return this.selectMap.filter {
        it.value.contains(target) && it.key.left == left
    }.map {
        it.key
    }.firstOrNull()
}