charmxi: convert Entry::stateVars from TList to std::list
[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 #include "CList.h"
9
10 #include <iostream>
11 #include <stdio.h>
12 #include <string.h>
13 #include <stdlib.h>
14 #include <list>
15
16
17 namespace xi {
18
19 class Chare;
20 class CParsedFile;
21
22 extern void generateSignature(XStr& decls, XStr& defs,
23                               const Entry* entry, bool declareStatic,
24                               const char* returnType, const XStr* name, bool isEnd,
25                               std::list<CStateVar*>* params);
26 extern void generateSignature(XStr& decls, XStr& defs,
27                               const Chare* chare, bool declareStatic,
28                               const char* returnType, const XStr* name, bool isEnd,
29                               std::list<CStateVar*>* params);
30 extern void endMethod(XStr& op);
31
32 class CStateVar;
33
34 /******************* Utilities ****************/
35
36 class Prefix {
37 public:
38   static const char *Proxy;
39   static const char *ProxyElement;
40   static const char *ProxySection;
41   static const char *Message;
42   static const char *Index;
43   static const char *Python;
44 };
45
46 typedef enum {
47   forAll=0,forIndividual=1,forSection=2,forPython=3,forIndex=-1
48 } forWhom;
49
50 class Chare;//Forward declaration
51 class Message;
52 class TParamList;
53 extern int fortranMode;
54 extern int internalMode;
55 extern const char *cur_file;
56 void die(const char *why,int line=-1);
57
58 class Value : public Printable {
59   private:
60     int factor;
61     const char *val;
62   public:
63     Value(const char *s);
64     void print(XStr& str) { str << val; }
65     int getIntVal(void);
66 };
67
68 class ValueList : public Printable {
69   private:
70     Value *val;
71     ValueList *next;
72   public:
73     ValueList(Value* v, ValueList* n=0) : val(v), next(n) {}
74     void print(XStr& str) {
75       if(val) {
76         str << "["; val->print(str); str << "]";
77       }
78       if(next)
79         next->print(str);
80     }
81     void printValue(XStr& str) {
82       if(val) {
83         val->print(str);
84       }
85       if(next) {
86           std::cout << "Unsupported type\n";
87           abort();
88       }
89     }
90 };
91
92 class Module;
93
94 class Construct : public Printable {
95   protected:
96     int external;
97   public:
98     int line;
99     Module *containerModule;
100     Construct() {external=0;line=-1;}
101     void setExtern(int &e) { external = e; }
102     void setModule(Module *m) { containerModule = m; }
103     virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent)
104     {
105       (void)declstr; (void)defstr; (void)defconstr; (void)connectPresent;
106     }
107     virtual void genDecls(XStr& str) { (void)str; }
108     virtual void genDefs(XStr& str) { (void)str; }
109     virtual void genReg(XStr& str) { (void)str; }
110     virtual void preprocess() { }
111     virtual void check() { }
112
113     // DMK - Accel Support
114     virtual int genAccels_spe_c_funcBodies(XStr& str) { (void)str; return 0; }
115     virtual void genAccels_spe_c_regFuncs(XStr& str) { (void)str; }
116     virtual void genAccels_spe_c_callInits(XStr& str) { (void)str; }
117     virtual void genAccels_spe_h_includes(XStr& str) { (void)str; }
118     virtual void genAccels_spe_h_fiCountDefs(XStr& str) { (void)str; }
119     virtual void genAccels_ppe_c_regFuncs(XStr& str) { (void)str; }
120 };
121
122 class ConstructList : public Construct {
123     std::list<Construct*> constructs;
124   public:
125     ConstructList(int l, Construct *c, ConstructList *n=0);
126     void setExtern(int e);
127     void setModule(Module *m);
128     void print(XStr& str);
129     void check();
130     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
131     void genDecls(XStr& str);
132     void genDefs(XStr& str);
133     void genReg(XStr& str);
134     void preprocess();
135
136     // DMK - Accel Support
137     int genAccels_spe_c_funcBodies(XStr& str);
138     void genAccels_spe_c_regFuncs(XStr& str);
139     void genAccels_spe_c_callInits(XStr& str);
140     void genAccels_spe_h_includes(XStr& str);
141     void genAccels_spe_h_fiCountDefs(XStr& str);
142     void genAccels_ppe_c_regFuncs(XStr& str);
143 };
144
145 /*********************** Type System **********************/
146 class Type : public Printable {
147   public:
148     virtual void print(XStr&) = 0;
149     virtual int isVoid(void) const {return 0;}
150     virtual int isBuiltin(void) const { return 0; }
151     virtual int isMessage(void) const {return 0;}
152     virtual int isTemplated(void) const { return 0; }
153     virtual int isPointer(void) const {return 0;}
154     virtual int isNamed(void) const { return 0; }
155     virtual int isCkArgMsgPtr(void) const {return 0;}
156     virtual int isCkArgMsg(void) const {return 0;}
157     virtual int isCkMigMsgPtr(void) const {return 0;}
158     virtual int isCkMigMsg(void) const {return 0;}
159     virtual int isReference(void) const {return 0;}
160     virtual Type *deref(void) {return this;}
161     virtual const char *getBaseName(void) const = 0;
162     virtual const char *getScope(void) const = 0;
163     virtual int getNumStars(void) const {return 0;}
164     virtual void genProxyName(XStr &str,forWhom forElement);
165     virtual void genIndexName(XStr &str);
166     virtual void genMsgProxyName(XStr& str);
167     XStr proxyName(forWhom w)
168         {XStr ret; genProxyName(ret,w); return ret;}
169     XStr indexName(void) 
170         {XStr ret; genIndexName(ret); return ret;}
171     XStr msgProxyName(void) 
172         {XStr ret; genMsgProxyName(ret); return ret;}
173     virtual void printVar(XStr &str, char *var) {print(str); str<<" "; str<<var;}
174     int operator==(const Type &tp) const {
175       return  (strcmp(getBaseName(), tp.getBaseName())==0);
176     }
177     virtual ~Type() { }
178 };
179
180 class BuiltinType : public Type {
181   private:
182     char *name;
183   public:
184     BuiltinType(const char *n) : name((char *)n) {}
185     int isBuiltin(void) const {return 1;}
186     void print(XStr& str) { str << name; }
187     int isVoid(void) const { return !strcmp(name, "void"); }
188     int isInt(void) const { return !strcmp(name, "int"); }
189     const char *getBaseName(void) const { return name; }
190     const char *getScope(void) const { return NULL; }
191 };
192
193 class NamedType : public Type {
194   private:
195     const char* name;
196     const char* scope;
197     TParamList *tparams;
198   public:
199     NamedType(const char* n, TParamList* t=0, const char* scope_=NULL)
200        : name(n), scope(scope_), tparams(t) {}
201     int isTemplated(void) const { return (tparams!=0); }
202     int isCkArgMsg(void) const {return 0==strcmp(name,"CkArgMsg");}
203     int isCkMigMsg(void) const {return 0==strcmp(name,"CkMigrateMessage");}
204     void print(XStr& str);
205     int isNamed(void) const {return 1;}
206     virtual const char *getBaseName(void) const { return name; }
207     virtual const char *getScope(void) const { return scope; }
208     virtual void genProxyName(XStr& str,forWhom forElement);
209     virtual void genIndexName(XStr& str);
210     virtual void genMsgProxyName(XStr& str);
211 };
212
213 class PtrType : public Type {
214   private:
215     Type *type;
216     int numstars; // level of indirection
217   public:
218     PtrType(Type *t) : type(t), numstars(1) {}
219     int isPointer(void) const {return 1;}
220     int isCkArgMsgPtr(void) const {return numstars==1 && type->isCkArgMsg();}
221     int isCkMigMsgPtr(void) const {return numstars==1 && type->isCkMigMsg();}
222     int isMessage(void) const {return numstars==1 && !type->isBuiltin();}
223     void indirect(void) { numstars++; }
224     int getNumStars(void) const {return numstars; }
225     void print(XStr& str);
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();}
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     void appendMember(Member *m);
660     void print(XStr& str);
661     void setChare(Chare *c);
662     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
663     void genDecls(XStr& str);
664     void genIndexDecls(XStr& str);
665     void genPythonDecls(XStr& str);
666     void genDefs(XStr& str);
667     void genReg(XStr& str);
668     void preprocess();
669     void check();
670
671     // DMK - Accel Support
672     int genAccels_spe_c_funcBodies(XStr& str);
673     void genAccels_spe_c_regFuncs(XStr& str);
674     void genAccels_spe_c_callInits(XStr& str);
675     void genAccels_spe_h_includes(XStr& str);
676     void genAccels_spe_h_fiCountDefs(XStr& str);
677     void genAccels_ppe_c_regFuncs(XStr& str);
678
679     void genPythonDefs(XStr& str);
680     void genPythonStaticDefs(XStr& str);
681     void genPythonStaticDocs(XStr& str);
682     void collectSdagCode(CParsedFile *pf, int& sdagPresent);
683     virtual void lookforCEntry(CEntry *centry);
684 };
685
686 /* Chare or group is a templated entity */
687 class Chare : public TEntity {
688   public:
689     enum { //Set these attribute bits in "attrib"
690         CMIGRATABLE=1<<2,
691         CPYTHON=1<<3,
692         CCHARE=1<<9,                 // plain non-migratable chare
693         CMAINCHARE=1<<10,
694         CARRAY=1<<11,
695         CGROUP=1<<12,
696         CNODEGROUP=1<<13
697     };
698     typedef unsigned int attrib_t;
699   protected:
700     attrib_t attrib;
701     int hasElement;//0-- no element type; 1-- has element type
702     forWhom forElement;
703     int hasSection; //1-- applies only to array section
704
705     NamedType *type;
706     MemberList *list;
707     TypeList *bases; //Base classes used by proxy
708     TypeList *bases_CBase; //Base classes used by CBase (or NULL)
709     
710     int entryCount;
711     int hasSdagEntry;
712     XStr sdagDefs;
713
714     void genTypedefs(XStr& str);
715     void genRegisterMethodDef(XStr& str);
716     void sharedDisambiguation(XStr &str,const XStr &superclass);
717   public:
718     Chare(int ln, attrib_t Nattr,
719         NamedType *t, TypeList *b=0, MemberList *l=0);
720     void genProxyNames(XStr& str, const char *prefix, const char *middle, 
721                         const char *suffix, const char *sep);
722     void genIndexNames(XStr& str, const char *prefix, const char *middle, 
723                         const char *suffix, const char *sep);
724     XStr proxyName(int withTemplates=1); 
725     XStr indexName(int withTemplates=1); 
726     XStr indexList();
727     XStr baseName(int withTemplates=1) const
728     {
729         XStr str;
730         str<<type->getBaseName();
731         if (withTemplates) str<<tvars();
732         return str;
733     }
734     int  isTemplated(void) { return (templat!=0); }
735     int  isMigratable(void) { return attrib&CMIGRATABLE; }
736     int  isPython(void) { return attrib&CPYTHON; }
737     int  isMainChare(void) {return attrib&CMAINCHARE;}
738     int  isChare(void) {return attrib&CCHARE;}     // plain non-migratable chare
739     int  isArray(void) {return attrib&CARRAY;}
740     int  isGroup(void) {return attrib&CGROUP;}
741     int  isNodeGroup(void) {return attrib&CNODEGROUP;}
742     int  isForElement(void) const {return forElement==forIndividual;}
743     int  isForSection(void) const {return forElement==forSection;}
744     int  hasSdag() const { return hasSdagEntry; }
745     void  setSdag(int f) { hasSdagEntry = f; }
746     forWhom getForWhom(void) const {return forElement;}
747     void print(XStr& str);
748     void check();
749     void genDefs(XStr& str);
750     void genReg(XStr& str);
751     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
752     void genDecls(XStr &str);
753     void preprocess();
754
755     // DMK - Accel Support
756     int genAccels_spe_c_funcBodies(XStr& str) {
757       int rtn = 0;
758       if (list) { rtn += list->genAccels_spe_c_funcBodies(str); }
759       return rtn;
760     }
761     void genAccels_spe_c_regFuncs(XStr& str) {
762       if (list) { list->genAccels_spe_c_regFuncs(str); }
763     }
764     void genAccels_spe_c_callInits(XStr& str) {
765       if (list) { list->genAccels_spe_c_callInits(str); }
766     }
767     void genAccels_spe_h_includes(XStr& str) {
768       if (list) { list->genAccels_spe_h_includes(str); }
769     }
770     void genAccels_spe_h_fiCountDefs(XStr& str) {
771       if (list) { list->genAccels_spe_h_fiCountDefs(str); }
772     }
773     void genAccels_ppe_c_regFuncs(XStr& str) {
774       if (list) { list->genAccels_ppe_c_regFuncs(str); }
775     }
776
777     int nextEntry(void) {return entryCount++;}
778     virtual void genSubDecls(XStr& str);
779     void genPythonDecls(XStr& str);
780     void genPythonDefs(XStr& str);
781     virtual char *chareTypeName(void) {return (char *)"chare";}
782     virtual char *proxyPrefix(void);
783     virtual void genSubRegisterMethodDef(XStr& str) { (void)str; }
784     void lookforCEntry(CEntry *centry);
785 };
786
787 class MainChare : public Chare {
788   public:
789     MainChare(int ln, attrib_t Nattr, 
790         NamedType *t, TypeList *b=0, MemberList *l=0):
791             Chare(ln, Nattr|CMAINCHARE, t,b,l) {}
792     virtual char *chareTypeName(void) {return (char *) "mainchare";}
793 };
794
795 class Array : public Chare {
796   protected:
797     XStr indexSuffix;
798     XStr indexType;//"CkArrayIndex"+indexSuffix;
799   public:
800     Array(int ln, attrib_t Nattr, NamedType *index,
801         NamedType *t, TypeList *b=0, MemberList *l=0);
802     virtual int is1D(void) {return indexSuffix==(const char*)"1D";}
803     virtual const char* dim(void) {return indexSuffix.get_string_const();}
804     virtual void genSubDecls(XStr& str);
805     virtual char *chareTypeName(void) {return (char *) "array";}
806 };
807
808 class Group : public Chare {
809   public:
810     Group(int ln, attrib_t Nattr,
811         NamedType *t, TypeList *b=0, MemberList *l=0);
812     virtual void genSubDecls(XStr& str);
813     virtual char *chareTypeName(void) {return (char *) "group";}
814     virtual void genSubRegisterMethodDef(XStr& str);
815 };
816
817 class NodeGroup : public Group {
818   public:
819     NodeGroup(int ln, attrib_t Nattr,
820         NamedType *t, TypeList *b=0, MemberList *l=0):
821             Group(ln,Nattr|CNODEGROUP,t,b,l) {}
822     virtual char *chareTypeName(void) {return (char *) "nodegroup";}
823 };
824
825
826 /****************** Messages ***************/
827 class Message; // forward declaration
828
829 class MsgVar {
830  public:
831   Type *type;
832   const char *name;
833   int cond;
834   int array;
835   MsgVar(Type *t, const char *n, int c, int a) : type(t), name(n), cond(c), array(a) { }
836   Type *getType() { return type; }
837   const char *getName() { return name; }
838   int isConditional() { return cond; }
839   int isArray() { return array; }
840   void print(XStr &str) {str<<(isConditional()?"conditional ":"");type->print(str);str<<" "<<name<<(isArray()?"[]":"")<<";";}
841 };
842
843 class MsgVarList : public Printable {
844  public:
845   MsgVar *msg_var;
846   MsgVarList *next;
847   MsgVarList(MsgVar *mv, MsgVarList *n=0) : msg_var(mv), next(n) {}
848   void print(XStr &str) {
849     msg_var->print(str);
850     str<<"\n";
851     if(next) next->print(str);
852   }
853   int len(void) { return (next==0)?1:(next->len()+1); }
854 };
855
856 class Message : public TEntity {
857     NamedType *type;
858     MsgVarList *mvlist;
859     void printVars(XStr& str) {
860       if(mvlist!=0) {
861         str << "{\n";
862         mvlist->print(str);
863         str << "}\n";
864       }
865     }
866   public:
867     Message(int l, NamedType *t, MsgVarList *mv=0)
868       : type(t), mvlist(mv) 
869       { line=l; setTemplate(0); }
870     void print(XStr& str);
871     void genDecls(XStr& str);
872     void genDefs(XStr& str);
873     void genReg(XStr& str);
874
875     virtual const char *proxyPrefix(void) {return Prefix::Message;}
876     void genAllocDecl(XStr& str);
877     int numArrays(void) {
878       if (mvlist==0) return 0;
879       int count = 0;
880       MsgVarList *mv = mvlist;
881       for (int i=0; i<mvlist->len(); ++i, mv=mv->next) if (mv->msg_var->isArray()) count ++;
882       return count;
883     }
884     int numConditional(void) {
885       if (mvlist==0) return 0;
886       int count = 0;
887       MsgVarList *mv = mvlist;
888       for (int i=0; i<mvlist->len(); ++i, mv=mv->next) if (mv->msg_var->isConditional()) count ++;
889       return count;
890     }
891     int numVars(void) { return ((mvlist==0) ? 0 : mvlist->len()); }
892 };
893
894
895
896
897
898 /******************* Entry Point ****************/
899 // Entry attributes
900 #define STHREADED 0x01
901 #define SSYNC     0x02
902 #define SLOCKED   0x04
903 #define SPURE     0x10
904 #define SMIGRATE  0x20 //<- is magic migration constructor
905 #define SCREATEHERE   0x40 //<- is a create-here-if-nonexistant
906 #define SCREATEHOME   0x80 //<- is a create-at-home-if-nonexistant
907 #define SIMMEDIATE    0x100 //<- is a immediate
908 #define SNOKEEP       0x200
909 #define SNOTRACE      0x400
910 #define SSKIPSCHED    0x800 //<- is a message skipping charm scheduler
911 #define SPYTHON       0x1000
912 #define SINLINE       0x2000 //<- inline message
913 #define SIGET         0x4000 
914 #define SLOCAL        0x8000 //<- local message
915 #define SACCEL        0x10000
916 #define SMEM          0x20000
917 #define SREDUCE       0x40000 // <- reduction target
918
919 /* An entry construct */
920 class Entry : public Member {
921   private:
922     int line,entryCount;
923     int attribs;    
924     Type *retType;
925     Value *stacksize;
926     const char *pythonDoc;
927     
928     XStr proxyName(void) {return container->proxyName();}
929     XStr indexName(void) {return container->indexName();}
930
931 //    friend class CParsedFile;
932     int hasCallMarshall;
933     void genCall(XStr &dest,const XStr &preCall, bool redn_wrapper=false);
934
935     XStr epStr(bool isForRedn = false, bool templateCall = false);
936     XStr epIdx(int fromProxy=1, bool isForRedn = false);
937     XStr epRegFn(int fromProxy=1, bool isForRedn = false);
938     XStr chareIdx(int fromProxy=1);
939     void genEpIdxDecl(XStr& str);
940     void genEpIdxDef(XStr& str);
941     
942     void genChareDecl(XStr& str);
943     void genChareStaticConstructorDecl(XStr& str);
944     void genChareStaticConstructorDefs(XStr& str);
945     void genChareDefs(XStr& str);
946     
947     void genArrayDefs(XStr& str);
948     void genArrayStaticConstructorDecl(XStr& str);
949     void genArrayStaticConstructorDefs(XStr& str);
950     void genArrayDecl(XStr& str);
951     
952     void genGroupDecl(XStr& str);
953     void genGroupStaticConstructorDecl(XStr& str);
954     void genGroupStaticConstructorDefs(XStr& str);
955     void genGroupDefs(XStr& str);
956     
957     void genPythonDecls(XStr& str);
958     void genPythonDefs(XStr& str);
959     void genPythonStaticDefs(XStr& str);
960     void genPythonStaticDocs(XStr& str);
961
962     // DMK - Accel Support
963     void genAccelFullParamList(XStr& str, int makeRefs);
964     void genAccelFullCallList(XStr& str);
965     void genAccelIndexWrapperDecl_general(XStr& str);
966     void genAccelIndexWrapperDef_general(XStr& str);
967     void genAccelIndexWrapperDecl_spe(XStr& str);
968     void genAccelIndexWrapperDef_spe(XStr& str);
969     int genAccels_spe_c_funcBodies(XStr& str);
970     void genAccels_spe_c_regFuncs(XStr& str);
971     void genAccels_ppe_c_regFuncs(XStr& str);
972
973     XStr paramType(int withDefaultVals,int withEO=0,int useConst=1);
974     XStr paramComma(int withDefaultVals,int withEO=0);
975     XStr eo(int withDefaultVals,int priorComma=1);
976     XStr syncReturn(void);
977     XStr marshallMsg(void);
978     XStr callThread(const XStr &procName,int prependEntryName=0);
979
980     // SDAG support
981     std::list<CStateVar *> estateVars;
982
983   public:
984     XStr *label;
985     char *name;
986     TParamList *targs;
987
988     // SDAG support
989     SdagConstruct *sdagCon;
990     std::list<CStateVar *> stateVars;
991     CEntry *entryPtr;
992     const char *intExpr;
993     ParamList *param;
994     ParamList *connectParam;
995     int isConnect;
996     int isWhenEntry;
997
998     void addEStateVar(CStateVar *sv) {
999       estateVars.push_back(sv);
1000       stateVars.push_back(sv);
1001     }
1002
1003     // DMK - Accel Support
1004     ParamList* accelParam;
1005     XStr* accelCodeBody;
1006     XStr* accelCallbackName;
1007     void setAccelParam(ParamList* apl) { accelParam = apl; }
1008     void setAccelCodeBody(XStr* acb) { accelCodeBody = acb; }
1009     void setAccelCallbackName(XStr* acbn) { accelCallbackName = acbn; }
1010
1011     // DMK - Accel Support
1012     int accel_numScalars;
1013     int accel_numArrays;
1014     int accel_dmaList_numReadOnly;
1015     int accel_dmaList_numReadWrite;
1016     int accel_dmaList_numWriteOnly;
1017     int accel_dmaList_scalarNeedsWrite;
1018
1019     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);
1020     void setChare(Chare *c);
1021     int isConnectEntry(void) { return isConnect; }
1022     int paramIsMarshalled(void) { return param->isMarshalled(); }
1023     int getStackSize(void) { return (stacksize ? stacksize->getIntVal() : 0); }
1024     int isThreaded(void) { return (attribs & STHREADED); }
1025     int isSync(void) { return (attribs & SSYNC); }
1026     int isIget(void) { return (attribs & SIGET); }
1027     int isConstructor(void) { return !strcmp(name, container->baseName(0).get_string());}
1028     int isExclusive(void) { return (attribs & SLOCKED); }
1029     int isImmediate(void) { return (attribs & SIMMEDIATE); }
1030     int isSkipscheduler(void) { return (attribs & SSKIPSCHED); }
1031     int isInline(void) { return attribs & SINLINE; }
1032     int isLocal(void) { return attribs & SLOCAL; }
1033     int isCreate(void) { return (attribs & SCREATEHERE)||(attribs & SCREATEHOME); }
1034     int isCreateHome(void) { return (attribs & SCREATEHOME); }
1035     int isCreateHere(void) { return (attribs & SCREATEHERE); }
1036     int isPython(void) { return (attribs & SPYTHON); }
1037     int isNoTrace(void) { return (attribs & SNOTRACE); }
1038     int isNoKeep(void) { return (attribs & SNOKEEP); }
1039     int isSdag(void) { return (sdagCon!=0); }
1040
1041     // DMK - Accel support
1042     int isAccel(void) { return (attribs & SACCEL); }
1043
1044     int isMemCritical(void) { return (attribs & SMEM); }
1045     int isReductionTarget(void) { return (attribs & SREDUCE); }
1046
1047     void print(XStr& str);
1048     void check();
1049     void genIndexDecls(XStr& str);
1050     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
1051     void genDecls(XStr& str);
1052     void genDefs(XStr& str);
1053     void genReg(XStr& str);
1054     XStr genRegEp(bool isForRedn = false);
1055     void preprocess();
1056     char *getEntryName() { return name; }
1057     void generateEntryList(std::list<CEntry*>&, WhenConstruct *);
1058     void collectSdagCode(CParsedFile *pf, int& sdagPresent);
1059     void propagateState(int);
1060     void lookforCEntry(CEntry *centry);
1061     int getLine() { return line; }
1062 };
1063
1064 class EntryList {
1065   public:
1066     Entry *entry;
1067     EntryList *next;
1068     EntryList(Entry *e,EntryList *elist=NULL):
1069         entry(e), next(elist) {}
1070     void generateEntryList(std::list<CEntry*>&, WhenConstruct *);
1071 };
1072
1073
1074 /******************** AccelBlock : Block of code for accelerator **********************/
1075 class AccelBlock : public Construct {
1076
1077  protected:
1078
1079   XStr* code;
1080
1081  private:
1082
1083   void outputCode(XStr& str) {
1084     if (code != NULL) {
1085       str << "\n#ifndef CK_TEMPLATES_ONLY\n"
1086           << "/***** Accel_Block Start *****/\n"
1087           << (*(code))
1088           << "\n/***** Accel_Block End *****/\n"
1089           << "#endif /*CK_TEMPLATES_ONLY*/\n\n";
1090     }
1091   }
1092
1093  public:
1094
1095   /// Constructor(s)/Destructor ///
1096   AccelBlock(int l, XStr* c) { line = l; code = c; }
1097   ~AccelBlock() { delete code; }
1098
1099   /// Printable Methods ///
1100   void print(XStr& str) { (void)str; }
1101
1102   /// Construct Methods ///
1103   void genDefs(XStr& str) { outputCode(str); }
1104
1105   /// Construct Accel Support Methods ///
1106   int genAccels_spe_c_funcBodies(XStr& str) { outputCode(str); return 0; }
1107 };
1108
1109
1110 /****************** Modules, etc. ****************/
1111 class Module : public Construct {
1112     int _isMain;
1113     const char *name;
1114     
1115   public:
1116     ConstructList *clist;
1117     Module(int l, const char *n, ConstructList *c) : name(n), clist(c) {
1118             line = l;
1119             _isMain=0;
1120             if (clist!=NULL) clist->setModule(this);
1121     }
1122     void print(XStr& str);
1123     void check();
1124     void generate();
1125     void setModule();
1126     void prependConstruct(Construct *c) { clist = new ConstructList(-1, c, clist); }
1127     void preprocess();
1128     void genDepend(const char *cifile);
1129     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
1130     void genDecls(XStr& str);
1131     void genDefs(XStr& str);
1132     void genReg(XStr& str);
1133     void setMain(void) { _isMain = 1; }
1134     int isMain(void) { return _isMain; }
1135
1136     // DMK - Accel Support
1137     int genAccels_spe_c_funcBodies(XStr& str);
1138     void genAccels_spe_c_regFuncs(XStr& str);
1139     void genAccels_spe_c_callInits(XStr& str);
1140     void genAccels_spe_h_includes(XStr& str);
1141     void genAccels_spe_h_fiCountDefs(XStr& str);
1142     void genAccels_ppe_c_regFuncs(XStr& str);
1143 };
1144
1145 class ModuleList : public Printable {
1146     std::list<Module*> modules;
1147   public:
1148     int line;
1149     ModuleList(int l, Module *m, ModuleList *n=0) : line(l)
1150         {
1151             modules.push_back(m);
1152             if (n)
1153                 modules.insert(modules.end(),
1154                                n->modules.begin(), n->modules.end());
1155         }
1156     void print(XStr& str);
1157     void check();
1158     void generate();
1159     void preprocess();
1160     void genDepends(std::string ciFileBaseName);
1161 };
1162
1163 class Readonly : public Member {
1164     int msg; // is it a readonly var(0) or msg(1) ?
1165     Type *type;
1166     const char *name;
1167     ValueList *dims;
1168     XStr qName(void) const { /*Return fully qualified name*/
1169       XStr ret;
1170       if(container) ret<<container->baseName()<<"::";
1171       ret<<name;
1172       return ret;
1173     }
1174   public:
1175     Readonly(int l, Type *t, const char *n, ValueList* d, int m=0)
1176             : msg(m), type(t), name(n)
1177             { line=l; dims=d; setChare(0); }
1178     void print(XStr& str);
1179     void genDecls(XStr& str);
1180     void genIndexDecls(XStr& str);
1181     void genDefs(XStr& str);
1182     void genReg(XStr& str);
1183 };
1184
1185 class InitCall : public Member {
1186
1187     const char *name; //Name of subroutine to call
1188     int isNodeCall;
1189
1190     // DMK - Accel Support
1191     int isAccelFlag;
1192
1193 public:
1194
1195     InitCall(int l, const char *n, int nodeCall);
1196     void print(XStr& str);
1197     void genReg(XStr& str);
1198
1199     // DMK - Accel Support
1200     void genAccels_spe_c_callInits(XStr& str);
1201
1202     void setAccel() { isAccelFlag = 1; }
1203     void clearAccel() { isAccelFlag = 0; }
1204     int isAccel() { return isAccelFlag; }
1205 };
1206
1207 class PUPableClass : public Member {
1208     NamedType* type;
1209     PUPableClass *next; //Linked-list of PUPable classes
1210 public:
1211     PUPableClass(int l, NamedType* type_, PUPableClass *next_);
1212     void print(XStr& str);
1213     void genDefs(XStr& str);
1214     void genReg(XStr& str);
1215
1216     // DMK - Accel Support
1217     int genAccels_spe_c_funcBodies(XStr& str) {
1218       int rtn=0;
1219       if (next) { rtn += next->genAccels_spe_c_funcBodies(str); }
1220       return rtn;
1221     }
1222     void genAccels_spe_c_regFuncs(XStr& str) {
1223       if (next) { next->genAccels_spe_c_regFuncs(str); }
1224     }
1225     void genAccels_spe_c_callInits(XStr& str) {
1226       if (next) { next->genAccels_spe_c_callInits(str); }
1227     }
1228     void genAccels_spe_h_includes(XStr& str) {
1229       if (next) { next->genAccels_spe_h_includes(str); }
1230     }
1231     void genAccels_spe_h_fiCountDefs(XStr& str) {
1232       if (next) { next->genAccels_spe_h_fiCountDefs(str); }
1233     }
1234     void genAccels_ppe_c_regFuncs(XStr& str) {
1235       if (next) { next->genAccels_ppe_c_regFuncs(str); }
1236     }
1237 };
1238
1239 class IncludeFile : public Member {
1240     const char *name; //Name of include file
1241 public:
1242     IncludeFile(int l, const char *name_);
1243     void print(XStr& str);
1244     void genDecls(XStr& str);
1245 };
1246
1247 class ClassDeclaration : public Member {
1248     const char *name; //Name of class 
1249 public:
1250     ClassDeclaration(int l, const char *name_);
1251     void print(XStr& str);
1252     void genDecls(XStr& str);
1253 };
1254
1255
1256 /******************* Structured Dagger Constructs ***************/
1257 class SdagConstruct { 
1258 private:
1259   void generateOverlap(XStr& decls, XStr& defs, Entry* entry);
1260   void generateWhile(XStr& decls, XStr& defs, Entry* entry);
1261   void generateFor(XStr& decls, XStr& defs, Entry* entry);
1262   void generateIf(XStr& decls, XStr& defs, Entry* entry);
1263   void generateElse(XStr& decls, XStr& defs, Entry* entry);
1264   void generateForall(XStr& decls, XStr& defs, Entry* entry);
1265   void generateOlist(XStr& decls, XStr& defs, Entry* entry);
1266   void generateSdagEntry(XStr& decls, XStr& defs, Entry *entry);
1267   void generateSlist(XStr& decls, XStr& defs, Entry* entry);
1268   void generateAtomic(XStr& decls, XStr& defs, Entry* entry);
1269   void generateForward(XStr& decls, XStr& defs, Entry* entry);
1270   void generateConnect(XStr& decls, XStr& defs, Entry* entry);
1271
1272 protected:
1273   void generateCall(XStr& defs, std::list<CStateVar*>& args,
1274                     const XStr* name, const char* nameSuffix = 0);
1275
1276   void generateTraceBeginCall(XStr& defs);          // for trace
1277   void generateBeginTime(XStr& defs);               //for Event Bracket
1278   void generateEventBracket(XStr& defs, int eventType);     //for Event Bracket
1279   void generateListEventBracket(XStr& defs, int eventType);
1280   void generateChildrenCode(XStr& decls, XStr& defs, Entry* entry);
1281   void generateChildrenEntryList(std::list<CEntry*>& CEntrylist, WhenConstruct *thisWhen);
1282   void propagateStateToChildren(std::list<CStateVar*>&, std::list<CStateVar*>&, std::list<SdagConstruct*>&, int);
1283   std::list<SdagConstruct *> *constructs;
1284   std::list<SdagConstruct *> *publishesList;
1285   std::list<CStateVar *> *stateVars;
1286   std::list<CStateVar *> *stateVarsChildren;
1287
1288 public:
1289   int nodeNum;
1290   XStr *label;
1291   XStr *counter;
1292   EToken type;
1293   char nameStr[128];
1294   XStr *traceName;      
1295   SdagConstruct *next;
1296   ParamList *param;
1297   XStr *text;
1298   XStr *connectEntry;
1299   int nextBeginOrEnd;
1300   EntryList *elist;
1301   SdagConstruct *con1, *con2, *con3, *con4;
1302   SdagConstruct(EToken t, SdagConstruct *construct1);
1303
1304   SdagConstruct(EToken t, SdagConstruct *construct1, SdagConstruct *aList);
1305
1306   SdagConstruct(EToken t, XStr *txt, SdagConstruct *c1, SdagConstruct *c2, SdagConstruct *c3,
1307               SdagConstruct *c4, SdagConstruct *constructAppend, EntryList *el);
1308
1309  SdagConstruct(EToken t, const char *str) : type(t), traceName(NULL), con1(0), con2(0), con3(0), con4(0)
1310   { text = new XStr(str); constructs = new std::list<SdagConstruct*>();
1311     publishesList = new std::list<SdagConstruct*>(); }
1312                                              
1313  
1314   SdagConstruct(EToken t) : type(t), traceName(NULL), con1(0), con2(0), con3(0), con4(0) 
1315   { publishesList = new std::list<SdagConstruct*>();
1316                   constructs = new std::list<SdagConstruct*>(); }
1317
1318   SdagConstruct(EToken t, XStr *txt) : type(t), traceName(NULL), text(txt), con1(0), con2(0), con3(0), con4(0) 
1319   { publishesList = new std::list<SdagConstruct*>();
1320                   constructs = new std::list<SdagConstruct*>();  }
1321   SdagConstruct(EToken t, const char *entryStr, const char *codeStr, ParamList *pl);
1322   void numberNodes(void);
1323   void labelNodes(void);
1324   void generateConnectEntryList(std::list<SdagConstruct*>&);
1325   void generateConnectEntries(XStr&);
1326   virtual void generateEntryList(std::list<CEntry*>&, WhenConstruct *);
1327   void propagateState(int);
1328   virtual void propagateState(std::list<CStateVar*>&, std::list<CStateVar*>&, std::list<SdagConstruct*>&, int);
1329   virtual void generateCode(XStr& decls, XStr& defs, Entry *entry);
1330   void generateWhenCode(XStr& op);
1331   void setNext(SdagConstruct *, int);
1332
1333   // for trace
1334   void generateTrace();          
1335   void generateRegisterEp(XStr& defs);
1336   void generateTraceEp(XStr& decls, XStr& defs, Chare* chare);
1337   static void generateTraceEndCall(XStr& defs);
1338   static void generateTlineEndCall(XStr& defs);
1339   static void generateBeginExec(XStr& defs, const char *name);
1340   static void generateEndExec(XStr& defs);
1341   static void generateEndSeq(XStr& defs);
1342   static void generateDummyBeginExecute(XStr& defs);
1343 };
1344
1345 class WhenConstruct : public SdagConstruct {
1346 public:
1347   void generateCode(XStr& decls, XStr& defs, Entry *entry);
1348   WhenConstruct(EntryList *el, SdagConstruct *body)
1349     : SdagConstruct(SWHEN, 0, 0, 0,0,0, body, el)
1350   { }
1351   void generateEntryList(std::list<CEntry*>& CEntrylist, WhenConstruct *thisWhen);
1352   void propagateState(std::list<CStateVar*>&, std::list<CStateVar*>&, std::list<SdagConstruct*>&, int);
1353 };
1354
1355 SdagConstruct *buildAtomic(const char* code,
1356                            SdagConstruct *pub_list,
1357                            const char *trace_name);
1358
1359 extern void RemoveSdagComments(char *);
1360
1361 }
1362
1363 #endif