package IR.Tree;
import IR.*;
import Util.Lattice;
-
import java.util.*;
-
-
public class BuildIR {
State state;
}
}
-public void parseInitializers(ClassDescriptor cn){
- Vector fv=cn.getFieldVec();
+ public void parseInitializers(ClassDescriptor cn){
+ Vector fv=cn.getFieldVec();
int pos = 0;
- for(int i=0;i<fv.size();i++) {
+ for(int i=0;i<fv.size();i++) {
FieldDescriptor fd=(FieldDescriptor)fv.get(i);
if(fd.getExpressionNode()!=null) {
- Iterator methodit = cn.getMethods();
- while(methodit.hasNext()){
- MethodDescriptor currmd=(MethodDescriptor)methodit.next();
- if(currmd.isConstructor()){
- BlockNode bn=state.getMethodBody(currmd);
- NameNode nn=new NameNode(new NameDescriptor(fd.getSymbol()));
- AssignmentNode an=new AssignmentNode(nn,fd.getExpressionNode(),new AssignOperation(1));
- bn.addBlockStatementAt(new BlockExpressionNode(an), pos);
- }
- }
- pos++;
+ Iterator methodit = cn.getMethods();
+ while(methodit.hasNext()){
+ MethodDescriptor currmd=(MethodDescriptor)methodit.next();
+ if(currmd.isConstructor()){
+ BlockNode bn=state.getMethodBody(currmd);
+ NameNode nn=new NameNode(new NameDescriptor(fd.getSymbol()));
+ AssignmentNode an=new AssignmentNode(nn,fd.getExpressionNode(),new AssignOperation(1));
+ bn.addBlockStatementAt(new BlockExpressionNode(an), pos);
+ }
+ }
+ pos++;
}
- }
- }
-
+ }
+ }
+
private ClassDescriptor parseEnumDecl(ClassDescriptor cn, ParseNode pn) {
ClassDescriptor ecd=new ClassDescriptor(pn.getChild("name").getTerminal(), false);
ecd.setAsEnum();
}
}
if(spinLocSet.size()>0){
+ //checking if location is actually defined in the hierarchy
+ for (Iterator iterator = spinLocSet.iterator(); iterator.hasNext();) {
+ String locID = (String) iterator.next();
+ if(!locOrder.containsKey(locID)){
+ throw new Error("Error: The spinning location '"+
+ locID + "' is not defined in the hierarchy of the class '"+cd +"'.");
+ }
+ }
state.addLocationPropertySet(cd, spinLocSet);
}
state.addLocationOrder(cd, locOrder);
}
}
+ int innerCount=0;
+
private ExpressionNode parseExpression(ParseNode pn) {
if (isNode(pn,"assignment"))
return parseAssignmentExpression(pn);
con.addFlagEffects(fe);
}
+ return con;
+ } else if (isNode(pn,"createobjectcls")) {
+ //TODO::: FIX BUG!!! static fields in caller context need to become parameters
+ TypeDescriptor td=parseTypeDescriptor(pn);
+ innerCount++;
+ ClassDescriptor cnnew=new ClassDescriptor(td.getSymbol()+"$"+innerCount, false);
+ cnnew.setSuper(td.getSymbol());
+ parseClassBody(cnnew, pn.getChild("decl").getChild("classbody"));
+ Vector args=parseArgumentList(pn);
+
+ CreateObjectNode con=new CreateObjectNode(td, false, null);
+ con.setNumLine(pn.getLine());
+ for(int i=0; i<args.size(); i++) {
+ con.addArgument((ExpressionNode)args.get(i));
+ }
+
return con;
} else if (isNode(pn,"createarray")) {
//System.out.println(pn.PPrint(3,true));
String paramname=paramn.getChild("single").getTerminal();
TypeDescriptor type=new TypeDescriptor(TypeDescriptor.TAG);
md.addTagParameter(type, paramname);
- } else {
+ } else {
+
TypeDescriptor type=parseTypeDescriptor(paramn);
ParseNode tmp=paramn;
String paramname=tmp.getChild("single").getTerminal();
md.addParameter(type, paramname);
+ if(isNode(paramn, "annotation_parameter")){
+ ParseNode bodynode=paramn.getChild("annotation_body");
+ parseParameterAnnotation(bodynode,type);
+ }
+
}
}
}
}
}
}
-
+
+ private void parseParameterAnnotation(ParseNode body_list,TypeDescriptor type){
+ ParseNode body_node = body_list.getFirstChild();
+ if (isNode(body_node, "marker_annotation")) {
+ type.addAnnotationMarker(new AnnotationDescriptor(body_node.getChild("name").getTerminal()));
+ } else if (isNode(body_node, "single_annotation")) {
+ type.addAnnotationMarker(new AnnotationDescriptor(body_node.getChild("name").getTerminal(),
+ body_node.getChild("element_value").getTerminal()));
+ } else if (isNode(body_node, "normal_annotation")) {
+ throw new Error("Annotation with multiple data members is not supported yet.");
+ }
+ }
+
private boolean isNode(ParseNode pn, String label) {
if (pn.getLabel().equals(label))
return true;