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