sdag: fix bug generating references in SDAG entry methods
[charm.git] / src / xlat-i / xi-symbol.h
1 #ifndef _SYMBOL_H
2 #define _SYMBOL_H
3
4 #include "xi-util.h"
5 #include "EToken.h"
6 #include "CEntry.h"
7 #include "sdag-globals.h"
8
9 #include <iostream>
10 #include <stdio.h>
11 #include <string.h>
12 #include <stdlib.h>
13 #include <list>
14
15
16 namespace xi {
17
18 class Chare;
19 class CParsedFile;
20
21 extern void generateSignature(XStr& decls, XStr& defs,
22                               const Entry* entry, bool declareStatic,
23                               const char* returnType, const XStr* name, bool isEnd,
24                               std::list<CStateVar*>* params);
25 extern void generateSignature(XStr& decls, XStr& defs,
26                               const Chare* chare, bool declareStatic,
27                               const char* returnType, const XStr* name, bool isEnd,
28                               std::list<CStateVar*>* params);
29 extern void endMethod(XStr& op);
30
31 class CStateVar;
32
33 /******************* Utilities ****************/
34
35 class Prefix {
36 public:
37   static const char *Proxy;
38   static const char *ProxyElement;
39   static const char *ProxySection;
40   static const char *Message;
41   static const char *Index;
42   static const char *Python;
43 };
44
45 typedef enum {
46   forAll=0,forIndividual=1,forSection=2,forPython=3,forIndex=-1
47 } forWhom;
48
49 class Chare;//Forward declaration
50 class Message;
51 class TParamList;
52 extern int fortranMode;
53 extern int internalMode;
54 extern const char *cur_file;
55 void die(const char *why,int line=-1);
56
57 class Value : public Printable {
58   private:
59     int factor;
60     const char *val;
61   public:
62     Value(const char *s);
63     void print(XStr& str) { str << val; }
64     int getIntVal(void);
65 };
66
67 class ValueList : public Printable {
68   private:
69     Value *val;
70     ValueList *next;
71   public:
72     ValueList(Value* v, ValueList* n=0) : val(v), next(n) {}
73     void print(XStr& str) {
74       if(val) {
75         str << "["; val->print(str); str << "]";
76       }
77       if(next)
78         next->print(str);
79     }
80     void printValue(XStr& str) {
81       if(val) {
82         val->print(str);
83       }
84       if(next) {
85           std::cout << "Unsupported type\n";
86           abort();
87       }
88     }
89 };
90
91 class Module;
92
93 class Construct : public Printable {
94   protected:
95     int external;
96   public:
97     int line;
98     Module *containerModule;
99     Construct() {external=0;line=-1;}
100     void setExtern(int &e) { external = e; }
101     void setModule(Module *m) { containerModule = m; }
102     virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent)
103     {
104       (void)declstr; (void)defstr; (void)defconstr; (void)connectPresent;
105     }
106     virtual void genDecls(XStr& str) { (void)str; }
107     virtual void genDefs(XStr& str) { (void)str; }
108     virtual void genReg(XStr& str) { (void)str; }
109     virtual void preprocess() { }
110     virtual void check() { }
111
112     // DMK - Accel Support
113     virtual int genAccels_spe_c_funcBodies(XStr& str) { (void)str; return 0; }
114     virtual void genAccels_spe_c_regFuncs(XStr& str) { (void)str; }
115     virtual void genAccels_spe_c_callInits(XStr& str) { (void)str; }
116     virtual void genAccels_spe_h_includes(XStr& str) { (void)str; }
117     virtual void genAccels_spe_h_fiCountDefs(XStr& str) { (void)str; }
118     virtual void genAccels_ppe_c_regFuncs(XStr& str) { (void)str; }
119 };
120
121 class ConstructList : public Construct {
122     std::list<Construct*> constructs;
123   public:
124     ConstructList(int l, Construct *c, ConstructList *n=0);
125     void setExtern(int e);
126     void setModule(Module *m);
127     void print(XStr& str);
128     void check();
129     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
130     void genDecls(XStr& str);
131     void genDefs(XStr& str);
132     void genReg(XStr& str);
133     void preprocess();
134
135     // DMK - Accel Support
136     int genAccels_spe_c_funcBodies(XStr& str);
137     void genAccels_spe_c_regFuncs(XStr& str);
138     void genAccels_spe_c_callInits(XStr& str);
139     void genAccels_spe_h_includes(XStr& str);
140     void genAccels_spe_h_fiCountDefs(XStr& str);
141     void genAccels_ppe_c_regFuncs(XStr& str);
142 };
143
144 /*********************** Type System **********************/
145 class Type : public Printable {
146   public:
147     virtual void print(XStr&) = 0;
148     virtual int isVoid(void) const {return 0;}
149     virtual int isBuiltin(void) const { return 0; }
150     virtual int isMessage(void) const {return 0;}
151     virtual int isTemplated(void) const { return 0; }
152     virtual int isPointer(void) const {return 0;}
153     virtual int isNamed(void) const { return 0; }
154     virtual int isCkArgMsgPtr(void) const {return 0;}
155     virtual int isCkArgMsg(void) const {return 0;}
156     virtual int isCkMigMsgPtr(void) const {return 0;}
157     virtual int isCkMigMsg(void) const {return 0;}
158     virtual int isReference(void) const {return 0;}
159     virtual Type *deref(void) {return this;}
160     virtual const char *getBaseName(void) const = 0;
161     virtual const char *getScope(void) const = 0;
162     virtual int getNumStars(void) const {return 0;}
163     virtual void genProxyName(XStr &str,forWhom forElement);
164     virtual void genIndexName(XStr &str);
165     virtual void genMsgProxyName(XStr& str);
166     XStr proxyName(forWhom w)
167         {XStr ret; genProxyName(ret,w); return ret;}
168     XStr indexName(void) 
169         {XStr ret; genIndexName(ret); return ret;}
170     XStr msgProxyName(void) 
171         {XStr ret; genMsgProxyName(ret); return ret;}
172     virtual void printVar(XStr &str, char *var) {print(str); str<<" "; str<<var;}
173     int operator==(const Type &tp) const {
174       return  (strcmp(getBaseName(), tp.getBaseName())==0);
175     }
176     virtual ~Type() { }
177 };
178
179 class BuiltinType : public Type {
180   private:
181     char *name;
182   public:
183     BuiltinType(const char *n) : name((char *)n) {}
184     int isBuiltin(void) const {return 1;}
185     void print(XStr& str) { str << name; }
186     int isVoid(void) const { return !strcmp(name, "void"); }
187     int isInt(void) const { return !strcmp(name, "int"); }
188     const char *getBaseName(void) const { return name; }
189     const char *getScope(void) const { return NULL; }
190 };
191
192 class NamedType : public Type {
193   private:
194     const char* name;
195     const char* scope;
196     TParamList *tparams;
197   public:
198     NamedType(const char* n, TParamList* t=0, const char* scope_=NULL)
199        : name(n), scope(scope_), tparams(t) {}
200     int isTemplated(void) const { return (tparams!=0); }
201     int isCkArgMsg(void) const {return 0==strcmp(name,"CkArgMsg");}
202     int isCkMigMsg(void) const {return 0==strcmp(name,"CkMigrateMessage");}
203     void print(XStr& str);
204     int isNamed(void) const {return 1;}
205     virtual const char *getBaseName(void) const { return name; }
206     virtual const char *getScope(void) const { return scope; }
207     virtual void genProxyName(XStr& str,forWhom forElement);
208     virtual void genIndexName(XStr& str);
209     virtual void genMsgProxyName(XStr& str);
210 };
211
212 class PtrType : public Type {
213   private:
214     Type *type;
215     int numstars; // level of indirection
216   public:
217     PtrType(Type *t) : type(t), numstars(1) {}
218     int isPointer(void) const {return 1;}
219     int isCkArgMsgPtr(void) const {return numstars==1 && type->isCkArgMsg();}
220     int isCkMigMsgPtr(void) const {return numstars==1 && type->isCkMigMsg();}
221     int isMessage(void) const {return numstars==1 && !type->isBuiltin();}
222     void indirect(void) { numstars++; }
223     int getNumStars(void) const {return numstars; }
224     void print(XStr& str);
225     Type* deref(void) { return type; }
226     const char *getBaseName(void) const { return type->getBaseName(); }
227     const char *getScope(void) const { return NULL; }
228     virtual void genMsgProxyName(XStr& str) { 
229       if(numstars != 1) {
230         die("too many stars-- entry parameter must have form 'MTYPE *msg'"); 
231       } else {
232         type->genMsgProxyName(str);
233       }
234     }
235 };
236
237 class ReferenceType : public Type {
238   private:
239     Type *referant;
240   public:
241     ReferenceType(Type *t) : referant(t) {}
242     int isReference(void) const {return 1;}
243     void print(XStr& str) {str<<referant<<" &";}
244     virtual Type *deref(void) {return referant;}
245     const char *getBaseName(void) const { return referant->getBaseName(); }
246     const char *getScope(void) const { return NULL; }
247 };
248
249 //This is used as a list of base classes
250 class TypeList : public Printable {
251     Type *type;
252     TypeList *next;
253   public:
254     TypeList(Type *t, TypeList *n=0) : type(t), next(n) {}
255     ~TypeList() { delete type; delete next; }
256     int length(void) const;
257     Type *getFirst(void) {return type;}
258     void print(XStr& str);
259     void genProxyNames(XStr& str, const char *prefix, const char *middle, 
260                         const char *suffix, const char *sep, forWhom forElement);
261 };
262
263 /**************** Parameter types & lists (for marshalling) ************/
264 class Parameter {
265     Type *type;
266     const char *name; /*The name of the variable, if any*/
267     const char *given_name; /*The name of the msg in ci file, if any*/
268     const char *arrLen; /*The expression for the length of the array;
269                          NULL if not an array*/
270     Value *val; /*Initial value, if any*/
271     int line;
272     int byReference; //Fake a pass-by-reference (for efficiency)
273     int conditional; //If the parameter is conditionally packed
274
275     // DMK - Added field for accelerator options
276     int accelBufferType;
277     XStr* accelInstName;
278
279     friend class ParamList;
280     void pup(XStr &str);
281     void copyPtr(XStr &str);
282     void marshallArraySizes(XStr &str);
283     void marshallArrayData(XStr &str);
284     void beginUnmarshall(XStr &str);
285     void unmarshallArrayData(XStr &str);
286     void pupAllValues(XStr &str);
287   public:
288     Parameter(int Nline,Type *Ntype,const char *Nname=0,
289         const char *NarrLen=0,Value *Nvalue=0);
290     void setConditional(int c) { conditional = c; if (c) byReference = false; };
291     void print(XStr &str,int withDefaultValues=0,int useConst=1);
292     void printAddress(XStr &str);
293     void printValue(XStr &str);
294     int isMessage(void) const {return type->isMessage();}
295     int isVoid(void) const {return type->isVoid();}
296     int isCkArgMsgPtr(void) const {return type->isCkArgMsgPtr();}
297     int isCkMigMsgPtr(void) const {return type->isCkMigMsgPtr();}
298     int isArray(void) const {return arrLen!=NULL;}
299     int isConditional(void) const {return conditional;}
300     Type *getType(void) {return type;}
301     const char *getArrayLen(void) const {return arrLen;}
302     const char *getGivenName(void) const {return given_name;}
303     const char *getName(void) const {return name;}
304     void printMsg(XStr& str) {
305       type->print(str);
306       if(given_name!=0)
307         str <<given_name;
308     }
309     int operator==(const Parameter &parm) const {
310       return *type == *parm.type;
311     }
312
313     // DMK - Added for accelerator options
314     public:
315     enum {
316       ACCEL_BUFFER_TYPE_UNKNOWN   = 0,
317       ACCEL_BUFFER_TYPE_MIN       = 1,
318       ACCEL_BUFFER_TYPE_READWRITE = 1,
319       ACCEL_BUFFER_TYPE_READONLY  = 2,
320       ACCEL_BUFFER_TYPE_WRITEONLY = 3,
321       ACCEL_BUFFER_TYPE_MAX       = 3
322     };
323     void setAccelBufferType(int abt) {
324       accelBufferType = ((abt < ACCEL_BUFFER_TYPE_MIN || abt > ACCEL_BUFFER_TYPE_MAX) ? (ACCEL_BUFFER_TYPE_UNKNOWN) : (abt));
325     }
326     int getAccelBufferType() { return accelBufferType; }
327     void setAccelInstName(XStr* ain) { accelInstName = ain; }
328     XStr* getAccelInstName(void) { return accelInstName; }
329
330 };
331 class ParamList {
332     typedef int (Parameter::*pred_t)(void) const;
333     int orEach(pred_t f);
334     typedef void (Parameter::*fn_t)(XStr &str);
335     void callEach(fn_t f,XStr &str);
336     bool manyPointers;
337   public:
338     Parameter *param;
339     ParamList *next;
340     ParamList(ParamList *pl) : manyPointers(false), param(pl->param), next(pl->next) {}
341     ParamList(Parameter *Nparam,ParamList *Nnext=NULL)
342         :param(Nparam), next(Nnext) { 
343           manyPointers = false;
344           if(next != NULL && (param->isMessage() || next->isMessage())){
345             manyPointers = true;
346           }
347     }
348     void print(XStr &str,int withDefaultValues=0,int useConst=1);
349     void printAddress(XStr &str);
350     void printValue(XStr &str);
351     int isNamed(void) const {return param->type->isNamed();}
352     int isBuiltin(void) const {return param->type->isBuiltin();}
353     int isMessage(void) const {
354         return (next==NULL) && param->isMessage();
355     }
356     const char *getArrayLen(void) const {return param->getArrayLen();}
357     int isArray(void) const {return param->isArray();}
358     int isReference(void) const {return param->type->isReference() || param->byReference;}
359     int isVoid(void) const {
360         return (next==NULL) && param->isVoid();
361     }
362     int isPointer(void) const {return param->type->isPointer();}
363     const char *getGivenName(void) const {return param->getGivenName();}
364     int isMarshalled(void) const {
365         return !isVoid() && !isMessage();
366     }
367     int isCkArgMsgPtr(void) const {
368         return (next==NULL) && param->isCkArgMsgPtr();
369     }
370     int isCkMigMsgPtr(void) const {
371         return (next==NULL) && param->isCkMigMsgPtr();
372     }
373     int getNumStars(void) const {return param->type->getNumStars(); }
374     const char *getBaseName(void) {
375         return param->type->getBaseName();
376     }
377     void genMsgProxyName(XStr &str) {
378         param->type->genMsgProxyName(str);
379     }
380     void printMsg(XStr& str) {
381         ParamList *pl;
382         param->printMsg(str);
383         pl = next;
384         while (pl != NULL)
385         {
386            str <<", ";
387            pl->param->printMsg(str);
388            pl = pl->next;
389         } 
390     }
391     void preprocess();
392     int hasConditional();
393     void marshall(XStr &str, XStr &entry);
394     void beginUnmarshall(XStr &str);
395     void beginRednWrapperUnmarshall(XStr &str);
396     void unmarshall(XStr &str, int isFirst=1);
397     void unmarshallAddress(XStr &str, int isFirst=1);
398     void pupAllValues(XStr &str);
399     void endUnmarshall(XStr &str);
400     int operator==(const ParamList &plist) const {
401       if (!(*param == *(plist.param))) return 0;
402       if (!next && !plist.next) return 1;
403       if (!next || !plist.next) return 0;
404       return *next ==  *plist.next;
405     }
406     void checkParamList();
407 };
408
409 class FuncType : public Type {
410   private:
411     Type *rtype;
412     const char *name;
413     ParamList *params;
414   public:
415     FuncType(Type* r, const char* n, ParamList* p)
416         :rtype(r),name(n),params(p) {}
417     void print(XStr& str) { 
418       rtype->print(str);
419       str << "(*" << name << ")(";
420       if(params)
421         params->print(str);
422     }
423     const char *getBaseName(void) const { return name; }
424     const char *getScope(void) const { return NULL; }
425 };
426
427 /****************** Template Support **************/
428 /* Template Instantiation Parameter */
429 class TParam : public Printable {
430   public:
431     virtual void genSpec(XStr& str)=0;
432 };
433
434 /* List of Template Instantiation parameters */
435 class TParamList : public Printable {
436     TParam *tparam;
437     TParamList *next;
438   public:
439     TParamList(TParam *t, TParamList *n=0) : tparam(t), next(n) {}
440     void print(XStr& str);
441     void genSpec(XStr& str);
442     std::string to_string();
443 };
444
445 /* A type instantiation parameter */
446 class TParamType : public TParam {
447   Type *type;
448   public:
449     TParamType(Type *t) : type(t) {}
450     void print(XStr& str) { type->print(str); }
451     void genSpec(XStr& str) { type->print(str); }
452 };
453
454 /* A Value instantiation parameter */
455 class TParamVal : public TParam {
456     const char *val;
457   public:
458     TParamVal(const char *v) : val(v) {}
459     void print(XStr& str) { str << val; }
460     void genSpec(XStr& str) { str << val; }
461 };
462
463 class Scope : public Construct {
464   protected:
465     const char* name_;
466     ConstructList* contents_;
467   public:
468     Scope(const char* name, ConstructList* contents) : name_(name), contents_(contents) {}
469     virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent) {
470         contents_->genPub(declstr, defstr, defconstr, connectPresent);
471     }
472     virtual void genDecls(XStr& str) {
473         str << "namespace " << name_ << " {\n";
474         contents_->genDecls(str);
475         str << "} // namespace " << name_ << "\n";
476     }
477     virtual void genDefs(XStr& str) {
478         str << "namespace " << name_ << " {\n";
479         contents_->genDefs(str);
480         str << "} // namespace " << name_ << "\n";
481     }
482     virtual void genReg(XStr& str) {
483         str << "using namespace " << name_ << ";\n";
484         contents_->genReg(str);
485     }
486     virtual void preprocess() {
487         contents_->preprocess();
488     }
489     virtual void print(XStr& str) {
490         str << "namespace " << name_ << "{\n";
491         contents_->print(str);
492         str << "} // namespace " << name_ << "\n";
493     }
494     void check();
495
496     // DMK - Accel Support
497     virtual int genAccels_spe_c_funcBodies(XStr& str) {
498       return contents_->genAccels_spe_c_funcBodies(str);
499     }
500     virtual void genAccels_spe_c_regFuncs(XStr& str) {
501       contents_->genAccels_spe_c_regFuncs(str);
502     }
503     virtual void genAccels_spe_c_callInits(XStr& str) {
504       contents_->genAccels_spe_c_callInits(str);
505     }
506     virtual void genAccels_spe_h_includes(XStr& str) {
507       contents_->genAccels_spe_h_includes(str);
508     }
509     virtual void genAccels_spe_h_fiCountDefs(XStr& str) {
510       contents_->genAccels_spe_h_fiCountDefs(str);
511     }
512     virtual void genAccels_ppe_c_regFuncs(XStr& str) {
513       contents_->genAccels_ppe_c_regFuncs(str);
514     }
515 };
516
517 class UsingScope : public Construct {
518   protected:
519     const char* name_;
520     bool symbol_;
521   public:
522     UsingScope(const char* name, bool symbol=false) : name_(name), symbol_(symbol) {}
523     virtual void genDecls(XStr& str) {
524         str << "using ";
525         if (!symbol_) str << "namespace ";
526         str << name_ << ";\n";
527     }
528     virtual void print(XStr& str) {
529         str << "using ";
530         if (!symbol_) str << "namespace ";
531         str << name_ << ";\n";
532     }
533 };
534
535
536 /* A template construct */
537 class TVarList;
538 class TEntity;
539
540 class Template : public Construct {
541     TVarList *tspec;
542     TEntity *entity;
543   public:
544     Template(TVarList *t, TEntity *e) : tspec(t), entity(e) {}
545     virtual void setExtern(int e);
546     void print(XStr& str);
547     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
548     void genDecls(XStr& str);
549     void genDefs(XStr& str);
550     void genSpec(XStr& str);
551     void genVars(XStr& str);
552
553     // DMK - Accel Support
554     int genAccels_spe_c_funcBodies(XStr& str);
555     void genAccels_spe_c_regFuncs(XStr& str);
556     void genAccels_spe_c_callInits(XStr& str);
557     void genAccels_spe_h_includes(XStr& str);
558     void genAccels_spe_h_fiCountDefs(XStr& str);
559     void genAccels_ppe_c_regFuncs(XStr& str);
560 };
561
562 /* An entity that could be templated, i.e. chare, group or a message */
563 class TEntity : public Construct {
564   protected:
565     Template *templat;
566   public:
567     void setTemplate(Template *t) { templat = t; }
568     virtual XStr tspec(void) const {
569         XStr str; 
570         if (templat) templat->genSpec(str); 
571         return str;
572     }
573     virtual XStr tvars(void) const {
574         XStr str;
575         if (templat) templat->genVars(str); 
576         return str;
577     }
578 };
579 /* A formal argument of a template */
580 class TVar : public Printable {
581   public:
582     virtual void genLong(XStr& str) = 0;
583     virtual void genShort(XStr& str) = 0;
584 };
585
586 /* a formal type argument */
587 class TType : public TVar {
588     Type *type;
589     Type *init;
590   public:
591     TType(Type *t, Type *i=0) : type(t), init(i) {}
592     void print(XStr& str);
593     void genLong(XStr& str);
594     void genShort(XStr& str);
595 };
596
597 /* a formal function argument */
598 class TFunc : public TVar {
599     FuncType *type;
600     const char *init;
601   public:
602     TFunc(FuncType *t, const char *v=0) : type(t), init(v) {}
603     void print(XStr& str) { type->print(str); if(init) str << "=" << init; }
604     void genLong(XStr& str){ type->print(str); if(init) str << "=" << init; }
605     void genShort(XStr& str) {str << type->getBaseName(); }
606 };
607
608 /* A formal variable argument */
609 class TName : public TVar {
610     Type *type;
611     const char *name;
612     const char *val;
613   public:
614     TName(Type *t, const char *n, const char *v=0) : type(t), name(n), val(v) {}
615     void print(XStr& str);
616     void genLong(XStr& str);
617     void genShort(XStr& str);
618 };
619
620 /* A list of formal arguments to a template */
621 class TVarList : public Printable {
622     TVar *tvar;
623     TVarList *next;
624   public:
625     TVarList(TVar *v, TVarList *n=0) : tvar(v), next(n) {}
626     void print(XStr& str);
627     void genLong(XStr& str);
628     void genShort(XStr& str);
629 };
630
631 /******************* Chares, Arrays, Groups ***********/
632
633 /* Member of a chare or group, i.e. entry, RO or ROM */
634 class Member : public Construct {
635    //friend class CParsedFile;
636   protected:
637     Chare *container;
638   public:
639     TVarList *tspec;
640     Member() : container(0), tspec(0) { }
641     inline Chare *getContainer() const { return container; }
642     virtual void setChare(Chare *c) { container = c; }
643     virtual int isSdag(void) { return 0; }
644     virtual void collectSdagCode(CParsedFile *, int&) { return; }
645     XStr makeDecl(const XStr &returnType,int forProxy=0, bool isStatic = false);
646     virtual void genPythonDecls(XStr& ) {}
647     virtual void genIndexDecls(XStr& ) {}
648     virtual void genPythonDefs(XStr& ) {}
649     virtual void genPythonStaticDefs(XStr&) {}
650     virtual void genPythonStaticDocs(XStr&) {}
651     virtual void lookforCEntry(CEntry *)  {}
652 };
653
654 /* List of members of a chare or group */
655 class MemberList : public Printable {
656     std::list<Member*> members;
657   public:
658     MemberList(Member *m, MemberList *n=0);
659     MemberList(std::list<Entry*>&);
660
661     void appendMember(Member *m);
662     void print(XStr& str);
663     void setChare(Chare *c);
664     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
665     void genDecls(XStr& str);
666     void genIndexDecls(XStr& str);
667     void genPythonDecls(XStr& str);
668     void genDefs(XStr& str);
669     void genReg(XStr& str);
670     void preprocess();
671     void check();
672
673     // DMK - Accel Support
674     int genAccels_spe_c_funcBodies(XStr& str);
675     void genAccels_spe_c_regFuncs(XStr& str);
676     void genAccels_spe_c_callInits(XStr& str);
677     void genAccels_spe_h_includes(XStr& str);
678     void genAccels_spe_h_fiCountDefs(XStr& str);
679     void genAccels_ppe_c_regFuncs(XStr& str);
680
681     void genPythonDefs(XStr& str);
682     void genPythonStaticDefs(XStr& str);
683     void genPythonStaticDocs(XStr& str);
684     void collectSdagCode(CParsedFile *pf, int& sdagPresent);
685     virtual void lookforCEntry(CEntry *centry);
686 };
687
688 /* Chare or group is a templated entity */
689 class Chare : public TEntity {
690   public:
691     enum { //Set these attribute bits in "attrib"
692         CMIGRATABLE=1<<2,
693         CPYTHON=1<<3,
694         CCHARE=1<<9,                 // plain non-migratable chare
695         CMAINCHARE=1<<10,
696         CARRAY=1<<11,
697         CGROUP=1<<12,
698         CNODEGROUP=1<<13
699     };
700     typedef unsigned int attrib_t;
701   protected:
702     attrib_t attrib;
703     int hasElement;//0-- no element type; 1-- has element type
704     forWhom forElement;
705     int hasSection; //1-- applies only to array section
706
707     NamedType *type;
708     MemberList *list;
709     TypeList *bases; //Base classes used by proxy
710     TypeList *bases_CBase; //Base classes used by CBase (or NULL)
711     
712     int entryCount;
713     int hasSdagEntry;
714     XStr sdagDefs;
715
716     void genTypedefs(XStr& str);
717     void genRegisterMethodDef(XStr& str);
718     void sharedDisambiguation(XStr &str,const XStr &superclass);
719   public:
720     Chare(int ln, attrib_t Nattr,
721         NamedType *t, TypeList *b=0, MemberList *l=0);
722     void genProxyNames(XStr& str, const char *prefix, const char *middle, 
723                         const char *suffix, const char *sep);
724     void genIndexNames(XStr& str, const char *prefix, const char *middle, 
725                         const char *suffix, const char *sep);
726     XStr proxyName(int withTemplates=1); 
727     XStr indexName(int withTemplates=1); 
728     XStr indexList();
729     XStr baseName(int withTemplates=1) const
730     {
731         XStr str;
732         str<<type->getBaseName();
733         if (withTemplates) str<<tvars();
734         return str;
735     }
736     int  isTemplated(void) { return (templat!=0); }
737     int  isMigratable(void) { return attrib&CMIGRATABLE; }
738     int  isPython(void) { return attrib&CPYTHON; }
739     int  isMainChare(void) {return attrib&CMAINCHARE;}
740     int  isChare(void) {return attrib&CCHARE;}     // plain non-migratable chare
741     int  isArray(void) {return attrib&CARRAY;}
742     int  isGroup(void) {return attrib&CGROUP;}
743     int  isNodeGroup(void) {return attrib&CNODEGROUP;}
744     int  isForElement(void) const {return forElement==forIndividual;}
745     int  isForSection(void) const {return forElement==forSection;}
746     int  hasSdag() const { return hasSdagEntry; }
747     void  setSdag(int f) { hasSdagEntry = f; }
748     forWhom getForWhom(void) const {return forElement;}
749     void print(XStr& str);
750     void check();
751     void genDefs(XStr& str);
752     void genReg(XStr& str);
753     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
754     void genDecls(XStr &str);
755     void preprocess();
756
757     // DMK - Accel Support
758     int genAccels_spe_c_funcBodies(XStr& str) {
759       int rtn = 0;
760       if (list) { rtn += list->genAccels_spe_c_funcBodies(str); }
761       return rtn;
762     }
763     void genAccels_spe_c_regFuncs(XStr& str) {
764       if (list) { list->genAccels_spe_c_regFuncs(str); }
765     }
766     void genAccels_spe_c_callInits(XStr& str) {
767       if (list) { list->genAccels_spe_c_callInits(str); }
768     }
769     void genAccels_spe_h_includes(XStr& str) {
770       if (list) { list->genAccels_spe_h_includes(str); }
771     }
772     void genAccels_spe_h_fiCountDefs(XStr& str) {
773       if (list) { list->genAccels_spe_h_fiCountDefs(str); }
774     }
775     void genAccels_ppe_c_regFuncs(XStr& str) {
776       if (list) { list->genAccels_ppe_c_regFuncs(str); }
777     }
778
779     int nextEntry(void) {return entryCount++;}
780     virtual void genSubDecls(XStr& str);
781     void genPythonDecls(XStr& str);
782     void genPythonDefs(XStr& str);
783     virtual char *chareTypeName(void) {return (char *)"chare";}
784     virtual char *proxyPrefix(void);
785     virtual void genSubRegisterMethodDef(XStr& str) { (void)str; }
786     void lookforCEntry(CEntry *centry);
787 };
788
789 class MainChare : public Chare {
790   public:
791     MainChare(int ln, attrib_t Nattr, 
792         NamedType *t, TypeList *b=0, MemberList *l=0):
793             Chare(ln, Nattr|CMAINCHARE, t,b,l) {}
794     virtual char *chareTypeName(void) {return (char *) "mainchare";}
795 };
796
797 class Array : public Chare {
798   protected:
799     XStr indexSuffix;
800     XStr indexType;//"CkArrayIndex"+indexSuffix;
801   public:
802     Array(int ln, attrib_t Nattr, NamedType *index,
803         NamedType *t, TypeList *b=0, MemberList *l=0);
804     virtual int is1D(void) {return indexSuffix==(const char*)"1D";}
805     virtual const char* dim(void) {return indexSuffix.get_string_const();}
806     virtual void genSubDecls(XStr& str);
807     virtual char *chareTypeName(void) {return (char *) "array";}
808 };
809
810 class Group : public Chare {
811   public:
812     Group(int ln, attrib_t Nattr,
813         NamedType *t, TypeList *b=0, MemberList *l=0);
814     virtual void genSubDecls(XStr& str);
815     virtual char *chareTypeName(void) {return (char *) "group";}
816     virtual void genSubRegisterMethodDef(XStr& str);
817 };
818
819 class NodeGroup : public Group {
820   public:
821     NodeGroup(int ln, attrib_t Nattr,
822         NamedType *t, TypeList *b=0, MemberList *l=0):
823             Group(ln,Nattr|CNODEGROUP,t,b,l) {}
824     virtual char *chareTypeName(void) {return (char *) "nodegroup";}
825 };
826
827
828 /****************** Messages ***************/
829 class Message; // forward declaration
830
831 class MsgVar {
832  public:
833   Type *type;
834   const char *name;
835   int cond;
836   int array;
837   MsgVar(Type *t, const char *n, int c, int a) : type(t), name(n), cond(c), array(a) { }
838   Type *getType() { return type; }
839   const char *getName() { return name; }
840   int isConditional() { return cond; }
841   int isArray() { return array; }
842   void print(XStr &str) {str<<(isConditional()?"conditional ":"");type->print(str);str<<" "<<name<<(isArray()?"[]":"")<<";";}
843 };
844
845 class MsgVarList : public Printable {
846  public:
847   MsgVar *msg_var;
848   MsgVarList *next;
849   MsgVarList(MsgVar *mv, MsgVarList *n=0) : msg_var(mv), next(n) {}
850   void print(XStr &str) {
851     msg_var->print(str);
852     str<<"\n";
853     if(next) next->print(str);
854   }
855   int len(void) { return (next==0)?1:(next->len()+1); }
856 };
857
858 class Message : public TEntity {
859     NamedType *type;
860     MsgVarList *mvlist;
861     void printVars(XStr& str) {
862       if(mvlist!=0) {
863         str << "{\n";
864         mvlist->print(str);
865         str << "}\n";
866       }
867     }
868   public:
869     Message(int l, NamedType *t, MsgVarList *mv=0)
870       : type(t), mvlist(mv) 
871       { line=l; setTemplate(0); }
872     void print(XStr& str);
873     void genDecls(XStr& str);
874     void genDefs(XStr& str);
875     void genReg(XStr& str);
876
877     virtual const char *proxyPrefix(void) {return Prefix::Message;}
878     void genAllocDecl(XStr& str);
879     int numArrays(void) {
880       if (mvlist==0) return 0;
881       int count = 0;
882       MsgVarList *mv = mvlist;
883       for (int i=0; i<mvlist->len(); ++i, mv=mv->next) if (mv->msg_var->isArray()) count ++;
884       return count;
885     }
886     int numConditional(void) {
887       if (mvlist==0) return 0;
888       int count = 0;
889       MsgVarList *mv = mvlist;
890       for (int i=0; i<mvlist->len(); ++i, mv=mv->next) if (mv->msg_var->isConditional()) count ++;
891       return count;
892     }
893     int numVars(void) { return ((mvlist==0) ? 0 : mvlist->len()); }
894 };
895
896
897
898
899
900 /******************* Entry Point ****************/
901 // Entry attributes
902 #define STHREADED 0x01
903 #define SSYNC     0x02
904 #define SLOCKED   0x04
905 #define SPURE     0x10
906 #define SMIGRATE  0x20 //<- is magic migration constructor
907 #define SCREATEHERE   0x40 //<- is a create-here-if-nonexistant
908 #define SCREATEHOME   0x80 //<- is a create-at-home-if-nonexistant
909 #define SIMMEDIATE    0x100 //<- is a immediate
910 #define SNOKEEP       0x200
911 #define SNOTRACE      0x400
912 #define SSKIPSCHED    0x800 //<- is a message skipping charm scheduler
913 #define SPYTHON       0x1000
914 #define SINLINE       0x2000 //<- inline message
915 #define SIGET         0x4000 
916 #define SLOCAL        0x8000 //<- local message
917 #define SACCEL        0x10000
918 #define SMEM          0x20000
919 #define SREDUCE       0x40000 // <- reduction target
920
921 /* An entry construct */
922 class Entry : public Member {
923   private:
924     int line,entryCount;
925     int attribs;    
926     Type *retType;
927     Value *stacksize;
928     const char *pythonDoc;
929     
930     XStr proxyName(void) {return container->proxyName();}
931     XStr indexName(void) {return container->indexName();}
932
933 //    friend class CParsedFile;
934     int hasCallMarshall;
935     void genCall(XStr &dest,const XStr &preCall, bool redn_wrapper=false);
936
937     XStr epStr(bool isForRedn = false, bool templateCall = false);
938     XStr epIdx(int fromProxy=1, bool isForRedn = false);
939     XStr epRegFn(int fromProxy=1, bool isForRedn = false);
940     XStr chareIdx(int fromProxy=1);
941     void genEpIdxDecl(XStr& str);
942     void genEpIdxDef(XStr& str);
943     
944     void genChareDecl(XStr& str);
945     void genChareStaticConstructorDecl(XStr& str);
946     void genChareStaticConstructorDefs(XStr& str);
947     void genChareDefs(XStr& str);
948     
949     void genArrayDefs(XStr& str);
950     void genArrayStaticConstructorDecl(XStr& str);
951     void genArrayStaticConstructorDefs(XStr& str);
952     void genArrayDecl(XStr& str);
953     
954     void genGroupDecl(XStr& str);
955     void genGroupStaticConstructorDecl(XStr& str);
956     void genGroupStaticConstructorDefs(XStr& str);
957     void genGroupDefs(XStr& str);
958     
959     void genPythonDecls(XStr& str);
960     void genPythonDefs(XStr& str);
961     void genPythonStaticDefs(XStr& str);
962     void genPythonStaticDocs(XStr& str);
963
964     // DMK - Accel Support
965     void genAccelFullParamList(XStr& str, int makeRefs);
966     void genAccelFullCallList(XStr& str);
967     void genAccelIndexWrapperDecl_general(XStr& str);
968     void genAccelIndexWrapperDef_general(XStr& str);
969     void genAccelIndexWrapperDecl_spe(XStr& str);
970     void genAccelIndexWrapperDef_spe(XStr& str);
971     int genAccels_spe_c_funcBodies(XStr& str);
972     void genAccels_spe_c_regFuncs(XStr& str);
973     void genAccels_ppe_c_regFuncs(XStr& str);
974
975     XStr paramType(int withDefaultVals,int withEO=0,int useConst=1);
976     XStr paramComma(int withDefaultVals,int withEO=0);
977     XStr eo(int withDefaultVals,int priorComma=1);
978     XStr syncReturn(void);
979     XStr marshallMsg(void);
980     XStr callThread(const XStr &procName,int prependEntryName=0);
981
982     // SDAG support
983     std::list<CStateVar *> estateVars;
984
985   public:
986     XStr *label;
987     char *name;
988     TParamList *targs;
989
990     // SDAG support
991     SdagConstruct *sdagCon;
992     std::list<CStateVar *> stateVars;
993     CEntry *entryPtr;
994     const char *intExpr;
995     ParamList *param;
996     ParamList *connectParam;
997     int isConnect;
998     int isWhenEntry;
999
1000     void addEStateVar(CStateVar *sv) {
1001       estateVars.push_back(sv);
1002       stateVars.push_back(sv);
1003     }
1004
1005     // DMK - Accel Support
1006     ParamList* accelParam;
1007     XStr* accelCodeBody;
1008     XStr* accelCallbackName;
1009     void setAccelParam(ParamList* apl) { accelParam = apl; }
1010     void setAccelCodeBody(XStr* acb) { accelCodeBody = acb; }
1011     void setAccelCallbackName(XStr* acbn) { accelCallbackName = acbn; }
1012
1013     // DMK - Accel Support
1014     int accel_numScalars;
1015     int accel_numArrays;
1016     int accel_dmaList_numReadOnly;
1017     int accel_dmaList_numReadWrite;
1018     int accel_dmaList_numWriteOnly;
1019     int accel_dmaList_scalarNeedsWrite;
1020
1021     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);
1022     void setChare(Chare *c);
1023     int isConnectEntry(void) { return isConnect; }
1024     int paramIsMarshalled(void) { return param->isMarshalled(); }
1025     int getStackSize(void) { return (stacksize ? stacksize->getIntVal() : 0); }
1026     int isThreaded(void) { return (attribs & STHREADED); }
1027     int isSync(void) { return (attribs & SSYNC); }
1028     int isIget(void) { return (attribs & SIGET); }
1029     int isConstructor(void) { return !strcmp(name, container->baseName(0).get_string());}
1030     bool isMigrationConstructor() { return isConstructor() && (attribs & SMIGRATE); }
1031     int isExclusive(void) { return (attribs & SLOCKED); }
1032     int isImmediate(void) { return (attribs & SIMMEDIATE); }
1033     int isSkipscheduler(void) { return (attribs & SSKIPSCHED); }
1034     int isInline(void) { return attribs & SINLINE; }
1035     int isLocal(void) { return attribs & SLOCAL; }
1036     int isCreate(void) { return (attribs & SCREATEHERE)||(attribs & SCREATEHOME); }
1037     int isCreateHome(void) { return (attribs & SCREATEHOME); }
1038     int isCreateHere(void) { return (attribs & SCREATEHERE); }
1039     int isPython(void) { return (attribs & SPYTHON); }
1040     int isNoTrace(void) { return (attribs & SNOTRACE); }
1041     int isNoKeep(void) { return (attribs & SNOKEEP); }
1042     int isSdag(void) { return (sdagCon!=0); }
1043
1044     // DMK - Accel support
1045     int isAccel(void) { return (attribs & SACCEL); }
1046
1047     int isMemCritical(void) { return (attribs & SMEM); }
1048     int isReductionTarget(void) { return (attribs & SREDUCE); }
1049
1050     void print(XStr& str);
1051     void check();
1052     void genIndexDecls(XStr& str);
1053     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
1054     void genDecls(XStr& str);
1055     void genDefs(XStr& str);
1056     void genReg(XStr& str);
1057     XStr genRegEp(bool isForRedn = false);
1058     void preprocess();
1059     char *getEntryName() { return name; }
1060     void generateEntryList(std::list<CEntry*>&, WhenConstruct *);
1061     void collectSdagCode(CParsedFile *pf, int& sdagPresent);
1062     void propagateState(int);
1063     void lookforCEntry(CEntry *centry);
1064     int getLine() { return line; }
1065 };
1066
1067 class EntryList {
1068   public:
1069     Entry *entry;
1070     EntryList *next;
1071     EntryList(Entry *e,EntryList *elist=NULL):
1072         entry(e), next(elist) {}
1073     void generateEntryList(std::list<CEntry*>&, WhenConstruct *);
1074 };
1075
1076
1077 /******************** AccelBlock : Block of code for accelerator **********************/
1078 class AccelBlock : public Construct {
1079
1080  protected:
1081
1082   XStr* code;
1083
1084  private:
1085
1086   void outputCode(XStr& str) {
1087     if (code != NULL) {
1088       str << "\n#ifndef CK_TEMPLATES_ONLY\n"
1089           << "/***** Accel_Block Start *****/\n"
1090           << (*(code))
1091           << "\n/***** Accel_Block End *****/\n"
1092           << "#endif /*CK_TEMPLATES_ONLY*/\n\n";
1093     }
1094   }
1095
1096  public:
1097
1098   /// Constructor(s)/Destructor ///
1099   AccelBlock(int l, XStr* c) { line = l; code = c; }
1100   ~AccelBlock() { delete code; }
1101
1102   /// Printable Methods ///
1103   void print(XStr& str) { (void)str; }
1104
1105   /// Construct Methods ///
1106   void genDefs(XStr& str) { outputCode(str); }
1107
1108   /// Construct Accel Support Methods ///
1109   int genAccels_spe_c_funcBodies(XStr& str) { outputCode(str); return 0; }
1110 };
1111
1112
1113 /****************** Modules, etc. ****************/
1114 class Module : public Construct {
1115     int _isMain;
1116     const char *name;
1117     
1118   public:
1119     ConstructList *clist;
1120     Module(int l, const char *n, ConstructList *c) : name(n), clist(c) {
1121             line = l;
1122             _isMain=0;
1123             if (clist!=NULL) clist->setModule(this);
1124     }
1125     void print(XStr& str);
1126     void check();
1127     void generate();
1128     void setModule();
1129     void prependConstruct(Construct *c) { clist = new ConstructList(-1, c, clist); }
1130     void preprocess();
1131     void genDepend(const char *cifile);
1132     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
1133     void genDecls(XStr& str);
1134     void genDefs(XStr& str);
1135     void genReg(XStr& str);
1136     void setMain(void) { _isMain = 1; }
1137     int isMain(void) { return _isMain; }
1138
1139     // DMK - Accel Support
1140     int genAccels_spe_c_funcBodies(XStr& str);
1141     void genAccels_spe_c_regFuncs(XStr& str);
1142     void genAccels_spe_c_callInits(XStr& str);
1143     void genAccels_spe_h_includes(XStr& str);
1144     void genAccels_spe_h_fiCountDefs(XStr& str);
1145     void genAccels_ppe_c_regFuncs(XStr& str);
1146 };
1147
1148 class ModuleList : public Printable {
1149     std::list<Module*> modules;
1150   public:
1151     int line;
1152     ModuleList(int l, Module *m, ModuleList *n=0) : line(l)
1153         {
1154             modules.push_back(m);
1155             if (n)
1156                 modules.insert(modules.end(),
1157                                n->modules.begin(), n->modules.end());
1158         }
1159     void print(XStr& str);
1160     void check();
1161     void generate();
1162     void preprocess();
1163     void genDepends(std::string ciFileBaseName);
1164 };
1165
1166 class Readonly : public Member {
1167     int msg; // is it a readonly var(0) or msg(1) ?
1168     Type *type;
1169     const char *name;
1170     ValueList *dims;
1171     XStr qName(void) const { /*Return fully qualified name*/
1172       XStr ret;
1173       if(container) ret<<container->baseName()<<"::";
1174       ret<<name;
1175       return ret;
1176     }
1177   public:
1178     Readonly(int l, Type *t, const char *n, ValueList* d, int m=0)
1179             : msg(m), type(t), name(n)
1180             { line=l; dims=d; setChare(0); }
1181     void print(XStr& str);
1182     void genDecls(XStr& str);
1183     void genIndexDecls(XStr& str);
1184     void genDefs(XStr& str);
1185     void genReg(XStr& str);
1186 };
1187
1188 class InitCall : public Member {
1189
1190     const char *name; //Name of subroutine to call
1191     int isNodeCall;
1192
1193     // DMK - Accel Support
1194     int isAccelFlag;
1195
1196 public:
1197
1198     InitCall(int l, const char *n, int nodeCall);
1199     void print(XStr& str);
1200     void genReg(XStr& str);
1201
1202     // DMK - Accel Support
1203     void genAccels_spe_c_callInits(XStr& str);
1204
1205     void setAccel() { isAccelFlag = 1; }
1206     void clearAccel() { isAccelFlag = 0; }
1207     int isAccel() { return isAccelFlag; }
1208 };
1209
1210 class PUPableClass : public Member {
1211     NamedType* type;
1212     PUPableClass *next; //Linked-list of PUPable classes
1213 public:
1214     PUPableClass(int l, NamedType* type_, PUPableClass *next_);
1215     void print(XStr& str);
1216     void genDefs(XStr& str);
1217     void genReg(XStr& str);
1218
1219     // DMK - Accel Support
1220     int genAccels_spe_c_funcBodies(XStr& str) {
1221       int rtn=0;
1222       if (next) { rtn += next->genAccels_spe_c_funcBodies(str); }
1223       return rtn;
1224     }
1225     void genAccels_spe_c_regFuncs(XStr& str) {
1226       if (next) { next->genAccels_spe_c_regFuncs(str); }
1227     }
1228     void genAccels_spe_c_callInits(XStr& str) {
1229       if (next) { next->genAccels_spe_c_callInits(str); }
1230     }
1231     void genAccels_spe_h_includes(XStr& str) {
1232       if (next) { next->genAccels_spe_h_includes(str); }
1233     }
1234     void genAccels_spe_h_fiCountDefs(XStr& str) {
1235       if (next) { next->genAccels_spe_h_fiCountDefs(str); }
1236     }
1237     void genAccels_ppe_c_regFuncs(XStr& str) {
1238       if (next) { next->genAccels_ppe_c_regFuncs(str); }
1239     }
1240 };
1241
1242 class IncludeFile : public Member {
1243     const char *name; //Name of include file
1244 public:
1245     IncludeFile(int l, const char *name_);
1246     void print(XStr& str);
1247     void genDecls(XStr& str);
1248 };
1249
1250 class ClassDeclaration : public Member {
1251     const char *name; //Name of class 
1252 public:
1253     ClassDeclaration(int l, const char *name_);
1254     void print(XStr& str);
1255     void genDecls(XStr& str);
1256 };
1257
1258
1259 /******************* Structured Dagger Constructs ***************/
1260 class SdagConstruct { 
1261 private:
1262   void generateOverlap(XStr& decls, XStr& defs, Entry* entry);
1263   void generateWhile(XStr& decls, XStr& defs, Entry* entry);
1264   void generateFor(XStr& decls, XStr& defs, Entry* entry);
1265   void generateIf(XStr& decls, XStr& defs, Entry* entry);
1266   void generateElse(XStr& decls, XStr& defs, Entry* entry);
1267   void generateForall(XStr& decls, XStr& defs, Entry* entry);
1268   void generateOlist(XStr& decls, XStr& defs, Entry* entry);
1269   void generateSdagEntry(XStr& decls, XStr& defs, Entry *entry);
1270   void generateSlist(XStr& decls, XStr& defs, Entry* entry);
1271   void generateAtomic(XStr& decls, XStr& defs, Entry* entry);
1272   void generateForward(XStr& decls, XStr& defs, Entry* entry);
1273   void generateConnect(XStr& decls, XStr& defs, Entry* entry);
1274   void generateCaseList(XStr& decls, XStr& defs, Entry* entry);
1275
1276 protected:
1277   void generateCall(XStr& defs, std::list<CStateVar*>& args,
1278                     const XStr* name, const char* nameSuffix = 0);
1279
1280   void generateTraceBeginCall(XStr& defs);          // for trace
1281   void generateBeginTime(XStr& defs);               //for Event Bracket
1282   void generateEventBracket(XStr& defs, int eventType);     //for Event Bracket
1283   void generateListEventBracket(XStr& defs, int eventType);
1284   void generateChildrenCode(XStr& decls, XStr& defs, Entry* entry);
1285   void generateChildrenEntryList(std::list<CEntry*>& CEntrylist, WhenConstruct *thisWhen);
1286   void propagateStateToChildren(std::list<CStateVar*>&, std::list<CStateVar*>&, std::list<SdagConstruct*>&, int);
1287   std::list<SdagConstruct *> *constructs;
1288   std::list<SdagConstruct *> *publishesList;
1289   std::list<CStateVar *> *stateVars;
1290   std::list<CStateVar *> *stateVarsChildren;
1291
1292 public:
1293   int nodeNum;
1294   XStr *label;
1295   XStr *counter;
1296   EToken type;
1297   char nameStr[128];
1298   XStr *traceName;      
1299   SdagConstruct *next;
1300   ParamList *param;
1301   XStr *text;
1302   XStr *connectEntry;
1303   int nextBeginOrEnd;
1304   EntryList *elist;
1305   SdagConstruct *con1, *con2, *con3, *con4;
1306   SdagConstruct(EToken t, SdagConstruct *construct1);
1307
1308   SdagConstruct(EToken t, SdagConstruct *construct1, SdagConstruct *aList);
1309
1310   SdagConstruct(EToken t, XStr *txt, SdagConstruct *c1, SdagConstruct *c2, SdagConstruct *c3,
1311               SdagConstruct *c4, SdagConstruct *constructAppend, EntryList *el);
1312
1313  SdagConstruct(EToken t, const char *str) : type(t), traceName(NULL), con1(0), con2(0), con3(0), con4(0)
1314   { text = new XStr(str); constructs = new std::list<SdagConstruct*>();
1315     publishesList = new std::list<SdagConstruct*>(); }
1316                                              
1317  
1318   SdagConstruct(EToken t) : type(t), traceName(NULL), con1(0), con2(0), con3(0), con4(0) 
1319   { publishesList = new std::list<SdagConstruct*>();
1320                   constructs = new std::list<SdagConstruct*>(); }
1321
1322   SdagConstruct(EToken t, XStr *txt) : type(t), traceName(NULL), text(txt), con1(0), con2(0), con3(0), con4(0) 
1323   { publishesList = new std::list<SdagConstruct*>();
1324                   constructs = new std::list<SdagConstruct*>();  }
1325   SdagConstruct(EToken t, const char *entryStr, const char *codeStr, ParamList *pl);
1326   void numberNodes(void);
1327   void labelNodes(void);
1328   void generateConnectEntryList(std::list<SdagConstruct*>&);
1329   void generateConnectEntries(XStr&);
1330   virtual void generateEntryList(std::list<CEntry*>&, WhenConstruct *);
1331   void propagateState(int);
1332   virtual void propagateState(std::list<CStateVar*>&, std::list<CStateVar*>&, std::list<SdagConstruct*>&, int);
1333   virtual void generateCode(XStr& decls, XStr& defs, Entry *entry);
1334   void generateWhenCode(XStr& op);
1335   void setNext(SdagConstruct *, int);
1336
1337   // for trace
1338   void generateTrace();          
1339   void generateRegisterEp(XStr& defs);
1340   void generateTraceEp(XStr& decls, XStr& defs, Chare* chare);
1341   static void generateTraceEndCall(XStr& defs);
1342   static void generateTlineEndCall(XStr& defs);
1343   static void generateBeginExec(XStr& defs, const char *name);
1344   static void generateEndExec(XStr& defs);
1345   static void generateEndSeq(XStr& defs);
1346   static void generateDummyBeginExecute(XStr& defs);
1347 };
1348
1349 class WhenConstruct : public SdagConstruct {
1350 public:
1351   CStateVar* speculativeState;
1352   void generateCode(XStr& decls, XStr& defs, Entry *entry);
1353   WhenConstruct(EntryList *el, SdagConstruct *body)
1354     : SdagConstruct(SWHEN, 0, 0, 0,0,0, body, el)
1355     , speculativeState(0)
1356   { }
1357   void generateEntryList(std::list<CEntry*>& CEntrylist, WhenConstruct *thisWhen);
1358   void propagateState(std::list<CStateVar*>&, std::list<CStateVar*>&, std::list<SdagConstruct*>&, int);
1359 };
1360
1361 SdagConstruct *buildAtomic(const char* code,
1362                            SdagConstruct *pub_list,
1363                            const char *trace_name);
1364
1365 extern void RemoveSdagComments(char *);
1366
1367 }
1368
1369 #endif