private void doOutput() {
try {
for(Iterator<TagDescriptor> tagit=tsresults.keySet().iterator(); tagit.hasNext(); ) {
- TagDescriptor tag=tagit.next();
- Set<TagState> set=tsresults.get(tag);
- File dotfile_flagstates= new File("tag"+tag.getSymbol()+".dot");
- FileOutputStream dotstream=new FileOutputStream(dotfile_flagstates,false);
- TagState.DOTVisitor.visit(dotstream,set);
+ TagDescriptor tag=tagit.next();
+ Set<TagState> set=tsresults.get(tag);
+ File dotfile_flagstates= new File("tag"+tag.getSymbol()+".dot");
+ FileOutputStream dotstream=new FileOutputStream(dotfile_flagstates,false);
+ TagState.DOTVisitor.visit(dotstream,set);
}
for(Iterator<ClassDescriptor> cdit=fsresults.keySet().iterator(); cdit.hasNext(); ) {
- ClassDescriptor cd=cdit.next();
- Set<TagState> set=fsresults.get(cd);
- File dotfile_flagstates= new File("class"+cd.getSymbol()+".dot");
- FileOutputStream dotstream=new FileOutputStream(dotfile_flagstates,false);
- TagState.DOTVisitor.visit(dotstream,set);
+ ClassDescriptor cd=cdit.next();
+ Set<TagState> set=fsresults.get(cd);
+ File dotfile_flagstates= new File("class"+cd.getSymbol()+".dot");
+ FileOutputStream dotstream=new FileOutputStream(dotfile_flagstates,false);
+ TagState.DOTVisitor.visit(dotstream,set);
}
} catch (Exception e) {
e.printStackTrace();
toprocess.remove(ts);
//Loop through each task
for(Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator(); taskit.hasNext(); ) {
- TaskDescriptor td=(TaskDescriptor)taskit.next();
- TaskQueue tq=tasktable.get(td);
- processTask(td, tq, ts);
+ TaskDescriptor td=(TaskDescriptor)taskit.next();
+ TaskQueue tq=tasktable.get(td);
+ processTask(td, tq, ts);
}
}
}
FlagState fs=fsit.next();
FlagTagState fts=new FlagTagState(ts, fs);
for(int i=0; i<td.numParameters(); i++) {
- System.out.println("Trying to enqueue "+td);
- if (canEnqueue(td, i, fs)) {
- System.out.println("Enqueued");
- TaskQueueIterator tqi=tq.enqueue(i, fts);
- while(tqi.hasNext()) {
- System.out.println("binding");
- processBinding(tqi);
- tqi.next();
- }
- }
+ System.out.println("Trying to enqueue "+td);
+ if (canEnqueue(td, i, fs)) {
+ System.out.println("Enqueued");
+ TaskQueueIterator tqi=tq.enqueue(i, fts);
+ while(tqi.hasNext()) {
+ System.out.println("binding");
+ processBinding(tqi);
+ tqi.next();
+ }
+ }
}
}
}
//Iterator through the Tags
for(Iterator<TempDescriptor> tmpit=prevtable.keySet().iterator(); tmpit.hasNext(); ) {
- TempDescriptor tmp=tmpit.next();
- Wrapper prevtag=prevtable.get(tmp);
- if (prevtag instanceof ObjWrapper)
- continue;
- if (table.containsKey(tmp)) {
- //merge tag states
- TagWrapper currtag=(TagWrapper) table.get(tmp);
- tagtable.put((TagWrapper)prevtag, currtag);
- assert(currtag.initts.equals(((TagWrapper)prevtag).initts));
- for(Iterator<TagState> tagit=((TagWrapper)prevtag).ts.iterator(); tagit.hasNext(); ) {
- TagState tag=tagit.next();
- if (!currtag.ts.contains(tag)) {
- currtag.ts.add(tag);
- }
- }
- } else {
- TagWrapper clonetag=((TagWrapper)prevtag).clone();
- tagtable.put((TagWrapper)prevtag, clonetag);
- table.put(tmp, clonetag);
- }
+ TempDescriptor tmp=tmpit.next();
+ Wrapper prevtag=prevtable.get(tmp);
+ if (prevtag instanceof ObjWrapper)
+ continue;
+ if (table.containsKey(tmp)) {
+ //merge tag states
+ TagWrapper currtag=(TagWrapper) table.get(tmp);
+ tagtable.put((TagWrapper)prevtag, currtag);
+ assert(currtag.initts.equals(((TagWrapper)prevtag).initts));
+ for(Iterator<TagState> tagit=((TagWrapper)prevtag).ts.iterator(); tagit.hasNext(); ) {
+ TagState tag=tagit.next();
+ if (!currtag.ts.contains(tag)) {
+ currtag.ts.add(tag);
+ }
+ }
+ } else {
+ TagWrapper clonetag=((TagWrapper)prevtag).clone();
+ tagtable.put((TagWrapper)prevtag, clonetag);
+ table.put(tmp, clonetag);
+ }
}
//Iterator through the Objects
for(Iterator<TempDescriptor> tmpit=prevtable.keySet().iterator(); tmpit.hasNext(); ) {
- TempDescriptor tmp=tmpit.next();
- Wrapper obj=prevtable.get(tmp);
- if (obj instanceof TagWrapper)
- continue;
- ObjWrapper prevobj=(ObjWrapper)obj;
- if (!table.containsKey(tmp)) {
- //merge tag states
- ObjWrapper newobj=new ObjWrapper();
- newobj.initfs=prevobj.initfs;
- table.put(tmp, newobj);
- }
- ObjWrapper currobj=(ObjWrapper) table.get(tmp);
- assert(currobj.initfs.equals(prevobj.initfs));
- for(Iterator<TagWrapper> tagit=prevobj.tags.iterator(); tagit.hasNext(); ) {
- TagWrapper tprev=tagit.next();
- TagWrapper t=tagtable.get(tprev);
- currobj.tags.add(t);
- }
- for(Iterator<FlagState> flagit=prevobj.fs.iterator(); flagit.hasNext(); ) {
- FlagState fs=flagit.next();
- currobj.fs.add(fs);
- }
+ TempDescriptor tmp=tmpit.next();
+ Wrapper obj=prevtable.get(tmp);
+ if (obj instanceof TagWrapper)
+ continue;
+ ObjWrapper prevobj=(ObjWrapper)obj;
+ if (!table.containsKey(tmp)) {
+ //merge tag states
+ ObjWrapper newobj=new ObjWrapper();
+ newobj.initfs=prevobj.initfs;
+ table.put(tmp, newobj);
+ }
+ ObjWrapper currobj=(ObjWrapper) table.get(tmp);
+ assert(currobj.initfs.equals(prevobj.initfs));
+ for(Iterator<TagWrapper> tagit=prevobj.tags.iterator(); tagit.hasNext(); ) {
+ TagWrapper tprev=tagit.next();
+ TagWrapper t=tagtable.get(tprev);
+ currobj.tags.add(t);
+ }
+ for(Iterator<FlagState> flagit=prevobj.fs.iterator(); flagit.hasNext(); ) {
+ FlagState fs=flagit.next();
+ currobj.fs.add(fs);
+ }
}
}
return table;
TagWrapper tw=tagit.next();
HashSet<TagState> newstates=new HashSet<TagState>();
for(Iterator<TagState> tgit=tw.ts.iterator(); tgit.hasNext(); ) {
- TagState ts=tgit.next();
- for(Iterator<FlagState> flagit=ts.getFS().iterator(); flagit.hasNext(); ) {
- FlagState fs=flagit.next();
- if (flagmap.containsKey(fs)) {
- if (flagmap.get(fs).equals(fs)) {
- newstates.add(ts);
- } else {
- TagState tsarray[]=ts.clearFS(fs);
- //Can do strong update here because these
- //must be parameter objects...therefore
- //all possible aliasing relationships are
- //explored
- for(int i=0; i<tsarray.length; i++) {
- TagState ts2=canonical(tsarray[i]);
- TagState tsarray2[]=ts2.addnewFS(flagmap.get(fs));
- for(int j=0; j<tsarray2.length; j++)
- newstates.add(canonical(tsarray2[j]));
- }
- }
- }
- }
+ TagState ts=tgit.next();
+ for(Iterator<FlagState> flagit=ts.getFS().iterator(); flagit.hasNext(); ) {
+ FlagState fs=flagit.next();
+ if (flagmap.containsKey(fs)) {
+ if (flagmap.get(fs).equals(fs)) {
+ newstates.add(ts);
+ } else {
+ TagState tsarray[]=ts.clearFS(fs);
+ //Can do strong update here because these
+ //must be parameter objects...therefore
+ //all possible aliasing relationships are
+ //explored
+ for(int i=0; i<tsarray.length; i++) {
+ TagState ts2=canonical(tsarray[i]);
+ TagState tsarray2[]=ts2.addnewFS(flagmap.get(fs));
+ for(int j=0; j<tsarray2.length; j++)
+ newstates.add(canonical(tsarray2[j]));
+ }
+ }
+ }
+ }
}
tw.ts=newstates;
}
private void setTag(ObjWrapper ow, TagWrapper twnew, TagDescriptor tag, boolean value) {
if (value) {
if (ow.tags.contains(twnew)) {
- System.out.println("Tag already bound to object.");
- return;
+ System.out.println("Tag already bound to object.");
+ return;
}
} else {
if (!ow.tags.contains(twnew)) {
- System.out.println("Tag not bound to object.");
- return;
+ System.out.println("Tag not bound to object.");
+ return;
}
}
HashSet<FlagState> newfsstates=new HashSet<FlagState>();
TagWrapper tw=tagit.next();
HashSet<TagState> newstates=new HashSet<TagState>();
for(Iterator<TagState> tgit=tw.ts.iterator(); tgit.hasNext(); ) {
- TagState ts=tgit.next();
- for(Iterator<FlagState> flagit=ts.getFS().iterator(); flagit.hasNext(); ) {
- FlagState fs=flagit.next();
- if (flagmap.containsKey(fs)) {
- FlagState[] fmap=flagmap.get(fs);
- for(int i=0; i<fmap.length; i++) {
- FlagState fsnew=fmap[i];
- if (fsnew.equals(fs)) {
- newstates.add(ts);
- } else {
- TagState tsarray[]=ts.clearFS(fs);
- //Can do strong update here because
- //these must be parameter
- //objects...therefore all possible
- //aliasing relationships are explored
- for(int j=0; j<tsarray.length; j++) {
- TagState ts2=canonical(tsarray[j]);
- TagState tsarray2[]=ts2.addnewFS(fsnew);
- for(int k=0; k<tsarray2.length; k++)
- newstates.add(canonical(tsarray2[k]));
- }
- }
- }
- }
- }
+ TagState ts=tgit.next();
+ for(Iterator<FlagState> flagit=ts.getFS().iterator(); flagit.hasNext(); ) {
+ FlagState fs=flagit.next();
+ if (flagmap.containsKey(fs)) {
+ FlagState[] fmap=flagmap.get(fs);
+ for(int i=0; i<fmap.length; i++) {
+ FlagState fsnew=fmap[i];
+ if (fsnew.equals(fs)) {
+ newstates.add(ts);
+ } else {
+ TagState tsarray[]=ts.clearFS(fs);
+ //Can do strong update here because
+ //these must be parameter
+ //objects...therefore all possible
+ //aliasing relationships are explored
+ for(int j=0; j<tsarray.length; j++) {
+ TagState ts2=canonical(tsarray[j]);
+ TagState tsarray2[]=ts2.addnewFS(fsnew);
+ for(int k=0; k<tsarray2.length; k++)
+ newstates.add(canonical(tsarray2[k]));
+ }
+ }
+ }
+ }
+ }
}
tw.ts=newstates;
}
{
HashSet<TagState> newstates=new HashSet<TagState>();
for(Iterator<TagState> tgit=twnew.ts.iterator(); tgit.hasNext(); ) {
- TagState ts=tgit.next();
- for(Iterator<FlagState> flagit=newfsstates.iterator(); flagit.hasNext(); ) {
- FlagState fsnew=flagit.next();
- //Can do strong update here because these must
- //be parameter objects...therefore all
- //possible aliasing relationships are explored
- TagState tsarray2[];
- if (value)
- tsarray2=ts.addnewFS(fsnew);
- else
- tsarray2=ts.clearFS(fsnew);
- for(int j=0; j<tsarray2.length; j++)
- newstates.add(canonical(tsarray2[j]));
- }
+ TagState ts=tgit.next();
+ for(Iterator<FlagState> flagit=newfsstates.iterator(); flagit.hasNext(); ) {
+ FlagState fsnew=flagit.next();
+ //Can do strong update here because these must
+ //be parameter objects...therefore all
+ //possible aliasing relationships are explored
+ TagState tsarray2[];
+ if (value)
+ tsarray2=ts.addnewFS(fsnew);
+ else
+ tsarray2=ts.clearFS(fsnew);
+ for(int j=0; j<tsarray2.length; j++)
+ newstates.add(canonical(tsarray2[j]));
+ }
}
twnew.ts=newstates;
}
boolean newtagstate=fn.getTagChange(ttp);
ObjWrapper ow=(ObjWrapper)table.get(tmp);
if (!newtagstate)
- setTag(ow, tagw, tag, newtagstate);
+ setTag(ow, tagw, tag, newtagstate);
}
//Do the flags next
boolean newtagstate=fn.getTagChange(ttp);
ObjWrapper ow=(ObjWrapper)table.get(tmp);
if (newtagstate)
- setTag(ow, tagw, tag, newtagstate);
+ setTag(ow, tagw, tag, newtagstate);
}
}
/* Compute type */
Iterator it=fn.getTempFlagPairs();
if (it.hasNext()) {
- TempFlagPair tfp=(TempFlagPair)it.next();
- fntemp=tfp.getTemp();
+ TempFlagPair tfp=(TempFlagPair)it.next();
+ fntemp=tfp.getTemp();
} else {
- it=fn.getTempTagPairs();
- if (!it.hasNext())
- throw new Error();
- TempTagPair ttp=(TempTagPair)it.next();
- fntemp=ttp.getTemp();
+ it=fn.getTempTagPairs();
+ if (!it.hasNext())
+ throw new Error();
+ TempTagPair ttp=(TempTagPair)it.next();
+ fntemp=ttp.getTemp();
}
}
FlagState fs=canonical(new FlagState(fntemp.getType().getClassDesc()));
boolean newtagstate=fn.getTagChange(ttp);
assert(ow==table.get(tmp));
if (newtagstate)
- setTag(ow, tagw, tag, newtagstate);
+ setTag(ow, tagw, tag, newtagstate);
else
- throw new Error("Can't clear tag in newly allocated object");
+ throw new Error("Can't clear tag in newly allocated object");
}
for(Iterator<FlagState> fsit=ow.fs.iterator(); fsit.hasNext(); ) {
FlagState fs2=fsit.next();
ts2.addSource(td);
addresult(fs2.getClassDescriptor(), ts2);
if (!discovered.contains(ts2)) {
- discovered.add(ts2);
- toprocess.add(ts2);
+ discovered.add(ts2);
+ toprocess.add(ts2);
}
}
}
for(Iterator<TagState> tsit=tw.ts.iterator(); tsit.hasNext(); ) {
TagState ts=tsit.next();
if (init==null) {
- ts.addSource(td);
+ ts.addSource(td);
} else {
- TagEdge te=new TagEdge(ts, td);
- if (!init.containsEdge(te)) {
- init.addEdge(te);
- }
+ TagEdge te=new TagEdge(ts, td);
+ if (!init.containsEdge(te)) {
+ init.addEdge(te);
+ }
}
if (ts.getTag()!=null)
- addresult(ts.getTag(), ts);
+ addresult(ts.getTag(), ts);
else
- addresult(ts.getClassDesc(), ts);
+ addresult(ts.getClassDesc(), ts);
if (!discovered.contains(ts)) {
- discovered.add(ts);
- toprocess.add(ts);
+ discovered.add(ts);
+ toprocess.add(ts);
}
}
}
TempDescriptor tmp=tmpit.next();
Wrapper w=table.get(tmp);
if (w instanceof TagWrapper) {
- TagWrapper tw=(TagWrapper)w;
- recordtagchange(tw, td);
+ TagWrapper tw=(TagWrapper)w;
+ recordtagchange(tw, td);
} else {
- ObjWrapper ow=(ObjWrapper)w;
- recordobj(ow, td);
+ ObjWrapper ow=(ObjWrapper)w;
+ recordobj(ow, td);
}
}
}
for(Iterator<TempDescriptor> tmpit=table1.keySet().iterator(); tmpit.hasNext(); ) {
TempDescriptor tmp=tmpit.next();
if (table2.containsKey(tmp)) {
- emap.put(table1.get(tmp), table2.get(tmp));
+ emap.put(table1.get(tmp), table2.get(tmp));
} else return false;
}
Wrapper w1=table1.get(tmp);
Wrapper w2=table2.get(tmp);
if (w1 instanceof TagWrapper) {
- TagWrapper t1=(TagWrapper)w1;
- TagWrapper t2=(TagWrapper)w2;
- if (!t1.ts.equals(t2.ts))
- return false;
+ TagWrapper t1=(TagWrapper)w1;
+ TagWrapper t2=(TagWrapper)w2;
+ if (!t1.ts.equals(t2.ts))
+ return false;
} else {
- ObjWrapper t1=(ObjWrapper)w1;
- ObjWrapper t2=(ObjWrapper)w2;
- if (!t1.fs.equals(t2.fs))
- return false;
- if (t1.tags.size()!=t2.tags.size())
- return false;
- for(Iterator<TagWrapper> twit=t1.tags.iterator(); twit.hasNext(); ) {
- TagWrapper tw1=twit.next();
- if (!t2.tags.contains(emap.get(tw1)))
- return false;
- }
+ ObjWrapper t1=(ObjWrapper)w1;
+ ObjWrapper t2=(ObjWrapper)w2;
+ if (!t1.fs.equals(t2.fs))
+ return false;
+ if (t1.tags.size()!=t2.tags.size())
+ return false;
+ for(Iterator<TagWrapper> twit=t1.tags.iterator(); twit.hasNext(); ) {
+ TagWrapper tw1=twit.next();
+ if (!t2.tags.contains(emap.get(tw1)))
+ return false;
+ }
}
}
return true;
Hashtable<TempDescriptor, Wrapper> table=computeInitialState(wtable, fn);
switch(fn.kind()) {
case FKind.FlatFlagActionNode:
- processFlatFlag((FlatFlagActionNode)fn, table, td);
- break;
+ processFlatFlag((FlatFlagActionNode)fn, table, td);
+ break;
case FKind.FlatTagDeclaration:
- processFlatTag((FlatTagDeclaration)fn, table, td);
- break;
+ processFlatTag((FlatTagDeclaration)fn, table, td);
+ break;
case FKind.FlatCall:
- processFlatCall((FlatCall)fn, table);
- break;
+ processFlatCall((FlatCall)fn, table);
+ break;
case FKind.FlatReturnNode:
- processFlatReturnNode((FlatReturnNode)fn, table, td);
- break;
+ processFlatReturnNode((FlatReturnNode)fn, table, td);
+ break;
default:
}
if (!equivalent(table, wtable.get(fn))) {
- wtable.put(fn, table);
- for(int i=0; i<fn.numNext(); i++) {
- tovisit.add(fn.getNext(i));
- }
+ wtable.put(fn, table);
+ for(int i=0; i<fn.numNext(); i++) {
+ tovisit.add(fn.getNext(i));
+ }
} else {
- for(int i=0; i<fn.numNext(); i++) {
- if (!visited.contains(fn.getNext(i)))
- tovisit.add(fn.getNext(i));
- }
+ for(int i=0; i<fn.numNext(); i++) {
+ if (!visited.contains(fn.getNext(i)))
+ tovisit.add(fn.getNext(i));
+ }
}
}
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;
}
}
private static boolean isTaskTrigger_tag(TagExpressionList tel, FlagState fs) {
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;
projects / IRC.git / blobdiff