📄 parser.java
字号:
}
//移动到else里以判断是否是数组 nextSym();
}
while (sym == Symbol.comma);
}
else {
String ss1 = err.report(34); // 格式错误，应是左括号
ss = ss + ss1 + "\n";
}
if (sym == Symbol.rparen) {
nextSym();
}
else {
String ss1 = err.report(33); // 格式错误，应是右括号
ss = ss + ss1 + "\n";
while (!fsys.get(sym)) {
nextSym();
}
}
}
/**
* 分析<赋值语句>
* @param fsys 后跟符号集
* @param lev 当前层次
*/
private void parseAssignStatement(SymSet fsys, int lev) {
int i;
SymSet nxtlev;
i = table.position(lex.id);
if (i > 0) {
Table.Item item = table.get(i);
if (item.kind == Objekt.variable) {
nextSym();
if (sym == Symbol.becomes) {
nextSym();
nxtlev = (SymSet) fsys.clone();
parseExpression(nxtlev, lev);
// parseExpression将产生一系列指令，但最终结果将会保存在栈顶，执行sto命令完成赋值
interp.gen(Fct.STO, lev - item.level, item.adr);
}
else {
if (sym == Symbol.lparen) { // 数组啦...
nextSym();
nxtlev = (SymSet) fsys.clone();
parseExpression(nxtlev, lev);
// parseExpression将产生一系列指令，但最终结果将会保存在栈顶，执行sto命令完成赋值
//在expression最后已经有这个了:nextSym(); //一个)
nextSym(); //一个:=
//后面和var赋值相同,除了最后生成的语句
nextSym();
nxtlev = (SymSet) fsys.clone();
parseExpression(nxtlev, lev);
// parseExpression将产生一系列指令，但最终结果将会保存在栈顶，执行sto命令完成赋值
interp.gen(Fct.STA, lev - item.level,
item.adr);
}
else {
String ss1 = err.report(13); // 没有检测到赋值符号
ss = ss + ss1 + "\n";
}
}
}
else {
String ss1 = err.report(12); // 赋值语句格式错误
ss = ss + ss1 + "\n";
}
}
else {
String ss1 = err.report(11); // 变量未找到
ss = ss + ss1 + "\n";
}
}
/**
* 分析<表达式>
* @param fsys 后跟符号集
* @param lev 当前层次
*/
private void parseExpression(SymSet fsys, int lev) {
Symbol addop;
SymSet nxtlev;
// 分析[+|-]<项>
if (sym == Symbol.plus || sym == Symbol.minus) {
addop = sym;
nextSym();
nxtlev = (SymSet) fsys.clone();
nxtlev.set(Symbol.plus);
nxtlev.set(Symbol.minus);
parseTerm(nxtlev, lev);
if (addop == Symbol.minus) {
interp.gen(Fct.OPR, 0, 1);
}
}
else {
nxtlev = (SymSet) fsys.clone();
nxtlev.set(Symbol.plus);
nxtlev.set(Symbol.minus);
parseTerm(nxtlev, lev);
}
// 分析{<加法运算符><项>}
while (sym == Symbol.plus || sym == Symbol.minus) {
addop = sym;
nextSym();
nxtlev = (SymSet) fsys.clone();
nxtlev.set(Symbol.plus);
nxtlev.set(Symbol.minus);
parseTerm(nxtlev, lev);
if (addop == Symbol.plus) {
interp.gen(Fct.OPR, 0, 2);
}
else {
interp.gen(Fct.OPR, 0, 3);
}
}
}
/**
* 分析<项>
* @param fsys 后跟符号集
* @param lev 当前层次
*/
private void parseTerm(SymSet fsys, int lev) {
Symbol mulop;
SymSet nxtlev;
// 分析<因子>
nxtlev = (SymSet) fsys.clone();
nxtlev.set(Symbol.times);
nxtlev.set(Symbol.slash);
parseFactor(nxtlev, lev);
// 分析{<乘法运算符><因子>}
while (sym == Symbol.times || sym == Symbol.slash) {
mulop = sym;
nextSym();
parseFactor(nxtlev, lev);
if (mulop == Symbol.times) {
interp.gen(Fct.OPR, 0, 4);
}
else {
interp.gen(Fct.OPR, 0, 5);
}
}
}
/**
* 分析<因子>
* @param fsys 后跟符号集
* @param lev 当前层次
*/
private void parseFactor(SymSet fsys, int lev) {
SymSet nxtlev;
test(facbegsys, fsys, 24); // 检测因子的开始符号
// the original while... is problematic: var1(var2+var3)
// thanks to macross
// while(inset(sym, facbegsys))
if (facbegsys.get(sym)) {
if (sym == Symbol.ident) { // 因子为常量或变量
int i = table.position(lex.id);
if (i > 0) {
Table.Item item = table.get(i);
switch (item.kind) {
case constant: // 名字为常量
interp.gen(Fct.LIT, 0, item.val);
nextSym();
break;
case variable: // 名字为变量
//为将nextSym()放入次,将nextSym()放在每个case后
nextSym();
if (sym != Symbol.lparen) { //后面不是'(',是变量
interp.gen(Fct.LOD,
lev - item.level, item.adr);
}
else { //是数组
int ltmp = lev - item.level;
int adrtmp = item.adr;
nextSym();
nxtlev = (SymSet) fsys.clone();
nxtlev.set(Symbol.rparen);
parseExpression(nxtlev, lev);
interp.gen(Fct.LDA, ltmp,
adrtmp);
nextSym(); //nextSym(); //),=
//TODO interp没有修改
}
//nextSym();
break;
case procedure: // 名字为过程
String ss1 = err.report(21); // 不能为过程
ss = ss + ss1 + "\n";
nextSym();
break;
}
}
else {
String ss1 = err.report(11); // 标识符未声明
ss = ss + ss1 + "\n";
}
}
else if (sym == Symbol.number) { // 因子为数
int num = lex.num;
if (num > PL0.amax) {
String ss1 = err.report(31);
ss = ss + ss1 + "\n";
num = 0;
}
interp.gen(Fct.LIT, 0, num);
nextSym();
}
else if (sym == Symbol.lparen) { // 因子为表达式
nextSym();
nxtlev = (SymSet) fsys.clone();
nxtlev.set(Symbol.rparen);
parseExpression(nxtlev, lev);
if (sym == Symbol.rparen) {
nextSym();
}
else {
String ss1 = err.report(22); // 缺少右括号
ss = ss + ss1 + "\n";
}
}
else {
// 做补救措施
test(fsys, facbegsys, 23);
}
}
}
/**
* 分析<条件>
* @param fsys 后跟符号集
* @param lev 当前层次
*/
private void parseCondition(SymSet fsys, int lev) {
Symbol relop;
SymSet nxtlev;
if (sym == Symbol.oddsym) {
// 分析 ODD<表达式>
nextSym();
parseExpression(fsys, lev);
interp.gen(Fct.OPR, 0, 6);
}
else {
// 分析<表达式><关系运算符><表达式>
nxtlev = (SymSet) fsys.clone();
nxtlev.set(Symbol.eql);
nxtlev.set(Symbol.neq);
nxtlev.set(Symbol.lss);
nxtlev.set(Symbol.leq);
nxtlev.set(Symbol.gtr);
nxtlev.set(Symbol.geq);
parseExpression(nxtlev, lev);
if (sym == Symbol.eql || sym == Symbol.neq
|| sym == Symbol.lss || sym == Symbol.leq
|| sym == Symbol.gtr || sym == Symbol.geq) {
relop = sym;
nextSym();
parseExpression(fsys, lev);
switch (relop) {
case eql:
interp.gen(Fct.OPR, 0, 8);
break;
case neq:
interp.gen(Fct.OPR, 0, 9);
break;
case lss:
interp.gen(Fct.OPR, 0, 10);
break;
case geq:
interp.gen(Fct.OPR, 0, 11);
break;
case gtr:
interp.gen(Fct.OPR, 0, 12);
break;
case leq:
interp.gen(Fct.OPR, 0, 13);
break;
}
}
else {
String ss1 = err.report(20);
ss = ss + ss1 + "\n";
}
}
}
public String ret() {
return ss;
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -