From: bdemsky <bdemsky>
Date: Mon, 15 May 2006 19:49:07 +0000 (+0000)
Subject: Checked in code to:
X-Git-Tag: preEdgeChange~886
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=1f8274ea18d22d2519e7ceaf3764d7551c1ecc68;hp=ccfeddfa15db5a3aeed92ff1019d81e2853c3683;p=IRC.git

Checked in code to:
1) Build parse tree for tasks
2) Type check flag expressions
---

diff --git a/Robust/src/IR/State.java b/Robust/src/IR/State.java
index a811df08..b2545392 100644
--- a/Robust/src/IR/State.java
+++ b/Robust/src/IR/State.java
@@ -80,6 +80,10 @@ public class State {
 	return classes;
     }
 
+    public SymbolTable getTaskSymbolTable() {
+	return tasks;
+    }
+
     public FlatMethod getMethodFlat(MethodDescriptor md) {
 	return (FlatMethod)flatmethodmap.get(md);
     }
diff --git a/Robust/src/IR/TaskDescriptor.java b/Robust/src/IR/TaskDescriptor.java
index 96489bc8..47a92909 100644
--- a/Robust/src/IR/TaskDescriptor.java
+++ b/Robust/src/IR/TaskDescriptor.java
@@ -58,6 +58,10 @@ public class TaskDescriptor extends Descriptor {
 	paramtable.add(vd);
     }
 
+    public FlagExpressionNode getFlag(VarDescriptor vd) {
+	return (FlagExpressionNode) flagstable.get(vd);
+    }
+
     public int numParameters() {
 	return params.size();
     }
diff --git a/Robust/src/IR/Tree/BuildIR.java b/Robust/src/IR/Tree/BuildIR.java
index 0150b12e..c9368be4 100644
--- a/Robust/src/IR/Tree/BuildIR.java
+++ b/Robust/src/IR/Tree/BuildIR.java
@@ -63,13 +63,24 @@ public class BuildIR {
 	if (isNode(pn,"flag_effect")) {
 	    String flagname=pn.getChild("name").getTerminal();
 	    FlagEffects fe=new FlagEffects(flagname);
-
-	    
-	    
+	    parseFlagEffect(fe, pn.getChild("flag_list"));
 	    return fe;
 	} else throw new Error();
     }
 
