Templates, domains, arrays generation code and grammar modifications.
authorJonathan Lifflander <jliffl2@illinois.edu>
Mon, 26 Apr 2010 21:38:08 +0000 (16:38 -0500)
committerJonathan Lifflander <jliffl2@illinois.edu>
Mon, 26 Apr 2010 21:38:08 +0000 (16:38 -0500)
src/langs/charj/src/charj/translator/Charj.g
src/langs/charj/src/charj/translator/Charj.stg
src/langs/charj/src/charj/translator/CharjEmitter.g
src/langs/charj/src/charj/translator/CharjSemantics.g

index 9b6cb96cf94c3fd10547911ad706c690e36ae0ed..45a7e930992cdcc3bfd1083f6cd49cbde62746fa 100644 (file)
@@ -64,6 +64,7 @@ tokens {
     CLASS_STATIC_INITIALIZER;
     CLASS_TOP_LEVEL_SCOPE;
     CONSTRUCTOR_DECL;
+    DOMAIN_EXPRESSION;
     ENUM_TOP_LEVEL_SCOPE;
     EXPR;
     EXTENDS_BOUND_LIST;
@@ -82,14 +83,17 @@ tokens {
     CHARJ_SOURCE;
     METHOD_CALL;
     MODIFIER_LIST;
+    NEW_EXPRESSION;
     PAREN_EXPR;
     POST_DEC;
     POST_INC;
     PRE_DEC;
     PRE_INC;
     QUALIFIED_TYPE_IDENT;
+    RANGE_EXPRESSION;
     STATIC_ARRAY_CREATOR;
     SUPER_CONSTRUCTOR_CALL;
+    TEMPLATE_INST;
     THIS_CONSTRUCTOR_CALL;
     TYPE;
     UNARY_MINUS;
@@ -209,9 +213,9 @@ typeList
 classScopeDeclaration
     :   modifierList?
         (   genericTypeParameterList?
-            (   type IDENT formalParameterList arrayDeclaratorList? (block | ';')
+            (   type IDENT formalParameterList (block | ';')
                 ->  ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? type IDENT
-                    formalParameterList arrayDeclaratorList? block?)
+                    formalParameterList block?)
             |   'void' IDENT formalParameterList (block | ';')
                 ->  ^(VOID_METHOD_DECL modifierList? genericTypeParameterList? IDENT formalParameterList block?)
             |   ident=IDENT formalParameterList block
@@ -228,9 +232,9 @@ classScopeDeclaration
 interfaceScopeDeclaration
     :   modifierList?
         (   genericTypeParameterList?
-            (   type IDENT formalParameterList arrayDeclaratorList? ';'
+            (   type IDENT formalParameterList ';'
                 ->  ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList?
-                        type IDENT formalParameterList arrayDeclaratorList?)
+                        type IDENT formalParameterList)
             |   'void' IDENT formalParameterList ';'
                 ->  ^(VOID_METHOD_DECL modifierList? genericTypeParameterList? IDENT formalParameterList)
             )
@@ -263,15 +267,15 @@ interfaceFieldDeclarator
 
 
 variableDeclaratorId
-    :   IDENT^ arrayDeclaratorList?
+    :   IDENT^ domainExpression?
     ;
 
 variableInitializer
     :   arrayInitializer
-    |   expression
+    |   newExpression
     ;
 
-arrayDeclarator
+/*arrayDeclarator
     :   '[' ']'
         ->  ARRAY_DECLARATOR
     ;
@@ -279,13 +283,29 @@ arrayDeclarator
 arrayDeclaratorList
     :   arrayDeclarator+
         ->  ^(ARRAY_DECLARATOR_LIST arrayDeclarator+)   
-    ;
+    ;*/
 
 arrayInitializer
     :   lc='{' (variableInitializer (',' variableInitializer)* ','?)? '}'
         ->  ^(ARRAY_INITIALIZER[$lc, "ARRAY_INITIALIZER"] variableInitializer*)
     ;
 
+templateArg
+    : genericTypeArgument
+    | literal
+    ;
+
+templateArgList
+    :   templateArg (','! templateArg)*
+    ;
+
+templateInstantiation
+    :    '<' templateArgList '>'
+        -> ^(TEMPLATE_INST templateArgList)
+    |    '<' templateInstantiation '>'
+        -> ^(TEMPLATE_INST templateInstantiation)
+    ;
+
 genericTypeParameterList
     :   lt='<' genericTypeParameter (',' genericTypeParameter)* genericTypeListClosing
         ->  ^(GENERIC_TYPE_PARAM_LIST[$lt, "GENERIC_TYPE_PARAM_LIST"] genericTypeParameter+)
@@ -342,13 +362,13 @@ type
     ;
 
 simpleType
-    :   primitiveType arrayDeclaratorList?
-        ->  ^(TYPE primitiveType arrayDeclaratorList?)  
+    :   primitiveType domainExpression?
+        ->  ^(TYPE primitiveType domainExpression?)  
     ;
 
 objectType
-    :   qualifiedTypeIdent arrayDeclaratorList?
-        ->  ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
+    :   qualifiedTypeIdent domainExpression?
+        ->  ^(TYPE qualifiedTypeIdent domainExpression?)
     ;
 
 qualifiedTypeIdent
@@ -357,7 +377,7 @@ qualifiedTypeIdent
     ;
 
 typeIdent
-    :   IDENT^ genericTypeArgumentList?
+    :   IDENT^ templateInstantiation?
     ;
 
 primitiveType
@@ -371,10 +391,10 @@ primitiveType
     |   'double'
     ;
 
-genericTypeArgumentList
+/*genericTypeArgumentList
     :   lt='<' genericTypeArgument (',' genericTypeArgument)* genericTypeListClosing
         ->  ^(GENERIC_TYPE_ARG_LIST[$lt, "GENERIC_TYPE_ARG_LIST"] genericTypeArgument+)
-    ;
+    ;*/
 
 genericTypeArgument
     :   type
@@ -495,6 +515,29 @@ parenthesizedExpression
         ->  ^(PAREN_EXPR[$lp, "PAREN_EXPR"] expression)
     ;
     
+rangeItem
+    :   DECIMAL_LITERAL
+    |   IDENT
+    ;
+
+rangeExpression
+    :   rangeItem
+        -> ^(RANGE_EXPRESSION rangeItem)
+    |   rangeItem ':' rangeItem
+        -> ^(RANGE_EXPRESSION rangeItem rangeItem)
+    |   rangeItem ':' rangeItem ':' rangeItem
+        -> ^(RANGE_EXPRESSION rangeItem rangeItem rangeItem)
+    ;
+
+rangeList
+    :   rangeExpression (','! rangeExpression)*
+    ;
+
+domainExpression
+    :   '[' rangeList ']'
+        -> ^(DOMAIN_EXPRESSION rangeList)
+    ;
+
 expressionList
     :   expression (','! expression)*
     ;
@@ -631,12 +674,12 @@ postfixedExpression
         (   outerDot='.'                 
             // Note: generic type arguments are only valid for method calls,
             // i.e. if there is an argument list
-            (   (   genericTypeArgumentList?  
+            (   (   templateInstantiation?  
                     IDENT
                     ->  ^($outerDot $postfixedExpression IDENT)
                 ) 
                 (   arguments
-                    ->  ^(METHOD_CALL $postfixedExpression genericTypeArgumentList? arguments)
+                    ->  ^(METHOD_CALL $postfixedExpression templateInstantiation? arguments)
                 )?
             |   'this'
                 ->  ^($outerDot $postfixedExpression 'this')
@@ -663,17 +706,17 @@ primaryExpression
     |   literal
     |   newExpression
     |   qualifiedIdentExpression
-    |   genericTypeArgumentList 
+    |   templateInstantiation 
         (   s='super'
             (   arguments
-                ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] genericTypeArgumentList arguments)
+                ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] templateInstantiation arguments)
             |   IDENT arguments
-                ->  ^(METHOD_CALL ^('.' 'super' IDENT) genericTypeArgumentList arguments)
+                ->  ^(METHOD_CALL ^('.' 'super' IDENT) templateInstantiation arguments)
             )
         |   IDENT arguments
-            ->  ^(METHOD_CALL IDENT genericTypeArgumentList arguments)
+            ->  ^(METHOD_CALL IDENT templateInstantiation arguments)
         |   t='this' arguments
-            ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] genericTypeArgumentList arguments)
+            ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] templateInstantiation arguments)
         )
     |   (   'this'
             ->  'this'
@@ -700,15 +743,15 @@ qualifiedIdentExpression
         (   arguments
             ->  ^(METHOD_CALL qualifiedIdentifier arguments)
         |   outerDot='.'
-            (   genericTypeArgumentList 
+            (   templateInstantiation 
                 (   s='super' arguments
                     ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"]
-                            qualifiedIdentifier genericTypeArgumentList arguments)
+                            qualifiedIdentifier templateInstantiation arguments)
                 |   'super' innerDot='.' IDENT arguments
                     ->  ^(METHOD_CALL ^($innerDot ^($outerDot qualifiedIdentifier 'super') IDENT)
-                            genericTypeArgumentList arguments)
+                            templateInstantiation arguments)
                 |   IDENT arguments
-                    ->  ^(METHOD_CALL ^($outerDot qualifiedIdentifier IDENT) genericTypeArgumentList arguments)
+                    ->  ^(METHOD_CALL ^($outerDot qualifiedIdentifier IDENT) templateInstantiation arguments)
                 )
             |   'this'
                 ->  ^($outerDot qualifiedIdentifier 'this')
@@ -719,19 +762,14 @@ qualifiedIdentExpression
     ;
 
 newExpression
-    :   n='new'
-        (   primitiveType newArrayConstruction          // new static array of primitive type elements
-            ->  ^(STATIC_ARRAY_CREATOR[$n, "STATIC_ARRAY_CREATOR"] primitiveType newArrayConstruction)
-        |   genericTypeArgumentList? qualifiedTypeIdent
-                newArrayConstruction                // new static array of object type reference elements
-            ->  ^(STATIC_ARRAY_CREATOR[$n, "STATIC_ARRAY_CREATOR"] genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction)
-        )
+    :   'new' domainExpression arguments?
+        ->  ^(NEW_EXPRESSION arguments? domainExpression)
     ;
     
-newArrayConstruction
+/*newArrayConstruction
     :   arrayDeclaratorList arrayInitializer
     |   '['! expression ']'! ('['! expression ']'!)* arrayDeclaratorList?
-    ;
+    ;*/
 
 arguments
     :   lp='(' expressionList? ')'
index 9c8b4a96ac1fcb74ae3a3d7fea4d063099aa7ba3..9c1752abdc5f7276c6574c4616d159010e077f04 100644 (file)
@@ -215,9 +215,15 @@ embed_cc(str, blk) ::=
 >>
 
 
-class_var_decl(modl, type, declList) ::=
+class_var_decl(modl, type, declList, domainExps) ::=
 <<
-<if(modl)><modl>:<else>public:<endif> <type> <declList>;
+<if(modl)>
+<modl>:
+<else>
+public:
+<endif>
+<domainExps; separator="; ">
+<type> <declList>;
 >>
 
 
@@ -233,9 +239,9 @@ var_decl(id, initializer) ::=
 >>
 
 
-var_decl_id(id, array_decl_list) ::=
+var_decl_id(id, domainExp) ::=
 <<
-<id><if(array_decl_list)> <array_decl_list><endif>
+<id><if(domainExp)> <domainExp><endif>
 >>
 
 
@@ -257,10 +263,11 @@ local_mod_list(mods) ::=
 >>
  
 
-local_var_decl(modList, type, declList) ::=
+local_var_decl(modList, type, declList, domainExps) ::=
 <<
+<domainExps>
 <if(modList)>
-<modList> <type> <declList>;
+<modList> <type> <declList>
 <else>
 <type> <declList>;
 <endif>
@@ -402,4 +409,10 @@ arguments(exprs) ::=
 <exprs; separator=", ">
 >>
 
-
+range_constructor(range, others) ::=
+<<
+<if(range)>
+(new Domain(<range>)<if(others)>, <others; separator=", "><endif>)
+<else>
+<endif>
+>>
\ No newline at end of file
index 0d29b575e60b6009c86432ff22938577501ce636..939a1b1cbb7b627fa6320d6ba74a12c27f6bad56 100644 (file)
@@ -200,7 +200,7 @@ enumConstant
 classScopeDeclaration
 @init { boolean entry = false; }
     :   ^(FUNCTION_METHOD_DECL m=modifierList? g=genericTypeParameterList? 
-            ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
+            ty=type IDENT f=formalParameterList
             b=block?)
         { 
             if ($m.st != null) {
@@ -214,7 +214,6 @@ classScopeDeclaration
                 ty={$ty.text},
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
-                adl={$a.st},
                 block={$b.st})
         -> {emitH()}? funcMethodDecl_h(
                 modl={$m.st}, 
@@ -222,7 +221,6 @@ classScopeDeclaration
                 ty={$ty.text},
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
-                adl={$a.st},
                 block={$b.st})
         -> {(emitCI() && entry)}? funcMethodDecl_ci(
                 modl={$m.st}, 
@@ -230,7 +228,6 @@ classScopeDeclaration
                 ty={$ty.text},
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
-                adl={$a.st},
                 block={$b.st})
         ->
     |   ^(VOID_METHOD_DECL m=modifierList? g=genericTypeParameterList? IDENT 
@@ -260,17 +257,29 @@ classScopeDeclaration
                 fpl={$f.st}, 
                 block={$b.st})
         ->
-    |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
+    |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType (^(vdl=VAR_DECLARATOR_LIST (^(VAR_DECLARATOR (^(IDENT de+=(domainExpression[null])?)) variableInitializer[null]?))+)))
         -> {emitCC() || emitH()}? class_var_decl(
             modl={$modifierList.st},
             type={$simpleType.st},
-            declList={$variableDeclaratorList.st})
+            domainExps={$de},
+            declList={$vdl})
         ->
