Changes checked in

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 76aa6ded20ac78023e00548ffe4383d64a1b75b8..ca460c3a73d1daa25d4efbea80a368ee4308b8fe 100644 (file)
--- 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 67cdd3c28dd9342e5e2b001fc052337175c19dbd..679bdaee7c5b8b15d43aac3bae1377b182fc7ab9 100644 (file)
--- 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 e1fd3cce459c91d3ce6587a2050fc44ee62e1024..09983029d37d0c53ac0b50a9da0d064f4de4b27c 100644 (file)
--- 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;
+    }
 }