Merged arrays into Charj mainline.
authorJonathan Lifflander <jliffl2@illinois.edu>
Mon, 14 Jun 2010 15:44:45 +0000 (10:44 -0500)
committerJonathan Lifflander <jliffl2@illinois.edu>
Mon, 14 Jun 2010 15:44:45 +0000 (10:44 -0500)
1  2 
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
src/langs/charj/src/charj/translator/ClassSymbol.java
src/langs/charj/src/charj/translator/Translator.java

index 8bd1ba11c9705a7f5f03ce5bc085907e8e231752,45a7e930992cdcc3bfd1083f6cd49cbde62746fa..94e671962dcc279bec1f9f866ce21ac51745ff53
@@@ -16,108 -16,7 +16,108 @@@ options 
  }
  
  tokens {
 +
 +    ENTRY                   = 'entry'           ;
 +    PUBLIC                  = 'public'          ;
 +    PROTECTED               = 'protected'       ;
      ENTRY                   = 'entry'           ;
 +    PRIVATE                 = 'private'         ;
 +    ABSTRACT                = 'abstract'        ;
 +    NATIVE                  = 'native'          ;
 +    FINAL                   = 'final'           ;
 +    STATIC                  = 'static'          ;
 +    VOLATILE                = 'volatile'        ;
 +    VOID                    = 'void'            ;
 +    BOOLEAN                 = 'boolean'         ;
 +    CHAR                    = 'char'            ;
 +    BYTE                    = 'byte'            ;
 +    SHORT                   = 'short'           ;
 +    INT                     = 'int'             ;
 +    LONG                    = 'long'            ;
 +    FLOAT                   = 'float'           ;
 +    DOUBLE                  = 'double'          ;
 +    TRUE                    = 'true'            ;
 +    FALSE                   = 'false'           ;
 +    NULL                    = 'null'            ;
 +    THIS                    = 'this'            ;
 +    SUPER                   = 'super'           ;
 +    CHARE                   = 'chare'           ;
 +    CHARE_ARRAY             = 'chare_array'     ;
 +    MAINCHARE               = 'mainchare'       ;
 +    INTERFACE               = 'interface'       ;
 +    PACKAGE                 = 'package'         ;
 +    IMPORT                  = 'import'          ;
 +    CLASS                   = 'class'           ;
 +    EXTENDS                 = 'extends'         ;
 +    GROUP                   = 'group'           ;
 +    NODEGROUP               = 'nodegroup'       ;
 +    ENUM                    = 'enum'            ;
 +    READONLY                = 'readonly'        ;
 +
 +    PRINT                   = 'print'           ;
 +    PRINTLN                 = 'println'         ;
 +    EXIT                    = 'exit'            ;
 +    EXITALL                 = 'exitAll'         ;
 +    GETMYPE                 = 'getMyPe'         ;
 +    GETMYRANK               = 'getMyRank'       ;
 +    GETMYNODE               = 'getMyNode'       ;
 +    GETNUMPES               = 'getNumPes'       ;
 +    GETNUMNODES             = 'getNumNodes'     ;
 +
 +    FOR                     = 'for'             ;
 +    WHILE                   = 'while'           ;
 +    IF                      = 'if'              ;
 +    CASE                    = 'case'            ;
 +    SWITCH                  = 'switch'          ;
 +    RETURN                  = 'return'          ;
 +    ELSE                    = 'else'            ;
 +    CONTINUE                = 'continue'        ;
 +    DO                      = 'do'              ;
 +    DEFAULT                 = 'default'         ;
 +    WHILE                   = 'while'           ;
 +    THROW                   = 'throw'           ;
 +    BREAK                   = 'break'           ;
 +
 +    DOT                     = '.'               ;
 +    NEW                     = 'new'             ;
 +    BITWISE_OR              = '|'               ;
 +    BITWISE_AND             = '&'               ;
 +    ASSIGNMENT              = '='               ;
 +    EQUALS                  = '=='              ;
 +    NOT_EQUALS              = '!='              ;
 +    PLUS_EQUALS             = '+='              ;
 +    MINUS_EQUALS            = '-='              ;
 +    TIMES_EQUALS            = '*='              ;
 +    DIVIDE_EQUALS           = '/='              ;
 +    AND_EQUALS              = '&='              ;
 +    OR_EQUALS               = '|='              ;
 +    POWER_EQUALS            = '^='              ;
 +    MOD_EQUALS              = '%='              ;
 +    OR                      = '||'              ;
 +    AND                     = '&&'              ;
 +    POWER                   = '^'               ;
 +    GT                      = '>'               ;
 +    GTE                     = '>='              ;
 +    LT                      = '<'               ;
 +    LTE                     = '<='              ;
 +    PLUS                    = '+'               ;
 +    MINUS                   = '-'               ;
 +    TIMES                   = '*'               ;
 +    DIVIDE                  = '/'               ;
 +    MOD                     = '%'               ;
 +    UNARY_PLUS              = '++'              ;
 +    UNARY_MINUS             = '--'              ;
 +    NOT                     = '!'               ;
 +    TILDE                   = '~'               ;
 +    AT                      = '@'               ;
 +    INSTANCEOF              = 'instanceof'      ;
 +
 +    // Charj keywords for things that are automatically generated
 +    // and we don't want the user to use them as identifiers
 +
 +    PUP                     = 'pup'             ;
 +    INITMETHOD              = 'initMethod'      ;
 +
  
      // C++ keywords that aren't used in charj. 
      // We don't use these ourselves, but they're still reserved
      CLASS_STATIC_INITIALIZER;
      CLASS_TOP_LEVEL_SCOPE;
      CONSTRUCTOR_DECL;
+     DOMAIN_EXPRESSION;
      ENUM_TOP_LEVEL_SCOPE;
      EXPR;
      EXTENDS_BOUND_LIST;
      EXTENDS_CLAUSE;
      FOR_EACH;
 +    FOR_EXPR;
 +    FOR_UPDATE;
      FORMAL_PARAM_LIST;
      FORMAL_PARAM_STD_DECL;
      FORMAL_PARAM_VARARG_DECL;
      INTERFACE_TOP_LEVEL_SCOPE;
      IMPLEMENTS_CLAUSE;
      LABELED_STATEMENT;
 -    LOCAL_MODIFIER_LIST;
      CHARJ_SOURCE;
      METHOD_CALL;
 +    ENTRY_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;
 -    UNARY_PLUS;
 +    SIMPLE_TYPE;
 +    OBJECT_TYPE;
 +    REFERENCE_TYPE;
 +    POINTER_TYPE;
 +    PROXY_TYPE;
      PRIMITIVE_VAR_DECLARATION;
      OBJECT_VAR_DECLARATION;
      VAR_DECLARATOR;
      VAR_DECLARATOR_LIST;
 -    VOID_METHOD_DECL;
 +    ARROW;
 +    LOCAL_MODIFIER_LIST;
 +    ACCESS_MODIFIER_LIST;
 +    CHARJ_MODIFIER_LIST;
 +    OTHER_MODIFIER_LIST;
  }
  
  @header {
@@@ -227,75 -121,81 +231,84 @@@ package charj.translator
  
  // Starting point for parsing a Charj file.
  charjSource
 -    :   compilationUnit
 +    :   compilationUnit EOF
          ->  ^(CHARJ_SOURCE compilationUnit)
      ;
  
  compilationUnit
      :   packageDeclaration? 
 -        importDeclaration* 
 -        typeDeclaration
 +        topLevelDeclaration+ 
 +    ;
 +
 +topLevelDeclaration
 +    :   importDeclaration
 +    |   readonlyDeclaration
 +    |   typeDeclaration
      ;
  
  packageDeclaration
 -    :   'package'^ qualifiedIdentifier ';'!  
 +    :   PACKAGE IDENT (DOT IDENT)* ';'
 +        ->  ^(PACKAGE IDENT+)
      ;
  
  importDeclaration
 -    :   'import'^ qualifiedIdentifier '.*'? ';'!
 +    :   IMPORT^ qualifiedIdentifier '.*'? ';'!
 +    ;
 +
 +readonlyDeclaration
 +    :   READONLY^ localVariableDeclaration ';'!
      ;
  
  typeDeclaration
      :   classDefinition
+     |   templateDeclaration
      |   interfaceDefinition
      |   enumDefinition
      |   chareDefinition
 -    |   chareArrayDefinition
      ;
  
+ templateList
+     : 'class'! IDENT (','! 'class'! IDENT)*
+     ;
+ templateDeclaration
+     : 'template' '<' templateList '>' classDefinition
+         -> ^('template' templateList classDefinition)
+     ;
  classDefinition
 -    : 'public'? 'class' IDENT ('extends' type)? ('implements' typeList)? '{'
 -            classScopeDeclaration*
 -        '}' ';'?
 -        -> ^('class' IDENT ^('extends' type)? ^('implements' typeList)? classScopeDeclaration*)
 +    :   PUBLIC? CLASS IDENT (EXTENDS type)? ('implements' typeList)? '{'
-             classScopeDeclaration*
-         '}' ';'?
++      classScopeDeclaration* '}' ';'?
 +        -> ^(TYPE CLASS IDENT ^(EXTENDS type)? ^('implements' typeList)? classScopeDeclaration*)
      ;
  
  chareType
 -    :   'chare'
 -    |   'group'
 -    |   'nodegroup'
 +    :   CHARE
 +    |   GROUP
 +    |   NODEGROUP
 +    |   MAINCHARE
 +    |   CHARE_ARRAY '[' ARRAY_DIMENSION ']' -> ^(CHARE_ARRAY ARRAY_DIMENSION)
      ;
  
  chareDefinition
 -    :   'public'? chareType IDENT ('extends' type)? ('implements' typeList)? '{'
 +    :   PUBLIC? chareType IDENT (EXTENDS type)? ('implements' typeList)? '{'
              classScopeDeclaration*
          '}' ';'?
 -        -> ^(chareType IDENT ^('extends' type)? ^('implements' typeList)? classScopeDeclaration*)
 -    ;
 -
 -chareArrayDefinition
 -    :   'public'? 'chare_array' '[' ARRAY_DIMENSION ']' IDENT ('extends' type)? ('implements' typeList)? '{'
 -            classScopeDeclaration*
 -        '}' ';'?
 -        -> ^('chare_array' ARRAY_DIMENSION IDENT ^('extends' type)? ^('implements' typeList)? classScopeDeclaration*)
 +        -> ^(TYPE chareType IDENT ^(EXTENDS type)? ^('implements' typeList)? classScopeDeclaration*)
      ;
  
  interfaceDefinition
 -    :   'interface' IDENT ('extends' typeList)?  '{'
 +    :   'interface' IDENT (EXTENDS typeList)?  '{'
              interfaceScopeDeclaration*
          '}' ';'?
 -        -> ^('interface' IDENT ^('extends' typeList)? interfaceScopeDeclaration*)
 +        -> ^('interface' IDENT ^(EXTENDS typeList)? interfaceScopeDeclaration*)
      ;
  
  enumDefinition
 -    :   'enum' IDENT ('implements' typeList)? '{'
 +    :   ENUM IDENT ('implements' typeList)? '{'
              enumConstants ','? ';' classScopeDeclaration*
          '}' ';'?
 -        -> ^('enum' IDENT ^('implements' typeList)? enumConstants classScopeDeclaration*)
 +        -> ^(ENUM IDENT ^('implements' typeList)? enumConstants classScopeDeclaration*)
      ;
  
  enumConstants
@@@ -313,9 -213,11 +326,11 @@@ typeLis
  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?)
++            /*|   'void' IDENT formalParameterList (block | ';')
++                ->  ^(VOID_METHOD_DECL modifierList? genericTypeParameterList? IDENT formalParameterList block?)*/
              |   ident=IDENT formalParameterList block
                  ->  ^(CONSTRUCTOR_DECL[$ident, "CONSTRUCTOR_DECL"] modifierList? genericTypeParameterList? IDENT
                          formalParameterList block)
  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)
++            /*|   'void' IDENT formalParameterList ';'
++                ->  ^(VOID_METHOD_DECL modifierList? genericTypeParameterList? IDENT formalParameterList)*/
              )
          |   simpleType interfaceFieldDeclaratorList ';'
              ->  ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType interfaceFieldDeclaratorList)
@@@ -347,7 -251,7 +364,7 @@@ classFieldDeclaratorLis
      ;
  
  classFieldDeclarator
 -    :   variableDeclaratorId ('=' variableInitializer)?
 +    :   variableDeclaratorId (ASSIGNMENT variableInitializer)?
          ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
      ;
  
@@@ -357,21 -261,21 +374,21 @@@ interfaceFieldDeclaratorLis
      ;
  
  interfaceFieldDeclarator
 -    :   variableDeclaratorId '=' variableInitializer
 +    :   variableDeclaratorId ASSIGNMENT variableInitializer
          ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer)
      ;
  
  
  variableDeclaratorId
-     :   IDENT^ arrayDeclaratorList?
 -    :   IDENT^ domainExpression?
++    :   ^(IDENT domainExpression?)
      ;
  
  variableInitializer
      :   arrayInitializer
 -    |   newExpression
 +    |   expression
      ;
  
- arrayDeclarator
/*arrayDeclarator
      :   '[' ']'
          ->  ARRAY_DECLARATOR
      ;
  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+)
@@@ -406,7 -326,7 +439,7 @@@ genericTypeParamete
      ;
  
  bound
 -    :   e='extends' type ('&' type)*
 +    :   e=EXTENDS type ('&' type)*
          ->  ^(EXTENDS_BOUND_LIST[$e, "EXTENDS_BOUND_LIST"] type+)
      ;
  
@@@ -416,12 -336,12 +449,12 @@@ modifierLis
      ;
  
  modifier
 -    :   'public'
 -    |   'protected'
 -    |   'entry'
 -    |   'private'
 -    |   'abstract'
 -    |   'native'
 +    :   PUBLIC
 +    |   PROTECTED
 +    |   ENTRY
 +    |   PRIVATE
 +    |   ABSTRACT
 +    |   NATIVE
      |   localModifier
      ;
  
@@@ -431,61 -351,50 +464,61 @@@ localModifierLis
      ;
  
  localModifier
 -    :   'final'
 -    |   'static'
 -    |   'volatile'
 +    :   FINAL
 +    |   STATIC
 +    |   VOLATILE
      ;
  
  type
      :   simpleType
      |   objectType
-     :   qualifiedTypeIdent AT arrayDeclaratorList?
-         ->  ^(PROXY_TYPE qualifiedTypeIdent arrayDeclaratorList?)
-     |   qualifiedTypeIdent arrayDeclaratorList?
-         ->  ^(OBJECT_TYPE qualifiedTypeIdent arrayDeclaratorList?)
 +    |   VOID
 +    ;
 +
 +constructorType
++    :   qualifiedTypeIdent AT domainExpression?
++        ->  ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
++    |   qualifiedTypeIdent domainExpression?
++        ->  ^(OBJECT_TYPE qualifiedTypeIdent domainExpression?)
      ;
  
 +
  simpleType
-     :   primitiveType arrayDeclaratorList?
-         ->  ^(SIMPLE_TYPE primitiveType arrayDeclaratorList?)  
+     :   primitiveType domainExpression?
 -        ->  ^(TYPE primitiveType domainExpression?)  
++        ->  ^(SIMPLE_TYPE primitiveType domainExpression?)  
      ;
  
  objectType
-     :   qualifiedTypeIdent AT arrayDeclaratorList?
-         ->  ^(PROXY_TYPE qualifiedTypeIdent arrayDeclaratorList?)
-     |   qualifiedTypeIdent arrayDeclaratorList?
-         ->  ^(POINTER_TYPE qualifiedTypeIdent arrayDeclaratorList?)
 -    :   qualifiedTypeIdent domainExpression?
 -        ->  ^(TYPE qualifiedTypeIdent domainExpression?)
++    :   qualifiedTypeIdent AT domainExpression?
++        ->  ^(PROXY_TYPE qualifiedTypeIdent domainExpression?)
++    |   qualifiedTypeIdent domainExpression?
++        ->  ^(POINTER_TYPE qualifiedTypeIdent domainExpression?)
      ;
  
  qualifiedTypeIdent
 -    :   typeIdent ('.' typeIdent)*
 +    :   typeIdent (DOT typeIdent)*
          ->  ^(QUALIFIED_TYPE_IDENT typeIdent+) 
      ;
  
  typeIdent
-     :   IDENT^ genericTypeArgumentList?
+     :   IDENT^ templateInstantiation?
      ;
  
  primitiveType
 -    :   'boolean'
 -    |   'char'
 -    |   'byte'
 -    |   'short'
 -    |   'int'
 -    |   'long'
 -    |   'float'
 -    |   'double'
 +    :   BOOLEAN
 +    |   CHAR
 +    |   BYTE
 +    |   SHORT
 +    |   INT
 +    |   LONG
 +    |   FLOAT
 +    |   DOUBLE
      ;
  
- genericTypeArgumentList
/*genericTypeArgumentList
      :   lt='<' genericTypeArgument (',' genericTypeArgument)* genericTypeListClosing
          ->  ^(GENERIC_TYPE_ARG_LIST[$lt, "GENERIC_TYPE_ARG_LIST"] genericTypeArgument+)
-     ;
+     ;*/
  
  genericTypeArgument
      :   type
