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