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