@@@ -524,16 -433,14 +557,16 @@@ qualifiedIdentifie
      :   (   IDENT
              ->  IDENT
          )
 -        (   '.' ident=IDENT
 -            ->  ^('.' $qualifiedIdentifier $ident)
 +        (   DOT ident=IDENT
 +            ->  ^(DOT $qualifiedIdentifier $ident)
          )*
      ;
  
  block
      :   lc='{' blockStatement* '}'
          ->  ^(BLOCK[$lc, "BLOCK"] blockStatement*)
 +    |   nonBlockStatement
 +        -> ^(BLOCK nonBlockStatement)
      ;
  
  blockStatement
@@@ -547,68 -454,53 +580,68 @@@ localVariableDeclaratio
      |   localModifierList? objectType classFieldDeclaratorList
          ->  ^(OBJECT_VAR_DECLARATION localModifierList? objectType classFieldDeclaratorList)
      ;
 -        
 +
  statement
 -    :   block
 -    |   'assert' expr1=expression 
 +    :   nonBlockStatement
 +    |   block
 +    ;
 +        
 +nonBlockStatement
 +    :   'assert' expr1=expression 
          (   ':' expr2=expression ';'
              ->  ^('assert' $expr1 $expr2)
          |   ';'
              ->  ^('assert' $expr1)
          )
 -    |   'if' parenthesizedExpression ifStat=statement 
 -        (   'else' elseStat=statement
 -            ->  ^('if' parenthesizedExpression $ifStat $elseStat)
 +    |   IF parenthesizedExpression ifStat=block
 +        (   ELSE elseStat=block
 +            ->  ^(IF parenthesizedExpression $ifStat $elseStat)
          |
 -            ->  ^('if' parenthesizedExpression $ifStat)
 +            ->  ^(IF parenthesizedExpression $ifStat)
          )   
 -    |   f='for' '('
 -        (   forInit? ';' expression? ';' expressionList? ')' statement
 -            -> ^($f forInit expression? expressionList statement)
 -        |   localModifierList? type IDENT ':' expression ')' statement
 -            -> ^(FOR_EACH[$f, "FOR_EACH"] localModifierList? type IDENT expression statement)
 +    |   f=FOR '('
 +        (   forInit? ';' expression? ';' expressionList? ')' block
 +            -> ^($f forInit? FOR_EXPR expression? FOR_UPDATE expressionList? block)
 +        |   localModifierList? type IDENT ':' expression ')' block
 +            -> ^(FOR_EACH[$f, "FOR_EACH"] localModifierList? type IDENT expression block)
          )
 -    |   'while' parenthesizedExpression statement
 -        ->  ^('while' parenthesizedExpression statement)
 -    |   'do' statement 'while' parenthesizedExpression ';'
 -        ->  ^('do' statement parenthesizedExpression)
 -    |   'switch' parenthesizedExpression '{' switchCaseLabel* '}'
 -        ->  ^('switch' parenthesizedExpression switchCaseLabel*)
 -    |   'return' expression? ';'
 -        ->  ^('return' expression?)
 -    |   'throw' expression ';'
 -        ->  ^('throw' expression)
 -    |   'break' IDENT? ';'
 -        ->  ^('break' IDENT?)
 -    |   'continue' IDENT? ';'
 -        ->  ^('continue' IDENT?)
 +    |   WHILE parenthesizedExpression block
 +        ->  ^(WHILE parenthesizedExpression block)
 +    |   DO block WHILE parenthesizedExpression ';'
 +        ->  ^(DO block parenthesizedExpression)
 +    |   SWITCH parenthesizedExpression '{' switchCaseLabel* '}'
 +        ->  ^(SWITCH parenthesizedExpression switchCaseLabel*)
 +    |   RETURN expression? ';'
 +        ->  ^(RETURN expression?)
 +    |   THROW expression ';'
 +        ->  ^(THROW expression)
 +    |   BREAK IDENT? ';'
 +        ->  ^(BREAK IDENT?)
 +    |   CONTINUE IDENT? ';'
 +        ->  ^(CONTINUE IDENT?)
      |   IDENT ':' statement
          ->  ^(LABELED_STATEMENT IDENT statement)
 +    |   'delete' qualifiedIdentifier ';'
 +        -> ^('delete' qualifiedIdentifier)
      |   'embed' STRING_LITERAL EMBED_BLOCK
          ->  ^('embed' STRING_LITERAL EMBED_BLOCK)
      |   expression ';'!
      |   ';' // Preserve empty statements.
 +    |   PRINT '(' (expression (',' expression)*)* ')' ';'
 +        ->  ^(PRINT expression*)
 +    |   PRINTLN '(' (expression (',' expression)*)* ')' ';'
 +        ->  ^(PRINTLN expression*)
 +    |   EXIT '(' expression? ')' ';'
 +        ->  ^(EXIT expression?)
 +    |   EXITALL '(' ')' ';'
 +        ->  EXITALL
 +
      ;           
          
  
  switchCaseLabel
 -    :   'case'^ expression ':'! blockStatement*
 -    |   'default'^ ':'! blockStatement*
 +    :   CASE^ expression ':'! blockStatement*
 +    |   DEFAULT^ ':'! blockStatement*
      ;
      
  forInit
@@@ -623,6 -515,29 +656,29 @@@ parenthesizedExpressio
          ->  ^(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)*
      ;
@@@ -634,7 -549,7 +690,7 @@@ expressio
  
  assignmentExpression
      :   conditionalExpression 
 -        (   (   '='^
 +        (   (   ASSIGNMENT^
              |   '+='^
              |   '-='^
              |   '*='^
@@@ -676,7 -591,7 +732,7 @@@ andExpressio
  
  equalityExpression
      :   instanceOfExpression 
 -        (   (   '=='^
 +        (   (   EQUALS^
              |   '!='^
              ) 
              instanceOfExpression
@@@ -754,31 -669,29 +810,30 @@@ postfixedExpressio
      :   (   primaryExpression
              ->  primaryExpression
          )
--        // ... and than the optional things that may follow a primary
--        // expression 0 or more times.
 -        (   outerDot='.'                 
++        // ... and than the optional things that may follow a primary expression 0 or more times.
 +        (   outerDot=DOT                 
              // 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')
 -            |   s='super' arguments
 +            |   THIS
 +                ->  ^($outerDot $postfixedExpression THIS)
 +            |   s=SUPER arguments
                  ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] $postfixedExpression arguments)
 -            |   (   'super' innerDot='.' IDENT
 -                    ->  ^($innerDot ^($outerDot $postfixedExpression 'super') IDENT)
 +            |   (   SUPER innerDot=DOT IDENT
 +                    ->  ^($innerDot ^($outerDot $postfixedExpression SUPER) IDENT)
                  )
                  (   arguments
                      ->  ^(METHOD_CALL $postfixedExpression arguments)
                  )?
              )
-         |   (AT genericTypeArgumentList? IDENT arguments)
-             ->  ^(ENTRY_METHOD_CALL ^(AT $postfixedExpression IDENT) genericTypeArgumentList? arguments)
++        |   (AT templateInstantiation? IDENT arguments)
++            ->  ^(ENTRY_METHOD_CALL ^(AT $postfixedExpression IDENT) templateInstantiation? arguments)
          |   '[' expression ']'
              ->  ^(ARRAY_ELEMENT_ACCESS $postfixedExpression expression)
          )*
@@@ -793,42 -706,32 +848,42 @@@ primaryExpressio
      |   literal
      |   newExpression
      |   qualifiedIdentExpression
-     |   genericTypeArgumentList 
 -    |   templateInstantiation 
 -        (   s='super'
++    |   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 ^(DOT SUPER IDENT) genericTypeArgumentList arguments)
 -                ->  ^(METHOD_CALL ^('.' 'super' IDENT) templateInstantiation arguments)
++                ->  ^(METHOD_CALL ^(DOT SUPER IDENT) templateInstantiation arguments)
              )
          |   IDENT arguments
-             ->  ^(METHOD_CALL IDENT genericTypeArgumentList arguments)
+             ->  ^(METHOD_CALL IDENT templateInstantiation arguments)
 -        |   t='this' arguments
 +        |   t=THIS arguments
-             ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] genericTypeArgumentList arguments)
+             ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] templateInstantiation arguments)
          )
 -    |   (   'this'
 -            ->  'this'
 +    |   (   THIS
 +            ->  THIS
          )
          (   arguments
              ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] arguments)
          )?
 -    |   s='super' arguments
 +    |   s=SUPER arguments
          ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] arguments)
 -    |   (   'super' '.' IDENT
 +    |   (   SUPER DOT IDENT
          )
          (   arguments
 -            ->  ^(METHOD_CALL ^('.' 'super' IDENT) arguments)
 -        |   ->  ^('.' 'super' IDENT)
 +            ->  ^(METHOD_CALL ^(DOT SUPER IDENT) arguments)
 +        |   ->  ^(DOT SUPER IDENT)
          )
 +    |   GETMYPE '(' ')'
 +        ->  GETMYPE
 +    |   GETNUMPES '(' ')'
 +        ->  GETNUMPES
 +    |   GETMYRANK '(' ')'
 +        ->  GETMYRANK
 +    |   GETMYNODE '(' ')'
 +        -> GETMYNODE
 +    |   GETNUMNODES '(' ')'
 +        -> GETNUMNODES
      ;
      
  qualifiedIdentExpression
          // And now comes the stuff that may follow the qualified identifier.
          (   arguments
              ->  ^(METHOD_CALL qualifiedIdentifier arguments)
 -        |   outerDot='.'
 -            (   templateInstantiation 
 -                (   s='super' arguments
 +        |   outerDot=DOT
-             (   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)
 +                |   SUPER innerDot=DOT 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')
 -            |   s='super' arguments
 +            |   THIS
 +                ->  ^($outerDot qualifiedIdentifier THIS)
 +            |   s=SUPER arguments
                  ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] qualifiedIdentifier arguments)
              )
          )?
      ;
  
  newExpression
 -    :   'new' domainExpression arguments?
 -        ->  ^(NEW_EXPRESSION arguments? domainExpression)
 +    :   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)
++        (
++            domainExpression arguments?
++            ->  ^(NEW_EXPRESSION arguments? domainExpression)
 +        |   constructorType arguments
 +            -> ^(NEW constructorType arguments)
 +        )
      ;
      
- newArrayConstruction
/*newArrayConstruction
      :   arrayDeclaratorList arrayInitializer
      |   '['! expression ']'! ('['! expression ']'!)* arrayDeclaratorList?
-     ;
+     ;*/
  
  arguments
      :   lp='(' expressionList? ')'
@@@ -887,9 -783,9 +940,9 @@@ litera
      |   FLOATING_POINT_LITERAL
      |   CHARACTER_LITERAL
      |   STRING_LITERAL
 -    |   'true'
 -    |   'false'
 -    |   'null'
 +    |   TRUE
 +    |   FALSE
 +    |   NULL
      ;
  
  // LEXER
