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