X-Git-Url: http://plrg.eecs.uci.edu/git/?p=IRC.git;a=blobdiff_plain;f=Robust%2Fsrc%2FAnalysis%2FTaskStateAnalysis%2FTaskAnalysis.java;h=11cff8f28b278548759746838ba115b8416aea96;hp=954060f9e9f741b947826a78ee02c82914f09544;hb=bdc086e2ec7fcc674a604906627b52e16fba7eb3;hpb=eb17be02c22191b3fc7bdc335d9434ada68278de

diff --git a/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java b/Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java
index 954060f9..11cff8f2 100644
--- 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) {
-	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) {
-	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)) {
-	tdToFEdges.put(td, new Vector<FEdge>());
+        tdToFEdges.put(td, new Vector<FEdge>());
       }
 
       /** 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++) {
-	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
-	continue;
+        continue;
 
       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(); ) {
-	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();
@@ -217,55 +217,55 @@ public class TaskAnalysis {
       //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:
-	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:
-	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:
-	return !(isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs));
+        return !(isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs));
 
       default:
-	return false;
+        return false;
       }
   }
 
@@ -307,14 +307,14 @@ public class TaskAnalysis {
 
     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;
@@ -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())
-	fstemp=fstemp.setFlag(tfp.getFlag(),ffan.getFlagChange(tfp));
+        fstemp=fstemp.setFlag(tfp.getFlag(),ffan.getFlagChange(tfp));
     }
 
     //Process the tag changes
@@ -342,15 +342,15 @@ public class TaskAnalysis {
       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
@@ -358,15 +358,15 @@ public class TaskAnalysis {
       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;
@@ -422,17 +422,17 @@ public class TaskAnalysis {
 
     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++) {
-	fstemp=fstemp.setFlag(fd[i],BoolValTable[i]);
+        fstemp=fstemp.setFlag(fd[i],BoolValTable[i]);
       }
       if (!sourcenodes.containsKey(fstemp))
-	toprocess.add(fstemp);
+        toprocess.add(fstemp);
 
       fstemp=canonicalizeFlagState(sourcenodes,fstemp);
       fs.addEdge(new FEdge(fstemp,"Runtime", null, -1));