Merge branch 'charm' of charmgit:charm into charm
authorChao Mei <chaomei2@illinois.edu>
Wed, 26 May 2010 22:09:36 +0000 (17:09 -0500)
committerChao Mei <chaomei2@illinois.edu>
Wed, 26 May 2010 22:09:36 +0000 (17:09 -0500)
17 files changed:
src/ck-core/ck.C
src/ck-core/debug-charm.C
src/ck-core/debug-charm.h
src/langs/charj/build.xml
src/langs/charj/src/charj/translator/Charj.g
src/langs/charj/src/charj/translator/Charj.stg
src/langs/charj/src/charj/translator/CharjAST.java
src/langs/charj/src/charj/translator/CharjASTModifier.g [new file with mode: 0644]
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/PupRoutineCreator.java [new file with mode: 0644]
src/langs/charj/src/charj/translator/SymbolTable.java
src/langs/charj/src/charj/translator/SymbolWithScope.java
src/langs/charj/src/charj/translator/Translator.java
src/scripts/configure
src/scripts/configure.in

index 3682b5073b2f2af4d4642156b76428230bb15cbb..4a23f7fa574b3419d0605c9457937a3527c59894 100644 (file)
@@ -1317,7 +1317,8 @@ void _skipCldEnqueue(int pe,envelope *env, int infoFn)
        env, env->getQueueing(),env->getPriobits(),
        (unsigned int *)env->getPrioPtr());
   } else {
-    CkPackMessage(&env);
+    if (pe < 0 || CmiNodeOf(pe) != CmiMyNode())
+      CkPackMessage(&env);
     int len=env->getTotalsize();
     CmiSetXHandler(env,CmiGetHandler(env));
 #if CMK_OBJECT_QUEUE_AVAILABLE
index 7302f1bd7813fe6374ab66e4913feaeda081b294..5daa3ff9034d0c37ea100fbefb53ad1530954f72 100644 (file)
 //#include "queueing.h"
 #include <unistd.h>
 
+#if CMK_BLUEGENE_CHARM
+#include "blue_impl.h"
+#endif
+
 
 #if CMK_CHARMDEBUG && CMK_CCS_AVAILABLE && !defined(_WIN32)
 
@@ -510,6 +514,28 @@ class CpdList_message : public CpdListAccessor {
   }
 };
 
