Minic词法，语法，语义实现
jjt文件实现，上面部分是和界面的连接：
/** * JJTree template file created by SF JavaCC plugin 1.5.28+ wizard for JavaCC 1.5.0+ */ options { static = false; } PARSER_BEGIN(Minic) package Minic; import util.*; import java.io.*; import java.util.*; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.PrintStream; public class Minic { public static String cifaFile = ".//src//file//lexical.txt"; public static String yufaFile = ".//src//file//yufa.txt"; public static String yuyiFile = ".//src//file//yuyi.txt"; public static String errorFile = ".//src//file//error.txt"; public static Boolean existF = false; //用来进行错误分析使用 public static String S = ""; public static ArrayList < Symbol > mylist = new ArrayList < Symbol > (); public static SymbolTable symbollist = new SymbolTable(mylist); QTList qtList = new QTList(); public void printQTList() { qtList.printQTTable(); } public static void main(String args []) { try { File file = new File(".//src//file//1.txt"); FileInputStream fis = new FileInputStream(file); Minic mm = new Minic(fis); run(".//src//file//2.txt"); } catch (Exception e) { e.printStackTrace(); } } public static void run(String FilePath) throws FileNotFoundException { try { //词法部分 File file = new File(FilePath); SimpleCharStream scs = new SimpleCharStream(new FileInputStream(file)); //输出流 FileOutputStream fos1 = new FileOutputStream(cifaFile); //词法 FileOutputStream fos2 = new FileOutputStream(yufaFile); //语法 FileOutputStream fos3 = new FileOutputStream(yuyiFile); //语义 PrintStream LexicalStream1 = new PrintStream(fos1); PrintStream LexicalStream2 = new PrintStream(fos2); PrintStream LexicalStream3 = new PrintStream(fos3); //词法部分 MinicTokenManager mtm = new MinicTokenManager(scs); Token a = mtm.getNextToken(); String lexicalStr = ""; while (a.kind != EOF) { lexicalStr += a.kind; lexicalStr += "\t"; lexicalStr += a.image; lexicalStr += "\n"; System.out.println(a.kind + "\t" + a.image); a = mtm.getNextToken(); } //将流传送到文件 LexicalStream1.print(lexicalStr); Minic tmp = new Minic(new FileInputStream(new File(FilePath))); SimpleNode n = tmp.Start(); System.setOut(LexicalStream2); n.dump(""); //语义分析 System.setOut(LexicalStream3); tmp.printQTList(); fos1.close(); LexicalStream1.close(); fos2.close(); LexicalStream2.close(); fos3.close(); LexicalStream3.close(); } catch (Exception e) { e.printStackTrace(); } } public static void yuyi(Minic mm) throws FileNotFoundException { try { SimpleNode n = mm.Start(); FileOutputStream fos = new FileOutputStream(yuyiFile); PrintStream ps = new PrintStream(fos); System.setOut(ps); dumps("", n, ps); fos.close(); ps.close(); } catch (Exception e) { System.out.println("error\n" + e.getMessage()); e.printStackTrace(); } } public static void dumps(String prefix, SimpleNode sn, PrintStream ps) { ps.println(prefix); if (sn.children != null) { for (int i = 0; i < sn.children.length; ++i) { SimpleNode n = (SimpleNode) sn.children [i]; if (n != null) { n.dump(prefix + " "); } } } } public static void cifa(String FilePath) throws FileNotFoundException { try { File file = new File(FilePath); SimpleCharStream scs = new SimpleCharStream(new FileInputStream(file)); FileOutputStream fos = new FileOutputStream(cifaFile); PrintStream LexicalStream = new PrintStream(fos); MinicTokenManager mtm = new MinicTokenManager(scs); Token a = mtm.getNextToken(); String lexicalStr = ""; while (a.kind != EOF) { lexicalStr += a.kind; lexicalStr += "\t"; lexicalStr += a.image; lexicalStr += "\n"; System.out.println(a.kind + "\t" + a.image); a = mtm.getNextToken(); } LexicalStream.print(lexicalStr); fos.close(); LexicalStream.close(); } catch (Exception e) { System.out.println("Oops."); System.out.println(e.getMessage()); } } } PARSER_END(Minic) SKIP : { " " | "\t" | "\n" | "\r" | < "//" (~[ "\n", "\r" ])* ( "\n" | "\r" | "\r\n" ) > | < "/*" (~[ "*" ])* "*" ( ~[ "/" ] (~[ "*" ])* "*" )* "/" > } TOKEN : /*keyword关键字*/ { < IF : "if" > | < ELSE : "else" > | < RETURN : "return" > | < CHAR : "char" > | < DOUBLE : "double" > | < ENUM : "enum" > | < FLOAT : "float" > | < INT : "int" > | < LONG : "long" > | < SHORT : "short" > | < SIGNED : "signed" > | < STRUCT : "struct" > | < UNION : "union" > | < UNSIGNED : "unsigned" > | < VOID : "void" > | < FOR : "for" > | < DO : "do" > | < WHILE : "while" > | < BREAK : "break" > | < CONTINUE : "continue" > | < GOTO : "goto" > | < SWITCH : "switch" > | < CASE : "case" > | < dEFAULT : "default" > | < AUTO : "auto" > | < EXTERN : "extern" > | < REGISTER : "register" > | < STATIC : "static" > | < CONST : "const" > | < SIZEOF : "sizeof" > | < TYPEDEF : "typedef" > | < VOLATUIVE : "volatile" > | < MAIN : "main"> } TOKEN : /*separater分隔符*/ { < semicolon : ";" > | < comma : "," > | < leftbracket : "(" > | < rightbracket : ")" > | < leftmidbracket : "[" > | < rightmidbracket : "]" > | < leftbigbracket : "{" > | < rightbigbracket : "}" > } TOKEN : /* OPERATOR运算符*/ { < ADD : "+" > | < SUBTRACT : "-" > | < MULTIPLY : "*" > | < DIVIDE : "/" > | < BE : ">" > | < LE : "<" > | < EQUAL : "=" > | < AND : "&&" > | < OR : "||" > | < NOT : "!"> | < AUTOADD :"++"> | < AUTOSUBTRACT :"--"> } TOKEN : /* LITERALS常量 */ { < INTEGER_LITERAL : < DECIMAL_LITERAL > ([ "l", "L" ])? | < HEX_LITERAL > ([ "l", "L" ])? | < OCTAL_LITERAL > ([ "l", "L" ])? > | < #DECIMAL_LITERAL : [ "1"-"9" ] ([ "0"-"9" ])* > | < #HEX_LITERAL : "0" [ "x", "X" ] ([ "0"-"9", "a"-"f", "A"-"F" ])+ > | < #OCTAL_LITERAL : "0" ([ "0"-"7" ])* > } TOKEN : /* IDENTIFIERS标识符 */ { < IDENTIFIER : < LETTER > ( < LETTER > | < DIGIT > )* > | < #LETTER : [ "_", "a"-"z", "A"-"Z" ] > | < #DIGIT : [ "0"-"9" ] > } //**************************************************// SimpleNode Start() : {} { Program() < EOF> { return jjtThis; } } void Program() : //程序 {} { ( < INT > | < VOID> ) < MAIN > "(" ")" "{" ( StatementBlock() )* "}" } void StatementBlock() : //语句块 {} { ( Statement() )+ /*| "{" ( StatementBlock() )* "}" */ } void Statement() : //语句 {} { DeclarationStatement() //声明语句 | AssignmentStatement() //赋值语句 | ifelseStatement() //if-else语句 | whileStatement() //while语句 | dowhileStatement() //dowhile语句 | forStatement() //for语句 | switcaStatement() //switchcase语句 } Token type() : { Token t = null; } { t = < INT > { return t; } | t = < FLOAT > { return t; } | t = < DOUBLE > { return t; } | t = < CHAR > { return t; } | t = < VOID > { return t; } } //声明语句 void DeclarationStatement() : { Token Sbo1 = null; Token Sbo2 = null; Token Sbo3 = null; String name = null; String str = null; Symbol tempsymbol = null; } { Sbo1 = type() Sbo2 = < IDENTIFIER > //标识符 { //查看错误 name = Sbo2.image; if (symbollist.exist(name)) { str = name + "变量已声明过，错误：重复声明" + "\n"; S += str; str = null; existF = true; } else { //将变量加入符号表 tempsymbol = new Symbol(name, Sbo1.image); symbollist.addS(tempsymbol); } } ( "," Sbo3 = < IDENTIFIER > { //查看错误 name = Sbo3.image; if (symbollist.exist(name)) { str = name + "变量已声明过，错误：重复声明" + "\n"; S += str; str = null; existF = true; } else { //将变量加入符号表 tempsymbol = new Symbol(name, Sbo1.image); symbollist.addS(tempsymbol); } } )* ";" } //赋值语句 void AssignmentStatement() : { Token id; Token a; String e = null; //若是有错误，用来存放错误信息 String str = null; } { //将IDENTIFIER赋给id,将等号赋给a，将表达式赋给e id = < IDENTIFIER > a = "=" e = Expression() { //生成四元式，入链表 QTInfo qt = new QTInfo("=",e,"_",id.image); qtList.addQTInfo(qt); } { if (symbollist.getSize() != 0) { if (!symbollist.exist(id.image)) { str = id.image + "变量未曾声明，错误：使用未声明" + "\n"; S += str; str = null; existF = true; } } } ";" } //if-else条件语句 void ifelseStatement() : { ConditionValue chain = null; int quad; int fquad; } { "if" "(" chain = orboolExpression() ")" { quad = QTInfo.size + 1; } { //回填真链 chain.backpatchTrueChain(QTInfo.size + 1); } "{" StatementBlock() "}" { fquad = QTInfo.size + 1; } ( LOOKAHEAD(1) < ELSE > { //else前的无条件跳转为“qt”四元式 QTInfo qt = new QTInfo("J", "_", "_","0"); qtList.addQTInfo(qt); fquad++; } StatementBlock() { //得到此时下一个四元式的序号，用来回填上面的无条件跳转“qt” qt.setResult(QTInfo.size + 1); } )? { chain.backpatchFalseChain(fquad); } } //while语句 void whileStatement() : { ConditionValue chain = null; int quad; } { < WHILE > "(" { quad = QTInfo.size + 1; } chain = Condition() ")" //OrBooleanExpression() { //回填真链 chain.backpatchTrueChain(QTInfo.size + 1); } "{" StatementBlock() "}" { //while的一次跳转，回到上面去 qtList.addQTInfo(new QTInfo("J", "_", "_", quad)); chain.backpatchFalseChain(QTInfo.size +1); } } ConditionValue Condition(): //while,if关系 { String e1 = null; String e2 = null; String rop = null; ConditionValue chain = new ConditionValue(); } { e1 = Expression() ( rop = rop() e2 = Expression() )? { if(rop != null) //rop是 > { //生成四元式，加入列表，合并真链 QTInfo info = new QTInfo("J" + rop,e1,e2,"T"); qtList.addQTInfo(info); chain.mergeTrue(info); } else { QTInfo info = new QTInfo("Jnz",e1,"_","T"); qtList.addQTInfo(info); chain.mergeTrue(info); } QTInfo info = new QTInfo("J","_","_","F"); qtList.addQTInfo(info); chain.mergeFalse(info); return chain; } } String rop(): { Token t = null; } { t = < BE > //大于 { return t.image; } } //for语句 void forStatement() : { ConditionValue chain = new ConditionValue(); int quad; int fquad; int mquad; int cquad; } { < FOR> "(" /*AssignmentStatement()后面已自带“；”，所以不需要再加了*/ AssignmentStatement() //赋值 { cquad = QTInfo.size + 1; } chain = Condition() //条件 ";" { mquad = QTInfo.size + 1; } autoinc() { qtList.addQTInfo(new QTInfo("J", "_", "_", cquad)); } ")" "{" { quad = QTInfo.size + 1; } StatementBlock() "}" { //跳转到自增或自减语句之前，进行自增或自减操作 qtList.addQTInfo(new QTInfo("J", "_", "_", mquad)); } { fquad = QTInfo.size + 1; //回填假链 chain.backpatchFalseChain(fquad); //回填真链 chain.backpatchTrueChain(quad); } } //自增自减 void autoinc() : { Token id; Token op; String newTemp; } { id = < IDENTIFIER > ( op = < AUTOADD> { //生成四元式，入链表,自增 //newTemp = VariableNameGenerator.genVariableName(); QTInfo qt = new QTInfo("+",id.image,"1",id.image); qtList.addQTInfo(qt); } | op = < AUTOSUBTRACT> { //生成四元式，入链表，自减 newTemp = VariableNameGenerator.genVariableName(); QTInfo info = new QTInfo("-",id.image,"1",newTemp); QTInfo info1 = new QTInfo("=",newTemp,"_",id.image); qtList.addQTInfo(info); qtList.addQTInfo(info1); } ) } //do-while语句 void dowhileStatement() : { int quad; ConditionValue chain = new ConditionValue(); } { < DO > { quad = QTInfo.size + 1; } "{" StatementBlock() "}" < WHILE > "(" chain = Condition() ")" ";" { //回填真链 chain.backpatchTrueChain(quad); } { //不需要回跳，在条件为真的情况下已经回跳了 //qtList.addQTInfo(new QTInfo("J", "_", "_", quad)); chain.backpatchFalseChain(QTInfo.size +1); } } //switch-case语句 void switcaStatement() : { int quad; int quad1; String res = null; //存放E的结果 Token rmi; //存放匹配的选项 } { < SWITCH> "(" res = AdditiveExpression() ")" "{" ( < CASE> rmi = < INTEGER_LITERAL> ":" { //得到下一个四元式的序号，进行回填操作 quad = QTInfo.size + 1; } { /*Goto L语句，采用定义性出现，即以S产生的第一个四元式的序号作为 标号L的地址*/ quad++; //如果res等于rmi.image，就跳转到quad四元式 QTInfo info = new QTInfo("case",res,rmi.image,quad); qtList.addQTInfo(info); } Statement() < BREAK> ";" )+ < dEFAULT> ":" { quad1 = QTInfo.size + 1; } { //如果前面都无法匹配，则进行default quad1++; QTInfo info = new QTInfo("case",res,"default",quad1); qtList.addQTInfo(info); } Statement() "}" } //&&布尔表达式 ConditionValue andboolExpression() : { ConditionValue chain1 = new ConditionValue(); ConditionValue chain2 = new ConditionValue(); int quad; } { chain1 = Condition() { quad = QTInfo.size + 1; } /*当下面括号内不存在时，与布尔表达式就相当于一个Condition()， 当括号内的存在时， 需要将chain2返回，当括号内的不存在时，需要将chain1返回，所以将chain1赋给chain2*/ { chain2 = chain1; } ( "&&" chain2 = Condition() { //回填真链 chain1.backpatchTrueChain(quad); //合并假链chain1,chain2 chain2.mergeFalse(chain1.falseChain); } )? { return chain2; } } //||布尔表达式 ConditionValue orboolExpression() : { //布尔左右两边需要判断的 ConditionValue chain1 = new ConditionValue(); ConditionValue chain2 = new ConditionValue(); int quad; } { //让||两边格式一个&&表达式 chain1 = andboolExpression() /*与与布尔表达式一样*/ { chain2 = chain1; } ( { quad = QTInfo.size + 1; } "||" chain2 = andboolExpression() { //回填假链 chain1.backpatchFalseChain(quad); //合并真链 chain2.mergeTure(chain1.trueChain); } )? { return chain2; } } String Expression() : //表达式 { String first; String middle; String newTemp; Token op; } { //first = MultiplicativeExpression() first = AdditiveExpression() { newTemp = first; } ( ( op = < ADD > | op = < MULTIPLY > | op = < SUBTRACT > ) //middle = MultiplicativeExpression() middle = AdditiveExpression() { newTemp = VariableNameGenerator.genVariableName(); QTInfo qt = new QTInfo(op.image,first,middle,newTemp); qtList.addQTInfo(qt); first = newTemp; } )* { return newTemp; } } void Operator() : //运算符 {} { "+" | "-" | "*" | "/" } String Relation() : //关系符 { Token op; } { op = "<" | op = "<=" | op = ">" | op = ">=" | op = "==" | op = "!=" { return op.image; } } //加法表达式 String AdditiveExpression() : { String first; String middle; String newTemp; Token op; } { first = MultiplicativeExpression() //first是返回的字符串 { newTemp = first; } ( ( op = "+" //op是Token对象 | op = "-" ) middle = MultiplicativeExpression() // middle是返回的字符串 { newTemp = VariableNameGenerator.genVariableName(); QTInfo qt = new QTInfo(op.image,first,middle,newTemp); qtList.addQTInfo(qt); first = newTemp; } )* { return newTemp; } } //乘法表达式 String MultiplicativeExpression() : { String first; String middle; String newTemp; Token op; } { first = UnaryExpression() //first是返回的字符串 { newTemp = first; } ( ( op = "*" //op是Token对象 | op = "/" | op = "%" ) middle = UnaryExpression() // middle是返回的字符串 { newTemp = VariableNameGenerator.genVariableName(); QTInfo qt = new QTInfo(op.image,first,middle,newTemp); qtList.addQTInfo(qt); first = newTemp; } )* { return newTemp; } } String UnaryExpression() : { String str = null; Token t = null; } { "(" str = Expression() ")" { return str; } | t = < IDENTIFIER > { str = t.image; return str; } | t = < INTEGER_LITERAL > { str = t.image; return str; } } void Identifier() : {} { < IDENTIFIER > } void Integer() : {} { < INTEGER_LITERAL > }
QTInfo：定义四元式
package util; //定义四元式的信息 public class QTInfo { public static int size = 0; // 四元式全局个数 private int innerId; // 当前四元式ID private String operator; private String arg1; private String arg2; private String result; public QTInfo(String operator, String arg1, String arg2, String result) { super(); this.innerId = ++size; this.operator = operator; this.arg1 = arg1; this.arg2 = arg2; this.result = result; } public QTInfo(String operator, String arg1, String arg2, int result) { this(operator, arg1, arg2, result + ""); } public String getOperator() { return this.operator; } public void setResult(String result) { this.result = result; } public void setResult(int result) { this.result = "" + result; } public String getResult() { return this.result; } public void setInnerId(int innerID) { this.innerId = innerID; } public int getInnerIdSeqen() { return size; } public String toString() { // TODO Auto-generated method stub return this.innerId + ":\t(" + this.operator + ",\t" + this.arg1 + ",\t" + this.arg2 + ",\t" + this.result + "\t)\n"; } }
QTList:存放四元式的列表：
package util; import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; import java.util.ArrayList; import java.util.Iterator; public class QTList { public ArrayList<QTInfo> QTList = new ArrayList<QTInfo>(); public static boolean flag = true; public void addQTInfo(QTInfo info) { QTList.add(info); } public void addQTInfo(int index, QTInfo info) { QTList.add(index, info); } public QTInfo get(int index) { return (QTInfo) QTList.get(index); } public QTInfo remove(int index) { return QTList.remove(index - 1); } public void clear() { QTList.clear(); QTInfo.size = 0; } public void printQTTable() { // System.out.println(toString()); Iterator<QTInfo> itr = QTList.iterator(); try { while (itr.hasNext()) { QTInfo tmp = (QTInfo) itr.next(); System.out.println(tmp.toString()); } } catch (Exception e) { e.printStackTrace(); } } }
ConditionValue真链和假链
package util; import java.util.ArrayList; import java.util.Iterator; public class ConditionValue { public ArrayList<QTInfo> trueChain = new ArrayList<QTInfo>(); public ArrayList<QTInfo> falseChain = new ArrayList<QTInfo>(); //增加一个四元式 public void mergeTrue(QTInfo qtTrue){ trueChain.add(qtTrue); } //增加多个四元式，即合并两条真链 public void mergeTure(ArrayList<QTInfo> chaint) { Iterator<QTInfo> itr = chaint.iterator(); while(itr.hasNext()){ trueChain.add(itr.next()); } } public void mergeFalse(QTInfo qtFalse){ falseChain.add(qtFalse); } public void mergeFalse(ArrayList<QTInfo> chainf) { Iterator<QTInfo> itr = chainf.iterator(); while(itr.hasNext()){ falseChain.add(itr.next()); } } public void backpatchTrueChain(int result){ Iterator<QTInfo> itr = trueChain.iterator(); while(itr.hasNext()){ itr.next().setResult(result); } } public void backpatchFalseChain(int result){ Iterator<QTInfo> itr = falseChain.iterator(); while(itr.hasNext()){ itr.next().setResult(result); } } }
VariableNameGenerator变量产生器
package util; /** * 变量名产生器 * */ public class VariableNameGenerator { private static final String VAR_PREFIX = "T"; // 前缀 private static int sequenceId = 0; // 序号 T1、T2、T3... public static String genVariableName() { ++sequenceId; return VAR_PREFIX + sequenceId; } public void clear() { // TODO Auto-generated method stub sequenceId = 0; } }
Symbol符号
package util; public class Symbol { public String name; public String type; public Symbol(String name, String type) { super(); this.name = name; this.type = type; } }
SymbolTable符号表
package util; import java.util.ArrayList; public class SymbolTable { public ArrayList<Symbol> mylist=null; public SymbolTable(ArrayList<Symbol> mylist) { super(); this.mylist = mylist; } //返回链表中存放的变量个数 public int getSize() { return mylist.size(); } //查看变量是否在表中已经存在 public boolean exist(String name){ boolean index=false; for(Symbol temp:mylist){ if(temp.name.equals(name)){ index=true; } } return index; } //往符号表中增加变量 public void addS(Symbol temp){ mylist.add(temp); } }
界面部分就不上传了，只有jjt文件的上面涉及到界面，直接删掉就可以。
