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