-    |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
+//(^(VAR_DECLARATOR_LIST variableDeclarator+))
+    |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[$objectType.st])
+
+       // {
+           //     /*List<StringTemplate> stlist = new ArrayList<StringTemplate>();
+           //     for (CharjAST domain : $variableDeclaratorList.domains) {
+           //         //stlist.add(domain.st);
+        //         System.out.println(domain.toString());
+        //     }*/
+           // }
+
         -> {emitCC() || emitH()}? class_var_decl(
             modl={$modifierList.st},
             type={$objectType.st},
             declList={$variableDeclaratorList.st})
+            //domainExps={$variableDeclaratorList.domains})
         ->
     |   ^(CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList b=block)
         { 
@@ -301,45 +310,68 @@ classScopeDeclaration
     ;
     
 interfaceScopeDeclaration
-    :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? type IDENT formalParameterList arrayDeclaratorList?)
+    :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? type IDENT formalParameterList)
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
     |   ^(VOID_METHOD_DECL modifierList? genericTypeParameterList? IDENT formalParameterList)
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
-    |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
+    |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList[$simpleType.st])
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
-    |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
+    |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[$objectType.st])
         -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
     ;
 
-variableDeclaratorList
-    :   ^(VAR_DECLARATOR_LIST (var_decls+=variableDeclarator)+)
+variableDeclaratorList[StringTemplate obtype]
+    :   ^(VAR_DECLARATOR_LIST (var_decls+=variableDeclarator[obtype])+ )
         -> var_decl_list(var_decls={$var_decls})
     ;
 
