switch to spaces only..

[IRC.git] / Robust / src / Analysis / TaskStateAnalysis / TaskAnalysis.java

diff --git a/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java b/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java
index 954060f9e9f741b947826a78ee02c82914f09544..11cff8f28b278548759746838ba115b8416aea96 100644 (file)
--- a/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java
+++ b/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java
@@ -56,29 +56,29 @@ public class TaskAnalysis {
       /* Adding the flags of the super class */
       ClassDescriptor tmp=cd;
       while(tmp!=null) {
       /* Adding the flags of the super class */
       ClassDescriptor tmp=cd;
       while(tmp!=null) {

-       for(Iterator it_cflags=tmp.getFlags(); it_cflags.hasNext(); ) {
-         FlagDescriptor fd = (FlagDescriptor)it_cflags.next();
-         vFlags.add(fd);
-       }
-       tmp=tmp.getSuperDesc();
+        for(Iterator it_cflags=tmp.getFlags(); it_cflags.hasNext(); ) {
+          FlagDescriptor fd = (FlagDescriptor)it_cflags.next();
+          vFlags.add(fd);
+        }
+        tmp=tmp.getSuperDesc();

       }
 
 
       if (vFlags.size()!=0) {
       }
 
 
       if (vFlags.size()!=0) {

-       flag=new FlagDescriptor[vFlags.size()];
-
-       for(int i=0; i < vFlags.size(); i++) {
-         if (((FlagDescriptor)vFlags.get(i)).getExternal()) {
-           flag[ctr]=(FlagDescriptor)vFlags.get(i);
-           vFlags.remove(flag[ctr]);
-           ctr++;
-         }
-       }
-       for(int i=0; i < vFlags.size(); i++) {
-         flag[i+ctr]=(FlagDescriptor)vFlags.get(i);
-       }
-       extern_flags.put(cd,new Integer(ctr));
-       flags.put(cd,flag);
+        flag=new FlagDescriptor[vFlags.size()];
+
+        for(int i=0; i < vFlags.size(); i++) {
+          if (((FlagDescriptor)vFlags.get(i)).getExternal()) {
+            flag[ctr]=(FlagDescriptor)vFlags.get(i);
+            vFlags.remove(flag[ctr]);
+            ctr++;
+          }
+        }
+        for(int i=0; i < vFlags.size(); i++) {
+          flag[i+ctr]=(FlagDescriptor)vFlags.get(i);
+        }
+        extern_flags.put(cd,new Integer(ctr));
+        flags.put(cd,flag);

 
       }
     }
 
       }
     }


@@ -156,7 +156,7 @@ public class TaskAnalysis {
       String taskname=td.getSymbol();
 
       if(!tdToFEdges.containsKey(td)) {
       String taskname=td.getSymbol();
 
       if(!tdToFEdges.containsKey(td)) {

-       tdToFEdges.put(td, new Vector<FEdge>());
+        tdToFEdges.put(td, new Vector<FEdge>());

       }
 
       /** counter to keep track of the number of parameters (of the
       }
 
       /** counter to keep track of the number of parameters (of the


@@ -168,46 +168,46 @@ public class TaskAnalysis {
       int parameterindex=0;
 
       for(int i=0; i < td.numParameters(); i++) {
       int parameterindex=0;
 
       for(int i=0; i < td.numParameters(); i++) {

-       FlagExpressionNode fen=td.getFlag(td.getParameter(i));
-       TagExpressionList tel=td.getTag(td.getParameter(i));
-
-       /** Checking to see if the parameter is of the same
-        *  type/class as the flagstate's and also if the
-        *  flagstate fs triggers the given task*/
-
-       if (typeutil.isSuperorType(td.getParamType(i).getClassDesc(),cd)
-           && isTaskTrigger_flag(fen,fs)
-           && isTaskTrigger_tag(tel,fs)) {
-         temp=fm.getParameter(i);
-         parameterindex=i;
-         trigger_ctr++;
-       }
+        FlagExpressionNode fen=td.getFlag(td.getParameter(i));
+        TagExpressionList tel=td.getTag(td.getParameter(i));
+
+        /** Checking to see if the parameter is of the same
+         *  type/class as the flagstate's and also if the
+         *  flagstate fs triggers the given task*/
+
+        if (typeutil.isSuperorType(td.getParamType(i).getClassDesc(),cd)
+            && isTaskTrigger_flag(fen,fs)
+            && isTaskTrigger_tag(tel,fs)) {
+          temp=fm.getParameter(i);
+          parameterindex=i;
+          trigger_ctr++;
+        }

       }
 
       if (trigger_ctr==0)   //Look at next task
       }
 
       if (trigger_ctr==0)   //Look at next task

-       continue;
+        continue;

 
       if (trigger_ctr>1)
 
       if (trigger_ctr>1)