+void CpdDeliverMessage(char * msg) {
+  int msgNum;
+  void *m;
+  sscanf(msg+CmiMsgHeaderSizeBytes, "%d", &msgNum);
+  //CmiPrintf("received deliver request %d\n",msgNum);
+
+  void *debugQ=CkpvAccess(debugQueue);
+  CdsFifo_Enqueue(debugQ, (void*)(-1)); // Enqueue a guard
+  for (int i=0; i<msgNum; ++i) CdsFifo_Enqueue(debugQ, CdsFifo_Dequeue(debugQ));
+  CkpvAccess(skipBreakpoint) = 1;
+  char *queuedMsg = (char *)CdsFifo_Dequeue(debugQ);
+#if CMK_BLUEGENE_CHARM
+  stopVTimer();
+  BgProcessMessageDefault(cta(threadinfo), queuedMsg);
+  startVTimer();
+#else
+  CmiHandleMessage(queuedMsg);
+#endif
+  CkpvAccess(skipBreakpoint) = 0;
+  while ((m=CdsFifo_Dequeue(debugQ)) != (void*)(-1)) CdsFifo_Enqueue(debugQ, m);  
+}
+
 class CpdList_msgStack : public CpdListAccessor {
   virtual const char * getPath(void) const {return "charm/messageStack";}
   virtual size_t getLength(void) const {
@@ -562,10 +588,6 @@ void CpdBreakPointInit()
   CpvAccess(breakPointEntryTable) = new CpdBpFuncTable_t(10,0.5,CkHashFunction_int,CkHashCompare_int );
 }
 
-#if CMK_BLUEGENE_CHARM
-#include "blue_impl.h"
-#endif
-
 static void _call_freeze_on_break_point(void * msg, void * object)
 {
       //Save breakpoint entry point index. This is retrieved from msg.
@@ -832,6 +854,7 @@ void CpdCharmInit()
   CcsRegisterHandler("ccs_debug_startgdb",(CmiHandler)CpdStartGdb);
   CpdListRegister(new CpdListAccessor_c("hostinfo",hostInfoLength,0,hostInfo,0));
   CpdListRegister(new CpdList_localQ());
+  CcsRegisterHandler("deliverMessage",(CmiHandler)CpdDeliverMessage);
   CpdListRegister(new CpdList_arrayElementNames());
   CpdListRegister(new CpdList_arrayElements());
   CpdListRegister(new CpdList_objectNames());
index ee6f7b7db0085ea6d1424dfe68b9f7e3e235e04b..e2b2a29bde8e7ca5352694c1307835d5afbd78a2 100644 (file)
@@ -15,7 +15,7 @@
 #include "cklists.h"
 
 #define CHARMDEBUG_MAJOR   10
-#define CHARMDEBUG_MINOR    0
+#define CHARMDEBUG_MINOR    1
 
 void *CpdGetCurrentObject();
 void *CpdGetCurrentMsg();
index 09ab4a6480980e364462db65deb1acb8365a0549..18d9d4d427f77b0177015653feff834524bd9a04 100644 (file)
             grammar.path="${buildsrc}/charj/translator"/>
     </target>
 
+    <target name="CharjASTModifier" depends="Charj">
+        <antlr3 grammar.name="CharjASTModifier.g"
+            grammar.path="${buildsrc}/charj/translator"/>
+    </target>
+
     <target name="CharjSemantics" depends="Charj">
         <antlr3 grammar.name="CharjSemantics.g"
             grammar.path="${buildsrc}/charj/translator"/>
     </target>
 
-    <target name="CharjEmitter" depends="CharjSemantics">
+    <target name="CharjEmitter" depends="CharjSemantics,CharjASTModifier">
         <antlr3 grammar.name="CharjEmitter.g"
             grammar.path="${buildsrc}/charj/translator"/>
     </target>
index 3547067638df15180879f44fa3b2d8cc196731c4..5dfc8f4d294dc4fb68613ea2ea970385b6724dc3 100644 (file)
@@ -16,7 +16,86 @@ 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'            ;
+
+    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'           ;
+
+    NEW                     = 'new'             ;
+    BITWISE_OR              = '|'               ;
+    BITWISE_AND             = '&'               ;
+    EQUALS                  = '='               ;
+    NOT_EQUALS              = '!='              ;
+    PLUS_EQUALS             = '+='              ;
+    MINUS_EQUALS            = '-='              ;
+    TIMES_EQUALS            = '*='              ;
+    DIVIDE_EQUALS           = '/='              ;
+    AND_EQUALS              = '&='              ;
+    OR_EQUALS               = '|='              ;
+    POWER_EQUALS            = '^='              ;
+    MOD_EQUALS              = '%='              ;
+    OR                      = '||'              ;
+    AND                     = '&&'              ;
+    POWER                   = '^'               ;
+    GT                      = '>'               ;
+    LT                      = '<'               ;
+    PLUS                    = '+'               ;
+    MINUS                   = '-'               ;
+    TIMES                   = '*'               ;
+    DIVIDE                  = '/'               ;
+    MOD                     = '%'               ;
+    UNARY_PLUS              = '++'              ;
+    UNARY_MINUS             = '--'              ;
+    NOT                     = '!'               ;
+    TILDA                   = '~'               ;
+    INSTANCEOF              = 'instanceof'      ;
+
 
     // C++ keywords that aren't used in charj. 
     // We don't use these ourselves, but they're still reserved
@@ -94,8 +173,10 @@ tokens {
     SUPER_CONSTRUCTOR_CALL;
     THIS_CONSTRUCTOR_CALL;
     TYPE;
-    UNARY_MINUS;
-    UNARY_PLUS;
+    SIMPLE_TYPE;
+    OBJECT_TYPE;
+    REFERENCE_TYPE;
+    POINTER_TYPE;
     PRIMITIVE_VAR_DECLARATION;
     OBJECT_VAR_DECLARATION;
     VAR_DECLARATOR;
@@ -129,12 +210,12 @@ compilationUnit
     ;
 
 packageDeclaration
-    :   'package' IDENT ('.' IDENT)+ ';'  
-        ->  ^('package' IDENT+)
+    :   PACKAGE IDENT ('.' IDENT)+ ';'  
+        ->  ^(PACKAGE IDENT+)
     ;
 
 importDeclaration
-    :   'import'^ qualifiedIdentifier '.*'? ';'!
+    :   IMPORT^ qualifiedIdentifier '.*'? ';'!
     ;
 
 typeDeclaration
@@ -145,38 +226,39 @@ typeDeclaration
     ;
 
 classDefinition
-    :   'public'? 'class' IDENT ('extends' type)? ('implements' typeList)? '{'
+    :   PUBLIC? CLASS IDENT (EXTENDS type)? ('implements' typeList)? '{'
             classScopeDeclaration*
         '}' ';'?
-        -> ^(TYPE 'class' IDENT ^('extends' type)? ^('implements' typeList)? classScopeDeclaration*)
+        -> ^(TYPE CLASS IDENT ^(EXTENDS type)? ^('implements' typeList)? classScopeDeclaration*)
     ;
 
 chareType
-    :   'chare'
-    |   'group'
-    |   'nodegroup'
-    |   'chare_array' '[' ARRAY_DIMENSION ']' -> ^('chare_array' ARRAY_DIMENSION)
+    :   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*
         '}' ';'?
-        -> ^(TYPE chareType 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
@@ -287,7 +369,7 @@ genericTypeParameter
     ;
 
 bound
-    :   e='extends' type ('&' type)*
+    :   e=EXTENDS type ('&' type)*
         ->  ^(EXTENDS_BOUND_LIST[$e, "EXTENDS_BOUND_LIST"] type+)
     ;
 
@@ -297,12 +379,12 @@ modifierList
     ;
 
 modifier
-    :   'public'
-    |   'protected'
-    |   'entry'
-    |   'private'
-    |   'abstract'
-    |   'native'
+    :   PUBLIC
+    |   PROTECTED
+    |   ENTRY
+    |   PRIVATE
+    |   ABSTRACT
+    |   NATIVE
     |   localModifier
     ;
 
@@ -312,25 +394,25 @@ localModifierList
     ;
 
 localModifier
-    :   'final'
-    |   'static'
-    |   'volatile'
+    :   FINAL
+    |   STATIC
+    |   VOLATILE
     ;
 
 type
     :   simpleType
     |   objectType
-    |   'void'
+    |   VOID
     ;
 
 simpleType
     :   primitiveType arrayDeclaratorList?
-        ->  ^(TYPE primitiveType arrayDeclaratorList?)  
+        ->  ^(SIMPLE_TYPE primitiveType arrayDeclaratorList?)  
     ;
 
 objectType
     :   qualifiedTypeIdent arrayDeclaratorList?
-        ->  ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
+        ->  ^(POINTER_TYPE qualifiedTypeIdent arrayDeclaratorList?)
     ;
 
 qualifiedTypeIdent
@@ -343,14 +425,14 @@ typeIdent
     ;
 
 primitiveType
-    :   'boolean'
-    |   'char'
-    |   'byte'
-    |   'short'
-    |   'int'
-    |   'long'
-    |   'float'
-    |   'double'
+    :   BOOLEAN
+    |   CHAR
+    |   BYTE
+    |   SHORT
+    |   INT
+    |   LONG
+    |   FLOAT
+    |   DOUBLE
     ;
 
 genericTypeArgumentList
@@ -403,6 +485,8 @@ qualifiedIdentifier
 block
     :   lc='{' blockStatement* '}'
         ->  ^(BLOCK[$lc, "BLOCK"] blockStatement*)
+    |   nonBlockStatement
+        -> ^(BLOCK nonBlockStatement)
     ;
 
 blockStatement
@@ -416,43 +500,49 @@ localVariableDeclaration
     |   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? FOR_EXPR expression? FOR_UPDATE 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 ';'!
@@ -461,8 +551,8 @@ statement
         
 
 switchCaseLabel
-    :   'case'^ expression ':'! blockStatement*
-    |   'default'^ ':'! blockStatement*
+    :   CASE^ expression ':'! blockStatement*
+    |   DEFAULT^ ':'! blockStatement*
     ;
     
 forInit
@@ -620,8 +710,8 @@ postfixedExpression
                 (   arguments
                     ->  ^(METHOD_CALL $postfixedExpression genericTypeArgumentList? arguments)
                 )?
-            |   'this'
-                ->  ^($outerDot $postfixedExpression 'this')
+            |   THIS
+                ->  ^($outerDot $postfixedExpression THIS)
             |   s='super' arguments
                 ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] $postfixedExpression arguments)
             |   (   'super' innerDot='.' IDENT
@@ -654,11 +744,11 @@ primaryExpression
             )
         |   IDENT arguments
             ->  ^(METHOD_CALL IDENT genericTypeArgumentList arguments)
-        |   t='this' arguments
+        |   t=THIS arguments
             ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] genericTypeArgumentList arguments)
         )
-    |   (   'this'
-            ->  'this'
+    |   (   THIS
+            ->  THIS
         )
         (   arguments
             ->  ^(THIS_CONSTRUCTOR_CALL[$t, "THIS_CONSTRUCTOR_CALL"] arguments)
@@ -692,8 +782,8 @@ qualifiedIdentExpression
                 |   IDENT arguments
                     ->  ^(METHOD_CALL ^($outerDot qualifiedIdentifier IDENT) genericTypeArgumentList arguments)
                 )
-            |   'this'
-                ->  ^($outerDot qualifiedIdentifier 'this')
+            |   THIS
+                ->  ^($outerDot qualifiedIdentifier THIS)
             |   s='super' arguments
                 ->  ^(SUPER_CONSTRUCTOR_CALL[$s, "SUPER_CONSTRUCTOR_CALL"] qualifiedIdentifier arguments)
             )
@@ -701,12 +791,14 @@ qualifiedIdentExpression
     ;
 
 newExpression
-    :   n='new'
+    :   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)
+        |   qualifiedTypeIdent arguments
+            -> ^(NEW qualifiedTypeIdent arguments)
         )
     ;
     
@@ -727,9 +819,9 @@ literal
     |   FLOATING_POINT_LITERAL
     |   CHARACTER_LITERAL
     |   STRING_LITERAL
-    |   'true'
-    |   'false'
-    |   'null'
+    |   TRUE
+    |   FALSE
+    |   NULL
     ;
 
 // LEXER
index 915c79a2897e37d26a3a1e71eb6e2f80e5a0c89f..a810e3db533413966230ba970d40c6d0c1f6ad58 100644 (file)
@@ -1,30 +1,19 @@
 group Charj;
 