-variableDeclarator
-    :   ^(VAR_DECLARATOR id=variableDeclaratorId initializer=variableInitializer?)
+variableDeclarator[StringTemplate obtype]
+    :   ^(VAR_DECLARATOR id=variableDeclaratorId initializer=variableInitializer[obtype]?)
         -> var_decl(id={$id.st}, initializer={$initializer.st})
     ;
     
 variableDeclaratorId
-    :   ^(IDENT adl=arrayDeclaratorList?)
-        -> var_decl_id(id={$IDENT.text}, arrayDeclList={$adl.st})
+    :   ^(IDENT domainExpression[null]?)
+        -> var_decl_id(id={$IDENT.text}, domainExp={$domainExpression.st})
     ;
 
-variableInitializer
+variableInitializer[StringTemplate obtype]
     :   arrayInitializer
         -> {$arrayInitializer.st}
-    |   expression
-        -> {$expression.st}
+    |   newExpression[obtype]
+        -> {$newExpression.st}
     ;
 
-arrayDeclaratorList
+rangeItem
+    :   dl=DECIMAL_LITERAL
+        -> template(t={$dl.text}) "<t>"
+    |   IDENT
+        -> template(t={$IDENT.text}) "<t>"
+    ;
+
+rangeExpression
+    :   ^(RANGE_EXPRESSION (ri+=rangeItem)*)
+        -> template(t={$ri}) "new Range(<t; separator=\",\">)"
+    ;
+
+rangeList
+    :   (r+=rangeExpression)*
+        -> template(t={$r}) "<t; separator=\", \">"
+    ;
+
+domainExpression[List<StringTemplate> otherParams]
+    :   ^(DOMAIN_EXPRESSION rl=rangeList)
+        -> range_constructor(range={$rl.st}, others={$otherParams}) 
+
+    ;
+
+/*arrayDeclaratorList
     :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
         -> template(t={$text}) "<t>"
-    ;
+    ;*/
     
 arrayInitializer
