Merge branch 'charm' of charmgit:charm into harshitha/adaptive_lb
[charm.git] / src / xlat-i / xi-grammar.y
1 %expect 6
2 %{
3 #include <iostream>
4 #include <string>
5 #include <string.h>
6 #include "xi-symbol.h"
7 #include "EToken.h"
8 using namespace xi;
9 extern int yylex (void) ;
10 extern unsigned char in_comment;
11 void yyerror(const char *);
12 extern unsigned int lineno;
13 extern int in_bracket,in_braces,in_int_expr;
14 extern std::list<Entry *> connectEntries;
15 ModuleList *modlist;
16 namespace xi {
17 extern int macroDefined(const char *str, int istrue);
18 extern const char *python_doc;
19 void splitScopedName(const char* name, const char** scope, const char** basename);
20 }
21 %}
22
23 %union {
24   ModuleList *modlist;
25   Module *module;
26   ConstructList *conslist;
27   Construct *construct;
28   TParam *tparam;
29   TParamList *tparlist;
30   Type *type;
31   PtrType *ptype;
32   NamedType *ntype;
33   FuncType *ftype;
34   Readonly *readonly;
35   Message *message;
36   Chare *chare;
37   Entry *entry;
38   EntryList *entrylist;
39   Parameter *pname;
40   ParamList *plist;
41   Template *templat;
42   TypeList *typelist;
43   MemberList *mbrlist;
44   Member *member;
45   TVar *tvar;
46   TVarList *tvarlist;
47   Value *val;
48   ValueList *vallist;
49   MsgVar *mv;
50   MsgVarList *mvlist;
51   PUPableClass *pupable;
52   IncludeFile *includeFile;
53   const char *strval;
54   int intval;
55   Chare::attrib_t cattr;
56   SdagConstruct *sc;
57   WhenConstruct *when;
58   XStr* xstrptr;
59   AccelBlock* accelBlock;
60 }
61
62 %token MODULE
63 %token MAINMODULE
64 %token EXTERN
65 %token READONLY
66 %token INITCALL
67 %token INITNODE
68 %token INITPROC
69 %token PUPABLE
70 %token <intval> CHARE MAINCHARE GROUP NODEGROUP ARRAY
71 %token MESSAGE
72 %token CONDITIONAL
73 %token CLASS
74 %token INCLUDE
75 %token STACKSIZE
76 %token THREADED
77 %token TEMPLATE
78 %token SYNC IGET EXCLUSIVE IMMEDIATE SKIPSCHED INLINE VIRTUAL MIGRATABLE 
79 %token CREATEHERE CREATEHOME NOKEEP NOTRACE
80 %token VOID
81 %token CONST
82 %token PACKED
83 %token VARSIZE
84 %token ENTRY
85 %token FOR
86 %token FORALL
87 %token WHILE
88 %token WHEN
89 %token OVERLAP
90 %token ATOMIC
91 %token FORWARD
92 %token IF
93 %token ELSE
94 %token CONNECT
95 %token PUBLISHES 
96 %token PYTHON LOCAL
97 %token NAMESPACE
98 %token USING 
99 %token <strval> IDENT NUMBER LITERAL CPROGRAM HASHIF HASHIFDEF
100 %token <intval> INT LONG SHORT CHAR FLOAT DOUBLE UNSIGNED
101 %token ACCEL
102 %token READWRITE
103 %token WRITEONLY
104 %token ACCELBLOCK
105 %token MEMCRITICAL
106 %token REDUCTIONTARGET
107 %token CASE
108
109 %type <modlist>         ModuleEList File
110 %type <module>          Module
111 %type <conslist>        ConstructEList ConstructList
112 %type <construct>       Construct ConstructSemi
113 %type <strval>          Name QualName CCode CPROGRAM_List OptNameInit 
114 %type <strval>          OptTraceName
115 %type <val>             OptStackSize
116 %type <intval>          OptExtern OptSemiColon MAttribs MAttribList MAttrib
117 %type <intval>          OptConditional MsgArray
118 %type <intval>          EAttribs EAttribList EAttrib OptVoid
119 %type <cattr>           CAttribs CAttribList CAttrib
120 %type <cattr>           ArrayAttribs ArrayAttribList ArrayAttrib
121 %type <tparam>          TParam
122 %type <tparlist>        TParamList TParamEList OptTParams
123 %type <type>            BaseType Type SimpleType OptTypeInit EReturn
124 %type <type>            BuiltinType
125 %type <ftype>           FuncType
126 %type <ntype>           NamedType QualNamedType ArrayIndexType
127 %type <ptype>           PtrType OnePtrType
128 %type <readonly>        Readonly ReadonlyMsg
129 %type <message>         Message TMessage
130 %type <chare>           Chare Group NodeGroup Array TChare TGroup TNodeGroup TArray
131 %type <entry>           Entry SEntry
132 %type <entrylist>       SEntryList
133 %type <templat>         Template
134 %type <pname>           Parameter ParamBracketStart AccelParameter AccelArrayParam
135 %type <plist>           ParamList EParameters AccelParamList AccelEParameters
136 %type <intval>          AccelBufferType
137 %type <xstrptr>         AccelInstName
138 %type <accelBlock>      AccelBlock
139 %type <typelist>        BaseList OptBaseList
140 %type <mbrlist>         MemberEList MemberList
141 %type <member>          Member MemberBody NonEntryMember InitNode InitProc UnexpectedToken
142 %type <pupable>         PUPableClass
143 %type <includeFile>     IncludeFile
144 %type <tvar>            TVar
145 %type <tvarlist>        TVarList TemplateSpec
146 %type <val>             ArrayDim Dim DefaultParameter
147 %type <vallist>         DimList
148 %type <mv>              Var
149 %type <mvlist>          VarList
150 %type <intval>          ParamBraceStart ParamBraceEnd SParamBracketStart SParamBracketEnd StartIntExpr EndIntExpr
151 %type <sc>              Slist SingleConstruct Olist OptSdagCode HasElse ForwardList PublishesList OptPubList CaseList
152 %type <when>            WhenConstruct NonWhenConstruct
153 %type <intval>          PythonOptions
154
155 %%
156
157 File            : ModuleEList
158                 { $$ = $1; modlist = $1; }
159                 ;
160
161 ModuleEList     : /* Empty */
162                 { 
163                   $$ = 0; 
164                 }
165                 | Module ModuleEList
166                 { $$ = new ModuleList(lineno, $1, $2); }
167                 ;
168
169 OptExtern       : /* Empty */
170                 { $$ = 0; }
171                 | EXTERN
172                 { $$ = 1; }
173                 ;
174
175 OptSemiColon    : /* Empty */
176                 { $$ = 0; }
177                 | ';'
178                 { $$ = 1; }
179                 ;
180
181 Name            : IDENT
182                 { $$ = $1; }
183                 ;
184
185 QualName        : IDENT
186                 { $$ = $1; }
187                 | QualName ':'':' IDENT
188                 {
189                   char *tmp = new char[strlen($1)+strlen($4)+3];
190                   sprintf(tmp,"%s::%s", $1, $4);
191                   $$ = tmp;
192                 }
193                 ;
194
195 Module          : MODULE Name ConstructEList
196                 { 
197                     $$ = new Module(lineno, $2, $3); 
198                 }
199                 | MAINMODULE Name ConstructEList
200                 {  
201                     $$ = new Module(lineno, $2, $3); 
202                     $$->setMain();
203                 }
204                 ;
205
206 ConstructEList  : ';'
207                 { $$ = 0; }
208                 | '{' ConstructList '}' OptSemiColon
209                 { $$ = $2; }
210                 ;
211
212 ConstructList   : /* Empty */
213                 { $$ = 0; }
214                 | Construct ConstructList
215                 { $$ = new ConstructList(lineno, $1, $2); }
216                 ;
217
218 ConstructSemi   : USING NAMESPACE QualName
219                 { $$ = new UsingScope($3, false); }
220                 | USING QualName
221                 { $$ = new UsingScope($2, true); }
222                 | OptExtern NonEntryMember
223                 { $2->setExtern($1); $$ = $2; }
224                 | OptExtern Message
225                 { $2->setExtern($1); $$ = $2; }
226                 | EXTERN ENTRY EReturn QualNamedType Name OptTParams EParameters
227                 {
228                   Entry *e = new Entry(lineno, 0, $3, $5, $7, 0, 0, 0, 0, 0);
229                   int isExtern = 1;
230                   e->setExtern(isExtern);
231                   e->targs = $6;
232                   e->label = new XStr;
233                   $4->print(*e->label);
234                   $$ = e;
235                 }
236                 ;
237
238 Construct       : OptExtern '{' ConstructList '}' OptSemiColon
239         { if($3) $3->setExtern($1); $$ = $3; }
240         | NAMESPACE Name '{' ConstructList '}'
241         { $$ = new Scope($2, $4); }
242         | ConstructSemi ';'
243         { $$ = $1; }
244         | ConstructSemi UnexpectedToken
245         { yyerror("The preceding construct must be semicolon terminated"); YYABORT; }
246         | OptExtern Module
247         { $2->setExtern($1); $$ = $2; }
248         | OptExtern Chare
249         { $2->setExtern($1); $$ = $2; }
250         | OptExtern Group
251         { $2->setExtern($1); $$ = $2; }
252         | OptExtern NodeGroup
253         { $2->setExtern($1); $$ = $2; }
254         | OptExtern Array
255         { $2->setExtern($1); $$ = $2; }
256         | OptExtern Template
257         { $2->setExtern($1); $$ = $2; }
258         | HashIFComment
259         { $$ = NULL; }
260         | HashIFDefComment
261         { $$ = NULL; }
262         | AccelBlock
263         { $$ = $1; }
264         | error
265         { printf("Invalid construct\n"); YYABORT; }
266         ;
267
268 TParam          : Type
269                 { $$ = new TParamType($1); }
270                 | NUMBER
271                 { $$ = new TParamVal($1); }
272                 | LITERAL
273                 { $$ = new TParamVal($1); }
274                 ;
275
276 TParamList      : TParam
277                 { $$ = new TParamList($1); }
278                 | TParam ',' TParamList
279                 { $$ = new TParamList($1, $3); }
280                 ;
281
282 TParamEList     : /* Empty */
283                 { $$ = 0; }
284                 | TParamList
285                 { $$ = $1; }
286                 ;
287
288 OptTParams      :  /* Empty */
289                 { $$ = 0; }
290                 | '<' TParamEList '>'
291                 { $$ = $2; }
292                 ;
293
294 BuiltinType     : INT
295                 { $$ = new BuiltinType("int"); }
296                 | LONG
297                 { $$ = new BuiltinType("long"); }
298                 | SHORT
299                 { $$ = new BuiltinType("short"); }
300                 | CHAR
301                 { $$ = new BuiltinType("char"); }
302                 | UNSIGNED INT
303                 { $$ = new BuiltinType("unsigned int"); }
304                 | UNSIGNED LONG
305                 { $$ = new BuiltinType("unsigned long"); }
306                 | UNSIGNED LONG INT
307                 { $$ = new BuiltinType("unsigned long"); }
308                 | UNSIGNED LONG LONG
309                 { $$ = new BuiltinType("unsigned long long"); }
310                 | UNSIGNED SHORT
311                 { $$ = new BuiltinType("unsigned short"); }
312                 | UNSIGNED CHAR
313                 { $$ = new BuiltinType("unsigned char"); }
314                 | LONG LONG
315                 { $$ = new BuiltinType("long long"); }
316                 | FLOAT
317                 { $$ = new BuiltinType("float"); }
318                 | DOUBLE
319                 { $$ = new BuiltinType("double"); }
320                 | LONG DOUBLE
321                 { $$ = new BuiltinType("long double"); }
322                 | VOID
323                 { $$ = new BuiltinType("void"); }
324                 ;
325
326 NamedType       : Name OptTParams { $$ = new NamedType($1,$2); };
327 QualNamedType   : QualName OptTParams { 
328                     const char* basename, *scope;
329                     splitScopedName($1, &scope, &basename);
330                     $$ = new NamedType(basename, $2, scope);
331                 }
332                 ;
333
334 SimpleType      : BuiltinType
335                 { $$ = $1; }
336                 | QualNamedType
337                 { $$ = $1; }
338                 ;
339
340 OnePtrType      : SimpleType '*'
341                 { $$ = new PtrType($1); }
342                 ;
343
344 PtrType         : OnePtrType '*'
345                 { $1->indirect(); $$ = $1; }
346                 | PtrType '*'
347                 { $1->indirect(); $$ = $1; }
348                 ;
349
350 FuncType        : BaseType '(' '*' Name ')' '(' ParamList ')'
351                 { $$ = new FuncType($1, $4, $7); }
352                 ;
353
354 BaseType        : SimpleType
355                 { $$ = $1; }
356                 | OnePtrType
357                 { $$ = $1; }
358                 | PtrType
359                 { $$ = $1; }
360                 | FuncType
361                 { $$ = $1; }
362                 //{ $$ = $1; }
363                 | CONST BaseType 
364                 { $$ = new ConstType($2); }
365                 | BaseType CONST
366                 { $$ = new ConstType($1); }
367                 ;
368
369 Type            : BaseType '&'
370                 { $$ = new ReferenceType($1); }
371                 | BaseType
372                 { $$ = $1; }
373                 ;
374
375 ArrayDim        : NUMBER
376                 { $$ = new Value($1); }
377                 | QualName
378                 { $$ = new Value($1); }
379                 ;
380
381 Dim             : '[' ArrayDim ']'
382                 { $$ = $2; }
383                 ;
384
385 DimList         : /* Empty */
386                 { $$ = 0; }
387                 | Dim DimList
388                 { $$ = new ValueList($1, $2); }
389                 ;
390
391 Readonly        : READONLY Type QualName DimList
392                 { $$ = new Readonly(lineno, $2, $3, $4); }
393                 ;
394
395 ReadonlyMsg     : READONLY MESSAGE SimpleType '*'  Name
396                 { $$ = new Readonly(lineno, $3, $5, 0, 1); }
397                 ;
398
399 OptVoid         : /*Empty*/
400                 { $$ = 0;}
401                 | VOID
402                 { $$ = 0;}
403                 ;
404
405 MAttribs        : /* Empty */
406                 { $$ = 0; }
407                 | '[' MAttribList ']'
408                 { 
409                   /*
410                   printf("Warning: Message attributes are being phased out.\n");
411                   printf("Warning: Please remove them from interface files.\n");
412                   */
413                   $$ = $2; 
414                 }
415                 ;
416
417 MAttribList     : MAttrib
418                 { $$ = $1; }
419                 | MAttrib ',' MAttribList
420                 { $$ = $1 | $3; }
421                 ;
422
423 MAttrib         : PACKED
424                 { $$ = 0; }
425                 | VARSIZE
426                 { $$ = 0; }
427                 ;
428
429 CAttribs        : /* Empty */
430                 { $$ = 0; }
431                 | '[' CAttribList ']'
432                 { $$ = $2; }
433                 ;
434
435 CAttribList     : CAttrib
436                 { $$ = $1; }
437                 | CAttrib ',' CAttribList
438                 { $$ = $1 | $3; }
439                 ;
440
441 PythonOptions   : /* Empty */
442                 { python_doc = NULL; $$ = 0; }
443                 | LITERAL
444                 { python_doc = $1; $$ = 0; }
445                 ;
446
447 ArrayAttrib     : PYTHON
448                 { $$ = Chare::CPYTHON; }
449                 ;
450
451 ArrayAttribs    : /* Empty */
452                 { $$ = 0; }
453                 | '[' ArrayAttribList ']'
454                 { $$ = $2; }
455                 ;
456
457 ArrayAttribList : ArrayAttrib
458                 { $$ = $1; }
459                 | ArrayAttrib ',' ArrayAttribList
460                 { $$ = $1 | $3; }
461                 ;
462
463 CAttrib         : MIGRATABLE
464                 { $$ = Chare::CMIGRATABLE; }
465                 | PYTHON
466                 { $$ = Chare::CPYTHON; }
467                 ;
468
469 OptConditional  : /* Empty */
470                 { $$ = 0; }
471                 | CONDITIONAL
472                 { $$ = 1; }
473
474 MsgArray        : /* Empty */
475                 { $$ = 0; }
476                 | '[' ']'
477                 { $$ = 1; }
478
479 Var             : OptConditional Type Name MsgArray ';'
480                 { $$ = new MsgVar($2, $3, $1, $4); }
481                 ;
482
483 VarList         : Var
484                 { $$ = new MsgVarList($1); }
485                 | Var VarList
486                 { $$ = new MsgVarList($1, $2); }
487                 ;
488
489 Message         : MESSAGE MAttribs NamedType
490                 { $$ = new Message(lineno, $3); }
491                 | MESSAGE MAttribs NamedType '{' VarList '}'
492                 { $$ = new Message(lineno, $3, $5); }
493                 ;
494
495 OptBaseList     : /* Empty */
496                 { $$ = 0; }
497                 | ':' BaseList
498                 { $$ = $2; }
499                 ;
500
501 BaseList        : QualNamedType
502                 { $$ = new TypeList($1); }
503                 | QualNamedType ',' BaseList
504                 { $$ = new TypeList($1, $3); }
505                 ;
506
507 Chare           : CHARE CAttribs NamedType OptBaseList MemberEList
508                 { $$ = new Chare(lineno, $2|Chare::CCHARE, $3, $4, $5); }
509                 | MAINCHARE CAttribs NamedType OptBaseList MemberEList
510                 { $$ = new MainChare(lineno, $2, $3, $4, $5); }
511                 ;
512
513 Group           : GROUP CAttribs NamedType OptBaseList MemberEList
514                 { $$ = new Group(lineno, $2, $3, $4, $5); }
515                 ;
516
517 NodeGroup       : NODEGROUP CAttribs NamedType OptBaseList MemberEList
518                 { $$ = new NodeGroup(lineno, $2, $3, $4, $5); }
519                 ;
520
521 ArrayIndexType  : '[' NUMBER Name ']'
522                 {/*Stupid special case for [1D] indices*/
523                         char *buf=new char[40];
524                         sprintf(buf,"%sD",$2);
525                         $$ = new NamedType(buf); 
526                 }
527                 | '[' Name ']'
528                 { $$ = new NamedType($2); }
529                 ;
530
531 Array           : ARRAY ArrayAttribs ArrayIndexType NamedType OptBaseList MemberEList
532                 {  $$ = new Array(lineno, $2, $3, $4, $5, $6); }
533                 | ARRAY ArrayIndexType ArrayAttribs NamedType OptBaseList MemberEList
534                 {  $$ = new Array(lineno, $3, $2, $4, $5, $6); }
535                 ;
536
537 TChare          : CHARE CAttribs Name OptBaseList MemberEList
538                 { $$ = new Chare(lineno, $2|Chare::CCHARE, new NamedType($3), $4, $5);}
539                 | MAINCHARE CAttribs Name OptBaseList MemberEList
540                 { $$ = new MainChare(lineno, $2, new NamedType($3), $4, $5); }
541                 ;
542
543 TGroup          : GROUP CAttribs Name OptBaseList MemberEList
544                 { $$ = new Group(lineno, $2, new NamedType($3), $4, $5); }
545                 ;
546
547 TNodeGroup      : NODEGROUP CAttribs Name OptBaseList MemberEList
548                 { $$ = new NodeGroup( lineno, $2, new NamedType($3), $4, $5); }
549                 ;
550
551 TArray          : ARRAY ArrayIndexType Name OptBaseList MemberEList
552                 { $$ = new Array( lineno, 0, $2, new NamedType($3), $4, $5); }
553                 ;
554
555 TMessage        : MESSAGE MAttribs Name ';'
556                 { $$ = new Message(lineno, new NamedType($3)); }
557                 | MESSAGE MAttribs Name '{' VarList '}' ';'
558                 { $$ = new Message(lineno, new NamedType($3), $5); }
559                 ;
560
561 OptTypeInit     : /* Empty */
562                 { $$ = 0; }
563                 | '=' Type
564                 { $$ = $2; }
565                 ;
566
567 OptNameInit     : /* Empty */
568                 { $$ = 0; }
569                 | '=' NUMBER
570                 { $$ = $2; }
571                 | '=' LITERAL
572                 { $$ = $2; }
573                 ;
574
575 TVar            : CLASS Name OptTypeInit
576                 { $$ = new TType(new NamedType($2), $3); }
577                 | FuncType OptNameInit
578                 { $$ = new TFunc($1, $2); }
579                 | Type Name OptNameInit
580                 { $$ = new TName($1, $2, $3); }
581                 ;
582
583 TVarList        : TVar
584                 { $$ = new TVarList($1); }
585                 | TVar ',' TVarList
586                 { $$ = new TVarList($1, $3); }
587                 ;
588
589 TemplateSpec    : TEMPLATE '<' TVarList '>'
590                 { $$ = $3; }
591                 ;
592
593 Template        : TemplateSpec TChare
594                 { $$ = new Template($1, $2); $2->setTemplate($$); }
595                 | TemplateSpec TGroup
596                 { $$ = new Template($1, $2); $2->setTemplate($$); }
597                 | TemplateSpec TNodeGroup
598                 { $$ = new Template($1, $2); $2->setTemplate($$); }
599                 | TemplateSpec TArray
600                 { $$ = new Template($1, $2); $2->setTemplate($$); }
601                 | TemplateSpec TMessage
602                 { $$ = new Template($1, $2); $2->setTemplate($$); }
603                 ;
604
605 MemberEList     : ';'
606                 { $$ = 0; }
607                 | '{' MemberList '}' OptSemiColon
608                 { $$ = $2; }
609                 ;
610
611 MemberList      : /* Empty */
612                 { 
613                   if (!connectEntries.empty()) {
614                     $$ = new MemberList(connectEntries);
615                   } else {
616                     $$ = 0; 
617                   }
618                 }
619                 | Member MemberList
620                 { $$ = new MemberList($1, $2); }
621                 ;
622
623 NonEntryMember  : Readonly
624                 { $$ = $1; }
625                 | ReadonlyMsg
626                 { $$ = $1; }
627                 | InitProc
628                 | InitNode
629                 { $$ = $1; }
630                 | PUPABLE PUPableClass
631                 { $$ = $2; }
632                 | INCLUDE IncludeFile
633                 { $$ = $2; }
634                 | CLASS Name
635                 { $$ = new ClassDeclaration(lineno,$2); } 
636                 ;
637
638 InitNode        : INITNODE OptVoid QualName
639                 { $$ = new InitCall(lineno, $3, 1); }
640                 | INITNODE OptVoid QualName '(' OptVoid ')'
641                 { $$ = new InitCall(lineno, $3, 1); }
642                 | INITNODE OptVoid QualName '<' TParamList '>' '(' OptVoid ')'
643                 { $$ = new InitCall(lineno,
644                                     strdup((std::string($3) + '<' +
645                                             ($5)->to_string() + '>').c_str()),
646                                     1);
647                 }
648                 | INITCALL OptVoid QualName
649                 { printf("Warning: deprecated use of initcall. Use initnode or initproc instead.\n"); 
650                   $$ = new InitCall(lineno, $3, 1); }
651                 | INITCALL OptVoid QualName '(' OptVoid ')'
652                 { printf("Warning: deprecated use of initcall. Use initnode or initproc instead.\n");
653                   $$ = new InitCall(lineno, $3, 1); }
654                 ;
655
656 InitProc        : INITPROC OptVoid QualName
657                 { $$ = new InitCall(lineno, $3, 0); }
658                 | INITPROC OptVoid QualName '(' OptVoid ')'
659                 { $$ = new InitCall(lineno, $3, 0); }
660                 | INITPROC OptVoid QualName '<' TParamList '>' '(' OptVoid ')'
661                 { $$ = new InitCall(lineno,
662                                     strdup((std::string($3) + '<' +
663                                             ($5)->to_string() + '>').c_str()),
664                                     0);
665                 }
666                 | INITPROC '[' ACCEL ']' OptVoid QualName '(' OptVoid ')'
667                 {
668                   InitCall* rtn = new InitCall(lineno, $6, 0);
669                   rtn->setAccel();
670                   $$ = rtn;
671                 }
672                 ;
673
674 PUPableClass    : QualNamedType
675                 { $$ = new PUPableClass(lineno,$1,0); } 
676                 | QualNamedType ',' PUPableClass
677                 { $$ = new PUPableClass(lineno,$1,$3); }
678                 ;
679 IncludeFile    : LITERAL
680                 { $$ = new IncludeFile(lineno,$1); } 
681                 ;
682
683 Member          : MemberBody ';'
684                 { $$ = $1; }
685                 // Error constructions
686                 | MemberBody UnexpectedToken
687                 { yyerror("The preceding entry method declaration must be semicolon-terminated."); YYABORT; }
688                 ;
689
690 MemberBody      : Entry
691                 { $$ = $1; }
692                 | TemplateSpec Entry
693                 {
694                   $2->tspec = $1;
695                   $$ = $2;
696                 }
697                 | NonEntryMember
698                 { $$ = $1; }
699                 ;
700
701 UnexpectedToken : ENTRY
702                 { $$ = 0; }
703                 | '}'
704                 { $$ = 0; }
705                 | INITCALL
706                 { $$ = 0; }
707                 | INITNODE
708                 { $$ = 0; }
709                 | INITPROC
710                 { $$ = 0; }
711                 | CHARE
712                 { $$ = 0; }
713                 | MAINCHARE
714                 { $$ = 0; }
715                 | ARRAY
716                 { $$ = 0; }
717                 | GROUP
718                 { $$ = 0; }
719                 | NODEGROUP
720                 { $$ = 0; }
721                 | READONLY
722                 { $$ = 0; }
723
724 Entry           : ENTRY EAttribs EReturn Name EParameters OptStackSize OptSdagCode
725                 { 
726                   if ($7 != 0) { 
727                     $7->con1 = new SdagConstruct(SIDENT, $4);
728                     $7->param = new ParamList($5);
729                   }
730                   $$ = new Entry(lineno, $2, $3, $4, $5, $6, $7, 0, 0); 
731                 }
732                 | ENTRY EAttribs Name EParameters OptSdagCode /*Constructor*/
733                 { 
734                   if ($5 != 0) {
735                     $5->con1 = new SdagConstruct(SIDENT, $3);
736                     $5->param = new ParamList($4);
737                   }
738                   Entry *e = new Entry(lineno, $2,     0, $3, $4,  0, $5, 0, 0);
739                   if (e->param && e->param->isCkMigMsgPtr()) {
740                     yyerror("Charm++ takes a CkMigrateMsg chare constructor for granted, but continuing anyway");
741                     $$ = NULL;
742                   } else
743                     $$ = e;
744                 }
745                 | ENTRY '[' ACCEL ']' VOID Name EParameters AccelEParameters ParamBraceStart CCode ParamBraceEnd Name /* DMK : Accelerated Entry Method */
746                 {
747                   int attribs = SACCEL;
748                   const char* name = $6;
749                   ParamList* paramList = $7;
750                   ParamList* accelParamList = $8;
751                   XStr* codeBody = new XStr($10);
752                   const char* callbackName = $12;
753
754                   $$ = new Entry(lineno, attribs, new BuiltinType("void"), name, paramList,
755                                  0, 0, 0, 0, 0
756                                 );
757                   $$->setAccelParam(accelParamList);
758                   $$->setAccelCodeBody(codeBody);
759                   $$->setAccelCallbackName(new XStr(callbackName));
760                 }
761                 ;
762
763 AccelBlock      : ACCELBLOCK ParamBraceStart CCode ParamBraceEnd ';'
764                 { $$ = new AccelBlock(lineno, new XStr($3)); }
765                 | ACCELBLOCK ';'
766                 { $$ = new AccelBlock(lineno, NULL); }
767                 ;
768
769 EReturn         : VOID
770                 { $$ = new BuiltinType("void"); }
771                 | OnePtrType
772                 { $$ = $1; }
773                 ;
774
775 EAttribs        : /* Empty */
776                 { $$ = 0; }
777                 | '[' EAttribList ']'
778                 { $$ = $2; }
779                 | error
780                 { printf("Invalid entry method attribute list\n"); YYABORT; }
781                 ;
782
783 EAttribList     : EAttrib
784                 { $$ = $1; }
785                 | EAttrib ',' EAttribList
786                 { $$ = $1 | $3; }
787                 ;
788
789 EAttrib         : THREADED
790                 { $$ = STHREADED; }
791                 | SYNC
792                 { $$ = SSYNC; }
793                 | IGET
794                 { $$ = SIGET; }
795                 | EXCLUSIVE
796                 { $$ = SLOCKED; }
797                 | CREATEHERE
798                 { $$ = SCREATEHERE; }
799                 | CREATEHOME
800                 { $$ = SCREATEHOME; }
801                 | NOKEEP
802                 { $$ = SNOKEEP; }
803                 | NOTRACE
804                 { $$ = SNOTRACE; }
805                 | IMMEDIATE
806                 { $$ = SIMMEDIATE; }
807                 | SKIPSCHED
808                 { $$ = SSKIPSCHED; }
809                 | INLINE
810                 { $$ = SINLINE; }
811                 | LOCAL
812                 { $$ = SLOCAL; }
813                 | PYTHON PythonOptions
814                 { $$ = SPYTHON; }
815                 | MEMCRITICAL
816                 { $$ = SMEM; }
817                 | REDUCTIONTARGET
818                 { $$ = SREDUCE; }
819                 | error
820                 { printf("Invalid entry method attribute: %s\n", yylval); YYABORT; }
821                 ;
822
823 DefaultParameter: LITERAL
824                 { $$ = new Value($1); }
825                 | NUMBER
826                 { $$ = new Value($1); }
827                 | QualName
828                 { $$ = new Value($1); }
829                 ;
830
831 CPROGRAM_List   :  /* Empty */
832                 { $$ = ""; }
833                 | CPROGRAM
834                 { $$ = $1; }
835                 | CPROGRAM ',' CPROGRAM_List
836                 {  /*Returned only when in_bracket*/
837                         char *tmp = new char[strlen($1)+strlen($3)+3];
838                         sprintf(tmp,"%s, %s", $1, $3);
839                         $$ = tmp;
840                 }
841                 ;
842
843 CCode           : /* Empty */
844                 { $$ = ""; }
845                 | CPROGRAM
846                 { $$ = $1; }
847                 | CPROGRAM '[' CCode ']' CCode
848                 {  /*Returned only when in_bracket*/
849                         char *tmp = new char[strlen($1)+strlen($3)+strlen($5)+3];
850                         sprintf(tmp,"%s[%s]%s", $1, $3, $5);
851                         $$ = tmp;
852                 }
853                 | CPROGRAM '{' CCode '}' CCode
854                 { /*Returned only when in_braces*/
855                         char *tmp = new char[strlen($1)+strlen($3)+strlen($5)+3];
856                         sprintf(tmp,"%s{%s}%s", $1, $3, $5);
857                         $$ = tmp;
858                 }
859                 | CPROGRAM '(' CPROGRAM_List ')' CCode
860                 { /*Returned only when in_braces*/
861                         char *tmp = new char[strlen($1)+strlen($3)+strlen($5)+3];
862                         sprintf(tmp,"%s(%s)%s", $1, $3, $5);
863                         $$ = tmp;
864                 }
865                 |'(' CCode ')' CCode
866                 { /*Returned only when in_braces*/
867                         char *tmp = new char[strlen($2)+strlen($4)+3];
868                         sprintf(tmp,"(%s)%s", $2, $4);
869                         $$ = tmp;
870                 }
871                 ;
872
873 ParamBracketStart : Type Name '['
874                 {  /*Start grabbing CPROGRAM segments*/
875                         in_bracket=1;
876                         $$ = new Parameter(lineno, $1,$2);
877                 }
878                 ;
879
880 ParamBraceStart : '{'
881                 { 
882                    /*Start grabbing CPROGRAM segments*/
883                         in_braces=1;
884                         $$ = 0;
885                 }
886                 ;
887
888 ParamBraceEnd   : '}'
889                 { 
890                         in_braces=0;
891                         $$ = 0;
892                 }
893                 ;
894
895 Parameter       : Type
896                 { $$ = new Parameter(lineno, $1);}
897                 | Type Name OptConditional
898                 { $$ = new Parameter(lineno, $1,$2); $$->setConditional($3); }
899                 | Type Name '=' DefaultParameter
900                 { $$ = new Parameter(lineno, $1,$2,0,$4);} 
901                 | ParamBracketStart CCode ']'
902                 { /*Stop grabbing CPROGRAM segments*/
903                         in_bracket=0;
904                         $$ = new Parameter(lineno, $1->getType(), $1->getName() ,$2);
905                 } 
906                 ;
907
908 AccelBufferType : READONLY  { $$ = Parameter::ACCEL_BUFFER_TYPE_READONLY; }
909                 | READWRITE { $$ = Parameter::ACCEL_BUFFER_TYPE_READWRITE; }
910                 | WRITEONLY { $$ = Parameter::ACCEL_BUFFER_TYPE_WRITEONLY; }
911                 ;
912
913 AccelInstName   : Name { $$ = new XStr($1); }
914                 | AccelInstName '-' '>' Name { $$ = new XStr(""); *($$) << *($1) << "->" << $4; }
915                 | AccelInstName '.' Name { $$ = new XStr(""); *($$) << *($1) << "." << $3; }
916                 | AccelInstName '[' AccelInstName ']'
917                 {
918                   $$ = new XStr("");
919                   *($$) << *($1) << "[" << *($3) << "]";
920                   delete $1;
921                   delete $3;
922                 }
923                 | AccelInstName '[' NUMBER ']'
924                 {
925                   $$ = new XStr("");
926                   *($$) << *($1) << "[" << $3 << "]";
927                   delete $1;
928                 }
929                 | AccelInstName '(' AccelInstName ')'
930                 {
931                   $$ = new XStr("");
932                   *($$) << *($1) << "(" << *($3) << ")";
933                   delete $1;
934                   delete $3;
935                 }
936                 ;
937
938 AccelArrayParam : ParamBracketStart CCode ']'
939                 {
940                   in_bracket = 0;
941                   $$ = new Parameter(lineno, $1->getType(), $1->getName(), $2);
942                 }
943                 ;
944
945 AccelParameter  : AccelBufferType ':' Type Name '<' AccelInstName '>'
946                 {
947                   $$ = new Parameter(lineno, $3, $4);
948                   $$->setAccelInstName($6);
949                   $$->setAccelBufferType($1);
950                 }
951                 | Type Name '<' AccelInstName '>'
952                 {
953                   $$ = new Parameter(lineno, $1, $2);
954                   $$->setAccelInstName($4);
955                   $$->setAccelBufferType(Parameter::ACCEL_BUFFER_TYPE_READWRITE);
956                 }
957                 | AccelBufferType ':' AccelArrayParam '<' AccelInstName '>'
958                 {
959                   $$ = $3;
960                   $$->setAccelInstName($5);
961                   $$->setAccelBufferType($1);
962                 }
963                 ;
964
965 ParamList       : Parameter
966                 { $$ = new ParamList($1); }
967                 | Parameter ',' ParamList
968                 { $$ = new ParamList($1,$3); }
969                 ;
970
971 AccelParamList  : AccelParameter
972                 { $$ = new ParamList($1); }
973                 | AccelParameter ',' AccelParamList
974                 { $$ = new ParamList($1,$3); }
975                 ;
976
977 EParameters     : '(' ParamList ')'
978                 { $$ = $2; }
979                 | '(' ')'
980                 { $$ = new ParamList(new Parameter(0, new BuiltinType("void"))); }
981                 ;
982
983 AccelEParameters  : '[' AccelParamList ']'
984                   { $$ = $2; }
985                   | '[' ']'
986                   { $$ = 0; }
987                   ;
988
989 OptStackSize    : /* Empty */
990                 { $$ = 0; }
991                 | STACKSIZE '=' NUMBER
992                 { $$ = new Value($3); }
993                 ;
994
995 OptSdagCode     : /* Empty */
996                 { $$ = 0; }
997                 | SingleConstruct
998                 { $$ = new SdagConstruct(SSDAGENTRY, $1); }
999                 | '{' Slist '}'
1000                 { $$ = new SdagConstruct(SSDAGENTRY, $2); }
1001                 ;
1002
1003 Slist           : SingleConstruct
1004                 { $$ = new SdagConstruct(SSLIST, $1); }
1005                 | SingleConstruct Slist
1006                 { $$ = new SdagConstruct(SSLIST, $1, $2);  }
1007                 ;
1008
1009 Olist           : SingleConstruct
1010                 { $$ = new SdagConstruct(SOLIST, $1); }
1011                 | SingleConstruct Slist
1012                 { $$ = new SdagConstruct(SOLIST, $1, $2); } 
1013                 ;
1014
1015 CaseList        : WhenConstruct
1016                 { $$ = new SdagConstruct(SCASELIST, $1); }
1017                 | WhenConstruct CaseList
1018                 { $$ = new SdagConstruct(SCASELIST, $1, $2); }
1019                 | NonWhenConstruct
1020                 { yyerror("Case blocks in SDAG can only contain when clauses."); YYABORT; }
1021                 ;
1022
1023 OptPubList      : /* Empty */
1024                 { $$ = 0; }
1025                 | PUBLISHES '(' PublishesList ')'
1026                 { $$ = $3; }
1027                 ;
1028
1029 PublishesList   : IDENT 
1030                 { $$ = new SdagConstruct(SPUBLISHES, new SdagConstruct(SIDENT, $1)); }
1031                 | IDENT ',' PublishesList 
1032                 { $$ = new SdagConstruct(SPUBLISHES, new SdagConstruct(SIDENT, $1), $3);  }
1033                 ;
1034
1035 OptTraceName    : LITERAL
1036                  { $$ = $1; }
1037                 |
1038                  { $$ = 0; }
1039                 ;
1040
1041 WhenConstruct   : WHEN SEntryList '{' '}'
1042                 { $$ = new WhenConstruct($2, 0); }
1043                 | WHEN SEntryList SingleConstruct
1044                 { $$ = new WhenConstruct($2, $3); }
1045                 | WHEN SEntryList '{' Slist '}'
1046                 { $$ = new WhenConstruct($2, $4); }
1047                 ;
1048
1049 NonWhenConstruct : ATOMIC
1050                  { $$ = 0; }
1051                  | CONNECT
1052                  { $$ = 0; }
1053                  | OVERLAP
1054                  { $$ = 0; }
1055                  | FOR
1056                  { $$ = 0; }
1057                  | FORALL
1058                  { $$ = 0; }
1059                  | IF
1060                  { $$ = 0; }
1061                  | WHILE
1062                  { $$ = 0; }
1063                  | FORWARD
1064                  { $$ = 0; }
1065                  ;
1066
1067 SingleConstruct : ATOMIC OptTraceName ParamBraceStart CCode ParamBraceEnd OptPubList 
1068                  {
1069                    $$ = buildAtomic($4, $6, $2);
1070                  }
1071                 | CONNECT '(' IDENT EParameters ')' ParamBraceStart CCode '}'
1072                 {  
1073                    in_braces = 0;
1074                    if (($4->isVoid() == 0) && ($4->isMessage() == 0))
1075                    {
1076                       connectEntries.push_back(new Entry(0, 0, new BuiltinType("void"), $3,
1077                                         new ParamList(new Parameter(lineno, new PtrType( 
1078                                         new NamedType("CkMarshallMsg")), "_msg")), 0, 0, 0, 1, $4));
1079                    }
1080                    else  {
1081                       connectEntries.push_back(new Entry(0, 0, new BuiltinType("void"), $3, $4, 0, 0, 0, 1, $4));
1082                    }
1083                    $$ = new SdagConstruct(SCONNECT, $3, $7, $4);
1084                 }
1085                 | OVERLAP '{' Olist '}'
1086                 { $$ = new SdagConstruct(SOVERLAP,0, 0,0,0,0,$3, 0); }  
1087                 | WhenConstruct
1088                 { $$ = $1; }
1089                 | CASE '{' CaseList '}'
1090                 { $$ = new SdagConstruct(SCASE, 0, 0, 0, 0, 0, $3, 0); }
1091                 | FOR StartIntExpr CCode ';' CCode ';' CCode  EndIntExpr '{' Slist '}'
1092                 { $$ = new SdagConstruct(SFOR, 0, new SdagConstruct(SINT_EXPR, $3), new SdagConstruct(SINT_EXPR, $5),
1093                              new SdagConstruct(SINT_EXPR, $7), 0, $10, 0); }
1094                 | FOR StartIntExpr CCode ';' CCode ';' CCode  EndIntExpr SingleConstruct
1095                 { $$ = new SdagConstruct(SFOR, 0, new SdagConstruct(SINT_EXPR, $3), new SdagConstruct(SINT_EXPR, $5), 
1096                          new SdagConstruct(SINT_EXPR, $7), 0, $9, 0); }
1097                 | FORALL '[' IDENT ']' StartIntExpr CCode ':' CCode ',' CCode  EndIntExpr SingleConstruct
1098                 { $$ = new SdagConstruct(SFORALL, 0, new SdagConstruct(SIDENT, $3), new SdagConstruct(SINT_EXPR, $6), 
1099                              new SdagConstruct(SINT_EXPR, $8), new SdagConstruct(SINT_EXPR, $10), $12, 0); }
1100                 | FORALL '[' IDENT ']' StartIntExpr CCode ':' CCode ',' CCode  EndIntExpr '{' Slist '}' 
1101                 { $$ = new SdagConstruct(SFORALL, 0, new SdagConstruct(SIDENT, $3), new SdagConstruct(SINT_EXPR, $6), 
1102                                  new SdagConstruct(SINT_EXPR, $8), new SdagConstruct(SINT_EXPR, $10), $13, 0); }
1103                 | IF StartIntExpr CCode EndIntExpr SingleConstruct HasElse
1104                 { $$ = new SdagConstruct(SIF, 0, new SdagConstruct(SINT_EXPR, $3), $6,0,0,$5,0); }
1105                 | IF StartIntExpr CCode EndIntExpr '{' Slist '}' HasElse
1106                 { $$ = new SdagConstruct(SIF, 0, new SdagConstruct(SINT_EXPR, $3), $8,0,0,$6,0); }
1107                 | WHILE StartIntExpr CCode EndIntExpr SingleConstruct 
1108                 { $$ = new SdagConstruct(SIF, 0, new SdagConstruct(SINT_EXPR, $3), 0,0,0,$5,0); }
1109                 | WHILE StartIntExpr CCode EndIntExpr '{' Slist '}' 
1110                 { $$ = new SdagConstruct(SWHILE, 0, new SdagConstruct(SINT_EXPR, $3), 0,0,0,$6,0); }
1111                 | FORWARD ForwardList ';'
1112                 { $$ = $2; }
1113                 | ParamBraceStart CCode ParamBraceEnd
1114                 { $$ = buildAtomic($2, NULL, NULL); }
1115                 | error
1116                 { printf("Unknown SDAG construct or malformed entry method definition.\n"
1117                          "You may have forgotten to terminate an entry method definition with a"
1118                          " semicolon or forgotten to mark a block of sequential SDAG code as 'atomic'\n"); YYABORT; }
1119                 ;
1120
1121 HasElse         : /* Empty */
1122                 { $$ = 0; }
1123                 | ELSE SingleConstruct
1124                 { $$ = new SdagConstruct(SELSE, 0,0,0,0,0, $2,0); }
1125                 | ELSE '{' Slist '}'
1126                 { $$ = new SdagConstruct(SELSE, 0,0,0,0,0, $3,0); }
1127                 ;
1128 ForwardList     : IDENT 
1129                 { $$ = new SdagConstruct(SFORWARD, new SdagConstruct(SIDENT, $1)); }
1130                 | IDENT ',' ForwardList 
1131                 { $$ = new SdagConstruct(SFORWARD, new SdagConstruct(SIDENT, $1), $3);  }
1132                 ;
1133
1134 EndIntExpr      : ')'
1135                 { in_int_expr = 0; $$ = 0; }
1136                 ;
1137
1138 StartIntExpr    : '('
1139                 { in_int_expr = 1; $$ = 0; }
1140                 ;
1141
1142 SEntry          : IDENT EParameters
1143                 { $$ = new Entry(lineno, 0, 0, $1, $2, 0, 0, 0, 0); }
1144                 | IDENT SParamBracketStart CCode SParamBracketEnd EParameters 
1145                 { $$ = new Entry(lineno, 0, 0, $1, $5, 0, 0, $3, 0); }
1146                 ;
1147
1148 SEntryList      : SEntry 
1149                 { $$ = new EntryList($1); }
1150                 | SEntry ',' SEntryList
1151                 { $$ = new EntryList($1,$3); }
1152                 ;
1153
1154 SParamBracketStart : '['
1155                    { in_bracket=1; } 
1156                    ;
1157 SParamBracketEnd   : ']'
1158                    { in_bracket=0; } 
1159                    ;
1160
1161 HashIFComment   : HASHIF Name
1162                 { if (!macroDefined($2, 1)) in_comment = 1; }
1163                 ;
1164
1165 HashIFDefComment: HASHIFDEF Name
1166                 { if (!macroDefined($2, 0)) in_comment = 1; }
1167                 ;
1168
1169 %%
1170 void yyerror(const char *mesg)
1171 {
1172     std::cerr << cur_file<<":"<<lineno<<": Charmxi syntax error> "
1173               << mesg << std::endl;
1174 }