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