b8b85daf7594e00e679187d2a6e61bd8dde3cdb9
[charm.git] / src / langs / charj / src / charj / translator / CharjPostAnalysis.g
1 /**
2  *  TODO add a description
3  */
4
5 tree grammar CharjASTModifier2;
6
7 options {
8     backtrack = true; 
9     memoize = true;
10     tokenVocab = Charj;
11     ASTLabelType = CharjAST;
12     output = AST;
13 }
14
15 @header {
16 package charj.translator;
17 }
18
19 // Replace default ANTLR generated catch clauses with this action, allowing early failure.
20 @rulecatch {
21     catch (RecognitionException re) {
22         reportError(re);
23         throw re;
24     }
25 }
26
27 @members {
28     SymbolTable symtab = null;
29     PackageScope currentPackage = null;
30     ClassSymbol currentClass = null;
31     MethodSymbol currentMethod = null;
32     LocalScope currentLocalScope = null;
33     Translator translator;
34
35     AstModifier astmod = new AstModifier();
36
37     protected boolean containsModifier(CharjAST modlist, int type)
38     {
39         if(modlist == null)
40             return false;
41         CharjAST charjModList = modlist.getChildOfType(CharjParser.CHARJ_MODIFIER_LIST);
42         if(charjModList == null)
43             return false;
44         if(charjModList.getChildOfType(CharjParser.ENTRY) == null)
45             return false;
46         return true;
47     }
48
49         String getQualIdText(CharjAST qid)
50         {
51                 StringBuilder sb = new StringBuilder();
52
53                 sb.append(qid.getChild(0).getText());
54
55                 for(int i = 1; i < qid.getChildren().size(); i++)
56                         sb.append("::" + qid.getChild(i).getText());
57
58                 return sb.toString();
59         }
60 }
61         
62 // Starting point for parsing a Charj file.
63 charjSource[SymbolTable _symtab] returns [ClassSymbol cs]
64     :   ^(CHARJ_SOURCE 
65         (packageDeclaration)? 
66         (importDeclaration
67         | typeDeclaration { $cs = $typeDeclaration.sym; }
68         | externDeclaration
69         | readonlyDeclaration)*)
70     ;
71
72 // note: no new scope here--this replaces the default scope
73 packageDeclaration
74     :   ^(PACKAGE IDENT+)
75     ;
76     
77 importDeclaration
78     :   ^(IMPORT qualifiedIdentifier '.*'?)
79     ;
80
81 readonlyDeclaration
82     :   ^(READONLY localVariableDeclaration)
83     ;
84
85 externDeclaration
86     :   ^(EXTERN qualifiedIdentifier)
87     ;
88
89 typeDeclaration returns [ClassSymbol sym]
90     :   ^(TYPE classType IDENT { currentClass = (ClassSymbol) $IDENT.def.type; }
91             (^('extends' parent=type))? (^('implements' type+))?
92                 classScopeDeclaration*)
93     |   ^('interface' IDENT (^('extends' type+))?  interfaceScopeDeclaration*)
94     |   ^('enum' IDENT (^('implements' type+))? enumConstant+ classScopeDeclaration*)
95     ;
96
97 classType
98     :   CLASS
99     |   chareType
100     ;
101
102 chareType
103     :   CHARE
104     |   GROUP
105     |   NODEGROUP
106     |   MAINCHARE
107     |   ^(CHARE_ARRAY ARRAY_DIMENSION)
108     ;
109
110 enumConstant
111     :   ^(IDENT arguments?)
112     ;
113     
114 classScopeDeclaration
115     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList?
116             type IDENT formalParameterList domainExpression? b=block)
117     |   ^(ENTRY_FUNCTION_DECL modifierList? genericTypeParameterList?
118             type IDENT entryFormalParameterList domainExpression? b=block?)
119         -> {$b.sdag}? ^(SDAG_FUNCTION_DECL modifierList? genericTypeParameterList?
120                 type IDENT entryFormalParameterList domainExpression? block?)
121         -> ^(ENTRY_FUNCTION_DECL modifierList? genericTypeParameterList?
122             type IDENT entryFormalParameterList domainExpression? block?)
123     |   ^(DIVCON_METHOD_DECL modifierList? type IDENT formalParameterList divconBlock)
124     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
125             //^(VAR_DECLARATOR_LIST field[$simpleType.type]+))
126     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
127             //^(VAR_DECLARATOR_LIST field[$objectType.type]+))
128     |   ^(CONSTRUCTOR_DECL modifierList? genericTypeParameterList? IDENT formalParameterList 
129             block)
130     |   ^(ENTRY_CONSTRUCTOR_DECL modifierList? genericTypeParameterList? IDENT entryFormalParameterList 
131             block)
132     ;
133
134 field [ClassSymbol type]
135     :   ^(VAR_DECLARATOR ^(IDENT domainExpression?) variableInitializer?)
136     ;
137     
138 interfaceScopeDeclaration
139     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
140             type IDENT formalParameterList domainExpression?)
141         // Interface constant declarations have been switched to variable
142         // declarations by Charj.g; the parser has already checked that
143         // there's an obligatory initializer.
144     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
145     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
146     ;
147
148 variableDeclaratorList
149     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
150     ;
151
152 variableDeclarator
153     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
154     ;
155     
156 variableDeclaratorId
157     :   ^(IDENT domainExpression?)
158     ;
159
160 variableInitializer
161     :   arrayInitializer
162     |   expression
163     ;
164     
165 arrayInitializer
166     :   ^(ARRAY_INITIALIZER variableInitializer*)
167     ;
168
169 templateArg
170     : genericTypeArgument
171     | literal
172     ;
173
174 templateArgList
175     :   templateArg templateArg*
176     ;
177
178 templateInstantiation
179     :    ^(TEMPLATE_INST templateArgList)
180     |    ^(TEMPLATE_INST templateInstantiation)
181     ;
182
183 genericTypeParameterList
184     :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
185     ;
186
187 genericTypeParameter
188     :   ^(IDENT bound?)
189     ;
190         
191 bound
192     :   ^(EXTENDS_BOUND_LIST type+)
193     ;
194
195 modifierList
196     :   ^(MODIFIER_LIST accessModifierList localModifierList charjModifierList otherModifierList)
197     ;
198
199 modifier
200     :   accessModifier
201     |   localModifier
202     |   charjModifier
203     |   otherModifier
204     ;
205
206 localModifierList
207     :   ^(LOCAL_MODIFIER_LIST localModifier*)
208     ;
209
210 accessModifierList
211     :   ^(ACCESS_MODIFIER_LIST accessModifier*)
212     ;
213
214 charjModifierList
215     :   ^(CHARJ_MODIFIER_LIST charjModifier*)
216     ;
217
218 otherModifierList
219     :   ^(OTHER_MODIFIER_LIST otherModifier*)
220     ;
221     
222 localModifier
223     :   FINAL
224     |   STATIC
225     |   VOLATILE
226     ;
227
228 accessModifier
229     :   PUBLIC
230     |   PROTECTED
231     |   PRIVATE
232     ;
233
234 charjModifier
235     :   ENTRY
236     |   SDAGENTRY
237     |   TRACED
238     ;
239
240 otherModifier
241     :   ABSTRACT
242     |   NATIVE
243     ;
244
245 entryArgType
246     :   simpleType
247     |   entryArgObjectType
248     |   VOID
249     ;
250
251 type
252     :   simpleType
253     |   objectType
254     |   VOID
255     ;
256
257 nonArraySectionObjectType returns [Type type]
258 @after
259 {
260         $type = $start.symbolType;
261 }
262         :       simpleType
263         |   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
264         |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
265     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
266     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
267         |       VOID
268         ;       
269
270 simpleType returns [ClassSymbol type]
271     :   ^(SIMPLE_TYPE primitiveType domainExpression?)
272     ;
273     
274 objectType returns [ClassSymbol type]
275     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
276     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
277     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
278     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
279         |       ^(ARRAY_SECTION_TYPE qualifiedTypeIdent domainExpression?)
280     ;
281
282 entryArgObjectType returns [ClassSymbol type]
283     :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
284     |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression?)
285     |   ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
286     |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
287     ;
288
289 qualifiedTypeIdent returns [ClassSymbol type]
290     :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
291     ;
292
293 typeIdent returns [String name]
294     :   ^(IDENT templateInstantiation?)
295     ;
296
297 primitiveType
298     :   BOOLEAN
299     |   CHAR
300     |   BYTE
301     |   SHORT
302     |   INT
303     |   LONG
304     |   FLOAT
305     |   DOUBLE
306     ;
307
308 genericTypeArgumentList
309     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
310     ;
311     
312 genericTypeArgument
313     :   type
314     |   '?'
315     ;
316
317 formalParameterList
318     :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
319     ;
320
321 formalParameterStandardDecl
322     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
323     ;
324
325 entryFormalParameterList
326     :   ^(FORMAL_PARAM_LIST entryFormalParameterStandardDecl* formalParameterVarargDecl?) 
327     ;
328
329 entryFormalParameterStandardDecl
330     :   ^(FORMAL_PARAM_STD_DECL localModifierList? entryArgType variableDeclaratorId)
331     ;
332     
333 formalParameterVarargDecl
334     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
335     ;
336     
337 // FIXME: is this rule right? Verify that this is ok, I expected something like:
338 // IDENT (^(DOT qualifiedIdentifier IDENT))*
339 qualifiedIdentifier
340     :   IDENT
341     |   ^(DOT qualifiedIdentifier IDENT)
342     ;
343     
344 block returns [boolean sdag]
345 @init { $sdag = false; }
346     :   ^(BLOCK (blockStatement { $sdag |= $blockStatement.sdag; })*)
347     ;
348
349 blockStatement returns [boolean sdag]
350 @init { $sdag = false; }
351     :   localVariableDeclaration
352     |   statement { $sdag = $statement.sdag; }
353     ;
354     
355 localVariableDeclaration
356     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
357     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
358     ;
359
360 statement returns [boolean sdag]
361 @init { $sdag = false; }
362     : nonBlockStatement { $sdag = $nonBlockStatement.sdag; }
363     | sdagStatement { $sdag = true; }
364     | block { $sdag = $block.sdag; }
365     ;
366
367 divconBlock
368     :   ^(DIVCON_BLOCK divconExpr)
369     ;
370
371 divconAssignment
372     :   ^(LET_ASSIGNMENT IDENT expression)
373     ;
374
375 divconAssignmentList
376     :   divconAssignment+
377     ;
378
379 divconExpr
380     :   ^(IF parenthesizedExpression divconExpr divconExpr?)
381     |   ^(LET divconAssignmentList IN divconExpr)
382     |   expression
383     ;
384
385 sdagStatement
386     :   ^(OVERLAP block)
387     |   ^(WHEN (IDENT expression? formalParameterList)* block)
388     ;
389
390 nonBlockStatement returns [boolean sdag]
391 @init { $sdag = false; }
392     :   ^(ASSERT expression expression?)
393     |   ^(IF parenthesizedExpression (i=block { $sdag |= $i.sdag; }) (e=block { $sdag |= $e.sdag; })?)
394         -> {$sdag}? ^(SDAG_IF parenthesizedExpression $i $e?)
395         -> ^(IF parenthesizedExpression $i $e?)
396     |   ^(FOR forInit? FOR_EXPR (e1=expression)? FOR_UPDATE (e2+=expression)* block {
397             $sdag = $block.sdag;
398         })
399         -> {$sdag}? ^(SDAG_FOR forInit? FOR_EXPR $e1? FOR_UPDATE $e2? block)
400         -> ^(FOR forInit? FOR_EXPR $e1? FOR_UPDATE $e2? block)
401     |   ^(FOR_EACH localModifierList? type IDENT expression block { $sdag = $block.sdag; })
402     |   ^(WHILE parenthesizedExpression block { $sdag = $block.sdag; })
403         -> {$sdag}? ^(SDAG_WHILE parenthesizedExpression block)
404         -> ^(WHILE parenthesizedExpression block)
405     |   ^(DO block parenthesizedExpression { $sdag = $block.sdag; })
406         -> {$sdag}? ^(SDAG_DO block parenthesizedExpression)
407         -> ^(DO block parenthesizedExpression)
408     |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
409     |   ^(RETURN expression?)
410     |   ^(THROW expression)
411     |   ^(BREAK IDENT?) 
412     |   ^(CONTINUE IDENT?) 
413     |   ^(LABELED_STATEMENT IDENT statement)
414     |   expression
415     |   ^('delete' expression)
416     |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
417     |   ';' // Empty statement.
418     |   ^(PRINT expression*)
419     |   ^(PRINTLN expression*)
420     |   ^(EXIT expression?)
421     |   EXITALL
422     ;
423         
424 switchCaseLabel
425     :   ^(CASE expression blockStatement*)
426     |   ^(DEFAULT blockStatement*)
427     ;
428     
429 forInit
430     :   localVariableDeclaration 
431     |   expression+
432     ;
433     
434 // EXPRESSIONS
435
436 parenthesizedExpression
437     :   ^(PAREN_EXPR expression)
438     ;
439     
440 expression
441     :   ^(EXPR expr)
442     ;
443
444 expr
445     :   ^(ASSIGNMENT expr expr)
446     |   ^(PLUS_EQUALS expr expr)
447     |   ^(MINUS_EQUALS expr expr)
448     |   ^(TIMES_EQUALS expr expr)
449     |   ^(DIVIDE_EQUALS expr expr)
450     |   ^(AND_EQUALS expr expr)
451     |   ^(OR_EQUALS expr expr)
452     |   ^(POWER_EQUALS expr expr)
453     |   ^(MOD_EQUALS expr expr)
454     |   ^('>>>=' expr expr)
455     |   ^('>>=' expr expr)
456     |   ^('<<=' expr expr)
457     |   ^('?' expr expr expr)
458     |   ^(OR expr expr)
459     |   ^(AND expr expr)
460     |   ^(BITWISE_OR expr expr)
461     |   ^(POWER expr expr)
462     |   ^(BITWISE_AND expr expr)
463     |   ^(EQUALS expr expr)
464     |   ^(NOT_EQUALS expr expr)
465     |   ^(INSTANCEOF expr type)
466     |   ^(LTE expr expr)
467     |   ^(GTE expr expr)
468     |   ^('>>>' expr expr)
469     |   ^('>>' expr expr)
470     |   ^(GT expr expr)
471     |   ^('<<' expr expr)
472     |   ^(LT expr expr)
473     |   ^(PLUS expr expr)
474     |   ^(MINUS expr expr)
475     |   ^(TIMES expr expr)
476     |   ^(DIVIDE expr expr)
477     |   ^(MOD expr expr)
478     |   ^(UNARY_PLUS expr)
479     |   ^(UNARY_MINUS expr)
480     |   ^(PRE_INC expr)
481     |   ^(PRE_DEC expr)
482     |   ^(POST_INC expr)
483     |   ^(POST_DEC expr)
484     |   ^(TILDE expr)
485     |   ^(NOT expr)
486     |   ^(CAST_EXPR type expr)
487     |   primaryExpression
488     ;
489     
490 primaryExpression returns [Type type]
491     :   ^(DOT pe=primaryExpression
492                 (   IDENT { $type = $IDENT.symbolType; }
493                 |   THIS  { $type = $IDENT.symbolType; }
494                 |   SUPER { $type = $IDENT.symbolType; }
495                 )
496         )
497                 -> { $pe.type instanceof PointerType }? ^(ARROW primaryExpression IDENT? THIS? SUPER?)
498                 ->                                                                              ^(DOT primaryExpression IDENT? THIS? SUPER?)
499     |   parenthesizedExpression
500     |   IDENT
501                 {
502                         $type = $IDENT.symbolType;
503                 }
504     |   CHELPER
505     |   ^(METHOD_CALL pe=primaryExpression genericTypeArgumentList? arguments) 
506                 {
507                         $type = $METHOD_CALL.symbolType;
508                 }
509     |   ^(ENTRY_METHOD_CALL pe=primaryExpression genericTypeArgumentList? entryArguments)
510                 {
511                         $type = $ENTRY_METHOD_CALL.symbolType;
512                 }
513     |   explicitConstructorCall
514     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
515                 {
516                         $type = $ARRAY_ELEMENT_ACCESS.symbolType;
517                 }
518     |   ^(ARRAY_ELEMENT_ACCESS pe=primaryExpression domainExpression)
519                 {
520                         $type = $ARRAY_ELEMENT_ACCESS.symbolType; // TODO this is not correct, as it's always null
521                         if($pe.type instanceof ProxyType && $domainExpression.ranges.get(0).size() > 1)
522                         {
523                                 System.out.println("creating a new ArraySectionInitializer");
524                                 ArraySectionInitializer asi = new ArraySectionInitializer($domainExpression.ranges, ((ProxyType)$pe.type).baseType.getTypeName());
525                                 currentClass.sectionInitializers.add(asi);
526                                 System.out.println(asi);
527                         }
528                 }
529                         ->      { $pe.type instanceof ProxyType && $domainExpression.ranges.get(0).size() > 1 }? ^(METHOD_CALL IDENT["arraySectionInitializer" + (ArraySectionInitializer.getCount() - 1)] ^(ARGUMENT_LIST ^(EXPR primaryExpression)))
530                         ->                                                                                                                                                                       ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
531     |   literal
532     |   newExpression
533                 {
534                         $type = $newExpression.type;
535                 }
536         |       THIS
537                 {
538                         $type = $THIS.symbolType;
539                 }
540     |   arrayTypeDeclarator
541     |   SUPER
542                 {
543                         $type = $SUPER.symbolType;
544                 }
545     |   GETNUMPES
546     |   GETNUMNODES
547     |   GETMYPE
548     |   GETMYNODE
549     |   GETMYRANK
550         |       THISINDEX
551         |       THISPROXY
552                 {
553                         $type = $THISPROXY.symbolType;
554                 }
555     |   domainExpression
556     ;
557     
558 explicitConstructorCall
559     :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
560     |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
561     ;
562
563 arrayTypeDeclarator
564     :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
565     ;
566
567 newExpression returns [Type type]
568     :   ^(NEW_EXPRESSION arguments? domainExpression)
569     |   ^(NEW nonArraySectionObjectType arguments)
570                 {
571                         $type = $nonArraySectionObjectType.type;
572                 }
573     ;
574
575 arguments returns [Object expr]
576     :   ^(ARGUMENT_LIST expression*) 
577     ;
578
579 entryArguments
580     :   ^(ARGUMENT_LIST entryArgExpr*)
581     ;
582
583 entryArgExpr
584     :   ^(EXPR entryExpr)
585     ;
586
587 entryExpr
588     :   ^(ASSIGNMENT expr expr)
589     |   ^(PLUS_EQUALS expr expr)
590     |   ^(MINUS_EQUALS expr expr)
591     |   ^(TIMES_EQUALS expr expr)
592     |   ^(DIVIDE_EQUALS expr expr)
593     |   ^(AND_EQUALS expr expr)
594     |   ^(OR_EQUALS expr expr)
595     |   ^(POWER_EQUALS expr expr)
596     |   ^(MOD_EQUALS expr expr)
597     |   ^('>>>=' expr expr)
598     |   ^('>>=' expr expr)
599     |   ^('<<=' expr expr)
600     |   ^('?' expr expr expr)
601     |   ^(OR expr expr)
602     |   ^(AND expr expr)
603     |   ^(BITWISE_OR expr expr)
604     |   ^(POWER expr expr)
605     |   ^(BITWISE_AND expr expr)
606     |   ^(EQUALS expr expr)
607     |   ^(NOT_EQUALS expr expr)
608     |   ^(INSTANCEOF expr type)
609     |   ^(LTE expr expr)
610     |   ^(GTE expr expr)
611     |   ^('>>>' expr expr)
612     |   ^('>>' expr expr)
613     |   ^(GT expr expr)
614     |   ^('<<' expr expr)
615     |   ^(LT expr expr)
616     |   ^(PLUS expr expr)
617     |   ^(MINUS expr expr)
618     |   ^(TIMES expr expr)
619     |   ^(DIVIDE expr expr)
620     |   ^(MOD expr expr)
621     |   ^(UNARY_PLUS expr)
622     |   ^(UNARY_MINUS expr)
623     |   ^(PRE_INC expr)
624     |   ^(PRE_DEC expr)
625     |   ^(POST_INC expr)
626     |   ^(POST_DEC expr)
627     |   ^(TILDE expr)
628     |   ^(NOT expr)
629     |   ^(CAST_EXPR type expr)
630     |   entryPrimaryExpression
631     ;
632     
633 entryPrimaryExpression
634     :   ^(DOT primaryExpression
635                 (   IDENT
636                 |   THIS
637                 |   SUPER
638                 )
639         )
640     |   ^(ARROW primaryExpression
641                 (   IDENT
642                 |   THIS
643                 |   SUPER
644                 )
645         )
646     |   parenthesizedExpression
647     |   IDENT
648         {
649             //System.out.println("Derefing ID with type " + $IDENT.symbolType.getClass().getName() +
650             //    ":\n" + $IDENT.symbolType + "\nand def info " + $IDENT.def.getClass().getName() + ":\n" + $IDENT.def);
651             if ($IDENT.symbolType instanceof ClassSymbol) {
652                 if (!((ClassSymbol)$IDENT.symbolType).isPrimitive) {
653                     astmod.makePointerDereference($IDENT);
654                 }
655             }
656         }
657     |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
658     |   ^(ENTRY_METHOD_CALL primaryExpression genericTypeArgumentList? entryArguments)
659     |   explicitConstructorCall
660     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
661     |   literal
662     |   newExpression
663         ->  ^(POINTER_DEREFERENCE newExpression)
664     |   THIS
665         ->  ^(POINTER_DEREFERENCE THIS)
666     |   arrayTypeDeclarator
667     |   SUPER
668     |   GETNUMPES
669     |   GETNUMNODES
670     |   GETMYPE
671     |   GETMYNODE
672     |   GETMYRANK
673     |   domainExpression
674     ;
675
676 literal 
677     :   HEX_LITERAL
678     |   OCTAL_LITERAL
679     |   DECIMAL_LITERAL
680     |   FLOATING_POINT_LITERAL
681     |   CHARACTER_LITERAL
682     |   STRING_LITERAL          
683     |   TRUE
684     |   FALSE
685     |   NULL 
686     ;
687
688 rangeItem returns [Object item]
689     :   DECIMAL_LITERAL { $item = $DECIMAL_LITERAL; }
690     |   IDENT                   { $item = $IDENT; }
691     ;
692
693 rangeExpression returns [ArrayList<Object> range]
694 @init
695 {
696         $range = new ArrayList<Object>();
697 }
698     :   ^(RANGE_EXPRESSION rangeItem)                                                           { $range.add($rangeItem.item); }        
699     |   ^(RANGE_EXPRESSION i1=rangeItem i2=rangeItem)                           { $range.add($i1.item); $range.add($i2.item); }
700     |   ^(RANGE_EXPRESSION i1=rangeItem i2=rangeItem i3=rangeItem)      { $range.add($i1.item); $range.add($i2.item); $range.add($i3.item); }
701     ;
702
703 rangeList returns [ArrayList<ArrayList<Object>> ranges]
704 @init
705 {
706         $ranges = new ArrayList<ArrayList<Object>>();
707 }
708     :   (rangeExpression { $ranges.add($rangeExpression.range); })+
709     ;
710
711 domainExpression returns [ArrayList<ArrayList<Object>> ranges]
712     :   ^(DOMAIN_EXPRESSION rangeList)  { $ranges = $rangeList.ranges; }
713     ;