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