int discoverytime = -1;
int finishingtime = -1; /* used for searches */
- //Hashtable<String,Integer> tags=new Hashtable<String,Integer>();
+ //Hashtable<TagDescriptor,Integer> tags=new Hashtable<TagDescriptor,Integer>();
Vector edges = new Vector();
Vector inedges = new Vector();
NodeStatus status = UNVISITED;
private final HashSet flagstate;
private final ClassDescriptor cd;
- private final Hashtable<String,Integer> tags;
+ private final Hashtable<TagDescriptor,Integer> tags;
public void setOption(String option) {
this.nodeoption=","+option;
public FlagState(ClassDescriptor cd) {
this.flagstate=new HashSet();
this.cd=cd;
- this.tags=new Hashtable<String,Integer>();
+ this.tags=new Hashtable<TagDescriptor,Integer>();
this.uid=FlagState.nodeid++;
}
* @param cd ClassDescriptor
* @param flagstate a <CODE>HashSet</CODE> containing FlagDescriptors
*/
- private FlagState(HashSet flagstate, ClassDescriptor cd,Hashtable<String,Integer> tags) {
+ private FlagState(HashSet flagstate, ClassDescriptor cd,Hashtable<TagDescriptor,Integer> tags) {
this.flagstate=flagstate;
this.cd=cd;
this.tags=tags;
public FlagState setTag(TagDescriptor tag){
- HashSet newset=flagstate.clone();
- Hashtable<String,Integer> newtags=tags.clone();
+ HashSet newset=(HashSet)flagstate.clone();
+ Hashtable<TagDescriptor,Integer> newtags=(Hashtable<TagDescriptor,Integer>)tags.clone();
if (newtags.containsKey(tag)){
switch (newtags.get(tag).intValue()){
case ONETAG:
- newtags.put(tag,new Integer(MULTITAG));
+ newtags.put(tag,new Integer(MULTITAGS));
break;
- case MULTITAG:
- newtags.put(tag,new Integer(MULTITAG));
+ case MULTITAGS:
+ newtags.put(tag,new Integer(MULTITAGS));
break;
}
}
if (tagtype.equals(td.getSymbol()))
return tags.get(td).intValue(); //returns either ONETAG or MULTITAG
}
- return NOTAG;
+ return NOTAGS;
}
public FlagState[] clearTag(TagDescriptor tag){
+ FlagState[] retstates;
if (tags.containsKey(tag)){
switch(tags.get(tag).intValue()){
case ONETAG:
- HashSet newset=flagstate.clone();
- Hashtable<String,Integer> newtags=tags.clone();
+ HashSet newset=(HashSet)flagstate.clone();
+ Hashtable<TagDescriptor,Integer> newtags=(Hashtable<TagDescriptor,Integer>)tags.clone();
newtags.remove(tag);
- return new FlagState(newset,cd,newtags);
- break;
- case MULTITAG:
- //when tagcount is more than 2, COUNT stays at MULTITAG
- FlagState[] retstates=new FlagState[2];
- HashSet newset1=flagstate.clone();
- Hashtable<String,Integer> newtags1=tags.clone();
+ retstates=new FlagState[]{new FlagState(newset,cd,newtags)};
+ return retstates;
+
+ case MULTITAGS:
+ //when tagcount is more than 2, COUNT stays at MULTITAGS
+ retstates=new FlagState[2];
+ HashSet newset1=(HashSet)flagstate.clone();
+ Hashtable<TagDescriptor,Integer> newtags1=(Hashtable<TagDescriptor,Integer>)tags.clone();
retstates[1]=new FlagState(newset1,cd,newtags1);
//when tagcount is 2, COUNT changes to ONETAG
- HashSet newset2=flagstate.clone();
- Hashtable<String,Integer> newtags2=tags.clone();
+ HashSet newset2=(HashSet)flagstate.clone();
+ Hashtable<TagDescriptor,Integer> newtags2=(Hashtable<TagDescriptor,Integer>)tags.clone();
newtags1.put(tag,new Integer(ONETAG));
retstates[1]=new FlagState(newset2,cd,newtags2);
return retstates;
- break;
+ default:
+ return null;
}
}else{
throw new Error("Invalid Operation: Can not clear a tag that doesn't exist.");
+
}
}
public FlagState setFlag(FlagDescriptor fd, boolean status) {
HashSet newset=(HashSet) flagstate.clone();
+ Hashtable<TagDescriptor,Integer> newtags=(Hashtable<TagDescriptor,Integer>)tags.clone();
if (status)
newset.add(fd);
else if (newset.contains(fd)){
newset.remove(fd);
}
- return new FlagState(newset, cd);
+
+ return new FlagState(newset, cd,newtags);
}
/** Tests for equality of two flagstate objects.
case ONETAG:
label+=", "+td.toString()+"(1)";
break;
- case MULTITAG:
+ case MULTITAGS:
label+=", "+td.toString()+"(n)";
break;
default:
toprocess.add(fsnew);
}
} else if (ffan.getTaskType() == FlatFlagActionNode.TASKEXIT) {
- FlagState fs_taskexit=evalTaskExitNode(ffan,cd,fs,temp);
- if (!sourcenodes.containsKey(fs_taskexit)) {
- toprocess.add(fs_taskexit);
- }
- //seen this node already
- fs_taskexit=canonicalizeFlagState(sourcenodes,fs_taskexit);
- Edge newedge=new Edge(fs_taskexit,taskname);
- fs.addEdge(newedge);
+ Vector<FlagState> fsv_taskexit=evalTaskExitNode(ffan,cd,fs,temp);
+
+ 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);
+ Edge newedge=new Edge(fs_taskexit,taskname);
+ fs.addEdge(newedge);
+ }
}
}
}
else
switch (((FlagOpNode)fen).getOp().getOp()) {
case Operation.LOGIC_AND:
- return ((isTaskTrigger(((FlagOpNode)fen).getLeft(),fs)) && (isTaskTrigger(((FlagOpNode)fen).getRight(),fs)));
+ return ((isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs)) && (isTaskTrigger_flag(((FlagOpNode)fen).getRight(),fs)));
case Operation.LOGIC_OR:
- return ((isTaskTrigger(((FlagOpNode)fen).getLeft(),fs)) || (isTaskTrigger(((FlagOpNode)fen).getRight(),fs)));
+ return ((isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs)) || (isTaskTrigger_flag(((FlagOpNode)fen).getRight(),fs)));
case Operation.LOGIC_NOT:
- return !(isTaskTrigger(((FlagOpNode)fen).getLeft(),fs));
+ return !(isTaskTrigger_flag(((FlagOpNode)fen).getLeft(),fs));
default:
return false;
}
for (int i=0;i<tel.numTags() ; i++){
switch (fs.getTagCount(tel.getType(i))){
case FlagState.ONETAG:
- case FlagState.MULTITAG:
- retval=true;
+ case FlagState.MULTITAGS:
break;
- case FlagState.NOTAG:
+ case FlagState.NOTAGS:
return false;
- break;
}
- return true;
+
}
+ return true;
}
/*private int tagTypeCount(TagExpressionList tel, String tagtype){
}
else
break;
+
+ }
return fstemp;
- }
+}
private Vector<FlagState> evalTaskExitNode(FlatNode nn,ClassDescriptor cd,FlagState fs, TempDescriptor temp){
FlagState fstemp=fs;
//FlagState[] fstemparray=new FlagState[3];
- Vector<FlagState> fsv=new Vector<FlagState>();
-
-
+ Vector<FlagState> inprocess=new Vector<FlagState>();
+ Vector<FlagState> processed=new Vector<FlagState>();
+
for(Iterator it_tfp=((FlatFlagActionNode)nn).getTempFlagPairs();it_tfp.hasNext();) {
TempFlagPair tfp=(TempFlagPair)it_tfp.next();
if (temp==tfp.getTemp())
fstemp=fstemp.setFlag(tfp.getFlag(),((FlatFlagActionNode)nn).getFlagChange(tfp));
}
+ inprocess.add(fstemp);
+ processed.add(fstemp);
+
for(Iterator it_ttp=((FlatFlagActionNode)nn).getTempTagPairs();it_ttp.hasNext();) {
TempTagPair ttp=(TempTagPair)it_ttp.next();
- if (temp==ttp.getTemp()){
- if (((FlatFlagActionNode)nn).getTagChange(ttp)){
- fstemp=fstemp.setTag(ttp.getTag());
- fstemp
- else
- fstemparray
+
+ if (temp==ttp.getTemp()){
+ processed=new Vector<FlagState>();
+ for (Enumeration en=inprocess.elements();en.hasMoreElements();){
+ FlagState fsworking=(FlagState)en.nextElement();
+ if (((FlatFlagActionNode)nn).getTagChange(ttp)){
+ fsworking=fsworking.setTag(ttp.getTag());
+ processed.add(fsworking);
+ }
+ else
+ {
+ processed.addAll(Arrays.asList(fsworking.clearTag(ttp.getTag())));
+ }
+ }
+ inprocess=processed;
}
-
- return fstemp;
- }
+ }
+ return processed;
+
+}
private FlagState canonicalizeFlagState(Hashtable sourcenodes, FlagState fs){
fstemp=canonicalizeFlagState(sourcenodes,fstemp);
fs.addEdge(new Edge(fstemp,"Runtime"));
}
+ }
}
-}
+
projects / IRC.git / commitdiff