Charm++: Charm Source Code Documentation

00001 #ifndef _SYMBOL_H
00002 #define _SYMBOL_H
00003 
00004 #include "xi-util.h"
00005 #include "EToken.h"
00006 #include "CEntry.h"
00007 #include "sdag-globals.h"
00008 #include "CList.h"
00009 #include "CParsedFile.h"
00010 
00011 #include <iostream>
00012 #include <stdio.h>
00013 #include <string.h>
00014 #include <stdlib.h>
00015 #include <list>
00016 
00017 
00018 namespace xi {
00019 
00020 extern void generateSignature(XStr& decls, XStr& defs,
00021                               const Entry* entry, bool declareStatic,
00022                               const char* returnType, const XStr* name, bool isEnd,
00023                               TList<CStateVar*>* params);
00024 extern void generateSignature(XStr& decls, XStr& defs,
00025                               const Chare* chare, bool declareStatic,
00026                               const char* returnType, const XStr* name, bool isEnd,
00027                               TList<CStateVar*>* params);
00028 extern void endMethod(XStr& op);
00029 
00030 class CStateVar;
00031 
00032 /******************* Utilities ****************/
00033 
00034 class Prefix {
00035 public:
00036   static const char *Proxy;
00037   static const char *ProxyElement;
00038   static const char *ProxySection;
00039   static const char *Message;
00040   static const char *Index;
00041   static const char *Python;
00042 };
00043 
00044 typedef enum {
00045   forAll=0,forIndividual=1,forSection=2,forPython=3,forIndex=-1
00046 } forWhom;
00047 
00048 class Chare;//Forward declaration
00049 class Message;
00050 class TParamList;
00051 extern int fortranMode;
00052 extern int internalMode;
00053 extern const char *cur_file;
00054 void die(const char *why,int line=-1);
00055 
00056 class Value : public Printable {
00057   private:
00058     int factor;
00059     const char *val;
00060   public:
00061     Value(const char *s);
00062     void print(XStr& str) { str << val; }
00063     int getIntVal(void);
00064 };
00065 
00066 class ValueList : public Printable {
00067   private:
00068     Value *val;
00069     ValueList *next;
00070   public:
00071     ValueList(Value* v, ValueList* n=0) : val(v), next(n) {}
00072     void print(XStr& str) {
00073       if(val) {
00074         str << "["; val->print(str); str << "]";
00075       }
00076       if(next)
00077         next->print(str);
00078     }
00079     void printValue(XStr& str) {
00080       if(val) {
00081         val->print(str);
00082       }
00083       if(next) {
00084           std::cout << "Unsupported type\n";
00085           abort();
00086       }
00087     }
00088 };
00089 
00090 class Module;
00091 
00092 class Construct : public Printable {
00093   protected:
00094     int external;
00095   public:
00096     int line;
00097     Module *containerModule;
00098     Construct() {external=0;line=-1;}
00099     void setExtern(int &e) { external = e; }
00100     void setModule(Module *m) { containerModule = m; }
00101     virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent)
00102     {
00103       (void)declstr; (void)defstr; (void)defconstr; (void)connectPresent;
00104     }
00105     virtual void genDecls(XStr& str) { (void)str; }
00106     virtual void genDefs(XStr& str) { (void)str; }
00107     virtual void genReg(XStr& str) { (void)str; }
00108     virtual void preprocess() { }
00109 
00110     // DMK - Accel Support
00111     virtual int genAccels_spe_c_funcBodies(XStr& str) { (void)str; return 0; }
00112     virtual void genAccels_spe_c_regFuncs(XStr& str) { (void)str; }
00113     virtual void genAccels_spe_c_callInits(XStr& str) { (void)str; }
00114     virtual void genAccels_spe_h_includes(XStr& str) { (void)str; }
00115     virtual void genAccels_spe_h_fiCountDefs(XStr& str) { (void)str; }
00116     virtual void genAccels_ppe_c_regFuncs(XStr& str) { (void)str; }
00117 };
00118 
00119 class ConstructList : public Construct {
00120     std::list<Construct*> constructs;
00121   public:
00122     ConstructList(int l, Construct *c, ConstructList *n=0);
00123     void setExtern(int e);
00124     void setModule(Module *m);
00125     void print(XStr& str);
00126     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
00127     void genDecls(XStr& str);
00128     void genDefs(XStr& str);
00129     void genReg(XStr& str);
00130     void preprocess();
00131 
00132     // DMK - Accel Support
00133     int genAccels_spe_c_funcBodies(XStr& str);
00134     void genAccels_spe_c_regFuncs(XStr& str);
00135     void genAccels_spe_c_callInits(XStr& str);
00136     void genAccels_spe_h_includes(XStr& str);
00137     void genAccels_spe_h_fiCountDefs(XStr& str);
00138     void genAccels_ppe_c_regFuncs(XStr& str);
00139 };
00140 
00141 /*********************** Type System **********************/
00142 class Type : public Printable {
00143   public:
00144     virtual void print(XStr&) = 0;
00145     virtual int isVoid(void) const {return 0;}
00146     virtual int isBuiltin(void) const { return 0; }
00147     virtual int isMessage(void) const {return 0;}
00148     virtual int isTemplated(void) const { return 0; }
00149     virtual int isPointer(void) const {return 0;}
00150     virtual int isNamed(void) const { return 0; }
00151     virtual int isCkArgMsgPtr(void) const {return 0;}
00152     virtual int isCkArgMsg(void) const {return 0;}
00153     virtual int isCkMigMsgPtr(void) const {return 0;}
00154     virtual int isCkMigMsg(void) const {return 0;}
00155     virtual int isReference(void) const {return 0;}
00156     virtual Type *deref(void) {return this;}
00157     virtual const char *getBaseName(void) const = 0;
00158     virtual const char *getScope(void) const = 0;
00159     virtual int getNumStars(void) const {return 0;}
00160     virtual void genProxyName(XStr &str,forWhom forElement);
00161     virtual void genIndexName(XStr &str);
00162     virtual void genMsgProxyName(XStr& str);
00163     XStr proxyName(forWhom w)
00164         {XStr ret; genProxyName(ret,w); return ret;}
00165     XStr indexName(void) 
00166         {XStr ret; genIndexName(ret); return ret;}
00167     XStr msgProxyName(void) 
00168         {XStr ret; genMsgProxyName(ret); return ret;}
00169     virtual void printVar(XStr &str, char *var) {print(str); str<<" "; str<<var;}
00170     int operator==(const Type &tp) const {
00171       return  (strcmp(getBaseName(), tp.getBaseName())==0);
00172     }
00173 };
00174 
00175 class BuiltinType : public Type {
00176   private:
00177     char *name;
00178   public:
00179     BuiltinType(const char *n) : name((char *)n) {}
00180     int isBuiltin(void) const {return 1;}
00181     void print(XStr& str) { str << name; }
00182     int isVoid(void) const { return !strcmp(name, "void"); }
00183     int isInt(void) const { return !strcmp(name, "int"); }
00184     const char *getBaseName(void) const { return name; }
00185     const char *getScope(void) const { return NULL; }
00186 };
00187 
00188 class NamedType : public Type {
00189   private:
00190     const char* name;
00191     const char* scope;
00192     TParamList *tparams;
00193   public:
00194     NamedType(const char* n, TParamList* t=0, const char* scope_=NULL)
00195        : name(n), scope(scope_), tparams(t) {}
00196     int isTemplated(void) const { return (tparams!=0); }
00197     int isCkArgMsg(void) const {return 0==strcmp(name,"CkArgMsg");}
00198     int isCkMigMsg(void) const {return 0==strcmp(name,"CkMigrateMessage");}
00199     void print(XStr& str);
00200     int isNamed(void) const {return 1;}
00201     virtual const char *getBaseName(void) const { return name; }
00202     virtual const char *getScope(void) const { return scope; }
00203     virtual void genProxyName(XStr& str,forWhom forElement);
00204     virtual void genIndexName(XStr& str);
00205     virtual void genMsgProxyName(XStr& str);
00206 };
00207 
00208 class PtrType : public Type {
00209   private:
00210     Type *type;
00211     int numstars; // level of indirection
00212   public:
00213     PtrType(Type *t) : type(t), numstars(1) {}
00214     int isPointer(void) const {return 1;}
00215     int isCkArgMsgPtr(void) const {return numstars==1 && type->isCkArgMsg();}
00216     int isCkMigMsgPtr(void) const {return numstars==1 && type->isCkMigMsg();}
00217     int isMessage(void) const {return numstars==1 && !type->isBuiltin();}
00218     void indirect(void) { numstars++; }
00219     int getNumStars(void) const {return numstars; }
00220     void print(XStr& str);
00221     const char *getBaseName(void) const { return type->getBaseName(); }
00222     const char *getScope(void) const { return NULL; }
00223     virtual void genMsgProxyName(XStr& str) { 
00224       if(numstars != 1) {
00225         die("too many stars-- entry parameter must have form 'MTYPE *msg'"); 
00226       } else {
00227         type->genMsgProxyName(str);
00228       }
00229     }
00230 };
00231 
00232 class ReferenceType : public Type {
00233   private:
00234     Type *referant;
00235   public:
00236     ReferenceType(Type *t) : referant(t) {}
00237     int isReference(void) const {return 1;}
00238     void print(XStr& str) {str<<referant<<" &";}
00239     virtual Type *deref(void) {return referant;}
00240     const char *getBaseName(void) const { return referant->getBaseName(); }
00241     const char *getScope(void) const { return NULL; }
00242 };
00243 
00244 //This is used as a list of base classes
00245 class TypeList : public Printable {
00246     Type *type;
00247     TypeList *next;
00248   public:
00249     TypeList(Type *t, TypeList *n=0) : type(t), next(n) {}
00250     ~TypeList() { delete type; delete next; }
00251     int length(void) const;
00252     Type *getFirst(void) {return type;}
00253     void print(XStr& str);
00254     void genProxyNames(XStr& str, const char *prefix, const char *middle, 
00255                         const char *suffix, const char *sep, forWhom forElement);
00256 };
00257 
00258 /**************** Parameter types & lists (for marshalling) ************/
00259 class Parameter {
00260     Type *type;
00261     const char *name; /*The name of the variable, if any*/
00262     const char *given_name; /*The name of the msg in ci file, if any*/
00263     const char *arrLen; /*The expression for the length of the array;
00264                          NULL if not an array*/
00265     Value *val; /*Initial value, if any*/
00266     int line;
00267     int byReference; //Fake a pass-by-reference (for efficiency)
00268     int conditional; //If the parameter is conditionally packed
00269 
00270     // DMK - Added field for accelerator options
00271     int accelBufferType;
00272     XStr* accelInstName;
00273 
00274     friend class ParamList;
00275     void pup(XStr &str);
00276     void copyPtr(XStr &str);
00277     void marshallArraySizes(XStr &str);
00278     void marshallArrayData(XStr &str);
00279     void beginUnmarshall(XStr &str);
00280     void unmarshallArrayData(XStr &str);
00281     void pupAllValues(XStr &str);
00282   public:
00283     Parameter(int Nline,Type *Ntype,const char *Nname=0,
00284         const char *NarrLen=0,Value *Nvalue=0);
00285     void setConditional(int c) { conditional = c; if (c) byReference = false; };
00286     void print(XStr &str,int withDefaultValues=0,int useConst=1);
00287     void printAddress(XStr &str);
00288     void printValue(XStr &str);
00289     int isMessage(void) const {return type->isMessage();}
00290     int isVoid(void) const {return type->isVoid();}
00291     int isCkArgMsgPtr(void) const {return type->isCkArgMsgPtr();}
00292     int isCkMigMsgPtr(void) const {return type->isCkMigMsgPtr();}
00293     int isArray(void) const {return arrLen!=NULL;}
00294     int isConditional(void) const {return conditional;}
00295     Type *getType(void) {return type;}
00296     const char *getArrayLen(void) const {return arrLen;}
00297     const char *getGivenName(void) const {return given_name;}
00298     const char *getName(void) const {return name;}
00299     void printMsg(XStr& str) {
00300       type->print(str);
00301       if(given_name!=0)
00302         str <<given_name;
00303     }
00304     int operator==(const Parameter &parm) const {
00305       return *type == *parm.type;
00306     }
00307 
00308     // DMK - Added for accelerator options
00309     public:
00310     enum {
00311       ACCEL_BUFFER_TYPE_UNKNOWN   = 0,
00312       ACCEL_BUFFER_TYPE_MIN       = 1,
00313       ACCEL_BUFFER_TYPE_READWRITE = 1,
00314       ACCEL_BUFFER_TYPE_READONLY  = 2,
00315       ACCEL_BUFFER_TYPE_WRITEONLY = 3,
00316       ACCEL_BUFFER_TYPE_MAX       = 3
00317     };
00318     void setAccelBufferType(int abt) {
00319       accelBufferType = ((abt < ACCEL_BUFFER_TYPE_MIN || abt > ACCEL_BUFFER_TYPE_MAX) ? (ACCEL_BUFFER_TYPE_UNKNOWN) : (abt));
00320     }
00321     int getAccelBufferType() { return accelBufferType; }
00322     void setAccelInstName(XStr* ain) { accelInstName = ain; }
00323     XStr* getAccelInstName(void) { return accelInstName; }
00324 
00325 };
00326 class ParamList {
00327     typedef int (Parameter::*pred_t)(void) const;
00328     int orEach(pred_t f);
00329     typedef void (Parameter::*fn_t)(XStr &str);
00330     void callEach(fn_t f,XStr &str);
00331     bool manyPointers;
00332   public:
00333     Parameter *param;
00334     ParamList *next;
00335     ParamList(ParamList *pl) : manyPointers(false), param(pl->param), next(pl->next) {}
00336     ParamList(Parameter *Nparam,ParamList *Nnext=NULL)
00337         :param(Nparam), next(Nnext) { 
00338           manyPointers = false;
00339           if(next != NULL && (param->isMessage() || next->isMessage())){
00340             manyPointers = true;
00341           }
00342     }
00343     void print(XStr &str,int withDefaultValues=0,int useConst=1);
00344     void printAddress(XStr &str);
00345     void printValue(XStr &str);
00346     int isNamed(void) const {return param->type->isNamed();}
00347     int isBuiltin(void) const {return param->type->isBuiltin();}
00348     int isMessage(void) const {
00349         return (next==NULL) && param->isMessage();
00350     }
00351     const char *getArrayLen(void) const {return param->getArrayLen();}
00352     int isArray(void) const {return param->isArray();}
00353     int isReference(void) const {return param->type->isReference();}
00354     int isVoid(void) const {
00355         return (next==NULL) && param->isVoid();
00356     }
00357     int isPointer(void) const {return param->type->isPointer();}
00358     const char *getGivenName(void) const {return param->getGivenName();}
00359     int isMarshalled(void) const {
00360         return !isVoid() && !isMessage();
00361     }
00362     int isCkArgMsgPtr(void) const {
00363         return (next==NULL) && param->isCkArgMsgPtr();
00364     }
00365     int isCkMigMsgPtr(void) const {
00366         return (next==NULL) && param->isCkMigMsgPtr();
00367     }
00368     int getNumStars(void) const {return param->type->getNumStars(); }
00369     const char *getBaseName(void) {
00370         return param->type->getBaseName();
00371     }
00372     void genMsgProxyName(XStr &str) {
00373         param->type->genMsgProxyName(str);
00374     }
00375     void printMsg(XStr& str) {
00376         ParamList *pl;
00377         param->printMsg(str);
00378         pl = next;
00379         while (pl != NULL)
00380         {
00381            str <<", ";
00382            pl->param->printMsg(str);
00383            pl = pl->next;
00384         } 
00385     }
00386     void preprocess();
00387     int hasConditional();
00388     void marshall(XStr &str, XStr &entry);
00389     void beginUnmarshall(XStr &str);
00390     void beginRednWrapperUnmarshall(XStr &str);
00391     void unmarshall(XStr &str, int isFirst=1);
00392     void unmarshallAddress(XStr &str, int isFirst=1);
00393     void pupAllValues(XStr &str);
00394     void endUnmarshall(XStr &str);
00395     int operator==(const ParamList &plist) const {
00396       if (!(*param == *(plist.param))) return 0;
00397       if (!next && !plist.next) return 1;
00398       if (!next || !plist.next) return 0;
00399       return *next ==  *plist.next;
00400     }
00401     void checkParamList();
00402 };
00403 
00404 class FuncType : public Type {
00405   private:
00406     Type *rtype;
00407     const char *name;
00408     ParamList *params;
00409   public:
00410     FuncType(Type* r, const char* n, ParamList* p)
00411         :rtype(r),name(n),params(p) {}
00412     void print(XStr& str) { 
00413       rtype->print(str);
00414       str << "(*" << name << ")(";
00415       if(params)
00416         params->print(str);
00417     }
00418     const char *getBaseName(void) const { return name; }
00419     const char *getScope(void) const { return NULL; }
00420 };
00421 
00422 /****************** Template Support **************/
00423 /* Template Instantiation Parameter */
00424 class TParam : public Printable {
00425   public:
00426     virtual void genSpec(XStr& str)=0;
00427 };
00428 
00429 /* List of Template Instantiation parameters */
00430 class TParamList : public Printable {
00431     TParam *tparam;
00432     TParamList *next;
00433   public:
00434     TParamList(TParam *t, TParamList *n=0) : tparam(t), next(n) {}
00435     void print(XStr& str);
00436     void genSpec(XStr& str);
00437     std::string to_string();
00438 };
00439 
00440 /* A type instantiation parameter */
00441 class TParamType : public TParam {
00442   Type *type;
00443   public:
00444     TParamType(Type *t) : type(t) {}
00445     void print(XStr& str) { type->print(str); }
00446     void genSpec(XStr& str) { type->print(str); }
00447 };
00448 
00449 /* A Value instantiation parameter */
00450 class TParamVal : public TParam {
00451     const char *val;
00452   public:
00453     TParamVal(const char *v) : val(v) {}
00454     void print(XStr& str) { str << val; }
00455     void genSpec(XStr& str) { str << val; }
00456 };
00457 
00458 class Scope : public Construct {
00459   protected:
00460     const char* name_;
00461     ConstructList* contents_;
00462   public:
00463     Scope(const char* name, ConstructList* contents) : name_(name), contents_(contents) {}
00464     virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {
00465         contents_->genPub(declstr, defstr, defconstr, connectPresent);
00466     }
00467     virtual void genDecls(XStr& str) {
00468         str << "namespace " << name_ << " {\n";
00469         contents_->genDecls(str);
00470         str << "} // namespace " << name_ << "\n";
00471     }
00472     virtual void genDefs(XStr& str) {
00473         str << "namespace " << name_ << " {\n";
00474         contents_->genDefs(str);
00475         str << "} // namespace " << name_ << "\n";
00476     }
00477     virtual void genReg(XStr& str) {
00478         str << "using namespace " << name_ << ";\n";
00479         contents_->genReg(str);
00480     }
00481     virtual void preprocess() {
00482         contents_->preprocess();
00483     }
00484     virtual void print(XStr& str) {
00485         str << "namespace " << name_ << "{\n";
00486         contents_->print(str);
00487         str << "} // namespace " << name_ << "\n";
00488     }
00489 
00490     // DMK - Accel Support
00491     virtual int genAccels_spe_c_funcBodies(XStr& str) {
00492       return contents_->genAccels_spe_c_funcBodies(str);
00493     }
00494     virtual void genAccels_spe_c_regFuncs(XStr& str) {
00495       contents_->genAccels_spe_c_regFuncs(str);
00496     }
00497     virtual void genAccels_spe_c_callInits(XStr& str) {
00498       contents_->genAccels_spe_c_callInits(str);
00499     }
00500     virtual void genAccels_spe_h_includes(XStr& str) {
00501       contents_->genAccels_spe_h_includes(str);
00502     }
00503     virtual void genAccels_spe_h_fiCountDefs(XStr& str) {
00504       contents_->genAccels_spe_h_fiCountDefs(str);
00505     }
00506     virtual void genAccels_ppe_c_regFuncs(XStr& str) {
00507       contents_->genAccels_ppe_c_regFuncs(str);
00508     }
00509 };
00510 
00511 class UsingScope : public Construct {
00512   protected:
00513     const char* name_;
00514     bool symbol_;
00515   public:
00516     UsingScope(const char* name, bool symbol=false) : name_(name), symbol_(symbol) {}
00517     virtual void genDecls(XStr& str) {
00518         str << "using ";
00519         if (!symbol_) str << "namespace ";
00520         str << name_ << ";\n";
00521     }
00522     virtual void print(XStr& str) {
00523         str << "using ";
00524         if (!symbol_) str << "namespace ";
00525         str << name_ << ";\n";
00526     }
00527 };
00528 
00529 
00530 /* A template construct */
00531 class TVarList;
00532 class TEntity;
00533 
00534 class Template : public Construct {
00535     TVarList *tspec;
00536     TEntity *entity;
00537   public:
00538     Template(TVarList *t, TEntity *e) : tspec(t), entity(e) {}
00539     virtual void setExtern(int e);
00540     void print(XStr& str);
00541     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
00542     void genDecls(XStr& str);
00543     void genDefs(XStr& str);
00544     void genSpec(XStr& str);
00545     void genVars(XStr& str);
00546 
00547     // DMK - Accel Support
00548     int genAccels_spe_c_funcBodies(XStr& str);
00549     void genAccels_spe_c_regFuncs(XStr& str);
00550     void genAccels_spe_c_callInits(XStr& str);
00551     void genAccels_spe_h_includes(XStr& str);
00552     void genAccels_spe_h_fiCountDefs(XStr& str);
00553     void genAccels_ppe_c_regFuncs(XStr& str);
00554 };
00555 
00556 /* An entity that could be templated, i.e. chare, group or a message */
00557 class TEntity : public Construct {
00558   protected:
00559     Template *templat;
00560   public:
00561     void setTemplate(Template *t) { templat = t; }
00562     virtual XStr tspec(void) const {
00563         XStr str; 
00564         if (templat) templat->genSpec(str); 
00565         return str;
00566     }
00567     virtual XStr tvars(void) const {
00568         XStr str;
00569         if (templat) templat->genVars(str); 
00570         return str;
00571     }
00572 };
00573 /* A formal argument of a template */
00574 class TVar : public Printable {
00575   public:
00576     virtual void genLong(XStr& str) = 0;
00577     virtual void genShort(XStr& str) = 0;
00578 };
00579 
00580 /* a formal type argument */
00581 class TType : public TVar {
00582     Type *type;
00583     Type *init;
00584   public:
00585     TType(Type *t, Type *i=0) : type(t), init(i) {}
00586     void print(XStr& str);
00587     void genLong(XStr& str);
00588     void genShort(XStr& str);
00589 };
00590 
00591 /* a formal function argument */
00592 class TFunc : public TVar {
00593     FuncType *type;
00594     const char *init;
00595   public:
00596     TFunc(FuncType *t, const char *v=0) : type(t), init(v) {}
00597     void print(XStr& str) { type->print(str); if(init) str << "=" << init; }
00598     void genLong(XStr& str){ type->print(str); if(init) str << "=" << init; }
00599     void genShort(XStr& str) {str << type->getBaseName(); }
00600 };
00601 
00602 /* A formal variable argument */
00603 class TName : public TVar {
00604     Type *type;
00605     const char *name;
00606     const char *val;
00607   public:
00608     TName(Type *t, const char *n, const char *v=0) : type(t), name(n), val(v) {}
00609     void print(XStr& str);
00610     void genLong(XStr& str);
00611     void genShort(XStr& str);
00612 };
00613 
00614 /* A list of formal arguments to a template */
00615 class TVarList : public Printable {
00616     TVar *tvar;
00617     TVarList *next;
00618   public:
00619     TVarList(TVar *v, TVarList *n=0) : tvar(v), next(n) {}
00620     void print(XStr& str);
00621     void genLong(XStr& str);
00622     void genShort(XStr& str);
00623 };
00624 
00625 /******************* Chares, Arrays, Groups ***********/
00626 
00627 /* Member of a chare or group, i.e. entry, RO or ROM */
00628 class Member : public Construct {
00629    //friend class CParsedFile;
00630   protected:
00631     Chare *container;
00632   public:
00633     TVarList *tspec;
00634     Member() : container(0), tspec(0) { }
00635     inline Chare *getContainer() const { return container; }
00636     virtual void setChare(Chare *c) { container = c; }
00637     virtual int isSdag(void) { return 0; }
00638     virtual void collectSdagCode(CParsedFile *, int&) { return; }
00639     XStr makeDecl(const XStr &returnType,int forProxy=0, bool isStatic = false);
00640     virtual void genPythonDecls(XStr& ) {}
00641     virtual void genIndexDecls(XStr& ) {}
00642     virtual void genPythonDefs(XStr& ) {}
00643     virtual void genPythonStaticDefs(XStr&) {}
00644     virtual void genPythonStaticDocs(XStr&) {}
00645     virtual void lookforCEntry(CEntry *)  {}
00646 };
00647 
00648 /* List of members of a chare or group */
00649 class MemberList : public Printable {
00650     std::list<Member*> members;
00651   public:
00652     MemberList(Member *m, MemberList *n=0);
00653     void appendMember(Member *m);
00654     void print(XStr& str);
00655     void setChare(Chare *c);
00656     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
00657     void genDecls(XStr& str);
00658     void genIndexDecls(XStr& str);
00659     void genPythonDecls(XStr& str);
00660     void genDefs(XStr& str);
00661     void genReg(XStr& str);
00662     void preprocess();
00663 
00664     // DMK - Accel Support
00665     int genAccels_spe_c_funcBodies(XStr& str);
00666     void genAccels_spe_c_regFuncs(XStr& str);
00667     void genAccels_spe_c_callInits(XStr& str);
00668     void genAccels_spe_h_includes(XStr& str);
00669     void genAccels_spe_h_fiCountDefs(XStr& str);
00670     void genAccels_ppe_c_regFuncs(XStr& str);
00671 
00672     void genPythonDefs(XStr& str);
00673     void genPythonStaticDefs(XStr& str);
00674     void genPythonStaticDocs(XStr& str);
00675     void collectSdagCode(CParsedFile *pf, int& sdagPresent);
00676     virtual void lookforCEntry(CEntry *centry);
00677 };
00678 
00679 /* Chare or group is a templated entity */
00680 class Chare : public TEntity {
00681   public:
00682     enum { //Set these attribute bits in "attrib"
00683         CMIGRATABLE=1<<2,
00684         CPYTHON=1<<3,
00685         CCHARE=1<<9,                 // plain non-migratable chare
00686         CMAINCHARE=1<<10,
00687         CARRAY=1<<11,
00688         CGROUP=1<<12,
00689         CNODEGROUP=1<<13
00690     };
00691     typedef unsigned int attrib_t;
00692   protected:
00693     attrib_t attrib;
00694     int hasElement;//0-- no element type; 1-- has element type
00695     forWhom forElement;
00696     int hasSection; //1-- applies only to array section
00697 
00698     NamedType *type;
00699     MemberList *list;
00700     TypeList *bases; //Base classes used by proxy
00701     TypeList *bases_CBase; //Base classes used by CBase (or NULL)
00702     
00703     int entryCount;
00704     int hasSdagEntry;
00705     XStr sdagDefs;
00706 
00707     void genTypedefs(XStr& str);
00708     void genRegisterMethodDef(XStr& str);
00709     void sharedDisambiguation(XStr &str,const XStr &superclass);
00710   public:
00711     Chare(int ln, attrib_t Nattr,
00712         NamedType *t, TypeList *b=0, MemberList *l=0);
00713     void genProxyNames(XStr& str, const char *prefix, const char *middle, 
00714                         const char *suffix, const char *sep);
00715     void genIndexNames(XStr& str, const char *prefix, const char *middle, 
00716                         const char *suffix, const char *sep);
00717     XStr proxyName(int withTemplates=1); 
00718     XStr indexName(int withTemplates=1); 
00719     XStr indexList();
00720     XStr baseName(int withTemplates=1) const
00721     {
00722         XStr str;
00723         str<<type->getBaseName();
00724         if (withTemplates) str<<tvars();
00725         return str;
00726     }
00727     int  isTemplated(void) { return (templat!=0); }
00728     int  isMigratable(void) { return attrib&CMIGRATABLE; }
00729     int  isPython(void) { return attrib&CPYTHON; }
00730     int  isMainChare(void) {return attrib&CMAINCHARE;}
00731     int  isChare(void) {return attrib&CCHARE;}     // plain non-migratable chare
00732     int  isArray(void) {return attrib&CARRAY;}
00733     int  isGroup(void) {return attrib&CGROUP;}
00734     int  isNodeGroup(void) {return attrib&CNODEGROUP;}
00735     int  isForElement(void) const {return forElement==forIndividual;}
00736     int  isForSection(void) const {return forElement==forSection;}
00737     int  hasSdag() const { return hasSdagEntry; }
00738     void  setSdag(int f) { hasSdagEntry = f; }
00739     forWhom getForWhom(void) const {return forElement;}
00740     void print(XStr& str);
00741     void genDefs(XStr& str);
00742     void genReg(XStr& str);
00743     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
00744     void genDecls(XStr &str);
00745     void preprocess();
00746 
00747     // DMK - Accel Support
00748     int genAccels_spe_c_funcBodies(XStr& str) {
00749       int rtn = 0;
00750       if (list) { rtn += list->genAccels_spe_c_funcBodies(str); }
00751       return rtn;
00752     }
00753     void genAccels_spe_c_regFuncs(XStr& str) {
00754       if (list) { list->genAccels_spe_c_regFuncs(str); }
00755     }
00756     void genAccels_spe_c_callInits(XStr& str) {
00757       if (list) { list->genAccels_spe_c_callInits(str); }
00758     }
00759     void genAccels_spe_h_includes(XStr& str) {
00760       if (list) { list->genAccels_spe_h_includes(str); }
00761     }
00762     void genAccels_spe_h_fiCountDefs(XStr& str) {
00763       if (list) { list->genAccels_spe_h_fiCountDefs(str); }
00764     }
00765     void genAccels_ppe_c_regFuncs(XStr& str) {
00766       if (list) { list->genAccels_ppe_c_regFuncs(str); }
00767     }
00768 
00769     int nextEntry(void) {return entryCount++;}
00770     virtual void genSubDecls(XStr& str);
00771     void genPythonDecls(XStr& str);
00772     void genPythonDefs(XStr& str);
00773     virtual char *chareTypeName(void) {return (char *)"chare";}
00774     virtual char *proxyPrefix(void);
00775     virtual void genSubRegisterMethodDef(XStr& str) { (void)str; }
00776     void lookforCEntry(CEntry *centry);
00777 };
00778 
00779 class MainChare : public Chare {
00780   public:
00781     MainChare(int ln, attrib_t Nattr, 
00782         NamedType *t, TypeList *b=0, MemberList *l=0):
00783             Chare(ln, Nattr|CMAINCHARE, t,b,l) {}
00784     virtual char *chareTypeName(void) {return (char *) "mainchare";}
00785 };
00786 
00787 class Array : public Chare {
00788   protected:
00789     XStr indexSuffix;
00790     XStr indexType;//"CkArrayIndex"+indexSuffix;
00791   public:
00792     Array(int ln, attrib_t Nattr, NamedType *index,
00793         NamedType *t, TypeList *b=0, MemberList *l=0);
00794     virtual int is1D(void) {return indexSuffix==(const char*)"1D";}
00795     virtual const char* dim(void) {return indexSuffix.get_string_const();}
00796     virtual void genSubDecls(XStr& str);
00797     virtual char *chareTypeName(void) {return (char *) "array";}
00798 };
00799 
00800 class Group : public Chare {
00801   public:
00802     Group(int ln, attrib_t Nattr,
00803         NamedType *t, TypeList *b=0, MemberList *l=0);
00804     virtual void genSubDecls(XStr& str);
00805     virtual char *chareTypeName(void) {return (char *) "group";}
00806     virtual void genSubRegisterMethodDef(XStr& str);
00807 };
00808 
00809 class NodeGroup : public Group {
00810   public:
00811     NodeGroup(int ln, attrib_t Nattr,
00812         NamedType *t, TypeList *b=0, MemberList *l=0):
00813             Group(ln,Nattr|CNODEGROUP,t,b,l) {}
00814     virtual char *chareTypeName(void) {return (char *) "nodegroup";}
00815 };
00816 
00817 
00818 /****************** Messages ***************/
00819 class Message; // forward declaration
00820 
00821 class MsgVar {
00822  public:
00823   Type *type;
00824   const char *name;
00825   int cond;
00826   int array;
00827   MsgVar(Type *t, const char *n, int c, int a) : type(t), name(n), cond(c), array(a) { }
00828   Type *getType() { return type; }
00829   const char *getName() { return name; }
00830   int isConditional() { return cond; }
00831   int isArray() { return array; }
00832   void print(XStr &str) {str<<(isConditional()?"conditional ":"");type->print(str);str<<" "<<name<<(isArray()?"[]":"")<<";";}
00833 };
00834 
00835 class MsgVarList : public Printable {
00836  public:
00837   MsgVar *msg_var;
00838   MsgVarList *next;
00839   MsgVarList(MsgVar *mv, MsgVarList *n=0) : msg_var(mv), next(n) {}
00840   void print(XStr &str) {
00841     msg_var->print(str);
00842     str<<"\n";
00843     if(next) next->print(str);
00844   }
00845   int len(void) { return (next==0)?1:(next->len()+1); }
00846 };
00847 
00848 class Message : public TEntity {
00849     NamedType *type;
00850     MsgVarList *mvlist;
00851     void printVars(XStr& str) {
00852       if(mvlist!=0) {
00853         str << "{\n";
00854         mvlist->print(str);
00855         str << "}\n";
00856       }
00857     }
00858   public:
00859     Message(int l, NamedType *t, MsgVarList *mv=0)
00860       : type(t), mvlist(mv) 
00861       { line=l; setTemplate(0); }
00862     void print(XStr& str);
00863     void genDecls(XStr& str);
00864     void genDefs(XStr& str);
00865     void genReg(XStr& str);
00866 
00867     virtual const char *proxyPrefix(void) {return Prefix::Message;}
00868     void genAllocDecl(XStr& str);
00869     int numArrays(void) {
00870       if (mvlist==0) return 0;
00871       int count = 0;
00872       MsgVarList *mv = mvlist;
00873       for (int i=0; i<mvlist->len(); ++i, mv=mv->next) if (mv->msg_var->isArray()) count ++;
00874       return count;
00875     }
00876     int numConditional(void) {
00877       if (mvlist==0) return 0;
00878       int count = 0;
00879       MsgVarList *mv = mvlist;
00880       for (int i=0; i<mvlist->len(); ++i, mv=mv->next) if (mv->msg_var->isConditional()) count ++;
00881       return count;
00882     }
00883     int numVars(void) { return ((mvlist==0) ? 0 : mvlist->len()); }
00884 };
00885 
00886 
00887 
00888 
00889 
00890 /******************* Entry Point ****************/
00891 // Entry attributes
00892 #define STHREADED 0x01
00893 #define SSYNC     0x02
00894 #define SLOCKED   0x04
00895 #define SPURE     0x10
00896 #define SMIGRATE  0x20 //<- is magic migration constructor
00897 #define SCREATEHERE   0x40 //<- is a create-here-if-nonexistant
00898 #define SCREATEHOME   0x80 //<- is a create-at-home-if-nonexistant
00899 #define SIMMEDIATE    0x100 //<- is a immediate
00900 #define SNOKEEP       0x200
00901 #define SNOTRACE      0x400
00902 #define SSKIPSCHED    0x800 //<- is a message skipping charm scheduler
00903 #define SPYTHON       0x1000
00904 #define SINLINE       0x2000 //<- inline message
00905 #define SIGET         0x4000 
00906 #define SLOCAL        0x8000 //<- local message
00907 #define SACCEL        0x10000
00908 #define SMEM          0x20000
00909 #define SREDUCE       0x40000 // <- reduction target
00910 
00911 /* An entry construct */
00912 class Entry : public Member {
00913   private:
00914     int line,entryCount;
00915     int attribs;    
00916     Type *retType;
00917     Value *stacksize;
00918     const char *pythonDoc;
00919     
00920     XStr proxyName(void) {return container->proxyName();}
00921     XStr indexName(void) {return container->indexName();}
00922 
00923 //    friend class CParsedFile;
00924     int hasCallMarshall;
00925     void genCall(XStr &dest,const XStr &preCall, bool redn_wrapper=false);
00926 
00927     XStr epStr(bool isForRedn = false, bool templateCall = false);
00928     XStr epIdx(int fromProxy=1, bool isForRedn = false);
00929     XStr epRegFn(int fromProxy=1, bool isForRedn = false);
00930     XStr chareIdx(int fromProxy=1);
00931     void genEpIdxDecl(XStr& str);
00932     void genEpIdxDef(XStr& str);
00933     
00934     void genChareDecl(XStr& str);
00935     void genChareStaticConstructorDecl(XStr& str);
00936     void genChareStaticConstructorDefs(XStr& str);
00937     void genChareDefs(XStr& str);
00938     
00939     void genArrayDefs(XStr& str);
00940     void genArrayStaticConstructorDecl(XStr& str);
00941     void genArrayStaticConstructorDefs(XStr& str);
00942     void genArrayDecl(XStr& str);
00943     
00944     void genGroupDecl(XStr& str);
00945     void genGroupStaticConstructorDecl(XStr& str);
00946     void genGroupStaticConstructorDefs(XStr& str);
00947     void genGroupDefs(XStr& str);
00948     
00949     void genPythonDecls(XStr& str);
00950     void genPythonDefs(XStr& str);
00951     void genPythonStaticDefs(XStr& str);
00952     void genPythonStaticDocs(XStr& str);
00953 
00954     // DMK - Accel Support
00955     void genAccelFullParamList(XStr& str, int makeRefs);
00956     void genAccelFullCallList(XStr& str);
00957     void genAccelIndexWrapperDecl_general(XStr& str);
00958     void genAccelIndexWrapperDef_general(XStr& str);
00959     void genAccelIndexWrapperDecl_spe(XStr& str);
00960     void genAccelIndexWrapperDef_spe(XStr& str);
00961     int genAccels_spe_c_funcBodies(XStr& str);
00962     void genAccels_spe_c_regFuncs(XStr& str);
00963     void genAccels_ppe_c_regFuncs(XStr& str);
00964 
00965     XStr paramType(int withDefaultVals,int withEO=0,int useConst=1);
00966     XStr paramComma(int withDefaultVals,int withEO=0);
00967     XStr eo(int withDefaultVals,int priorComma=1);
00968     XStr syncReturn(void);
00969     XStr marshallMsg(void);
00970     XStr callThread(const XStr &procName,int prependEntryName=0);
00971   public:
00972     XStr *label;
00973     char *name;
00974     TParamList *targs;
00975 
00976     // SDAG support
00977     SdagConstruct *sdagCon;
00978     TList<CStateVar *> *stateVars;
00979     TList<CStateVar *> *stateVarsChildren;
00980     TList<CStateVar *> estateVars;
00981     CEntry *entryPtr;
00982     const char *intExpr;
00983     ParamList *param;
00984     ParamList *connectParam;
00985     int isConnect;
00986     int isWhenEntry;
00987 
00988     // DMK - Accel Support
00989     ParamList* accelParam;
00990     XStr* accelCodeBody;
00991     XStr* accelCallbackName;
00992     void setAccelParam(ParamList* apl) { accelParam = apl; }
00993     void setAccelCodeBody(XStr* acb) { accelCodeBody = acb; }
00994     void setAccelCallbackName(XStr* acbn) { accelCallbackName = acbn; }
00995 
00996     // DMK - Accel Support
00997     int accel_numScalars;
00998     int accel_numArrays;
00999     int accel_dmaList_numReadOnly;
01000     int accel_dmaList_numReadWrite;
01001     int accel_dmaList_numWriteOnly;
01002     int accel_dmaList_scalarNeedsWrite;
01003 
01004     Entry(int l, int a, Type *r, const char *n, ParamList *p, Value *sz=0, SdagConstruct *sc =0, const char *e=0, int connect=0, ParamList *connectPList =0);
01005     void setChare(Chare *c);
01006     int isConnectEntry(void) { return isConnect; }
01007     int paramIsMarshalled(void) { return param->isMarshalled(); }
01008     int getStackSize(void) { return (stacksize ? stacksize->getIntVal() : 0); }
01009     int isThreaded(void) { return (attribs & STHREADED); }
01010     int isSync(void) { return (attribs & SSYNC); }
01011     int isIget(void) { return (attribs & SIGET); }
01012     int isConstructor(void) { return !strcmp(name, container->baseName(0).get_string());}
01013     int isExclusive(void) { return (attribs & SLOCKED); }
01014     int isImmediate(void) { return (attribs & SIMMEDIATE); }
01015     int isSkipscheduler(void) { return (attribs & SSKIPSCHED); }
01016     int isInline(void) { return attribs & SINLINE; }
01017     int isLocal(void) { return attribs & SLOCAL; }
01018     int isCreate(void) { return (attribs & SCREATEHERE)||(attribs & SCREATEHOME); }
01019     int isCreateHome(void) { return (attribs & SCREATEHOME); }
01020     int isCreateHere(void) { return (attribs & SCREATEHERE); }
01021     int isPython(void) { return (attribs & SPYTHON); }
01022     int isNoTrace(void) { return (attribs & SNOTRACE); }
01023     int isNoKeep(void) { return (attribs & SNOKEEP); }
01024     int isSdag(void) { return (sdagCon!=0); }
01025 
01026     // DMK - Accel support
01027     int isAccel(void) { return (attribs & SACCEL); }
01028 
01029     int isMemCritical(void) { return (attribs & SMEM); }
01030     int isReductionTarget(void) { return (attribs & SREDUCE); }
01031 
01032     void print(XStr& str);
01033     void genIndexDecls(XStr& str);
01034     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
01035     void genDecls(XStr& str);
01036     void genDefs(XStr& str);
01037     void genReg(XStr& str);
01038     XStr genRegEp(bool isForRedn = false);
01039     void preprocess();
01040     char *getEntryName() { return name; }
01041     void generateEntryList(TList<CEntry*>&, SdagConstruct *);
01042     void collectSdagCode(CParsedFile *pf, int& sdagPresent);
01043     void propagateState(int);
01044     void lookforCEntry(CEntry *centry);
01045 };
01046 
01047 class EntryList {
01048   public:
01049     Entry *entry;
01050     EntryList *next;
01051     EntryList(Entry *e,EntryList *elist=NULL):
01052         entry(e), next(elist) {}
01053     void generateEntryList(TList<CEntry*>&, SdagConstruct *);
01054 };
01055 
01056 
01057 /******************** AccelBlock : Block of code for accelerator **********************/
01058 class AccelBlock : public Construct {
01059 
01060  protected:
01061 
01062   XStr* code;
01063 
01064  private:
01065 
01066   void outputCode(XStr& str) {
01067     if (code != NULL) {
01068       str << "\n#ifndef CK_TEMPLATES_ONLY\n"
01069           << "/***** Accel_Block Start *****/\n"
01070           << (*(code))
01071           << "\n/***** Accel_Block End *****/\n"
01072           << "#endif /*CK_TEMPLATES_ONLY*/\n\n";
01073     }
01074   }
01075 
01076  public:
01077 
01079   AccelBlock(int l, XStr* c) { line = l; code = c; }
01080   ~AccelBlock() { delete code; }
01081 
01083   void print(XStr& str) { (void)str; }
01084 
01086   void genDefs(XStr& str) { outputCode(str); }
01087 
01089   int genAccels_spe_c_funcBodies(XStr& str) { outputCode(str); return 0; }
01090 };
01091 
01092 
01093 /****************** Modules, etc. ****************/
01094 class Module : public Construct {
01095     int _isMain;
01096     const char *name;
01097     
01098   public:
01099     ConstructList *clist;
01100     Module(int l, const char *n, ConstructList *c) : name(n), clist(c) {
01101             line = l;
01102             _isMain=0;
01103             if (clist!=NULL) clist->setModule(this);
01104     }
01105     void print(XStr& str);
01106     void generate();
01107     void setModule();
01108     void prependConstruct(Construct *c) { clist = new ConstructList(-1, c, clist); }
01109     void preprocess();
01110     void genDepend(const char *cifile);
01111     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
01112     void genDecls(XStr& str);
01113     void genDefs(XStr& str);
01114     void genReg(XStr& str);
01115     void setMain(void) { _isMain = 1; }
01116     int isMain(void) { return _isMain; }
01117 
01118     // DMK - Accel Support
01119     int genAccels_spe_c_funcBodies(XStr& str);
01120     void genAccels_spe_c_regFuncs(XStr& str);
01121     void genAccels_spe_c_callInits(XStr& str);
01122     void genAccels_spe_h_includes(XStr& str);
01123     void genAccels_spe_h_fiCountDefs(XStr& str);
01124     void genAccels_ppe_c_regFuncs(XStr& str);
01125 };
01126 
01127 class ModuleList : public Printable {
01128     std::list<Module*> modules;
01129   public:
01130     int line;
01131     ModuleList(int l, Module *m, ModuleList *n=0) : line(l)
01132         {
01133             modules.push_back(m);
01134             if (n)
01135                 modules.insert(modules.end(),
01136                                n->modules.begin(), n->modules.end());
01137         }
01138     void print(XStr& str);
01139     void generate();
01140     void preprocess();
01141     void genDepends(std::string ciFileBaseName);
01142 };
01143 
01144 class Readonly : public Member {
01145     int msg; // is it a readonly var(0) or msg(1) ?
01146     Type *type;
01147     const char *name;
01148     ValueList *dims;
01149     XStr qName(void) const { /*Return fully qualified name*/
01150       XStr ret;
01151       if(container) ret<<container->baseName()<<"::";
01152       ret<<name;
01153       return ret;
01154     }
01155   public:
01156     Readonly(int l, Type *t, const char *n, ValueList* d, int m=0)
01157             : msg(m), type(t), name(n)
01158             { line=l; dims=d; setChare(0); }
01159     void print(XStr& str);
01160     void genDecls(XStr& str);
01161     void genIndexDecls(XStr& str);
01162     void genDefs(XStr& str);
01163     void genReg(XStr& str);
01164 };
01165 
01166 class InitCall : public Member {
01167 
01168     const char *name; //Name of subroutine to call
01169     int isNodeCall;
01170 
01171     // DMK - Accel Support
01172     int isAccelFlag;
01173 
01174 public:
01175 
01176     InitCall(int l, const char *n, int nodeCall);
01177     void print(XStr& str);
01178     void genReg(XStr& str);
01179 
01180     // DMK - Accel Support
01181     void genAccels_spe_c_callInits(XStr& str);
01182 
01183     void setAccel() { isAccelFlag = 1; }
01184     void clearAccel() { isAccelFlag = 0; }
01185     int isAccel() { return isAccelFlag; }
01186 };
01187 
01188 class PUPableClass : public Member {
01189     NamedType* type;
01190     PUPableClass *next; //Linked-list of PUPable classes
01191 public:
01192     PUPableClass(int l, NamedType* type_, PUPableClass *next_);
01193     void print(XStr& str);
01194     void genDefs(XStr& str);
01195     void genReg(XStr& str);
01196 
01197     // DMK - Accel Support
01198     int genAccels_spe_c_funcBodies(XStr& str) {
01199       int rtn=0;
01200       if (next) { rtn += next->genAccels_spe_c_funcBodies(str); }
01201       return rtn;
01202     }
01203     void genAccels_spe_c_regFuncs(XStr& str) {
01204       if (next) { next->genAccels_spe_c_regFuncs(str); }
01205     }
01206     void genAccels_spe_c_callInits(XStr& str) {
01207       if (next) { next->genAccels_spe_c_callInits(str); }
01208     }
01209     void genAccels_spe_h_includes(XStr& str) {
01210       if (next) { next->genAccels_spe_h_includes(str); }
01211     }
01212     void genAccels_spe_h_fiCountDefs(XStr& str) {
01213       if (next) { next->genAccels_spe_h_fiCountDefs(str); }
01214     }
01215     void genAccels_ppe_c_regFuncs(XStr& str) {
01216       if (next) { next->genAccels_ppe_c_regFuncs(str); }
01217     }
01218 };
01219 
01220 class IncludeFile : public Member {
01221     const char *name; //Name of include file
01222 public:
01223     IncludeFile(int l, const char *name_);
01224     void print(XStr& str);
01225     void genDecls(XStr& str);
01226 };
01227 
01228 class ClassDeclaration : public Member {
01229     const char *name; //Name of class 
01230 public:
01231     ClassDeclaration(int l, const char *name_);
01232     void print(XStr& str);
01233     void genDecls(XStr& str);
01234 };
01235 
01236 
01237 /******************* Structured Dagger Constructs ***************/
01238 class SdagConstruct { 
01239 private:
01240   void generateWhen(XStr& decls, XStr& defs, Entry* entry);
01241   void generateOverlap(XStr& decls, XStr& defs, Entry* entry);
01242   void generateWhile(XStr& decls, XStr& defs, Entry* entry);
01243   void generateFor(XStr& decls, XStr& defs, Entry* entry);
01244   void generateIf(XStr& decls, XStr& defs, Entry* entry);
01245   void generateElse(XStr& decls, XStr& defs, Entry* entry);
01246   void generateForall(XStr& decls, XStr& defs, Entry* entry);
01247   void generateOlist(XStr& decls, XStr& defs, Entry* entry);
01248   void generateSdagEntry(XStr& decls, XStr& defs, Entry *entry);
01249   void generateSlist(XStr& decls, XStr& defs, Entry* entry);
01250   void generateAtomic(XStr& decls, XStr& defs, Entry* entry);
01251   void generateForward(XStr& decls, XStr& defs, Entry* entry);
01252   void generateConnect(XStr& decls, XStr& defs, Entry* entry);
01253   void generateCall(XStr& defs, TList<CStateVar*>& args,
01254                     const char* name, const char* nameSuffix = 0);
01255 
01256   void generateTraceBeginCall(XStr& defs);          // for trace
01257   void generateBeginTime(XStr& defs);               //for Event Bracket
01258   void generateEventBracket(XStr& defs, int eventType);     //for Event Bracket
01259   void generateListEventBracket(XStr& defs, int eventType);
01260 public:
01261   int nodeNum;
01262   XStr *label;
01263   XStr *counter;
01264   EToken type;
01265   char nameStr[128];
01266   XStr *traceName;      
01267   TList<SdagConstruct *> *constructs;
01268   TList<SdagConstruct *> *publishesList;
01269   TList<CStateVar *> *stateVars;
01270   TList<CStateVar *> *stateVarsChildren;
01271   SdagConstruct *next;
01272   ParamList *param;
01273   XStr *text;
01274   XStr *connectEntry;
01275   int nextBeginOrEnd;
01276   EntryList *elist;
01277   SdagConstruct *con1, *con2, *con3, *con4;
01278   SdagConstruct(EToken t, SdagConstruct *construct1);
01279 
01280   SdagConstruct(EToken t, SdagConstruct *construct1, SdagConstruct *aList);
01281 
01282   SdagConstruct(EToken t, XStr *txt, SdagConstruct *c1, SdagConstruct *c2, SdagConstruct *c3,
01283               SdagConstruct *c4, SdagConstruct *constructAppend, EntryList *el);
01284 
01285  SdagConstruct(EToken t, const char *str) : type(t), traceName(NULL), con1(0), con2(0), con3(0), con4(0)
01286                 { text = new XStr(str); constructs = new TList<SdagConstruct*>(); 
01287                   publishesList = new TList<SdagConstruct*>(); }
01288                                              
01289  
01290   SdagConstruct(EToken t) : type(t), traceName(NULL), con1(0), con2(0), con3(0), con4(0) 
01291                 { publishesList = new TList<SdagConstruct*>();
01292                   constructs = new TList<SdagConstruct*>(); }
01293 
01294   SdagConstruct(EToken t, XStr *txt) : type(t), traceName(NULL), text(txt), con1(0), con2(0), con3(0), con4(0) 
01295                 { publishesList = new TList<SdagConstruct*>();
01296                   constructs = new TList<SdagConstruct*>();  }
01297   SdagConstruct(EToken t, const char *entryStr, const char *codeStr, ParamList *pl);
01298   void numberNodes(void);
01299   void labelNodes(void);
01300   void generateConnectEntryList(TList<SdagConstruct*>&);
01301   void generateConnectEntries(XStr&);
01302   void generateEntryList(TList<CEntry*>&, SdagConstruct *);
01303   void propagateState(int);
01304   void propagateState(TList<CStateVar*>&, TList<CStateVar*>&, TList<SdagConstruct*>&, int);
01305   void generateCode(XStr& decls, XStr& defs, Entry *entry);
01306   void setNext(SdagConstruct *, int);
01307 
01308   // for trace
01309   void generateTrace();          
01310   void generateRegisterEp(XStr& defs);
01311   void generateTraceEp(XStr& decls, XStr& defs, Chare* chare);
01312   static void generateTraceEndCall(XStr& defs);
01313   static void generateTlineEndCall(XStr& defs);
01314   static void generateBeginExec(XStr& defs, const char *name);
01315   static void generateEndExec(XStr& defs);
01316   static void generateEndSeq(XStr& defs);
01317   static void generateDummyBeginExecute(XStr& defs);
01318 
01319 };
01320 
01321 SdagConstruct *buildAtomic(const char* code,
01322                            SdagConstruct *pub_list,
01323                            const char *trace_name);
01324 
01325 extern void RemoveSdagComments(char *);
01326 
01327 }
01328 
01329 #endif
xlat-i/xi-symbol.h
