llvmir some opt

frontend/ast/decl/ConstDecl.java

@@ -0,0 +1,51 @@
+package frontend.ast.decl;
+
+import error.Errors;
+import error.ErrorType;
+
+import java.util.ArrayList;
+
+import error.Error;
+import frontend.ast.Node;
+import frontend.ast.SyntaxType;
+import frontend.ast.token.TokenNode;
+import frontend.lexer.TokenStream;
+import frontend.lexer.TokenType;
+
+public class ConstDecl extends Node {
+    public ConstDecl(TokenStream ts) {
+        super(SyntaxType.CONST_DECL, ts);
+    }
+
+    public void parse(Errors errors) {
+        TokenNode constkk = new TokenNode(this.ts);
+        addChild(constkk);
+        TokenNode intkk = new TokenNode(this.ts);
+        addChild(intkk);
+        while (true) {
+            ConstDef cdef = new ConstDef(this.ts);
+            cdef.parse(errors);
+            addChild(cdef);
+            if (getCurrToken().getType() != TokenType.COMMA) {
+                break;
+            } else {
+                TokenNode comma = new TokenNode(this.ts);
+                addChild(comma);
+            }
+        }
+        if (getCurrToken().getType() != TokenType.SEMICN) {
+            errors.addError(new Error(this.ts.peek(-1).getLine(), ErrorType.i));
+        } else {
+            TokenNode semicoln = new TokenNode(this.ts);
+            addChild(semicoln);
+        }
+    }
+
+    public ArrayList<ConstDef> GetConstDefs() {
+        ArrayList<ConstDef> constDefs = new ArrayList<>();
+        for (int i = 2; i < getChildren().size(); i += 2) {
+            constDefs.add((ConstDef) getChild(i));
+        }
+        return constDefs;
+    }
+}

frontend/ast/decl/ConstDef.java

@@ -0,0 +1,66 @@
+package frontend.ast.decl;
+
+import error.Error;
+import error.ErrorType;
+import error.Errors;
+import frontend.ast.Node;
+import frontend.ast.SyntaxType;
+import frontend.ast.exp.ConstExp;
+import frontend.ast.token.TokenNode;
+import frontend.ast.val.ConstInitVal;
+import frontend.lexer.TokenStream;
+import frontend.lexer.TokenType;
+import midend.symbol.ArraySymbol;
+import midend.symbol.Symbol;
+import midend.symbol.SymbolType;
+
+public class ConstDef extends Node {
+    private boolean isArray;
+
+    public ConstDef(TokenStream ts) {
+        super(SyntaxType.CONST_DEF, ts);
+        isArray = false;
+    }
+
+    public void parse(Errors errors) {
+        TokenNode ident = new TokenNode(this.ts);
+        addChild(ident);
+        if (getCurrToken().getType() == TokenType.LBRACK) {
+            TokenNode lbrack = new TokenNode(this.ts);
+            addChild(lbrack);
+            isArray = true;
+            ConstExp cep = new ConstExp(this.ts);
+            cep.parse(errors);
+            addChild(cep);
+            if (getCurrToken().getType() == TokenType.RBRACK) {
+                TokenNode rbrack = new TokenNode(this.ts);
+                addChild(rbrack);
+            } else {
+                errors.addError(new Error(this.ts.peek(-1).getLine(), ErrorType.k));
+            }
+        }
+        TokenNode assign = new TokenNode(this.ts);
+        addChild(assign);
+        ConstInitVal civ = new ConstInitVal(this.ts);
+        civ.parse(errors);
+        addChild(civ);
+    }
+
+    public Symbol getSymbol() {
+        if (isArray) {
+            TokenNode tn = (TokenNode) getChild(0);
+            ArraySymbol arraySymbol = new ArraySymbol(tn.getName(),
+                    SymbolType.CONST_INT_ARRAY, tn.getLine(),
+                    ((ConstExp) getChild(2)).getValue());
+            arraySymbol.addValue(((ConstInitVal) getChild(getChildren().size() - 1)).getValue());
+            arraySymbol.fullValue();
+            return arraySymbol;
+        } else {
+            TokenNode tn = (TokenNode) getChild(0);
+            Symbol valueSymbol = new Symbol(tn.getName(),
+                    SymbolType.CONST_INT, tn.getLine());
+            valueSymbol.addValue(((ConstInitVal) getChild(getChildren().size() - 1)).getValue());
+            return valueSymbol;
+        }
+    }
+}

frontend/ast/decl/Decl.java

@@ -0,0 +1,25 @@
+package frontend.ast.decl;
+
+import error.Errors;
+import frontend.ast.Node;
+import frontend.ast.SyntaxType;
+import frontend.lexer.TokenStream;
+import frontend.lexer.TokenType;
+
+public class Decl extends Node {
+    public Decl(TokenStream ts) {
+        super(SyntaxType.DECL, ts);
+    }
+
+    public void parse(Errors errors) {
+        if (getCurrToken().getType() == TokenType.CONSTTK) {
+            ConstDecl cd = new ConstDecl(this.ts);
+            cd.parse(errors);
+            addChild(cd);
+        } else {
+            VarDecl vd = new VarDecl(this.ts);
+            vd.parse(errors);
+            addChild(vd);
+        }
+    }
+}

frontend/ast/decl/VarDecl.java

@@ -0,0 +1,59 @@
+package frontend.ast.decl;
+
+import error.ErrorType;
+import error.Errors;
+
+import java.util.ArrayList;
+
+import error.Error;
+import frontend.ast.Node;
+import frontend.ast.SyntaxType;
+import frontend.ast.token.TokenNode;
+import frontend.lexer.TokenStream;
+import frontend.lexer.TokenType;
+
+public class VarDecl extends Node {
+    public VarDecl(TokenStream ts) {
+        super(SyntaxType.VAR_DECL, ts);
+    }
+
+    public void parse(Errors errors) {
+        if (getCurrToken().getType() == TokenType.STATICTK) {
+            TokenNode staitckk = new TokenNode(ts);
+            addChild(staitckk);
+        }
+        TokenNode intkk = new TokenNode(ts);
+        addChild(intkk);
+        while (true) {
+            VarDef vdf = new VarDef(ts);
+            vdf.parse(errors);
+            addChild(vdf);
+            if (getCurrToken().getType() == TokenType.COMMA) {
+                TokenNode comma = new TokenNode(ts);
+                addChild(comma);
+            } else {
+                break;
+            }
+        }
+        if (getCurrToken().getType() == TokenType.SEMICN) {
+            TokenNode semicn = new TokenNode(ts);
+            addChild(semicn);
+        } else {
+            errors.addError(new Error(this.ts.peek(-1).getLine(), ErrorType.i));
+        }
+    }
+
+    public ArrayList<VarDef> GetVarDefs() {
+        ArrayList<VarDef> varDefs = new ArrayList<VarDef>();
+        if (getChild(1) instanceof VarDef) {
+            for (int i = 1; i < getChildren().size(); i += 2) {
+                varDefs.add((VarDef) getChild(i));
+            }
+        } else {
+            for (int i = 2; i < getChildren().size(); i += 2) {
+                varDefs.add((VarDef) getChild(i));
+            }
+        }
+        return varDefs;
+    }
+}

frontend/ast/decl/VarDef.java