-    :   ^(ARRAY_INITIALIZER variableInitializer*)
+    :   ^(ARRAY_INITIALIZER variableInitializer[null]*)
         -> template(t={$text}) "/* arrayInitializer-not implemented */ <t>"
     ;
 
@@ -405,13 +437,13 @@ type
     ;
 
 simpleType
-    :   ^(TYPE primitiveType arrayDeclaratorList?)
-        -> type(typeID={$primitiveType.st}, arrDeclList={$arrayDeclaratorList.st})
+    :   ^(TYPE primitiveType domainExpression[null]?)
+        -> type(typeID={$primitiveType.st}, arrDeclList={$domainExpression.st})
     ;
 
 objectType
-    :   ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
-        -> type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$arrayDeclaratorList.st})
+    :   ^(TYPE qualifiedTypeIdent domainExpression[null]?)
+        -> type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
     ;
 
 qualifiedTypeIdent
@@ -420,8 +452,8 @@ qualifiedTypeIdent
     ;
 
 typeIdent
-    :   ^(IDENT genericTypeArgumentList?)
-        -> typeIdent(typeID={$IDENT.text}, generics={$genericTypeArgumentList.st})
+    :   ^(IDENT templateInstantiation?)
+        -> typeIdent(typeID={$IDENT.text}, generics={$templateInstantiation.st})
     ;
 
 primitiveType