@@@ -900,7 -796,8 +953,7 @@@ DECIMAL_LITERAL : ('0' | '1'..'9' '0'..
  
  OCTAL_LITERAL : '0' ('0'..'7')+ INTEGER_TYPE_SUFFIX? ;
  
 -//fragment
 -ARRAY_DIMENSION :  '1'..'6' ('d'|'D') ;
 +ARRAY_DIMENSION :  ('1'..'6')('d'|'D') ;
  
  fragment
  HEX_DIGIT : ('0'..'9'|'a'..'f'|'A'..'F') ;
@@@ -911,11 -808,11 +964,11 @@@ INTEGER_TYPE_SUFFIX : ('l'|'L') 
  FLOATING_POINT_LITERAL
      :   ('0'..'9')+ 
          (
 -            '.' ('0'..'9')* EXPONENT? FLOAT_TYPE_SUFFIX?
 +            DOT ('0'..'9')* EXPONENT? FLOAT_TYPE_SUFFIX?
          |   EXPONENT FLOAT_TYPE_SUFFIX?
          |   FLOAT_TYPE_SUFFIX
          )
 -    |   '.' ('0'..'9')+ EXPONENT? FLOAT_TYPE_SUFFIX?
 +    |   DOT ('0'..'9')+ EXPONENT? FLOAT_TYPE_SUFFIX?
      ;
  
  fragment
@@@ -997,9 -894,8 +1050,9 @@@ COMMEN
      ;
  
  LINE_COMMENT
 -    : '//' ~('\n'|'\r')* '\r'? '\n'
 +    : ('//'|'#') ~('\n'|'\r')* '\r'? '\n'
      {   
          $channel = HIDDEN;
      }
      ;
 +
index 324f8775cf1dd3db75e55b95194fbe7c68f96977,5266339cadd25b072788c29248a1030685dcc6d0..25178534a77f0df1db66058d9d90dc70227d2432
@@@ -1,25 -1,31 +1,25 @@@
  group Charj;
  
 -charjSource_ci(pd, ids, tds, debug) ::= 
 -//<pd>
 -//<ids>
 +charjSource_ci(basename, pd, imports, types, ros, debug) ::=
  <<
 -<if(debug)>/* \<charjSource_ci> */<endif>
 -/*
 - * packageDeclaration disabled...
 -<pd>
 - * end packageDeclaration
 - */
  
 -/*
 - * importDeclarations disabled...
 -<ids>
 - * end importDeclarations
 - */
 -
 -<tds>
 -<if(debug)>/* \</charjSource_ci> */<endif>
 +// interface for <basename>
 +<imports; separator="\n">
 +<types; separator="\n\n">
 +<if(ros)>
  
 +module <basename>_readonly {
 +    <ros; separator="\n">
 +}
 +<endif>
  >>
  
  
 -charjSource_h(pd, ids, tds, cb, debug) ::= 
 +charjSource_h(basename, pd, imports, types, ros, debug) ::=
  <<
 -<if(debug)>/* \<CHARJ_SOURCE> */<endif>
 +#ifndef __<basename>__
 +#define __<basename>__
 +
  /**************************************************************************
   * WARNING                                                                *
   **************************************************************************
   * It is not meant to be edited by hand and may be overwritten by charjc. *
   **************************************************************************/
  
 -<pd>
 -<ids>
 -<tds>
 -<cb>
 +<imports; separator="\n">
 +<types; separator="\n\n">
 +<if(ros)>
 +/* Readonly variables */
 +<readonlys_h(pds = pd, ros = ros)>
 +#include "<basename>_readonly.decl.h"
 +<endif>
  
 -<if(debug)>/* \</CHARJ_SOURCE> */<endif>
  
 ->>
 +#endif // __<basename>__
 +
  
 +>>
  
 -charjSource_cc(pd, ids, tds, cb, debug) ::= 
 +charjSource_cc(basename, pd, imports, types, ros, debug) ::=
  <<
 -<if(debug)>/* \<CHARJ_SOURCE> */<endif>
 -<ids>
 -<pd>
 -<tds>
 -<cb>
 -<if(debug)>/* \</CHARJ_SOURCE> */<endif>
 +#include "<basename>.h"
 +
 +<imports; separator="\n">
 +<types; separator="\n\n">
 +<if(ros)>
  
 +/* Readonly variable support */
 +<readonlys_cc(pds = pd, ros = ros, basename = basename)>
 +<endif>
 +
 +
 +>>
 +
 +readonlys_h(pds, ros) ::=
 +<<
 +<if(first(pds))>namespace <first(pds)>
 +{
 +    <readonlys_h(pds = rest(pds), ros = ros)>
 +} // namespace <first(pds)>
 +<else>
 +<ros; separator="\n">
 +<endif>
  >>
  
 -packageDeclaration_cc_h(ids) ::= 
 +readonlys_cc(pds, ros, basename) ::=
  <<
 -<if(debug)>/* \<packageDeclaration> */<endif>
 -namespace <ids; separator=" { namespace "> {
 -<if(debug)>/* \</packageDeclaration> */<endif>
 +<if(first(pds))>namespace <first(pds)>
 +{
 +    <readonlys_cc(pds = rest(pds), ros = ros, basename = basename)>
 +} // namespace <first(pds)>
 +<else>
 +<ros; separator="\n">
 +#include "<basename>_readonly.def.h"
 +<endif>
 +
  >>
  
 -importDeclaration_cc_h(inc_id, use_id) ::= 
 +importDeclaration_cc_h(inc_id, use_id) ::=
  <<
 -<if(debug)>/* \<importDeclaration> */<endif>
  #include \<<inc_id>\>
  using <use_id>;
 -<if(debug)>/* \</importDeclaration> */<endif>
  >>
  
  classExtends_ci(type) ::= "<type>"
@@@ -97,182 -80,130 +97,191 @@@ interfaceExtends(ts) ::
  : public <ts; separator=", public ">
  >>
  
 -classDeclaration_h(ident, ext, csds) ::=
 +type_preamble_h(sym) ::=
  <<
 -/* superclass: <ext> */
 -class <ident>: public CBase_<ident> {
 -    <csds; separator="\n">
 -};
 +<sym.Includes:{include| #include \<<include>\>
 +}>
 +<sym.Usings:{using| using <using>;
 +}>
 +<sym.MemberTypeNames:{name| class <name>;
 +}>
  >>
  
 -classWrapper_h(ident, ext, csds, class1) ::=
 +chare_preamble_h(sym) ::=
  <<
 -<if(debug)>/* \<typeDeclaration> */<endif>
 -
 -#include "<ident>.decl.h"
 -
 -<classDeclaration_h(ident=ident, ext=ext, csds=csds)>
 +<type_preamble_h(sym)>
 +>>
  
 -<if(debug)>/* \</typeDeclaration> */<endif>
 +type_epilogue_h(sym) ::=
 +<<
  >>
  
 -templateDeclaration_h(tident, ident, ext, csds) ::=
 +chare_epilogue_h(sym) ::=
  <<
 -#include "<ident>.decl.h"
 -template \<class <tident; separator=", class ">\>
 -<classDeclaration_h(ident=ident, ext=ext, csds=csds)>
 +<type_epilogue_h(sym)>
  >>
  
- classDeclaration_h(sym, ident, ext, csds) ::=
 -classDeclaration_cc(ident, ext, csds) ::=
++classDeclaration_h(sym, ident, ext, csds, tident) ::=
  <<
 -<if(debug)>/* \<typeDeclaration> */<endif>
 +<type_preamble_h(sym)>
++<if(tident)>
++<templateDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds, tident = tident)>
++<else>
 +<classDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
++<endif>
 +<type_epilogue_h(sym)>
 +>>
  
 +classDeclaration_h_cont(pds, sym, ident, ext, csds) ::=
 +<<
 +<if(first(pds))>namespace <first(pds)>
 +{
 +    <classDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
 +} // namespace <first(pds)>
 +<else>
 +<if(ext)>
 +class <ident> : public <ext> {
 +<else>
 +class <ident> {
 +<endif>
  
 -#include "<ident>.decl.h"
 -/* superclass: <ext> */
 -class <ident>: public CBase_<ident> {
 -    <csds; separator="\n">
 +    <csds; separator="\n\n">
  };
 -#include "<ident>.def.h"
 -<if(debug)>/* \</typeDeclaration> */<endif>
 +<endif>
 +>>
  
++templateDeclaration_h(pds, sym, ident, ext, csds, tident) ::=
++<<
++template \<class <tident; separator=", class ">\>
++<classDeclaration_h_cont(pds=pds, sym=sym, ident=ident, ext=ext, csds=csds)>
+ >>
  
 +classDeclaration_cc(sym, ident, ext, csds) ::=
 +<<
 +<classDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
 +>>
  
 -charedeclaration_ci(chareType, arrayDim, ident, ext, csds) ::=
 +classDeclaration_cc_cont(pds, sym, ident, ext, csds) ::=
  <<
 -<if(debug)>/* \<typeDeclaration> */<endif>
 -module <ident> {
 -<if(ext)>
 -    extern module <ext>;
 -    <chareType><if(arrayDim)> [<arrayDim>]<endif> <ident>: <ext> {
 +<if(first(pds))>namespace <first(pds)>
 +{
 +    <classDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
 +} // namespace <first(pds)>
  <else>
 -    <chareType><if(arrayDim)> [<arrayDim>]<endif> <ident> {
 +<csds; separator="\n\n">
  <endif>
 -        <csds; separator="\n">
 -    }
 -}
 -
 -<if(debug)>/* \</typeDeclaration> */<endif>
 -
  >>
  
  
 -funcMethodDecl_h(modl, gtpl, ty, id, fpl, adl, block) ::=
 +chareDeclaration_cc(sym, ident, ext, csds) ::=
  <<
 -<if(modl)><modl>: <endif><ty> <gtpl> <id><fpl> <adl>;
 +#include "<ident>.decl.h"
 +<chareDeclaration_cc_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
 +#include "<ident>.def.h"
  >>
  
 +chareDeclaration_cc_cont(pds, sym, ident, ext, csds) ::=
 +<<
 +<if(first(pds))>namespace <first(pds)>
 +{
 +    <chareDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
 +} // namespace <first(pds)>
 +<else>
 +<csds; separator="\n\n">
 +<endif>
 +>>
  
 -funcMethodDecl_ci(modl, gtpl, ty, id, fpl, adl, block) ::=
 +chareDeclaration_h(sym, ident, ext, csds) ::=
  <<
 -entry <ty> <gtpl> <id><fpl> <adl>;
 +<chare_preamble_h(sym)>
 +#include "<ident>.decl.h"
 +<chareDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
 +<chare_epilogue_h(sym)>
  >>
  
 +chareDeclaration_h_cont(pds, sym, ident, ext, csds) ::=
 +<<
 +<if(first(pds))>namespace <first(pds)>
 +{
 +    <chareDeclaration_h_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
 +} // namespace <first(pds)>
 +<else>
 +<if(ext)>/* superclass: <ext> */<endif>
 +class <ident>: public CBase_<ident> {
 +    <csds; separator="\n">
 +};
 +<endif>
 +>>
  
 -funcMethodDecl_cc(modl, gtpl, ty, id, fpl, adl, block) ::=
 +chareDeclaration_ci(sym, chareType, arrayDim, ident, ext, csds) ::=
  <<
 -<if(modl)><modl>: <endif><ty> <gtpl> <id><fpl> <adl> {
 -    <block>
 +<if(sym.isMainChare)>main<endif>module <ident> {
 +<if(ext)>
 +    extern module <ext>;
 +<endif>
 +    <sym.Externs:{ext| extern module <ext>;
 +    }>
 +    <chareDeclaration_ci_cont(pds = sym.packageNames, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
  }
  >>
  
  
 -voidMethodDecl_ci(modl, gtpl, id, fpl, block) ::=
 +chareDeclaration_ci_cont(pds, sym, chareType, arrayDim, ident, ext, csds) ::=
  <<
 -entry void<gtpl> <id><fpl>;
 +<if(first(pds))>namespace <first(pds)>
 +{
 +    <chareDeclaration_ci_cont(pds = rest(pds), sym = sym, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
 +} // namespace <first(pds)>
 +<else>
 +<chareType><if(arrayDim)> [<arrayDim>]<endif> <ident><if(ext)> : <ext><endif> {
 +    <csds; separator="\n">
 +};
 +<endif>
  >>
  
 +funcMethodDecl_h(modl, gtpl, ty, id, fpl, adl, block) ::=
 +<<
 +<modl><ty><gtpl> <id><fpl><adl>;
 +>>
  
 -voidMethodDecl_h(modl, gtpl, id, fpl, block) ::=
 +
 +funcMethodDecl_ci(modl, gtpl, ty, id, fpl, adl, block) ::=
  <<
 -<if(modl)><modl>: <endif>void<gtpl> <id><fpl>;
 +<modl><ty><gtpl> <id><fpl><adl>;
  >>
  
  
 -voidMethodDecl_cc(modl, gtpl, id, fpl, block) ::=
 +funcMethodDecl_cc(sym, modl, gtpl, ty, id, fpl, adl, block) ::=
  <<
 -<if(modl)><modl>: <endif>void<gtpl> <id><fpl> {
 -    <block>
 -}
 +<modl><ty><gtpl> <sym.Name>::<id><fpl><adl>
 +<block>
  >>
  
  
  ctorDecl_ci(modl, gtpl, id, fpl, block) ::=
  <<
 -entry void<gtpl> <id><fpl>;
 +<modl>void<gtpl> <id><fpl>;
  >>
  
  
  ctorDecl_h(modl, gtpl, id, fpl, block) ::=
  <<
 -<if(modl)><modl>:<endif><gtpl> <id><fpl>;
 +<modl><id><fpl>;
  >>
  
  
  ctorDecl_cc(modl, gtpl, id, fpl, block) ::=
  <<
 -<if(modl)><modl>:<endif><gtpl> <id><fpl> {
 -    <block>
 -}
 +<modl><id>::<id><fpl>
 +<block>
  >>
  
  
  block_cc(bsl) ::=
  <<
 -<bsl:{s| <s><\n>}>
 +{
 +    <bsl; separator="\n">
 +}
  >>
  
  
@@@ -286,7 -217,12 +295,7 @@@ embed_cc(str, blk) ::
  
  class_var_decl(modl, type, declList) ::=
  <<
 -<if(modl)>
 -<modl>:
 -<else>
 -public: 
 -<endif>
 -<type> <declList>;
 +<modl><type> <declList>;
  >>
  
  
@@@ -296,24 -232,15 +305,24 @@@ var_decl_list(var_decls) ::
  >>
  
  
 -var_decl(id, initializer) ::=
 +var_decl_cc(id, initializer) ::=
  <<
  <id><if(initializer)> = <initializer><endif>
  >>
  
 +var_decl_h(id, initializer) ::=
 +<<
 +<id>
 +>>
 +
 +var_decl_ci(id, initializer) ::=
 +<<
 +<id><if(initializer)> = <initializer><endif>
 +>>
  
- 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>
  >>
  
  
@@@ -323,58 -250,34 +332,59 @@@ var_id_decl(id, adl) ::
  >>
  
  
 -mod_list(mods) ::=
 +mod_list_cc(accmods, localmods, charjmods, othermods) ::=
  <<
 -<if(mods)><mods; separator=" "><endif>
 +<if(localmods)><localmods; separator=" "> <endif><if(othermods)><othermods; separator=" "> <endif>
  >>
  
 +mod_list_h(accmods, localmods, charjmods, othermods) ::=
 +<<
 +<if(accmods)><accmods; separator=" ">: <endif><if(othermods)><othermods; separator=" "> <endif>
 +>>
  
 -local_mod_list(mods) ::=
 +mod_list_ci(accmods, localmods, charjmods, othermods) ::=
  <<
 -<if(mods)><mods; separator=" "><endif>
 +<if(charjmods)><charjmods; separator=" "> <endif>
  >>
 - 
  
- local_var_decl(modList, type, declList) ::=
+ local_var_decl(modList, type, declList, domainExps) ::=
  <<
 -<if(modList)>
 -<modList> <type> <declList>
 -<else>
 -<type> <declList>;
 -<endif>
 +<if(modList)><modList> <endif><type> <declList>;
 +>>
 +
- local_mod_list(mods) ::= <<
++local_mod_list(mods) ::= 
++<<
 +<mods; separator=" ">
  >>
  
  
 -type(typeID, arrDeclList) ::=
 +simple_type(typeID, arrDeclList) ::=
  <<
  <typeID><arrDeclList>
  >>
  
  
 +obj_type(typeID, arrDeclList) ::=
 +<<
 +<typeID><arrDeclList>
 +>>
 +
 +proxy_type(typeID, arrDeclList) ::=
 +<<
 +CProxy_<typeID><arrDeclList>
 +>>
 +
 +pointer_type(typeID, arrDeclList) ::=
 +<<
 +<typeID>*<arrDeclList>
 +>>
 +
 +reference_type(typeID, arrDeclList) ::=
 +<<
 +<typeID>&<arrDeclList>
 +>>
 +
 +
  typeIdent(typeID, generics) ::=
  <<
  <typeID><generics>
@@@ -415,23 -318,33 +425,23 @@@ CkAssert(<cond>)
  
  if(cond, then, else_) ::=
  <<
 -if <cond> {
 -    <then>
 -}<if(else_)> else {
 -    <else_>
 -}<endif>
 +if <cond> <then><if(else_)> else <else_><endif>
  >>
  
  
  for(initializer, cond, update, body) ::=
  <<
 -for (<initializer> <cond> <update>) {
 -    <body>
 -}
 +for (<if(initializer)><initializer><else>;<endif> <cond>; <update; separator=", ">) <body>
  >>
  
  while(cond, body) ::=
  <<
 -while <cond> {
 -    <body>
 -} 
 +while <cond> <body>
  >>
  
  dowhile(cond, body) ::=
  <<
 -do {
 -    <body>
 -} while <cond>;
 +do <body> while <cond>;
  >>
  
  
@@@ -457,6 -370,16 +467,6 @@@ case(expr, block) ::
  case <expr>: <block>
  >>
  
 -for_cond(expr) ::=
 -<<
 -<expr>
 ->>
 -
 -for_update(exprs) ::=
 -<<
 -<exprs; separator=", ">
 ->>
 -
  method_call(primary, generic_types, args) ::=
  <<
  <if(generic_types)>
@@@ -476,7 -399,7 +486,7 @@@ array_construction_with_init(array_decl
  array_construction(exprs, array_decls) ::=
  <<
  [<exprs; separator="][">]<array_decls>
 ->> 
 +>>
  
  
  arguments(exprs) ::=
  <exprs; separator=", ">
  >>
  
 ->>
 +print(exprs) ::=
 +<<
 +<if(first(exprs))>cout <exprs : { n | \<\< <n> }>;<endif>
 +>>
 +
 +println(exprs) ::=
 +<<
 +cout<if(first(exprs))> <exprs : { n | \<\< <n> }><else> <endif>\<\< endl;
 +>>
 +
 +exit(expr) ::=
 +<<
 +<if(expr)>exit(<expr>)<else>exit(0)<endif>;
 +>>
 +
 +exitall() ::=
 +<<
 +CkExit();
 +>>
 +
+ range_constructor(range, others, len) ::=
+ <<
+ <if(range)>
+ Domain\<<len>\>(<range>)<if(others)>, <others; separator=", "><endif>
+ <else>
+ <endif>
++>>
index 8de9fc6d6c8aff8bbd6ae133683e750139e75d82,0406c7033abf669d14f648d9993cfb5722145b58..e680c7d00a36ae5c2f8cd93e2393e64c128344d4
@@@ -19,12 -19,12 +19,12 @@@ package charj.translator
  
  
  @members {
 -    SymbolTable symtab_ = null;
 +    SymbolTable symtab = null;
  
 -    PackageScope currentPackage_ = null;
 -    ClassSymbol currentClass_ = null;
 -    MethodSymbol currentMethod_ = null;
 -    LocalScope currentLocalScope_ = null;
 +    PackageScope currentPackage = null;
 +    ClassSymbol currentClass = null;
 +    MethodSymbol currentMethod = null;
 +    LocalScope currentLocalScope = null;
  
      Translator translator_;
      OutputMode mode_;
@@@ -33,7 -33,6 +33,7 @@@
      private boolean emitCI() { return mode_ == OutputMode.ci; }
      private boolean emitH() { return mode_ == OutputMode.h; }
      private boolean debug() { return translator_.debug(); }
 +    private String basename() { return translator_.basename(); }
  
      /**
       *  Override ANTLR's token mismatch behavior so we throw exceptions early.
  // Starting point for parsing a Charj file.
  charjSource[SymbolTable symtab, OutputMode m]
  @init {
 -    this.symtab_ = symtab;
 +    this.symtab = symtab;
      this.translator_ = symtab.translator;
      this.mode_ = m;
 -    String closingBraces = "";
  }
      :   ^(CHARJ_SOURCE (p=packageDeclaration)? 
 -        (i+=importDeclaration)* 
 -        (t=typeDeclaration))
 +        (i+=importDeclaration)*
 +        (r+=readonlyDeclaration)*
 +        (t+=typeDeclaration)*)
 +        -> {emitCC()}? charjSource_cc(basename={basename()}, pd={$p.names}, imports={$i}, types={$t}, ros={$r}, debug={debug()})
 +        -> {emitCI()}? charjSource_ci(basename={basename()}, pd={$p.names}, imports={$i}, types={$t}, ros={$r}, debug={debug()})
 +        -> {emitH()}? charjSource_h(basename={basename()}, pd={$p.names}, imports={$i}, types={$t}, ros={$r}, debug={debug()})
 +        ->
 +    ;
 +
 +topLevelDeclaration
 +    :   importDeclaration -> {$importDeclaration.st;}
 +    |   typeDeclaration -> {$typeDeclaration.st;}
 +    ;
 +
 +packageDeclaration returns [List names]
 +    :   ^('package' (ids+=IDENT)+)
          {
 -            // construct string of }'s to close namespace 
 -            if ($p.st != null) {
 -                String temp_p = $p.st.toString();
 -                for (int idx=0; idx<temp_p.length(); ++idx) {
 -                    if (temp_p.charAt(idx) == '{') {
 -                        closingBraces += "} ";
 -                    }
 -                }
 -            }
 +            $names = $ids;
          }
 -        -> {emitCC()}? charjSource_cc(
 -            pd={$p.st}, ids={$i}, tds={$t.st}, cb={closingBraces}, debug={debug()})
 -        -> {emitCI()}? charjSource_ci(pd={$p.st}, ids={$i}, tds={$t.st}, debug={debug()})
 -        -> {emitH()}? charjSource_h(
 -            pd={$p.st}, ids={$i}, tds={$t.st}, cb={closingBraces}, debug={debug()})
          ->
      ;
  
 -packageDeclaration
 -@init { 
 -    List<String> names = null; 
 -}
 -    :   ^('package' qualifiedIdentifier)  {
 -            names =  java.util.Arrays.asList(
 -                    $qualifiedIdentifier.text.split("[.]"));
 -        }
 -        -> {(emitCC() || emitH())}? packageDeclaration_cc_h(
 -            ids={names})
 +readonlyDeclaration
 +    :   ^(READONLY lvd=localVariableDeclaration)
 +        -> {emitCI()}? template(bn={basename()}, v={$lvd.st}) "readonly <v>"
 +        -> {emitH()}? template(v={$lvd.st}) "extern <v>"
 +        -> {emitCC()}? {$lvd.st;}
          ->
      ;
      
@@@ -132,45 -136,47 +132,52 @@@ importDeclaratio
      ;
      
  typeDeclaration
 -    :   ^('template' (i0+=IDENT*) ^('class' i1=IDENT (^('extends' su=type))? (^('implements' type+))? (csds+=classScopeDeclaration)*))
 -        -> {emitH()}? templateDeclaration_h(
 -            tident={$i0},
 -            ident={$i1.text},
 -            ext={$su.st},
 -            csds={$csds})
 -        ->
 -    |   ^('class' i1=IDENT (^('extends' su=type))? (^('implements' type+))? (csds+=classScopeDeclaration)*)
 +    :   ^(TYPE CLASS IDENT (^('extends' su=type))? (^('implements' type+))?
 +        {
 +            currentClass = (ClassSymbol)$IDENT.symbol;
 +        }
 +        (csds+=classScopeDeclaration)*)
          -> {emitCC()}? classDeclaration_cc(
 -                ident={$i1.text}, 
 +                sym={currentClass},
 +                ident={$IDENT.text}, 
                  ext={$su.st}, 
                  csds={$csds})
 -        -> {emitH()}? classWrapper_h(
 -                ident={$i1.text}, 
 +        -> {emitH()}?  classDeclaration_h(
 +                sym={currentClass},
 +                ident={$IDENT.text}, 
                  ext={$su.st}, 
                  csds={$csds})
          ->
 -    |   ^('interface' IDENT (^('extends' type+))? interfaceScopeDeclaration*)
++    |   ^('template' (i0+=IDENT*) ^('class' i1=IDENT (^('extends' su=type))? (^('implements' type+))? (csds+=classScopeDeclaration)*))
++        -> {emitH()}? templateDeclaration_h(
++            tident={$i0},
++            ident={$i1.text},
++            ext={$su.st},
++            csds={$csds})
++        -> 
 +    |   ^(INTERFACE IDENT (^('extends' type+))? interfaceScopeDeclaration*)
          -> template(t={$text}) "/*INTERFACE-not implemented*/ <t>"
 -    |   ^('enum' IDENT (^('implements' type+))? classScopeDeclaration*)
 +    |   ^(ENUM IDENT (^('implements' type+))? classScopeDeclaration*)
          -> template(t={$text}) "/*ENUM-not implemented*/ <t>"
 -    |   ^(chareType IDENT (^('extends' type))? (^('implements' type+))? classScopeDeclaration*)
 -        -> {emitCC()}? classDeclaration_cc(
 +    |   ^(TYPE chareType IDENT (^('extends' type))? (^('implements' type+))?
 +        {
 +            currentClass = (ClassSymbol)$IDENT.symbol;
 +        }
 +        (csds+=classScopeDeclaration)*)
 +        -> {emitCC()}? chareDeclaration_cc(
 +                sym={currentClass},
                  ident={$IDENT.text}, 
                  ext={$su.st}, 
                  csds={$csds})
 -        -> {emitCI()}? charedeclaration_ci(
 +        -> {emitCI()}? chareDeclaration_ci(
 +                sym={currentClass},
                  chareType={$chareType.st},
                  arrayDim={null},
                  ident={$IDENT.text}, 
                  ext={$su.st}, 
                  csds={$csds})
 -        -> {emitH()}? classDeclaration_h(
 -                ident={$IDENT.text}, 
 -                ext={$su.st}, 
 -                csds={$csds})
 -        ->
 -    |   ^('chare_array' ARRAY_DIMENSION IDENT (^('extends' type))? (^('implements' type+))? classScopeDeclaration*)
 -        -> {emitCI()}? charedeclaration_ci(
 -                chareType={"array"},
 -                arrayDim={$ARRAY_DIMENSION.text.toUpperCase()},
 +        -> {emitH()}? chareDeclaration_h(
 +                sym={currentClass},
                  ident={$IDENT.text}, 
                  ext={$su.st}, 
                  csds={$csds})
@@@ -181,12 -187,9 +188,12 @@@ chareTyp
  @init {
  $st = %{$start.getText()};
  }
 -    :   'chare'
 -    |   'group'
 -    |   'nodegroup'
 +    :   CHARE
 +    |   GROUP
 +    |   NODEGROUP
 +    |   MAINCHARE
 +    |   ^(CHARE_ARRAY ARRAY_DIMENSION)
 +        -> template(t={$ARRAY_DIMENSION.text}) "array [<t>]"
      ;
  
  enumConstant
      ;
  
  classScopeDeclaration
 -@init { boolean entry = false; }
 +@init
 +{
 +    boolean entry = false;
 +    boolean migrationCtor = 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) {
 -                // determine whether this is an entry method
 -                entry = listContainsToken($m.start.getChildren(), ENTRY);
 -            }
 +        {
 +            // determine whether it's an entry method
 +            if($m.start != null)
 +                entry = listContainsToken($m.start.getChildren(), CHARJ_MODIFIER_LIST);
          }
          -> {emitCC()}? funcMethodDecl_cc(
 +                sym={currentClass},
                  modl={$m.st}, 
                  gtpl={$g.st}, 
 -                ty={$ty.text},
 +                ty={$ty.st},
                  id={$IDENT.text}, 
                  fpl={$f.st}, 
-                 adl={$a.st},
                  block={$b.st})
          -> {emitH()}? funcMethodDecl_h(
                  modl={$m.st}, 
                  gtpl={$g.st}, 
 -                ty={$ty.text},
 +                ty={$ty.st},
                  id={$IDENT.text}, 
                  fpl={$f.st}, 
-                 adl={$a.st},
                  block={$b.st})
          -> {(emitCI() && entry)}? funcMethodDecl_ci(
                  modl={$m.st}, 
                  gtpl={$g.st}, 
 -                ty={$ty.text},
 -                id={$IDENT.text}, 
 -                fpl={$f.st}, 
 -                block={$b.st})
 -        ->
 -    |   ^(VOID_METHOD_DECL m=modifierList? g=genericTypeParameterList? IDENT 
 -            f=formalParameterList b=block?)
 -        { 
 -            // determine whether this is an entry method
 -            if ($m.st != null) {
 -                entry = listContainsToken($m.start.getChildren(), ENTRY);
 -            }
 -        }
 -        -> {emitCC()}? voidMethodDecl_cc(
 -                modl={$m.st}, 
 -                gtpl={$g.st}, 
 -                id={$IDENT.text}, 
 -                fpl={$f.st}, 
 -                block={$b.st})
 -        -> {emitCI() && entry}? voidMethodDecl_ci(
 -                modl={$m.st}, 
 -                gtpl={$g.st}, 
 -                id={$IDENT.text}, 
 -                fpl={$f.st}, 
 -                block={$b.st})
 -        -> {emitH()}? voidMethodDecl_h(
 -                modl={$m.st}, 
 -                gtpl={$g.st}, 
 +                ty={$ty.st},
                  id={$IDENT.text}, 
                  fpl={$f.st}, 
-                 adl={$a.st},
                  block={$b.st})
          ->
-     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
-         -> {emitH()}? class_var_decl(
+     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList[null, false])
+         -> {emitCC() || emitH()}? class_var_decl(
              modl={$modifierList.st},
              type={$simpleType.st},
              declList={$variableDeclaratorList.st})
          ->
-     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
-         -> {emitH()}? class_var_decl(
+     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[$objectType.st, false])
 -        /*{
 -            if ($currentClass != null) {
 -                $currentClass.members.put(
 -            }
 -        }*/
+         -> {emitCC() || emitH()}? class_var_decl(
              modl={$modifierList.st},
              type={$objectType.st},
              declList={$variableDeclaratorList.st})
          ->
      |   ^(CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList b=block)
 -        { 
 -            // determine whether this is an entry method
 -            if ($m.st != null) {
 -                entry = listContainsToken($m.start.getChildren(), ENTRY);
 +        {
 +            // determine whether it's an entry method
 +            if ($m.start != null) {
 +                entry = listContainsToken($m.start.getChildren(), CHARJ_MODIFIER_LIST);
              }
 +            migrationCtor = currentClass.migrationCtor == $CONSTRUCTOR_DECL;
          }
          -> {emitCC()}? ctorDecl_cc(
 -                modl={$m.st}, 
 +                modl={$m.st},
                  gtpl={$g.st}, 
                  id={$IDENT.text}, 
                  fpl={$f.st}, 
                  block={$b.st})
 -        -> {emitCI() && entry}? ctorDecl_ci(
 -                modl={$m.st}, 
 +        -> {emitCI() && entry && !migrationCtor}? ctorDecl_ci(
 +                modl={$m.st},
                  gtpl={$g.st}, 
                  id={$IDENT.text}, 
                  fpl={$f.st}, 
                  block={$b.st})
          -> {emitH()}? ctorDecl_h(
 -                modl={$m.st}, 
 +                modl={$m.st},
                  gtpl={$g.st}, 
                  id={$IDENT.text}, 
                  fpl={$f.st}, 
      ;
      
  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>"
-     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
 -    |   ^(VOID_METHOD_DECL modifierList? genericTypeParameterList? IDENT formalParameterList)
 -        -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
+     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList[$simpleType.st, false])
          -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
-     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
+     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[$objectType.st, false])
          -> template(t={$text}) "/*interfaceScopeDeclarations-not implemented */ <t>"
      ;
  
- variableDeclaratorList
-     :   ^(VAR_DECLARATOR_LIST (var_decls+=variableDeclarator)+)
+ variableDeclaratorList[StringTemplate obtype, boolean output]
+     :   ^(VAR_DECLARATOR_LIST (var_decls+=variableDeclarator[obtype, output])+ )
          -> var_decl_list(var_decls={$var_decls})
      ;
  
- variableDeclarator
-     :   ^(VAR_DECLARATOR id=variableDeclaratorId initializer=variableInitializer?)
-         -> {emitCC()}? var_decl_cc(id={$id.st}, initializer={$initializer.st})
-         -> {emitH()}?  var_decl_h(id={$id.st}, initializer={$initializer.st})
-         -> {emitCI()}? var_decl_ci(id={$id.st}, initializer={$initializer.st})
+ variableDeclarator[StringTemplate obtype, boolean output]
+     :   ^(VAR_DECLARATOR id=variableDeclaratorId[output] initializer=variableInitializer[obtype, output]?)
 -        -> {$output}? var_decl(id={$id.st}, initializer={$initializer.st})
 -        -> {!$output}? var_decl(id={$id.st})
++        -> {$output && emitCC()}? var_decl_cc(id={$id.st}, initializer={$initializer.st})
++        -> {$output && emitH()}?  var_decl_h(id={$id.st}, initializer={$initializer.st})
++        -> {$output && emitCI()}? var_decl_ci(id={$id.st}, initializer={$initializer.st})
++        -> {!$output && emitCC()}? var_decl_cc(id={$id.st})
++        -> {!$output && emitH()}?  var_decl_h(id={$id.st})
++        -> {!$output && emitCI()}? var_decl_ci(id={$id.st})
          ->
 -    ;
 +    ; 
      
- variableDeclaratorId
-     :   ^(IDENT adl=arrayDeclaratorList?)
-         -> var_decl_id(id={$IDENT.text}, arrayDeclList={$adl.st})
+ variableDeclaratorId[boolean output]
+     :   ^(IDENT de=domainExpression[null]?)
+         -> {$output}? var_decl_id(id={$IDENT.text}, domainExp={$de.st})
+         -> {!$output}? var_decl_id(id={$IDENT.text})
+         ->
      ;
  
- variableInitializer
+ variableInitializer[StringTemplate obtype, boolean output]
      :   arrayInitializer
          -> {$arrayInitializer.st}
+     |   newExpression[obtype, output]
+         -> {$newExpression.st}
 +    |   expression
 +        -> {$expression.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}) "Range(<t; separator=\",\">)"
+     ;
+ rangeList returns [int len]
+     :   (r+=rangeExpression)*
+         { $len = $r.size(); }
+         -> template(t={$r}) "<t; separator=\", \">"
+         
+     ;
+ domainExpression[List<StringTemplate> otherParams]
+     :   ^(DOMAIN_EXPRESSION rl=rangeList)
+         -> range_constructor(range={$rl.st}, others={$otherParams}, len={$rl.len})
+     ;
+ /*arrayDeclaratorList
      :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
          -> template(t={$text}) "<t>"
-     ;
+     ;*/
      
  arrayInitializer
-     :   ^(ARRAY_INITIALIZER variableInitializer*)
+     :   ^(ARRAY_INITIALIZER variableInitializer[null, false]*)
          -> template(t={$text}) "/* arrayInitializer-not implemented */ <t>"
      ;
  
@@@ -340,156 -395,106 +376,175 @@@ throwsClaus
      ;
  
  modifierList
 -    :   ^(MODIFIER_LIST (m+=modifier)+)
 -        -> mod_list(mods={$m})
 +    :   ^(MODIFIER_LIST accessModifierList? localModifierList? charjModifierList? otherModifierList?)
 +        ->  {emitCC()}? mod_list_cc(accmods = {$accessModifierList.names}, localmods = {$localModifierList.names}, charjmods = {$charjModifierList.names}, othermods = {$otherModifierList.names})
 +        ->  {emitH()}? mod_list_h(accmods = {$accessModifierList.names}, localmods = {$localModifierList.names}, charjmods = {$charjModifierList.names}, othermods = {$otherModifierList.names})
 +        ->  {emitCI()}? mod_list_ci(accmods = {$accessModifierList.names}, localmods = {$localModifierList.names}, charjmods = {$charjModifierList.names}, othermods = {$otherModifierList.names})
 +        ->
      ;
  
  modifier
 -@init {
 -$st = %{$start.getText()};
 -}
 -    :   'public'
 -    |   'protected'
 -    |   'private'
 -    |   'entry'
 -    |   'abstract'
 -    |   'native'
 +    :   accessModifier
      |   localModifier
 -        -> {$localModifier.st}
 +    |   charjModifier
 +    |   otherModifier
      ;
  
 +accessModifierList
 +returns [List names]
 +    :   ^(ACCESS_MODIFIER_LIST (m+=accessModifier)+)
 +        {
 +            $names = $m;
 +        }
 +    ;
  localModifierList
 +returns [List names]
      :   ^(LOCAL_MODIFIER_LIST (m+=localModifier)+)
 -        -> local_mod_list(mods={$m})
 +        {
 +            $names = $m;
 +        }
 +        ->  local_mod_list(mods = {$names})
      ;
  
 +charjModifierList
 +returns [List names]
 +    :   ^(CHARJ_MODIFIER_LIST (m+=charjModifier)+)
 +        {
 +            $names = $m;
 +        }
 +    ;
 +
 +otherModifierList
 +returns [List names]
 +    :   ^(OTHER_MODIFIER_LIST (m+=otherModifier)+)
 +        {
 +            $names = $m;
 +        }
 +    ;
 +    
  localModifier
 -@init {
 -$st = %{$start.getText()};
 +@init
 +{
 +    $st = %{$start.getText()};
 +}
 +    :   FINAL
 +    |   STATIC
 +    |   VOLATILE
 +    ;
 +
 +accessModifier
 +@init
 +{
 +    $st = %{$start.getText()};
 +}
 +    :   PUBLIC
 +    |   PROTECTED
 +    |   PRIVATE
 +    ;
 +
 +charjModifier
 +@init
 +{
 +    $st = %{$start.getText()};
  }
 -    :   'final'
 -    |   'static'
 -    |   'volatile'
 +    :   ENTRY
      ;
  
 +otherModifier
 +@init
 +{
 +    $st = %{$start.getText()};
 +}
 +    :   ABSTRACT
 +    |   NATIVE
 +    ;
      
  type
      :   simpleType
          -> {$simpleType.st}
      |   objectType 
          -> {$objectType.st}
 +    |   VOID
 +        {
 +            $st = %{$start.getText()};
 +        }
      ;
  
  simpleType
-     :   ^(SIMPLE_TYPE primitiveType arrayDeclaratorList?)
-         -> simple_type(typeID={$primitiveType.st}, arrDeclList={$arrayDeclaratorList.st})
 -    :   ^(TYPE primitiveType domainExpression[null]?)
 -        -> type(typeID={$primitiveType.st}, arrDeclList={$domainExpression.st})
++    :   ^(SIMPLE_TYPE primitiveType domainExpression[null]?)
++        -> simple_type(typeID={$primitiveType.st}, arrDeclList={$domainExpression.st})
      ;
  
  objectType
 -    :   ^(TYPE qualifiedTypeIdent domainExpression[null]?)
 -        -> type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
 +    : proxyType -> {$proxyType.st;}
 +    | nonProxyType -> {$nonProxyType.st}
 +    ;
 +
 +nonProxyType
-     :   ^(OBJECT_TYPE qualifiedTypeIdent arrayDeclaratorList?)
-         -> obj_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$arrayDeclaratorList.st})
-     |   ^(POINTER_TYPE qualifiedTypeIdent arrayDeclaratorList?)
-         -> pointer_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$arrayDeclaratorList.st})
-     |   ^(REFERENCE_TYPE qualifiedTypeIdent arrayDeclaratorList?)
-         -> reference_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$arrayDeclaratorList.st})
++    :   ^(OBJECT_TYPE qualifiedTypeIdent domainExpression[null]?)
++        -> obj_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
++    |   ^(POINTER_TYPE qualifiedTypeIdent domainExpression[null]?)
++        -> pointer_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
++    |   ^(REFERENCE_TYPE qualifiedTypeIdent domainExpression[null]?)
++        -> reference_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
      ;
  
 -qualifiedTypeIdent
 -    :   ^(QUALIFIED_TYPE_IDENT (t+=typeIdent)+) 
 -        -> template(types={$t}) "<types; separator=\".\">"
 +proxyType
-     :   ^(PROXY_TYPE qualifiedTypeIdent arrayDeclaratorList?)
-         -> proxy_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$arrayDeclaratorList.st})
++    :   ^(PROXY_TYPE qualifiedTypeIdent domainExpression[null]?)
++        -> proxy_type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$domainExpression.st})
 +    ;
 +
 +qualifiedTypeIdent returns [ClassSymbol type]
 +    :   ^(QUALIFIED_TYPE_IDENT (t+=typeIdent)+)
 +        {$type = (ClassSymbol)$QUALIFIED_TYPE_IDENT.symbol;}
 +        -> template(types={$t}) "<types; separator=\"::\">"
      ;
  
  typeIdent
-     :   ^(IDENT genericTypeArgumentList?)
-         -> typeIdent(typeID={$IDENT.text}, generics={$genericTypeArgumentList.st})
+     :   ^(IDENT templateInstantiation?)
+         -> typeIdent(typeID={$IDENT.text}, generics={$templateInstantiation.st})
      ;
  
  primitiveType
  @init {
  $st = %{$start.getText()};
  }
 -    :   'boolean'
 +    :   BOOLEAN
          -> template() "bool"
 -    |   'char'
 -    |   'byte'
 +    |   CHAR
 +    |   BYTE
          -> template() "char"
 -    |   'short'
 -    |   'int'
 -    |   'long'
 -    |   'float'
 -    |   'double'
 +    |   SHORT
 +    |   INT
 +    |   LONG
 +    |   FLOAT
 +    |   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}
@@@ -503,19 -508,19 +558,19 @@@ formalParameterLis
      ;
      
  formalParameterStandardDecl
-     :   ^(FORMAL_PARAM_STD_DECL lms=localModifierList? t=type vdid=variableDeclaratorId)
+     :   ^(FORMAL_PARAM_STD_DECL lms=localModifierList? t=type vdid=variableDeclaratorId[true])
          -> formal_param_decl(modList={$lms.st}, type={$t.st}, declID={$vdid.st})
      ;
      
  formalParameterVarargDecl
-     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
+     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId[true])
          -> template(t={$text}) "/*formal parameter varargs not implemented*/ <t>"
      ;
      
  qualifiedIdentifier
      :   IDENT
          -> template(t={$text}) "<t>"
 -    |   ^('.' qualifiedIdentifier IDENT)
 +    |   ^(DOT qualifiedIdentifier IDENT)
          -> template(t={$text}) "<t>"
      ;
      
@@@ -537,73 -542,58 +592,73 @@@ blockStatemen
  
  
  localVariableDeclaration
-     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
+     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType vdl=variableDeclaratorList[null, true])
          -> local_var_decl(
 -            modList={null},
 +            modList={$localModifierList.st},
              type={$simpleType.st},
-             declList={$variableDeclaratorList.st})
-     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
+             declList={$vdl.st})
+     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType vdl=variableDeclaratorList[$objectType.st, true])
          -> local_var_decl(
 -            modList={null},
 +            modList={$localModifierList.st},
              type={$objectType.st},
-             declList={$variableDeclaratorList.st})
+             declList={$vdl.st})
      ;
  
  
  statement
 -    :   block
 +    :   nonBlockStatement
 +        -> {$nonBlockStatement.st}
 +    |   block
          -> {$block.st}
 -    |   ^('assert' cond=expression msg=expression?)
 +    ;
 +
 +nonBlockStatement
 +    :   ^(ASSERT cond=expression msg=expression?)
          -> assert(cond={$cond.st}, msg={$msg.st})
 -    |   ^('if' parenthesizedExpression then=statement else_=statement?)
 +    |   ^(IF parenthesizedExpression then=block else_=block?)
          -> if(cond={$parenthesizedExpression.st}, then={$then.st}, else_={$else_.st})
 -    |   ^('for' forInit cond=expression? (update+=expression)* s=statement)
 -        -> for(initializer={$forInit.st}, cond={$cond.st}, update={$update}, body={$s.st})
 -    |   ^(FOR_EACH localModifierList? type IDENT expression statement
 +    |   ^(FOR forInit? FOR_EXPR cond=expression? FOR_UPDATE (update+=expression)* b=block)
 +        -> for(initializer={$forInit.st}, cond={$cond.st}, update={$update}, body={$block.st})
 +    |   ^(FOR_EACH localModifierList? type IDENT expression block
          -> template(t={$text}) "/* foreach not implemented */ <t>"
 -    |   ^('while' pe=parenthesizedExpression s=statement)
 -        -> while(cond={$pe.st}, body={$s.st})
 -    |   ^('do' s=statement pe=parenthesizedExpression)
 -        -> dowhile(cond={$pe.st}, block={$s.st})
 -    |   ^('switch' pe=parenthesizedExpression (scls+=switchCaseLabel)*)
 +    |   ^(WHILE pe=parenthesizedExpression b=block)
 +        -> while(cond={$pe.st}, body={$b.st})
 +    |   ^(DO b=block pe=parenthesizedExpression)
 +        -> dowhile(cond={$pe.st}, block={$b.st})
 +    |   ^(SWITCH pe=parenthesizedExpression (scls+=switchCaseLabel)*)
          -> switch(expr={$pe.st}, labels={$scls})
 -    |   ^('return' e=expression?)
 +    |   ^(RETURN e=expression?)
          -> return(val={$e.st})
 -    |   ^('throw' expression)
 +    |   ^(THROW expression)
          -> template(t={$text}) "/* throw not implemented */ <t>"
 -    |   ^('break' IDENT?)
 +    |   ^(BREAK IDENT?)
          -> template() "break;" // TODO: support labeling
 -    |   ^('continue' IDENT?)
 +    |   ^(CONTINUE IDENT?)
          -> template() "continue;" // TODO: support labeling
      |   ^(LABELED_STATEMENT i=IDENT s=statement)
          -> label(text={$i.text}, stmt={$s.st})
      |   expression
          -> template(expr={$expression.st}) "<expr>;"
 +    |   ^('delete' qualifiedIdentifier)
 +        -> template(t={$qualifiedIdentifier.st}) "delete <t>;"
      |   ^('embed' STRING_LITERAL EMBED_BLOCK)
          ->  embed_cc(str={$STRING_LITERAL.text}, blk={$EMBED_BLOCK.text})
      |   ';' // Empty statement.
          -> {%{$start.getText()}}
 +    |   ^(PRINT (exprs += expression)*)
 +        ->  print(exprs = {$exprs})
 +    |   ^(PRINTLN (exprs += expression)*)
 +        ->  println(exprs = {$exprs})
 +    |   ^(EXIT expression?)
 +        ->  exit(expr = {$expression.st})
 +    |   EXITALL
 +        ->  exitall()
      ;
          
  switchCaseLabel
 -    :   ^('case' expression (b+=blockStatement)*)
 +    :   ^(CASE expression (b+=blockStatement)*)
          -> case(expr={$expression.st}, block={$b})
 -    |   ^('default' (b+=blockStatement)*)
 +    |   ^(DEFAULT (b+=blockStatement)*)
          -> template(block={$b}) "default: <block>"
      ;
      
@@@ -624,10 -614,12 +679,12 @@@ parenthesizedExpressio
  expression
      :   ^(EXPR expr)
          -> {$expr.st}
+     |   domainExpression[null]
+         -> {$domainExpression.st}
      ;
  
  expr
 -    :   ^('=' e1=expr e2=expr)
 +    :   ^(ASSIGNMENT e1=expr e2=expr)
          -> template(e1={$e1.st}, e2={$e2.st}) "<e1> = <e2>"
      |   ^('+=' e1=expr e2=expr)
          -> template(e1={$e1.st}, e2={$e2.st}) "<e1> += <e2>"
          -> template(e1={$e1.st}, e2={$e2.st}) "<e1> || <e2>"
      |   ^('&&' e1=expr e2=expr)
          -> template(e1={$e1.st}, e2={$e2.st}) "<e1> && <e2>"
 -    |   ^('|' e1=expr e2=expr)
 +    |   ^(BITWISE_OR e1=expr e2=expr)
          -> template(e1={$e1.st}, e2={$e2.st}) "<e1> | <e2>"
      |   ^('^' e1=expr e2=expr)
          -> template(e1={$e1.st}, e2={$e2.st}) "<e1> ^ <e2>"
      |   ^('&' e1=expr e2=expr)
          -> template(e1={$e1.st}, e2={$e2.st}) "<e1> & <e2>"
 -    |   ^('==' e1=expr e2=expr)
 +    |   ^(EQUALS e1=expr e2=expr)
          -> template(e1={$e1.st}, e2={$e2.st}) "<e1> == <e2>"
      |   ^('!=' e1=expr e2=expr)
          -> template(e1={$e1.st}, e2={$e2.st}) "<e1> != <e2>"
          -> template(e1={$e1.st}) "<e1>++"
      |   ^(POST_DEC e1=expr)
          -> template(e1={$e1.st}) "<e1>--"
 -    |   ^('~' e1=expr)
 +    |   ^(TILDE e1=expr)
          -> template(e1={$e1.st}) "~<e1>"
 -    |   ^('!' e1=expr)
 +    |   ^(NOT e1=expr)
          -> template(e1={$e1.st}) "!<e1>"
      |   ^(CAST_EXPR ty=type e1=expr)
          -> template(ty={$ty.st}, e1={$e1.st}) "(<ty>)<e1>"
      |   primaryExpression
          -> {$primaryExpression.st}
      ;
 -    
 +
  primaryExpression
 -    :   ^('.' prim=primaryExpression IDENT)
 -        -> template(id={$IDENT}, prim={$prim.st}) "<prim>.<id>"
 -    |   ^('.' prim=primaryExpression 'this')
 -        -> template(prim={$prim.st}) "<prim>.this"
 -    |   ^('.' prim=primaryExpression 'super')
 -        -> template(prim={$prim.st}) "<prim>.super"
 +    :   ^(DOT prim=primaryExpression
 +            ( IDENT   -> template(id={$IDENT}, prim={$prim.st}) "<prim>.<id>"
 +            | THIS    -> template(prim={$prim.st}) "<prim>.this"
 +            | SUPER   -> template(prim={$prim.st}) "<prim>.super"
 +            )
 +        )
 +    |   ^(ARROW prim=primaryExpression
 +            ( IDENT   -> template(id={$IDENT}, prim={$prim.st}) "<prim>-><id>"
 +            | THIS    -> template(prim={$prim.st}) "<prim>->this"
 +            | SUPER   -> template(prim={$prim.st}) "<prim>->super"
 +            )
 +        )
      |   parenthesizedExpression
          -> {$parenthesizedExpression.st}
      |   IDENT
          -> {%{$start.getText()}}
      |   ^(METHOD_CALL pe=primaryExpression gtal=genericTypeArgumentList? args=arguments)
          -> method_call(primary={$pe.st}, generic_types={$gtal.st}, args={$args.st})
 +    |   ^(ENTRY_METHOD_CALL pe=primaryExpression gtal=genericTypeArgumentList? args=arguments)
 +        -> method_call(primary={$pe.st}, generic_types={$gtal.st}, args={$args.st})
      |   explicitConstructorCall
          -> {$explicitConstructorCall.st}
      |   ^(ARRAY_ELEMENT_ACCESS pe=primaryExpression ex=expression)
          -> template(pe={$pe.st}, ex={$ex.st}) "<pe>[<ex>]"
      |   literal
          -> {$literal.st}
-     |   newExpression
+     |   newExpression[null, false]
          -> {$newExpression.st}
 -    |   'this'
 +    |   THIS
          -> {%{$start.getText()}}
      |   arrayTypeDeclarator
          -> {$arrayTypeDeclarator.st}
 -    |   'super'
 +    |   SUPER
          -> {%{$start.getText()}}
 +    |   GETNUMPES
 +        ->  template() "CkNumPes()"
 +    |   GETNUMNODES
 +        ->  template() "CkNumNodes()"
 +    |   GETMYPE
 +        ->  template() "CkMyPe()"
 +    |   GETMYNODE
 +        ->  template() "CkMyNode()"
 +    |   GETMYRANK
 +        ->  template() "CkMyRank()"
 +
      ;
      
  explicitConstructorCall
@@@ -775,20 -748,23 +832,31 @@@ arrayTypeDeclarato
          -> template(t={$text}) "<t>"
      ;
  
- newExpression
+ newExpression[StringTemplate obtype, boolean output] returns [StringTemplate initArray]
+     :   ^(NEW_EXPRESSION arguments? domainExpression[$arguments.args])
+         -> {$output}? template(domain={$domainExpression.st},type={$obtype}) "new <type>(<domain>)"
+         -> {!$output}? template() ""
+         ->
++    |   ^(NEW proxyType arguments)
++        -> template(t={$proxyType.st}, a={$arguments.st}) "<t>::ckNew(<a>)"
++    |   ^(NEW nonProxyType arguments)
++        -> template(q={$nonProxyType.st}, a={$arguments.st}) "new <q>(<a>)"
+     ;
+ /*newExpression
      :   ^(  STATIC_ARRAY_CREATOR
              (   primitiveType newArrayConstruction
              |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
              )
          )
          -> template(t={$text}) "<t>"
 +    |   ^(NEW proxyType arguments)
 +        -> template(t={$proxyType.st}, a={$arguments.st}) "<t>::ckNew(<a>)"
 +    |   ^(NEW nonProxyType arguments)
 +        -> template(q={$nonProxyType.st}, a={$arguments.st}) "new <q>(<a>)"
      ;
- newArrayConstruction
+ */
/*newArrayConstruction
      :   arrayDeclaratorList arrayInitializer
          -> array_construction_with_init(
                  array_decls={$arrayDeclaratorList.st},
      |   (ex+=expression)+ adl=arrayDeclaratorList?
          -> array_construction(exprs={$ex}, array_decls={$adl.st})
      ;
- arguments
-     :   ^(ARGUMENT_LIST (ex+=expression)*)
-         -> arguments(exprs={$ex})
+ */
+ arguments returns [List<StringTemplate> args]
+ @init {
+     $args = new ArrayList<StringTemplate>();
+ }
+     :   ^(ARGUMENT_LIST (e=expression { $args.add($e.st); } )*)        
+         ->  arguments(exprs={$args})
      ;
  
  literal
@@@ -812,8 -791,8 +883,8 @@@ $st = %{$start.getText()}
      |   FLOATING_POINT_LITERAL
      |   CHARACTER_LITERAL
      |   STRING_LITERAL
 -    |   'true'
 -    |   'false'
 -    |   'null'
 +    |   TRUE
 +    |   FALSE
 +    |   NULL
      ;
  
index e7d3fcf92581f901dec23725412ac5b11b390d50,50810c78ef4962a155aaaf814020cc25103fa28d..c9ff0cbcf12115af89258e96232bb34d5a713fde
@@@ -28,8 -28,6 +28,8 @@@ package charj.translator
      MethodSymbol currentMethod = null;
      LocalScope currentLocalScope = null;
      Translator translator;
 +    List<CharjAST> imports = new ArrayList<CharjAST>();
 +    AstModifier astmod = new AstModifier();
  
      /**
       *  Test a list of CharjAST nodes to see if any of them has the given token
              }
          }
      }
 +
 +    public void addImport(CharjAST importNode) {
 +        imports.add(importNode);
 +    }
  }
  
  
@@@ -87,22 -81,22 +87,22 @@@ scope ScopeStack; // default scop
      symtab = _symtab;
      $ScopeStack::current = symtab.getDefaultPkg();
  }
 -    // TODO: go back to allowing multiple type definitions per file, check that
 -    // there is exactly one public type and return that one.
      :   ^(CHARJ_SOURCE 
          (packageDeclaration)? 
 -        (importDeclarations) 
 -        (typeDeclaration[$importDeclarations.packageNames]))
 -        { $cs = $typeDeclaration.sym; }
 +        (importDeclaration
 +        | typeDeclaration { $cs = $typeDeclaration.sym; }
 +        | readonlyDeclaration)*)
      ;
  
  // note: no new scope here--this replaces the default scope
  packageDeclaration
  @init { 
      List<String> names = null; 
 +    String packageName = "";
  }
 -    :   ^('package' qualifiedIdentifier)  {
 -            String packageName = $qualifiedIdentifier.text;
 +    :   ^(PACKAGE ((ids+=IDENT) { packageName += "." + $IDENT.text; })+)
 +        {
 +            packageName = packageName.substring(1);
              PackageScope ps = symtab.resolvePackage(packageName);
              if (ps == null) {
                  ps = symtab.definePackage(packageName);
              }
              currentPackage = ps;
              $ScopeStack::current = ps;
 -            $qualifiedIdentifier.start.symbol = ps;
          }
      ;
      
 -importDeclarations returns [List<CharjAST> packageNames]
 -@init {
 -      packageNames = new ArrayList<CharjAST>();
 -}
 -    :   (^('import' qualifiedIdentifier './*'?)
 -              { packageNames.add($qualifiedIdentifier.start); })*
 +importDeclaration
 +    :   ^(IMPORT qualifiedIdentifier '.*'?)
 +        { addImport($qualifiedIdentifier.start); }
      ;
  
 +readonlyDeclaration
 +    :   ^(READONLY localVariableDeclaration)
 +    ;
  
 -typeDeclaration[List<CharjAST> imports] returns [ClassSymbol sym]
 +typeDeclaration returns [ClassSymbol sym]
  scope ScopeStack; // top-level type scope
 -    :   ^('template' i1=IDENT* typeDeclaration[$imports])
 +    :   ^(TYPE classType IDENT
 +            (^('extends' parent=type))? (^('implements' type+))?
 +            {
 +                Scope outerScope = $ScopeStack[-1]::current;
 +                $sym = new ClassSymbol(symtab, $IDENT.text, outerScope.resolveType($parent.text), outerScope);
 +                outerScope.define($sym.name, $sym);
 +                currentClass = $sym;
 +                $sym.definition = $typeDeclaration.start;
 +                $sym.definitionTokenStream = input.getTokenStream();
 +                $IDENT.symbol = $sym;
 +                $ScopeStack::current = $sym;
 +                String classTypeName = $classType.text;
 +                if (classTypeName.equals("class")) {
 +                } else if (classTypeName.equals("chare")) {
 +                    currentClass.isChare = true;
 +                } else if (classTypeName.equals("group")) {
 +                    currentClass.isChare = true;
 +                } else if (classTypeName.equals("nodegroup")) {
 +                    currentClass.isChare = true;
 +                } else if (classTypeName.equals("chare_array")) {
 +                    currentClass.isChare = true;
 +                } else if (classTypeName.equals("mainchare")) {
 +                    currentClass.isChare = true;
 +                    currentClass.isMainChare = true;
 +                } else System.out.println("Error: type " + classTypeName + " not recognized.");
 +                importPackages($sym, imports);
 +            }
 +            classScopeDeclaration*)
 +            {
 +                //System.out.println("Members for type " + $sym.name + ":");
 +                //for (Map.Entry<String, Symbol> entry : $sym.members.entrySet()) {
 +                //    System.out.println(entry.getKey());
 +                //}
 +            }
++    |   ^('template' i1=IDENT* typeDeclaration)
+         {
+             // JL: Need to fill the templateArgs in ClassSymbol, and push this down
+             // to the class subtree
+         }
 -    |   ^('class' i2=IDENT (^('extends' type))? (^('implements' type+))? 
 -        {
 -            Scope outerScope = $ScopeStack[-1]::current;
 -            $sym = new ClassSymbol(symtab, $i2.text, null, outerScope);
 -            outerScope.define($sym.name, $sym);
 -            currentClass = $sym;
 -            $sym.definition = $typeDeclaration.start;
 -            $sym.definitionTokenStream = input.getTokenStream();
 -            $i2.symbol = $sym;
 -            $ScopeStack::current = $sym;
 -            importPackages($sym, $imports);
 -        }
 -            classScopeDeclaration*)
      |   ^('interface' IDENT (^('extends' type+))?  interfaceScopeDeclaration*)
      |   ^('enum' IDENT (^('implements' type+))? enumConstant+ classScopeDeclaration*)
 -    |   ^(chareType IDENT (^('extends' type))? (^('implements' type+))? classScopeDeclaration*)
 -    |   ^('chare_array' ARRAY_DIMENSION IDENT (^('extends' type))? (^('implements' type+))? classScopeDeclaration*)
 +    ;
 +
 +classType
 +    :   CLASS
 +    |   chareType
      ;
  
  chareType
 -    :   'chare'
 -    |   'group'
 -    |   'nodegroup'
 +    :   CHARE
 +    |   GROUP
 +    |   NODEGROUP
 +    |   MAINCHARE
 +    |   ^(CHARE_ARRAY ARRAY_DIMENSION)
      ;
  
  enumConstant
      ;
      
  classScopeDeclaration
 +scope ScopeStack;
      :   ^(FUNCTION_METHOD_DECL m=modifierList? g=genericTypeParameterList? 
              ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
              b=block?)
 -    |   ^(VOID_METHOD_DECL m=modifierList? g=genericTypeParameterList? IDENT 
 -            f=formalParameterList b=block?)
 -    |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList[false])
 -    |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[false])
 +        {
 +            ClassSymbol returnType = currentClass.resolveType($ty.text);
 +            MethodSymbol sym = new MethodSymbol(symtab, $IDENT.text, currentClass, returnType);
 +            currentMethod = sym;
 +            sym.definition = $classScopeDeclaration.start;
 +            sym.definitionTokenStream = input.getTokenStream();
 +            currentClass.define($IDENT.text, sym);
 +            $FUNCTION_METHOD_DECL.symbol = sym;
 +        }
 +    |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType
-             ^(VAR_DECLARATOR_LIST field[$simpleType.type]+))
++            ^(VAR_DECLARATOR_LIST field[$simpleType.type, false]+))
 +    |   ^(OBJECT_VAR_DECLARATION modifierList? objectType
-             ^(VAR_DECLARATOR_LIST field[$objectType.type]+))
++            ^(VAR_DECLARATOR_LIST field[$objectType.type, false]+))
 +        {
 +            ClassSymbol type = $objectType.type;
 +            if (type != null && type.isChare) currentClass.addExtern(type.getName());
 +        }
      |   ^(CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList 
              b=block)
          {
 -              if (currentClass != null) {
 +            if (astmod.isMigrationCtor($CONSTRUCTOR_DECL)) currentClass.migrationCtor = $CONSTRUCTOR_DECL;
++            if (currentClass != null) {
+                 currentClass.constructor = $classScopeDeclaration.start;
 -            } 
++            }
          }
      ;
- field [ClassSymbol type]
-     :   ^(VAR_DECLARATOR ^(IDENT arrayDeclaratorList?) variableInitializer?)
 +
-             VariableSymbol sym = new VariableSymbol(symtab, $IDENT.text, $type);
++field [ClassSymbol type, boolean localdef]
++    :   ^(VAR_DECLARATOR variableDeclaratorId[localdef] variableInitializer?)
 +    {
-             currentClass.define($IDENT.text, sym);
++            VariableSymbol sym = new VariableSymbol(symtab, $variableDeclaratorId.ident, $type);
 +            sym.definition = $field.start;
 +            sym.definitionTokenStream = input.getTokenStream();
 +            $VAR_DECLARATOR.symbol = sym;
++            currentClass.define($variableDeclaratorId.ident, sym);
 +    }
 +    ;
      
  interfaceScopeDeclaration
      :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
              type IDENT formalParameterList arrayDeclaratorList?)
 -    |   ^(VOID_METHOD_DECL modifierList? genericTypeParameterList? IDENT formalParameterList)
          // Interface constant declarations have been switched to variable
          // declarations by Charj.g; the parser has already checked that
          // there's an obligatory initializer.
-     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
-     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
+     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList[false])
+     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList[false])
      ;
  
- variableDeclaratorList
-     :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
+ variableDeclaratorList[boolean localdef]
+     :   ^(VAR_DECLARATOR_LIST variableDeclarator[localdef]+)
      ;
  
- variableDeclarator
-     :   ^(VAR_DECLARATOR ^(IDENT arrayDeclaratorList?) variableInitializer?)
+ variableDeclarator[boolean localdef]
+     :   ^(VAR_DECLARATOR variableDeclaratorId[localdef] variableInitializer?)
      ;
      
- variableDeclaratorId
-     :   ^(IDENT arrayDeclaratorList?)
 -variableDeclaratorId[boolean localdef]
 -    :   ^(IDENT domainExpression? 
++variableDeclaratorId[boolean localdef] returns [String ident]
++    :   ^(IDENT domainExpression?
+         { 
+             if (currentClass != null && !localdef) {
+                 currentClass.initializers.add($variableDeclaratorId.start);
+             }
++
++            $ident = $IDENT.text;
+         } )
+     ;
+ 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
 -    |   newExpression
 +    |   expression
      ;
  
  arrayDeclaratorList
@@@ -268,110 -243,73 +301,119 @@@ boun
      ;
  
  modifierList
 -    :   ^(MODIFIER_LIST modifier+)
 +    :   ^(MODIFIER_LIST accessModifierList? localModifierList? charjModifierList? otherModifierList?)
      ;
  
  modifier
 -    :   'public'
 -    |   'protected'
 -    |   'private'
 -    |   'entry'
 -    |   'abstract'
 -    |   'native'
 +    :   accessModifier
      |   localModifier
 +    |   charjModifier
 +    |   otherModifier
      ;
  
  localModifierList
      :   ^(LOCAL_MODIFIER_LIST localModifier+)
      ;
  
 +accessModifierList
 +    :   ^(ACCESS_MODIFIER_LIST accessModifier+)
 +    ;
 +
 +charjModifierList
 +    :   ^(CHARJ_MODIFIER_LIST charjModifier+)
 +    ;
 +
 +otherModifierList
 +    :   ^(OTHER_MODIFIER_LIST otherModifier+)
 +    ;
 +    
  localModifier
 -    :   'final'
 -    |   'static'
 -    |   'volatile'
 +    :   FINAL
 +    |   STATIC
 +    |   VOLATILE
 +    ;
 +
 +accessModifier
 +    :   PUBLIC
 +    |   PROTECTED
 +    |   PRIVATE
 +    ;
 +
 +charjModifier
 +    :   ENTRY
 +    ;
 +
 +otherModifier
 +    :   ABSTRACT
 +    |   NATIVE
      ;
  
  type
      :   simpleType
 -    |   objectType 
 +    |   objectType
 +    |   VOID
      ;
  
 -simpleType
 -    :   ^(TYPE primitiveType domainExpression?)
 +simpleType returns [ClassSymbol type]
 +    :   ^(SIMPLE_TYPE primitiveType arrayDeclaratorList?)
 +        {
 +            $type = symtab.resolveBuiltinType($primitiveType.text);
 +        }
      ;
      
 -objectType
 -    :   ^(TYPE qualifiedTypeIdent domainExpression?)
 +objectType returns [ClassSymbol type]
 +    :   ^(OBJECT_TYPE qualifiedTypeIdent arrayDeclaratorList?)
 +    |   ^(REFERENCE_TYPE qualifiedTypeIdent arrayDeclaratorList?)
 +    |   ^(PROXY_TYPE qualifiedTypeIdent arrayDeclaratorList?)
 +    |   ^(POINTER_TYPE qualifiedTypeIdent arrayDeclaratorList?)
 +        {
 +            $type = $qualifiedTypeIdent.type;
 +        }
      ;
  
 -qualifiedTypeIdent
 -    :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
 +qualifiedTypeIdent returns [ClassSymbol type]
 +@init {
 +String name = "";
 +}
 +    :   ^(QUALIFIED_TYPE_IDENT (typeIdent {name += $typeIdent.name;})+) 
 +        {
 +            $type = null;
 +            /*System.out.println("trying to resolve type " + name + " in type " + currentClass);*/
 +            if (currentClass != null) $type = currentClass.resolveType(name);
 +            /*System.out.println("got " + $type);*/
 +            if ($type == null) $type = symtab.resolveBuiltinType(name);
 +            $QUALIFIED_TYPE_IDENT.symbol = $type;
 +        }
      ;
  
 -typeIdent
 +typeIdent returns [String name]
-     :   ^(IDENT genericTypeArgumentList?)
+     :   ^(IDENT templateInstantiation?)
 +        { $name = $IDENT.text; }
      ;
  
  primitiveType
 -    :   'boolean'     { $start.symbol = new Symbol(symtab, "bool_primitive", symtab.resolveBuiltinType("bool")); }
 -    |   'char'        { $start.symbol = new Symbol(symtab, "char_primitive", symtab.resolveBuiltinType("char")); }
 -    |   'byte'        { $start.symbol = new Symbol(symtab, "byte_primitive", symtab.resolveBuiltinType("char")); }
 -    |   'short'       { $start.symbol = new Symbol(symtab, "short_primitive", symtab.resolveBuiltinType("short")); }
 -    |   'int'         { $start.symbol = new Symbol(symtab, "int_primitive", symtab.resolveBuiltinType("int")); }
 -    |   'long'        { $start.symbol = new Symbol(symtab, "long_primitive", symtab.resolveBuiltinType("long")); }
 -    |   'float'       { $start.symbol = new Symbol(symtab, "float_primitive", symtab.resolveBuiltinType("float")); }
 -    |   'double'      { $start.symbol = new Symbol(symtab, "double_primitive", symtab.resolveBuiltinType("double")); }
 +    :   BOOLEAN     { $start.symbol = new Symbol(symtab, "bool_primitive", symtab.resolveBuiltinType("bool")); }
 +    |   CHAR        { $start.symbol = new Symbol(symtab, "char_primitive", symtab.resolveBuiltinType("char")); }
 +    |   BYTE        { $start.symbol = new Symbol(symtab, "byte_primitive", symtab.resolveBuiltinType("char")); }
 +    |   SHORT       { $start.symbol = new Symbol(symtab, "short_primitive", symtab.resolveBuiltinType("short")); }
 +    |   INT         { $start.symbol = new Symbol(symtab, "int_primitive", symtab.resolveBuiltinType("int")); }
 +    |   LONG        { $start.symbol = new Symbol(symtab, "long_primitive", symtab.resolveBuiltinType("long")); }
 +    |   FLOAT       { $start.symbol = new Symbol(symtab, "float_primitive", symtab.resolveBuiltinType("float")); }
 +    |   DOUBLE      { $start.symbol = new Symbol(symtab, "double_primitive", symtab.resolveBuiltinType("double")); }
      ;
  
  genericTypeArgumentList
      :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
      ;
+ templateArgList
+     :   genericTypeArgument+
+     ;
+ templateInstantiation
+     :   ^(TEMPLATE_INST templateArgList)
+     |   ^(TEMPLATE_INST templateInstantiation)
+     ;
      
  genericTypeArgument
      :   type
@@@ -383,18 -321,18 +425,18 @@@ formalParameterLis
      ;
      
  formalParameterStandardDecl
-     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
+     :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId[false])
      ;
      
  formalParameterVarargDecl
