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