+ private void assignAnnotationsToType(Modifiers modifiers, TypeDescriptor type){
+ Vector<AnnotationDescriptor> annotations=modifiers.getAnnotations();
+ for(int i=0; i<annotations.size(); i++) {
+ // it only supports a marker annotation
+ AnnotationDescriptor an=annotations.elementAt(i);
+ type.addAnnotationMarker(an);
+ }
+ }
+
+ private ExpressionNode parseExpression(ParseNode pn) {
+ if (isNode(pn,"assignment"))
+ return parseAssignmentExpression(pn);
+ else if (isNode(pn,"logical_or")||isNode(pn,"logical_and")||
+ isNode(pn,"bitwise_or")||isNode(pn,"bitwise_xor")||
+ isNode(pn,"bitwise_and")||isNode(pn,"equal")||
+ isNode(pn,"not_equal")||isNode(pn,"comp_lt")||
+ isNode(pn,"comp_lte")||isNode(pn,"comp_gt")||
+ isNode(pn,"comp_gte")||isNode(pn,"leftshift")||
+ isNode(pn,"rightshift")||isNode(pn,"sub")||
+ isNode(pn,"urightshift")||isNode(pn,"sub")||
+ isNode(pn,"add")||isNode(pn,"mult")||
+ isNode(pn,"div")||isNode(pn,"mod")) {
+ ParseNodeVector pnv=pn.getChildren();
+ ParseNode left=pnv.elementAt(0);
+ ParseNode right=pnv.elementAt(1);
+ Operation op=new Operation(pn.getLabel());
+ OpNode on=new OpNode(parseExpression(left),parseExpression(right),op);
+ on.setNumLine(pn.getLine());
+ return on;
+ } else if (isNode(pn,"unaryplus")||
+ isNode(pn,"unaryminus")||
+ isNode(pn,"not")||
+ isNode(pn,"comp")) {
+ ParseNode left=pn.getFirstChild();
+ Operation op=new Operation(pn.getLabel());
+ OpNode on=new OpNode(parseExpression(left),op);
+ on.setNumLine(pn.getLine());
+ return on;
+ } else if (isNode(pn,"postinc")||
+ isNode(pn,"postdec")) {
+ ParseNode left=pn.getFirstChild();
+ AssignOperation op=new AssignOperation(pn.getLabel());
+ AssignmentNode an=new AssignmentNode(parseExpression(left),null,op);
+ an.setNumLine(pn.getLine());
+ return an;
+
+ } else if (isNode(pn,"preinc")||
+ isNode(pn,"predec")) {
+ ParseNode left=pn.getFirstChild();
+ AssignOperation op=isNode(pn,"preinc") ? new AssignOperation(AssignOperation.PLUSEQ) : new AssignOperation(AssignOperation.MINUSEQ);
+ AssignmentNode an=new AssignmentNode(parseExpression(left),
+ new LiteralNode("integer",new Integer(1)),op);
+ an.setNumLine(pn.getLine());
+ return an;
+ } else if (isNode(pn,"literal")) {
+ String literaltype=pn.getTerminal();
+ ParseNode literalnode=pn.getChild(literaltype);
+ Object literal_obj=literalnode.getLiteral();
+ LiteralNode ln=new LiteralNode(literaltype, literal_obj);
+ ln.setNumLine(pn.getLine());
+ return ln;
+ } else if (isNode(pn,"createobject")) {
+ TypeDescriptor td=parseTypeDescriptor(pn);
+
+ Vector args=parseArgumentList(pn);
+ boolean isglobal=pn.getChild("global")!=null||
+ pn.getChild("scratch")!=null;
+ String disjointId=null;
+ if( pn.getChild("disjoint") != null) {
+ disjointId = pn.getChild("disjoint").getTerminal();
+ }
+ CreateObjectNode con=new CreateObjectNode(td, isglobal, disjointId);
+ con.setNumLine(pn.getLine());
+ for(int i=0; i<args.size(); i++) {
+ con.addArgument((ExpressionNode)args.get(i));
+ }
+ /* Could have flag set or tag added here */
+ if (pn.getChild("flag_list")!=null||pn.getChild("tag_list")!=null) {
+ FlagEffects fe=new FlagEffects(null);
+ if (pn.getChild("flag_list")!=null)
+ parseFlagEffect(fe, pn.getChild("flag_list"));
+
+ if (pn.getChild("tag_list")!=null)
+ parseTagEffect(fe, pn.getChild("tag_list"));
+ con.addFlagEffects(fe);
+ }
+
+ return con;
+ } else if (isNode(pn,"createarray")) {
+ //System.out.println(pn.PPrint(3,true));
+ boolean isglobal=pn.getChild("global")!=null||
+ pn.getChild("scratch")!=null;
+ String disjointId=null;
+ if( pn.getChild("disjoint") != null) {
+ disjointId = pn.getChild("disjoint").getTerminal();
+ }
+ TypeDescriptor td=parseTypeDescriptor(pn);
+ Vector args=parseDimExprs(pn);
+ int num=0;
+ if (pn.getChild("dims_opt").getLiteral()!=null)
+ num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
+ for(int i=0; i<(args.size()+num); i++)
+ td=td.makeArray(state);
+ CreateObjectNode con=new CreateObjectNode(td, isglobal, disjointId);
+ con.setNumLine(pn.getLine());
+ for(int i=0; i<args.size(); i++) {
+ con.addArgument((ExpressionNode)args.get(i));
+ }
+ return con;
+ } if (isNode(pn,"createarray2")) {
+ TypeDescriptor td=parseTypeDescriptor(pn);
+ int num=0;
+ if (pn.getChild("dims_opt").getLiteral()!=null)
+ num=((Integer)pn.getChild("dims_opt").getLiteral()).intValue();
+ for(int i=0; i<num; i++)
+ td=td.makeArray(state);
+ CreateObjectNode con=new CreateObjectNode(td, false, null);
+ con.setNumLine(pn.getLine());
+ ParseNode ipn = pn.getChild("initializer");
+ Vector initializers=parseVariableInitializerList(ipn);
+ ArrayInitializerNode ain = new ArrayInitializerNode(initializers);
+ ain.setNumLine(pn.getLine());
+ con.addArrayInitializer(ain);
+ return con;
+ } else if (isNode(pn,"name")) {
+ NameDescriptor nd=parseName(pn);
+ NameNode nn=new NameNode(nd);
+ nn.setNumLine(pn.getLine());
+ return nn;
+ } else if (isNode(pn,"this")) {
+ NameDescriptor nd=new NameDescriptor("this");
+ NameNode nn=new NameNode(nd);
+ nn.setNumLine(pn.getLine());
+ return nn;
+ } else if (isNode(pn,"isavailable")) {
+ NameDescriptor nd=new NameDescriptor(pn.getTerminal());
+ NameNode nn=new NameNode(nd);
+ nn.setNumLine(pn.getLine());
+ return new OpNode(nn,null,new Operation(Operation.ISAVAILABLE));
+ } else if (isNode(pn,"methodinvoke1")) {
+ NameDescriptor nd=parseName(pn.getChild("name"));
+ Vector args=parseArgumentList(pn);
+ MethodInvokeNode min=new MethodInvokeNode(nd);
+ min.setNumLine(pn.getLine());
+ for(int i=0; i<args.size(); i++) {
+ min.addArgument((ExpressionNode)args.get(i));
+ }
+ return min;
+ } else if (isNode(pn,"methodinvoke2")) {
+ String methodid=pn.getChild("id").getTerminal();
+ ExpressionNode exp=parseExpression(pn.getChild("base").getFirstChild());
+ Vector args=parseArgumentList(pn);
+ MethodInvokeNode min=new MethodInvokeNode(methodid,exp);
+ min.setNumLine(pn.getLine());
+ for(int i=0; i<args.size(); i++) {
+ min.addArgument((ExpressionNode)args.get(i));
+ }
+ return min;
+ } else if (isNode(pn,"fieldaccess")) {
+ ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
+ String fieldname=pn.getChild("field").getTerminal();
+
+ FieldAccessNode fan=new FieldAccessNode(en,fieldname);
+ fan.setNumLine(pn.getLine());
+ return fan;
+ } else if (isNode(pn,"arrayaccess")) {
+ ExpressionNode en=parseExpression(pn.getChild("base").getFirstChild());
+ ExpressionNode index=parseExpression(pn.getChild("index").getFirstChild());
+ ArrayAccessNode aan=new ArrayAccessNode(en,index);
+ aan.setNumLine(pn.getLine());
+ return aan;
+ } else if (isNode(pn,"cast1")) {
+ try {
+ CastNode cn=new CastNode(parseTypeDescriptor(pn.getChild("type")),parseExpression(pn.getChild("exp").getFirstChild()));
+ cn.setNumLine(pn.getLine());
+ return cn;
+ } catch (Exception e) {
+ System.out.println(pn.PPrint(1,true));
+ e.printStackTrace();
+ throw new Error();
+ }
+ } else if (isNode(pn,"cast2")) {
+ CastNode cn=new CastNode(parseExpression(pn.getChild("type").getFirstChild()),parseExpression(pn.getChild("exp").getFirstChild()));
+ cn.setNumLine(pn.getLine());
+ return cn;
+ } else if (isNode(pn, "getoffset")) {
+ TypeDescriptor td=parseTypeDescriptor(pn);
+ String fieldname = pn.getChild("field").getTerminal();
+ //System.out.println("Checking the values of: "+ " td.toString()= " + td.toString()+ " fieldname= " + fieldname);
+ return new OffsetNode(td, fieldname);
+ } else if (isNode(pn, "tert")) {
+
+ TertiaryNode tn=new TertiaryNode(parseExpression(pn.getChild("cond").getFirstChild()),
+ parseExpression(pn.getChild("trueexpr").getFirstChild()),
+ parseExpression(pn.getChild("falseexpr").getFirstChild()) );
+ tn.setNumLine(pn.getLine());
+
+ return tn;
+ } else if (isNode(pn, "instanceof")) {
+ ExpressionNode exp=parseExpression(pn.getChild("exp").getFirstChild());
+ TypeDescriptor t=parseTypeDescriptor(pn);
+ InstanceOfNode ion=new InstanceOfNode(exp,t);
+ ion.setNumLine(pn.getLine());
+ return ion;
+ } else if (isNode(pn, "array_initializer")) {
+ Vector initializers=parseVariableInitializerList(pn);
+ return new ArrayInitializerNode(initializers);
+ } else if (isNode(pn, "class_type")) {
+ TypeDescriptor td=parseTypeDescriptor(pn);
+ ClassTypeNode ctn=new ClassTypeNode(td);
+ ctn.setNumLine(pn.getLine());
+ return ctn;
+ } else if (isNode(pn, "empty")) {
+ return null;
+ } else {
+ System.out.println("---------------------");
+ System.out.println(pn.PPrint(3,true));
+ throw new Error();