Robust/src/Analysis/TaskStateAnalysis/TaskAnalysis.java

   1 package Analysis.TaskStateAnalysis;
   2 import Analysis.TaskStateAnalysis.*;
   3 import IR.*;
   4 import IR.Tree.*;
   5 import IR.Flat.*;
   6 import java.util.*;
   7 import java.io.File;
   8 import java.io.FileWriter;
   9
  10 public class TaskAnalysis {
  11     State state;
  12     Hashtable Adj_List;
  13     Hashtable flags;
  14     Hashtable extern_flags;
  15     Queue<TriggerState> q_main;
  16
  17     /**
  18      * Class Constructor
  19      *
  20      * @param state a flattened State object
  21      * @see State
  22      */
  23     public TaskAnalysis(State state)
  24     {
  25         this.state=state;
  26     }
  27
  28     /** This function returns the number of external flags, etc */
  29
  30     private void getFlagsfromClasses() {
  31         flags=new Hashtable();
  32         extern_flags = new Hashtable();
  33
  34         for(Iterator it_classes=state.getClassSymbolTable().getDescriptorsIterator();it_classes.hasNext();) {
  35
  36             ClassDescriptor cd = (ClassDescriptor)it_classes.next();
  37             System.out.println(cd.getSymbol());
  38             Vector vFlags=new Vector();
  39             FlagDescriptor flag[];
  40             int ctr=0;
  41
  42
  43             /* Adding the flags of the super class */
  44             if (cd.getSuper()!=null) {
  45                 ClassDescriptor superdesc=cd.getSuperDesc();
  46
  47                 for(Iterator it_cflags=superdesc.getFlags();it_cflags.hasNext();) {
  48                     FlagDescriptor fd = (FlagDescriptor)it_cflags.next();
  49                     System.out.println(fd.toString());
  50                     vFlags.add(fd);
  51                 }
  52             }
  53
  54             for(Iterator it_cflags=cd.getFlags();it_cflags.hasNext();) {
  55                 FlagDescriptor fd = (FlagDescriptor)it_cflags.next();
  56                 System.out.println(fd.toString());
  57                 vFlags.add(fd);
  58             }
  59
  60             if (vFlags.size()!=0) {
  61                 flag=new FlagDescriptor[vFlags.size()];
  62
  63                 for(int i=0;i < vFlags.size() ; i++) {
  64                     if (((FlagDescriptor)vFlags.get(i)).getExternal()) {
  65                         flag[ctr]=(FlagDescriptor)vFlags.get(i);
  66                         vFlags.remove(flag[ctr]);
  67                         ctr++;
  68                     }
  69                 }
  70                 for(int i=0;i < vFlags.size() ; i++) {
  71                     flag[i+ctr]=(FlagDescriptor)vFlags.get(i);
  72                 }
  73                 extern_flags.put(cd,new Integer(ctr));
  74                 flags.put(cd,flag);
  75
  76             }
  77         }
  78     }
  79
  80     public void taskAnalysis() throws java.io.IOException {
  81         Adj_List=new Hashtable();
  82
  83         getFlagsfromClasses();
  84
  85         int externs;
  86         q_main=new LinkedList<TriggerState>();
  87
  88         for(Iterator it_classes=(Iterator)flags.keys();it_classes.hasNext();) {
  89             ClassDescriptor cd=(ClassDescriptor)it_classes.next();
  90
  91             externs=((Integer)extern_flags.get(cd)).intValue();
  92
  93             FlagDescriptor[] fd=(FlagDescriptor[])flags.get(cd);
  94             //Debug block
  95             System.out.println("Inside taskAnalysis;\n Class:"+ cd.getSymbol());
  96             System.out.println("No of externs " + externs);
  97             System.out.println("No of flags: "+fd.length);
  98             //Debug block
  99             if (fd.length == externs) {
 100                 System.out.println("extern called");
 101                 boolean onlyExterns=true;
 102             } else {
 103                 if ((fd.length == 1)
 104                     && (fd[0].getSymbol().compareTo("initialstate")==0)) {
 105                     FlagState fstemp=new FlagState(fd, cd);
 106                     Hashtable Adj_List_temp=new Hashtable();
 107
 108                     fstemp.put(fd[0],new Boolean(true));
 109                     Vector vtemp=new Vector();
 110                     vtemp.add(new Edge(fstemp,"Runtime"));
 111                     Adj_List_temp.put(new FlagState(fd,cd),vtemp);
 112                     Adj_List.put(cd,Adj_List_temp);
 113
 114                     Queue<TriggerState> q_temp=analyseTasks(new TriggerState(cd,fstemp));
 115
 116
 117                     if ( q_temp != null) {
 118                         q_main.addAll(q_temp);
 119                     }
 120
 121                 }
 122             }
 123         }
 124         while (q_main.size() > 0) {
 125             // ****debug block********
 126             for (Iterator it_qm=q_main.iterator();it_qm.hasNext();)
 127                 {
 128                     TriggerState ts_qm=(TriggerState)it_qm.next();
 129                     FlagState fs_qm=ts_qm.getState();
 130                     System.out.println("/***********contents of main q**********/");
 131                     System.out.println("FS : "+fs_qm.toString((FlagDescriptor [])flags.get(ts_qm.getClassDescriptor())));
 132
 133
 134                 }
 135             System.out.println("/*********************************/");
 136             // ****debug block********
 137             Queue<TriggerState> q_temp=analyseTasks(q_main.poll());
 138             if ( q_temp != null) {
 139                 q_main.addAll(q_temp);
 140             }
 141         }
 142
 143         //Creating DOT files
 144         Enumeration e=Adj_List.keys();
 145
 146         while (e.hasMoreElements()) {
 147             System.out.println("creating dot file");
 148             ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
 149             System.out.println((cdtemp.getSymbol()));
 150             createDOTfile(cdtemp);
 151         }
 152
 153     }
 154
 155
 156     public Queue<TriggerState> analyseTasks(TriggerState ts) throws java.io.IOException {
 157         Queue<FlagState> q;
 158         Queue<FlagState> qft;
 159
 160         Hashtable Adj_List_temp;
 161         Queue<TriggerState> q_retval;
 162
 163         ClassDescriptor cd=ts.getClassDescriptor();
 164
 165         if (Adj_List.containsKey(cd)) {
 166             //Debug block
 167             System.out.println("Inside analyseTasks;\n Checking if adj_list contains the class desc:"+ cd.getSymbol());
 168             //Debug block
 169
 170             Adj_List_temp=(Hashtable)Adj_List.get(cd);
 171         } else {
 172             Adj_List_temp=new Hashtable();
 173             Adj_List.put(cd,Adj_List_temp);
 174         }
 175
 176
 177         int externs=((Integer)extern_flags.get(cd)).intValue();
 178         FlagDescriptor[] fd=(FlagDescriptor[])flags.get(cd);
 179
 180         q = new LinkedList<FlagState>();
 181         q_retval=new LinkedList<TriggerState>();
 182         q.offer(ts.getState());
 183
 184         //***Debug Block***
 185
 186         while (q.size() != 0) {
 187             System.out.println("inside while loop in analysetasks \n");
 188
 189             FlagState fsworking=q.poll();
 190
 191             //***Debug Block***
 192             FlagDescriptor[] ftemp=(FlagDescriptor[])flags.get(cd);
 193             System.out.println("Processing state: "+cd.getSymbol()+" " + fsworking.toString(ftemp));
 194
 195             //***Debug Block***
 196
 197
 198             for(Iterator it_tasks=state.getTaskSymbolTable().getDescriptorsIterator();it_tasks.hasNext();) {
 199                 TaskDescriptor td = (TaskDescriptor)it_tasks.next();
 200                 boolean taskistriggered=false;
 201                 int ctr=0;
 202                 String taskname=getTaskName(td);
 203
 204
 205
 206                 //***Debug Block***
 207
 208                 System.out.println();
 209                 System.out.println("Method: AnalyseTasks");
 210                 System.out.println(taskname);
 211                 System.out.println();
 212
 213                 //***Debug Block***
 214
 215
 216                 for(int i=0; i < td.numParameters(); i++) {
 217                     FlagExpressionNode fen=td.getFlag(td.getParameter(i));
 218                     if (isTaskTrigger(fen,fsworking))
 219                         taskistriggered = true;
 220                 }
 221
 222                 if (taskistriggered) {
 223                     //***Debug Block***
 224                     //
 225                     System.out.println("inside taskistriggered");
 226
 227                     //***Debug Block***
 228                     if (wasFlagStateProcessed(Adj_List_temp,fsworking)) {
 229                         if (! (fd.length == externs))
 230                             continue;
 231                     } else
 232                         Adj_List_temp.put(fsworking,new Vector());
 233
 234                     FlatMethod fm = state.getMethodFlat(td);
 235                     FlatNode fn=fm.methodEntryNode();
 236
 237                     HashSet tovisit= new HashSet();
 238                     HashSet visited= new HashSet();
 239
 240                     tovisit.add(fn);
 241                     while(!tovisit.isEmpty()) {
 242                         FlatNode fn1 = (FlatNode)tovisit.iterator().next();
 243                         tovisit.remove(fn1);
 244                         visited.add(fn1);
 245                         for(int i = 0; i < fn1.numNext(); i++) {
 246                             FlatNode nn=fn1.getNext(i);
 247                             if (nn.kind()==13) {
 248                                 //***Debug Block***
 249                                 if (((FlatFlagActionNode)nn).getFFANType() == FlatFlagActionNode.PRE) {
 250                                     throw new Error("PRE FlagActions not supported");
 251                                 } else if (((FlatFlagActionNode)nn).getFFANType() == FlatFlagActionNode.NEWOBJECT) {
 252                                     //***Debug Block***
 253                                     System.out.println("NEWObject");
 254                                     //***Debug Block***
 255
 256
 257                                     TempDescriptor[] tdArray = ((FlatFlagActionNode)nn).readsTemps();
 258
 259                                     //Under the safe assumption that all the temps in FFAN.NewObject node are of the same type(class)
 260                                     ClassDescriptor cd_new=tdArray[0].getType().getClassDesc();
 261
 262                                     System.out.println("Class: "+cd_new.getSymbol());
 263
 264                                     FlagState fstemp=new FlagState((FlagDescriptor[])flags.get(cd_new), cd_new);
 265
 266                                     for(Iterator it_tfp=((FlatFlagActionNode)nn).getTempFlagPairs();it_tfp.hasNext();) {
 267                                         TempFlagPair tfp=(TempFlagPair)it_tfp.next();
 268                                         if (tfp.getFlag()==null) {
 269                                             System.out.println("test1");
 270                                             q_retval.addAll(createPossibleRuntimeStates(new TriggerState(cd_new,new FlagState((FlagDescriptor[])flags.get(cd_new), cd_new))));
 271                                             // ****debug block********
 272                                             System.out.println("/***********contents of q ret**********/");
 273                                             for (Iterator it_qret=q_retval.iterator();it_qret.hasNext();) {
 274                                                 TriggerState ts_qret=(TriggerState)it_qret.next();
 275                                                 FlagState fs_qret=ts_qret.getState();
 276
 277                                                 System.out.println("FS : "+fs_qret.toString((FlagDescriptor [])flags.get(ts_qret.getClassDescriptor())));
 278                                             }
 279                                             System.out.println("/*********************************/");
 280                                             // ****debug block********
 281                                         } else
 282                                             fstemp.put(tfp.getFlag(),new Boolean(((FlatFlagActionNode)nn).getFlagChange(tfp)));
 283
 284
 285                                     }
 286
 287                                     //***Debug Block***
 288                                     System.out.println("test2");
 289                                     System.out.println("Newobj fsworking "+fsworking.toString((FlagDescriptor [])flags.get(cd_new)));
 290                                     System.out.println("Newobj fstemp "+fstemp.toString((FlagDescriptor [])flags.get(cd_new)));
 291
 292                                     //***Debug Block***
 293
 294                                     q_retval.offer(new TriggerState(cd_new,fstemp));
 295
 296                                     //make this a function containsExterns()
 297                                     int extrns=((Integer)extern_flags.get(cd_new)).intValue();
 298
 299                                     if ((extrns >0) && (extrns!=((FlagDescriptor[])flags.get(cd_new)).length))
 300                                         q_retval.addAll(createPossibleRuntimeStates(new TriggerState(cd_new,fstemp)));
 301
 302                                     fstemp=null;
 303                                     // ****debug block********
 304                                     System.out.println("/***********contents of q ret 1**********/");
 305                                     for (Iterator it_qret=q_retval.iterator();it_qret.hasNext();) {
 306                                         TriggerState ts_qret=(TriggerState)it_qret.next();
 307                                         FlagState fs_qret=ts_qret.getState();
 308
 309                                         System.out.println("FS : "+fs_qret.toString((FlagDescriptor [])flags.get(ts_qret.getClassDescriptor())));
 310                                     }
 311                                     System.out.println("/*********************************/");
 312                                     // ****debug block********
 313
 314                                 }
 315                                 if (((FlatFlagActionNode)nn).getFFANType() == FlatFlagActionNode.TASKEXIT) {
 316                                     //***Debug Block***
 317                                     //
 318                                     System.out.println("TaskExit");
 319                                     //***Debug Block***
 320
 321                                     FlagState fstemp=new FlagState(fsworking.getStateTable(), null); //WHAT CLASS IS THIS
 322
 323                                     for(Iterator it_tfp=((FlatFlagActionNode)nn).getTempFlagPairs();it_tfp.hasNext();) {
 324                                         TempFlagPair tfp=(TempFlagPair)it_tfp.next();
 325                                         fstemp.put(tfp.getFlag(),new Boolean(((FlatFlagActionNode)nn).getFlagChange(tfp)));
 326                                     }
 327                                     //***Debug Block***
 328                                     System.out.println();
 329                                     System.out.println(fstemp.toString((FlagDescriptor [])flags.get(cd)));
 330                                     System.out.println();
 331                                     System.out.println("taskexit fsworking "+fsworking.toString((FlagDescriptor [])flags.get(cd)));
 332                                     System.out.println("taskexit fstemp "+fstemp.toString((FlagDescriptor [])flags.get(cd)));
 333
 334                                     //***Debug Block***
 335                                     if (!edgeexists(Adj_List_temp,fsworking,fstemp,taskname)) {
 336                                         ((Vector)Adj_List_temp.get(fsworking)).add(new Edge(fstemp,taskname));
 337                                     }
 338                                     if (!wasFlagStateProcessed(Adj_List_temp,fstemp)) {
 339                                         q.offer(fstemp);
 340                                     }
 341                                     fstemp=null;
 342
 343                                 }
 344                             }
 345
 346                             if (!visited.contains(nn) && !tovisit.contains(nn)) {
 347                                 tovisit.add(nn);
 348                             }
 349                         }
 350                     }
 351                 }
 352             }
 353         }
 354         if (q_retval.size()==0)
 355             return null;
 356         else
 357             return q_retval;
 358     }
 359
 360     private boolean isTaskTrigger(FlagExpressionNode fen,FlagState fs) {
 361         if (fen instanceof FlagNode)
 362             return fs.get(((FlagNode)fen).getFlag());
 363         else
 364             switch (((FlagOpNode)fen).getOp().getOp()) {
 365             case Operation.LOGIC_AND:
 366                 return ((isTaskTrigger(((FlagOpNode)fen).getLeft(),fs)) && (isTaskTrigger(((FlagOpNode)fen).getRight(),fs)));
 367             case Operation.LOGIC_OR:
 368                 return ((isTaskTrigger(((FlagOpNode)fen).getLeft(),fs)) || (isTaskTrigger(((FlagOpNode)fen).getRight(),fs)));
 369             case Operation.LOGIC_NOT:
 370                 return !(isTaskTrigger(((FlagOpNode)fen).getLeft(),fs));
 371             default:
 372                 return false;
 373             }
 374     }
 375
 376     private boolean wasFlagStateProcessed(Hashtable Adj_List,FlagState fs) {
 377         Enumeration e=Adj_List.keys();
 378
 379         while(e.hasMoreElements()) {
 380             FlagState fsv = (FlagState)(e.nextElement());
 381
 382             if (fsv.isEqual(fs))
 383                 return true;
 384         }
 385         return false;
 386     }
 387
 388     private boolean existsInQueue(TriggerState ts) {
 389         for(Iterator it_queue=q_main.iterator();it_queue.hasNext();) {
 390             TriggerState ts_local=(TriggerState)it_queue.next();
 391
 392             if (ts_local.equals(ts))
 393                 return true;
 394         }
 395         return false;
 396     }
 397
 398     private boolean existsInFSQueue(Queue q,FlagState fs) {
 399         for (Iterator it_q=q.iterator();it_q.hasNext();) {
 400             if(((FlagState)it_q.next()).isEqual(fs))
 401                 return true;
 402         }
 403         return false;
 404     }
 405
 406     public void printAdjList(ClassDescriptor cd) {
 407         Enumeration e=((Hashtable)Adj_List.get(cd)).keys();
 408         while(e.hasMoreElements()) {
 409             FlagState fsv = (FlagState)(e.nextElement());
 410             System.out.println(fsv.toString((FlagDescriptor [])flags.get(cd)));
 411         }
 412     }
 413
 414     public void createDOTfile(ClassDescriptor cd) throws java.io.IOException {
 415         File dotfile= new File("graph"+cd.getSymbol()+".dot");
 416
 417         FileWriter dotwriter=new FileWriter(dotfile,true);
 418
 419         dotwriter.write("digraph G{ \n");
 420         dotwriter.write("center=true;\norientation=landscape;\n");
 421
 422         Enumeration e=((Hashtable)Adj_List.get(cd)).keys();
 423         while(e.hasMoreElements()) {
 424             FlagState fsv = (FlagState)(e.nextElement());
 425             System.out.println(fsv.toString());
 426             Hashtable test=(Hashtable)Adj_List.get(cd);
 427             Vector edges=(Vector)test.get(fsv);
 428             for(int i=0;i < edges.size();i++) {
 429                 dotwriter.write(fsv.toString((FlagDescriptor [])flags.get(cd))+" -> "+((Edge)edges.get(i)).getState().toString((FlagDescriptor [])flags.get(cd))+"[label=\""+((Edge)edges.get(i)).getName()+"\"];\n");
 430             }
 431
 432         }
 433         dotwriter.write("}\n");
 434         dotwriter.flush();
 435         dotwriter.close();
 436     }
 437
 438     private String getTaskName(TaskDescriptor td) {
 439         StringTokenizer st = new StringTokenizer(td.toString(),"(");
 440         return st.nextToken();
 441     }
 442
 443     private boolean edgeexists(Hashtable Adj_List_local,FlagState v1, FlagState v2,String name) {
 444         Vector edges=(Vector)Adj_List_local.get(v1);
 445
 446         if (edges == null) {
 447             System.out.println("no edges");
 448         } else {
 449             for(int i=0;i < edges.size();i++) {
 450                 FlagState fs=((Edge)edges.get(i)).getState();
 451                 if (fs.isEqual(v2) && (name.compareTo(((Edge)edges.get(i)).getName())==0))
 452                     return true;
 453             }
 454         }
 455         return false;
 456     }
 457
 458     private void processExterns(boolean onlyExterns,ClassDescriptor cd) throws java.io.IOException {
 459         int noOfIterations;
 460         Hashtable Adj_List_temp;
 461         if (Adj_List.containsKey(cd)) {
 462             Adj_List_temp=(Hashtable)Adj_List.get(cd);
 463         } else {
 464             Adj_List_temp=new Hashtable();
 465             Adj_List.put(cd,Adj_List_temp);
 466         }
 467
 468
 469         if (onlyExterns) {
 470             FlagDescriptor [] fd=(FlagDescriptor [])flags.get(cd);
 471             System.out.println("onlyExterns"+fd.length);
 472             noOfIterations=1<<fd.length;
 473             boolean BoolValTable[]=new boolean[fd.length];
 474
 475             for(int i=0; i < fd.length ; i++) {
 476                 System.out.println(fd[i].getSymbol());
 477                 BoolValTable[i]=false;
 478             }
 479             Adj_List_temp.put(new FlagState(fd,cd),new Vector());
 480
 481             for(int k=1; k<noOfIterations; k++) {
 482                 for(int j=0; j< fd.length ;j++) {
 483                     if ((k% (1<<j)) == 0)
 484                         BoolValTable[j]=(!BoolValTable[j]);
 485                 }
 486
 487                 FlagState fstemp=new FlagState(fd,cd);
 488                 int i=0;
 489                 for(Enumeration e=fstemp.getStateTable().keys(); e.hasMoreElements() && i < fd.length;i++) {
 490                     fstemp.put((FlagDescriptor)e.nextElement(),new Boolean(BoolValTable[i]));
 491                 }
 492                 Adj_List_temp.put(fstemp,new Vector());
 493             }
 494
 495             Enumeration e=Adj_List_temp.keys();
 496             while(e.hasMoreElements()) {
 497                 FlagState fstemp=(FlagState)e.nextElement();
 498                 Enumeration en=Adj_List_temp.keys();
 499                 while (en.hasMoreElements()) {
 500                     FlagState fs=(FlagState)en.nextElement();
 501                     if(fstemp == fs) {
 502                         continue;
 503                     } else {
 504                         ((Vector)Adj_List_temp.get(fstemp)).add(new Edge(fs,"Runtime"));
 505                     }
 506                 }
 507             }
 508         }
 509     }
 510
 511     private Queue createPossibleRuntimeStates(TriggerState ts) throws java.io.IOException {
 512         int noOfIterations, externs;
 513         Hashtable Adj_List_temp;
 514         boolean onlyExterns;
 515
 516         System.out.println("Inside CreatePossible runtime states");
 517
 518         ClassDescriptor cd = ts.getClassDescriptor();
 519         FlagState fs= ts.getState();
 520         if (Adj_List.containsKey(cd)) {
 521             Adj_List_temp=(Hashtable)Adj_List.get(cd);
 522         } else {
 523             Adj_List_temp=new Hashtable();
 524             Adj_List.put(cd,Adj_List_temp);
 525         }
 526
 527         externs=((Integer)extern_flags.get(cd)).intValue();
 528
 529         FlagDescriptor[] fd=(FlagDescriptor[])flags.get(cd);
 530
 531         onlyExterns= (fd.length==externs);
 532
 533         Queue  q_ret=new LinkedList();
 534
 535         if (onlyExterns) {
 536             noOfIterations=1<<fd.length;
 537             boolean BoolValTable[]=new boolean[fd.length];
 538
 539             for(int i=0; i < fd.length ; i++) {
 540                 System.out.println(fd[i].getSymbol());
 541                 BoolValTable[i]=false;
 542             }
 543
 544             if (! wasFlagStateProcessed(Adj_List_temp,fs)) {
 545                 TriggerState ts_local=new TriggerState(cd,fs);
 546                 if (!existsInQueue(ts_local)) {
 547                     q_ret.offer(ts_local);
 548                 }
 549                 Adj_List_temp.put(fs,new Vector());
 550             }
 551
 552             for(int k=1; k<noOfIterations; k++) {
 553                 for(int j=0; j< fd.length ;j++) {
 554                     if ((k% (1<<j))==0)
 555                         BoolValTable[j]=(!BoolValTable[j]);
 556                 }
 557
 558                 FlagState fstemp=new FlagState(fs.getStateTable(),cd);
 559                 int i=0;
 560                 for(Enumeration e=fstemp.getStateTable().keys(); e.hasMoreElements() && i < fd.length;i++) {
 561                     fstemp.put((FlagDescriptor)e.nextElement(),new Boolean(BoolValTable[i]));
 562                 }
 563
 564                 if (wasFlagStateProcessed(Adj_List_temp,fstemp)) {
 565                     continue;
 566                 } else {
 567                     TriggerState ts_local=new TriggerState(cd,fstemp);
 568                     if (!existsInQueue(ts_local)) {
 569                         q_ret.offer(ts_local);
 570                     }
 571
 572
 573                     Adj_List_temp.put(fstemp,new Vector());
 574                 }
 575
 576             }
 577
 578             Enumeration e=Adj_List_temp.keys();
 579             while(e.hasMoreElements()) {
 580                 FlagState fstemp=(FlagState)e.nextElement();
 581                 Enumeration en=Adj_List_temp.keys();
 582                 while (en.hasMoreElements()) {
 583                     FlagState fs_local=(FlagState)en.nextElement();
 584                     if(fstemp == fs_local)
 585                         continue;
 586                     else
 587                         ((Vector)Adj_List_temp.get(fstemp)).add(new Edge(fs_local,"Runtime"));
 588                 }
 589             }
 590
 591             return q_ret;
 592         } else {
 593             System.out.println("inside else part");
 594             noOfIterations=1<<externs;
 595             boolean BoolValTable[]=new boolean[externs];
 596             Hashtable Adj_List_local;
 597
 598
 599             Adj_List_local=new Hashtable();
 600
 601             for(int i=0; i < externs ; i++) {
 602                 System.out.println(fd[i].getSymbol());
 603                 BoolValTable[i]=fs.get(fd[i]);
 604             }
 605
 606             for(int k=1; k<noOfIterations; k++) {
 607                 for(int j=0; j< fd.length ;j++) {
 608                     if ((k% (1<<j))==0)
 609                         BoolValTable[j]=(!BoolValTable[j]);
 610                 }
 611
 612                 FlagState fstemp=new FlagState(fs.getStateTable(),cd);
 613                 FlagDescriptor fdtemp[]=(FlagDescriptor [])flags.get(cd);
 614
 615                 for(int i=0; i < externs;i++)
 616                     {
 617                         fstemp.put(fdtemp[i],new Boolean(BoolValTable[i]));
 618                     }
 619
 620                 q_ret.offer(new TriggerState(cd,fstemp));
 621             }
 622
 623             return q_ret;
 624
 625         }
 626     }
 627
 628     private Queue createPossibleRuntimeStates(ClassDescriptor cd,FlagState fs) throws java.io.IOException {
 629         int noOfIterations, externs;
 630         Hashtable Adj_List_temp;
 631         boolean onlyExterns;
 632
 633         System.out.println("Inside CreatePossible runtime states(flagstates)");
 634
 635         if (Adj_List.containsKey(cd))
 636             Adj_List_temp=(Hashtable)Adj_List.get(cd);
 637         else {
 638             Adj_List_temp=new Hashtable();
 639             Adj_List.put(cd,Adj_List_temp);
 640         }
 641
 642         externs=((Integer)extern_flags.get(cd)).intValue();
 643
 644         FlagDescriptor[] fd=(FlagDescriptor[])flags.get(cd);
 645
 646         onlyExterns=fd.length==externs;
 647
 648         Queue  q_ret;
 649
 650         q_ret=new LinkedList();
 651
 652         if (onlyExterns) {
 653             noOfIterations=1<<fd.length;
 654             boolean BoolValTable[]=new boolean[fd.length];
 655
 656             for(int i=0; i < fd.length ; i++) {
 657                 System.out.println(fd[i].getSymbol());
 658                 BoolValTable[i]=false;
 659             }
 660
 661             return q_ret;
 662         } else {
 663             System.out.println("inside else part(fs)");
 664             noOfIterations=1<<externs;
 665             boolean BoolValTable[]=new boolean[externs];
 666             Hashtable Adj_List_local;
 667
 668
 669             Adj_List_local=new Hashtable();
 670
 671             for(int i=0; i < externs ; i++) {
 672                 System.out.println(fd[i].getSymbol());
 673                 BoolValTable[i]=fs.get(fd[i]);
 674             }
 675
 676             if (! wasFlagStateProcessed(Adj_List_temp,fs)) {
 677                 Adj_List_temp.put(fs,new Vector());
 678             }
 679             for(int k=1; k<noOfIterations; k++) {
 680                 for(int j=0; j< fd.length ;j++) {
 681                     if ((k% (1<<j))==0)
 682                         BoolValTable[j]=(!BoolValTable[j]);
 683                 }
 684
 685                 FlagState fstemp=new FlagState(fs.getStateTable(),cd);
 686                 FlagDescriptor fdtemp[]=(FlagDescriptor [])flags.get(cd);
 687
 688                 for(int i=0; i < externs;i++) {
 689                     fstemp.put(fdtemp[i],new Boolean(BoolValTable[i]));
 690                 }
 691
 692                 q_ret.offer(fstemp);
 693                 ((Vector)(Adj_List_temp.get(fs))).add(new Edge(fstemp,"Runtime"));
 694
 695             }
 696             return q_ret;
 697
 698         }
 699     }
 700
 701
 702     private void processTasksWithPost(ClassDescriptor cd, Hashtable pre) {
 703     }
 704
 705     private ClassDescriptor processFlatNew(FlatNode fn) {
 706         if (! (fn.getNext(0).kind() == 13)) {
 707             return (((FlatNew)fn).getType().getClassDesc());
 708         }
 709         return null;
 710     }
 711
 712 }