Robust/src/IR/Flat/BuildCode.java

   1 package IR.Flat;
   2 import IR.Tree.FlagExpressionNode;
   3 import IR.Tree.DNFFlag;
   4 import IR.Tree.DNFFlagAtom;
   5 import IR.Tree.TagExpressionList;
   6 import IR.*;
   7 import java.util.*;
   8 import java.io.*;
   9 import Util.Relation;
  10 import Analysis.TaskStateAnalysis.FlagState;
  11 import Analysis.TaskStateAnalysis.MyOptional;
  12
  13 public class BuildCode {
  14     State state;
  15     Hashtable temptovar;
  16     Hashtable paramstable;
  17     Hashtable tempstable;
  18     Hashtable fieldorder;
  19     Hashtable flagorder;
  20     int tag=0;
  21     String localsprefix="___locals___";
  22     String paramsprefix="___params___";
  23     public static boolean GENERATEPRECISEGC=false;
  24     public static String PREFIX="";
  25     public static String arraytype="ArrayObject";
  26     Virtual virtualcalls;
  27     TypeUtil typeutil;
  28     private int maxtaskparams=0;
  29     ClassDescriptor[] cdarray;
  30     TypeDescriptor[] arraytable;
  31
  32     public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil) {
  33         state=st;
  34         this.temptovar=temptovar;
  35         paramstable=new Hashtable();
  36         tempstable=new Hashtable();
  37         fieldorder=new Hashtable();
  38         flagorder=new Hashtable();
  39         this.typeutil=typeutil;
  40         virtualcalls=new Virtual(state);
  41     }
  42
  43     /** The buildCode method outputs C code for all the methods.  The Flat
  44      * versions of the methods must already be generated and stored in
  45      * the State object. */
  46
  47     public void buildCode() {
  48         /* Create output streams to write to */
  49         PrintWriter outclassdefs=null;
  50         PrintWriter outstructs=null;
  51         PrintWriter outrepairstructs=null;
  52         PrintWriter outmethodheader=null;
  53         PrintWriter outmethod=null;
  54         PrintWriter outvirtual=null;
  55         PrintWriter outtask=null;
  56         PrintWriter outtaskdefs=null;
  57         PrintWriter outoptionalarrays=null;
  58
  59         try {
  60             OutputStream str=new FileOutputStream(PREFIX+"structdefs.h");
  61             outstructs=new java.io.PrintWriter(str, true);
  62             str=new FileOutputStream(PREFIX+"methodheaders.h");
  63             outmethodheader=new java.io.PrintWriter(str, true);
  64             str=new FileOutputStream(PREFIX+"classdefs.h");
  65             outclassdefs=new java.io.PrintWriter(str, true);
  66             str=new FileOutputStream(PREFIX+"methods.c");
  67             outmethod=new java.io.PrintWriter(str, true);
  68             str=new FileOutputStream(PREFIX+"virtualtable.h");
  69             outvirtual=new java.io.PrintWriter(str, true);
  70             if (state.TASK) {
  71                 str=new FileOutputStream(PREFIX+"task.h");
  72                 outtask=new java.io.PrintWriter(str, true);
  73                 str=new FileOutputStream(PREFIX+"taskdefs.c");
  74                 outtaskdefs=new java.io.PrintWriter(str, true);
  75                 if (state.OPTIONAL){
  76                     str=new FileOutputStream(PREFIX+"optionnalarrays.c");
  77                     outoptionalarrays=new java.io.PrintWriter(str, true);
  78                 }
  79             }
  80             if (state.structfile!=null) {
  81                 str=new FileOutputStream(PREFIX+state.structfile+".struct");
  82                 outrepairstructs=new java.io.PrintWriter(str, true);
  83             }
  84         } catch (Exception e) {
  85             e.printStackTrace();
  86             System.exit(-1);
  87         }
  88
  89         /* Build the virtual dispatch tables */
  90         buildVirtualTables(outvirtual);
  91
  92
  93         /* Output includes */
  94
  95         outmethodheader.println("#ifndef METHODHEADERS_H");
  96         outmethodheader.println("#define METHODHEADERS_H");
  97         outmethodheader.println("#include \"structdefs.h\"");
  98
  99         outstructs.println("#ifndef STRUCTDEFS_H");
 100         outstructs.println("#define STRUCTDEFS_H");
 101         outstructs.println("#include \"classdefs.h\"");
 102
 103
 104
 105         /* Output types for short array and string */
 106         outstructs.println("#define STRINGARRAYTYPE "+
 107                            (state.getArrayNumber(
 108                                                  (new TypeDescriptor(typeutil.getClass(TypeUtil.StringClass))).makeArray(state))+state.numClasses()));
 109
 110         outstructs.println("#define OBJECTARRAYTYPE "+
 111                            (state.getArrayNumber(
 112                                                  (new TypeDescriptor(typeutil.getClass(TypeUtil.ObjectClass))).makeArray(state))+state.numClasses()));
 113
 114
 115         outstructs.println("#define STRINGTYPE "+typeutil.getClass(TypeUtil.StringClass).getId());
 116         outstructs.println("#define CHARARRAYTYPE "+
 117                            (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.CHAR)).makeArray(state))+state.numClasses()));
 118
 119         outstructs.println("#define BYTEARRAYTYPE "+
 120                            (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.BYTE)).makeArray(state))+state.numClasses()));
 121
 122         outstructs.println("#define BYTEARRAYARRAYTYPE "+
 123                            (state.getArrayNumber((new TypeDescriptor(TypeDescriptor.BYTE)).makeArray(state).makeArray(state))+state.numClasses()));
 124
 125         outstructs.println("#define NUMCLASSES "+state.numClasses());
 126         if (state.TASK) {
 127             outstructs.println("#define STARTUPTYPE "+typeutil.getClass(TypeUtil.StartupClass).getId());
 128             outstructs.println("#define TAGTYPE "+typeutil.getClass(TypeUtil.TagClass).getId());
 129             outstructs.println("#define TAGARRAYTYPE "+
 130                                (state.getArrayNumber(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass)).makeArray(state))+state.numClasses()));
 131         }
 132
 133         // Output the C class declarations
 134         // These could mutually reference each other
 135         if (state.THREAD)
 136             outclassdefs.println("#include <pthread.h>");
 137
 138         outclassdefs.println("struct "+arraytype+";");
 139
 140         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 141         while(it.hasNext()) {
 142             ClassDescriptor cn=(ClassDescriptor)it.next();
 143             outclassdefs.println("struct "+cn.getSafeSymbol()+";");
 144         }
 145         outclassdefs.println("");
 146         {
 147             //Print out definition for array type
 148             outclassdefs.println("struct "+arraytype+" {");
 149             outclassdefs.println("  int type;");
 150             if (state.THREAD) {
 151                 outclassdefs.println("  pthread_t tid;");
 152                 outclassdefs.println("  void * lockentry;");
 153                 outclassdefs.println("  int lockcount;");
 154             }
 155
 156             if (state.TASK) {
 157                 outclassdefs.println("  int flag;");
 158                 outclassdefs.println("  void * flagptr;");
 159                 outclassdefs.println("  int failedstatus;");
 160                 outclassdefs.println("  int * flagset;");
 161             }
 162             printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs);
 163             outclassdefs.println("  int ___length___;");
 164             outclassdefs.println("};\n");
 165
 166             if (state.TASK) {
 167             //Print out definitions for task types
 168                 outtask.println("struct parameterdescriptor {");
 169                 outtask.println("int type;");
 170                 outtask.println("int numberterms;");
 171                 outtask.println("int *intarray;");
 172                 outtask.println("void * queue;");
 173                 outtask.println("int numbertags;");
 174                 outtask.println("int *tagarray;");
 175                 outtask.println("};");
 176
 177                 outtask.println("struct taskdescriptor {");
 178                 outtask.println("void * taskptr;");
 179                 outtask.println("int numParameters;");
 180                 outtask.println("int numTotal;");
 181                 outtask.println("struct parameterdescriptor **descriptorarray;");
 182                 outtask.println("char * name;");
 183                 outtask.println("};");
 184                 outtask.println("extern struct taskdescriptor * taskarray[];");
 185                 outtask.println("extern numtasks;");
 186             }
 187         }
 188
 189         // Output function prototypes and structures for parameters
 190         it=state.getClassSymbolTable().getDescriptorsIterator();
 191         while(it.hasNext()) {
 192             ClassDescriptor cn=(ClassDescriptor)it.next();
 193             generateCallStructs(cn, outclassdefs, outstructs, outmethodheader);
 194         }
 195
 196         if (state.TASK) {
 197             /* Map flags to integers */
 198             it=state.getClassSymbolTable().getDescriptorsIterator();
 199             while(it.hasNext()) {
 200                 ClassDescriptor cn=(ClassDescriptor)it.next();
 201                 mapFlags(cn);
 202             }
 203             /* Generate Tasks */
 204             generateTaskStructs(outstructs, outmethodheader);
 205         }
 206
 207         outmethodheader.println("#endif");
 208
 209         outmethodheader.close();
 210
 211         /* Build the actual methods */
 212         outmethod.println("#include \"methodheaders.h\"");
 213         outmethod.println("#include \"virtualtable.h\"");
 214         outmethod.println("#include <runtime.h>");
 215         if (state.THREAD)
 216             outmethod.println("#include <thread.h>");
 217         if (state.main!=null) {
 218             outmethod.println("#include <string.h>");
 219         }
 220
 221         if (state.CONSCHECK) {
 222             outmethod.println("#include \"checkers.h\"");
 223         }
 224         outclassdefs.println("extern int classsize[];");
 225         outclassdefs.println("extern int hasflags[];");
 226         outclassdefs.println("extern int * pointerarray[];");
 227         outclassdefs.println("extern int supertypes[];");
 228
 229         //Store the sizes of classes & array elements
 230         generateSizeArray(outmethod);
 231
 232         //Store table of supertypes
 233         generateSuperTypeTable(outmethod);
 234
 235         //Store the layout of classes
 236         generateLayoutStructs(outmethod);
 237
 238         /* Generate code for methods */
 239         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 240         while(classit.hasNext()) {
 241             ClassDescriptor cn=(ClassDescriptor)classit.next();
 242             Iterator methodit=cn.getMethods();
 243             while(methodit.hasNext()) {
 244                 /* Classify parameters */
 245                 MethodDescriptor md=(MethodDescriptor)methodit.next();
 246                 FlatMethod fm=state.getMethodFlat(md);
 247                 if (!md.getModifiers().isNative())
 248                     generateFlatMethod(fm,outmethod);
 249             }
 250         }
 251
 252         if (state.TASK) {
 253             /* Compile task based program */
 254             outtaskdefs.println("#include \"task.h\"");
 255             outtaskdefs.println("#include \"methodheaders.h\"");
 256             Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 257             while(taskit.hasNext()) {
 258                 TaskDescriptor td=(TaskDescriptor)taskit.next();
 259                 FlatMethod fm=state.getMethodFlat(td);
 260                 generateFlatMethod(fm, outmethod);
 261                 generateTaskDescriptor(outtaskdefs, fm, td);
 262             }
 263
 264             {
 265                 //Output task descriptors
 266                 taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 267                 outtaskdefs.println("struct taskdescriptor * taskarray[]= {");
 268                 boolean first=true;
 269                 while(taskit.hasNext()) {
 270                     TaskDescriptor td=(TaskDescriptor)taskit.next();
 271                     if (first)
 272                         first=false;
 273                     else
 274                         outtaskdefs.println(",");
 275                     outtaskdefs.print("&task_"+td.getSafeSymbol());
 276                 }
 277                 outtaskdefs.println("};");
 278             }
 279
 280             outtaskdefs.println("int numtasks="+state.getTaskSymbolTable().getValueSet().size()+";");
 281
 282         } else if (state.main!=null) {
 283             /* Generate main method */
 284             outmethod.println("int main(int argc, const char *argv[]) {");
 285             outmethod.println("  int i;");
 286             if (GENERATEPRECISEGC) {
 287                 outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);");
 288             } else {
 289                 outmethod.println("  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);");
 290             }
 291             if (state.THREAD) {
 292                 outmethod.println("initializethreads();");
 293             }
 294             outmethod.println("  for(i=1;i<argc;i++) {");
 295             outmethod.println("    int length=strlen(argv[i]);");
 296             if (GENERATEPRECISEGC) {
 297                 outmethod.println("    struct ___String___ *newstring=NewString(NULL, argv[i], length);");
 298             } else {
 299                 outmethod.println("    struct ___String___ *newstring=NewString(argv[i], length);");
 300             }
 301             outmethod.println("    ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;");
 302             outmethod.println("  }");
 303
 304
 305             MethodDescriptor md=typeutil.getMain();
 306             ClassDescriptor cd=typeutil.getMainClass();
 307
 308             outmethod.println("   {");
 309             if (GENERATEPRECISEGC) {
 310                 outmethod.print("       struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
 311                 outmethod.println("1, NULL,"+"stringarray};");
 312                 outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
 313             } else
 314                 outmethod.println("     "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
 315             outmethod.println("   }");
 316
 317             if (state.THREAD) {
 318                 outmethod.println("pthread_mutex_lock(&gclistlock);");
 319                 outmethod.println("threadcount--;");
 320                 outmethod.println("pthread_cond_signal(&gccond);");
 321                 outmethod.println("pthread_mutex_unlock(&gclistlock);");
 322                 outmethod.println("pthread_exit(NULL);");
 323             }
 324             outmethod.println("}");
 325         }
 326         if (state.TASK)
 327             outstructs.println("#define MAXTASKPARAMS "+maxtaskparams);
 328
 329         if (state.TASK&&state.OPTIONAL){
 330             generateOptionalArrays(outoptionalarrays, state.getAnalysisResult(), state.getMyOptionals());
 331             outoptionalarrays.close();
 332         }
 333
 334
 335         /* Output structure definitions for repair tool */
 336         if (state.structfile!=null) {
 337             buildRepairStructs(outrepairstructs);
 338             outrepairstructs.close();
 339         }
 340         outstructs.println("#endif");
 341
 342         outstructs.close();
 343         outmethod.close();
 344
 345
 346     }
 347
 348     private int maxcount=0;
 349
 350     private void buildRepairStructs(PrintWriter outrepairstructs) {
 351         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 352         while(classit.hasNext()) {
 353             ClassDescriptor cn=(ClassDescriptor)classit.next();
 354             outrepairstructs.println("structure "+cn.getSymbol()+" {");
 355             outrepairstructs.println("  int __type__;");
 356             if (state.TASK) {
 357                 outrepairstructs.println("  int __flag__;");
 358                 outrepairstructs.println("  int __flagptr__;");
 359             }
 360             printRepairStruct(cn, outrepairstructs);
 361             outrepairstructs.println("}\n");
 362         }
 363
 364         for(int i=0;i<state.numArrays();i++) {
 365             TypeDescriptor tdarray=arraytable[i];
 366             TypeDescriptor tdelement=tdarray.dereference();
 367             outrepairstructs.println("structure "+arraytype+"_"+state.getArrayNumber(tdarray)+" {");
 368             outrepairstructs.println("  int __type__;");
 369             printRepairStruct(typeutil.getClass(TypeUtil.ObjectClass), outrepairstructs);
 370             outrepairstructs.println("  int length;");
 371             /*
 372               // Need to add support to repair tool for this
 373               if (tdelement.isClass()||tdelement.isArray())
 374                 outrepairstructs.println("  "+tdelement.getRepairSymbol()+" * elem[this.length];");
 375             else
 376                 outrepairstructs.println("  "+tdelement.getRepairSymbol()+" elem[this.length];");
 377             */
 378             outrepairstructs.println("}\n");
 379         }
 380
 381     }
 382
 383     private void printRepairStruct(ClassDescriptor cn, PrintWriter output) {
 384         ClassDescriptor sp=cn.getSuperDesc();
 385         if (sp!=null)
 386             printRepairStruct(sp, output);
 387
 388         Vector fields=(Vector)fieldorder.get(cn);
 389
 390         for(int i=0;i<fields.size();i++) {
 391             FieldDescriptor fd=(FieldDescriptor)fields.get(i);
 392             if (fd.getType().isArray()) {
 393                 output.println("  "+arraytype+"_"+ state.getArrayNumber(fd.getType()) +" * "+fd.getSymbol()+";");
 394             } else if (fd.getType().isClass())
 395                 output.println("  "+fd.getType().getRepairSymbol()+" * "+fd.getSymbol()+";");
 396             else if (fd.getType().isFloat())
 397                 output.println("  int "+fd.getSymbol()+"; /* really float */");
 398             else
 399                 output.println("  "+fd.getType().getRepairSymbol()+" "+fd.getSymbol()+";");
 400         }
 401     }
 402
 403     /** This method outputs TaskDescriptor information */
 404     void generateTaskDescriptor(PrintWriter output, FlatMethod fm, TaskDescriptor task) {
 405         for (int i=0;i<task.numParameters();i++) {
 406             VarDescriptor param_var=task.getParameter(i);
 407             TypeDescriptor param_type=task.getParamType(i);
 408             FlagExpressionNode param_flag=task.getFlag(param_var);
 409             TagExpressionList param_tag=task.getTag(param_var);
 410
 411             int dnfterms;
 412             if (param_flag==null) {
 413                 output.println("int parameterdnf_"+i+"_"+task.getSafeSymbol()+"[]={");
 414                 output.println("0x0, 0x0 };");
 415                 dnfterms=1;
 416             } else {
 417
 418                 DNFFlag dflag=param_flag.getDNF();
 419                 dnfterms=dflag.size();
 420
 421                 Hashtable flags=(Hashtable)flagorder.get(param_type.getClassDesc());
 422                 output.println("int parameterdnf_"+i+"_"+task.getSafeSymbol()+"[]={");
 423                 for(int j=0;j<dflag.size();j++) {
 424                     if (j!=0)
 425                         output.println(",");
 426                     Vector term=dflag.get(j);
 427                     int andmask=0;
 428                     int checkmask=0;
 429                     for(int k=0;k<term.size();k++) {
 430                         DNFFlagAtom dfa=(DNFFlagAtom)term.get(k);
 431                         FlagDescriptor fd=dfa.getFlag();
 432                         boolean negated=dfa.getNegated();
 433                         int flagid=1<<((Integer)flags.get(fd)).intValue();
 434                         andmask|=flagid;
 435                         if (!negated)
 436                             checkmask|=flagid;
 437                     }
 438                     output.print("0x"+Integer.toHexString(andmask)+", 0x"+Integer.toHexString(checkmask));
 439                 }
 440                 output.println("};");
 441             }
 442
 443             output.println("int parametertag_"+i+"_"+task.getSafeSymbol()+"[]={");
 444             //BUG...added next line to fix, test with any task program
 445             if (param_tag!=null)
 446                 for(int j=0;j<param_tag.numTags();j++) {
 447                     if (j!=0)
 448                         output.println(",");
 449                     /* for each tag we need */
 450                     /* which slot it is */
 451                     /* what type it is */
 452                     TagVarDescriptor tvd=(TagVarDescriptor)task.getParameterTable().get(param_tag.getName(j));
 453                     TempDescriptor tmp=param_tag.getTemp(j);
 454                     int slot=fm.getTagInt(tmp);
 455                     output.println(slot+", "+state.getTagId(tvd.getTag()));
 456                 }
 457             output.println("};");
 458
 459             output.println("struct parameterdescriptor parameter_"+i+"_"+task.getSafeSymbol()+"={");
 460             output.println("/* type */"+param_type.getClassDesc().getId()+",");
 461             output.println("/* number of DNF terms */"+dnfterms+",");
 462             output.println("parameterdnf_"+i+"_"+task.getSafeSymbol()+",");
 463             output.println("0,");
 464             //BUG, added next line to fix and else statement...test
 465             //with any task program
 466             if (param_tag!=null)
 467                 output.println("/* number of tags */"+param_tag.numTags()+",");
 468             else
 469                 output.println("/* number of tags */ 0,");
 470             output.println("parametertag_"+i+"_"+task.getSafeSymbol());
 471             output.println("};");
 472         }
 473
 474
 475         output.println("struct parameterdescriptor * parameterdescriptors_"+task.getSafeSymbol()+"[] = {");
 476         for (int i=0;i<task.numParameters();i++) {
 477             if (i!=0)
 478                 output.println(",");
 479             output.print("&parameter_"+i+"_"+task.getSafeSymbol());
 480         }
 481         output.println("};");
 482
 483         output.println("struct taskdescriptor task_"+task.getSafeSymbol()+"={");
 484         output.println("&"+task.getSafeSymbol()+",");
 485         output.println("/* number of parameters */" +task.numParameters() + ",");
 486         int numtotal=task.numParameters()+fm.numTags();
 487         output.println("/* number total parameters */" +numtotal + ",");
 488         output.println("parameterdescriptors_"+task.getSafeSymbol()+",");
 489         output.println("\""+task.getSymbol()+"\"");
 490         output.println("};");
 491     }
 492
 493
 494     /** The buildVirtualTables method outputs the virtual dispatch
 495      * tables for methods. */
 496
 497     private void buildVirtualTables(PrintWriter outvirtual) {
 498         Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
 499         while(classit.hasNext()) {
 500             ClassDescriptor cd=(ClassDescriptor)classit.next();
 501             if (virtualcalls.getMethodCount(cd)>maxcount)
 502                 maxcount=virtualcalls.getMethodCount(cd);
 503         }
 504         MethodDescriptor[][] virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
 505
 506         /* Fill in virtual table */
 507         classit=state.getClassSymbolTable().getDescriptorsIterator();
 508         while(classit.hasNext()) {
 509             ClassDescriptor cd=(ClassDescriptor)classit.next();
 510             fillinRow(cd, virtualtable, cd.getId());
 511         }
 512
 513         ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass);
 514         Iterator arrayit=state.getArrayIterator();
 515         while(arrayit.hasNext()) {
 516             TypeDescriptor td=(TypeDescriptor)arrayit.next();
 517             int id=state.getArrayNumber(td);
 518             fillinRow(objectcd, virtualtable, id+state.numClasses());
 519         }
 520
 521         outvirtual.print("void * virtualtable[]={");
 522         boolean needcomma=false;
 523         for(int i=0;i<state.numClasses()+state.numArrays();i++) {
 524             for(int j=0;j<maxcount;j++) {
 525                 if (needcomma)
 526                     outvirtual.print(", ");
 527                 if (virtualtable[i][j]!=null) {
 528                     MethodDescriptor md=virtualtable[i][j];
 529                     outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
 530                 } else {
 531                     outvirtual.print("0");
 532                 }
 533                 needcomma=true;
 534             }
 535             outvirtual.println("");
 536         }
 537         outvirtual.println("};");
 538         outvirtual.close();
 539     }
 540
 541     private void fillinRow(ClassDescriptor cd, MethodDescriptor[][] virtualtable, int rownum) {
 542         /* Get inherited methods */
 543         if (cd.getSuperDesc()!=null)
 544             fillinRow(cd.getSuperDesc(), virtualtable, rownum);
 545         /* Override them with our methods */
 546         for(Iterator it=cd.getMethods();it.hasNext();) {
 547             MethodDescriptor md=(MethodDescriptor)it.next();
 548             if (md.isStatic()||md.getReturnType()==null)
 549                 continue;
 550             int methodnum=virtualcalls.getMethodNumber(md);
 551             virtualtable[rownum][methodnum]=md;
 552         }
 553     }
 554
 555     /** Generate array that contains the sizes of class objects.  The
 556      * object allocation functions in the runtime use this
 557      * information. */
 558
 559     private void generateSizeArray(PrintWriter outclassdefs) {
 560         outclassdefs.print("int classsize[]={");
 561         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 562         cdarray=new ClassDescriptor[state.numClasses()];
 563         while(it.hasNext()) {
 564             ClassDescriptor cd=(ClassDescriptor)it.next();
 565             cdarray[cd.getId()]=cd;
 566         }
 567         boolean needcomma=false;
 568         for(int i=0;i<state.numClasses();i++) {
 569             if (needcomma)
 570                 outclassdefs.print(", ");
 571             outclassdefs.print("sizeof(struct "+cdarray[i].getSafeSymbol()+")");
 572             needcomma=true;
 573         }
 574
 575         arraytable=new TypeDescriptor[state.numArrays()];
 576
 577         Iterator arrayit=state.getArrayIterator();
 578         while(arrayit.hasNext()) {
 579             TypeDescriptor td=(TypeDescriptor)arrayit.next();
 580             int id=state.getArrayNumber(td);
 581             arraytable[id]=td;
 582         }
 583
 584         for(int i=0;i<state.numArrays();i++) {
 585             if (needcomma)
 586                 outclassdefs.print(", ");
 587             TypeDescriptor tdelement=arraytable[i].dereference();
 588             if (tdelement.isArray()||tdelement.isClass())
 589                 outclassdefs.print("sizeof(void *)");
 590             else
 591                 outclassdefs.print("sizeof("+tdelement.getSafeSymbol()+")");
 592             needcomma=true;
 593         }
 594
 595         outclassdefs.println("};");
 596     }
 597
 598     /** Constructs params and temp objects for each method or task.
 599      * These objects tell the compiler which temps need to be
 600      * allocated.  */
 601
 602     private void generateTempStructs(FlatMethod fm) {
 603         MethodDescriptor md=fm.getMethod();
 604         TaskDescriptor task=fm.getTask();
 605
 606         ParamsObject objectparams=md!=null?new ParamsObject(md,tag++):new ParamsObject(task, tag++);
 607         if (md!=null)
 608             paramstable.put(md, objectparams);
 609         else
 610             paramstable.put(task, objectparams);
 611
 612         for(int i=0;i<fm.numParameters();i++) {
 613             TempDescriptor temp=fm.getParameter(i);
 614             TypeDescriptor type=temp.getType();
 615             if ((type.isPtr()||type.isArray())&&GENERATEPRECISEGC)
 616                 objectparams.addPtr(temp);
 617             else
 618                 objectparams.addPrim(temp);
 619         }
 620
 621         for(int i=0;i<fm.numTags();i++) {
 622             TempDescriptor temp=fm.getTag(i);
 623             if (GENERATEPRECISEGC)
 624                 objectparams.addPtr(temp);
 625             else
 626                 objectparams.addPrim(temp);
 627         }
 628
 629         TempObject objecttemps=md!=null?new TempObject(objectparams,md,tag++):new TempObject(objectparams, task, tag++);
 630         if (md!=null)
 631             tempstable.put(md, objecttemps);
 632         else
 633             tempstable.put(task, objecttemps);
 634
 635         for(Iterator nodeit=fm.getNodeSet().iterator();nodeit.hasNext();) {
 636             FlatNode fn=(FlatNode)nodeit.next();
 637             TempDescriptor[] writes=fn.writesTemps();
 638             for(int i=0;i<writes.length;i++) {
 639                 TempDescriptor temp=writes[i];
 640                 TypeDescriptor type=temp.getType();
 641                 if ((type.isPtr()||type.isArray())&&GENERATEPRECISEGC)
 642                     objecttemps.addPtr(temp);
 643                 else
 644                     objecttemps.addPrim(temp);
 645             }
 646         }
 647     }
 648
 649     private void generateLayoutStructs(PrintWriter output) {
 650         Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
 651         while(it.hasNext()) {
 652             ClassDescriptor cn=(ClassDescriptor)it.next();
 653             output.println("int "+cn.getSafeSymbol()+"_pointers[]={");
 654             Iterator allit=cn.getFieldTable().getAllDescriptorsIterator();
 655             int count=0;
 656             while(allit.hasNext()) {
 657                 FieldDescriptor fd=(FieldDescriptor)allit.next();
 658                 TypeDescriptor type=fd.getType();
 659                 if (type.isPtr()||type.isArray())
 660                     count++;
 661             }
 662             output.print(count);
 663             allit=cn.getFieldTable().getAllDescriptorsIterator();
 664             while(allit.hasNext()) {
 665                 FieldDescriptor fd=(FieldDescriptor)allit.next();
 666                 TypeDescriptor type=fd.getType();
 667                 if (type.isPtr()||type.isArray()) {
 668                     output.println(",");
 669                     output.print("((int)&(((struct "+cn.getSafeSymbol() +" *)0)->"+fd.getSafeSymbol()+"))");
 670                 }
 671             }
 672             output.println("};");
 673         }
 674         output.println("int * pointerarray[]={");
 675         boolean needcomma=false;
 676         for(int i=0;i<state.numClasses();i++) {
 677             ClassDescriptor cn=cdarray[i];
 678             if (needcomma)
 679                 output.println(",");
 680             needcomma=true;
 681             output.print(cn.getSafeSymbol()+"_pointers");
 682         }
 683
 684         for(int i=0;i<state.numArrays();i++) {
 685             if (needcomma)
 686                 output.println(", ");
 687             TypeDescriptor tdelement=arraytable[i].dereference();
 688             if (tdelement.isArray()||tdelement.isClass())
 689                 output.print("((int *)1)");
 690             else
 691                 output.print("0");
 692             needcomma=true;
 693         }
 694
 695         output.println("};");
 696         needcomma=false;
 697         output.println("int hasflags[]={");
 698         for(int i=0;i<state.numClasses();i++) {
 699             ClassDescriptor cn=cdarray[i];
 700             if (needcomma)
 701                 output.println(", ");
 702             needcomma=true;
 703             if (cn.hasFlags())
 704                 output.print("1");
 705             else
 706                 output.print("0");
 707         }
 708         output.println("};");
 709     }
 710
 711     /** Print out table to give us supertypes */
 712     private void generateSuperTypeTable(PrintWriter output) {
 713         output.println("int supertypes[]={");
 714         boolean needcomma=false;
 715         for(int i=0;i<state.numClasses();i++) {
 716             ClassDescriptor cn=cdarray[i];
 717             if (needcomma)
 718                 output.println(",");
 719             needcomma=true;
 720             if (cn.getSuperDesc()!=null) {
 721                 ClassDescriptor cdsuper=cn.getSuperDesc();
 722                 output.print(cdsuper.getId());
 723             } else
 724                 output.print("-1");
 725         }
 726         output.println("};");
 727     }
 728
 729     /** Force consistent field ordering between inherited classes. */
 730
 731     private void printClassStruct(ClassDescriptor cn, PrintWriter classdefout) {
 732         ClassDescriptor sp=cn.getSuperDesc();
 733         if (sp!=null)
 734             printClassStruct(sp, classdefout);
 735
 736         if (!fieldorder.containsKey(cn)) {
 737             Vector fields=new Vector();
 738             fieldorder.put(cn,fields);
 739             Iterator fieldit=cn.getFields();
 740             while(fieldit.hasNext()) {
 741                 FieldDescriptor fd=(FieldDescriptor)fieldit.next();
 742                 if (sp==null||!sp.getFieldTable().contains(fd.getSymbol()))
 743                     fields.add(fd);
 744             }
 745         }
 746         Vector fields=(Vector)fieldorder.get(cn);
 747
 748         for(int i=0;i<fields.size();i++) {
 749             FieldDescriptor fd=(FieldDescriptor)fields.get(i);
 750             if (fd.getType().isClass()||fd.getType().isArray())
 751                 classdefout.println("  struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
 752             else
 753                 classdefout.println("  "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
 754         }
 755     }
 756
 757
 758     /* Map flags to integers consistently between inherited
 759      * classes. */
 760
 761     private void mapFlags(ClassDescriptor cn) {
 762         ClassDescriptor sp=cn.getSuperDesc();
 763         if (sp!=null)
 764             mapFlags(sp);
 765         int max=0;
 766         if (!flagorder.containsKey(cn)) {
 767             Hashtable flags=new Hashtable();
 768             flagorder.put(cn,flags);
 769             if (sp!=null) {
 770                 Hashtable superflags=(Hashtable)flagorder.get(sp);
 771                 Iterator superflagit=superflags.keySet().iterator();
 772                 while(superflagit.hasNext()) {
 773                     FlagDescriptor fd=(FlagDescriptor)superflagit.next();
 774                     Integer number=(Integer)superflags.get(fd);
 775                     flags.put(fd, number);
 776                     if ((number.intValue()+1)>max)
 777                         max=number.intValue()+1;
 778                 }
 779             }
 780
 781             Iterator flagit=cn.getFlags();
 782             while(flagit.hasNext()) {
 783                 FlagDescriptor fd=(FlagDescriptor)flagit.next();
 784                 if (sp==null||!sp.getFlagTable().contains(fd.getSymbol()))
 785                     flags.put(fd, new Integer(max++));
 786             }
 787         }
 788     }
 789
 790
 791     /** This function outputs (1) structures that parameters are
 792      * passed in (when PRECISE GC is enabled) and (2) function
 793      * prototypes for the methods */
 794
 795     private void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout) {
 796         /* Output class structure */
 797         classdefout.println("struct "+cn.getSafeSymbol()+" {");
 798         classdefout.println("  int type;");
 799         if (state.THREAD) {
 800             classdefout.println("  pthread_t tid;");
 801             classdefout.println("  void * lockentry;");
 802             classdefout.println("  int lockcount;");
 803         }
 804
 805         if (state.TASK) {
 806             classdefout.println("  int flag;");
 807             classdefout.println("  void * flagptr;");
 808             classdefout.println("  int failedstatus;");
 809             classdefout.println("  int * flagset;");
 810         }
 811         printClassStruct(cn, classdefout);
 812         classdefout.println("};\n");
 813
 814         /* Cycle through methods */
 815         Iterator methodit=cn.getMethods();
 816         while(methodit.hasNext()) {
 817             /* Classify parameters */
 818             MethodDescriptor md=(MethodDescriptor)methodit.next();
 819             FlatMethod fm=state.getMethodFlat(md);
 820             generateTempStructs(fm);
 821
 822             ParamsObject objectparams=(ParamsObject) paramstable.get(md);
 823             TempObject objecttemps=(TempObject) tempstable.get(md);
 824
 825             /* Output parameter structure */
 826             if (GENERATEPRECISEGC) {
 827                 output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
 828                 output.println("  int size;");
 829                 output.println("  void * next;");
 830                 for(int i=0;i<objectparams.numPointers();i++) {
 831                     TempDescriptor temp=objectparams.getPointer(i);
 832                     output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 833                 }
 834                 output.println("};\n");
 835             }
 836
 837             /* Output temp structure */
 838             if (GENERATEPRECISEGC) {
 839                 output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
 840                 output.println("  int size;");
 841                 output.println("  void * next;");
 842                 for(int i=0;i<objecttemps.numPointers();i++) {
 843                     TempDescriptor temp=objecttemps.getPointer(i);
 844                     if (temp.getType().isNull())
 845                         output.println("  void * "+temp.getSafeSymbol()+";");
 846                     else
 847                         output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 848                 }
 849                 output.println("};\n");
 850             }
 851
 852             /* Output method declaration */
 853             if (md.getReturnType()!=null) {
 854                 if (md.getReturnType().isClass()||md.getReturnType().isArray())
 855                     headersout.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
 856                 else
 857                     headersout.print(md.getReturnType().getSafeSymbol()+" ");
 858             } else
 859                 //catch the constructor case
 860                 headersout.print("void ");
 861             headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
 862
 863             boolean printcomma=false;
 864             if (GENERATEPRECISEGC) {
 865                 headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
 866                 printcomma=true;
 867             }
 868
 869             //output parameter list
 870             for(int i=0;i<objectparams.numPrimitives();i++) {
 871                 TempDescriptor temp=objectparams.getPrimitive(i);
 872                 if (printcomma)
 873                     headersout.print(", ");
 874                 printcomma=true;
 875                 if (temp.getType().isClass()||temp.getType().isArray())
 876                     headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
 877                 else
 878                     headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
 879             }
 880             headersout.println(");\n");
 881         }
 882     }
 883
 884
 885     /** This function outputs (1) structures that parameters are
 886      * passed in (when PRECISE GC is enabled) and (2) function
 887      * prototypes for the tasks */
 888
 889     private void generateTaskStructs(PrintWriter output, PrintWriter headersout) {
 890         /* Cycle through tasks */
 891         Iterator taskit=state.getTaskSymbolTable().getDescriptorsIterator();
 892
 893         while(taskit.hasNext()) {
 894             /* Classify parameters */
 895             TaskDescriptor task=(TaskDescriptor)taskit.next();
 896             FlatMethod fm=state.getMethodFlat(task);
 897             generateTempStructs(fm);
 898
 899             ParamsObject objectparams=(ParamsObject) paramstable.get(task);
 900             TempObject objecttemps=(TempObject) tempstable.get(task);
 901
 902             /* Output parameter structure */
 903             if (GENERATEPRECISEGC) {
 904                 output.println("struct "+task.getSafeSymbol()+"_params {");
 905
 906                 output.println("  int size;");
 907                 output.println("  void * next;");
 908                 for(int i=0;i<objectparams.numPointers();i++) {
 909                     TempDescriptor temp=objectparams.getPointer(i);
 910                     output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 911                 }
 912
 913                 output.println("};\n");
 914                 if ((objectparams.numPointers()+fm.numTags())>maxtaskparams) {
 915                     maxtaskparams=objectparams.numPointers()+fm.numTags();
 916                 }
 917             }
 918
 919             /* Output temp structure */
 920             if (GENERATEPRECISEGC) {
 921                 output.println("struct "+task.getSafeSymbol()+"_locals {");
 922                 output.println("  int size;");
 923                 output.println("  void * next;");
 924                 for(int i=0;i<objecttemps.numPointers();i++) {
 925                     TempDescriptor temp=objecttemps.getPointer(i);
 926                     if (temp.getType().isNull())
 927                         output.println("  void * "+temp.getSafeSymbol()+";");
 928                     else if(temp.getType().isTag())
 929                         output.println("  struct "+
 930                                        (new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 931                     else
 932                         output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
 933                 }
 934                 output.println("};\n");
 935             }
 936
 937             /* Output task declaration */
 938             headersout.print("void " + task.getSafeSymbol()+"(");
 939
 940             boolean printcomma=false;
 941             if (GENERATEPRECISEGC) {
 942                 headersout.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
 943             } else
 944                 headersout.print("void * parameterarray[]");
 945             headersout.println(");\n");
 946         }
 947     }
 948
 949     /** Generate code for flatmethod fm. */
 950
 951     private void generateFlatMethod(FlatMethod fm, PrintWriter output) {
 952         MethodDescriptor md=fm.getMethod();
 953         TaskDescriptor task=fm.getTask();
 954
 955         ClassDescriptor cn=md!=null?md.getClassDesc():null;
 956
 957         ParamsObject objectparams=(ParamsObject)paramstable.get(md!=null?md:task);
 958
 959         generateHeader(fm, md!=null?md:task,output);
 960
 961         TempObject objecttemp=(TempObject) tempstable.get(md!=null?md:task);
 962
 963         /* Print code */
 964         if (GENERATEPRECISEGC) {
 965             if (md!=null)
 966                 output.print("   struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
 967             else
 968                 output.print("   struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
 969
 970             output.print(objecttemp.numPointers()+",");
 971             output.print(paramsprefix);
 972             for(int j=0;j<objecttemp.numPointers();j++)
 973                 output.print(", NULL");
 974             output.println("};");
 975         }
 976
 977         for(int i=0;i<objecttemp.numPrimitives();i++) {
 978             TempDescriptor td=objecttemp.getPrimitive(i);
 979             TypeDescriptor type=td.getType();
 980             if (type.isNull())
 981                 output.println("   void * "+td.getSafeSymbol()+";");
 982             else if (type.isClass()||type.isArray())
 983                 output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
 984             else
 985                 output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
 986         }
 987
 988         /* Generate labels first */
 989         HashSet tovisit=new HashSet();
 990         HashSet visited=new HashSet();
 991         int labelindex=0;
 992         Hashtable nodetolabel=new Hashtable();
 993         tovisit.add(fm.getNext(0));
 994         FlatNode current_node=null;
 995
 996         //Assign labels 1st
 997         //Node needs a label if it is
 998         while(!tovisit.isEmpty()) {
 999             FlatNode fn=(FlatNode)tovisit.iterator().next();
1000             tovisit.remove(fn);
1001             visited.add(fn);
1002             for(int i=0;i<fn.numNext();i++) {
1003                 FlatNode nn=fn.getNext(i);
1004                 if(i>0) {
1005                     //1) Edge >1 of node
1006                     nodetolabel.put(nn,new Integer(labelindex++));
1007                 }
1008                 if (!visited.contains(nn)&&!tovisit.contains(nn)) {
1009                     tovisit.add(nn);
1010                 } else {
1011                     //2) Join point
1012                     nodetolabel.put(nn,new Integer(labelindex++));
1013                 }
1014             }
1015         }
1016
1017         if (state.THREAD&&GENERATEPRECISEGC) {
1018             output.println("checkcollect(&"+localsprefix+");");
1019         }
1020
1021         //Do the actual code generation
1022         tovisit=new HashSet();
1023         visited=new HashSet();
1024         tovisit.add(fm.getNext(0));
1025         while(current_node!=null||!tovisit.isEmpty()) {
1026             if (current_node==null) {
1027                 current_node=(FlatNode)tovisit.iterator().next();
1028                 tovisit.remove(current_node);
1029             }
1030             visited.add(current_node);
1031             if (nodetolabel.containsKey(current_node))
1032                 output.println("L"+nodetolabel.get(current_node)+":");
1033             if (state.INSTRUCTIONFAILURE) {
1034                 if (state.THREAD) {
1035                     output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
1036                 }
1037                 else
1038                     output.println("if ((--instructioncount)==0) injectinstructionfailure();");
1039             }
1040             if (current_node.numNext()==0) {
1041                 output.print("   ");
1042                 generateFlatNode(fm, current_node, output);
1043                 if (current_node.kind()!=FKind.FlatReturnNode) {
1044                     output.println("   return;");
1045                 }
1046                 current_node=null;
1047             } else if(current_node.numNext()==1) {
1048                 output.print("   ");
1049                 generateFlatNode(fm, current_node, output);
1050                 FlatNode nextnode=current_node.getNext(0);
1051                 if (visited.contains(nextnode)) {
1052                     output.println("goto L"+nodetolabel.get(nextnode)+";");
1053                     current_node=null;
1054                 } else
1055                     current_node=nextnode;
1056             } else if (current_node.numNext()==2) {
1057                 /* Branch */
1058                 output.print("   ");
1059                 generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
1060                 if (!visited.contains(current_node.getNext(1)))
1061                     tovisit.add(current_node.getNext(1));
1062                 if (visited.contains(current_node.getNext(0))) {
1063                     output.println("goto L"+nodetolabel.get(current_node.getNext(0))+";");
1064                     current_node=null;
1065                 } else
1066                     current_node=current_node.getNext(0);
1067             } else throw new Error();
1068         }
1069
1070
1071         output.println("}\n\n");
1072     }
1073
1074     /** Generate text string that corresponds to the Temp td. */
1075     private String generateTemp(FlatMethod fm, TempDescriptor td) {
1076         MethodDescriptor md=fm.getMethod();
1077         TaskDescriptor task=fm.getTask();
1078         TempObject objecttemps=(TempObject) tempstable.get(md!=null?md:task);
1079
1080         if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
1081             return td.getSafeSymbol();
1082         }
1083
1084         if (objecttemps.isLocalPtr(td)) {
1085             return localsprefix+"."+td.getSafeSymbol();
1086         }
1087
1088         if (objecttemps.isParamPtr(td)) {
1089             return paramsprefix+"->"+td.getSafeSymbol();
1090         }
1091         throw new Error();
1092     }
1093
1094     private void generateFlatNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
1095         switch(fn.kind()) {
1096         case FKind.FlatTagDeclaration:
1097             generateFlatTagDeclaration(fm, (FlatTagDeclaration) fn,output);
1098             return;
1099         case FKind.FlatCall:
1100             generateFlatCall(fm, (FlatCall) fn,output);
1101             return;
1102         case FKind.FlatFieldNode:
1103             generateFlatFieldNode(fm, (FlatFieldNode) fn,output);
1104             return;
1105         case FKind.FlatElementNode:
1106             generateFlatElementNode(fm, (FlatElementNode) fn,output);
1107             return;
1108         case FKind.FlatSetElementNode:
1109             generateFlatSetElementNode(fm, (FlatSetElementNode) fn,output);
1110             return;
1111         case FKind.FlatSetFieldNode:
1112             generateFlatSetFieldNode(fm, (FlatSetFieldNode) fn,output);
1113             return;
1114         case FKind.FlatNew:
1115             generateFlatNew(fm, (FlatNew) fn,output);
1116             return;
1117         case FKind.FlatOpNode:
1118             generateFlatOpNode(fm, (FlatOpNode) fn,output);
1119             return;
1120         case FKind.FlatCastNode:
1121             generateFlatCastNode(fm, (FlatCastNode) fn,output);
1122             return;
1123         case FKind.FlatLiteralNode:
1124             generateFlatLiteralNode(fm, (FlatLiteralNode) fn,output);
1125             return;
1126         case FKind.FlatReturnNode:
1127             generateFlatReturnNode(fm, (FlatReturnNode) fn,output);
1128             return;
1129         case FKind.FlatNop:
1130             output.println("/* nop */");
1131             return;
1132         case FKind.FlatBackEdge:
1133             if (state.THREAD&&GENERATEPRECISEGC) {
1134                 output.println("checkcollect(&"+localsprefix+");");
1135             } else
1136                 output.println("/* nop */");
1137             return;
1138         case FKind.FlatCheckNode:
1139             generateFlatCheckNode(fm, (FlatCheckNode) fn, output);
1140             return;
1141         case FKind.FlatFlagActionNode:
1142             generateFlatFlagActionNode(fm, (FlatFlagActionNode) fn, output);
1143             return;
1144         }
1145         throw new Error();
1146
1147     }
1148
1149     private void generateFlatCheckNode(FlatMethod fm,  FlatCheckNode fcn, PrintWriter output) {
1150
1151         if (state.CONSCHECK) {
1152             String specname=fcn.getSpec();
1153             String varname="repairstate___";
1154             output.println("{");
1155             output.println("struct "+specname+"_state * "+varname+"=allocate"+specname+"_state();");
1156
1157             TempDescriptor[] temps=fcn.getTemps();
1158             String[] vars=fcn.getVars();
1159             for(int i=0;i<temps.length;i++) {
1160                 output.println(varname+"->"+vars[i]+"=(int)"+generateTemp(fm, temps[i])+";");
1161             }
1162
1163             output.println("if (doanalysis"+specname+"("+varname+")) {");
1164             output.println("free"+specname+"_state("+varname+");");
1165             output.println("} else {");
1166             output.println("/* Bad invariant */");
1167             output.println("free"+specname+"_state("+varname+");");
1168             output.println("abort_task();");
1169             output.println("}");
1170
1171             output.println("}");
1172         }
1173     }
1174
1175     private void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
1176         MethodDescriptor md=fc.getMethod();
1177         ParamsObject objectparams=(ParamsObject) paramstable.get(md);
1178         ClassDescriptor cn=md.getClassDesc();
1179         output.println("{");
1180         if (GENERATEPRECISEGC) {
1181             output.print("       struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
1182
1183             output.print(objectparams.numPointers());
1184             //      output.print(objectparams.getUID());
1185             output.print(", & "+localsprefix);
1186             if (fc.getThis()!=null) {
1187                 output.print(", ");
1188                 output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis()));
1189             }
1190             for(int i=0;i<fc.numArgs();i++) {
1191                 Descriptor var=md.getParameter(i);
1192                 TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1193                 if (objectparams.isParamPtr(paramtemp)) {
1194                     TempDescriptor targ=fc.getArg(i);
1195                     output.print(", ");
1196                     TypeDescriptor td=md.getParamType(i);
1197                     if (td.isTag())
1198                         output.print("(struct "+(new TypeDescriptor(typeutil.getClass(TypeUtil.TagClass))).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
1199                     else
1200                         output.print("(struct "+md.getParamType(i).getSafeSymbol()  +" *)"+generateTemp(fm, targ));
1201                 }
1202             }
1203             output.println("};");
1204         }
1205         output.print("       ");
1206
1207
1208         if (fc.getReturnTemp()!=null)
1209             output.print(generateTemp(fm,fc.getReturnTemp())+"=");
1210
1211         /* Do we need to do virtual dispatch? */
1212         if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)) {
1213             output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
1214         } else {
1215
1216             output.print("((");
1217             if (md.getReturnType().isClass()||md.getReturnType().isArray())
1218                 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1219             else
1220                 output.print(md.getReturnType().getSafeSymbol()+" ");
1221             output.print("(*)(");
1222
1223             boolean printcomma=false;
1224             if (GENERATEPRECISEGC) {
1225                 output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
1226                 printcomma=true;
1227             }
1228
1229
1230             for(int i=0;i<objectparams.numPrimitives();i++) {
1231                 TempDescriptor temp=objectparams.getPrimitive(i);
1232                 if (printcomma)
1233                     output.print(", ");
1234                 printcomma=true;
1235                 if (temp.getType().isClass()||temp.getType().isArray())
1236                     output.print("struct " + temp.getType().getSafeSymbol()+" * ");
1237                 else
1238                     output.print(temp.getType().getSafeSymbol());
1239             }
1240
1241             output.print("))virtualtable["+generateTemp(fm,fc.getThis())+"->type*"+maxcount+"+"+virtualcalls.getMethodNumber(md)+"])");
1242         }
1243
1244         output.print("(");
1245         boolean needcomma=false;
1246         if (GENERATEPRECISEGC) {
1247             output.print("&__parameterlist__");
1248             needcomma=true;
1249         } else {
1250             if (fc.getThis()!=null) {
1251                 TypeDescriptor ptd=md.getThis().getType();
1252                 if (ptd.isClass()&&!ptd.isArray())
1253                     output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1254                 output.print(generateTemp(fm,fc.getThis()));
1255                 needcomma=true;
1256             }
1257         }
1258         for(int i=0;i<fc.numArgs();i++) {
1259             Descriptor var=md.getParameter(i);
1260             TempDescriptor paramtemp=(TempDescriptor)temptovar.get(var);
1261             if (objectparams.isParamPrim(paramtemp)) {
1262                 TempDescriptor targ=fc.getArg(i);
1263                 if (needcomma)
1264                     output.print(", ");
1265
1266                 TypeDescriptor ptd=md.getParamType(i);
1267                 if (ptd.isClass()&&!ptd.isArray())
1268                     output.print("(struct "+ptd.getSafeSymbol()+" *) ");
1269                 output.print(generateTemp(fm, targ));
1270                 needcomma=true;
1271             }
1272         }
1273         output.println(");");
1274         output.println("   }");
1275     }
1276
1277     private boolean singleCall(ClassDescriptor thiscd, MethodDescriptor md) {
1278         Set subclasses=typeutil.getSubClasses(thiscd);
1279         if (subclasses==null)
1280             return true;
1281         for(Iterator classit=subclasses.iterator();classit.hasNext();) {
1282             ClassDescriptor cd=(ClassDescriptor)classit.next();
1283             Set possiblematches=cd.getMethodTable().getSet(md.getSymbol());
1284             for(Iterator matchit=possiblematches.iterator();matchit.hasNext();) {
1285                 MethodDescriptor matchmd=(MethodDescriptor)matchit.next();
1286                 if (md.matches(matchmd))
1287                     return false;
1288             }
1289         }
1290         return true;
1291     }
1292
1293     private void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
1294         output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
1295     }
1296
1297     private void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
1298         if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray())
1299             throw new Error("Can't set array length");
1300         output.println(generateTemp(fm, fsfn.getDst())+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
1301     }
1302
1303     private void generateFlatElementNode(FlatMethod fm, FlatElementNode fen, PrintWriter output) {
1304         TypeDescriptor elementtype=fen.getSrc().getType().dereference();
1305         String type="";
1306
1307         if (elementtype.isArray()||elementtype.isClass())
1308             type="void *";
1309         else
1310             type=elementtype.getSafeSymbol()+" ";
1311
1312         if (fen.needsBoundsCheck()) {
1313             output.println("if ("+generateTemp(fm, fen.getIndex())+"< 0 || "+generateTemp(fm, fen.getIndex())+" >= "+generateTemp(fm,fen.getSrc()) + "->___length___)");
1314             output.println("failedboundschk();");
1315         }
1316
1317         output.println(generateTemp(fm, fen.getDst())+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc())+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex())+"];");
1318     }
1319
1320     private void generateFlatSetElementNode(FlatMethod fm, FlatSetElementNode fsen, PrintWriter output) {
1321         //TODO: need dynamic check to make sure this assignment is actually legal
1322         //Because Object[] could actually be something more specific...ie. Integer[]
1323
1324         TypeDescriptor elementtype=fsen.getDst().getType().dereference();
1325         String type="";
1326
1327         if (elementtype.isArray()||elementtype.isClass())
1328             type="void *";
1329         else
1330             type=elementtype.getSafeSymbol()+" ";
1331
1332         if (fsen.needsBoundsCheck()) {
1333             output.println("if ("+generateTemp(fm, fsen.getIndex())+"< 0 || "+generateTemp(fm, fsen.getIndex())+" >= "+generateTemp(fm,fsen.getDst()) + "->___length___)");
1334             output.println("failedboundschk();");
1335         }
1336
1337         output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst())+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex())+"]="+generateTemp(fm,fsen.getSrc())+";");
1338     }
1339
1340     private void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
1341         if (fn.getType().isArray()) {
1342             int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
1343             if (GENERATEPRECISEGC) {
1344                 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize())+");");
1345             } else {
1346                 output.println(generateTemp(fm,fn.getDst())+"=allocate_newarray("+arrayid+", "+generateTemp(fm, fn.getSize())+");");
1347             }
1348         } else {
1349             if (GENERATEPRECISEGC) {
1350                 output.println(generateTemp(fm,fn.getDst())+"=allocate_new(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
1351             } else {
1352                 output.println(generateTemp(fm,fn.getDst())+"=allocate_new("+fn.getType().getClassDesc().getId()+");");
1353             }
1354         }
1355     }
1356
1357
1358     private void generateFlatTagDeclaration(FlatMethod fm, FlatTagDeclaration fn, PrintWriter output) {
1359         if (GENERATEPRECISEGC) {
1360             output.println(generateTemp(fm,fn.getDst())+"=allocate_tag(&"+localsprefix+", "+state.getTagId(fn.getType())+");");
1361         } else {
1362             output.println(generateTemp(fm,fn.getDst())+"=allocate_tag("+state.getTagId(fn.getType())+");");
1363         }
1364     }
1365
1366     private void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
1367
1368         if (fon.getRight()!=null)
1369             output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
1370         else if (fon.getOp().getOp()==Operation.ASSIGN)
1371             output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
1372         else if (fon.getOp().getOp()==Operation.UNARYPLUS)
1373             output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
1374         else if (fon.getOp().getOp()==Operation.UNARYMINUS)
1375             output.println(generateTemp(fm, fon.getDest())+" = -"+generateTemp(fm, fon.getLeft())+";");
1376         else if (fon.getOp().getOp()==Operation.LOGIC_NOT)
1377             output.println(generateTemp(fm, fon.getDest())+" = !"+generateTemp(fm, fon.getLeft())+";");
1378         else
1379             output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
1380     }
1381
1382     private void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
1383         /* TODO: Do type check here */
1384         if (fcn.getType().isArray()) {
1385             throw new Error();
1386         } else if (fcn.getType().isClass())
1387             output.println(generateTemp(fm,fcn.getDst())+"=(struct "+fcn.getType().getSafeSymbol()+" *)"+generateTemp(fm,fcn.getSrc())+";");
1388         else
1389             output.println(generateTemp(fm,fcn.getDst())+"=("+fcn.getType().getSafeSymbol()+")"+generateTemp(fm,fcn.getSrc())+";");
1390     }
1391
1392     private void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
1393         if (fln.getValue()==null)
1394             output.println(generateTemp(fm, fln.getDst())+"=0;");
1395         else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
1396             if (GENERATEPRECISEGC) {
1397                 output.println(generateTemp(fm, fln.getDst())+"=NewString(&"+localsprefix+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
1398             } else {
1399                 output.println(generateTemp(fm, fln.getDst())+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
1400             }
1401         } else if (fln.getType().isBoolean()) {
1402             if (((Boolean)fln.getValue()).booleanValue())
1403                 output.println(generateTemp(fm, fln.getDst())+"=1;");
1404             else
1405                 output.println(generateTemp(fm, fln.getDst())+"=0;");
1406         } else if (fln.getType().isChar()) {
1407             String st=FlatLiteralNode.escapeString(fln.getValue().toString());
1408             output.println(generateTemp(fm, fln.getDst())+"='"+st+"';");
1409         } else
1410             output.println(generateTemp(fm, fln.getDst())+"="+fln.getValue()+";");
1411     }
1412
1413     private void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
1414
1415         if (frn.getReturnTemp()!=null)
1416             output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
1417         else
1418             output.println("return;");
1419     }
1420
1421     private void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
1422         output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
1423     }
1424
1425     private void generateHeader(FlatMethod fm, Descriptor des, PrintWriter output) {
1426         /* Print header */
1427         ParamsObject objectparams=(ParamsObject)paramstable.get(des);
1428         MethodDescriptor md=null;
1429         TaskDescriptor task=null;
1430         if (des instanceof MethodDescriptor)
1431             md=(MethodDescriptor) des;
1432         else
1433             task=(TaskDescriptor) des;
1434
1435         ClassDescriptor cn=md!=null?md.getClassDesc():null;
1436
1437         if (md!=null&&md.getReturnType()!=null) {
1438             if (md.getReturnType().isClass()||md.getReturnType().isArray())
1439                 output.print("struct " + md.getReturnType().getSafeSymbol()+" * ");
1440             else
1441                 output.print(md.getReturnType().getSafeSymbol()+" ");
1442         } else
1443             //catch the constructor case
1444             output.print("void ");
1445         if (md!=null)
1446             output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
1447         else
1448             output.print(task.getSafeSymbol()+"(");
1449
1450         boolean printcomma=false;
1451         if (GENERATEPRECISEGC) {
1452             if (md!=null)
1453                 output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
1454             else
1455                 output.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
1456             printcomma=true;
1457         }
1458
1459         if (md!=null) {
1460             /* Method */
1461             for(int i=0;i<objectparams.numPrimitives();i++) {
1462                 TempDescriptor temp=objectparams.getPrimitive(i);
1463                 if (printcomma)
1464                     output.print(", ");
1465                 printcomma=true;
1466                 if (temp.getType().isClass()||temp.getType().isArray())
1467                     output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
1468                 else
1469                     output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
1470             }
1471             output.println(") {");
1472         } else if (!GENERATEPRECISEGC) {
1473             /* Imprecise Task */
1474             output.println("void * parameterarray[]) {");
1475             /* Unpack variables */
1476             for(int i=0;i<objectparams.numPrimitives();i++) {
1477                 TempDescriptor temp=objectparams.getPrimitive(i);
1478                 output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
1479             }
1480             for(int i=0;i<fm.numTags();i++) {
1481                 TempDescriptor temp=fm.getTag(i);
1482                 int offset=i+objectparams.numPrimitives();
1483                 output.println("struct ___TagDescriptor___ * "+temp.getSafeSymbol()+"=parameterarray["+offset+"];");
1484             }
1485
1486             if ((objectparams.numPrimitives()+fm.numTags())>maxtaskparams)
1487                 maxtaskparams=objectparams.numPrimitives()+fm.numTags();
1488         } else output.println(") {");
1489     }
1490
1491     public void generateFlatFlagActionNode(FlatMethod fm, FlatFlagActionNode ffan, PrintWriter output) {
1492         output.println("/* FlatFlagActionNode */");
1493
1494
1495         /* Process tag changes */
1496         Relation tagsettable=new Relation();
1497         Relation tagcleartable=new Relation();
1498
1499         Iterator tagsit=ffan.getTempTagPairs();
1500         while (tagsit.hasNext()) {
1501             TempTagPair ttp=(TempTagPair) tagsit.next();
1502             TempDescriptor objtmp=ttp.getTemp();
1503             TagDescriptor tag=ttp.getTag();
1504             TempDescriptor tagtmp=ttp.getTagTemp();
1505             boolean tagstatus=ffan.getTagChange(ttp);
1506             if (tagstatus) {
1507                 tagsettable.put(objtmp, tagtmp);
1508             } else {
1509                 tagcleartable.put(objtmp, tagtmp);
1510             }
1511         }
1512
1513
1514         Hashtable flagandtable=new Hashtable();
1515         Hashtable flagortable=new Hashtable();
1516
1517         /* Process flag changes */
1518         Iterator flagsit=ffan.getTempFlagPairs();
1519         while(flagsit.hasNext()) {
1520             TempFlagPair tfp=(TempFlagPair)flagsit.next();
1521             TempDescriptor temp=tfp.getTemp();
1522             Hashtable flagtable=(Hashtable)flagorder.get(temp.getType().getClassDesc());
1523             FlagDescriptor flag=tfp.getFlag();
1524             if (flag==null) {
1525                 //Newly allocate objects that don't set any flags case
1526                 if (flagortable.containsKey(temp)) {
1527                     throw new Error();
1528                 }
1529                 int mask=0;
1530                 flagortable.put(temp,new Integer(mask));
1531             } else {
1532                 int flagid=1<<((Integer)flagtable.get(flag)).intValue();
1533                 boolean flagstatus=ffan.getFlagChange(tfp);
1534                 if (flagstatus) {
1535                     int mask=0;
1536                     if (flagortable.containsKey(temp)) {
1537                         mask=((Integer)flagortable.get(temp)).intValue();
1538                     }
1539                     mask|=flagid;
1540                     flagortable.put(temp,new Integer(mask));
1541                 } else {
1542                     int mask=0xFFFFFFFF;
1543                     if (flagandtable.containsKey(temp)) {
1544                         mask=((Integer)flagandtable.get(temp)).intValue();
1545                     }
1546                     mask&=(0xFFFFFFFF^flagid);
1547                     flagandtable.put(temp,new Integer(mask));
1548                 }
1549             }
1550         }
1551
1552
1553         HashSet flagtagset=new HashSet();
1554         flagtagset.addAll(flagortable.keySet());
1555         flagtagset.addAll(flagandtable.keySet());
1556         flagtagset.addAll(tagsettable.keySet());
1557         flagtagset.addAll(tagcleartable.keySet());
1558
1559         Iterator ftit=flagtagset.iterator();
1560         while(ftit.hasNext()) {
1561             TempDescriptor temp=(TempDescriptor)ftit.next();
1562
1563
1564             Set tagtmps=tagcleartable.get(temp);
1565             if (tagtmps!=null) {
1566                 Iterator tagit=tagtmps.iterator();
1567                 while(tagit.hasNext()) {
1568                     TempDescriptor tagtmp=(TempDescriptor)tagit.next();
1569                     if (GENERATEPRECISEGC)
1570                         output.println("tagclear(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
1571                     else
1572                         output.println("tagclear((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
1573                 }
1574             }
1575
1576             tagtmps=tagsettable.get(temp);
1577             if (tagtmps!=null) {
1578                 Iterator tagit=tagtmps.iterator();
1579                 while(tagit.hasNext()) {
1580                     TempDescriptor tagtmp=(TempDescriptor)tagit.next();
1581                     if (GENERATEPRECISEGC)
1582                         output.println("tagset(&"+localsprefix+", (struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
1583                     else
1584                         output.println("tagset((struct ___Object___ *)"+generateTemp(fm, temp)+", "+generateTemp(fm,tagtmp)+");");
1585                 }
1586             }
1587
1588             int ormask=0;
1589             int andmask=0xFFFFFFF;
1590
1591             if (flagortable.containsKey(temp))
1592                 ormask=((Integer)flagortable.get(temp)).intValue();
1593             if (flagandtable.containsKey(temp))
1594                 andmask=((Integer)flagandtable.get(temp)).intValue();
1595             if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
1596                 output.println("flagorandinit("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
1597             } else {
1598                 output.println("flagorand("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
1599             }
1600         }
1601     }
1602
1603      void generateOptionalArrays(PrintWriter output, Hashtable<ClassDescriptor, Hashtable<FlagState, HashSet>> safeexecution, Hashtable myoptionals) {
1604
1605          /* SymbolTable classes = state.getClassSymbolTable();
1606          for( Iterator it = classes.getAllDescriptorsIterator(); it.hasNext();){
1607              ClassDescriptor cd = (ClassDescriptor)it.next();
1608              output.println("Class "+cd.getSymbol());
1609              Hashtable flags=(Hashtable)flagorder.get(cd);
1610              for (Iterator fit = cd.getFlags(); fit.hasNext();){
1611                  FlagDescriptor fd = (FlagDescriptor)fit.next();
1612                  int flagid=1<<((Integer)flags.get(fd)).intValue();
1613                  output.println("\tFlag associated with "+fd.getSymbol()+" : 0x"+Integer.toHexString(flagid)+" bx"+Integer.toBinaryString(flagid));
1614              }
1615              }*/
1616
1617
1618
1619          int fscounter = 0;
1620          int myocounter = 0;
1621          int classescounter = 0;
1622          Enumeration e = safeexecution.keys();
1623          while (e.hasMoreElements()) {
1624              //get the class
1625              ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
1626              for(Iterator myoit = ((HashSet)myoptionals.get(cdtemp)).iterator(); myoit.hasNext();){
1627                  MyOptional myo = (MyOptional)myoit.next();
1628                  output.println("struct myoptional myoptional_"+"/*ID to determine*/"+"_"+"cdtemp.getsafeSymbol()"+"={");
1629                  //insert code to generate the myoptional
1630                  output.println("};");
1631              }
1632              classescounter++;
1633              Hashtable hashtbtemp = safeexecution.get(cdtemp);
1634              Enumeration fses = hashtbtemp.keys();
1635              while(fses.hasMoreElements()){
1636                  //get all the possible falgstates reachable by an object
1637                  FlagState fs = (FlagState)fses.nextElement();
1638                  fscounter++;
1639                  //get the set of MyOptionnals
1640                  HashSet availabletasks = (HashSet)hashtbtemp.get(fs);
1641                  //iterate through the MyOptionals
1642                  for(Iterator mos = availabletasks.iterator(); mos.hasNext();){
1643                      MyOptional mm = (MyOptional)mos.next();
1644                      myocounter++;
1645                  }
1646                  output.println("struct myoptional * myoptionals_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {");
1647                  for(int i=0; i<myocounter; i++){
1648                      if(i==myocounter-1) output.println("&myoptional_"+"/*ID to determine*/"+"_"+cdtemp.getSafeSymbol()+"};");
1649
1650                      else output.println("&myoptional_"+"/*ID to determine*/"+"_"+cdtemp.getSafeSymbol()+",");
1651                  }
1652                  myocounter = 0;
1653                  output.println("int flagstatednf_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
1654                  for(Iterator flags = fs.getFlags(); flags.hasNext();){
1655                      FlagDescriptor flagd = (FlagDescriptor)flags.next();
1656                      //process the fs, maybe add int tagstate[]
1657                  }
1658                  output.println("};");
1659                  output.println("struct structB structB_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"={");
1660                  output.println("/* number of dnf terms (to add)*/,");
1661                  output.println("flagstatednf_"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
1662                  output.println("/* number of tags (to add)*/,");
1663                  output.println("tags_"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
1664                  output.println("/* number of myoptionals */,");
1665                  output.println("myoptionals_FS"+fscounter+"_"+cdtemp.getSafeSymbol());
1666                  output.println("};");
1667              }
1668              output.println("struct structB * structBs_"+cdtemp.getSafeSymbol()+"[] = {");
1669              for(int i = 0; i<fscounter; i++){
1670                  if(i==fscounter-1) output.println("&structB_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"};");
1671
1672                      else output.println("&structB_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+",");
1673              }
1674              fscounter = 0;
1675              output.println("struct structA structA_"+cdtemp.getSafeSymbol()+"={");
1676              output.println("/* class identifier */,");
1677              output.println("structBs_"+cdtemp.getSafeSymbol()+"};");
1678          }
1679          output.println("struct structA * classesarray[]={");
1680          e = safeexecution.keys();
1681          int j = 0;
1682          while (e.hasMoreElements()) {
1683              ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement();
1684              j++;
1685              if(j==classescounter) output.println("&structA_"+cdtemp.getSafeSymbol()+"};");
1686              else output.println("&structA_"+cdtemp.getSafeSymbol()+",");
1687          }
1688          output.println("int numclasses = "+classescounter+";");
1689
1690      }
1691
1692 }
1693
1694
1695
1696
1697
1698