@@ -440,11 +472,30 @@ $st = %{$start.getText()};
     |   'double'
     ;
 
+templateArg
+    :   genericTypeArgument
+        -> {$genericTypeArgument.st}
+    |   literal
+        -> {$literal.st}
+    ;
+
+templateArgList
+    :   params+=templateArg+
+        -> template(params={$params}) "<params; separator=\", \">"
+    ;
+
+templateInstantiation
+    :   ^(TEMPLATE_INST templateArgList)
+        -> template(args={$templateArgList.st}) "\<<args>\>"
+    |   ^(TEMPLATE_INST ts=templateInstantiation)
+        -> template(inst={$ts.st}) "\<<inst>\>"
+    ;
+
 genericTypeArgumentList
     :   ^(GENERIC_TYPE_ARG_LIST (gta+=genericTypeArgument)+)
         -> template(gtal={$gta}) "\<<gtal; separator=\", \">\>"
     ;
-    
+
 genericTypeArgument
     :   type
         -> {$type.st}
@@ -492,16 +543,18 @@ blockStatement
 
 
 localVariableDeclaration
-    :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
+    :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType vdl=(^(VAR_DECLARATOR_LIST (^(VAR_DECLARATOR (^(IDENT de+=domainExpression[null]?)) variableInitializer[null]?))+)))
         -> local_var_decl(
             modList={null},
             type={$simpleType.st},
-            declList={$variableDeclaratorList.st})
-    |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
+            domainExps={$de},
+            declList={$vdl})
+    |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType vdl=(^(VAR_DECLARATOR_LIST (^(VAR_DECLARATOR (^(IDENT de+=domainExpression[null]?)) variableInitializer[null]?))+)))
         -> local_var_decl(
             modList={null},
             type={$objectType.st},
-            declList={$variableDeclaratorList.st})
+            domainExps={$de},
+            declList={$vdl})
     ;
 
 
