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