-     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
+     :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId[false])
      ;
      
  // FIXME: is this rule right? Verify that this is ok, I expected something like:
 -// IDENT (^('.' qualifiedIdentifier IDENT))*
 +// IDENT (^(DOT qualifiedIdentifier IDENT))*
  qualifiedIdentifier
      :   IDENT
 -    |   ^('.' qualifiedIdentifier IDENT)
 +    |   ^(DOT qualifiedIdentifier IDENT)
      ;
      
  block
@@@ -407,54 -345,40 +449,54 @@@ blockStatemen
      ;
      
  localVariableDeclaration
-     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
-     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
+     :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList[true])
+     |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList[true])
 +        {
 +            ClassSymbol type = $objectType.type;
 +            /*System.out.println("looked up type " + type + " for declaration " + $objectType.text);*/
 +            if (type != null && type.isChare && currentClass != null) currentClass.addExtern(type.getName());
 +        }
      ;
  
  statement
 -    :   block
 -    |   ^('assert' expression expression?)
 -    |   ^('if' parenthesizedExpression statement statement?)
 -    |   ^('for' forInit expression? expression* statement)
 -    |   ^(FOR_EACH localModifierList? type IDENT expression statement) 
 -    |   ^('while' parenthesizedExpression statement)
 -    |   ^('do' statement parenthesizedExpression)
 -    |   ^('switch' parenthesizedExpression switchCaseLabel*)
 -    |   ^('return' expression?)
 -    |   ^('throw' expression)
 -    |   ^('break' IDENT?) {
 +    : nonBlockStatement
 +    | block
 +    ;
 +
 +nonBlockStatement
 +    :   ^(ASSERT expression expression?)
 +    |   ^(IF parenthesizedExpression block block?)
 +    |   ^(FOR forInit? FOR_EXPR expression? FOR_UPDATE expression* block)
 +    |   ^(FOR_EACH localModifierList? type IDENT expression block) 
 +    |   ^(WHILE parenthesizedExpression block)
 +    |   ^(DO block parenthesizedExpression)
 +    |   ^(SWITCH parenthesizedExpression switchCaseLabel*)
 +    |   ^(RETURN expression?)
 +    |   ^(THROW expression)
 +    |   ^(BREAK IDENT?) {
              if ($IDENT != null) {
                  translator.error(this, "Labeled break not supported yet, ignoring.", $IDENT);
              }
          }
 -    |   ^('continue' IDENT?) {
 +    |   ^(CONTINUE IDENT?) {
              if ($IDENT != null) {
                  translator.error(this, "Labeled continue not supported yet, ignoring.", $IDENT);
              }
          }
      |   ^(LABELED_STATEMENT IDENT statement)
      |   expression
 -    |   ^('embed' STRING_LITERAL EMBED_BLOCK)
 +    |   ^('delete' qualifiedIdentifier)
 +    |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
      |   ';' // Empty statement.
 +    |   ^(PRINT expression*)
 +    |   ^(PRINTLN expression*)
 +    |   ^(EXIT expression?)
 +    |   EXITALL
      ;
          
  switchCaseLabel
 -    :   ^('case' expression blockStatement*)
 -    |   ^('default' blockStatement*)
 +    :   ^(CASE expression blockStatement*)
 +    |   ^(DEFAULT blockStatement*)
      ;
      
  forInit
  parenthesizedExpression
      :   ^(PAREN_EXPR expression)
      ;
-     
  expression
      :   ^(EXPR expr)
      ;
  
  expr
 -    :   ^('=' expr expr)
 -    |   ^('+=' expr expr)
 -    |   ^('-=' expr expr)
 -    |   ^('*=' expr expr)
 -    |   ^('/=' expr expr)
 -    |   ^('&=' expr expr)
 -    |   ^('|=' expr expr)
 -    |   ^('^=' expr expr)
 -    |   ^('%=' expr expr)
 +    :   ^(ASSIGNMENT expr expr)
 +    |   ^(PLUS_EQUALS expr expr)
 +    |   ^(MINUS_EQUALS expr expr)
 +    |   ^(TIMES_EQUALS expr expr)
 +    |   ^(DIVIDE_EQUALS expr expr)
 +    |   ^(AND_EQUALS expr expr)
 +    |   ^(OR_EQUALS expr expr)
 +    |   ^(POWER_EQUALS expr expr)
 +    |   ^(MOD_EQUALS expr expr)
      |   ^('>>>=' expr expr)
      |   ^('>>=' expr expr)
      |   ^('<<=' expr expr)
      |   ^('?' expr expr expr)
 -    |   ^('||' expr expr)
 -    |   ^('&&' expr expr)
 -    |   ^('|' expr expr)
 -    |   ^('^' expr expr)
 -    |   ^('&' expr expr)
 -    |   ^('==' expr expr)
 -    |   ^('!=' expr expr)
 -    |   ^('instanceof' expr type)
 -    |   ^('<=' expr expr)
 -    |   ^('>=' expr expr)
 +    |   ^(OR expr expr)
 +    |   ^(AND expr expr)
 +    |   ^(BITWISE_OR expr expr)
 +    |   ^(POWER expr expr)
 +    |   ^(BITWISE_AND expr expr)
 +    |   ^(EQUALS expr expr)
 +    |   ^(NOT_EQUALS expr expr)
 +    |   ^(INSTANCEOF expr type)
 +    |   ^(LTE expr expr)
 +    |   ^(GTE expr expr)
      |   ^('>>>' expr expr)
      |   ^('>>' expr expr)
 -    |   ^('>' expr expr)
 +    |   ^(GT expr expr)
      |   ^('<<' expr expr)
 -    |   ^('<' expr expr)
 -    |   ^('+' expr expr)
 -    |   ^('-' expr expr)
 -    |   ^('*' expr expr)
 -    |   ^('/' expr expr)
 -    |   ^('%' expr expr)
 +    |   ^(LT expr expr)
 +    |   ^(PLUS expr expr)
 +    |   ^(MINUS expr expr)
 +    |   ^(TIMES expr expr)
 +    |   ^(DIVIDE expr expr)
 +    |   ^(MOD expr expr)
      |   ^(UNARY_PLUS expr)
      |   ^(UNARY_MINUS expr)
      |   ^(PRE_INC expr)
      |   ^(PRE_DEC expr)
      |   ^(POST_INC expr)
      |   ^(POST_DEC expr)
 -    |   ^('~' expr)
 -    |   ^('!' expr)
 +    |   ^(TILDE expr)
 +    |   ^(NOT expr)
      |   ^(CAST_EXPR type expr)
      |   primaryExpression
      ;
      
  primaryExpression
 -    :   ^(  '.' primaryExpression
 +    :   ^(DOT primaryExpression
                  (   IDENT
 -                |   'this'
 -                |   'super'
 +                |   THIS
 +                |   SUPER
 +                )
 +        )
 +    |   ^(ARROW primaryExpression
 +                (   IDENT
 +                |   THIS
 +                |   SUPER
                  )
          )
      |   parenthesizedExpression
      |   IDENT
      |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
 +    |   ^(ENTRY_METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
      |   explicitConstructorCall
      |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
      |   literal
      |   newExpression
 -    |   'this'
 +    |   THIS
      |   arrayTypeDeclarator
 -    |   'super'
 +    |   SUPER
 +    |   GETNUMPES
 +    |   GETNUMNODES
 +    |   GETMYPE
 +    |   GETMYNODE
 +    |   GETMYRANK
      ;
      
  explicitConstructorCall
@@@ -559,14 -471,22 +601,15 @@@ arrayTypeDeclarato
      ;
  
  newExpression
-     :   ^(  STATIC_ARRAY_CREATOR
-             (   primitiveType newArrayConstruction
-             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
-             )
-         )
+     :   ^(NEW_EXPRESSION arguments? domainExpression)
+         {
+             if (currentClass != null) {
+                 currentClass.initializers.add($newExpression.start);
+             }
+         }
 +    |   ^(NEW type arguments)
      ;
  
 -/*newExpression
 -    :   ^(  STATIC_ARRAY_CREATOR
 -            (   primitiveType newArrayConstruction
 -            |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
 -            )
 -        )
 -    ;*/
 -
  newArrayConstruction
      :   arrayDeclaratorList arrayInitializer
      |   expression+ arrayDeclaratorList?
@@@ -583,8 -503,8 +626,8 @@@ litera
      |   FLOATING_POINT_LITERAL
      |   CHARACTER_LITERAL
      |   STRING_LITERAL          
 -    |   'true'
 -    |   'false'
 -    |   'null'
 +    |   TRUE
 +    |   FALSE
 +    |   NULL 
      ;
  
index 42f072a2974c8116ee1379ad73a2855c80a7d187,f5f228bebf2dbde655179a4fd5a4e651b88d777a..e4c727df5e46617f96700f839eac96cf705921e1
@@@ -7,62 -7,60 +7,70 @@@ public class ClassSymbol extends Symbol
  
      public ClassSymbol superClass;
      public List<String> interfaceImpls;
+     public List<String> templateArgs;
+     public List<CharjAST> initializers;
+     public CharjAST constructor;
  
 -    Map<String, PackageScope> imports = 
 +    Map<String, PackageScope> imports =
          new LinkedHashMap<String, PackageScope>();
 +    List<String> includes = new ArrayList<String>();
 +    List<String> usings = new ArrayList<String>();
 +    List<String> externs = new ArrayList<String>();
  
 -    /** List of all fields and methods */
 +    /** Record of all fields and methods */
      public Map<String, Symbol> members = new LinkedHashMap<String, Symbol>();
 -    public Map<String, String> aliases = new LinkedHashMap<String, String>();
 -
 -    /** The set of method names (without signatures) for this class.  Maps
 -     *  to a list of methods with same name but different args
 -     protected Map<String, List<MethodSymbol>> methods =
 -     new HashMap<String, List<MethodSymbol>>();
 -     */
 -
 -    /** List of unmangled methods for this class. Used to distinguish
 -     *  var from method name in expressions.  x = f; // what is f?
 -     */
 -    protected Set<String> methodNames = new HashSet<String>();
 +    public Map<String, VariableSymbol> fields = new LinkedHashMap<String, VariableSymbol>();
 +    public Map<String, MethodSymbol> methods = new LinkedHashMap<String, MethodSymbol>();
  
      public boolean hasCopyCtor = false;
 +    public boolean isPrimitive = false;
 +    public boolean isChare = false;
 +    public boolean isMainChare = false;
 +
 +    public CharjAST migrationCtor = null;
  
      public ClassSymbol(
 -            SymbolTable symtab, 
 +            SymbolTable symtab,
              String name) {
          super(symtab, name);
          type = this;
          for (String pkg : SymbolTable.AUTO_IMPORTS) {
              importPackage(pkg);
          }
+       this.initializers = new ArrayList<CharjAST>();
+       constructor = null;
      }
  
      public ClassSymbol(
 -            SymbolTable symtab, 
 +            SymbolTable symtab,
              String name,
              ClassSymbol superClass,
              Scope scope) {
          this(symtab, name);
          this.superClass = superClass;
          this.scope = scope;
+       this.initializers = new ArrayList<CharjAST>();
+       constructor = null;
  
          // manually add automatic class methods and symbols here
 +        this.includes.add("charm++.h");
 +        this.includes.add("list");
 +        this.usings.add("std::list");
 +        this.includes.add("string");
 +        this.usings.add("std::string");
 +        this.includes.add("vector");
 +        this.usings.add("std::vector");
 +        this.includes.add("map");
 +        this.usings.add("std::map");
 +        this.includes.add("iostream");
 +        this.usings.add("std::cout");
 +        this.usings.add("std::endl");
      }
  
      public Scope getEnclosingScope() {
          // at root?  Then use enclosing scope
 -        if ( superClass==null ) { 
 +        if ( superClass==null ) {
              return scope;
          }
          return superClass;
@@@ -75,7 -73,7 +83,7 @@@
      /** Importing a package means adding the package to list of "filters"
       *  used by resolvePackage.  The resolve operation can only see classes
       *  defined in the imported packages.  This method asks the sym tab if
 -     *  it is known before looking at corresponding dir on disk to see if it 
 +     *  it is known before looking at corresponding dir on disk to see if it
       *  exists.
       *
       *  Return null if this class is not in sym tab and was not found in path.
@@@ -84,7 -82,7 +92,7 @@@
          if (debug()) System.out.println(
                  "ClassSymbol.importPackage(" + packageName +
                  "): add to " + toString());
 -        
 +
          PackageScope p = symtab.resolvePackage(packageName);
          if ( p!=null ) {
              imports.put(packageName, p);
          }
  
          if ( p==null && debug() ) System.out.println(
 -                "ClassSymbol.importPackage(" + packageName + 
 +                "ClassSymbol.importPackage(" + packageName +
                  "): dir not found");
          return p;
      }
  
 -    public void alias(
 -            CharjAST aliasAST, 
 -            CharjAST methodNameAST) {
 -        String op = aliasAST.getToken().getText();
 -        op = op.substring(1,op.length()-1);
 -        String method = methodNameAST.getToken().getText();
 -        method = method.substring(1,method.length()-1);
 -        alias(op, method);
 -    }
 -
 -    public void alias(
 -            String alias, 
 -            String methodName) {
 -        aliases.put(alias, methodName);
 -    }
 -
 -    public String getMethodNameForOperator(String op) {
 -        String name = aliases.get(op);
 -        if ( name==null ) {
 -            symtab.translator.error(
 -                    "no such operator for " + this.name + ": " + op);
 -        }
 -        return name;
 -    }
 -
      /** Using the list of imports, resolve a package name like charj.lang.
       *  There may be many packages defined and visible to the symbol table
       *  but this class can only see those packages in the implicit or explicit
          return imports.get(packageName);
      }
  
 -    /** To resolve a type in a class, look it up in each imported package 
 -     *  including the current package. Classes cannot be defined in the 
 +    /** To resolve a type in a class, look it up in each imported package
 +     *  including the current package. Classes cannot be defined in the
       *  superclass so don't look upwards for types.
       *
       *  First check to see if we are resolving enclosing class then
       *  look for type in each imported package.  If not found in existing
 -     *  packges, walk through imported packages again, trying to load from 
 +     *  packges, walk through imported packages again, trying to load from
       *  disk.
       */
      public ClassSymbol resolveType(String type) {
  
          if ( name.equals(type) ) {
              if ( debug() ) System.out.println(
 -                    "ClassSymbol.resolveType(" + type + 
 +                    "ClassSymbol.resolveType(" + type +
                      "): surrounding class " + name + ":" + members.keySet());
              return this;
          }
  
          // look for type in classes already defined in imported packages
          for (String packageName : imports.keySet()) {
 +            if ( debug() ) System.out.println( "Looking for type " +
 +                    type + " in package " + packageName);
              PackageScope pkg = resolvePackage(packageName);
              ClassSymbol cs = pkg.resolveType(type);
              if ( cs != null) { // stop looking, found it
                  if ( debug() ) System.out.println(
 -                        "ClassSymbol.resolveType(" + type + 
 -                        "): found in context " + name + ":" + 
 +                        "ClassSymbol.resolveType(" + type +
 +                        "): found in context " + name + ":" +
                          members.keySet());
                  return cs;
              }
          }
  
          // not already seen in one of the imported packages, look on disk
 -        for (String packageName : imports.keySet()) {
 -            PackageScope pkg = resolvePackage(packageName);
 -            ClassSymbol cs = symtab.translator.loadType(
 -                    pkg.getFullyQualifiedName(), type);
 -            if ( cs!=null ) {
 -                pkg.define(type, cs); // add to symbol table
 -                if ( debug() ) System.out.println(
 -                        "ClassSymbol.resolveType(" + type +
 -                        "): found after loading in context " + name +
 -                        ":" + members.keySet());
 -                return cs;
 -            }
 -        }
 +        //for (String packageName : imports.keySet()) {
 +        //    PackageScope pkg = resolvePackage(packageName);
 +        //    ClassSymbol cs = symtab.translator.loadType(
 +        //            pkg.getFullyQualifiedName(), type);
 +        //    if ( cs!=null ) {
 +        //        pkg.define(type, cs); // add to symbol table
 +        //        if ( debug() ) System.out.println(
 +        //                "ClassSymbol.resolveType(" + type +
 +        //                "): found after loading in context " + name +
 +        //                ":" + members.keySet());
 +        //        return cs;
 +        //    }
 +        //}
  
          if ( debug() ) System.out.println(
 -                "ClassSymbol.resolveType(" + type + 
 +                "ClassSymbol.resolveType(" + type +
                  "): not in context " + name + ":" + members.keySet());
          return null;
      }
  
      public MethodSymbol resolveMethodLocally(
 -            String name, 
 +            String name,
              int numargs) {
 -        if ( numargs>0 ) {
 +        if (numargs > 0) {
              name += numargs;
          }
 -     
 -        Symbol s = members.get(name);
 -        if ( s!=null && s.getClass() == MethodSymbol.class ) {
 -            return (MethodSymbol)s;
 -        }
  
 -        return null;
 +        return methods.get(name);
      }
  
      public boolean isMethod(String name) {
 -        if ( methodNames.contains(name) ) {
 +        if ( methods.containsKey(name) ) {
              return true;
          }
          if ( getEnclosingScope()!=null ) {
      }
  
      public Symbol define(
 -            String name, 
 +            String name,
              Symbol sym) {
 -        if ( sym instanceof MethodSymbol ) {
 -            methodNames.add(sym.name);
 +        if (sym == null) {
 +            System.out.println("ClassSymbol.define: Uh oh, defining null symbol");
 +        }
 +        members.put(name, sym);
 +        if (sym instanceof MethodSymbol) {
 +            methods.put(name, (MethodSymbol)sym);
 +        } else if (sym instanceof VariableSymbol) {
 +            fields.put(name, (VariableSymbol)sym);
          }
          return super.define(name, sym);
      }
              parent = scope.getFullyQualifiedName();
          }
          if ( parent!=null ) {
 -            return parent+"."+name;
 +            return parent+"::"+name;
          }
          return name;
      }
  
 -    public String getMangledName() {
 -        if ( SymbolTable.TYPE_NAMES_TO_MANGLE.contains(name) ) {
 -            return "m"+name;
 +    public void addInclude(String includeName) {
 +        includes.add(includeName);
 +    }
 +
 +    public void addExtern(String externName) {
 +        externs.add(externName);
 +    }
 +
 +    public void getUsings(String usingName) {
 +        usings.add(usingName);
 +    }
 +
 +    public List<String> getIncludes()
 +    {
 +        return includes;
 +    }
 +
 +    public List<String> getUsings()
 +    {
 +        return usings;
 +    }
 +
 +    public List<String> getExterns()
 +    {
 +        return externs;
 +    }
 +
 +    public List<String> getPackageNames()
 +    {
 +        List<String> list = new LinkedList<String>();
 +        for(Scope currentScope = scope;
 +                currentScope.getEnclosingScope() != null;
 +                currentScope = currentScope.getEnclosingScope()) {
 +            list.add(0, currentScope.getScopeName());
          }
 -        return name;
 +        return list;
 +    }
 +
 +    private Set<ClassSymbol> getMemberTypes()
 +    {
 +        Set<ClassSymbol> types = new HashSet<ClassSymbol>();
 +        for (Map.Entry<String, VariableSymbol> entry : fields.entrySet()) {
 +            // note: type info may be null for unknown types, but this might
 +            // need to be changed at some point.
 +            ClassSymbol type = ((VariableSymbol)entry.getValue()).type;
 +            if (type != null) types.add(type);
 +        }
 +        return types;
 +    }
 +
 +    public List<String> getMemberTypeNames()
 +    {
 +        List<String> names = new ArrayList<String>();
 +        for (ClassSymbol c : getMemberTypes()) {
 +            if (c.isPrimitive) continue;
 +            names.add(c.getName());
 +        }
 +        return names;
      }
  
 +    public String getName()
 +    {
 +        return name;
 +    }
  }
index 8c4398072a6aa81f6ac6f04bbc9ad1b708dfc3f4,f0bdce59c819cc6b8a0a331976ce5a3056804de7..901b8bfee813cdeb5523ca4111eb8b97eab1e550
@@@ -31,7 -31,6 +31,7 @@@ public class Translator 
      private String m_stdlib;
      private List<String> m_usrlibs;
  
 +    private String m_basename;
      private SymbolTable m_symtab;
      private CommonTree m_ast;
      private CommonTreeNodeStream m_nodes;
@@@ -58,7 -57,6 +58,7 @@@
  
      public boolean debug()      { return m_debug; }
      public boolean verbose()    { return m_verbose; }
 +    public String basename()    { return m_basename; }
  
      public static TreeAdaptor m_adaptor = new CommonTreeAdaptor() {
          public Object create(Token token) {
@@@ -74,8 -72,6 +74,8 @@@
      };
  
      public String translate(String filename) throws Exception {
 +        m_basename = filename.substring(0, filename.lastIndexOf("."));
 +
          ANTLRFileStream input = new ANTLRFileStream(filename);
              
          CharjLexer lexer = new CharjLexer(input);
          m_nodes.setTokenStream(tokens);
          m_nodes.setTreeAdaptor(m_adaptor);
  
 -        // do AST rewriting in semantic phase
 -        if (m_printAST) printAST("Before Semantic Pass", "before.html");
 -        ClassSymbol sem = semanticPass();
 +        // do AST rewriting and semantic checking
 +        if (m_printAST) printAST("Before Modifier Pass", "before_mod.html");
 +        modifierPass();
 +        m_nodes = new CommonTreeNodeStream(m_ast);
 +        m_nodes.setTokenStream(tokens);
 +        m_nodes.setTreeAdaptor(m_adaptor);
 +        if (m_printAST) printAST("Before Semantic Pass", "before_sem.html");
-         semanticPass();
++      ClassSymbol sem = semanticPass();
+       modifyNodes(sem);
 -        if (m_printAST) printAST("After Semantic Pass", "after.html");
++        //semanticPass();
 +        if (m_printAST) printAST("After Semantic Pass", "after_sem.html");
  
+       m_nodes = new CommonTreeNodeStream(m_ast);
+         m_nodes.setTokenStream(tokens);
+         m_nodes.setTreeAdaptor(m_adaptor);
          // emit code for .ci, .h, and .cc based on rewritten AST
 -        m_nodes.reset();
          String ciOutput = translationPass(OutputMode.ci);
          writeTempFile(filename, ciOutput, OutputMode.ci);
  
 -        m_nodes.reset();
          String hOutput = translationPass(OutputMode.h);
          writeTempFile(filename, hOutput, OutputMode.h);
          
 -        m_nodes.reset();
          String ccOutput = translationPass(OutputMode.cc);
          writeTempFile(filename, ccOutput, OutputMode.cc);
          if (!m_translate_only) compileTempFiles(filename, m_charmc);
              ccHeader + ccOutput + footer;
      }
  
 +    private void modifierPass() throws
 +        RecognitionException, IOException, InterruptedException
 +    {
 +        m_nodes.reset();
 +        CharjASTModifier mod = new CharjASTModifier(m_nodes);
 +        mod.setTreeAdaptor(m_adaptor);
 +        m_ast = (CommonTree)mod.charjSource(m_symtab).getTree();
 +    }
 +
      private ClassSymbol semanticPass() throws
          RecognitionException, IOException, InterruptedException
      {
 +        m_nodes.reset();
          CharjSemantics sem = new CharjSemantics(m_nodes);
          return sem.charjSource(m_symtab);
      }
  
 -              CharjAST ast2_1 = new CharjAST(CharjParser.T__140, ".");
+     private CharjAST addConstructor(ClassSymbol sem) {
+       CharjAST ast1 = new CharjAST(CharjParser.CONSTRUCTOR_DECL, 
+                                    "CONSTRUCTOR_DECL");
+       CharjAST ast2 = new CharjAST(CharjParser.IDENT, 
+                                    sem.getScopeName());
+       CharjAST ast3 = new CharjAST(CharjParser.FORMAL_PARAM_LIST, 
+                                    "FORMAL_PARAM_LIST");
+       CharjAST ast4 = new CharjAST(CharjParser.BLOCK, "BLOCK");
+       
+       ast1.addChild(ast2);
+       ast1.addChild(ast3);
+       ast1.addChild(ast4);
+       sem.definition.addChild(ast1);
+       return ast1;
+     }
+     private void modifyNodes(ClassSymbol sem) {
+       /* Add constructor */
+       if (sem.constructor == null) {
+           sem.constructor = addConstructor(sem);
+       }
+       /* Insert array initializers into the constructor */
+       for (CharjAST init : sem.initializers) {
+           System.out.println("processing init token = " + init.getType());
+           if (init.getType() == CharjParser.IDENT) {
+               CharjAST ast1 = new CharjAST(CharjParser.EXPR, "EXPR");
+               CharjAST ast2 = new CharjAST(CharjParser.METHOD_CALL, "METHOD_CALL");
++              CharjAST ast2_1 = new CharjAST(CharjParser.DOT, ".");
+               CharjAST ast2_2 = new CharjAST(CharjParser.IDENT, init.getText());
+               CharjAST ast2_3 = new CharjAST(CharjParser.IDENT, "init");
+               CharjAST ast4 = new CharjAST(CharjParser.ARGUMENT_LIST, "ARGUMENT_LIST");
+               ast1.addChild(ast2);
+               ast2.addChild(ast2_1);
+               ast2_1.addChild(ast2_2);
+               ast2_1.addChild(ast2_3);
+               ast2.addChild(ast4);
+               ast4.addChildren(init.getChildren());
+               //System.out.println(sem.constructor.toStringTree());
+               sem.constructor.getChild(2).addChild(ast1);
+           } else if (init.getType() == CharjParser.NEW_EXPRESSION) {
+               //(OBJECT_VAR_DECLARATION (TYPE (QUALIFIED_TYPE_IDENT (Array (TEMPLATE_INST (TYPE double(Symbol(double_primitive, ClassSymbol[double]: {}, ))))))) (VAR_DECLARATOR_LIST (VAR_DECLARATOR ccc (NEW_EXPRESSION (ARGUMENT_LIST (EXPR get)) (DOMAIN_EXPRESSION (RANGE_EXPRESSION 1))))))
+           }
+           
+       }
+     }
      private String translationPass(OutputMode m) throws
          RecognitionException, IOException, InterruptedException
      {
 +        m_nodes.reset();
          CharjEmitter emitter = new CharjEmitter(m_nodes);
          StringTemplateGroup templates = getTemplates(templateFile);
          emitter.setTemplateLib(templates);
              String fullName = packageDir + "/" + typeName + ".cj";
                
              ClassLoader cl = Thread.currentThread().getContextClassLoader();
 -            boolean fileExists = (cl.getResource(fullName) == null);
 +            boolean fileExists = (cl.getResource(fullName) != null);
              if (!fileExists) {
                  if (debug()) System.out.println(
                          " \tloadType(" + typeName + "): not found");
              String output) throws
          IOException
      {
 -        int lastDot = filename.lastIndexOf(".");
 -        int lastSlash = filename.lastIndexOf(java.io.File.separator);
 -        String tempFile = filename.substring(0, lastSlash + 1) +
 -            ".charj" + java.io.File.separator;
 -        new File(tempFile).mkdir();
 -        tempFile += filename.substring(lastSlash + 1, filename.length());
 -        if (m_verbose) System.out.println(" [charjc] create: " + tempFile);
 -        FileWriter fw = new FileWriter(tempFile);
 +        if (m_verbose) System.out.println(" [charjc] create: " + filename);
 +        FileWriter fw = new FileWriter(filename);
          fw.write(output);
          fw.close();
          return;
      }
  
      /**
 -     * Enters the .charj directory and compiles the .cc and .ci files 
 -     * generated from the given filename. The given charmc string 
 -     * includes all options to be passed to charmc. Any generated .o 
 -     * file is moved back to the initial directory.
 +     * Compiles the .cc and .ci files generated from the given filename.
 +     * The given charmc string includes all options to be passed to charmc.
 +     * Any generated .o file is moved back to the initial directory.
       */
      private void compileTempFiles(
              String filename,
          if (baseDirectory.equals("")) {
              baseDirectory = "./";
          }
 -        String tempDirectory = baseDirectory + ".charj/";
          String moduleName = filename.substring(lastSlash + 1, lastDot);
 -        String baseTempFilename = tempDirectory + moduleName;
 +        String baseTempFilename = moduleName;
  
          // Compile interface file
          String cmd = charmc + " " + baseTempFilename + ".ci";
          File currentDir = new File(".");
          int retVal = exec(cmd, currentDir);
          if (retVal != 0) {
 -            error("Could not compile generated interface file");
 +            error("Could not compile generated interface file.");
              return;
          }
  
          // Move decl.h and def.h into temp directory.
          // charmxi/charmc doesn't offer control over where to generate these
 -        cmd = "mv " + moduleName + ".decl.h " + moduleName + ".def.h " +
 -            tempDirectory;
 +        cmd = "touch " + baseTempFilename + ".decl.h " +
 +            baseTempFilename + ".def.h";
          retVal = exec(cmd, currentDir);
 -         if (retVal != 0) {
 -            error("Could not move .decl.h and .def.h files " +
 -                    "into temp directory");
 +        if (retVal != 0) {
 +            error("Could not touch .decl.h and .def.h files.");
              return;
 -        }       
 +        }
  
          // Compile c++ output
          cmd = charmc + " -c " + baseTempFilename + ".cc" + 
              error("Could not compile generated C++ file");
              return;
          }
 -
 -        // move generated .o and .h file into .cj directory
 -        cmd = "mv -f " + baseTempFilename + ".o " + baseDirectory;
 -        exec(cmd, currentDir);
 -        cmd = "cp -f " + baseTempFilename + ".h " + baseDirectory;
 -        exec(cmd, currentDir);
      }
  
      /**
       * Print a representation of the Charj AST. If message is not null,
       * it is printed, along with an ASCII representation of the tree,
       * to stdout. If filename is not null, an html temp file containin
 -     * the representation is printed to .charj/filename.
 +     * the representation is printed to filename.
       */
      public void printAST(String message, String filename) throws IOException
      {