-charjSource_ci(pd, ids, tds, debug) ::= 
-//<pd>
-//<ids>
-<<
-<if(debug)>/* \<charjSource_ci> */<endif>
-/*
- * packageDeclaration disabled...
- * end packageDeclaration
- */
-
-/*
- * importDeclarations disabled...
-<ids>
- * end importDeclarations
- */
+charjSource_ci(basename, pd, ids, tds, debug) ::=
+<<
 
+// interface for <basename>
 <tds>
-<if(debug)>/* \</charjSource_ci> */<endif>
 
 >>
 
 
-charjSource_h(pd, ids, tds, debug) ::=
+charjSource_h(basename, pd, ids, tds, debug) ::=
 <<
-<if(debug)>/* \<CHARJ_SOURCE> */<endif>
+#ifndef __<basename>__
+#define __<basename>__
+
 /**************************************************************************
  * WARNING                                                                *
  **************************************************************************
@@ -35,25 +24,24 @@ charjSource_h(pd, ids, tds, debug) ::=
 <ids>
 <tds>
 
-<if(debug)>/* \</CHARJ_SOURCE> */<endif>
+#endif // __<basename>__
 
 >>
 
 
-charjSource_cc(pd, ids, tds, debug) ::=
+charjSource_cc(basename, pd, ids, tds, debug) ::=
 <<
-<if(debug)>/* \<CHARJ_SOURCE> */<endif>
+#include "<basename>.h"
+
 <ids>
 <tds>
-<if(debug)>/* \</CHARJ_SOURCE> */<endif>
+
 >>
 
 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>"
@@ -70,6 +58,8 @@ interfaceExtends(ts) ::=
 classDeclaration_h(sym, ident, ext, csds) ::=
 <<
 <sym.IncludeString>
+<sym.MemberTypeNames:{name| class <name>;
+}>
 <classDeclaration_h_cont(pds = sym.packageNames, sym = sym, ident = ident, ext = ext, csds = csds)>
 >>
 
@@ -78,7 +68,7 @@ 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> {
@@ -86,7 +76,7 @@ class <ident> : public <ext> {
 class <ident> {
 <endif>
 
-    <csds; separator="\n">
+    <csds; separator="\n\n">
 };
 <endif>
 >>
@@ -103,16 +93,9 @@ classDeclaration_cc_cont(pds, sym, ident, ext, csds) ::=
 <if(first(pds))>namespace <first(pds)>
 {
     <classDeclaration_cc_cont(pds = rest(pds), sym = sym, ident = ident, ext = ext, csds = csds)>
-}
-<else>
-<if(ext)>
-class <ident>: public <ext> {
+} // namespace <first(pds)>
 <else>
-class <ident> {
-<endif>
-
-    <csds; separator="\n">
-};
+<csds; separator="\n\n">
 <endif>
 >>
 
@@ -129,11 +112,9 @@ 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)>
-}
-<else><if(ext)>/* superclass: <ext> */<endif>
-class <ident>: public CBase_<ident> {
-    <csds; separator="\n">
-};
+} // namespace <first(pds)>
+<else>
+<csds; separator="\n\n">
 <endif>
 >>
 
