📄 syntaxanalyze.java
字号:
}
//else处理
private void elseClause(LinkedList<Tokens> listT,DefaultMutableTreeNode elseTree) {
//添加子节点及输出
DefaultMutableTreeNode elseTreeT = new DefaultMutableTreeNode("else 语句");
elseTree.add(elseTreeT);
syntaxOutput.add(showSpace() + "else 语句");
tokenRightStart.add(listT.getFirst().start);
tokenRightEnd.add(listT.getFirst().end);
deep.add(countSpace);
//错误 ：语句长度过短
if (listT.size() < 3) {
keywordUseWrong(listT.getFirst());
syntaxWrongOutput.add(" 错误原因 ：语句格式错误");
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.getFirst().end);
listT.clear();
}
else {
//含有block
if (listT.get(1).token.equals("{")) {
int end = analyzeBracket(listT, "{", "}", 1);
//错误 ：block未结束
if (end == -1) {
syntaxWrong();
syntaxWrongOutput.add(" 括号无法匹配 #" + listT.get(1).lineNo);
tokenErrorStart.add(listT.get(1).start);
tokenErrorEnd.add(listT.get(1).end);
//移除"else"及"{",对剩余内容进行分析
listT.removeFirst();
listT.removeFirst();
syntaxAnalyze(elseTreeT, listT, true);
listT.clear();
}
//正常block
else if (end!= 2)
syntaxAnalyze(elseTreeT, new LinkedList<Tokens>(listT.subList(2, end)), true);
//剩余待分析内容
if (end == listT.size()) listT.clear();
else listT = new LinkedList<Tokens>(listT.subList(end+1, listT.size()));
}
//else之后有执行语句且不使用大括号
else {
countSpace++;
matchingAnalyze(
new LinkedList<Tokens>(listT.subList(1, listT.size())), elseTreeT, false);
countSpace--;
//将临时内容加载
listT = listTT;
}
}
//将剩余待分析内容备份
listTT = listT;
}
//计算对应括号位置
/*参数含义：
* String bracket1 括号开的字符串("(","{","[")
* String bracket2 括号闭的对应字符串(")","}","]")
* int startIndex 括号开在listT中所在位置
*/
public int analyzeBracket(LinkedList<Tokens> listT, String bracket1, String bracket2, int startIndex) {
//对应括号闭位置
int end = -1;
//括号开、闭的个数统计
int count1 = 0;
int count2 = 0;
for (int i = startIndex; i < listT.size(); i++) {
if (listT.get(i).token.equals(bracket1)) count1++;
else if (listT.get(i).token.equals(bracket2)) count2++;
if (count2 == count1) {
end = i;
break;
}
}
return end;
}
//重载：计算对应括号位置
/*参数含义：
* String bracket1 括号开的字符串('('和'[')
* String bracket2 括号闭的对应字符串(')'和']')
* int startIndex 括号开在listT中所在位置
*/
public static int analyzeBracket(String str, char bracket1, char bracket2, int startIndex) {
//对应括号闭位置
int end = -1;
//括号开、闭的个数统计
int count1 = 0;
int count2 = 0;
for (int i = startIndex; i < str.length(); i++) {
if (str.charAt(i) == bracket1) count1++;
else if (str.charAt(i) == bracket2) count2++;
if (count2 == count1) {
end = i;
break;
}
}
return end;
}
//声明int型变量并进行初始化
private void declare(LinkedList<Tokens> listT,
DefaultMutableTreeNode declarationTree, boolean executeTimes) {
//添加子节点
DefaultMutableTreeNode declarationTreeT = new DefaultMutableTreeNode("int型变量声明");
declarationTree.add(declarationTreeT);
//不存在初始化的值
if (listT.size()==3) {
keywordUseWrong(listT.getFirst());
syntaxWrongOutput.add(" 错误原因 ：声明变量格式错误");
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.getFirst().end);
listT.clear();
}
else {
//变量声明是否正确结束
boolean declareEnd = false;
for (int i = 3; i < listT.size(); i++) {
//变量声明正确结束
if (listT.get(i).token.equals(";")) {
declareEnd = true;
//错误：没有赋值内容
if (i==3) {
keywordUseWrong(listT.getFirst());
syntaxWrongOutput.add(" 错误原因 ：声明变量时赋值内容为空");
tokenErrorStart.add(listT.get(2).start);
tokenErrorEnd.add(listT.get(3).end);
}
else {
//添加子节点
declarationTreeT.add(new DefaultMutableTreeNode("变量: " + listT.get(1).token));
syntaxOutput.add(showSpace() + "变量声明：");
tokenRightStart.add(listT.getFirst().start);
tokenRightEnd.add(listT.getFirst().end);
deep.add(countSpace);
syntaxOutput.add(showSpace() + " 变量: " +
listT.get(1).token + " #" + listT.get(1).lineNo);
tokenRightStart.add(listT.get(1).start);
tokenRightEnd.add(listT.get(1).end);
deep.add(countSpace+1);
//对赋值内容进行算术表达式分析
if (arithmeticOperation(new LinkedList<Tokens>(listT.subList(3, i)), true, true))
//添加子节点
declarationTreeT.add(new DefaultMutableTreeNode("变量值: "+ arithmetic));
}
//剩余待分析内容
if (i != listT.size()-1)
listT = new LinkedList<Tokens>(listT.subList(i+1, listT.size()));
else listT.clear();
break;
}
}
//变量声明未正确结束
if (declareEnd == false) {
syntaxWrong();
syntaxWrongOutput.add(" 语句未结束 #" + listT.getFirst().lineNo);
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.getFirst().end);
//对赋值内容进行算术表达式分析
arithmeticOperation(new LinkedList<Tokens>(listT.subList(3, listT.size())), false, true);
listT.clear();
}
}
//进入后续分析或分析结束并备份剩余待分析内容
if (executeTimes)
matchingAnalyze(listT, declarationTree, true);
else listTT = listT;
}
//声明数组变量
private void arrayDeclare(LinkedList<Tokens> listT,
DefaultMutableTreeNode arrayTree, boolean executeTimes) {
//添加子节点及输出
DefaultMutableTreeNode arrayTreeT = new DefaultMutableTreeNode("array型变量声明");
arrayTree.add(arrayTreeT);
syntaxOutput.add(showSpace() + "变量声明：");
tokenRightStart.add(listT.getFirst().start);
tokenRightEnd.add(listT.getFirst().end);
deep.add(countSpace);
//此类语句所必须满足条件：
//格式限制
if (listT.size()<6 || (listT.size()==6 && !listT.get(5).token.equals(";"))) {
keywordUseWrong(listT.getFirst());
if (listT.size()<6) syntaxWrongOutput.add(" 错误原因 ：语句长度过短");
else syntaxWrongOutput.add(" 错误原因 ：声明变量没有正确结束");
tokenErrorStart.add(listT.getFirst().start);
tokenErrorEnd.add(listT.getFirst().end);
listT.clear();
}
else{
//对应"]"所在位置
int endBracket = analyzeBracket(listT, "[", "]", 2);
//对应"]"不存在
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(3, listT.size())), false, true);
listT.clear();
}
else {
//声明并初始化
if (endBracket == 3) {
//长度限制
if (listT.size()<7) {
declareWrong(listT.get(1));
listT.clear();
}
//格式限制
else if (!listT.get(4).token.equals("=") ) {
listT.removeFirst();
declareWrong(listT.getFirst());
listT = statementWrong(listT, false);
}
else {
//使用具体值进行初始化
if (listT.get(5).token.equals("{")){
//大括号结束位置
int endBracketT = analyzeBracket(listT, "{", "}", 5);
//没有对应大括号
if (endBracketT == -1) {
syntaxWrong();
syntaxWrongOutput.add(" 括号无法匹配 #" + listT.get(1).lineNo);
tokenErrorStart.add(listT.get(5).start);
tokenErrorEnd.add(listT.get(5).end);
listT.clear();
}
else {
//格式限制
if (endBracketT==listT.size()-1 ||
!listT.get(endBracketT+1).token.equals(";")){
syntaxWrong();
syntaxWrongOutput.add(" 语句未结束 #" + listT.getFirst().lineNo);
tokenErrorStart.add(listT.get(endBracketT).start);
tokenErrorEnd.add(listT.get(endBracketT).end);
}
else {
//用于存储数组变量值(字符串)
String variableValue = "";
//没有用于初始化数组变量的值
if (endBracketT == 6)
declareWrong(listT.getFirst());
else
//分析并保存数组变量的值
variableValue =
arrayData(new LinkedList<Tokens>(listT.subList(6, endBracketT)));
//数组变量值分析为正确
if (!variableValue.equals("false")) {
//添加子节点及输出
arrayTreeT.add(
new DefaultMutableTreeNode(
"数组变量: " + listT.get(1).token));
arrayTreeT.add(
new DefaultMutableTreeNode(
"数组变量值: {" + variableValue + "}"));
syntaxOutput.add(showSpace() + " 数组变量: " +
listT.get(1).token + " #" + listT.get(1).lineNo);
tokenRightStart.add(listT.get(1).start);
tokenRightEnd.add(listT.get(3).end);
deep.add(countSpace+1);
syntaxOutput.add(showSpace() + " 数组变量值: {" +
variableValue + "} #" + listT.get(5).lineNo);
tokenRightStart.add(listT.get(5).start);
tokenRightEnd.add(listT.get(endBracketT).end);
deep.add(countSpace+1);
}
//错误的数组变量值
else {
declareWrong(listT.get(1));
syntaxWrongOutput.add(" 错误原因 ：错误的初始化值");
tokenErrorStart.add(listT.get(5).start);
tokenErrorEnd.add(listT.get(endBracketT).end);
}
}
//剩余待分析内容
if (endBracketT == listT.size()-1) listT.clear();
//声明正确结束
else if (listT.get(endBracketT+1).token.equals(";")) {
if (endBracketT+1 == listT.size()-1) listT.clear();
else listT =
new LinkedList<Tokens>(listT.subList(endBracketT+2, listT.size()));
}
else listT =
new LinkedList<Tokens>(listT.subList(endBracketT+1, listT.size()));
}
}
//使用变量初始化数组变量
else if (listT.get(5).type==CMMI) {
//声明正确结束
if (listT.get(6).token.equals(";")) {
//添加子节点及输出
arrayTreeT.add(
new DefaultMutableTreeNode(
"数组变量: " + listT.get(1).token));
arrayTreeT.add(
new DefaultMutableTreeNode(
"数组变量值: " + listT.get(5).token));
syntaxOutput.add(showSpace() + " 数组变量: " +
listT.get(1).token + " #" + listT.get(1).lineNo);
tokenRightStart.add(listT.get(1).start);
tokenRightEnd.add(listT.get(3).end);
deep.add(countSpace+1);
syntaxOutput.add(showSpace() + " 数组变量值: " +
listT.get(5).token + " #" + listT.get(5).lineNo);
tokenRightStart.add(listT.get(5).start);
tokenRightEnd.add(listT.get(5).end);
deep.add(countSpace+1);
//剩余待分析内容
if (listT.size()==7) listT.clear();
else
listT =
new LinkedList<Tokens>(listT.subList(7, listT.size()));
}
//声明未正确结束
else {
syntaxWrong();
syntaxWrongOutput.add(" 语句未结束 #" + listT.getFirst().lineNo);
tokenErrorStart.add(listT.get(5).start);
tokenErrorEnd.add(listT.get(5).end);
listT =
new LinkedList<Tokens>(listT.subList(6, listT.size()));
}
}
//错误的数组变量初始化
else {
listT.removeFirst();
declareWrong(listT.get(1));
listT = statementWrong(listT, false);
}
}
}
//声明限定长度的数组而不初始化
else {
//存储声明数组变量时为指定数组长度的字符串
String length = "";
LinkedList<Tokens> listTTT = new LinkedList<Tokens>(listT.subList(3, endBracket));
for (Tokens value: listTTT)
length += value.token;
//对数组长度的表达式进行算术表达式的分析,仅需要错误时的输出
arithmeticOperation(listTTT, false, true);
//格式限制
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);
}
else {
//添加子节点及输出
arrayTreeT.add(
new DefaultMutableTreeNode("数组变量: " + listT.get(1).token));
arrayTreeT.add(
new DefaultMutableTreeNode("数组变量长度: " + length));
syntaxOutput.add(showSpace() + " 数组变量: " +
listT.get(1).token + " #" + listT.get(1).lineNo);
tokenRightStart.add(listT.get(1).start);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -