From fb5e6c9a3b75668af62e9d6a3f16d27107aee110 Mon Sep 17 00:00:00 2001 From: bdemsky Date: Wed, 22 Feb 2006 19:36:20 +0000 Subject: [PATCH] checking in changes --- Robust/src/IR/AssignOperation.java | 28 ++++ Robust/src/IR/ClassDescriptor.java | 44 ++++-- Robust/src/IR/FieldDescriptor.java | 4 + Robust/src/IR/Flat/BuildFlat.java | 109 +++++++++++-- Robust/src/IR/Flat/FlatCall.java | 26 ++++ Robust/src/IR/Flat/FlatCastNode.java | 18 +++ Robust/src/IR/Flat/FlatCondBranch.java | 10 ++ Robust/src/IR/Flat/FlatFieldNode.java | 22 +++ Robust/src/IR/Flat/FlatLiteralNode.java | 40 +++++ Robust/src/IR/Flat/FlatMethod.java | 70 ++++++++- Robust/src/IR/Flat/FlatNew.java | 16 ++ Robust/src/IR/Flat/FlatNode.java | 22 ++- Robust/src/IR/MethodDescriptor.java | 26 ++++ Robust/src/IR/State.java | 15 +- Robust/src/IR/SymbolTable.java | 15 +- Robust/src/IR/Tree/AssignmentNode.java | 12 ++ Robust/src/IR/Tree/BlockNode.java | 8 + Robust/src/IR/Tree/BuildIR.java | 14 +- Robust/src/IR/Tree/CastNode.java | 8 + Robust/src/IR/Tree/CreateObjectNode.java | 22 +++ Robust/src/IR/Tree/ExpressionNode.java | 4 + Robust/src/IR/Tree/FieldAccessNode.java | 14 ++ Robust/src/IR/Tree/LiteralNode.java | 7 +- Robust/src/IR/Tree/MethodInvokeNode.java | 24 +++ Robust/src/IR/Tree/SemanticCheck.java | 189 +++++++++++++++++++++++ Robust/src/IR/TypeDescriptor.java | 26 +++- Robust/src/IR/VarDescriptor.java | 4 + Robust/src/Main/Main.java | 5 + Robust/src/Parse/java14.cup | 15 +- Robust/src/t.test | 5 + 30 files changed, 771 insertions(+), 51 deletions(-) create mode 100644 Robust/src/IR/Flat/FlatCall.java create mode 100644 Robust/src/IR/Flat/FlatCastNode.java create mode 100644 Robust/src/IR/Flat/FlatFieldNode.java create mode 100644 Robust/src/IR/Flat/FlatLiteralNode.java create mode 100644 Robust/src/IR/Flat/FlatNew.java create mode 100644 Robust/src/IR/Tree/SemanticCheck.java diff --git a/Robust/src/IR/AssignOperation.java b/Robust/src/IR/AssignOperation.java index e8dce7de..2abd7c8e 100644 --- a/Robust/src/IR/AssignOperation.java +++ b/Robust/src/IR/AssignOperation.java @@ -23,6 +23,34 @@ public class AssignOperation { this.operation=parseOp(op); } + public Operation getBaseOp() { + switch(operation) { + case EQ: + return null; + case MULTEQ: + return new Operation(Operation.MULT); + case DIVEQ: + return new Operation(Operation.DIV); + case MODEQ: + return new Operation(Operation.MOD); + case PLUSEQ: + return new Operation(Operation.ADD); + case MINUSEQ: + return new Operation(Operation.SUB); + case LSHIFTEQ: + return new Operation(Operation.LEFTSHIFT); + case RSHIFTEQ: + return new Operation(Operation.RIGHTSHIFT); + case ANDEQ: + return new Operation(Operation.BIT_AND); + case XOREQ: + return new Operation(Operation.BIT_XOR); + case OREQ: + return new Operation(Operation.BIT_OR); + } + throw new Error(); + } + public static int parseOp(String st) { if (st.equals("eq")) return EQ; diff --git a/Robust/src/IR/ClassDescriptor.java b/Robust/src/IR/ClassDescriptor.java index 353ab00f..72b0802a 100644 --- a/Robust/src/IR/ClassDescriptor.java +++ b/Robust/src/IR/ClassDescriptor.java @@ -1,27 +1,40 @@ package IR; import java.util.*; import IR.Tree.*; +import IR.SymbolTable; import IR.FieldDescriptor; import IR.MethodDescriptor; import IR.NameDescriptor; -public class ClassDescriptor { - public ClassDescriptor() { - classname=null; +public class ClassDescriptor extends Descriptor { + public ClassDescriptor(String classname) { + super(classname); + this.classname=classname; superclass=null; - fields=new Vector(); - methods=new Vector(); + fields=new SymbolTable(); + methods=new SymbolTable(); } + String classname; - NameDescriptor superclass; + String superclass; Modifiers modifiers; - Vector fields; - Vector methods; + + SymbolTable fields; + SymbolTable methods; + public Iterator getMethods() { - return methods.iterator(); + return methods.getDescriptorsIterator(); + } + + public Iterator getFields() { + return fields.getDescriptorsIterator(); } + public SymbolTable getFieldTable() { + return fields; + } + public String printTree(State state) { int indent; String st=modifiers.toString()+"class "+classname; @@ -29,15 +42,16 @@ public class ClassDescriptor { st+="extends "+superclass.toString(); st+=" {\n"; indent=TreeNode.INDENT; - for(int i=0;i0) st+="\n"; - for(int i=0;i0) { + //1) Edge >1 of node + nodetolabel.put(nn,new Integer(labelindex++)); + } + if (!visited.contains(nn)) { + tovisit.add(nn); + } else { + //2) Join point + nodetolabel.put(nn,new Integer(labelindex++)); + } + } + } + + //Do the actual printing + tovisit=new HashSet(); + visited=new HashSet(); + tovisit.add(method_entry); + while(!tovisit.isEmpty()) { + if (current_node==null) { + current_node=(FlatNode)tovisit.iterator().next(); + tovisit.remove(current_node); + } + visited.add(current_node); + if (nodetolabel.containsKey(current_node)) + st+="L"+nodetolabel.get(current_node)+":\n"; + st+=current_node.toString(); + if (current_node.numNext()==0) { + current_node=null; + } else if(current_node.numNext()==1) { + FlatNode nextnode=current_node.getNext(0); + if (visited.contains(nextnode)) { + st+="goto L"+nodetolabel.get(nextnode)+"\n"; + current_node=null; + } else + current_node=nextnode; + } else if (current_node.numNext()==2) { + /* Branch */ + st+=((FlatCondBranch)current_node).toString("L"+nodetolabel.get(current_node.getNext(1))); + if (visited.contains(current_node.getNext(0))) { + st+="goto L"+nodetolabel.get(current_node.getNext(0))+"\n"; + current_node=null; + } else + current_node=current_node.getNext(0); + if (!visited.contains(current_node.getNext(1))) + tovisit.add(current_node.getNext(1)); + } else throw new Error(); + } + return st; + } + } diff --git a/Robust/src/IR/Flat/FlatNew.java b/Robust/src/IR/Flat/FlatNew.java new file mode 100644 index 00000000..e8aeaa63 --- /dev/null +++ b/Robust/src/IR/Flat/FlatNew.java @@ -0,0 +1,16 @@ +package IR.Flat; +import IR.TypeDescriptor; + +public class FlatNew extends FlatNode { + TempDescriptor dst; + TypeDescriptor type; + + public FlatNew(TypeDescriptor type, TempDescriptor dst) { + this.type=type; + this.dst=dst; + } + + public String toString() { + return dst.toString()+"= NEW "+type.toString(); + } +} diff --git a/Robust/src/IR/Flat/FlatNode.java b/Robust/src/IR/Flat/FlatNode.java index b53eb433..4824875a 100644 --- a/Robust/src/IR/Flat/FlatNode.java +++ b/Robust/src/IR/Flat/FlatNode.java @@ -2,13 +2,31 @@ package IR.Flat; import java.util.Vector; public class FlatNode { - Vector next; - + protected Vector next; + protected Vector prev; public String toString() { throw new Error(); } + public int numNext() { + return next.size(); + } + public FlatNode getNext(int i) { + return (FlatNode) next.get(i); + } + + public int numPrev() { + return prev.size(); + } + public FlatNode getPrev(int i) { + return (FlatNode) prev.get(i); + } + public void addNext(FlatNode n) { next.add(n); + n.addPrev(this); + } + protected void addPrev(FlatNode p) { + prev.add(p); } } diff --git a/Robust/src/IR/MethodDescriptor.java b/Robust/src/IR/MethodDescriptor.java index a7df7866..28eb9724 100644 --- a/Robust/src/IR/MethodDescriptor.java +++ b/Robust/src/IR/MethodDescriptor.java @@ -16,6 +16,7 @@ public class MethodDescriptor extends Descriptor { protected String identifier; protected Vector param_name; protected Vector param_type; + protected SymbolTable paramtable; public MethodDescriptor(Modifiers m, TypeDescriptor rt, String identifier) { super(identifier); @@ -26,10 +27,35 @@ public class MethodDescriptor extends Descriptor { this.uniqueid=count++; param_name=new Vector(); param_type=new Vector(); + paramtable=new SymbolTable(); } + public TypeDescriptor getReturnType() { + return returntype; + } + + public SymbolTable getParameterTable() { + return paramtable; + } + public void addParameter(TypeDescriptor type, String paramname) { param_name.add(paramname); param_type.add(type); + if (paramtable.getFromSameScope(paramname)!=null) { + throw new Error("Parameter "+paramname+" already defined"); + } + paramtable.add(paramname,type); + } + + public int numParameters() { + return param_name.size(); + } + + public String getParamName(int i) { + return (String) param_name.get(i); + } + + public TypeDescriptor getParamType(int i) { + return (TypeDescriptor) param_type.get(i); } public String toString() { diff --git a/Robust/src/IR/State.java b/Robust/src/IR/State.java index 1bd8067e..a83b1af7 100644 --- a/Robust/src/IR/State.java +++ b/Robust/src/IR/State.java @@ -6,16 +6,14 @@ import java.util.*; public class State { public State(ParseNode parsetree) { - globals=new SymbolTable(); this.parsetree=parsetree; - this.classset=new HashSet(); + this.classes=new SymbolTable(); this.treemethodmap=new Hashtable(); this.flatmethodmap=new Hashtable(); } - public SymbolTable globals; + public SymbolTable classes; public ParseNode parsetree; - public HashSet classset; public Hashtable treemethodmap; public Hashtable flatmethodmap; @@ -30,12 +28,17 @@ public class State { } public void addClass(ClassDescriptor tdn) { - classset.add(tdn); + if (classes.contains(tdn.getSymbol())) + throw new Error("Class "+tdn.getSymbol()+" defined twice"); + classes.add(tdn); } public BlockNode getMethodBody(MethodDescriptor md) { return (BlockNode)treemethodmap.get(md); - + } + + public SymbolTable getClassSymbolTable() { + return classes; } public FlatMethod getMethodFlat(MethodDescriptor md) { diff --git a/Robust/src/IR/SymbolTable.java b/Robust/src/IR/SymbolTable.java index 7203183e..a7218ffd 100644 --- a/Robust/src/IR/SymbolTable.java +++ b/Robust/src/IR/SymbolTable.java @@ -17,17 +17,12 @@ public class SymbolTable { this.parent = parent; } - //public void add(String name, Descriptor d) { - //table.put(name, d); - //} - public void add(Descriptor d) { - table.put(d.getSymbol(), d); + add(d.getSymbol(), d); } public void add(String name, Descriptor d) { table.put(name, d); - } public void dump() { @@ -59,10 +54,18 @@ public class SymbolTable { return table.keys(); } + public Iterator getNamesIterator() { + return table.keySet().iterator(); + } + public Enumeration getDescriptors() { return table.elements(); } + public Iterator getDescriptorsIterator() { + return table.values().iterator(); + } + public Iterator descriptors() { return table.values().iterator(); } diff --git a/Robust/src/IR/Tree/AssignmentNode.java b/Robust/src/IR/Tree/AssignmentNode.java index f30ccb56..31f5b4fa 100644 --- a/Robust/src/IR/Tree/AssignmentNode.java +++ b/Robust/src/IR/Tree/AssignmentNode.java @@ -11,6 +11,18 @@ public class AssignmentNode extends ExpressionNode { right=r; this.op=op; } + + public ExpressionNode getDest() { + return left; + } + + public ExpressionNode getSrc() { + return right; + } + + public AssignOperation getOperation() { + return op; + } public String printNode(int indent) { return left.printNode(indent)+" "+op.toString()+" "+right.printNode(indent); diff --git a/Robust/src/IR/Tree/BlockNode.java b/Robust/src/IR/Tree/BlockNode.java index 94179eea..62b3b67d 100644 --- a/Robust/src/IR/Tree/BlockNode.java +++ b/Robust/src/IR/Tree/BlockNode.java @@ -1,15 +1,23 @@ package IR.Tree; import java.util.Vector; +import IR.*; public class BlockNode extends TreeNode { Vector blockstatements; int printStyle=0; + protected SymbolTable table; + public final static int NORMAL=0; public final static int NOBRACES=1; public final static int EXPRLIST=2; public BlockNode() { blockstatements=new Vector(); + table=new SymbolTable(); + } + + public SymbolTable getVarTable() { + return table; } public void addBlockStatement(BlockStatementNode bsn) { diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java index 0dafcc9d..0995b447 100644 --- a/Robust/src/IR/Tree/BuildIR.java +++ b/Robust/src/IR/Tree/BuildIR.java @@ -29,10 +29,12 @@ public class BuildIR { public ClassDescriptor parseTypeDecl(ParseNode pn) { if (isNode(pn, "class_declaration")) { - ClassDescriptor cn=new ClassDescriptor(); - cn.setName(pn.getChild("name").getTerminal()); + ClassDescriptor cn=new ClassDescriptor(pn.getChild("name").getTerminal()); if (!isEmpty(pn.getChild("super").getTerminal())) { /* parse superclass name */ + ParseNode snn=pn.getChild("super").getChild("type").getChild("class").getChild("name"); + NameDescriptor nd=parseName(snn); + cn.setSuper(nd.toString()); } cn.setModifiers(parseModifiersList(pn.getChild("modifiers"))); parseClassBody(cn, pn.getChild("classbody")); @@ -315,6 +317,14 @@ public class BuildIR { ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild()); BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild()); blockstatements.add(new LoopNode(init,condition,update,body)); + } else if (isNode(pn,"whilestatement")) { + ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild()); + BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild()); + blockstatements.add(new LoopNode(condition,body,LoopNode.WHILELOOP)); + } else if (isNode(pn,"dowhilestatement")) { + ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild()); + BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild()); + blockstatements.add(new LoopNode(condition,body,LoopNode.DOWHILELOOP)); } else { System.out.println("---------------"); System.out.println(pn.PPrint(3,true)); diff --git a/Robust/src/IR/Tree/CastNode.java b/Robust/src/IR/Tree/CastNode.java index e4f82ec4..4e7dd8dd 100644 --- a/Robust/src/IR/Tree/CastNode.java +++ b/Robust/src/IR/Tree/CastNode.java @@ -18,6 +18,14 @@ public class CastNode extends ExpressionNode { this.etd=type; } + public TypeDescriptor getType() { + return td; + } + + public ExpressionNode getExpression() { + return exp; + } + public String printNode(int indentlevel) { if (etd==null) return "("+td.toString()+")"+exp.printNode(indentlevel); diff --git a/Robust/src/IR/Tree/CreateObjectNode.java b/Robust/src/IR/Tree/CreateObjectNode.java index 99b6783b..1d28efcf 100644 --- a/Robust/src/IR/Tree/CreateObjectNode.java +++ b/Robust/src/IR/Tree/CreateObjectNode.java @@ -1,10 +1,12 @@ package IR.Tree; import java.util.Vector; import IR.TypeDescriptor; +import IR.MethodDescriptor; public class CreateObjectNode extends ExpressionNode { TypeDescriptor td; Vector argumentlist; + MethodDescriptor md; public CreateObjectNode(TypeDescriptor type) { td=type; @@ -14,6 +16,26 @@ public class CreateObjectNode extends ExpressionNode { argumentlist.add(en); } + public void setConstructor(MethodDescriptor md) { + this.md=md; + } + + public MethodDescriptor getConstructor() { + return md; + } + + public TypeDescriptor getType() { + return td; + } + + public int numArgs() { + return argumentlist.size(); + } + + public ExpressionNode getArg(int i) { + return (ExpressionNode) argumentlist.get(i); + } + public String printNode(int indent) { String st="new "+td.toString()+"("; for(int i=0;i=BYTE)&&(type<=DOUBLE)); + } + + public boolean isClass() { + return type==CLASS; + } + public TypeDescriptor(NameDescriptor name) { super(name.toString()); this.type=CLASS; this.name_desc=name; + this.class_desc=null; } public TypeDescriptor(int t) { @@ -59,6 +79,8 @@ public class TypeDescriptor extends Descriptor { return "double"; else if (type==VOID) return "void"; + else if (type==NULL) + return "null"; else throw new Error(); } } diff --git a/Robust/src/IR/VarDescriptor.java b/Robust/src/IR/VarDescriptor.java index d8726f28..42038b2a 100644 --- a/Robust/src/IR/VarDescriptor.java +++ b/Robust/src/IR/VarDescriptor.java @@ -25,6 +25,10 @@ public class VarDescriptor extends Descriptor { return identifier; } + public TypeDescriptor getType() { + return td; + } + public String toString() { return td.toString()+" "+identifier; } diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java index 8eebe0a1..e9d89b96 100644 --- a/Robust/src/Main/Main.java +++ b/Robust/src/Main/Main.java @@ -5,6 +5,7 @@ import java.io.BufferedReader; import java.io.FileReader; import IR.Tree.ParseNode; import IR.Tree.BuildIR; +import IR.Tree.SemanticCheck; import IR.Flat.BuildFlat; import IR.State; @@ -21,8 +22,12 @@ public class Main { ParseNode p=(ParseNode) g./*debug_*/parse().value; // System.out.println(p.PPrint(2,true)); State state=new State(p); + BuildIR bir=new BuildIR(state); bir.buildtree(); + + SemanticCheck sc=new SemanticCheck(state); + sc.semanticCheck(); BuildFlat bf=new BuildFlat(state); bf.buildFlat(); diff --git a/Robust/src/Parse/java14.cup b/Robust/src/Parse/java14.cup index 74945097..761df786 100644 --- a/Robust/src/Parse/java14.cup +++ b/Robust/src/Parse/java14.cup @@ -178,7 +178,7 @@ non terminal ParseNode if_then_else_statement, if_then_else_statement_no_short_i //non terminal ParseNode switch_block_statement_group; //non terminal ParseNode switch_labels, switch_label; non terminal ParseNode while_statement, while_statement_no_short_if; -//non terminal ParseNode do_statement; +non terminal ParseNode do_statement; non terminal ParseNode for_statement, for_statement_no_short_if; non terminal ParseNode for_init_opt, for_init; non terminal ParseNode for_update_opt, for_update; @@ -774,7 +774,7 @@ statement_without_trailing_substatement ::= | empty_statement:st {: RESULT=st; :} | expression_statement:st {: RESULT=st; :} // | switch_statement -// | do_statement + | do_statement | break_statement:st {: RESULT=st; :} | continue_statement:st {: RESULT=st; :} | return_statement:st {: RESULT=st; :} @@ -876,9 +876,14 @@ while_statement_no_short_if ::= RESULT=pn; :} ; -//do_statement ::= -// DO statement WHILE LPAREN expression RPAREN SEMICOLON -// ; +do_statement ::= + DO statement:st WHILE LPAREN expression:exp RPAREN SEMICOLON {: + ParseNode pn=new ParseNode("dowhilestatement"); + pn.addChild("condition").addChild(exp); + pn.addChild("statement").addChild(st); + RESULT=pn; + :} + ; for_statement ::= FOR LPAREN for_init_opt:init SEMICOLON expression_opt:exp SEMICOLON for_update_opt:update RPAREN statement:st {: diff --git a/Robust/src/t.test b/Robust/src/t.test index 9e40fa59..1e99ef98 100644 --- a/Robust/src/t.test +++ b/Robust/src/t.test @@ -216,3 +216,8 @@ public class ParseNode { } +public class String {} + +public class ParseNodeVector {} + +public class Object {} -- 2.34.1