charmxi: print commit ID when erroring out
[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 extern const char * const CmiCommitID;
18
19 namespace xi {
20
21 class CStateVar;
22
23 /******************* Utilities ****************/
24
25 class Prefix {
26 public:
27   static const char *Proxy;
28   static const char *ProxyElement;
29   static const char *ProxySection;
30   static const char *Message;
31   static const char *Index;
32   static const char *Python;
33 };
34
35 typedef enum {
36   forAll=0,forIndividual=1,forSection=2,forPython=3,forIndex=-1
37 } forWhom;
38
39 class Chare;//Forward declaration
40 class Message;
41 class TParamList;
42 extern int fortranMode;
43 extern int internalMode;
44 extern const char *cur_file;
45 void die(const char *why,int line=-1);
46
47 class Value : public Printable {
48   private:
49     int factor;
50     const char *val;
51   public:
52     Value(const char *s);
53     void print(XStr& str) { str << val; }
54     int getIntVal(void);
55 };
56
57 class ValueList : public Printable {
58   private:
59     Value *val;
60     ValueList *next;
61   public:
62     ValueList(Value* v, ValueList* n=0) : val(v), next(n) {}
63     void print(XStr& str) {
64       if(val) {
65         str << "["; val->print(str); str << "]";
66       }
67       if(next)
68         next->print(str);
69     }
70     void printValue(XStr& str) {
71       if(val) {
72         val->print(str);
73       }
74       if(next) {
75           std::cout << "Unsupported type\n";
76           abort();
77       }
78     }
79 };
80
81 class Module;
82
83 class Construct : public Printable {
84   protected:
85     int external;
86   public:
87     int line;
88     Module *containerModule;
89     Construct() {external=0;line=-1;}
90     void setExtern(int &e) { external = e; }
91     void setModule(Module *m) { containerModule = m; }
92     virtual void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent)
93     {
94       (void)declstr; (void)defstr; (void)defconstr; (void)connectPresent;
95     }
96     virtual void genDecls(XStr& str) { (void)str; }
97     virtual void genDefs(XStr& str) { (void)str; }
98     virtual void genReg(XStr& str) { (void)str; }
99     virtual void preprocess() { }
100
101     // DMK - Accel Support
102     virtual int genAccels_spe_c_funcBodies(XStr& str) { (void)str; return 0; }
103     virtual void genAccels_spe_c_regFuncs(XStr& str) { (void)str; }
104     virtual void genAccels_spe_c_callInits(XStr& str) { (void)str; }
105     virtual void genAccels_spe_h_includes(XStr& str) { (void)str; }
106     virtual void genAccels_spe_h_fiCountDefs(XStr& str) { (void)str; }
107     virtual void genAccels_ppe_c_regFuncs(XStr& str) { (void)str; }
108 };
109
110 class ConstructList : public Construct {
111     std::list<Construct*> constructs;
112   public:
113     ConstructList(int l, Construct *c, ConstructList *n=0);
114     void setExtern(int e);
115     void setModule(Module *m);
116     void print(XStr& str);
117     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
118     void genDecls(XStr& str);
119     void genDefs(XStr& str);
120     void genReg(XStr& str);
121     void preprocess();
122
123     // DMK - Accel Support
124     int genAccels_spe_c_funcBodies(XStr& str);
125     void genAccels_spe_c_regFuncs(XStr& str);
126     void genAccels_spe_c_callInits(XStr& str);
127     void genAccels_spe_h_includes(XStr& str);
128     void genAccels_spe_h_fiCountDefs(XStr& str);
129     void genAccels_ppe_c_regFuncs(XStr& str);
130 };
131
132 /*********************** Type System **********************/
133 class Type : public Printable {
134   public:
135     virtual void print(XStr&) = 0;
136     virtual int isVoid(void) const {return 0;}
137     virtual int isBuiltin(void) const { return 0; }
138     virtual int isMessage(void) const {return 0;}
139     virtual int isTemplated(void) const { return 0; }
140     virtual int isPointer(void) const {return 0;}
141     virtual int isNamed(void) const { return 0; }
142     virtual int isCkArgMsgPtr(void) const {return 0;}
143     virtual int isCkArgMsg(void) const {return 0;}
144     virtual int isCkMigMsgPtr(void) const {return 0;}
145     virtual int isCkMigMsg(void) const {return 0;}
146     virtual int isReference(void) const {return 0;}
147     virtual Type *deref(void) {return this;}
148     virtual const char *getBaseName(void) const = 0;
149     virtual const char *getScope(void) const = 0;
150     virtual int getNumStars(void) const {return 0;}
151     virtual void genProxyName(XStr &str,forWhom forElement);
152     virtual void genIndexName(XStr &str);
153     virtual void genMsgProxyName(XStr& str);
154     XStr proxyName(forWhom w)
155         {XStr ret; genProxyName(ret,w); return ret;}
156     XStr indexName(void) 
157         {XStr ret; genIndexName(ret); return ret;}
158     XStr msgProxyName(void) 
159         {XStr ret; genMsgProxyName(ret); return ret;}
160     virtual void printVar(XStr &str, char *var) {print(str); str<<" "; str<<var;}
161     int operator==(const Type &tp) const {
162       return  (strcmp(getBaseName(), tp.getBaseName())==0);
163     }
164 };
165
166 class BuiltinType : public Type {
167   private:
168     char *name;
169   public:
170     BuiltinType(const char *n) : name((char *)n) {}
171     int isBuiltin(void) const {return 1;}
172     void print(XStr& str) { str << name; }
173     int isVoid(void) const { return !strcmp(name, "void"); }
174     int isInt(void) const { return !strcmp(name, "int"); }
175     const char *getBaseName(void) const { return name; }
176     const char *getScope(void) const { return NULL; }
177 };
178
179 class NamedType : public Type {
180   private:
181     const char* name;
182     const char* scope;
183     TParamList *tparams;
184   public:
185     NamedType(const char* n, TParamList* t=0, const char* scope_=NULL)
186        : name(n), scope(scope_), tparams(t) {}
187     int isTemplated(void) const { return (tparams!=0); }
188     int isCkArgMsg(void) const {return 0==strcmp(name,"CkArgMsg");}
189     int isCkMigMsg(void) const {return 0==strcmp(name,"CkMigrateMessage");}
190     void print(XStr& str);
191     int isNamed(void) const {return 1;}
192     virtual const char *getBaseName(void) const { return name; }
193     virtual const char *getScope(void) const { return scope; }
194     virtual void genProxyName(XStr& str,forWhom forElement);
195     virtual void genIndexName(XStr& str);
196     virtual void genMsgProxyName(XStr& str);
197 };
198
199 class PtrType : public Type {
200   private:
201     Type *type;
202     int numstars; // level of indirection
203   public:
204     PtrType(Type *t) : type(t), numstars(1) {}
205     int isPointer(void) const {return 1;}
206     int isCkArgMsgPtr(void) const {return numstars==1 && type->isCkArgMsg();}
207     int isCkMigMsgPtr(void) const {return numstars==1 && type->isCkMigMsg();}
208     int isMessage(void) const {return numstars==1 && !type->isBuiltin();}
209     void indirect(void) { numstars++; }
210     int getNumStars(void) const {return numstars; }
211     void print(XStr& str);
212     const char *getBaseName(void) const { return type->getBaseName(); }
213     const char *getScope(void) const { return NULL; }
214     virtual void genMsgProxyName(XStr& str) { 
215       if(numstars != 1) {
216         die("too many stars-- entry parameter must have form 'MTYPE *msg'"); 
217       } else {
218         type->genMsgProxyName(str);
219       }
220     }
221 };
222
223 class ReferenceType : public Type {
224   private:
225     Type *referant;
226   public:
227     ReferenceType(Type *t) : referant(t) {}
228     int isReference(void) const {return 1;}
229     void print(XStr& str) {str<<referant<<" &";}
230     virtual Type *deref(void) {return referant;}
231     const char *getBaseName(void) const { return referant->getBaseName(); }
232     const char *getScope(void) const { return NULL; }
233 };
234
235 //This is used as a list of base classes
236 class TypeList : public Printable {
237     Type *type;
238     TypeList *next;
239   public:
240     TypeList(Type *t, TypeList *n=0) : type(t), next(n) {}
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     virtual void setChare(Chare *c) { container = c; }
624     virtual int isSdag(void) { return 0; }
625     virtual void collectSdagCode(CParsedFile *, int&) { return; }
626     XStr makeDecl(const XStr &returnType,int forProxy=0);
627     virtual void genPythonDecls(XStr& ) {}
628     virtual void genIndexDecls(XStr& ) {}
629     virtual void genPythonDefs(XStr& ) {}
630     virtual void genPythonStaticDefs(XStr&) {}
631     virtual void genPythonStaticDocs(XStr&) {}
632     virtual void lookforCEntry(CEntry *)  {}
633 };
634
635 /* List of members of a chare or group */
636 class MemberList : public Printable {
637     std::list<Member*> members;
638   public:
639     MemberList(Member *m, MemberList *n=0);
640     void appendMember(Member *m);
641     void print(XStr& str);
642     void setChare(Chare *c);
643     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
644     void genDecls(XStr& str);
645     void genIndexDecls(XStr& str);
646     void genPythonDecls(XStr& str);
647     void genDefs(XStr& str);
648     void genReg(XStr& str);
649     void preprocess();
650
651     // DMK - Accel Support
652     int genAccels_spe_c_funcBodies(XStr& str);
653     void genAccels_spe_c_regFuncs(XStr& str);
654     void genAccels_spe_c_callInits(XStr& str);
655     void genAccels_spe_h_includes(XStr& str);
656     void genAccels_spe_h_fiCountDefs(XStr& str);
657     void genAccels_ppe_c_regFuncs(XStr& str);
658
659     void genPythonDefs(XStr& str);
660     void genPythonStaticDefs(XStr& str);
661     void genPythonStaticDocs(XStr& str);
662     void collectSdagCode(CParsedFile *pf, int& sdagPresent);
663     virtual void lookforCEntry(CEntry *centry);
664 };
665
666 /* Chare or group is a templated entity */
667 class Chare : public TEntity {
668   public:
669     enum { //Set these attribute bits in "attrib"
670         CMIGRATABLE=1<<2,
671         CPYTHON=1<<3,
672         CCHARE=1<<9,                 // plain non-migratable chare
673         CMAINCHARE=1<<10,
674         CARRAY=1<<11,
675         CGROUP=1<<12,
676         CNODEGROUP=1<<13
677     };
678     typedef unsigned int attrib_t;
679   protected:
680     attrib_t attrib;
681     int hasElement;//0-- no element type; 1-- has element type
682     forWhom forElement;
683     int hasSection; //1-- applies only to array section
684
685     NamedType *type;
686     MemberList *list;
687     TypeList *bases; //Base classes used by proxy
688     TypeList *bases_CBase; //Base classes used by CBase (or NULL)
689     
690     int entryCount;
691     int hasSdagEntry;
692
693     void genTypedefs(XStr& str);
694     void genRegisterMethodDef(XStr& str);
695     void sharedDisambiguation(XStr &str,const XStr &superclass);
696   public:
697     Chare(int ln, attrib_t Nattr,
698         NamedType *t, TypeList *b=0, MemberList *l=0);
699     void genProxyNames(XStr& str, const char *prefix, const char *middle, 
700                         const char *suffix, const char *sep);
701     void genIndexNames(XStr& str, const char *prefix, const char *middle, 
702                         const char *suffix, const char *sep);
703     XStr proxyName(int withTemplates=1); 
704     XStr indexName(int withTemplates=1); 
705     XStr indexList();
706     XStr baseName(int withTemplates=1) 
707     {
708         XStr str;
709         str<<type->getBaseName();
710         if (withTemplates) str<<tvars();
711         return str;
712     }
713     int  isTemplated(void) { return (templat!=0); }
714     int  isMigratable(void) { return attrib&CMIGRATABLE; }
715     int  isPython(void) { return attrib&CPYTHON; }
716     int  isMainChare(void) {return attrib&CMAINCHARE;}
717     int  isChare(void) {return attrib&CCHARE;}     // plain non-migratable chare
718     int  isArray(void) {return attrib&CARRAY;}
719     int  isGroup(void) {return attrib&CGROUP;}
720     int  isNodeGroup(void) {return attrib&CNODEGROUP;}
721     int  isForElement(void) const {return forElement==forIndividual;}
722     int  isForSection(void) const {return forElement==forSection;}
723     int  hasSdag() const { return hasSdagEntry; }
724     void  setSdag(int f) { hasSdagEntry = f; }
725     forWhom getForWhom(void) const {return forElement;}
726     void print(XStr& str);
727     void genDefs(XStr& str);
728     void genReg(XStr& str);
729     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
730     void genDecls(XStr &str);
731     void preprocess();
732
733     // DMK - Accel Support
734     int genAccels_spe_c_funcBodies(XStr& str) {
735       int rtn = 0;
736       if (list) { rtn += list->genAccels_spe_c_funcBodies(str); }
737       return rtn;
738     }
739     void genAccels_spe_c_regFuncs(XStr& str) {
740       if (list) { list->genAccels_spe_c_regFuncs(str); }
741     }
742     void genAccels_spe_c_callInits(XStr& str) {
743       if (list) { list->genAccels_spe_c_callInits(str); }
744     }
745     void genAccels_spe_h_includes(XStr& str) {
746       if (list) { list->genAccels_spe_h_includes(str); }
747     }
748     void genAccels_spe_h_fiCountDefs(XStr& str) {
749       if (list) { list->genAccels_spe_h_fiCountDefs(str); }
750     }
751     void genAccels_ppe_c_regFuncs(XStr& str) {
752       if (list) { list->genAccels_ppe_c_regFuncs(str); }
753     }
754
755     int nextEntry(void) {return entryCount++;}
756     virtual void genSubDecls(XStr& str);
757     void genPythonDecls(XStr& str);
758     void genPythonDefs(XStr& str);
759     virtual char *chareTypeName(void) {return (char *)"chare";}
760     virtual char *proxyPrefix(void);
761     virtual void genSubRegisterMethodDef(XStr& str) { (void)str; }
762     void lookforCEntry(CEntry *centry);
763 };
764
765 class MainChare : public Chare {
766   public:
767     MainChare(int ln, attrib_t Nattr, 
768         NamedType *t, TypeList *b=0, MemberList *l=0):
769             Chare(ln, Nattr|CMAINCHARE, t,b,l) {}
770     virtual char *chareTypeName(void) {return (char *) "mainchare";}
771 };
772
773 class Array : public Chare {
774   protected:
775     XStr indexSuffix;
776     XStr indexType;//"CkArrayIndex"+indexSuffix;
777   public:
778     Array(int ln, attrib_t Nattr, NamedType *index,
779         NamedType *t, TypeList *b=0, MemberList *l=0);
780     virtual int is1D(void) {return indexSuffix==(const char*)"1D";}
781     virtual const char* dim(void) {return indexSuffix.get_string_const();}
782     virtual void genSubDecls(XStr& str);
783     virtual char *chareTypeName(void) {return (char *) "array";}
784 };
785
786 class Group : public Chare {
787   public:
788     Group(int ln, attrib_t Nattr,
789         NamedType *t, TypeList *b=0, MemberList *l=0);
790     virtual void genSubDecls(XStr& str);
791     virtual char *chareTypeName(void) {return (char *) "group";}
792     virtual void genSubRegisterMethodDef(XStr& str);
793 };
794
795 class NodeGroup : public Group {
796   public:
797     NodeGroup(int ln, attrib_t Nattr,
798         NamedType *t, TypeList *b=0, MemberList *l=0):
799             Group(ln,Nattr|CNODEGROUP,t,b,l) {}
800     virtual char *chareTypeName(void) {return (char *) "nodegroup";}
801 };
802
803
804 /****************** Messages ***************/
805 class Message; // forward declaration
806
807 class MsgVar {
808  public:
809   Type *type;
810   const char *name;
811   int cond;
812   int array;
813   MsgVar(Type *t, const char *n, int c, int a) : type(t), name(n), cond(c), array(a) { }
814   Type *getType() { return type; }
815   const char *getName() { return name; }
816   int isConditional() { return cond; }
817   int isArray() { return array; }
818   void print(XStr &str) {str<<(isConditional()?"conditional ":"");type->print(str);str<<" "<<name<<(isArray()?"[]":"")<<";";}
819 };
820
821 class MsgVarList : public Printable {
822  public:
823   MsgVar *msg_var;
824   MsgVarList *next;
825   MsgVarList(MsgVar *mv, MsgVarList *n=0) : msg_var(mv), next(n) {}
826   void print(XStr &str) {
827     msg_var->print(str);
828     str<<"\n";
829     if(next) next->print(str);
830   }
831   int len(void) { return (next==0)?1:(next->len()+1); }
832 };
833
834 class Message : public TEntity {
835     NamedType *type;
836     MsgVarList *mvlist;
837     void printVars(XStr& str) {
838       if(mvlist!=0) {
839         str << "{\n";
840         mvlist->print(str);
841         str << "}\n";
842       }
843     }
844   public:
845     Message(int l, NamedType *t, MsgVarList *mv=0)
846       : type(t), mvlist(mv) 
847       { line=l; setTemplate(0); }
848     void print(XStr& str);
849     void genDecls(XStr& str);
850     void genDefs(XStr& str);
851     void genReg(XStr& str);
852
853     virtual const char *proxyPrefix(void) {return Prefix::Message;}
854     void genAllocDecl(XStr& str);
855     int numArrays(void) {
856       if (mvlist==0) return 0;
857       int count = 0;
858       MsgVarList *mv = mvlist;
859       for (int i=0; i<mvlist->len(); ++i, mv=mv->next) if (mv->msg_var->isArray()) count ++;
860       return count;
861     }
862     int numConditional(void) {
863       if (mvlist==0) return 0;
864       int count = 0;
865       MsgVarList *mv = mvlist;
866       for (int i=0; i<mvlist->len(); ++i, mv=mv->next) if (mv->msg_var->isConditional()) count ++;
867       return count;
868     }
869     int numVars(void) { return ((mvlist==0) ? 0 : mvlist->len()); }
870 };
871
872
873
874
875
876 /******************* Entry Point ****************/
877 // Entry attributes
878 #define STHREADED 0x01
879 #define SSYNC     0x02
880 #define SLOCKED   0x04
881 #define SPURE     0x10
882 #define SMIGRATE  0x20 //<- is magic migration constructor
883 #define SCREATEHERE   0x40 //<- is a create-here-if-nonexistant
884 #define SCREATEHOME   0x80 //<- is a create-at-home-if-nonexistant
885 #define SIMMEDIATE    0x100 //<- is a immediate
886 #define SNOKEEP       0x200
887 #define SNOTRACE      0x400
888 #define SSKIPSCHED    0x800 //<- is a message skipping charm scheduler
889 #define SPYTHON       0x1000
890 #define SINLINE       0x2000 //<- inline message
891 #define SIGET         0x4000 
892 #define SLOCAL        0x8000 //<- local message
893 #define SACCEL        0x10000
894 #define SMEM          0x20000
895 #define SREDUCE       0x40000 // <- reduction target
896
897 /* An entry construct */
898 class Entry : public Member {
899   private:
900     int line,entryCount;
901     int attribs;    
902     Type *retType;
903     Value *stacksize;
904     const char *pythonDoc;
905     
906     XStr proxyName(void) {return container->proxyName();}
907     XStr indexName(void) {return container->indexName();}
908
909 //    friend class CParsedFile;
910     int hasCallMarshall;
911     void genCall(XStr &dest,const XStr &preCall, bool redn_wrapper=false);
912
913     XStr epStr(void);
914     XStr epIdx(int fromProxy=1);
915     XStr chareIdx(int fromProxy=1);
916     void genEpIdxDecl(XStr& str);
917     void genEpIdxDef(XStr& str);
918     
919     void genChareDecl(XStr& str);
920     void genChareStaticConstructorDecl(XStr& str);
921     void genChareStaticConstructorDefs(XStr& str);
922     void genChareDefs(XStr& str);
923     
924     void genArrayDefs(XStr& str);
925     void genArrayStaticConstructorDecl(XStr& str);
926     void genArrayStaticConstructorDefs(XStr& str);
927     void genArrayDecl(XStr& str);
928     
929     void genGroupDecl(XStr& str);
930     void genGroupStaticConstructorDecl(XStr& str);
931     void genGroupStaticConstructorDefs(XStr& str);
932     void genGroupDefs(XStr& str);
933     
934     void genPythonDecls(XStr& str);
935     void genPythonDefs(XStr& str);
936     void genPythonStaticDefs(XStr& str);
937     void genPythonStaticDocs(XStr& str);
938
939     // DMK - Accel Support
940     void genAccelFullParamList(XStr& str, int makeRefs);
941     void genAccelFullCallList(XStr& str);
942     void genAccelIndexWrapperDecl_general(XStr& str);
943     void genAccelIndexWrapperDef_general(XStr& str);
944     void genAccelIndexWrapperDecl_spe(XStr& str);
945     void genAccelIndexWrapperDef_spe(XStr& str);
946     int genAccels_spe_c_funcBodies(XStr& str);
947     void genAccels_spe_c_regFuncs(XStr& str);
948     void genAccels_ppe_c_regFuncs(XStr& str);
949
950     XStr paramType(int withDefaultVals,int withEO=0,int useConst=1);
951     XStr paramComma(int withDefaultVals,int withEO=0);
952     XStr eo(int withDefaultVals,int priorComma=1);
953     XStr syncReturn(void);
954     XStr marshallMsg(void);
955     XStr callThread(const XStr &procName,int prependEntryName=0);
956   public:
957     SdagConstruct *sdagCon;
958     TList<CStateVar *> *stateVars;
959     TList<CStateVar *> *stateVarsChildren;
960     TList<CStateVar *> estateVars;
961     CEntry *entryPtr;
962     XStr *label;
963     char *name;
964     const char *intExpr;
965     ParamList *param;
966     ParamList *connectParam;
967     int isConnect;
968     int isWhenEntry;
969
970     // DMK - Accel Support
971     ParamList* accelParam;
972     XStr* accelCodeBody;
973     XStr* accelCallbackName;
974     void setAccelParam(ParamList* apl) { accelParam = apl; }
975     void setAccelCodeBody(XStr* acb) { accelCodeBody = acb; }
976     void setAccelCallbackName(XStr* acbn) { accelCallbackName = acbn; }
977
978     // DMK - Accel Support
979     int accel_numScalars;
980     int accel_numArrays;
981     int accel_dmaList_numReadOnly;
982     int accel_dmaList_numReadWrite;
983     int accel_dmaList_numWriteOnly;
984     int accel_dmaList_scalarNeedsWrite;
985
986     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);
987     void setChare(Chare *c);
988     int isConnectEntry(void) { return isConnect; }
989     int paramIsMarshalled(void) { return param->isMarshalled(); }
990     int getStackSize(void) { return (stacksize ? stacksize->getIntVal() : 0); }
991     int isThreaded(void) { return (attribs & STHREADED); }
992     int isSync(void) { return (attribs & SSYNC); }
993     int isIget(void) { return (attribs & SIGET); }
994     int isConstructor(void) { return !strcmp(name, container->baseName(0).get_string());}
995     int isExclusive(void) { return (attribs & SLOCKED); }
996     int isImmediate(void) { return (attribs & SIMMEDIATE); }
997     int isSkipscheduler(void) { return (attribs & SSKIPSCHED); }
998     int isInline(void) { return attribs & SINLINE; }
999     int isLocal(void) { return attribs & SLOCAL; }
1000     int isCreate(void) { return (attribs & SCREATEHERE)||(attribs & SCREATEHOME); }
1001     int isCreateHome(void) { return (attribs & SCREATEHOME); }
1002     int isCreateHere(void) { return (attribs & SCREATEHERE); }
1003     int isPython(void) { return (attribs & SPYTHON); }
1004     int isNoTrace(void) { return (attribs & SNOTRACE); }
1005     int isNoKeep(void) { return (attribs & SNOKEEP); }
1006     int isSdag(void) { return (sdagCon!=0); }
1007
1008     // DMK - Accel support
1009     int isAccel(void) { return (attribs & SACCEL); }
1010
1011     int isMemCritical(void) { return (attribs & SMEM); }
1012     int isReductionTarget(void) { return (attribs & SREDUCE); }
1013
1014     void print(XStr& str);
1015     void genIndexDecls(XStr& str);
1016     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
1017     void genDecls(XStr& str);
1018     void genDefs(XStr& str);
1019     void genReg(XStr& str);
1020     void preprocess();
1021     char *getEntryName() { return name; }
1022     void generateEntryList(TList<CEntry*>&, SdagConstruct *);
1023     void collectSdagCode(CParsedFile *pf, int& sdagPresent);
1024     void propagateState(int);
1025     void lookforCEntry(CEntry *centry);
1026 };
1027
1028 class EntryList {
1029   public:
1030     Entry *entry;
1031     EntryList *next;
1032     EntryList(Entry *e,EntryList *elist=NULL):
1033         entry(e), next(elist) {}
1034     void generateEntryList(TList<CEntry*>&, SdagConstruct *);
1035 };
1036
1037
1038 /******************** AccelBlock : Block of code for accelerator **********************/
1039 class AccelBlock : public Construct {
1040
1041  protected:
1042
1043   XStr* code;
1044
1045  private:
1046
1047   void outputCode(XStr& str) {
1048     if (code != NULL) {
1049       str << "\n#ifndef CK_TEMPLATES_ONLY\n"
1050           << "/***** Accel_Block Start *****/\n"
1051           << (*(code))
1052           << "\n/***** Accel_Block End *****/\n"
1053           << "#endif /*CK_TEMPLATES_ONLY*/\n\n";
1054     }
1055   }
1056
1057  public:
1058
1059   /// Constructor(s)/Destructor ///
1060   AccelBlock(int l, XStr* c) { line = l; code = c; }
1061   ~AccelBlock() { delete code; }
1062
1063   /// Printable Methods ///
1064   void print(XStr& str) { (void)str; }
1065
1066   /// Construct Methods ///
1067   void genDefs(XStr& str) { outputCode(str); }
1068
1069   /// Construct Accel Support Methods ///
1070   int genAccels_spe_c_funcBodies(XStr& str) { outputCode(str); return 0; }
1071 };
1072
1073
1074 /****************** Modules, etc. ****************/
1075 class Module : public Construct {
1076     int _isMain;
1077     const char *name;
1078     
1079   public:
1080     ConstructList *clist;
1081     Module(int l, const char *n, ConstructList *c) : name(n), clist(c) {
1082             line = l;
1083             _isMain=0;
1084             if (clist!=NULL) clist->setModule(this);
1085     }
1086     void print(XStr& str);
1087     void generate();
1088     void setModule();
1089     void prependConstruct(Construct *c) { clist = new ConstructList(-1, c, clist); }
1090     void preprocess();
1091     void genDepend(const char *cifile);
1092     void genPub(XStr& declstr, XStr& defstr, XStr& defconstr, int& connectPresent);
1093     void genDecls(XStr& str);
1094     void genDefs(XStr& str);
1095     void genReg(XStr& str);
1096     void setMain(void) { _isMain = 1; }
1097     int isMain(void) { return _isMain; }
1098
1099     // DMK - Accel Support
1100     int genAccels_spe_c_funcBodies(XStr& str);
1101     void genAccels_spe_c_regFuncs(XStr& str);
1102     void genAccels_spe_c_callInits(XStr& str);
1103     void genAccels_spe_h_includes(XStr& str);
1104     void genAccels_spe_h_fiCountDefs(XStr& str);
1105     void genAccels_ppe_c_regFuncs(XStr& str);
1106 };
1107
1108 class ModuleList : public Printable {
1109     std::list<Module*> modules;
1110   public:
1111     int line;
1112     ModuleList(int l, Module *m, ModuleList *n=0) : line(l)
1113         {
1114             modules.push_back(m);
1115             if (n)
1116                 modules.insert(modules.end(),
1117                                n->modules.begin(), n->modules.end());
1118         }
1119     void print(XStr& str);
1120     void generate();
1121     void preprocess();
1122     void genDepends(std::string ciFileBaseName);
1123 };
1124
1125 class Readonly : public Member {
1126     int msg; // is it a readonly var(0) or msg(1) ?
1127     Type *type;
1128     const char *name;
1129     ValueList *dims;
1130     XStr qName(void) const { /*Return fully qualified name*/
1131       XStr ret;
1132       if(container) ret<<container->baseName()<<"::";
1133       ret<<name;
1134       return ret;
1135     }
1136   public:
1137     Readonly(int l, Type *t, const char *n, ValueList* d, int m=0)
1138             : msg(m), type(t), name(n)
1139             { line=l; dims=d; setChare(0); }
1140     void print(XStr& str);
1141     void genDecls(XStr& str);
1142     void genIndexDecls(XStr& str);
1143     void genDefs(XStr& str);
1144     void genReg(XStr& str);
1145 };
1146
1147 class InitCall : public Member {
1148
1149     const char *name; //Name of subroutine to call
1150     int isNodeCall;
1151
1152     // DMK - Accel Support
1153     int isAccelFlag;
1154
1155 public:
1156
1157     InitCall(int l, const char *n, int nodeCall);
1158     void print(XStr& str);
1159     void genReg(XStr& str);
1160
1161     // DMK - Accel Support
1162     void genAccels_spe_c_callInits(XStr& str);
1163
1164     void setAccel() { isAccelFlag = 1; }
1165     void clearAccel() { isAccelFlag = 0; }
1166     int isAccel() { return isAccelFlag; }
1167 };
1168
1169 class PUPableClass : public Member {
1170     NamedType* type;
1171     PUPableClass *next; //Linked-list of PUPable classes
1172 public:
1173     PUPableClass(int l, NamedType* type_, PUPableClass *next_);
1174     void print(XStr& str);
1175     void genDefs(XStr& str);
1176     void genReg(XStr& str);
1177
1178     // DMK - Accel Support
1179     int genAccels_spe_c_funcBodies(XStr& str) {
1180       int rtn=0;
1181       if (next) { rtn += next->genAccels_spe_c_funcBodies(str); }
1182       return rtn;
1183     }
1184     void genAccels_spe_c_regFuncs(XStr& str) {
1185       if (next) { next->genAccels_spe_c_regFuncs(str); }
1186     }
1187     void genAccels_spe_c_callInits(XStr& str) {
1188       if (next) { next->genAccels_spe_c_callInits(str); }
1189     }
1190     void genAccels_spe_h_includes(XStr& str) {
1191       if (next) { next->genAccels_spe_h_includes(str); }
1192     }
1193     void genAccels_spe_h_fiCountDefs(XStr& str) {
1194       if (next) { next->genAccels_spe_h_fiCountDefs(str); }
1195     }
1196     void genAccels_ppe_c_regFuncs(XStr& str) {
1197       if (next) { next->genAccels_ppe_c_regFuncs(str); }
1198     }
1199 };
1200
1201 class IncludeFile : public Member {
1202     const char *name; //Name of include file
1203 public:
1204     IncludeFile(int l, const char *name_);
1205     void print(XStr& str);
1206     void genDecls(XStr& str);
1207 };
1208
1209 class ClassDeclaration : public Member {
1210     const char *name; //Name of class 
1211 public:
1212     ClassDeclaration(int l, const char *name_);
1213     void print(XStr& str);
1214     void genDecls(XStr& str);
1215 };
1216
1217
1218 /******************* Structured Dagger Constructs ***************/
1219 class SdagConstruct { 
1220 private:
1221   void generateWhen(XStr& op);
1222   void generateOverlap(XStr& op);
1223   void generateWhile(XStr& op);
1224   void generateFor(XStr& op);
1225   void generateIf(XStr& op);
1226   void generateElse(XStr& op);
1227   void generateForall(XStr& op);
1228   void generateOlist(XStr& op);
1229   void generateSdagEntry(XStr& op);
1230   void generateSlist(XStr& op);
1231   void generateAtomic(XStr& op);
1232   void generateForward(XStr& op);
1233   void generateConnect(XStr& op);
1234   void generatePrototype(XStr& op, ParamList *list);
1235   void generatePrototype(XStr& op, TList<CStateVar*>&);
1236   void generateCall(XStr& op, TList<CStateVar*>&);
1237
1238   void generateTraceBeginCall(XStr& op);          // for trace
1239   void generateBeginTime(XStr& op);               //for Event Bracket
1240   void generateEventBracket(XStr& op, int eventType);     //for Event Bracket
1241   void generateListEventBracket(XStr& op, int eventType);
1242 public:
1243   int nodeNum;
1244   XStr *label;
1245   XStr *counter;
1246   EToken type;
1247   char nameStr[128];
1248   XStr *traceName;      
1249   TList<SdagConstruct *> *constructs;
1250   TList<SdagConstruct *> *publishesList;
1251   TList<CStateVar *> *stateVars;
1252   TList<CStateVar *> *stateVarsChildren;
1253   SdagConstruct *next;
1254   ParamList *param;
1255   XStr *text;
1256   XStr *connectEntry;
1257   int nextBeginOrEnd;
1258   EntryList *elist;
1259   SdagConstruct *con1, *con2, *con3, *con4;
1260   SdagConstruct(EToken t, SdagConstruct *construct1);
1261
1262   SdagConstruct(EToken t, SdagConstruct *construct1, SdagConstruct *aList);
1263
1264   SdagConstruct(EToken t, XStr *txt, SdagConstruct *c1, SdagConstruct *c2, SdagConstruct *c3,
1265               SdagConstruct *c4, SdagConstruct *constructAppend, EntryList *el);
1266
1267  SdagConstruct(EToken t, const char *str) : type(t), traceName(NULL), con1(0), con2(0), con3(0), con4(0)
1268                 { text = new XStr(str); constructs = new TList<SdagConstruct*>(); 
1269                   publishesList = new TList<SdagConstruct*>(); }
1270                                              
1271  
1272   SdagConstruct(EToken t) : type(t), traceName(NULL), con1(0), con2(0), con3(0), con4(0) 
1273                 { publishesList = new TList<SdagConstruct*>();
1274                   constructs = new TList<SdagConstruct*>(); }
1275
1276   SdagConstruct(EToken t, XStr *txt) : type(t), traceName(NULL), text(txt), con1(0), con2(0), con3(0), con4(0) 
1277                 { publishesList = new TList<SdagConstruct*>();
1278                   constructs = new TList<SdagConstruct*>();  }
1279   SdagConstruct(EToken t, const char *entryStr, const char *codeStr, ParamList *pl);
1280   void numberNodes(void);
1281   void labelNodes(void);
1282   void generateConnectEntryList(TList<SdagConstruct*>&);
1283   void generateConnectEntries(XStr&);
1284   void generateEntryList(TList<CEntry*>&, SdagConstruct *);
1285   void propagateState(int);
1286   void propagateState(TList<CStateVar*>&, TList<CStateVar*>&, TList<SdagConstruct*>&, int);
1287   void generateCode(XStr& output);
1288   void setNext(SdagConstruct *, int);
1289
1290   // for trace
1291   void generateTrace();          
1292   void generateRegisterEp(XStr& output);          
1293   void generateTraceEpDecl(XStr& output);         
1294   void generateTraceEpDef(XStr& output);          
1295   static void generateTraceEndCall(XStr& op);            
1296   static void generateTlineEndCall(XStr& op);
1297   static void generateBeginExec(XStr& op, const char *name);
1298   static void generateEndExec(XStr& op);
1299   static void generateEndSeq(XStr& op);
1300   static void generateDummyBeginExecute(XStr& op);
1301
1302 };
1303
1304 SdagConstruct *buildAtomic(const char* code,
1305                            SdagConstruct *pub_list,
1306                            const char *trace_name);
1307
1308 extern void RemoveSdagComments(char *);
1309
1310 }
1311
1312 #endif