@@ -674,7 +727,7 @@ primaryExpression
         -> template(pe={$pe.st}, ex={$ex.st}) "<pe>[<ex>]"
     |   literal
         -> {$literal.st}
-    |   newExpression
+    |   newExpression[null]
         -> {$newExpression.st}
     |   'this'
         -> {%{$start.getText()}}
@@ -696,7 +749,12 @@ arrayTypeDeclarator
         -> template(t={$text}) "<t>"
     ;
 
-newExpression
+newExpression[StringTemplate obtype]
+    :   ^(NEW_EXPRESSION arguments? domainExpression[$arguments.args])
+        -> template(domain={$domainExpression.st},type={$obtype}) "new <type><domain>"
+    ;
+
+/*newExpression
     :   ^(  STATIC_ARRAY_CREATOR
             (   primitiveType newArrayConstruction
             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
@@ -704,8 +762,8 @@ newExpression
         )
         -> template(t={$text}) "<t>"
     ;
-
-newArrayConstruction
+*/
+/*newArrayConstruction
     :   arrayDeclaratorList arrayInitializer
         -> array_construction_with_init(
                 array_decls={$arrayDeclaratorList.st},
@@ -713,9 +771,12 @@ newArrayConstruction
     |   (ex+=expression)+ adl=arrayDeclaratorList?
         -> array_construction(exprs={$ex}, array_decls={$adl.st})
     ;
-
-arguments
-    :   ^(ARGUMENT_LIST (ex+=expression)*)
+*/
+arguments returns [List<StringTemplate> args]
+@init {
+    $args = new ArrayList<StringTemplate>();
+}
+    :   ^(ARGUMENT_LIST (ex+=(e=expression { $args.add($e.st); }))*)
         -> arguments(exprs={$ex})
     ;
 
index 7c2412f87bfb3285145066512dc4c89014ce293e..bbcad449cc36e3e7a0aa489ee0971649c4b2c0cd 100644 (file)
@@ -119,14 +119,14 @@ importDeclarations returns [List<CharjAST> packageNames]
 
 typeDeclaration[List<CharjAST> imports] returns [ClassSymbol sym]
 scope ScopeStack; // top-level type scope