@@ -148,7 +129,7 @@ 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> {
@@ -159,13 +140,11 @@ class <ident>: public CBase_<ident> {
 
 chareDeclaration_ci(sym, chareType, arrayDim, ident, ext, csds) ::=
 <<
-<if(debug)>/* \<typeDeclaration> */<endif>
 module <ident> {
 <if(ext)>
     extern module <ext>;
 <endif>
     <chareDeclaration_ci_cont(pds = sym.packageNames, chareType = chareType, arrayDim = arrayDim, ident = ident, ext = ext, csds = csds)>
-<if(debug)>/* \</typeDeclaration> */<endif>
 }
 >>
 
@@ -175,7 +154,7 @@ chareDeclaration_ci_cont(pds, sym, chareType, arrayDim, ident, ext, csds) ::=
 <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">
@@ -191,15 +170,14 @@ funcMethodDecl_h(modl, gtpl, ty, id, fpl, adl, block) ::=
 
 funcMethodDecl_ci(modl, gtpl, ty, id, fpl, adl, block) ::=
 <<
-entry <ty><gtpl> <id><fpl> <adl>;
+entry <ty><gtpl> <id><fpl><adl>;
 >>
 
 
-funcMethodDecl_cc(modl, gtpl, ty, id, fpl, adl, block) ::=
+funcMethodDecl_cc(sym, modl, gtpl, ty, id, fpl, adl, block) ::=
 <<
-<if(first(modl))><modl; separator = " ">: <endif><ty><gtpl> <id><fpl><adl> {
-    <block>
-}
+<ty><gtpl> <sym.Name>::<id><fpl><adl>
+<block>
 >>
 
 
@@ -217,15 +195,16 @@ ctorDecl_h(modl, gtpl, id, fpl, block) ::=
 
 ctorDecl_cc(modl, gtpl, id, fpl, block) ::=
 <<
-<if(modl)><modl>:<endif><gtpl> <id><fpl> {
-    <block>
-}
+<gtpl> <id>::<id><fpl>
+<block>
 >>
 
 
 block_cc(bsl) ::=
 <<
-<bsl:{s| <s><\n>}>
+{
+    <bsl; separator="\n">
+}
 >>
 
 
@@ -289,12 +268,28 @@ local_var_decl(modList, type, declList) ::=
 >>
 
 
-type(typeID, arrDeclList) ::=
+simple_type(typeID, arrDeclList) ::=
 <<
 <typeID><arrDeclList>
 >>
 
 
+obj_type(typeID, arrDeclList) ::=
+<<
+<typeID><arrDeclList>
+>>
+
+pointer_type(typeID, arrDeclList) ::=
+<<
+<typeID>*<arrDeclList>
+>>
+
+reference_type(typeID, arrDeclList) ::=
+<<
+<typeID>&<arrDeclList>
+>>
+
+
 typeIdent(typeID, generics) ::=
 <<
 <typeID><generics>
@@ -335,33 +330,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 (<if(initializer)><initializer><else>;<endif> <cond>; <update; separator=", ">) {
-    <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>;
 >>
 
 
index 53ef518b7c5b241fe909e6f581a5963c5518e406..c4ae2443ffee398094efa6a34398210324bdf8b4 100644 (file)
@@ -1,8 +1,10 @@
 package charj.translator;
 
 import org.antlr.runtime.tree.CommonTree;
+import org.antlr.runtime.tree.Tree;
 import org.antlr.runtime.Token;
 import org.antlr.runtime.CommonToken;
+import java.util.*;
 
 /**
  * Custom subclass of Antlr's tree node. Doesn't do anything special yet,
@@ -22,6 +24,30 @@ public class CharjAST extends CommonTree
         super(new CommonToken(type, text));
     }
 
+    public CharjAST getParent()
+    {
+        return (CharjAST) super.getParent();
+    }
+
+    public List<CharjAST> getChildren()
+    {
+        return (List<CharjAST>) super.getChildren();
+    }
+
+    public CharjAST getChild(int index)
+    {
+        try
+        {
+            return (CharjAST) super.getChild(index);
+        }
+        catch(ClassCastException e)
+        {
+            Tree child = super.getChild(index);
+            System.out.println("possible error node: " + child);
+            return new CharjAST(child.getType(), child.getText());
+        }
+    }
+
     public String toString() {
         String s = super.toString();
         if (symbol != null) {
@@ -30,4 +56,9 @@ public class CharjAST extends CommonTree
         return s;
     }
 
+    public CharjAST dupNode()
+    {
+        return new CharjAST(getType(), getText());
+    }
+
 }
diff --git a/src/langs/charj/src/charj/translator/CharjASTModifier.g b/src/langs/charj/src/charj/translator/CharjASTModifier.g
new file mode 100644 (file)
index 0000000..a878444
--- /dev/null
@@ -0,0 +1,399 @@
+/**
+ * The semantic phase walks the tree and builds the symbol table, handles
+ * all the imports, and does the semantic checks. The resulting tree and
+ * symbol table are used by the emitter to generate the output. 
+ */
+
+tree grammar CharjASTModifier;
+
+options {
+    backtrack = true; 
+    memoize = true;
+    tokenVocab = Charj;
+    ASTLabelType = CharjAST;
+    output = AST;
+}
+
+@header {
+package charj.translator;
+}
+
+@members {
+    SymbolTable symtab = null;
+    PackageScope currentPackage = null;
+    ClassSymbol currentClass = null;
+    MethodSymbol currentMethod = null;
+    LocalScope currentLocalScope = null;
+    Translator translator;
+
+    PupRoutineCreator puper = new PupRoutineCreator();
+}
+
+// Replace default ANTLR generated catch clauses with this action, allowing early failure.
+@rulecatch {
+    catch (RecognitionException re) {
+        reportError(re);
+        throw re;
+    }
+}
+
+
+// Starting point for parsing a Charj file.
+charjSource[SymbolTable _symtab] returns [ClassSymbol cs]
+@init {
+    symtab = _symtab;
+}
+    // 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; }
+    ;
+
+packageDeclaration
+    :   ^(PACKAGE (ids+=IDENT)+)  
+    ;
+    
+importDeclarations returns [List<CharjAST> packageNames]
+    :   (^(IMPORT qualifiedIdentifier '.*'?))*
+    ;
+
+typeDeclaration[List<CharjAST> imports] returns [ClassSymbol sym]
+    :   ^(TYPE (CLASS | chareType) IDENT (^('extends' parent=type))? (^('implements' type+))? classScopeDeclaration*)
+        {
+            $TYPE.tree.addChild(puper.getPupRoutineNode());
+        }
+    |   ^(INTERFACE IDENT (^('extends' type+))?  interfaceScopeDeclaration*)
+    |   ^(ENUM IDENT (^('implements' type+))? enumConstant+ classScopeDeclaration*)
+    ;
+
+chareType
+    :   CHARE
+    |   GROUP
+    |   NODEGROUP
+    |   ^(CHARE_ARRAY ARRAY_DIMENSION)
+    ;
+
+enumConstant
+    :   ^(IDENT arguments?)
+    ;
+    
+classScopeDeclaration
+    :   ^(FUNCTION_METHOD_DECL m=modifierList? g=genericTypeParameterList? 
+            ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
+            b=block?)
+    |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
+    |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
+    |   ^(CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList 
+            b=block)
+    ;
+    
+interfaceScopeDeclaration
+    :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
+            type IDENT formalParameterList arrayDeclaratorList?)
+        // 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)
+    ;
+
+variableDeclaratorList
+    :   ^(VAR_DECLARATOR_LIST variableDeclarator+)
+    ;
+
+variableDeclarator
+    :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
+    ;
+    
+variableDeclaratorId
+    :   ^(IDENT arrayDeclaratorList?)
+        {
+            puper.varPup($IDENT);
+        }
+    ;
+
+variableInitializer
+    :   arrayInitializer
+    |   expression
+    ;
+
+arrayDeclaratorList
+    :   ^(ARRAY_DECLARATOR_LIST ARRAY_DECLARATOR*)  
+    ;
+    
+arrayInitializer
+    :   ^(ARRAY_INITIALIZER variableInitializer*)
+    ;
+
+genericTypeParameterList
+    :   ^(GENERIC_TYPE_PARAM_LIST genericTypeParameter+)
+    ;
+
+genericTypeParameter
+    :   ^(IDENT bound?)
+    ;
+        
+bound
+    :   ^(EXTENDS_BOUND_LIST type+)
+    ;
+
+modifierList
+    :   ^(MODIFIER_LIST modifier+)
+    ;
+
+modifier
+    :   PUBLIC
+    |   PROTECTED
+    |   PRIVATE
+    |   ENTRY
+    |   ABSTRACT
+    |   NATIVE
+    |   localModifier
+    ;
+
+localModifierList
+    :   ^(LOCAL_MODIFIER_LIST localModifier+)
+    ;
+
+localModifier
+    :   FINAL
+    |   STATIC
+    |   VOLATILE
+    ;
+
+type
+    :   simpleType
+    |   objectType 
+    |   VOID
+    ;
+
+simpleType
+    :   ^(SIMPLE_TYPE primitiveType arrayDeclaratorList?)
+    ;
+    
+objectType
+    :   ^(OBJECT_TYPE qualifiedTypeIdent arrayDeclaratorList?)
+    |   ^(REFERENCE_TYPE qualifiedTypeIdent arrayDeclaratorList?)
+    |   ^(POINTER_TYPE qualifiedTypeIdent arrayDeclaratorList?)
+    ;
+
+qualifiedTypeIdent
+    :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
+    ;
+
+typeIdent
+    :   ^(IDENT genericTypeArgumentList?)
+    ;
+
+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")); }
+    ;
+
+genericTypeArgumentList
+    :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
+    ;
+    
+genericTypeArgument
+    :   type
+    |   '?'
+    ;
+
+formalParameterList
+    :   ^(FORMAL_PARAM_LIST formalParameterStandardDecl* formalParameterVarargDecl?) 
+    ;
+    
+formalParameterStandardDecl
+    :   ^(FORMAL_PARAM_STD_DECL localModifierList? type variableDeclaratorId)
+    ;
+    
+formalParameterVarargDecl
+    :   ^(FORMAL_PARAM_VARARG_DECL localModifierList? type variableDeclaratorId)
+    ;
+    
+// FIXME: is this rule right? Verify that this is ok, I expected something like:
+// IDENT (^('.' qualifiedIdentifier IDENT))*
+qualifiedIdentifier
+    :   IDENT
+    |   ^('.' qualifiedIdentifier IDENT)
+    ;
+    
+block
+    :   ^(BLOCK (blockStatement)*)
+    ;
+    
+blockStatement
+    :   localVariableDeclaration
+    |   statement
+    ;
+    
+localVariableDeclaration
+    :   ^(PRIMITIVE_VAR_DECLARATION localModifierList? simpleType variableDeclaratorList)
+    |   ^(OBJECT_VAR_DECLARATION localModifierList? objectType variableDeclaratorList)
+    ;
+
+statement
+    :   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?) {
+            if ($IDENT != null) {
+                translator.error(this, "Labeled continue not supported yet, ignoring.", $IDENT);
+            }
+        }
+    |   ^(LABELED_STATEMENT IDENT statement)
+    |   expression
+    |   ^('delete' qualifiedIdentifier)
+    |   ^(EMBED STRING_LITERAL EMBED_BLOCK)
+    |   ';' // Empty statement.
+    ;
+        
+switchCaseLabel
+    :   ^(CASE expression blockStatement*)
+    |   ^(DEFAULT blockStatement*)
+    ;
+    
+forInit
+    :   localVariableDeclaration 
+    |   expression+
+    ;
+    
+// EXPRESSIONS
+
+parenthesizedExpression
+    :   ^(PAREN_EXPR expression)
+    ;
+    
+expression
+    :   ^(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)
+    |   ^(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)
+    |   ^(GT 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)
+    |   ^(TILDA expr)
+    |   ^(NOT expr)
+    |   ^(CAST_EXPR type expr)
+    |   primaryExpression
+    ;
+    
+primaryExpression
+    :   ^(  '.' primaryExpression
+                (   IDENT
+                |   THIS
+                |   SUPER
+                )
+        )
+    |   parenthesizedExpression
+    |   IDENT
+    |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
+    |   explicitConstructorCall
+    |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
+    |   literal
+    |   newExpression
+    |   THIS
+    |   arrayTypeDeclarator
+    |   SUPER
+    ;
+    
+explicitConstructorCall
+    :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
+    |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
+    ;
+
+arrayTypeDeclarator
+    :   ^(ARRAY_DECLARATOR (arrayTypeDeclarator | qualifiedIdentifier | primitiveType))
+    ;
+
+newExpression
+    :   ^(  STATIC_ARRAY_CREATOR
+            (   primitiveType newArrayConstruction
+            |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
+            )
+        )
+    |   ^(NEW qualifiedTypeIdent arguments)
+    ;
+
+newArrayConstruction
+    :   arrayDeclaratorList arrayInitializer
+    |   expression+ arrayDeclaratorList?
+    ;
+
+arguments
+    :   ^(ARGUMENT_LIST expression*)
+    ;
+
+literal 
+    :   HEX_LITERAL
+    |   OCTAL_LITERAL
+    |   DECIMAL_LITERAL
+    |   FLOATING_POINT_LITERAL
+    |   CHARACTER_LITERAL
+    |   STRING_LITERAL          
+    |   TRUE
+    |   FALSE
+    |   NULL
+    ;
+
index 55407b8e35a31b588b38febbad35a03ce5638371..81353f56b630147d7ab9280d2e9bbdb0994e839a 100644 (file)
@@ -33,6 +33,7 @@ package charj.translator;
     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.
@@ -85,9 +86,9 @@ charjSource[SymbolTable symtab, OutputMode m]
     :   ^(CHARJ_SOURCE (p=packageDeclaration)? 
         (i+=importDeclaration)* 
         (t=typeDeclaration))
-        -> {emitCC()}? charjSource_cc(pd={$p.names}, ids={$i}, tds={$t.st}, debug={debug()})
-        -> {emitCI()}? charjSource_ci(pd={$p.names}, ids={$i}, tds={$t.st}, debug={debug()})
-        -> {emitH()}? charjSource_h(pd={$p.names}, ids={$i}, tds={$t.st}, debug={debug()})
+        -> {emitCC()}? charjSource_cc(basename={basename()}, pd={$p.names}, ids={$i}, tds={$t.st}, debug={debug()})
+        -> {emitCI()}? charjSource_ci(basename={basename()}, pd={$p.names}, ids={$i}, tds={$t.st}, debug={debug()})
+        -> {emitH()}? charjSource_h(basename={basename()}, pd={$p.names}, ids={$i}, tds={$t.st}, debug={debug()})
         ->
     ;
 
@@ -118,10 +119,11 @@ importDeclaration
     ;
     
 typeDeclaration
-    :   ^(TYPE 'class' 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(
                 sym={currentClass},
                 ident={$IDENT.text}, 
@@ -133,14 +135,15 @@ typeDeclaration
                 ext={$su.st}, 
                 csds={$csds})
         ->
-    |   ^('interface' IDENT (^('extends' type+))? interfaceScopeDeclaration*)
+    |   ^(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>"
-    |   ^(TYPE chareType IDENT (^('extends' type))? (^('implements' type+))? (csds+=classScopeDeclaration)*)
+    |   ^(TYPE chareType IDENT (^('extends' type))? (^('implements' type+))?
         {
             currentClass = (ClassSymbol)$IDENT.symbol;
         }
+        (csds+=classScopeDeclaration)*)
         -> {emitCC()}? chareDeclaration_cc(
                 sym={currentClass},
                 ident={$IDENT.text}, 
@@ -165,10 +168,11 @@ chareType
 @init {
 $st = %{$start.getText()};
 }
-    :   'chare'
-    |   'group'
-    |   'nodegroup'
-    |   ^('chare_array' ARRAY_DIMENSION)
+    :   CHARE
+    |   GROUP
+    |   NODEGROUP
+    |   MAINCHARE
+    |   ^(CHARE_ARRAY ARRAY_DIMENSION)
         -> template(t={$ARRAY_DIMENSION.text}) "array [<t>]"
     ;
 
@@ -196,9 +200,10 @@ classScopeDeclaration
             }
         }
         -> {emitCC()}? funcMethodDecl_cc(
+                sym={currentClass},
                 modl={modList}, 
                 gtpl={$g.st}, 
-                ty={$ty.text},
+                ty={$ty.st},
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 adl={$a.st},
@@ -206,7 +211,7 @@ classScopeDeclaration
         -> {emitH()}? funcMethodDecl_h(
                 modl={modList}, 
                 gtpl={$g.st}, 
-                ty={$ty.text},
+                ty={$ty.st},
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 adl={$a.st},
@@ -214,20 +219,20 @@ classScopeDeclaration
         -> {(emitCI() && entry)}? funcMethodDecl_ci(
                 modl={$m.st}, 
                 gtpl={$g.st}, 
-                ty={$ty.text},
+                ty={$ty.st},
                 id={$IDENT.text}, 
                 fpl={$f.st}, 
                 adl={$a.st},
                 block={$b.st})
         ->
     |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
-        -> {emitCC() || emitH()}? class_var_decl(
+        -> {emitH()}? class_var_decl(
             modl={$modifierList.st},
             type={$simpleType.st},
             declList={$variableDeclaratorList.st})
         ->
     |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
-        -> {emitCC() || emitH()}? class_var_decl(
+        -> {emitH()}? class_var_decl(
             modl={$modifierList.st},
             type={$objectType.st},
             declList={$variableDeclaratorList.st})
@@ -335,12 +340,12 @@ modifier
 @init {
 $st = %{$start.getText()};
 }
-    :   'public'
-    |   'protected'
-    |   'private'
-    |   'entry'
-    |   'abstract'
-    |   'native'
+    :   PUBLIC
+    |   PROTECTED
+    |   PRIVATE
+    |   ENTRY
+    |   ABSTRACT
+    |   NATIVE
     |   localModifier
         -> {$localModifier.st}
     ;
@@ -354,9 +359,9 @@ localModifier
 @init {
 $st = %{$start.getText()};
 }
-    :   'final'
-    |   'static'
-    |   'volatile'
+    :   FINAL
+    |   STATIC
+    |   VOLATILE
     ;
 
     
@@ -365,22 +370,29 @@ type
         -> {$simpleType.st}
     |   objectType 
         -> {$objectType.st}
-    |   'void'
+    |   VOID
+        {
+            $st = %{$start.getText()};
+        }
     ;
 
 simpleType
-    :   ^(TYPE primitiveType arrayDeclaratorList?)
-        -> type(typeID={$primitiveType.st}, arrDeclList={$arrayDeclaratorList.st})
+    :   ^(SIMPLE_TYPE primitiveType arrayDeclaratorList?)
+        -> simple_type(typeID={$primitiveType.st}, arrDeclList={$arrayDeclaratorList.st})
     ;
 
 objectType
-    :   ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
-        -> type(typeID={$qualifiedTypeIdent.st}, arrDeclList={$arrayDeclaratorList.st})
+    :   ^(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})
     ;
 
 qualifiedTypeIdent
     :   ^(QUALIFIED_TYPE_IDENT (t+=typeIdent)+) 
-        -> template(types={$t}) "<types; separator=\".\">"
+        -> template(types={$t}) "<types; separator=\"::\">"
     ;
 
 typeIdent
@@ -392,16 +404,16 @@ 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
     ;
 
 genericTypeArgumentList
@@ -470,34 +482,41 @@ localVariableDeclaration
 
 
 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? FOR_EXPR cond=expression? FOR_UPDATE (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.
@@ -505,9 +524,9 @@ statement
     ;
         
 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>"
     ;
     
@@ -561,7 +580,7 @@ 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)
+    |   ^(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>"
@@ -609,23 +628,23 @@ expr
         -> template(e1={$e1.st}) "<e1>++"
     |   ^(POST_DEC e1=expr)
         -> template(e1={$e1.st}) "<e1>--"
-    |   ^('~' e1=expr)
+    |   ^(TILDA 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"
+    :   ^('.' 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
@@ -640,11 +659,11 @@ primaryExpression
         -> {$literal.st}
     |   newExpression
         -> {$newExpression.st}
-    |   'this'
+    |   THIS
         -> {%{$start.getText()}}
     |   arrayTypeDeclarator
         -> {$arrayTypeDeclarator.st}
-    |   'super'
+    |   SUPER
         -> {%{$start.getText()}}
     ;
     
@@ -667,6 +686,8 @@ newExpression
             )
         )
         -> template(t={$text}) "<t>"
+    |   ^(NEW qualifiedTypeIdent arguments)
+        -> template(q={$qualifiedTypeIdent.st}, a={$arguments.st}) "new <q>(<a>)"
     ;
 
 newArrayConstruction
@@ -693,8 +714,8 @@ $st = %{$start.getText()};
     |   FLOATING_POINT_LITERAL
     |   CHARACTER_LITERAL
     |   STRING_LITERAL
-    |   'true'
-    |   'false'
-    |   'null'
+    |   TRUE
+    |   FALSE
+    |   NULL
     ;
 
index a8f04a1f2ad69735769671aa0f6858a90259e870..de5798eedd01162a658a55d8e642eb6300959c1c 100644 (file)
@@ -95,7 +95,7 @@ packageDeclaration
 @init { 
     List<String> names = null; 
 }
-    :   ^('package' (ids+=IDENT)+)  
+    :   ^(PACKAGE (ids+=IDENT)+)  
         {
             String packageName = "";
             for(Object o : $ids) packageName += '.' + ((CharjAST)o).getText();
@@ -113,37 +113,45 @@ packageDeclaration
     
 importDeclarations returns [List<CharjAST> packageNames]
 @init {
-       packageNames = new ArrayList<CharjAST>();
+    packageNames = new ArrayList<CharjAST>();
 }
-    :   (^('import' qualifiedIdentifier './*'?)
+    :   (^(IMPORT qualifiedIdentifier '.*'?)
                { packageNames.add($qualifiedIdentifier.start); })*
     ;
 
 
 typeDeclaration[List<CharjAST> imports] returns [ClassSymbol sym]
 scope ScopeStack; // top-level type scope
-    :   ^(TYPE ('class' | chareType) IDENT
-            (^('extends' parent=type))? (^('implements' type+))? classScopeDeclaration*)
-        {
-            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;
-            importPackages($sym, $imports);
-        }
+    :   ^(TYPE (CLASS | chareType) 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;
+                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());
+                //}
+            }
     |   ^('interface' IDENT (^('extends' type+))?  interfaceScopeDeclaration*)
     |   ^('enum' IDENT (^('implements' type+))? enumConstant+ classScopeDeclaration*)
     ;
 
 chareType
-    :   'chare'
-    |   'group'
-    |   'nodegroup'
-    |   ^('chare_array' ARRAY_DIMENSION)
+    :   CHARE
+    |   GROUP
+    |   NODEGROUP
+    |   MAINCHARE
+    |   ^(CHARE_ARRAY ARRAY_DIMENSION)
     ;
 
 enumConstant
@@ -156,21 +164,33 @@ scope ScopeStack;
             ty=type IDENT f=formalParameterList a=arrayDeclaratorList? 
             b=block?)
         {
-            /*
             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.members.put($IDENT.text, sym);
+            currentClass.define($IDENT.text, sym);
             $FUNCTION_METHOD_DECL.symbol = sym;
-            */
         }
-    |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType variableDeclaratorList)
-    |   ^(OBJECT_VAR_DECLARATION modifierList? objectType variableDeclaratorList)
+    |   ^(PRIMITIVE_VAR_DECLARATION modifierList? simpleType
+            ^(VAR_DECLARATOR_LIST field[$simpleType.type]+))
+    |   ^(OBJECT_VAR_DECLARATION modifierList? objectType
+            ^(VAR_DECLARATOR_LIST field[$objectType.type]+))
     |   ^(CONSTRUCTOR_DECL m=modifierList? g=genericTypeParameterList? IDENT f=formalParameterList 
             b=block)
     ;
+
+field [ClassSymbol type]
+    :   ^(VAR_DECLARATOR ^(IDENT arrayDeclaratorList?) variableInitializer?)
+    {
+            System.out.println("Found variable: " + $type + " " + $IDENT.text);
+            VariableSymbol sym = new VariableSymbol(symtab, $IDENT.text, $type);
+            sym.definition = $field.start;
+            sym.definitionTokenStream = input.getTokenStream();
+            $VAR_DECLARATOR.symbol = sym;
+            currentClass.define($IDENT.text, sym);
+    }
+    ;
     
 interfaceScopeDeclaration
     :   ^(FUNCTION_METHOD_DECL modifierList? genericTypeParameterList? 
@@ -187,7 +207,8 @@ variableDeclaratorList
     ;
 
 variableDeclarator
-    :   ^(VAR_DECLARATOR variableDeclaratorId variableInitializer?)
+    :   ^(VAR_DECLARATOR ^(IDENT arrayDeclaratorList?) variableInitializer?)
+
     ;
     
 variableDeclaratorId
@@ -224,12 +245,12 @@ modifierList
     ;
 
 modifier
-    :   'public'
-    |   'protected'
-    |   'private'
-    |   'entry'
-    |   'abstract'
-    |   'native'
+    :   PUBLIC
+    |   PROTECTED
+    |   ENTRY
+    |   PRIVATE
+    |   ABSTRACT
+    |   NATIVE
     |   localModifier
     ;
 
@@ -238,42 +259,55 @@ localModifierList
     ;
 
 localModifier
-    :   'final'
-    |   'static'
-    |   'volatile'
+    :   FINAL
+    |   STATIC
+    |   VOLATILE
     ;
 
 type
     :   simpleType
-    |   objectType 
-    |   'void'
+    |   objectType
+    |   VOID
     ;
 
-simpleType
-    :   ^(TYPE primitiveType arrayDeclaratorList?)
+simpleType returns [ClassSymbol type]
+    :   ^(SIMPLE_TYPE primitiveType arrayDeclaratorList?)
+        {
+            $type = symtab.resolveBuiltinType($primitiveType.text);
+        }
     ;
     
-objectType
-    :   ^(TYPE qualifiedTypeIdent arrayDeclaratorList?)
+objectType returns [ClassSymbol type]
+    :   ^(OBJECT_TYPE qualifiedTypeIdent arrayDeclaratorList?)
+    |   ^(REFERENCE_TYPE qualifiedTypeIdent arrayDeclaratorList?)
+    |   ^(POINTER_TYPE qualifiedTypeIdent arrayDeclaratorList?)
+        {
+            $type = currentClass.resolveType($qualifiedTypeIdent.name);
+            if ($type == null) $type = symtab.resolveBuiltinType($qualifiedTypeIdent.name);
+        }
     ;
 
-qualifiedTypeIdent
-    :   ^(QUALIFIED_TYPE_IDENT typeIdent+) 
+qualifiedTypeIdent returns [String name]
+@init {
+$name = "";
+}
+    :   ^(QUALIFIED_TYPE_IDENT (typeIdent {$name += $typeIdent.name;})+) 
     ;
 
-typeIdent
+typeIdent returns [String name]
     :   ^(IDENT genericTypeArgumentList?)
+        { $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
@@ -319,35 +353,40 @@ localVariableDeclaration
     ;
 
 statement
-    :   block
-    |   ^('assert' expression expression?)
-    |   ^('if' parenthesizedExpression statement statement?)
-    |   ^('for' forInit? FOR_EXPR expression? FOR_UPDATE 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.
     ;
         
 switchCaseLabel
-    :   ^('case' expression blockStatement*)
-    |   ^('default' blockStatement*)
+    :   ^(CASE expression blockStatement*)
+    |   ^(DEFAULT blockStatement*)
     ;
     
 forInit
@@ -366,47 +405,47 @@ expression
     ;
 
 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)
+    |   ^(TILDA expr)
+    |   ^(NOT expr)
     |   ^(CAST_EXPR type expr)
     |   primaryExpression
     ;
@@ -414,8 +453,8 @@ expr
 primaryExpression
     :   ^(  '.' primaryExpression
                 (   IDENT
-                |   'this'
-                |   'super'
+                |   THIS
+                |   SUPER
                 )
         )
     |   parenthesizedExpression
@@ -425,9 +464,9 @@ primaryExpression
     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
     |   literal
     |   newExpression
-    |   'this'
+    |   THIS
     |   arrayTypeDeclarator
-    |   'super'
+    |   SUPER
     ;
     
 explicitConstructorCall
@@ -445,6 +484,7 @@ newExpression
             |   genericTypeArgumentList? qualifiedTypeIdent newArrayConstruction
             )
         )
+    |   ^(NEW qualifiedTypeIdent arguments)
     ;
 
 newArrayConstruction
@@ -463,8 +503,8 @@ literal
     |   FLOATING_POINT_LITERAL
     |   CHARACTER_LITERAL
     |   STRING_LITERAL          
-    |   'true'
-    |   'false'
-    |   'null'
+    |   TRUE
+    |   FALSE
+    |   NULL 
     ;
 
index d9b8bd8229a45587dc05c84880b36340f9d8dd4f..3e173312367557bdf8eec7f88b7c5f5fa3f1cd7d 100644 (file)
@@ -12,22 +12,13 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
         new LinkedHashMap<String, PackageScope>();
     List<String> includes = 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 ClassSymbol(
             SymbolTable symtab, 
@@ -96,31 +87,6 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
         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
@@ -157,6 +123,8 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
 
         // 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
@@ -192,20 +160,15 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
     public MethodSymbol resolveMethodLocally(
             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 ) {
@@ -217,8 +180,11 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
     public Symbol define(
             String name, 
             Symbol sym) {
-        if ( sym instanceof MethodSymbol ) {
-            methodNames.add(sym.name);
+        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);
     }
@@ -233,14 +199,7 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
             parent = scope.getFullyQualifiedName();
         }
         if ( parent!=null ) {
-            return parent+"."+name;
-        }
-        return name;
-    }
-
-    public String getMangledName() {
-        if ( SymbolTable.TYPE_NAMES_TO_MANGLE.contains(name) ) {
-            return "m"+name;
+            return parent+"::"+name;
         }
         return name;
     }
@@ -260,30 +219,38 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
     public List<String> getPackageNames()
     {
         List<String> list = new ArrayList<String>();
-        String namespace = "";
-        for(Scope currentScope = scope; currentScope != null; currentScope = currentScope.getEnclosingScope())
-            list.add(0, currentScope.getScopeName());
-        list.remove(0);
+        for(Scope currentScope = scope;
+                currentScope.getEnclosingScope() != null;
+                currentScope = currentScope.getEnclosingScope()) {
+            list.add(currentScope.getScopeName());
+        }
         return list;
     }
 
-    public String getNamespaceOpeningString() {
-        Scope currentScope = scope;
-        String namespace = "";
-        while (currentScope.getEnclosingScope() != null) {
-            namespace = "namespace " + currentScope.getScopeName() + " {\n" + namespace;
-            currentScope = currentScope.getEnclosingScope();
+    private Set<ClassSymbol> getMemberTypes()
+    {
+        Set<ClassSymbol> types = new HashSet<ClassSymbol>();
+        for (Map.Entry<String, VariableSymbol> entry : fields.entrySet()) {
+            types.add(((VariableSymbol)entry.getValue()).type);
         }
-        return namespace;
+        return types;
     }
 
-    public String getNamespaceClosingString() {
-        Scope currentScope = scope;
-        String namespace = "";
-        while (currentScope.getEnclosingScope() != null) {
-            namespace += "\n} // namespace " + currentScope.getScopeName();
-            currentScope = currentScope.getEnclosingScope();
+    public List<String> getMemberTypeNames()
+    {
+        if (debug()) System.out.println("Looking for type names...");
+        if (debug()) System.out.println("Found " + fields.size() + " fields...");
+        List<String> names = new ArrayList<String>();
+        for (ClassSymbol c : getMemberTypes()) {
+            if (c.isPrimitive) continue;
+            names.add(c.getName());
+            if (debug()) System.out.println("Found type " + c.getFullyQualifiedName());
         }
-        return namespace;
+        return names;
+    }
+
+    public String getName()
+    {
+        return name;
     }
 }
diff --git a/src/langs/charj/src/charj/translator/PupRoutineCreator.java b/src/langs/charj/src/charj/translator/PupRoutineCreator.java
new file mode 100644 (file)
index 0000000..95c778e
--- /dev/null
@@ -0,0 +1,84 @@
+package charj.translator;
+
+import org.antlr.runtime.tree.CommonTree;
+import org.antlr.runtime.Token;
+import org.antlr.runtime.CommonToken;
+
+class PupRoutineCreator
+{
+    private CharjAST pupNode;
+    private CharjAST block;
+
+    PupRoutineCreator()
+    {
+        createPupNode();
+        block = pupNode.getChild(4);
+    }
+
+    protected CharjAST getPupRoutineNode()
+    {
+        return pupNode;
+    }
+
+    private CharjAST createNode(int type, String text)
+    {
+        return new CharjAST(new CommonToken(type, text));
+    }    
+
+    private void createPupNode()
+    {
+        pupNode = createNode(CharjParser.FUNCTION_METHOD_DECL, "FUNCTION_METHOD_DECL");
+
+       pupNode.addChild(createNode(CharjParser.MODIFIER_LIST, "MODIFIER_LIST"));
+        pupNode.addChild(createNode(CharjParser.VOID, "void"));
+        pupNode.addChild(createNode(CharjParser.IDENT, "pup"));
+        pupNode.addChild(createNode(CharjParser.FORMAL_PARAM_LIST, "FORMAL_PARAM_LIST"));
+        pupNode.addChild(createNode(CharjParser.BLOCK, "BLOCK"));
+
+        pupNode.getChild(0).addChild(createNode(CharjParser.PUBLIC, "public"));
+
+        pupNode.getChild(3).addChild(createNode(CharjParser.FORMAL_PARAM_STD_DECL, "FORMAL_PARAM_STD_DECL"));
+        pupNode.getChild(3).getChild(0).addChild(createNode(CharjParser.REFERENCE_TYPE, "REFERENCE_TYPE"));
+        pupNode.getChild(3).getChild(0).getChild(0).addChild(createNode(CharjParser.QUALIFIED_TYPE_IDENT, "QUALIFIED_TYPE_IDENT"));
+        pupNode.getChild(3).getChild(0).getChild(0).getChild(0).addChild(createNode(CharjParser.IDENT, "PUP::er"));
+
+        pupNode.getChild(3).getChild(0).addChild(createNode(CharjParser.IDENT, "p"));
+    }
+
+    protected CharjAST getEnclosingType(CharjAST varDeclNode)
+    {
+        for(CharjAST p = varDeclNode.getParent(); p != null; p = p.getParent())
+            if(p.getType() == CharjParser.TYPE)
+                return p;
+        return null;
+    }         
+
+    protected void varPup(CharjAST idNode)
+    {
+        boolean primitive = false;
+
+        for(CharjAST p = idNode.getParent(); p != null; p = p.getParent())
+            if(p.getType() == CharjParser.PRIMITIVE_VAR_DECLARATION)
+                primitive = true;
+            else if(p.getType() == CharjParser.FUNCTION_METHOD_DECL)
+                break;
+            else if(p.getType() == CharjParser.TYPE)
+            {
+                if(primitive)
+                    primitiveVarPup(idNode);
+                else
+                    objectVarPup(idNode);
+                break;
+            }
+    }
+
+    protected void primitiveVarPup(CharjAST idNode)
+    {
+        pupNode.getChild(4).addChild(createNode(CharjParser.EXPR, "EXPR"));
+        pupNode.getChild(4).getChild(0).addChild(createNode(CharjParser.BITWISE_OR, "|"));
+        pupNode.getChild(4).getChild(0).getChild(0).addChild(createNode(CharjParser.IDENT, "p"));
+        pupNode.getChild(4).getChild(0).getChild(0).addChild(idNode.dupNode());
+    }
+    
+    protected void objectVarPup(CharjAST varDeclNode){}
+}
index e557f8dcc64caffe4cc4ed0c48ed84ee925d87e8..3812e3e6fbd5aeeb3e8febf11b3f611b04774016 100644 (file)
@@ -67,6 +67,11 @@ public class SymbolTable {
         primitiveTypes.put("char",   new ClassSymbol(this, "char",   null, lang)); 
         primitiveTypes.put("short",  new ClassSymbol(this, "short",  null, lang)); 
         primitiveTypes.put("bool",   new ClassSymbol(this, "bool",   null, lang)); 
+        for (Map.Entry<String, ClassSymbol> entry : primitiveTypes.entrySet()) {
+            ClassSymbol c = entry.getValue();
+            lang.define(entry.getKey(), c);
+            c.isPrimitive = true;
+        }
     }
 
     public ClassSymbol resolveBuiltinType(String type) {
index bf4a28aaa8ad47c99aa397f1e6803d63390799f2..1b11cba55d2dc3b1b2781b3c0b8b307f30e6e642 100644 (file)
@@ -158,7 +158,7 @@ public abstract class SymbolWithScope
             parent = getEnclosingScope().getFullyQualifiedName();
         }
         if ( parent!=null ) {
-            return parent + "." + name;
+            return parent + "::" + name;
         }
         return name;
     }
index b0310e81c524d5accaa40bb9d26ed28334e14065..8c4398072a6aa81f6ac6f04bbc9ad1b708dfc3f4 100644 (file)
@@ -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;
@@ -57,6 +58,7 @@ public class Translator {
 
     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) {
@@ -72,6 +74,8 @@ public class Translator {
     };
 
     public String translate(String filename) throws Exception {
+        m_basename = filename.substring(0, filename.lastIndexOf("."));
+
         ANTLRFileStream input = new ANTLRFileStream(filename);
             
         CharjLexer lexer = new CharjLexer(input);
@@ -88,21 +92,23 @@ public class Translator {
         m_nodes.setTokenStream(tokens);
         m_nodes.setTreeAdaptor(m_adaptor);
 
-        // do AST rewriting in semantic phase
-        if (m_printAST) printAST("Before Semantic Pass", "before.html");
+        // 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();
-        if (m_printAST) printAST("After Semantic Pass", "after.html");
+        if (m_printAST) printAST("After Semantic Pass", "after_sem.html");
 
         // 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);
@@ -117,9 +123,19 @@ public class Translator {
             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);
     }
@@ -127,6 +143,7 @@ public class Translator {
     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);
@@ -203,7 +220,7 @@ public class Translator {
             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");
index 01110a602dab5a0465fac0b980b87c1a7e0c0617..6165c7936d56b2c3480b5dfc35f773c6743e9999 100755 (executable)
@@ -1962,6 +1962,7 @@ EOT
 test_finish() {
        rm -f $t $tc testlink test.o    > /dev/null 2>&1
        /bin/rm -f out
+       test $1 -eq 1 && echo "*** Please find detailed output in charmconfig.out ***"
        exit $1
 }
 
@@ -2563,7 +2564,7 @@ BUILD_MPI=$strictpass
 if test $BUILD_MPI -eq 0
 then
   echo "Error: Can not compile a MPI program"
-  exit 1
+  test_finish 1
 fi
 
 if test $BUILD_MPI -eq 1
@@ -2584,7 +2585,7 @@ then
                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
         else
                 echo "Error: can not find mpi library"
-                exit 1
+                test_finish 1
         fi
       fi
     else
@@ -3635,7 +3636,7 @@ echo "${ECHO_T}$GLIBCVERSION" >&6; }
     then
        echo "Your version of GLIBC is ancient, and does not have sufficient "
        echo "support for pthreads."
-       exit 1
+       test_finish 1
     fi
 esac
 fi
index 66cb58a86d2b21a4faf45e0cdc61f0f4278c95d9..d0ee5e76583806197ea1213c4ec117ca3c741990 100644 (file)
@@ -283,6 +283,7 @@ EOT
 test_finish() {
        rm -f $t $tc testlink test.o    > /dev/null 2>&1
        /bin/rm -f out
+       test $1 -eq 1 && echo "*** Please find detailed output in charmconfig.out ***"
        exit $1
 }
 
@@ -740,7 +741,7 @@ BUILD_MPI=$strictpass
 if test $BUILD_MPI -eq 0
 then
   echo "Error: Can not compile a MPI program"
-  exit 1
+  test_finish 1
 fi
 
 if test $BUILD_MPI -eq 1
@@ -761,7 +762,7 @@ then
                 add_flag CMK_SYSLIBS='"$CMK_SYSLIBS -lmpi"' "mpi lib"
         else
                 echo "Error: can not find mpi library"
-                exit 1
+                test_finish 1
         fi
       fi
     else
@@ -1569,7 +1570,7 @@ case $version in *linux*smp*|*linux*vmi*)
     then
        echo "Your version of GLIBC is ancient, and does not have sufficient "
        echo "support for pthreads."
-       exit 1
+       test_finish 1
     fi
 esac
 fi