能够识别出语法错误,并自动预测修正方案,采用填补法,将修正方案填补到输入代码中继续语法分析。其中预测修正方案是依据action表中当前行的可接受的终结符进行预测。如果无法预测时,即填补法无法修正时,那么会抛出所有已经预测解决的错误,如果填补法顺利预测,那么会在编译结束时提示用户编译时的所有错误。
能够生成LR1分析过程中的语法树。在语法分析顺利结束后会实时生成语法树,展示整个规约过程。
项目完整代码位于本人github仓库,欢迎指点。https://github.com/Vanghua/compiler.git
其中保留字表按照字典序排序,在识别关键字和标识符的接收状态中需要判断时标识符还是关键字。每次都要查找关键字表(保留字表),为了提高效率,这里进行排序并采用折半查找(O(logn))。种别码表是为了压缩生成的Token的大小,在生成的Token中内容只保存种别码表中的数字,在语法分析阶段再根据种别码表翻译出具体的词素内容。
// 保留字表,已按照字典序排序,便于折半查找
const reserveWords = [
'auto', 'break', 'case',
'char', 'const', 'continue',
'default', 'do', 'double',
'else', 'enum', 'extern',
'float', 'for', 'goto',
'if', 'int', 'long',
'register', 'return', 'short',
'signed', 'sizeof', 'static',
'struct', 'switch', 'typedef',
'union', 'unsigned', 'void',
'volatile', 'while'
]
// 种别码表
let type = [
['auto', 1], ['break', 2], ['case', 3],
['char', 4], ['const', 5], ['continue', 6],
['default', 7], ['do', 8], ['double', 9],
['else', 10], ['enum', 11], ['extern', 12],
['float', 13], ['for', 14], ['goto', 15],
['if', 16], ['int', 17], ['long', 18],
['register', 19], ['return', 20], ['short', 21],
['signed', 22], ['sizeof', 23], ['static', 24],
['struct', 25], ['switch', 26], ['typedef', 27],
['union', 28], ['unsigned', 29], ['void', 30],
['volatile', 31], ['while', 32], ['-', 33],
['--', 34], ['-=', 35], ['->', 36],
['!', 37], ['!=', 38], ['%', 39],
['%=', 40], ['&', 41], ['&&', 42],
['&=', 43], ['(', 44], [')', 45],
['*', 46], ['*=', 47], [",", 48],
['.', 49], ['/', 50], ['/=', 51],
[':', 52], [';', 53], ['?', 54],
['[', 55], [']', 56], ['^', 57],
['^=', 58], ['{', 59], ['|', 60],
['||', 61], ['|=', 62], ['}', 63],
['~', 64], ['+', 65], ['++', 66],
['+=', 67], ['<', 68], ['<<', 69],
['<<=', 70], ['<=', 71], ['=', 72],
['==', 73], ['>', 74], ['>=', 75],
['>>', 76], ['>>=', 77], ['"', 78],
['注释', 79], ['常数', 80], ['标识符', 81],
["'", 82], ['字符', 83], ['字符串', 84]
]
文件读入考虑大文件编译时可能的效率问题,采用两个缓冲区读入目标文件,保证每次能够读取一个完整的词素。双缓冲实现的核心部分在下面的read函数,read函数为词法分析函数提供接口,每次依据DFA分析32位缓冲区满时都会调用read函数将内容读入下一个缓冲区,两个缓冲区交替读取数据。在实现过程中要注意读取中文的问题,因为代码中可能有中文注释。read函数返回给词法分析函数一个长度为32的数组,每个元素都占一个字节。易错点是这里不能是每个英文字符或中文字符,英文字符是占一个字节,但是中文字符在Unicode编码下长度不止一个字节。
function open(fileName) {
return new Promise((res, rej) => {
fs.open(fileName, "r", function(err, fd) {
if(err)
rej(err)
res(fd)
})
})
}
function read(fd) {
return new Promise((res, rej) => {
fs.read(fd, readBuffer, 0,32, position, function(err,bytesRead, buffer) {
if(err)
rej("读取文件出错")
position += 32
let len = buffer.length, cString = []
// 注意把buffer缓冲区处理成字符数组的处理方式,在unicode的utf8下,英文占一个字节,中文占3个字节。
// 如果使用buffer.toString().split("")那么中文对应的三个字节会被加载成一个字符放入字符数组cString,这不是我们期望的,这样字符数组的长度达不到32。
// 在这里我们手动处理buffer缓冲区,把每8位即1字节转化成unicode字符,这样转化成的unicode字符实际上是乱码,不在82位C语言种别码表中。
// C语言不允许中文命名变量,对于注释,词法分析器需要略过。使用上述方法可以保证正确略过,否则长度错误的字符数组会导致很多难以理解的错误。
for(let i = 0; i < len; i ++)
cString.push(String.fromCharCode(buffer[i]))
if(bytesRead < 32)
cString[bytesRead] = "eof"
res(cString)
})
})
}
本项目中的DFA比较大,总共有77个状态,不便展示。下面列举出依据DFA识别词素的关键函数。
// 根据当前字符更新当前词素尾指针的行列信息
function updateRowCol(c) {
// 记录上一个col
lastCol = col
// 如果当前字符不是换行,那么列数加1。
if(c !== "\n")
col++
// 如果当前字符是换行,那么行数加1,列数置为0
if(c == "\n")
row ++, col = 0
return c
}
// 当词素被缓冲区截断时需要将后续内容读入另一个缓冲区
async function reRead() {
// 将后续内容读入空闲缓冲区
if(nowBuffer == buffer) {
reserveBuffer = await read(file)
nowBuffer = reserveBuffer
} else {
buffer = await read(file)
nowBuffer = buffer
}
// 词素尾指针为0,指向新缓冲区的第一个字符。更新尾指针在当前缓冲区中
forward = 0
forwardPos = nowBuffer
}
// 带有尾指针后退的状态回退操作,此时尾指针多读了一位需要回退
// 虽然JavaScript中不能传递基本类型的引用,在work函数外修改这些变量不会作用到work函数中,但是可以把值传给函数然后修改过后把值再传递回来
function retract(c, tokenType) {
// 当前标识符已经识别完,回退到初始状态
state = 0
// 尾指针多读了一位,当读入非字母数字下划线时会进入状态2,此时尾指针是当前读入的非字母数字下划线的下一位,同时记录的列也要随之减1
forward -= 1
col -= 1
// 生成当前标识符对应的token
getToken(tokenType)
// 查看当前代码是否读完,这样的检查仅用于多读了一位后的回退,如果当前接收状态不是由other字符到达的那么就不需要下面的eof检查
let isFinished = false
if(c == "eof")
isFinished = true
// 如果代码没有读完,那么令词素首指针和尾指针到达相同位置,开始新的词素识别
lex_begin = forward
// 如果两个指针不在同一个缓冲区内,那么把首指针放入尾指针所在缓冲区
if(beginPos != forwardPos)
beginPos = forwardPos
return isFinished
}
// 不带有尾指针后退的状态回退操作,此时的接收状态不是由other字符到达的
function back(tokenType) {
// 回退到初始状态
state = 0
// 生成当前标识符对应的token
getToken(tokenType)
// 如果代码没有读完,那么令词素首指针和尾指针到达相同位置,开始新的词素识别
lex_begin = forward
// 如果两个指针不在同一个缓冲区内,那么把首指针放入尾指针所在缓冲区
if(beginPos != forwardPos)
beginPos = forwardPos
}
// 不带有尾指针后退的状态回退操作,专门针对不需要生成token的词素,例如注释
function noTokenBack() {
// 回退到初始状态
state = 0
// 如果代码没有读完,那么令词素首指针和尾指针到达相同位置,开始新的词素识别
lex_begin = forward
// 如果两个指针不在同一个缓冲区内,那么把首指针放入尾指针所在缓冲区
if(beginPos != forwardPos)
beginPos = forwardPos
}
(下面只展示到初始状态到其它状态的跳转,共有77个状态,几百行代码不方便展示)
async function work() {
// 初始化当前缓冲区nowBuffer内容,正在使用的缓冲区buffer内容,更新首尾指针当前所在缓冲区
beginPos = forwardPos = nowBuffer = buffer = await read(file)
let c, isFinished = false
while(1) {
// 如果全部扫描完毕,那么退出词法分析,输出词集
if(isFinished)
return tokens
switch (state) {
case 0: // 初态
c = await nextChar()
// 如果当前读到了eof,那么说明文件已读完
if(c == "eof")
isFinished = true
// 如果字符时空格回车或者换行或者水平制表符,那么继续扫描下一个字符
if(utils.judBlank(c) || utils.judEnter(c) || utils.judNewLine(c) || utils.judTab(c)) {
++ lex_begin
// 除了词素尾指针在扫描词素字符时可能越过当前缓冲区,还有一种情况是词素首指针和尾指针相等,
// 两者一直在扫描空格换行和回车,此时两者共同越过缓冲区
// 当尾指针的位置是缓冲区大小加1,说明已经越过缓冲区一位,此时尾指针刚好在nextChar中被放置到新的缓冲区中,于是此时更新词素首指针的位置
if(lex_begin == nowBuffer.length + 1) {
lex_begin = 1
beginPos = forwardPos
}
}
// 如果是字母或者下划线开头,那么是标识符或保留字
else if(utils.judAlphabet(c) || utils.jud_(c))
state = 1
// 如果是数字开头,那么是常数
else if(utils.judNumber(c))
state = 3
// 其他情况由选择函数处理
else
state = utils.stateSelect(c)
break
// 这里只展示到初始状态到其它状态的跳转
下面文法的设计参考了C语言官网ISO C89标准给出的文法,由于该标准注明该文法只适用于理解C语言,不适合LR,LL型的语法分析。因此本人结合该文法,自己设计了以下的C语言文法的子集。
// C语言文法
let statement = [
// 语句
["statement", [";"]], // 语句可以为空
["statement", ["exp", ";"]],
["statement", ["onlyIfChoice"]],
["statement", ["ifElseIfChoice"]],
["statement", ["ifElseChoice"]],
["statement", ["loopStatement"]],
// 表达式
["exp", ["declaration"]],
["exp", ["assignment"]],
["exp", ["calStatement"]],
["exp", ["cpStatement"]],
// 声明语句
["declaration", ["basicDeclaration"]], // 赋值或不赋值的基本类型声明语句
["declaration", ["structDeclaration"]], // 赋值或者不赋值的结构体声明语句
["declaration", ["primaryFunctionDeclaration"]], // 不带赋值的函数声明语句
// 基本类型声明语句
["basicDeclaration", ["primaryType", "identifier_list"]],
["primaryType", ["char"]],
["primaryType", ["int"]],
["primaryType", ["const", "int"]],
["primaryType", ["long"]],
["primaryType", ["const", "long"]],
["primaryType", ["short"]],
["primaryType", ["const", "short"]],
["primaryType", ["unsigned"]],
["primaryType", ["float"]],
["primaryType", ["const", "float"]],
["primaryType", ["double"]],
["primaryType", ["const", "double"]],
["identifier_list", ["identifier"]], // <标识符列表> => <标识符>
["identifier_list", ["assignment"]], // <标识符列表> => <赋值语句>
["identifier_list", ["identifier", ",", "identifier_list"]], // <标识符列表> => <标识符><,><标识符列表>
["identifier_list", ["assignment", ",", "identifier_list"]], // <标识符列表> => <标识符><,><标识符列表>
// 多条声明语句
["multiDeclaration", ["declaration", ";"]], // 多条基本类型声明语句可以推出一条声明语句
["multiDeclaration", ["multiDeclaration", "declaration", ";"]], // 多条基本类型声明语句可以推出多条声明语句
// 函数声明语句
// 无赋值的函数声明语句
["primaryFunctionDeclaration", ["primaryType", "identifier", "(", "declaration_list", ")"]],
["primaryFunctionDeclaration", ["void", "identifier", "(", "declaration_list", ")"]],
["primaryFunctionDeclaration", ["primaryType", "identifier", "(", ")"]],
["primaryFunctionDeclaration", ["void", "identifier", "(", ")"]],
// 函数声明时的参数列表
["declaration_list", ["primaryType", "identifier"]],
["declaration_list", ["primaryType", "identifier", "declaration_list", ","]],
// 赋值的函数声明语句
["valueFunctionDeclaration", ["primaryFunctionDeclaration", "{", "multiStatement", "}"]], // 带有赋值的函数声明特殊,不需要;结尾
// 基本类型赋值语句
["assignment", ["identifier", "=", "identifier"]], // 变量赋值给另一个变量
["assignment", ["identifier", "=", "constant"]], // 常数赋给一个变量
["assignment", ["identifier", "=", "character"]], // 字符赋给一个变量
["assignment", ["identifier", "=", "string"]], // 字符串赋给一个变量
["assignment", ["identifier", "=", "identifier", "+", "identifier"]], // 假的
["assignment", ["identifier", "=", "identifier", "assignment"]],
["assignment", ["identifier", "=", "constant", "assignment"]],
["assignment", ["identifier", "=", "character", "assignment"]],
["assignment", ["identifier", "=", "string", "assignment"]],
["assignment", ["identifier", "+=", "identifier"]],
["assignment", ["identifier", "-=", "identifier"]],
["assignment", ["identifier", "*=", "identifier"]],
["assignment", ["identifier", "/=", "identifier"]],
["assignment", ["identifier", "%=", "identifier"]],
["assignment", ["identifier", "+=", "constant"]],
["assignment", ["identifier", "-=", "constant"]],
["assignment", ["identifier", "*=", "constant"]],
["assignment", ["identifier", "/=", "constant"]],
["assignment", ["identifier", "%=", "constant"]],
["assignment", ["identifier", "+=", "character"]],
["assignment", ["identifier", "-=", "character"]],
["assignment", ["identifier", "*=", "character"]],
["assignment", ["identifier", "/=", "character"]],
["assignment", ["identifier", "%=", "character"]],
// 运算语句
["calChar", ["identifier"]],
["calChar", ["constant"]],
["calStatement", ["calChar", "+", "calChar"]],
["calStatement", ["calChar", "++"]],
["calStatement", ["calChar", "--"]],
["calStatement", ["calChar", "*", "calChar"]],
["calStatement", ["calChar", "/", "calChar"]],
["calStatement", ["calChar", "%", "calChar"]],
// 比较语句
["cpStatement", ["calChar", "<", "calChar"]],
["cpStatement", ["calChar", "<=", "calChar"]],
["cpStatement", ["calChar", ">", "calChar"]],
["cpStatement", ["calChar", ">=", "calChar"]],
["cpStatement", ["calChar", "==", "calChar"]],
// 选择语句
["onlyIfChoice", ["if", "(", "exp", ")", "block"]], // <仅含有单个if的选择语句> => <终结符"("><语句><终结符")"><语句块>
["ifElseIfChoice", ["onlyIfChoice"]], // if,elseif语句可以只是if语句
["ifElseIfChoice", ["onlyIfChoice", "else", "ifElseIfChoice"]], // if,elseif语句可以是if+else+多条ifElse语句组成
["ifElseChoice", ["onlyIfChoice", "else", "block"]], // if,else语句可以只是if语句
// 循环语句
["loopStatement", ["for", "(", "declaration", ";", "cpStatement", ";", "calStatement", ")", "block"]],
["loopStatement", ["while", "(", "cpStatement", ")", "block"]],
// 代码块
["block", ["statement"]], // 代码块可以是一条不被大括号包围的语句
["block", ["{", "statement", "}"]], // 代码块可以是多条语句
// 多条语句
["multiStatement", ["statement"]], // 多条语句可以是一条语句
["multiStatement", ["statement", "multiStatement"]], // 多条语句可以由多个一条语句组成
// 程序入口
["program", ["valueFunctionDeclaration"]], // 可以是带有赋值的函数声明
]
// 终结符
let Vt = [
'auto', 'break', 'case',
'char', 'const', 'continue',
'default', 'do', 'double',
'else', 'enum', 'extern',
'float', 'for', 'goto',
'if', 'int', 'long',
'register', 'return', 'short',
'signed', 'sizeof', 'static',
'struct', 'switch', 'typedef',
'union', 'unsigned', 'void',
'volatile', 'while', '-',
'--', '-=', '->',
'!', '!=', '%',
'%=', '&', '&&',
'&=', '(', ')',
'*', '*=', ',',
'.', '/', '/=',
':', ';', '?',
'[', ']', '^',
'^=', '{', '}',
'|', '||', '|=',
'~', '+', '++',
'+=', '<', '<<',
'<<=', '<=', '=',
'==', '>', '>=',
'>>', '>>=', '"',
'constant', 'identifier', "'",
'character','string', '\x00'
]
// 非终结符
let Vs = [
'statement', 'allTypeStatement', 'declaration',
'primaryType', 'identifier_list', 'assignment',
'assignment_list', 'assignment_type', 'onlyIfChoice',
'ifElseIfChoice', 'ifElseChoice', 'block',
'multiStatement', 'basicDeclaration', 'program',
'multiDeclaration', 'primaryFunctionDeclaration', 'valueFunctionDeclaration',
'declaration_list', 'program', 'multiFunction',
'exp', 'calStatement', 'calChar',
'cpStatement', 'loopStatement'
]
在这里要考虑一下,本计划手动计算出action表和goto表,在词法分析阶段,一边分析一边局部建立DFA,但是由于上述文法比较多,action表和goto表的手动计算不太现实,因此先编写自动生成action表和goto表的代码。(注:下面只给出核心函数,其中会调用一些功能函数,具体调用比较多,可以到github查看源代码)
// 计算向前搜索符函数
function getForward(p, nextCharPos, G) {
let rightExp = p[1], len = rightExp.length, rest = [], forward = [...p[2]]
if(nextCharPos == len - 1) {
// 如果该非终结符在产生式末尾,那么rest为”当前项目的向前搜索符“
loop: for(let i = 0; i < p[2].length; i ++) {
rest = [p[2][i]]
let firstSet = new Set()
getFirst(rest, firstSet, [], G)
firstSet = [...firstSet];
// firstSet求出来一定是数组,规定如果含有空时,getFirst返回["\0"],即["\x00"]。此时按照LR1向前搜索符要求,应为#
// 注意:是含有空而不是只有空。只要firstSet中含有\x00时都应该对其处理
if(firstSet.indexOf("\x00") != -1)
firstSet.splice(firstSet.indexOf("\x00"), 1, "#")
// 把求出的first集作为可能的向前搜索符加入向前搜索符集合中,注意可能求出相同向前搜索符,应满足集合性质
forward = new Set([...forward, ...firstSet])
forward = [...forward]
}
} else {
// 如果该非终结符不在产生式末尾,那么rest为“该非终结符后面的符号串”再加上“当前项目的向前搜索符”
rest = rightExp.slice(nextCharPos + 1)
for(let i = 0; i < p[2].length; i ++) {
rest.push(p[2][i])
let firstSet = new Set()
getFirst(rest, firstSet, [], G)
firstSet = [...firstSet];
rest.pop()
if(firstSet.indexOf("\x00") != -1)
firstSet.splice(firstSet.indexOf("\x00"), 1, "#")
forward = new Set([...forward, ...firstSet])
forward = [...forward]
}
}
return forward
}
// LR1分析中的求项目集空闭包函数
function getClosure(I, G) {
for(let p of I) {
// rightExp表示产生式右侧,pos表示·在表达式右侧的位置,len表示表达式右侧的长度
let rightExp = p[1], pos = rightExp.indexOf("·"), len = rightExp.length
if(pos != len - 1) {
// 当·不在产生式末尾时做如下处理
// nextChar表示·后面下一个符号,isInVs表示该符号是否是非终结符,nextCharPos表示当前非终结符在产生式右侧的位置
let nextChar = rightExp[pos + 1], isInVs = G.Vs.indexOf(nextChar) == -1 ? false : true, nextCharPos = pos + 1
if(isInVs) {
// 如果是非终结符,需要添加新的项目,在添加新项目前,先找到其向前搜索符
// 计算向前搜索符集合
let forward = getForward(p, nextCharPos, G)
// 如果是非终结符,那么需要在该项目集中添加新的项目
loop: for(let pp of G.expand) {
// LExp表示产生式左侧,RExp表示产生式右侧
let LExp = pp[0], RExp = pp[1]
if(LExp == nextChar && RExp[0] == "·") {
let newExp = [...pp, forward]
// hasFindSame表示newExp是否在I项目集中找到相同的产生式。
let hasFindSame = update(I, newExp, G.Vs, [], G)
if(hasFindSame)
continue loop
// 如果存在一个项目产生式,左侧是当前非终结符,且右侧第一个符号是项目符号。那么将其加入当前项目集,其向前搜索符上述代码已求解
I.push(newExp)
}
}
}
}
}
return I
}
// LR1分析中的项目集转换GO函数
// cnt表示当前项目集的编号,从0开始编号
function go(I, ISet, G, nodes) {
// allNext表示在当前项目集下,按·后面的字符对产生式进行分类的映射,每一个映射都会转移到下一个项目集
let allINext = new Map()
for(let p of I) {
let rightExp = p[1], pos = rightExp.indexOf("·"), len = rightExp.length, leftExp = p[0], forward = p[2]
if(pos == len - 1)
continue
// char表示·后面的字符
let char = rightExp[pos + 1]
// 对rightExp浅拷贝,后续要让·后移一位,不能影响文法
let nextExp = [...rightExp]
// 实现项目符号后移一个字符(现在下一个字符后面添加项目符号,之后删除原项目符号)
nextExp.splice(pos + 2, 0, "·")
nextExp.splice(pos, 1)
// 向映射中添加分类的项目集
if(!allINext.get(char))
allINext.set(char, [])
let items = allINext.get(char)
items.push([leftExp, nextExp, forward])
allINext.set(char ,items)
}
// 对allINext中分好类的项目产生式集求空闭包
allINext.forEach((item, char) => {
// I表示一个映射中的项目集,char表示一个映射中的字符
let INext = getClosure(item, G)
// 判断该项目集是否在总项目集中存在
let isExist = judSameItem(ISet, INext)
// 如果I不存在那么在邻接表顶点中添加
if(!nodes[toString(I)])
nodes[toString(I)] = new Nodes(I, [])
// 如果INext不存在那么在邻接表顶点中添加
if(!nodes[toString(INext)])
nodes[toString(INext)] = new Nodes(INext, [])
// 添加一条I到INext的边
nodes[toString(I)].firstEdge.push(new Edges(char, INext, []))
if(!isExist) {
// 如果该项目在项目集中不存在,那么在总项目集种添加它,并求它能转换到的新状态
ISet.push(INext)
go(INext, ISet, G, nodes)
}
})
}
// 求某个串货非终结符的first集函数
function getFirst(symbols, result, vis, G) {
// 遍历待求串
let len = symbols.length
for(let i = 0; i < len; i ++) {
// isVt用于判断当前字符是否是终结符
let s = symbols[i], isVt = G.Vt.indexOf(s) == -1 ? false : true
if(isVt)
// 如果是终结符,则可说明其一定属于该串的first集(当然并非该串的所有终结符都会被加入,下面有提前退出条件)
result.add(s)
else if(!isVt && !vis[s]) {
// 如果是非终结符且没有被求过first集,则计算first集。求过first集的不再重复计算,避免循环左递归
for(let p of G.P)
if(p[0] == s) {
vis[s] = true
getFirst(p[1], result, vis, G)
vis[s] = false
}
}
// 从result中弹出空串,用"\0"表示空串
// 这表示只有在当前字符是当前串的最后一个字符且能推导出空串时,空串才属于first集合。如果串中某一个非终结符不是最后一个字符,且能推出空串,那么空串不属于first集
if(result[result.length - 1] == "\0")
result.delete("\0")
// isNull表示是否能够推导出空串
let isNull = nullable([s], [], G)
if(!isNull)
// 如果当前字符不能推导出空串,那么该串的first集已求出,即为result
// 当前字符可能是终结符,也可能是不能多步推导出空串的非终结符
break
else if(isNull && i == len - 1)
// 只有在当前字符是当前串的最后一个字符且能推导出空串时,空串才属于first集合
result.add("\0")
}
}
let char = input[charPos]
// 如果当前指针所指输入串位置的符号不为终结符#,那么令当前符号和当前栈顶状态进行分析
let state = getTop(stateStack)
let col = action[0].indexOf(char), act = action[state + 1][col]
if(!act) {
// 如果找不到,那么交给错误处理程序处理。错误处理程序能够预测错误的修复方案并修复,从而进行后续的编译
// return handleError(...)是老版本的错误处理,遇到错误直接抛出,并对当前错误做出预测
// return handleError(tokens[charPos - 1], state, action)
// fixedChar表示错误处理程序预测的修补符号。每次遇到错误时都会做出预测尽量弥补,直到预测结果为空或编译结束才抛出错误。
let token = tokens[charPos - 1]
let fixedChar = handleError(token, state, action)[0]
// 保存错误信息
errors += throwAnalysisError(token.row, token.col, "语法错误", `${token.content}后不符合C语言语法
`)
// 如果无法预测(即:当前状态只有唯一的接收非终结符时,那么直接抛出错误)
if(!fixedChar)
return new Promise((res, rej) => {
rej(errors)
})
// 将预测的结果填入输入代码,需要修改输入代码和token信息
input.splice(charPos, 0, fixedChar)
let t = new Token()
t.content = fixedChar
tokens.splice(charPos, 0, t)
}
function handleError(token, state, action) {
// fix为预测的修复方案,res为实际要填充的内容
let fix = [], res = []
for(let i = 1; i < action[0].length; i ++) {
let act = action[state + 1][i]
if(act) {
if(act[0]) {
let Vt = action[0][i]
if (Vt != "#" && Vt != "\x00")
fix.push(Vt)
}
}
}
fix.forEach(el => {
switch(el) {
case "constant":
// 如果需要填补数值,那么填补0
res.push(0)
break
case "identifier":
// 如果需要填补标识符,那么填补一个未声明的标识符
res.push("undefined_identifier")
break
case "character":
// 如果需要填补字符,那么填补一个空字符
res.push("\x00")
break
case "string":
// 如果需要填补字符串,那么填补一个空字符串
res.push("\x00")
break
default:
// 其它情况直接进行填补就行
res.push(el)
}
})
// output为原来抛出错误版本中显示错误内容的字符串,在当前版本下可以用来debug
// let output = throwAnalysisError(token.row, token.col, "语法错误", `${token.content}后不符合C语言语法
`)
// output += "建议填补以下符号 " + fix.join(",")
// return new Promise((res, rej) => {
// rej(output)
// })
// 如果预测结果为空,res数组第一个预测结果设置为null,用于外界判断预测结果。
if(!res.length)
res.push(null)
return res
}