-    :   ^('template'? i1=IDENT* ^('class' i2=IDENT (^('extends' type))? (^('implements' type+))? classScopeDeclaration*))
+    :   ^('template' i1=IDENT* typeDeclaration[$imports])
         {
             // JL: Need to fill the templateArgs in ClassSymbol, and push this down
             // to the class subtree
         }
     |   ^('class' i2=IDENT (^('extends' type))? (^('implements' type+))? classScopeDeclaration*)
         {
-            Scope outerScope = $ScopeStack[-1]::current;
+            /*Scope outerScope = $ScopeStack[-1]::current;
             $sym = new ClassSymbol(symtab, $i2.text, null, outerScope);
             outerScope.define($sym.name, $sym);
             currentClass = $sym;
@@ -134,7 +134,7 @@ scope ScopeStack; // top-level type scope
             $sym.definitionTokenStream = input.getTokenStream();
             $i2.symbol = $sym;
             $ScopeStack::current = $sym;
-            importPackages($sym, $imports);
+            importPackages($sym, $imports);*/
         }
     |   ^('interface' IDENT (^('extends' type+))?  interfaceScopeDeclaration*)
     |   ^('enum' IDENT (^('implements' type+))? enumConstant+ classScopeDeclaration*)
@@ -183,13 +183,32 @@ variableDeclarator
     :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
     ;
     
-variableDeclaratorId
-    :   ^(IDENT arrayDeclaratorList?)
+variableDeclaratorId returns [CharjAST domainExp]
+    :   ^(IDENT domainExpression? { domainExp = $domainExpression.start; }  )
+    ;
+
+rangeItem
+    :   DECIMAL_LITERAL
+    |   IDENT
+    ;
+
+rangeExpression
+    :   ^(RANGE_EXPRESSION rangeItem)
+    |   ^(RANGE_EXPRESSION rangeItem rangeItem)
+    |   ^(RANGE_EXPRESSION rangeItem rangeItem rangeItem)
+    ;
+
+rangeList
+    :   rangeExpression*
+    ;
+
+domainExpression
+    :   ^(DOMAIN_EXPRESSION rangeList)
     ;
 
 variableInitializer
     :   arrayInitializer
-    |   expression
+    |   newExpression
     ;
 
 arrayDeclaratorList
@@ -242,11 +261,11 @@ type
     ;
 
 simpleType
-    :   ^(TYPE primitiveType arrayDeclaratorList?)
+    :   ^(TYPE primitiveType domainExpression?)
     ;
     
 objectType
-    :   ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
+    :   ^(TYPE qualifiedTypeIdent domainExpression?)
     ;
 
 qualifiedTypeIdent
@@ -254,7 +273,7 @@ qualifiedTypeIdent
     ;
 
 typeIdent
-    :   ^(IDENT genericTypeArgumentList?)
+    :   ^(IDENT templateInstantiation?)
     ;
 
 primitiveType
@@ -271,6 +290,15 @@ primitiveType
 genericTypeArgumentList
     :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
     ;
+
+templateArgList
+    :   genericTypeArgument+
+    ;
+
+templateInstantiation
+    :   ^(TEMPLATE_INST templateArgList)
+    |   ^(TEMPLATE_INST templateInstantiation)
+    ;
     
 genericTypeArgument
     :   type
@@ -352,7 +380,7 @@ forInit
 parenthesizedExpression
     :   ^(PAREN_EXPR expression)
     ;
-    
+
 expression
     :   ^(EXPR expr)
     ;
@@ -432,12 +460,16 @@ arrayTypeDeclarator
     ;
 
 newExpression
+    :   ^(NEW_EXPRESSION arguments? domainExpression)
+    ;
+
+/*newExpression
     :   ^(  STATIC_ARRAY_CREATOR
             (   primitiveType newArrayConstruction
             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
             )
         )
-    ;
+    ;*/
 
 newArrayConstruction
     :   arrayDeclaratorList arrayInitializer