/** Parse the classes in this file */
public void parseFile(ParseNode pn) {
+ NameDescriptor packages;
+ Vector singleimports=new Vector();
+ Vector multiimports=new Vector();
+
+ ParseNode ipn=pn.getChild("imports").getChild("import_decls_list");
+ if (ipn!=null) {
+ ParseNodeVector pnv=ipn.getChildren();
+ for(int i=0;i<pnv.size();i++) {
+ ParseNode pnimport=pnv.elementAt(i);
+ NameDescriptor nd=parseName(pnimport.getChild("name"));
+ if (isNode(pnimport,"import_single"))
+ singleimports.add(nd);
+ else
+ multiimports.add(nd);
+ }
+ }
+ ParseNode ppn=pn.getChild("packages").getChild("package");
+ if (ppn!=null) {
+ packages=parseName(pn.getChild("name"));
+ }
ParseNode tpn=pn.getChild("type_declaration_list");
if (tpn!=null) {
ParseNodeVector pnv=tpn.getChildren();
public void parseFlagEffect(FlagEffects fes, ParseNode pn) {
ParseNodeVector pnv=pn.getChildren();
for(int i=0;i<pnv.size();i++) {
+ ParseNode pn2=pnv.elementAt(i);
boolean status=true;
- if (pn.getChild("not")!=null) {
+ if (isNode(pn2,"not")) {
status=false;
- pn=pn.getChild("not");
+ pn2=pn2.getChild("name");
}
- String name=pn.getChild("name").getTerminal();
+ String name=pn2.getTerminal();
fes.addEffect(new FlagEffect(name,status));
}
}
public FlagExpressionNode parseFlagExpression(ParseNode pn) {
- if (pn.getChild("or")!=null) {
- ParseNodeVector pnv=pn.getChild("or").getChildren();
+ if (isNode(pn,"or")) {
+ ParseNodeVector pnv=pn.getChildren();
ParseNode left=pnv.elementAt(0);
ParseNode right=pnv.elementAt(1);
return new FlagOpNode(parseFlagExpression(left), parseFlagExpression(right), new Operation(Operation.LOGIC_OR));
- } else if (pn.getChild("and")!=null) {
- ParseNodeVector pnv=pn.getChild("and").getChildren();
+ } else if (isNode(pn,"and")) {
+ ParseNodeVector pnv=pn.getChildren();
ParseNode left=pnv.elementAt(0);
ParseNode right=pnv.elementAt(1);
return new FlagOpNode(parseFlagExpression(left), parseFlagExpression(right), new Operation(Operation.LOGIC_AND));
- } else if (pn.getChild("not")!=null) {
- ParseNodeVector pnv=pn.getChild("not").getChildren();
+ } else if (isNode(pn, "not")) {
+ ParseNodeVector pnv=pn.getChildren();
ParseNode left=pnv.elementAt(0);
return new FlagOpNode(parseFlagExpression(left), new Operation(Operation.LOGIC_NOT));
- } else if (pn.getChild("name")!=null) {
- return new FlagNode(pn.getChild("name").getTerminal());
+ } else if (isNode(pn,"name")) {
+ return new FlagNode(pn.getTerminal());
+ } else {
+ throw new Error();
+ }
+ }
+
+ public Vector parseChecks(ParseNode pn) {
+ Vector ccs=new Vector();
+ ParseNodeVector pnv=pn.getChildren();
+ for(int i=0;i<pnv.size();i++) {
+ ParseNode fn=pnv.elementAt(i);
+ ConstraintCheck cc=parseConstraintCheck(fn);
+ ccs.add(cc);
+ }
+ return ccs;
+ }
+
+ public ConstraintCheck parseConstraintCheck(ParseNode pn) {
+ if (isNode(pn,"cons_check")) {
+ String specname=pn.getChild("name").getChild("identifier").getTerminal();
+ Vector[] args=parseConsArgumentList(pn);
+ ConstraintCheck cc=new ConstraintCheck(specname);
+ for(int i=0;i<args[0].size();i++) {
+ cc.addVariable((String)args[0].get(i));
+ cc.addArgument((ExpressionNode)args[1].get(i));
+ }
+ return cc;
} else throw new Error();
}
tmp=tmp.getChild("array");
}
String paramname=tmp.getChild("single").getTerminal();
- FlagExpressionNode fen=parseFlagExpression(paramn.getChild("flag"));
+ FlagExpressionNode fen=parseFlagExpression(paramn.getChild("flag").getFirstChild());
td.addParameter(type,paramname,fen);
}
ParseNode flagnode=pn.getChild("flag");
if (flagnode!=null) {
parseFlagDecl(cn, flagnode.getChild("flag_declaration"));
+ return;
}
throw new Error();
}
private TypeDescriptor parseTypeDescriptor(ParseNode pn) {
ParseNode tn=pn.getChild("type");
+
String type_st=tn.getTerminal();
if(type_st.equals("byte")) {
return state.getTypeDescriptor(TypeDescriptor.BYTE);
private void parseFlagDecl(ClassDescriptor cn,ParseNode pn) {
String name=pn.getChild("name").getTerminal();
- cn.addFlag(new FlagDescriptor(name));
+ FlagDescriptor flag=new FlagDescriptor(name);
+ if (pn.getChild("external")!=null)
+ flag.makeExternal();
+ cn.addFlag(flag);
}
private void parseFieldDecl(ClassDescriptor cn,ParseNode pn) {
return new OpNode(parseExpression(left),parseExpression(right),op);
} else if (isNode(pn,"unaryplus")||
isNode(pn,"unaryminus")||
- isNode(pn,"postinc")||
- isNode(pn,"postdec")||
- isNode(pn,"preinc")||
- isNode(pn,"not")||
- isNode(pn,"predec")) {
+ isNode(pn,"not")) {
ParseNode left=pn.getFirstChild();
Operation op=new Operation(pn.getLabel());
return new OpNode(parseExpression(left),op);
+ } else if (isNode(pn,"postinc")||
+ isNode(pn,"postdec")) {
+ ParseNode left=pn.getFirstChild();
+ AssignOperation op=new AssignOperation(pn.getLabel());
+ return new AssignmentNode(parseExpression(left),null,op);
+
+ } 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);
+ return new AssignmentNode(parseExpression(left),
+ new LiteralNode("integer",new Integer(1)),op);
} else if (isNode(pn,"literal")) {
String literaltype=pn.getTerminal();
ParseNode literalnode=pn.getChild(literaltype);
for(int i=0;i<args.size();i++) {
con.addArgument((ExpressionNode)args.get(i));
}
+ /* Could have flag set here */
+ if (pn.getChild("flag_list")!=null) {
+ FlagEffects fe=new FlagEffects(null);
+ parseFlagEffect(fe, pn.getChild("flag_list"));
+ con.addFlagEffects(fe);
+ }
return con;
} else if (isNode(pn,"createarray")) {
- System.out.println(pn.PPrint(3,true));
+ //System.out.println(pn.PPrint(3,true));
TypeDescriptor td=parseTypeDescriptor(pn);
Vector args=parseDimExprs(pn);
int num=0;
return arglist;
}
+ private Vector[] parseConsArgumentList(ParseNode pn) {
+ Vector arglist=new Vector();
+ Vector varlist=new Vector();
+ ParseNode an=pn.getChild("cons_argument_list");
+ if (an==null) /* No argument list */
+ return new Vector[] {varlist, arglist};
+ ParseNodeVector anv=an.getChildren();
+ for(int i=0;i<anv.size();i++) {
+ ParseNode cpn=anv.elementAt(i);
+ ParseNode var=cpn.getChild("var");
+ ParseNode exp=cpn.getChild("exp").getFirstChild();
+ varlist.add(var.getTerminal());
+ arglist.add(parseExpression(exp));
+ }
+ return new Vector[] {varlist, arglist};
+ }
+
private ExpressionNode parseAssignmentExpression(ParseNode pn) {
AssignOperation ao=new AssignOperation(pn.getChild("op").getTerminal());
ParseNodeVector pnv=pn.getChild("args").getChildren();
ParseNode bodyn0=pn.getChild("body");
ParseNode bodyn=bodyn0.getChild("constructor_body");
cn.addMethod(md);
- if (bodyn!=null) {
- BlockNode bn=parseBlock(bodyn);
- state.addTreeCode(md,bn);
- }
+ BlockNode bn=parseBlock(bodyn);
+ state.addTreeCode(md,bn);
}
public BlockNode parseBlock(ParseNode pn) {
- if (isEmpty(pn.getTerminal()))
+ if (pn==null||isEmpty(pn.getTerminal()))
return new BlockNode();
ParseNode bsn=pn.getChild("block_statement_list");
return parseBlockHelper(bsn);
Vector vfe=null;
if (pn.getChild("flag_effects_list")!=null)
vfe=parseFlags(pn.getChild("flag_effects_list"));
- blockstatements.add(new TaskExitNode(vfe));
+ Vector ccs=null;
+ if (pn.getChild("cons_checks")!=null)
+ ccs=parseChecks(pn.getChild("cons_checks"));
+
+ blockstatements.add(new TaskExitNode(vfe, ccs));
} else if (isNode(pn,"return")) {
if (isEmpty(pn.getTerminal()))
blockstatements.add(new ReturnNode());
ExpressionNode condition=parseExpression(pn.getChild("condition").getFirstChild());
BlockNode body=parseSingleBlock(pn.getChild("statement").getFirstChild());
blockstatements.add(new LoopNode(condition,body,LoopNode.DOWHILELOOP));
- } else {
+ } else {
System.out.println("---------------");
System.out.println(pn.PPrint(3,true));
throw new Error();
ParseNode modn=pnv.elementAt(i);
if (isNode(modn,"public"))
m.addModifier(Modifiers.PUBLIC);
- if (isNode(modn,"protected"))
+ else if (isNode(modn,"protected"))
m.addModifier(Modifiers.PROTECTED);
- if (isNode(modn,"private"))
+ else if (isNode(modn,"private"))
m.addModifier(Modifiers.PRIVATE);
- if (isNode(modn,"static"))
+ else if (isNode(modn,"static"))
m.addModifier(Modifiers.STATIC);
- if (isNode(modn,"final"))
+ else if (isNode(modn,"final"))
m.addModifier(Modifiers.FINAL);
- if (isNode(modn,"native"))
+ else if (isNode(modn,"native"))
m.addModifier(Modifiers.NATIVE);
+ else if (isNode(modn,"synchronized"))
+ m.addModifier(Modifiers.SYNCHRONIZED);
+ else throw new Error("Unrecognized Modifier");
}
}
return m;
projects / IRC.git / blobdiff