📄 syntaxanalyze.java
字号:
tokenRightEnd.add(listT.get(1).end);
deep.add(countSpace+1);
syntaxOutput.add(showSpace() + " 数组变量长度: " + length +
" #" + listT.get(3).lineNo);
tokenRightStart.add(listT.get(3).start);
tokenRightEnd.add(listT.get(endBracket-1).end);
deep.add(countSpace+1);
}
//剩余待分析内容
if (endBracket == listT.size()-1) listT.clear();
//数组变量声明正确结束
else if (listT.get(endBracket+1).token.equals(";")) {
if (endBracket+1 == listT.size()-1) listT.clear();
else listT =
new LinkedList<Tokens>(listT.subList(endBracket+2, listT.size()));
}
else listT = new LinkedList<Tokens>(listT.subList(endBracket+1, listT.size()));
}
}
}
//进入后续分析或分析结束并备份剩余待分析内容
if (executeTimes)
matchingAnalyze(listT, arrayTree, true);
else listTT = listT;
}
//检测是否正确的数组值序列
//错误序列以"false"作为返回值
//正确则返回原数据的字符串序列
//具体编码与arithmeticOperation方法编码相同以保证直接调用arithmetic方法
private String arrayData(LinkedList<Tokens> listT) {
//错误：以","结束的序列
if (listT.getLast().token.equals(",")) return "false";
//存储原数据的字符串序列
String str1 = "";
//存储待分析内容
String strT = "";
//存储经过格式转化之后的待分析内容
String str2 = "";
//小括号开、闭的个数
int count1 = 0, count2 = 0;
//中括号开、闭的个数
int count3 = 0, count4 = 0;
//依次编码
for (Tokens value: listT) {
strT += value.token;
//待分析为数字
if (value.type == CMMN) str2+=0;
//待分析为标志符
else if (value.type == CMMI) str2+=1;
//待分析为"+"或"-"
else if (value.token.equals("+") || value.token.equals("-")) str2+=2;
//待分析为"*"或"/"
else if (value.token.equals("*") || value.token.equals("/")) str2+=3;
//待分析为"("
else if (value.token.equals("(")) {
str2+=4;count1++;
}
//待分析为")"
else if (value.token.equals(")")) {
str2+=5;count2++;
}
//待分析为"["
else if (value.token.equals("[")) {
str2+=6;count3++;
}
//待分析为"]"
else if (value.token.equals("]")) {
str2+=7;count4++;
}
//待分析为","
else if (value.token.equals(",")) {
//添加至原数据的字符串序列
str1 += strT;
//括号无法匹配
if (count1!=count2||count3!=count4) {
syntaxWrong();
syntaxWrongOutput.add(" 括号无法匹配 " + strT + " #" + value.lineNo);
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(value.start);
return "false";
}
//对数组值的每一项进行算术表达式的分析
if (!str2.isEmpty() && arithmetic(str2)==false) return "false";
//清空临时内容
strT = "";
str2 = "";
}
//待分析为其他内容
else {
syntaxWrong();
syntaxWrongOutput.add(" 算术表达式含有错误的内容");
tokenErrorStart.add(value.start);
tokenErrorEnd.add(value.start);
return "false";
}
}
//添加至原数据的字符串序列
str1 += strT;
//括号无法匹配
if (count1!=count2||count3!=count4) {
syntaxWrong();
syntaxWrongOutput.add(" 括号无法匹配 " + strT + " #" + listT.getLast().lineNo);
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.getLast().end);
return "false";
}
//对数组值的最后一项进行算术表达式的分析
if (arithmetic(str2)==false) return "false";
return str1;
}
//赋值语句
private void evaluate(LinkedList<Tokens> listT,
DefaultMutableTreeNode assignmentTree, boolean executeTimes) {
//添加子节点
DefaultMutableTreeNode assignmentTreeT = new DefaultMutableTreeNode("赋值语句");
assignmentTree.add(assignmentTreeT);
//格式限制
if (listT.size()>2 && listT.get(1).token.equals("=")){
//添加子节点及输出
assignmentTreeT.add(
new DefaultMutableTreeNode("变量: " + listT.getFirst().token));
syntaxOutput.add(showSpace() + "赋值语句：");
tokenRightStart.add(listT.getFirst().start);
tokenRightEnd.add(listT.getFirst().end);
deep.add(countSpace);
syntaxOutput.add(showSpace() + " 变量: " + listT.getFirst().token +
" #" + listT.getFirst().lineNo);
tokenRightStart.add(listT.getFirst().start);
tokenRightEnd.add(listT.getFirst().end);
deep.add(countSpace + 1);
//使用数组变量值对数组变量赋值
if (listT.get(2).token.equals("{")) {
//长度限制
if (listT.size()<6) {
syntaxWrong();
syntaxWrongOutput.add(" 错误的赋值语句 #" + listT.get(2).lineNo);
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.getLast().end);
listT.clear();
}
else {
//对应大括号结束位置
int endBracket = analyzeBracket(listT,"{", "}", 2);
//错误：不存在对应大括号
if (endBracket == -1){
syntaxWrong();
syntaxWrongOutput.add(" 没有对应括号 #" + listT.get(2).lineNo);
tokenErrorStart.add(listT.get(2).start);
tokenErrorEnd.add(listT.get(2).end);
listT = statementWrong(listT, false);
}
else {
//错误：语句未结束
if (endBracket==listT.size()-1 ||
!listT.get(endBracket+1).token.equals(";")){
syntaxWrong();
syntaxWrongOutput.add(" 语句未结束 #" + listT.getFirst().lineNo);
tokenErrorStart.add(listT.get(endBracket).start);
tokenErrorEnd.add(listT.get(endBracket).end);
}
//用于存储数组变量值(字符串)
String variableValue = "";
//格式限制
if (endBracket == 3)
declareWrong(listT.getFirst());
else
//分析并保存数组变量的值
variableValue =
arrayData(new LinkedList<Tokens>(listT.subList(3, endBracket)));
//数组变量值分析为正确
if (!variableValue.equals("false")) {
//添加子节点及输出
assignmentTreeT.add(
new DefaultMutableTreeNode("变量值: {" + variableValue + "}"));
syntaxOutput.add(showSpace() + " 变量值: {" +
variableValue + "} #" + listT.get(2).lineNo);
tokenRightStart.add(listT.get(2).start);
tokenRightEnd.add(listT.get(endBracket).end);
deep.add(countSpace+1);
}
//错误的数组变量值
else {
declareWrong(listT.get(1));
syntaxWrongOutput.add(" 错误原因 ：错误的初始化");
tokenErrorStart.add(listT.get(2).start);
tokenErrorEnd.add(listT.get(endBracket).end);
}
//剩余待分析部分
if (endBracket == listT.size()-1) listT.clear();
else if (listT.get(endBracket+1).token.equals(";")) {
if (endBracket+1 == listT.size()-1) listT.clear();
else listT =
new LinkedList<Tokens>(listT.subList(endBracket+2, listT.size()));
}
else listT =
new LinkedList<Tokens>(listT.subList(endBracket+1, listT.size()));
}
}
}
//使用算术表达式对变量进行赋值
else {
//赋值语句是否正确结束
boolean assignmentNotEnd = false;
for (int i = 0; i < listT.size(); i++) {
if (listT.get(i).token.equals(";")) {
//赋值语句正确结束
assignmentNotEnd = true;
//对赋值内容进行算术表达式分析,添加需要字节点
if (arithmeticOperation(new LinkedList<Tokens>(listT.subList(2, i)), true, true))
assignmentTreeT.add(new DefaultMutableTreeNode("变量值: " + arithmetic));
//剩余待分析内容
if (i != listT.size()-1)
listT = new LinkedList<Tokens>(listT.subList(i+1, listT.size()));
else listT.clear();
break;
}
}
//赋值语句未正确结束
if (assignmentNotEnd == false) {
syntaxWrong();
syntaxWrongOutput.add(" 语句未结束 #" + listT.getFirst().lineNo);
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.getLast().end);
//对赋值部分进行算术表达式分析
arithmeticOperation(new LinkedList<Tokens>(listT.subList(2, listT.size())), false, true);
listT.clear();
}
}
}
//对数组变量指定索引处的赋值
else if (listT.size()>2 && listT.get(1).token.equals("[")){
//对应括号结束位置
int endBracket = analyzeBracket(listT, "[", "]", 1);
//没有对应括号闭
if (endBracket==-1){
syntaxWrong();
syntaxWrongOutput.add(" 括号无法匹配 #" + listT.get(1).lineNo);
tokenErrorStart.add(listT.get(1).start);
tokenErrorEnd.add(listT.get(1).end);
//对索引部分进行算术表达式分析
arithmeticOperation(new LinkedList<Tokens>(listT.subList(2, listT.size())), false, true);
listT.clear();
}
else {
//用于存储待赋值变量
String strT = "";
for (Tokens value: new LinkedList<Tokens>(listT.subList(0, endBracket+1)))
strT+=value.token;
//添加子节点及输出
assignmentTreeT.add(new DefaultMutableTreeNode("变量: " + strT));
syntaxOutput.add(showSpace() + "赋值语句：");
tokenRightStart.add(listT.getFirst().start);
tokenRightEnd.add(listT.get(endBracket).end);
deep.add(countSpace);
//没有索引值
if (endBracket==2) {
syntaxWrong();
syntaxWrongOutput.add(" 错误的赋值语句 #" + listT.get(2).lineNo);
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.get(2).end);
}
else
//对索引值进行算术表达式分析,需要错误时的输出
arithmeticOperation(new LinkedList<Tokens>(listT.subList(2, endBracket)), false, true);
//输出
syntaxOutput.add(showSpace() + " 变量: " + strT + " #" + listT.getFirst().lineNo);
tokenRightStart.add(listT.getFirst().start);
tokenRightEnd.add(listT.get(endBracket).end);
deep.add(countSpace + 1);
//格式限制
if (endBracket==listT.size()-1 || endBracket==listT.size()-2 ||
!listT.get(endBracket+1).token.equals("=")) {
syntaxWrong();
syntaxWrongOutput.add(" 错误的赋值语句 #" + listT.get(endBracket+1).lineNo);
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.get(endBracket).end);
//剩余待分析内容
if (endBracket == listT.size()-1 || endBracket == listT.size()-2) listT.clear();
else listT = new LinkedList<Tokens>(listT.subList(endBracket+1, listT.size()));
}
else {
//赋值语句是否正确结束
boolean assignmentNotEnd = false;
for (int i = endBracket+2; i < listT.size(); i++) {
if (listT.get(i).token.equals(";")) {
//赋值语句正确结束
assignmentNotEnd = true;
//对赋值内容进行算术表达式分析,添加正确及错误时的输出
if(arithmeticOperation(
new LinkedList<Tokens>(listT.subList(endBracket+2, i)), true, true))
//添加子节点
assignmentTreeT.add(new DefaultMutableTreeNode("变量值: " + arithmetic));
//剩余待分析内容
if (i != listT.size()-1)
listT = new LinkedList<Tokens>(listT.subList(i+1, listT.size()));
else listT.clear();
break;
}
}
//赋值语句未正确结束
if (assignmentNotEnd == false) {
syntaxWrong();
syntaxWrongOutput.add(" 语句未结束 #" + listT.getFirst().lineNo);
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.getLast().end);
//对赋值部分进行算术表达式的分析,仅需要进行错误输出
arithmeticOperation(new LinkedList<Tokens>(listT.subList(endBracket+2, listT.size())),
false, true);
listT.clear();
}
}
}
}
//不满足赋值语句格式限制
else {
syntaxWrong();
listT = statementWrong(listT, true);
}
//进入后续分析或分析结束并备份剩余待分析内容
if (executeTimes)
matchingAnalyze(listT, assignmentTree, true);
else listTT = listT;
}
//读入变量值
private void read(LinkedList<Tokens> listT,
DefaultMutableTreeNode readTree, boolean executeTimes) {
//添加子节点
DefaultMutableTreeNode readTreeT = new DefaultMutableTreeNode("读入");
readTree.add(readTreeT);
syntaxOutput.add(showSpace() + "读入：");
tokenRightStart.add(listT.getFirst().start);
tokenRightEnd.add(listT.getFirst().end);
deep.add(countSpace);
//格式限制
if (listT.size()<3 || listT.get(1).type!=CMMI) {
keywordUseWrong(listT.getFirst());
syntaxWrongOutput.add(" 错误原因 ：read语句格式错误");
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.getLast().end);
//剩余待分析内容
if (listT.size()<3) listT.clear();
else listT.removeFirst();
}
else {
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -