--- /dev/null
+package IR.Tree;
+import IR.AssignOperation;
+
+public class AssignmentNode extends ExpressionNode {
+ ExpressionNode left;
+ ExpressionNode right;
+ AssignOperation op;
+
+ public AssignmentNode(ExpressionNode l, ExpressionNode r, AssignOperation op) {
+ left=l;
+ right=r;
+ this.op=op;
+ }
+
+ public String printNode() {
+ return left.printNode()+" "+op.toString()+" "+right.printNode();
+ }
+}
--- /dev/null
+package IR.Tree;
+
+class BlockExpressionNode extends BlockStatementNode {
+ ExpressionNode en;
+ public BlockExpressionNode(ExpressionNode e) {
+ this.en=e;
+ }
+
+ public String printNode() {
+ return en.printNode()+";";
+ }
+}
--- /dev/null
+package IR.Tree;
+import java.util.Vector;
+
+class BlockNode extends TreeNode {
+ Vector blockstatements;
+ public BlockNode() {
+ blockstatements=new Vector();
+ }
+
+ public void addBlockStatement(BlockStatementNode bsn) {
+ blockstatements.add(bsn);
+ }
+
+ public String printNode() {
+ String st="{\n";
+ for(int i=0;i<blockstatements.size();i++) {
+ BlockStatementNode bsn=(BlockStatementNode)blockstatements.get(i);
+ st+=bsn.printNode()+"\n";
+ }
+ st+="}\n";
+ return st;
+ }
+}
--- /dev/null
+package IR.Tree;
+
+class BlockStatementNode extends TreeNode {
+ public BlockStatementNode() {
+ }
+
+ public String printNode() {
+ return null;
+ }
+
+}
package IR.Tree;
import IR.*;
+import java.util.Vector;
public class BuildIR {
State state;
return state.getTypeDescriptor(TypeDescriptor.DOUBLE);
} else if(type_st.equals("class")) {
ParseNode nn=tn.getChild("class");
- return state.getTypeDescriptor(parseName(nn));
+ return state.getTypeDescriptor(parseName(nn.getChild("name")));
} else {
throw new Error();
}
}
- private NameDescriptor parseName(ParseNode pn) {
- ParseNode nn=pn.getChild("name");
+ private NameDescriptor parseName(ParseNode nn) {
ParseNode base=nn.getChild("base");
ParseNode id=nn.getChild("identifier");
if (base==null)
return new NameDescriptor(id.getTerminal());
- return new NameDescriptor(parseName(base),id.getTerminal());
+ return new NameDescriptor(parseName(base.getChild("name")),id.getTerminal());
}
private void parseFieldDecl(ClassNode cn,ParseNode pn) {
ParseNode mn=pn.getChild("modifier");
Modifiers m=parseModifiersList(mn);
+
+
ParseNode tn=pn.getChild("type");
TypeDescriptor t=parseTypeDescriptor(tn);
ParseNode vn=pn.getChild("variables").getChild("variable_declarators_list");
ParseNode literalnode=pn.getChild(literaltype);
Object literal_obj=literalnode.getLiteral();
return new LiteralNode(literaltype, literal_obj);
+ } else if (isNode(pn,"createobject")) {
+ TypeDescriptor td=parseTypeDescriptor(pn);
+ Vector args=parseArgumentList(pn);
+ CreateObjectNode con=new CreateObjectNode(td);
+ for(int i=0;i<args.size();i++) {
+ con.addArgument((ExpressionNode)args.get(i));
+ }
+ return con;
+ } else if (isNode(pn,"name")) {
+ NameDescriptor nd=parseName(pn);
+ return new NameNode(nd);
+ } else if (isNode(pn,"this")) {
+ NameDescriptor nd=new NameDescriptor("this");
+ return new NameNode(nd);
+ } else if (isNode(pn,"methodinvoke1")) {
+ NameDescriptor nd=parseName(pn.getChild("name"));
+ Vector args=parseArgumentList(pn);
+ MethodInvokeNode min=new MethodInvokeNode(nd);
+ 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);
+ 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();
+ return new FieldAccessNode(en,fieldname);
+ } else {
+ System.out.println("---------------------");
+ System.out.println(pn.PPrint(3,true));
+ throw new Error();
}
- throw new Error();
+ }
+
+ private Vector parseArgumentList(ParseNode pn) {
+ Vector arglist=new Vector();
+ ParseNode an=pn.getChild("argument_list");
+ if (an==null) /* No argument list */
+ return arglist;
+ ParseNodeVector anv=an.getChildren();
+ for(int i=0;i<anv.size();i++) {
+ arglist.add(parseExpression(anv.elementAt(i)));
+ }
+ return arglist;
}
private ExpressionNode parseAssignmentExpression(ParseNode pn) {
- return null;
+ AssignOperation ao=new AssignOperation(pn.getChild("op").getTerminal());
+ ParseNodeVector pnv=pn.getChild("args").getChildren();
+
+ AssignmentNode an=new AssignmentNode(parseExpression(pnv.elementAt(0)),parseExpression(pnv.elementAt(1)),ao);
+ return an;
}
ParseNode bodyn=pn.getChild("body");
MethodDescriptor md=parseMethodHeader(headern);
BlockNode bn=parseBlock(bodyn);
- cn.addMethod(md);
+ cn.addMethod(md,bn);
}
public BlockNode parseBlock(ParseNode pn) {
+ if (isEmpty(pn.getTerminal()))
+ return new BlockNode();
+ ParseNode bsn=pn.getChild("block_statement_list");
+ return parseBlockHelper(bsn);
+ }
+
+ private BlockNode parseBlockHelper(ParseNode pn) {
+ ParseNodeVector pnv=pn.getChildren();
+ BlockNode bn=new BlockNode();
+ for(int i=0;i<pnv.size();i++) {
+ Vector bsv=parseBlockStatement(pnv.elementAt(i));
+ for(int j=0;j<bsv.size();j++) {
+ bn.addBlockStatement((BlockStatementNode)bsv.get(j));
+ }
+ }
+ return bn;
+ }
+ public BlockNode parseSingleBlock(ParseNode pn) {
+ BlockNode bn=new BlockNode();
+ Vector bsv=parseBlockStatement(pn);
+ for(int j=0;j<bsv.size();j++) {
+ bn.addBlockStatement((BlockStatementNode)bsv.get(j));
+ }
+ return bn;
+ }
+ public Vector parseBlockStatement(ParseNode pn) {
+ Vector blockstatements=new Vector();
+ if (isNode(pn,"local_variable_declaration")) {
+ TypeDescriptor t=parseTypeDescriptor(pn);
+ ParseNode vn=pn.getChild("variable_declarators_list");
+ ParseNodeVector pnv=vn.getChildren();
+ for(int i=0;i<pnv.size();i++) {
+ ParseNode vardecl=pnv.elementAt(i);
+ String identifier=vardecl.getChild("single").getTerminal();
+ ParseNode epn=vardecl.getChild("initializer");
+
+ ExpressionNode en=null;
+ if (epn!=null)
+ en=parseExpression(epn.getFirstChild());
+
+ blockstatements.add(new DeclarationNode(new VarDescriptor(t,identifier, en)));
+ }
+ } else if (isNode(pn,"nop")) {
+ /* Do Nothing */
+ } else if (isNode(pn,"expression")) {
+ blockstatements.add(new BlockExpressionNode(parseExpression(pn.getFirstChild())));
+ } else if (isNode(pn,"ifstatement")) {
+ blockstatements.add(new IfStatementNode(parseExpression(pn.getChild("condition").getFirstChild()),
+ parseSingleBlock(pn.getChild("statement").getFirstChild()),
+ pn.getChild("else_statement")!=null?parseSingleBlock(pn.getChild("else_statement").getFirstChild()):null));
+ } else if (isNode(pn,"return")) {
+ if (isEmpty(pn.getTerminal()))
+ blockstatements.add(new ReturnNode());
+ else {
+ ExpressionNode en=parseExpression(pn.getFirstChild());
+ blockstatements.add(new ReturnNode(en));
+ }
+ } else if (isNode(pn,"block_statement_list")) {
+ BlockNode bn=parseBlockHelper(pn);
+ blockstatements.add(new SubBlockNode(bn));
+ } else if (isNode(pn,"empty")) {
+ /* nop */
+ } /*else {
+ System.out.println("---------------");
+ System.out.println(pn.PPrint(3,true));
+ throw new Error();
+ }*/
+ return blockstatements;
}
public MethodDescriptor parseMethodHeader(ParseNode pn) {
package IR.Tree;
import java.util.Vector;
+import java.util.Hashtable;
import IR.FieldDescriptor;
import IR.MethodDescriptor;
import IR.NameDescriptor;
superclass=null;
fields=new Vector();
methods=new Vector();
+ methodmap=new Hashtable();
}
String classname;
NameDescriptor superclass;
Modifiers modifiers;
Vector fields;
Vector methods;
+ Hashtable methodmap;
public String printNode() {
- String st=modifiers.toString()+classname;
+ String st=modifiers.toString()+"class "+classname;
if (superclass!=null)
st+="extends "+superclass.toString();
st+=" {\n";
for(int i=0;i<methods.size();i++) {
MethodDescriptor md=(MethodDescriptor)methods.get(i);
st+=md.toString()+"\n";
+ BlockNode bn=(BlockNode)methodmap.get(md);
+ st+=bn.printNode();
}
st+="}\n";
return st;
fields.add(fd);
}
- public void addMethod(MethodDescriptor md) {
+ public void addMethod(MethodDescriptor md, BlockNode b) {
methods.add(md);
+ methodmap.put(md,b);
}
-
+
public void setModifiers(Modifiers modifiers) {
this.modifiers=modifiers;
}
--- /dev/null
+package IR.Tree;
+import java.util.Vector;
+import IR.TypeDescriptor;
+
+public class CreateObjectNode extends ExpressionNode {
+ TypeDescriptor td;
+ Vector argumentlist;
+
+ public CreateObjectNode(TypeDescriptor type) {
+ td=type;
+ argumentlist=new Vector();
+ }
+ public void addArgument(ExpressionNode en) {
+ argumentlist.add(en);
+ }
+
+ public String printNode() {
+ String st="new "+td.toString()+"(";
+ for(int i=0;i<argumentlist.size();i++) {
+ ExpressionNode en=(ExpressionNode)argumentlist.get(i);
+ st+=en.printNode();
+ if ((i+1)!=argumentlist.size())
+ st+=", ";
+ }
+ return st+")";
+ }
+}
--- /dev/null
+package IR.Tree;
+import IR.VarDescriptor;
+
+class DeclarationNode extends BlockStatementNode {
+ VarDescriptor vd;
+ public DeclarationNode(VarDescriptor var) {
+ vd=var;
+ }
+
+ public String printNode() {
+ return vd.toString();
+ }
+
+}
--- /dev/null
+package IR.Tree;
+
+public class FieldAccessNode extends ExpressionNode {
+ ExpressionNode left;
+ String fieldname;
+
+ public FieldAccessNode(ExpressionNode l, String field) {
+ fieldname=field;
+ left=l;
+ }
+
+ public String printNode() {
+ return left.printNode()+"."+fieldname;
+ }
+}
--- /dev/null
+package IR.Tree;
+
+class IfStatementNode extends BlockStatementNode {
+ ExpressionNode cond;
+ BlockNode true_st;
+ BlockNode else_st;
+
+ public IfStatementNode(ExpressionNode cond, BlockNode true_st, BlockNode else_st) {
+ this.cond=cond;
+ this.true_st=true_st;
+ this.else_st=else_st;
+ }
+
+ public String printNode() {
+ if (else_st==null)
+ return "if("+cond.printNode()+") {\n"+true_st.printNode()+"\n}\n";
+ else
+ return "if("+cond.printNode()+") {\n"+true_st.printNode()+"\n} else {\n"+
+ else_st.printNode()+"}\n";
+ }
+}
--- /dev/null
+package IR.Tree;
+
+class LoopNode extends BlockStatementNode {
+ public SubBlockNode() {
+ }
+
+ public String printNode() {
+ return null;
+ }
+
+}
--- /dev/null
+package IR.Tree;
+import java.util.Vector;
+import IR.NameDescriptor;
+
+public class MethodInvokeNode extends ExpressionNode {
+ NameDescriptor nd;
+ Vector argumentlist;
+ String methodid;
+ ExpressionNode en;
+
+ public MethodInvokeNode(NameDescriptor name) {
+ nd=name;
+ argumentlist=new Vector();
+ methodid=null;
+ en=null;
+ }
+
+ public MethodInvokeNode(String methodid, ExpressionNode exp) {
+ this.methodid=methodid;
+ this.en=exp;
+ nd=null;
+ argumentlist=new Vector();
+ }
+
+ public void addArgument(ExpressionNode en) {
+ argumentlist.add(en);
+ }
+
+ public String printNode() {
+ String st;
+ if (nd==null) {
+ st=en.printNode()+"."+methodid+"(";
+ } else {
+ st=nd.toString()+"(";
+ }
+ for(int i=0;i<argumentlist.size();i++) {
+ ExpressionNode en=(ExpressionNode)argumentlist.get(i);
+ st+=en.printNode();
+ if ((i+1)!=argumentlist.size())
+ st+=", ";
+ }
+ return st+")";
+ }
+}
--- /dev/null
+package IR.Tree;
+import IR.NameDescriptor;
+
+public class NameNode extends ExpressionNode {
+ NameDescriptor name;
+ public NameNode(NameDescriptor nd) {
+ this.name=nd;
+ }
+
+ public String printNode() {
+ return name.toString();
+ }
+}
--- /dev/null
+package IR.Tree;
+
+class ReturnNode extends BlockStatementNode {
+ ExpressionNode en;
+
+ public ReturnNode() {
+ en=null;
+ }
+
+ public ReturnNode(ExpressionNode en) {
+ this.en=en;
+ }
+
+ public String printNode() {
+ if (en==null)
+ return "return";
+ else
+ return "return "+en.printNode();
+ }
+
+}
--- /dev/null
+package IR.Tree;
+
+class SubBlockNode extends BlockStatementNode {
+ BlockNode bn;
+ public SubBlockNode(BlockNode bn) {
+ this.bn=bn;
+ }
+
+ public String printNode() {
+ return bn.printNode();
+ }
+
+}
// 19.11) Blocks and Statements
block ::= LBRACE block_statements_opt:bso RBRACE {:
- ParseNode pn=new ParseNode("block");
- pn.addChild("block_statements_opt").addChild(bso);
- RESULT=pn;
+ RESULT=bso;
:}
;
block_statements_opt ::=
{: RESULT=new ParseNode("empty"); :}
| block_statements:bs {:
- ParseNode pn=new ParseNode("block_statements_opt");
- pn.addChild("block_statements").addChild(bs);
- RESULT=pn;
+ RESULT=bs;
:}
;
block_statements ::=
:}
| block_statements:bss block_statement:bs {:
bss.addChild(bs);
- RESULT=bs;
+ RESULT=bss;
:}
;
block_statement ::=
local_variable_declaration_statement:lvds {:
- ParseNode pn=new ParseNode("block_statement");
- pn.addChild("local_variable_declaration").addChild(lvds);
- RESULT=pn;
+ RESULT=lvds;
:}
| statement:statement {:
- ParseNode pn=new ParseNode("statement");
- pn.addChild("statement").addChild(statement);
- RESULT=pn;
+ RESULT=statement;
:}
// | class_declaration
// | interface_declaration
:}
;
local_variable_declaration ::=
- type:type variable_declarators:var_decls {:
+ type:type variable_declarators:var {:
ParseNode pn=new ParseNode("local_variable_declaration");
- pn.addChild("type").addChild(type);
- pn.addChild("variables").addChild(var_decls);
+ pn.addChild(type);
+ pn.addChild(var);
RESULT=pn;
:}
// | FINAL type variable_declarators
// IDENTIFIER COLON statement_no_short_if
// ;
expression_statement ::=
- statement_expression:se SEMICOLON {: RESULT=se; :}
+ statement_expression:se SEMICOLON {:
+ ParseNode pn=new ParseNode("expression");
+ pn.addChild(se);
+ RESULT=pn; :}
;
statement_expression ::=
assignment:st {: RESULT=st; :}
;
return_statement ::=
RETURN expression_opt:exp SEMICOLON {:
- RESULT=(new ParseNode("return")).addChild("retvalue").addChild(exp).getRoot(); :}
+ RESULT=(new ParseNode("return")).addChild(exp).getRoot(); :}
;
//throw_statement ::=
// THROW expression SEMICOLON
class_instance_creation_expression ::=
NEW class_or_interface_type:type LPAREN argument_list_opt:args RPAREN {:
ParseNode pn=new ParseNode("createobject");
- pn.addChild("type").addChild(type);
- pn.addChild("args").addChild(args);
+ pn.addChild(type);
+ pn.addChild(args);
RESULT=pn;
:}
// | NEW class_or_interface_type LPAREN argument_list_opt RPAREN class_body
;
method_invocation ::=
name:name LPAREN argument_list_opt:args RPAREN {:
- ParseNode pn=new ParseNode("methodinvoke");
- pn.addChild("name").addChild(name);
- pn.addChild("args").addChild(args);
+ ParseNode pn=new ParseNode("methodinvoke1");
+ pn.addChild(name);
+ pn.addChild(args);
RESULT=pn;
:}
| primary:base DOT IDENTIFIER:name LPAREN argument_list_opt:args RPAREN {:
- ParseNode pn=new ParseNode("methodinvoke");
+ ParseNode pn=new ParseNode("methodinvoke2");
pn.addChild("base").addChild(base);
- pn.addChild("name").addChild(name);
- pn.addChild("args").addChild(args);
+ pn.addChild("id").addChild(name);
+ pn.addChild(args);
RESULT=pn;
:}
// | SUPER DOT IDENTIFIER LPAREN argument_list_opt RPAREN
:}
;
assignment_operator ::=
- EQ {: RESULT=(new ParseNode("assignment_operator")).addChild("eq"); :}
- | MULTEQ {: RESULT=(new ParseNode("assignment_operator")).addChild("multeq"); :}
- | DIVEQ {: RESULT=(new ParseNode("assignment_operator")).addChild("diveq"); :}
- | MODEQ {: RESULT=(new ParseNode("assignment_operator")).addChild("modeq"); :}
- | PLUSEQ {: RESULT=(new ParseNode("assignment_operator")).addChild("pluseq"); :}
- | MINUSEQ {: RESULT=(new ParseNode("assignment_operator")).addChild("minuseq"); :}
- | LSHIFTEQ {: RESULT=(new ParseNode("assignment_operator")).addChild("lshifteq"); :}
- | RSHIFTEQ {: RESULT=(new ParseNode("assignment_operator")).addChild("rshifteq"); :}
-// | URSHIFTEQ {: RESULT=(new ParseNode("assignment_operator")).addChild("urshifteq"); :}
- | ANDEQ {: RESULT=(new ParseNode("assignment_operator")).addChild("andeq"); :}
- | XOREQ {: RESULT=(new ParseNode("assignment_operator")).addChild("xoreq"); :}
- | OREQ {: RESULT=(new ParseNode("assignment_operator")).addChild("oreq"); :}
+ EQ {: RESULT=new ParseNode("eq"); :}
+ | MULTEQ {: RESULT=new ParseNode("multeq"); :}
+ | DIVEQ {: RESULT=new ParseNode("diveq"); :}
+ | MODEQ {: RESULT=new ParseNode("modeq"); :}
+ | PLUSEQ {: RESULT=new ParseNode("pluseq"); :}
+ | MINUSEQ {: RESULT=new ParseNode("minuseq"); :}
+ | LSHIFTEQ {: RESULT=new ParseNode("lshifteq"); :}
+ | RSHIFTEQ {: RESULT=new ParseNode("rshifteq"); :}
+// | URSHIFTEQ {: RESULT=new ParseNode("urshifteq"); :}
+ | ANDEQ {: RESULT=new ParseNode("andeq"); :}
+ | XOREQ {: RESULT=new ParseNode("xoreq"); :}
+ | OREQ {: RESULT=new ParseNode("oreq"); :}
;
expression_opt ::=
{: RESULT=new ParseNode("empty"); :}
projects / IRC.git / commitdiff