-       System.out.println("Illegal Operation: A single flagstate cannot satisfy more than one parameter of a task:"+fs + " in "+td);
+        System.out.println("Illegal Operation: A single flagstate cannot satisfy more than one parameter of a task:"+fs + " in "+td);

 
 
       Set newstates=taganalysis.getFlagStates(td);
       for(Iterator fsit=newstates.iterator(); fsit.hasNext(); ) {
 
 
       Set newstates=taganalysis.getFlagStates(td);
       for(Iterator fsit=newstates.iterator(); fsit.hasNext(); ) {

-       FlagState fsnew=(FlagState) fsit.next();
-       System.out.println("SOURCE:"+fsnew);
-
-       if (!((Hashtable<FlagState,FlagState>)flagstates.get(fsnew.getClassDescriptor())).containsKey(fsnew)) {
-         ((Hashtable<FlagState,FlagState>)flagstates.get(fsnew.getClassDescriptor())).put(fsnew, fsnew);
-         toprocess.add(fsnew);
-       } else {
-         fsnew=((Hashtable<FlagState, FlagState>)flagstates.get(fsnew.getClassDescriptor())).get(fsnew);
-       }
-       fsnew.setAsSourceNode();
-       fsnew.addAllocatingTask(td);
-
-       if(!((Vector)cdtorootnodes.get(fsnew.getClassDescriptor())).contains(fsnew)) {
-         ((Vector)cdtorootnodes.get(fsnew.getClassDescriptor())).add(fsnew);
-       }
+        FlagState fsnew=(FlagState) fsit.next();
+        System.out.println("SOURCE:"+fsnew);
+
+        if (!((Hashtable<FlagState,FlagState>)flagstates.get(fsnew.getClassDescriptor())).containsKey(fsnew)) {
+          ((Hashtable<FlagState,FlagState>)flagstates.get(fsnew.getClassDescriptor())).put(fsnew, fsnew);
+          toprocess.add(fsnew);
+        } else {
+          fsnew=((Hashtable<FlagState, FlagState>)flagstates.get(fsnew.getClassDescriptor())).get(fsnew);
+        }
+        fsnew.setAsSourceNode();
+        fsnew.addAllocatingTask(td);
+
+        if(!((Vector)cdtorootnodes.get(fsnew.getClassDescriptor())).contains(fsnew)) {
+          ((Vector)cdtorootnodes.get(fsnew.getClassDescriptor())).add(fsnew);
+        }

       }
 
       Stack nodestack=new Stack();
       }
 
       Stack nodestack=new Stack();