@@ -0,0 +1,117 @@
+package frontend.ast.decl;
+
+import error.Errors;
+import error.Error;
+import error.ErrorType;
+import frontend.ast.Node;
+import frontend.ast.SyntaxType;
+import frontend.ast.exp.ConstExp;
+import frontend.ast.token.TokenNode;
+import frontend.lexer.TokenStream;
+import frontend.lexer.TokenType;
+import frontend.ast.val.InitVal;
+
+import midend.symbol.Symbol;
+import midend.symbol.SymbolManager;
+import midend.symbol.SymbolType;
+import midend.symbol.ArraySymbol;
+
+public class VarDef extends Node {
+    private boolean isArray;
+
+    public VarDef(TokenStream ts) {
+        super(SyntaxType.VAR_DEF, ts);
+        isArray = false;
+    }
+
+    public void parse(Errors errors) {
+        TokenNode ident = new TokenNode(this.ts);
+        addChild(ident);
+        if (getCurrToken().getType() == TokenType.LBRACK) {
+            TokenNode lbrack = new TokenNode(this.ts);
+            addChild(lbrack);
+            isArray = true;
+            ConstExp cep = new ConstExp(this.ts);
+            cep.parse(errors);
+            addChild(cep);
+            if (getCurrToken().getType() == TokenType.RBRACK) {
+                TokenNode rbrack = new TokenNode(this.ts);
+                addChild(rbrack);
+            } else {
+                errors.addError(new Error(this.ts.peek(-1).getLine(), ErrorType.k));
+            }
+        }
+        if (getCurrToken().getType() == TokenType.ASSIGN) {
+            TokenNode assign = new TokenNode(this.ts);
+            addChild(assign);
+            InitVal itv = new InitVal(this.ts);
+            itv.parse(errors);
+            addChild(itv);
+        }
+    }
+
+    public Symbol getSymbol(int isStatic) {
+        if (isStatic == 1) { //static修饰的变量有初值
+            if (isArray) {
+                TokenNode tn = (TokenNode) getChild(0);
+                ArraySymbol arraySymbol = new ArraySymbol(tn.getName(),
+                        SymbolType.STATIC_INT_ARRAY, tn.getLine(),
+                        ((ConstExp) getChild(2)).getValue());
+                if (HaveInitVal()) {
+                    arraySymbol.addValue(((InitVal) getChild(getChildren().size() - 1)).getValue());
+                }
+                arraySymbol.fullValue();
+                return arraySymbol;
+            } else {
+                TokenNode tn = (TokenNode) getChild(0);
+                Symbol valueSymbol = new Symbol(tn.getName(),
+                        SymbolType.STATIC_INT, tn.getLine());
+                if (HaveInitVal()) {
+                    valueSymbol.addValue(((InitVal) getChild(getChildren().size() - 1)).getValue());
+                } else {
+                    valueSymbol.addValue(0);
+                }
+                return valueSymbol;
+            }
+        } else { //要判断是否为全局变量，如果为全局变量，也应该赋初值
+            if (isArray) {
+                TokenNode tn = (TokenNode) getChild(0);
+                ArraySymbol arraySymbol = new ArraySymbol(tn.getName(),
+                        SymbolType.INT_ARRAY, tn.getLine(),
+                        ((ConstExp) getChild(2)).getValue());
+                if (SymbolManager.IsGlobal()) {
+                    if (HaveInitVal()) {
+                        arraySymbol.addValue(((InitVal) getChild(
+                                getChildren().size() - 1)).getValue());
+                    }
+                    arraySymbol.fullValue();
+                }
+                return arraySymbol;
+            } else {
+                TokenNode tn = (TokenNode) getChild(0);
+                Symbol symbol = new Symbol(tn.getName(),
+                        SymbolType.INT, tn.getLine());
+                if (SymbolManager.IsGlobal()) {
+                    if (HaveInitVal()) {
+                        symbol.addValue(((InitVal) getChild(
+                                getChildren().size() - 1)).getValue());
+                    } else {
+                        symbol.addValue(0);
+                    }
+                }
+                return symbol;
+            }
+        }
+    }
+
+    public boolean HaveInitVal() {
+        return getChild(getChildren().size() - 1) instanceof InitVal;
+    }
+
+    public InitVal getInitVal() {
+        if (HaveInitVal()) {
+            return (InitVal) getChild(getChildren().size() - 1);
+        }
+        return null;
+    }
+}