+    public void parseFlagEffect(FlagEffects fes, ParseNode pn) {
+	ParseNodeVector pnv=pn.getChildren();
+	for(int i=0;i<pnv.size();i++) {
+	    boolean status=true;
+	    if (pn.getChild("not")!=null) {
+		status=false;
+		pn=pn.getChild("not");
+	    }
+	    String name=pn.getChild("name").getTerminal();
+	    fes.addEffect(new FlagEffect(name,status));
+	}
+    }
+
     public FlagExpressionNode parseFlagExpression(ParseNode pn) {
 	if (pn.getChild("or")!=null) {
 	    ParseNodeVector pnv=pn.getChild("or").getChildren();
@@ -156,6 +167,10 @@ public class BuildIR {
 	    parseMethodDecl(cn,methodnode.getChild("method_declaration"));
 	    return;
 	}
+	ParseNode flagnode=pn.getChild("flag");
+	if (flagnode!=null) {
+	    parseFlagDecl(cn, flagnode.getChild("flag_declaration"));
+	}
 	throw new Error();
     }
 
@@ -202,6 +217,11 @@ public class BuildIR {
 	
     }
 
+    private void parseFlagDecl(ClassDescriptor cn,ParseNode pn) {
+	String name=pn.getChild("name").getTerminal();
+	cn.addFlag(new FlagDescriptor(name));
+    }
+
     private void parseFieldDecl(ClassDescriptor cn,ParseNode pn) {
 	ParseNode mn=pn.getChild("modifier");
 	Modifiers m=parseModifiersList(mn);
diff --git a/Robust/src/IR/Tree/FlagNode.java b/Robust/src/IR/Tree/FlagNode.java
index 3ef4fa97..7b18b7f5 100644
--- a/Robust/src/IR/Tree/FlagNode.java
+++ b/Robust/src/IR/Tree/FlagNode.java
@@ -18,6 +18,10 @@ public class FlagNode extends FlagExpressionNode {
 	return flag;
     }
 
+    public String getFlagName() {
+	return name;
+    }
+
     public int kind() {
 	return Kind.FlagNode;
     }
diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index f9ef70c7..561c9021 100644
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -22,16 +22,20 @@ public class SemanticCheck {
 	    //Set superclass link up
 	    if (cd.getSuper()!=null) {
 		cd.setSuper(typeutil.getClass(cd.getSuper()));
-		// Link together Field and Method tables
+		// Link together Field, Method, and Flag tables so classes
+		// inherit these from their superclasses
 		cd.getFieldTable().setParent(cd.getSuperDesc().getFieldTable());
 		cd.getMethodTable().setParent(cd.getSuperDesc().getMethodTable());
+		cd.getFlagTable().setParent(cd.getSuperDesc().getFlagTable());
 	    }
 	    
+	    /* Check to see that fields are well typed */
 	    for(Iterator field_it=cd.getFields();field_it.hasNext();) {
 		FieldDescriptor fd=(FieldDescriptor)field_it.next();
 		System.out.println("Checking field: "+fd);
 		checkField(cd,fd);
 	    }
+
 	    for(Iterator method_it=cd.getMethods();method_it.hasNext();) {
 		MethodDescriptor md=(MethodDescriptor)method_it.next();
 		checkMethod(cd,md);
@@ -47,6 +51,13 @@ public class SemanticCheck {
 		checkMethodBody(cd,md);
 	    }
 	}
+
+	for(Iterator task_it=state.getTaskSymbolTable().getDescriptorsIterator();task_it.hasNext();) {
+	    TaskDescriptor td=(TaskDescriptor)task_it.next();
+	    
+	    
+	}
+
     }
 
     public void checkTypeDescriptor(TypeDescriptor td) {
@@ -67,6 +78,46 @@ public class SemanticCheck {
 	checkTypeDescriptor(fd.getType());
     }
 
+    public void checkTask(TaskDescriptor td) {
+	for(int i=0;i<td.numParameters();i++) {
+	    /* Check that parameter is well typed */
+	    TypeDescriptor param_type=td.getParamType(i);
+	    checkTypeDescriptor(param_type);
+
+	    /* Check the parameter's flag expression is well formed */
+	    FlagExpressionNode fen=td.getFlag(td.getParameter(i));
+	    if (!param_type.isClass())
+		throw new Error("Cannot have non-object argument to a task");
+	    ClassDescriptor cd=param_type.getClassDesc();
+	    checkFlagExpressionNode(cd, fen);
+	}
+    }
+
+    public void checkFlagExpressionNode(ClassDescriptor cd, FlagExpressionNode fen) {
+	switch(fen.kind()) {
+	case Kind.FlagOpNode: 
+	    {
+		FlagOpNode fon=(FlagOpNode)fen;
+		checkFlagExpressionNode(cd, fon.getLeft());
+		if (fon.getRight()!=null)
+		    checkFlagExpressionNode(cd, fon.getRight());
+		break;
+	    }
+	case Kind.FlagNode:
+	    {
+		FlagNode fn=(FlagNode)fen;
+		String name=fn.getFlagName();
+		FlagDescriptor fd=(FlagDescriptor)cd.getFlagTable().get(name);
+		if (fd==null)
+		    throw new Error("Undeclared flag: "+name);
+		fn.setFlag(fd);
+		break;
+	    }
+	default:
+	    throw new Error("Unrecognized FlagExpressionNode");
+	}
+    }
+
     public void checkMethod(ClassDescriptor cd, MethodDescriptor md) {
 	/* Check return type */
 	if (!md.isConstructor())