@@ -217,55 +217,55 @@ public class TaskAnalysis {
       //Iterating through the nodes
 
       while(!nodestack.isEmpty()) {
       //Iterating through the nodes
 
       while(!nodestack.isEmpty()) {

-       FlatNode fn1 = (FlatNode) nodestack.pop();
-
-       if (fn1.kind()==FKind.FlatReturnNode) {
-         /* Self edge */
-         FEdge newedge=new FEdge(fs, taskname, td, parameterindex);
-         ((Vector<FEdge>)tdToFEdges.get(td)).add(newedge);
-         fs.addEdge(newedge);
-         newedge.setisbackedge(true);
-         continue;
-       } else if (fn1.kind()==FKind.FlatFlagActionNode) {
-         FlatFlagActionNode ffan=(FlatFlagActionNode)fn1;
-         if (ffan.getTaskType() == FlatFlagActionNode.PRE) {
-           if (ffan.getTempFlagPairs().hasNext()||ffan.getTempTagPairs().hasNext())
-             throw new Error("PRE FlagActions not supported");
-
-         } else if (ffan.getTaskType() == FlatFlagActionNode.TASKEXIT) {
-           Vector<FlagState> fsv_taskexit=evalTaskExitNode(ffan,cd,fs,temp);
-           Vector<FlagState> initFStates = ffan.getInitFStates(temp.getType().getClassDesc());
-           if(!initFStates.contains(fs)) {
-             initFStates.addElement(fs);
-           }
-           Vector<FlagState> targetFStates = ffan.getTargetFStates(fs);
-           for(Enumeration en=fsv_taskexit.elements(); en.hasMoreElements(); ) {
-             FlagState fs_taskexit=(FlagState)en.nextElement();
-             if (!sourcenodes.containsKey(fs_taskexit)) {
-               toprocess.add(fs_taskexit);
-             }
-             //seen this node already
-             fs_taskexit=canonicalizeFlagState(sourcenodes,fs_taskexit);
-             FEdge newedge=new FEdge(fs_taskexit,taskname, td, parameterindex);
-             newedge.setTaskExitIndex(ffan.getTaskExitIndex());
-             ((Vector<FEdge>)tdToFEdges.get(td)).add(newedge);
-             fs.addEdge(newedge);
-
-             if(!targetFStates.contains(fs_taskexit)) {
-               targetFStates.addElement(fs_taskexit);
-             }
-           }
-           continue;
-         }
-       }
-       /* Queue other nodes past this one */
-       for(int i=0; i<fn1.numNext(); i++) {
-         FlatNode fnext=fn1.getNext(i);
-         if (!discovered.contains(fnext)) {
-           discovered.add(fnext);
-           nodestack.push(fnext);
-         }
-       }
+        FlatNode fn1 = (FlatNode) nodestack.pop();
+
+        if (fn1.kind()==FKind.FlatReturnNode) {
+          /* Self edge */
+          FEdge newedge=new FEdge(fs, taskname, td, parameterindex);
+          ((Vector<FEdge>)tdToFEdges.get(td)).add(newedge);
+          fs.addEdge(newedge);
+          newedge.setisbackedge(true);
+          continue;
+        } else if (fn1.kind()==FKind.FlatFlagActionNode) {
+          FlatFlagActionNode ffan=(FlatFlagActionNode)fn1;
+          if (ffan.getTaskType() == FlatFlagActionNode.PRE) {
+            if (ffan.getTempFlagPairs().hasNext()||ffan.getTempTagPairs().hasNext())
+              throw new Error("PRE FlagActions not supported");
+
+          } else if (ffan.getTaskType() == FlatFlagActionNode.TASKEXIT) {
+            Vector<FlagState> fsv_taskexit=evalTaskExitNode(ffan,cd,fs,temp);
+            Vector<FlagState> initFStates = ffan.getInitFStates(temp.getType().getClassDesc());
+            if(!initFStates.contains(fs)) {
+              initFStates.addElement(fs);
+            }
+            Vector<FlagState> targetFStates = ffan.getTargetFStates(fs);
+            for(Enumeration en=fsv_taskexit.elements(); en.hasMoreElements(); ) {
+              FlagState fs_taskexit=(FlagState)en.nextElement();
+              if (!sourcenodes.containsKey(fs_taskexit)) {
+                toprocess.add(fs_taskexit);
+              }
+              //seen this node already
+              fs_taskexit=canonicalizeFlagState(sourcenodes,fs_taskexit);
+              FEdge newedge=new FEdge(fs_taskexit,taskname, td, parameterindex);
+              newedge.setTaskExitIndex(ffan.getTaskExitIndex());
+              ((Vector<FEdge>)tdToFEdges.get(td)).add(newedge);
+              fs.addEdge(newedge);
+
+              if(!targetFStates.contains(fs_taskexit)) {
+                targetFStates.addElement(fs_taskexit);
+              }
+            }
+            continue;
+          }
+        }
+        /* Queue other nodes past this one */
+        for(int i=0; i<fn1.numNext(); i++) {
+          FlatNode fnext=fn1.getNext(i);
+          if (!discovered.contains(fnext)) {
+            discovered.add(fnext);
+            nodestack.push(fnext);
+          }
+        }

       }
     }
   }
       }
     }
   }


@@ -290,16 +290,16 @@ public class TaskAnalysis {
     else
       switch (((FlagOpNode)fen).getOp().getOp()) {
       case Operation.LOGIC_AND:
     else
       switch (((FlagOpNode)fen).getOp().getOp()) {
       case Operation.LOGIC_AND:

-       return ((isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs)) && (isTaskTrigger_flag(((FlagOpNode)fen).getRight(),fs)));
+        return ((isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs)) && (isTaskTrigger_flag(((FlagOpNode)fen).getRight(),fs)));

 
       case Operation.LOGIC_OR:
 
       case Operation.LOGIC_OR:

-       return ((isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs)) || (isTaskTrigger_flag(((FlagOpNode)fen).getRight(),fs)));
+        return ((isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs)) || (isTaskTrigger_flag(((FlagOpNode)fen).getRight(),fs)));

 
       case Operation.LOGIC_NOT:
 
       case Operation.LOGIC_NOT:

-       return !(isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs));
+        return !(isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs));

 
       default:
 
       default:

-       return false;
+        return false;

       }
   }
 
       }
   }
 


