From bd84a394dcdc795182f60ea1ad2b8276e11574dd Mon Sep 17 00:00:00 2001
From: bdemsky <bdemsky>
Date: Mon, 7 Aug 2006 23:07:14 +0000
Subject: [PATCH] Changes checked in

---
 Robust/src/IR/Flat/BuildCode.java   | 65 ++++++++++++++++++++++++++++-
 Robust/src/IR/Tree/DNFFlag.java     | 16 ++++++-
 Robust/src/IR/Tree/DNFFlagAtom.java | 16 ++++++-
 3 files changed, 92 insertions(+), 5 deletions(-)

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 76aa6ded..ca460c3a 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -1,4 +1,7 @@
 package IR.Flat;
+import IR.Tree.FlagExpressionNode;
+import IR.Tree.DNFFlag;
+import IR.Tree.DNFFlagAtom;
 import IR.*;
 import java.util.*;
 import java.io.*;
@@ -89,6 +92,21 @@ public class BuildCode {
 	    printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs);
 	    outclassdefs.println("  int ___length___;");
 	    outclassdefs.println("};\n");
+
+	    if (state.TASK) {
+	    //Print out definitions for task types
+		outclassdefs.println("struct parameterdescriptor {");
+		outclassdefs.println("int type;");
+		outclassdefs.println("int numberterms;");
+		outclassdefs.println("int **intarray;");
+		outclassdefs.println("};");
+
+		outclassdefs.println("struct taskdescriptor {");
+		outclassdefs.println("void * taskptr;");
+		outclassdefs.println("int numParameters;");
+		outclassdefs.println("struct parameterdescriptor **descriptorarray;");
+		outclassdefs.println("};");
+	    }
 	}
 
 	// Output function prototypes and structures for parameters
@@ -165,9 +183,54 @@ public class BuildCode {
 
     /** This method outputs TaskDescriptor information */
     void generateTaskDescriptor(PrintWriter output, TaskDescriptor task) {
+	for (int i=0;i<task.numParameters();i++) {
+	    VarDescriptor param_var=task.getParameter(i);
+	    TypeDescriptor param_type=task.getParamType(i);
+	    FlagExpressionNode param_flag=task.getFlag(param_var);
+	    DNFFlag dflag=param_flag.getDNF();
+	    
+	    Hashtable flags=(Hashtable)flagorder.get(param_type.getClassDesc());
+			
+	    output.println("int [] parameterdnf_"+i+"_"+task.getSafeSymbol()+"={");
+	    for(int j=0;j<dflag.size();j++) {
+		if (j!=0)
+		    output.println(",");
+		Vector term=dflag.get(j);
+		int andmask=0;
+		int checkmask=0;
+		for(int k=0;k<term.size();k++) {
+		    DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
+		    FlagDescriptor fd=dfa.getFlag();
+		    boolean negated=dfa.getNegated();
+		    int flagid=((Integer)flags.get(fd)).intValue();
+		    andmask|=flagid;
+		    if (!negated)
+			checkmask|=flagid;
+		}
+		output.print(andmask+", "+checkmask);
+	    }
+	    output.println("};");
+
+	    output.println("struct parameterdescriptor parameter_"+i+"_"+task.getSafeSymbol()+"={");
+	    output.println("/* type */"+param_type.getClassDesc().getId()+",");
+	    output.println("/* number of DNF terms */"+dflag.size()+",");
+	    output.println("&parameterdnf_"+i+"_"+task.getSafeSymbol());
+	    output.println("};");
+	}
+
+
+	output.println("struct * parameterdescriptor parameterdescriptors_"+task.getSafeSymbol()+" [] = {");
+	for (int i=0;i<task.numParameters();i++) {
+	    if (i!=0)
+		output.println(",");
+	    output.print("&parameter_"+i+"_"+task.getSafeSymbol());
+	}
+	output.println("};");
+
 	output.println("struct taskdescriptor task_"+task.getSafeSymbol()+"={");
 	output.println("&"+task.getSafeSymbol()+",");
-	
+	output.println("/* number of parameters */" +task.numParameters() + ",");
+	output.println("&parameterdescriptors_"+task.getSafeSymbol());
 	output.println("};");
     }
 
diff --git a/Robust/src/IR/Tree/DNFFlag.java b/Robust/src/IR/Tree/DNFFlag.java
index 67cdd3c2..679bdaee 100644
--- a/Robust/src/IR/Tree/DNFFlag.java
+++ b/Robust/src/IR/Tree/DNFFlag.java
@@ -3,7 +3,7 @@ import java.util.Vector;
 import IR.*;
 
 public class DNFFlag {
-    Vector conjunctions;
+    private Vector conjunctions;
     public DNFFlag(FlagNode flag) {
 	DNFFlagAtom dfa=new DNFFlagAtom(flag, false);
 	conjunctions=new Vector();
@@ -15,6 +15,18 @@ public class DNFFlag {
 	conjunctions=new Vector();
     }
 
+    /** Returns the number of conjunctions in the DNF form. */
+
+    public int size() {
+	return conjunctions.size();
+    }
+
+    /** Returns a Vector containing the terms in the n'th conjunction. */
+
+    public Vector get(int n) {
+	return (Vector) conjunctions.get(n);
+    }
+
     /** This method negates a DNFFlag expression. */
 
     public DNFFlag not() {
@@ -24,7 +36,7 @@ public class DNFFlag {
             DNFFlag newflag=null;
             for (int j=0;j<conj.size();j++) {
                 DNFFlagAtom dfa=(DNFFlagAtom) conj.get(j);
-		DNFFlagAtom negdfa=new DNFFlagAtom(dfa.flag,!dfa.negated);
+		DNFFlagAtom negdfa=new DNFFlagAtom(dfa.getFlagNode(),!dfa.getNegated());
 		DNFFlag tmp=new DNFFlag();
 		Vector v=new Vector();
 		tmp.conjunctions.add(v);
diff --git a/Robust/src/IR/Tree/DNFFlagAtom.java b/Robust/src/IR/Tree/DNFFlagAtom.java
index e1fd3cce..09983029 100644
--- a/Robust/src/IR/Tree/DNFFlagAtom.java
+++ b/Robust/src/IR/Tree/DNFFlagAtom.java
@@ -3,11 +3,23 @@ package IR.Tree;
 import IR.*;
 
 public class DNFFlagAtom {
-    final FlagNode flag;
-    final boolean negated;
+    private final FlagNode flag;
+    private final boolean negated;
 
     public DNFFlagAtom(FlagNode flag, boolean negated) {
 	this.flag=flag;
 	this.negated=negated;
     }
+
+    public FlagNode getFlagNode() {
+	return flag;
+    }
+
+    public FlagDescriptor getFlag() {
+	return flag.getFlag();
+    }
+
+    public boolean getNegated() {
+	return negated;
+    }
 }
-- 
2.34.1