@@ -307,14 +307,14 @@ public class TaskAnalysis {
 
     if (tel!=null) {
       for (int i=0; i<tel.numTags(); i++) {
 
     if (tel!=null) {
       for (int i=0; i<tel.numTags(); i++) {

-       switch (fs.getTagCount(tel.getType(i))) {
-       case FlagState.ONETAG:
-       case FlagState.MULTITAGS:
-         break;
-
-       case FlagState.NOTAGS:
-         return false;
-       }
+        switch (fs.getTagCount(tel.getType(i))) {
+        case FlagState.ONETAG:
+        case FlagState.MULTITAGS:
+          break;
+
+        case FlagState.NOTAGS:
+          return false;
+        }

       }
     }
     return true;
       }
     }
     return true;


@@ -330,7 +330,7 @@ public class TaskAnalysis {
     for(Iterator it_tfp=ffan.getTempFlagPairs(); it_tfp.hasNext(); ) {
       TempFlagPair tfp=(TempFlagPair)it_tfp.next();
       if (temp==tfp.getTemp())
     for(Iterator it_tfp=ffan.getTempFlagPairs(); it_tfp.hasNext(); ) {
       TempFlagPair tfp=(TempFlagPair)it_tfp.next();
       if (temp==tfp.getTemp())

-       fstemp=fstemp.setFlag(tfp.getFlag(),ffan.getFlagChange(tfp));
+        fstemp=fstemp.setFlag(tfp.getFlag(),ffan.getFlagChange(tfp));

     }
 
     //Process the tag changes
     }
 
     //Process the tag changes


@@ -342,15 +342,15 @@ public class TaskAnalysis {
       TempTagPair ttp=(TempTagPair)it_ttp.next();
 
       if (temp==ttp.getTemp()) {
       TempTagPair ttp=(TempTagPair)it_ttp.next();
 
       if (temp==ttp.getTemp()) {

-       Vector<FlagState> oldprocess=processed;
-       processed=new Vector<FlagState>();
-
-       for (Enumeration en=oldprocess.elements(); en.hasMoreElements(); ) {
-         FlagState fsworking=(FlagState)en.nextElement();
-         if (!ffan.getTagChange(ttp)) {
-           processed.addAll(Arrays.asList(fsworking.clearTag(ttp.getTag())));
-         } else processed.add(fsworking);
-       }
+        Vector<FlagState> oldprocess=processed;
+        processed=new Vector<FlagState>();
+
+        for (Enumeration en=oldprocess.elements(); en.hasMoreElements(); ) {
+          FlagState fsworking=(FlagState)en.nextElement();
+          if (!ffan.getTagChange(ttp)) {
+            processed.addAll(Arrays.asList(fsworking.clearTag(ttp.getTag())));
+          } else processed.add(fsworking);
+        }

       }
     }
     //Process sets next
       }
     }
     //Process sets next


@@ -358,15 +358,15 @@ public class TaskAnalysis {
       TempTagPair ttp=(TempTagPair)it_ttp.next();
 
       if (temp==ttp.getTemp()) {
       TempTagPair ttp=(TempTagPair)it_ttp.next();
 
       if (temp==ttp.getTemp()) {

-       Vector<FlagState> oldprocess=processed;
-       processed=new Vector<FlagState>();
-
-       for (Enumeration en=oldprocess.elements(); en.hasMoreElements(); ) {
-         FlagState fsworking=(FlagState)en.nextElement();
-         if (ffan.getTagChange(ttp)) {
-           processed.addAll(Arrays.asList(fsworking.setTag(ttp.getTag())));
-         } else processed.add(fsworking);
-       }
+        Vector<FlagState> oldprocess=processed;
+        processed=new Vector<FlagState>();
+
+        for (Enumeration en=oldprocess.elements(); en.hasMoreElements(); ) {
+          FlagState fsworking=(FlagState)en.nextElement();
+          if (ffan.getTagChange(ttp)) {
+            processed.addAll(Arrays.asList(fsworking.setTag(ttp.getTag())));
+          } else processed.add(fsworking);
+        }

       }
     }
     return processed;
       }
     }
     return processed;


@@ -422,17 +422,17 @@ public class TaskAnalysis {
 
     for(int k=0; k<noOfIterations; k++) {
       for(int j=0; j < externs; j++) {
 
     for(int k=0; k<noOfIterations; k++) {
       for(int j=0; j < externs; j++) {

-       if ((k% (1<<j)) == 0)
-         BoolValTable[j]=(!BoolValTable[j]);
+        if ((k% (1<<j)) == 0)
+          BoolValTable[j]=(!BoolValTable[j]);

       }
 
       FlagState fstemp=fs;
 
       for(int i=0; i < externs; i++) {
       }
 
       FlagState fstemp=fs;
 
       for(int i=0; i < externs; i++) {

-       fstemp=fstemp.setFlag(fd[i],BoolValTable[i]);
+        fstemp=fstemp.setFlag(fd[i],BoolValTable[i]);

       }
       if (!sourcenodes.containsKey(fstemp))
       }
       if (!sourcenodes.containsKey(fstemp))

-       toprocess.add(fstemp);
+        toprocess.add(fstemp);

 
       fstemp=canonicalizeFlagState(sourcenodes,fstemp);
       fs.addEdge(new FEdge(fstemp,"Runtime", null, -1));
 
       fstemp=canonicalizeFlagState(sourcenodes,fstemp);
       fs.addEdge(new FEdge(fstemp,"Runtime", null, -1));