Merge branch 'charm' of charmgit:charm into charm
authorYanhua Yanhua <sun51@illinois.edu>
Fri, 20 Aug 2010 18:06:20 +0000 (13:06 -0500)
committerYanhua Yanhua <sun51@illinois.edu>
Fri, 20 Aug 2010 18:06:20 +0000 (13:06 -0500)
21 files changed:
src/arch/common/cc-iccstatic.sh
src/langs/charj/src/charj/libs/Array.cpp
src/langs/charj/src/charj/libs/Array.h
src/langs/charj/src/charj/translator/Charj.g
src/langs/charj/src/charj/translator/CharjASTModifier.g
src/langs/charj/src/charj/translator/CharjASTModifier2.g
src/langs/charj/src/charj/translator/CharjEmitter.g
src/langs/charj/src/charj/translator/ClassSymbol.java
src/langs/charj/src/charj/translator/PackageScope.java
src/langs/charj/src/charj/translator/Scope.java
src/langs/charj/src/charj/translator/SymbolDefiner.g
src/langs/charj/src/charj/translator/SymbolResolver.g
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/langs/charj/src/charj/translator/TypeName.java [new file with mode: 0644]
src/langs/charj/src/charj/translator/VariableInitializer.java
src/langs/charj/tests/unit/ArrayTest.cj
src/scripts/Makefile
src/util/pup_f.f90
src/util/pup_f.f90.sh

index f0b21f09e52ca50ebb9e802242cc51e7e6de2c5f..7eba56023e02946ef70fd04994a755c5e1a5bd43 100644 (file)
@@ -1,9 +1,25 @@
+# test version
+ICC_ver=`icc -v 2>&1 | grep Version`
+ICC_ver=`echo $ICC_ver | awk '{ print $2; }' | awk 'BEGIN {FS="."}; { print $1; }'`
+test -z "$ICC_ver" && echo "ICC compiler not found!" && exit 1
+#echo version:$ICC_ver
+
+if test $ICC_ver  -ge 10
+then
+  ICCOPTS="-static-intel"
+elif test $ICC_ver -eq 9
+then
+  ICCOPTS="-i-static"
+else
+  ICCOPTS="-static-libcxa"
+fi
+
 CMK_CPP_C='icc -E '
 CMK_CC='icc '
 CMK_CXX='icpc '
 CMK_CXXPP='icpc -E '
-CMK_LD='icc -static-libcxa '
-CMK_LDXX='icpc -static-libcxa '
+CMK_LD="icc $ICCOPTS"
+CMK_LDXX="icpc $ICCOPTS"
 CMK_LD_LIBRARY_PATH="-Wl,-rpath,$CHARMLIBSO/"
 CMK_CF90='ifc -auto '
 CMK_CF90_FIXED="$CMK_CF90 -132 -FI "
index 01853f05eb946e55634888a921bff26e78a3d6c4..c21445279d285ba7029f73d84c3582508930a01f 100644 (file)
 #include "Array.h"
 #include <iostream>
+#include <list>
+#include <string>
 
 using namespace std;
 using namespace CharjArray;
 
-class Test {
-public: Array<int> aaa;
-  
-  Test() {
-    aaa.init(Domain<1>(Range(3)));
+class ArrayTest {
+public:
+  virtual string testName() = 0;
+  virtual bool test() = 0;
+};
+
+class Array1DUnit : public ArrayTest {
+public:
+  string testName() {
+    return string("1D int array test");
   }
 
-};
+  bool test() {
+    int size = 10;
+    Range r(size);
+    Array<int> *array1 = new Array<int>(Domain<1>(Range(size)));
+    Array<int> &ref = *array1;
 
-class ArrayTest2 {
-public: 
-  Array<int> test;
+    if (ref.size() != size)
+      return false;
 
-  void test1() {
-    test[0] = 0;
-    int i;
-    for (i = 0; i < 10; i++) {
-      test[i] = 110;
+    for (int i = 0; i < ref.size(); i++) {
+      ref[i] = 20 + i;
     }
+
+    for (int i = 0; i < size; i++) {
+      if (ref[i] != i + 20)
+        return false;
+      //cout << i << ": " << ref[i] << endl;
+    }
+
+    return true;
   }
+};
+
+class Array2DUnitLinear : public ArrayTest {
+public:
+  string testName() {
+    return string("2D int array test");
+  }
+
+  bool test() {
+    int size1 = 2;
+    int size2 = 3;
+    Range dim1(size1);
+    Range dim2(size2);
+    Range rarray [2] = {dim1, dim2};
+    Array<int, 2> *array1 = new Array<int, 2>(Domain<2>(rarray));
+    Array<int, 2> &ref = *array1;
+
+    if (ref.size() != size1 * size2)
+      return false;
+
+    for (int i = 0; i < ref.size(); i++) {
+      ref[i] = 20 + i;
+    }
 
-  ArrayTest2() {
-    test.init(Domain<1>(Range(10)));
+    for (int i = 0; i < size1 * size2; i++) {
+      if (ref[i] != i + 20)
+        return false;
+      //cout << i << ": " << ref[i] << endl;
+    }
+
+    return true;
   }
 };
 
-int main(void) {
-  Range ranges[1];
-  ranges[0] = 10;
+class Array2DUnitRowMajor : public ArrayTest {
+public:
+  string testName() {
+    return string("2D int array test");
+  }
 
-  Domain<1> domain(ranges);
+  bool test() {
+    int size1 = 2;
+    int size2 = 3;
+    Range dim1(size1);
+    Range dim2(size2);
+    Range rarray [2] = {dim1, dim2};
+    Array<int, 2> *array1 = new Array<int, 2>(Domain<2>(rarray));
+    Array<int, 2> &ref = *array1;
+
+    if (ref.size() != size1 * size2)
+      return false;
+
+    for (int i = 0; i < ref.size(0); i++) {
+      for (int j = 0; j < ref.size(1); j++) {
+        ref.access(i, j) = i;
+      }
+    }
 
-  Array<int> arr;
+    for (int i = 0; i < size2; i++) {
+      if (ref[i] != 0)
+        return false;
+    }
 
-  arr.init(domain);
+    for (int i = size2; i < size2 * 2; i++) {
+      if (ref[i] != 1)
+        return false;
+    }
 
-  //arr[0] = 10;
-  arr[0] = 10000;
-  arr[1] = 20;
-  arr[8] = 200;
+    return true;
+  }
+};
+
+int main(void) {
+  list<ArrayTest*> tests;
+  Array1DUnit a1;
+  Array2DUnitLinear a2;
+  Array2DUnitRowMajor a3;
+
+  tests.push_back(&a1);
+  tests.push_back(&a2);
+  tests.push_back(&a3);
+
+  for (list<ArrayTest*>::iterator iter = tests.begin();
+       iter != tests.end();
+       ++iter) {
+    bool status = (*iter)->test();
+    if (status)
+      cout << (*iter)->testName() << " PASSED" << endl;
+    else
+      cout << (*iter)->testName() << " FAILED" << endl;
+  }
 
-  //Array<int> aaa;
-  //aaa(Domain<1>(Range(3));
+#if 0
+  Array<int>* newTest = new Array<int>(Domain<1>(Range(10)));
 
-  for (int i = 0; i < arr.size(); i++) {
-    cout << i << ": " << arr[i] << endl;
+  for (int i = 0; i < 9; i++) {
+    (*newTest)[i] = i;
   }
 
-  cout << endl;
+  for (int i = 0; i < 10; i++) {
+    cout << "newTest: " << (*newTest)[i] << endl;
+  }
 
-  ArrayTest2 at;
-  at.test1();
+  Array<int>* newTest2 = (*newTest)[Domain<1>(Range(5, 9))];
 
-  for (int i = 0; i < at.test.size(); i++) {
-    cout << i << ": " << at.test[i] << endl;
+  for (int i = 0; i < newTest2->size(); i++) {
+    cout << "newTest2: " << (*newTest2)[i] << endl;
   }
+#endif
 
   return 0;
 }
index 36de6660247afcb7bb5f614855ced74af361e1b1..59c44c2a1e1dc2830ac43d1cb6c025c57104f436 100644 (file)
@@ -1,14 +1,23 @@
 #ifndef ARRAY_H
 #define ARRAY_H
 
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <cassert>
+#include <iostream>
 #include <charm++.h>
 
 namespace CharjArray {
   class Range {
   public:
-    int size, offset;
+    int size, start, stop;
     Range() {}
-    Range(int size_) : size(size_) {}
+    Range(int size_) : size(size_), start(0), stop(size) {}
+    Range(int start_, int stop_) :
+      start(start_), stop(stop_), size(stop_ - start_) {
+      assert(stop >= start);
+    }
   };
 
   template<int dims>
@@ -27,6 +36,12 @@ namespace CharjArray {
       ranges[0] = range;
     }
 
+    Domain(Range range1, Range range2) {
+      // TODO: fix Charj generator so it uses the array
+      ranges[0] = range1;
+      ranges[1] = range2;
+    }
+
     int size() {
       int total = 0;
       for (int i = 0; i < dims; i++)
@@ -38,52 +53,99 @@ namespace CharjArray {
   };
 
   template<int dims>
-  class Point : public Domain<dims> {
+  class RowMajor {
+  public:
+    static int access(const int i, const Domain<dims> &d) {
+      return i - d.ranges[0].start;
+    }
+    static int access(const int i, const int j, const Domain<dims> &d) {
+      return (i - d.ranges[0].start) * d.ranges[1].size + j -
+        d.ranges[1].start;
+    }
+    // Generic access method, not used right now.
+    // static int access(const int *i, const Domain<dims> &d) {
+    //   int off = i[0];
+    //   int dimoff = 1;
+    //   for (int j = ndims-1; j > 0; --j) {
+    //     dimoff *= d.ranges[j].size;
+    //     off += dimoff * (i[j] - d.ranges[j].start);
+    //   }
+    //   return off;
+    // }
+  };
+
+  template<int dims>
+  class ColMajor {
   public:
-    Point(int dim) : Domain<dims>() {
-      this->ranges[0].size = dim;
+    static int access(const int i, const Domain<dims> &d) {
+      return i - d.ranges[0].start;
+    }
+    static int access(const int i, const int j, const Domain<dims> &d) {
+      return (j - d.ranges[1].start) * d.ranges[1].size + i -
+        d.ranges[0].start;
     }
   };
 
-  enum ArrayType { RECT, JAGGED, ROW_MAJOR, COL_MAJOR };
-  template<class type, int dims = 1, ArrayType atype = RECT>
+  template<class type, int dims = 1, class atype = RowMajor<dims> >
   class Array {
   private:
     Domain<dims> domain;
     type *block;
+    int ref_cout;
+    Array* ref_parent;
 
   public:
-    Array(Domain<dims> domain_) {
+    Array(Domain<dims> domain_) : ref_parent(0) {
       init(domain_);
     }
 
+    Array(type **block_) {
+      block = *block_;
+    }
+
+    Array() : ref_parent(0) {
+
+    }
+
+    Array(Array* parent, Domain<dims> domain_) : ref_parent(parent) {
+      domain = domain_;
+      block = parent->block;
+    }
+
     void init(Domain<dims> &domain_) {
       domain = domain_;
-      if (atype == RECT)
-       block = new type[domain.size()];
+      //if (atype == ROW_MAJOR)
+      block = new type[domain.size()];
     }
 
     ~Array() {
       delete block;
     }
-    
-    type* operator[] (const Domain<dims> &domain) {
+
+    /*type* operator[] (const Domain<dims> &domain) {
       return block[domain.ranges[0].size];
+      }*/
+
+    type& operator[] (const int i) {
+      return block[atype::access(i, domain)];
     }
 
-    type& operator[] (const Point<dims> &point) {
-      return block[point.ranges[0].size];
+    type& access(const int i, const int j) {
+      return block[atype::access(i, j, domain)];
     }
 
-    type& operator[] (const int index) {
-      return block[index];
+    Array<type, dims, atype>* operator[] (const Domain<dims> &domain) {
+      return new Array<type, dims, atype>(this, domain);
     }
 
     int size() {
       return domain.size();
     }
 
+    int size(int dim) {
+      return domain.ranges[dim].size;
+    }
+
     void pup(PUP::er& p) { }
   };
 }
index 5c26db6fd51254c968667a8a2572f9706d3c0dd3..bedf56248c1be2143a63c3098f807d284316cfd8 100644 (file)
@@ -383,7 +383,6 @@ interfaceFieldDeclarator
         ->  ^(VAR_DECLARATOR variableDeclaratorId variableInitializer)
     ;
 
-
 variableDeclaratorId
     :   IDENT^ domainExpression?
     ;
@@ -393,16 +392,6 @@ variableInitializer
     |   expression
     ;
 
-/*arrayDeclarator
-    :   '[' ']'
-        ->  ARRAY_DECLARATOR
-    ;
-
-arrayDeclaratorList
-    :   arrayDeclarator+
-        ->  ^(ARRAY_DECLARATOR_LIST arrayDeclarator+)   
-    ;*/
-
 arrayInitializer
     :   lc='{' (variableInitializer (',' variableInitializer)* ','?)? '}'
         ->  ^(ARRAY_INITIALIZER[$lc, "ARRAY_INITIALIZER"] variableInitializer*)
@@ -841,6 +830,8 @@ postfixedExpression
             ->  ^(ENTRY_METHOD_CALL ^(AT $postfixedExpression IDENT) templateInstantiation? arguments)
         |   '[' expression ']'
             ->  ^(ARRAY_ELEMENT_ACCESS $postfixedExpression expression)
+        |   domainExpression
+            ->  ^(ARRAY_ELEMENT_ACCESS $postfixedExpression domainExpression)
         )*
         // At the end there may follow a post increment/decrement.
         (   op='++'-> ^(POST_INC[$op, "POST_INC"] $postfixedExpression)
index 146d5c4687eb1b774dfbd5fce32006303bbf2c0b..9c640adc2db1876c6cdce515debc9e77124c863d 100644 (file)
@@ -160,7 +160,7 @@ templateArg
     ;
 
 templateArgList
-    :   templateArg (','! templateArg)*
+    :   templateArg templateArg*
     ;
 
 templateInstantiation
@@ -265,10 +265,6 @@ primitiveType
     |   DOUBLE
     ;
 
-genericTypeArgumentList
-    :   ^(GENERIC_TYPE_ARG_LIST genericTypeArgument+)
-    ;
-    
 genericTypeArgument
     :   type
     |   '?'
@@ -423,11 +419,12 @@ primaryExpression
              )
     |   parenthesizedExpression
     |   IDENT
-    |   ^(METHOD_CALL primaryExpression genericTypeArgumentList? arguments)
-    |   ^(ENTRY_METHOD_CALL ^(AT primaryExpression IDENT) genericTypeArgumentList? arguments)
-        ->  ^(ENTRY_METHOD_CALL ^(DOT primaryExpression IDENT) genericTypeArgumentList? arguments)
+    |   ^(METHOD_CALL primaryExpression templateInstantiation? arguments)
+    |   ^(ENTRY_METHOD_CALL ^(AT primaryExpression IDENT) templateInstantiation? arguments)
+        ->  ^(ENTRY_METHOD_CALL ^(DOT primaryExpression IDENT) templateInstantiation? arguments)
     |   explicitConstructorCall
     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
+    |   ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
     |   literal
     |   newExpression
     |   THIS
@@ -442,8 +439,8 @@ primaryExpression
     ;
     
 explicitConstructorCall
-    :   ^(THIS_CONSTRUCTOR_CALL genericTypeArgumentList? arguments)
-    |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? genericTypeArgumentList? arguments)
+    :   ^(THIS_CONSTRUCTOR_CALL templateInstantiation? arguments)
+    |   ^(SUPER_CONSTRUCTOR_CALL primaryExpression? templateInstantiation? arguments)
     ;
 
 arrayTypeDeclarator
index 607cd302b102da1ad9270fdae19254143d9be3ea..5b6ae40d408242d9a361c6362c0aa9f8a7d70fd4 100644 (file)
@@ -150,7 +150,7 @@ templateArg
     ;
 
 templateArgList
-    :   templateArg (','! templateArg)*
+    :   templateArg templateArg*
     ;
 
 templateInstantiation
@@ -432,6 +432,7 @@ primaryExpression
     |   ^(ENTRY_METHOD_CALL primaryExpression genericTypeArgumentList? entryArguments)
     |   explicitConstructorCall
     |   ^(ARRAY_ELEMENT_ACCESS primaryExpression expression)
+    |   ^(ARRAY_ELEMENT_ACCESS primaryExpression domainExpression)
     |   literal
     |   newExpression
     |   THIS
index 05e343e4c73a78e642c6aac1e9bf3c96ebd589f2..2a4c428fad881e7269a8ed05a77dc7e7c4c04779 100644 (file)
@@ -388,13 +388,26 @@ 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})
+    ;
+
+domainExpressionAccess
+    :   ^(DOMAIN_EXPRESSION rl=rangeListAccess)
+        -> template(t={$rangeListAccess.st}) "<t>"
+    ;
+
+rangeListAccess
+    :   (r+=rangeExpressionAccess)*
+        -> template(t={$r}) "<t; separator=\", \">"
+    ;
 
+rangeExpressionAccess
+    :   ^(RANGE_EXPRESSION (ri+=rangeItem)*)
+        -> template(t={$ri}) "<t; separator=\",\">"
     ;
 
 arrayInitializer
@@ -722,6 +735,13 @@ parenthesizedExpression
     :   ^(PAREN_EXPR exp=expression)
         -> template(expr={$exp.st}) "(<expr>)"
     ;
+
+expressionArrayAccess
+    :   ^(EXPR expr)
+        -> {$expr.st}
+    |    domainExpressionAccess
+        -> {$domainExpressionAccess.st}
+    ;
     
 expression
     :   ^(EXPR expr)
@@ -822,6 +842,7 @@ expr
     ;
 
 primaryExpression
+@init { int dims = 1; }
     :   ^(DOT prim=primaryExpression
             ( IDENT   -> template(id={$IDENT.text}, prim={$prim.st}) "<prim>.<id>"
             | THIS    -> template(prim={$prim.st}) "<prim>.this"
@@ -846,9 +867,23 @@ primaryExpression
         -> method_call(primary={$pe.st}, generic_types={$gtal.st}, args={$args.st})
     |   explicitConstructorCall
         -> {$explicitConstructorCall.st}
-    |   ^(ARRAY_ELEMENT_ACCESS pe=primaryExpression ex=expression)
-        -> {$pe.start.symbolType != null && $pe.start.symbolType instanceof PointerType}?
+    |   ^(ARRAY_ELEMENT_ACCESS pe=primaryExpression ex=expressionArrayAccess) {
+            if ($pe.start.symbolType != null && $pe.start.symbolType instanceof PointerType) {
+                PointerType p = (PointerType)($pe.start.symbolType);
+                if (p.baseType instanceof ClassSymbol) {
+                    ClassSymbol cs = (ClassSymbol)(p.baseType);
+                    if (cs.templateArgs != null && cs.templateArgs.size() > 1 &&
+                        cs.templateArgs.get(1) instanceof LiteralType) {
+                        LiteralType l = (LiteralType)(cs.templateArgs.get(1));
+                        dims = Integer.valueOf(l.literal);
+                    }
+                }
+            }
+        }
+        -> {$pe.start.symbolType != null && $pe.start.symbolType instanceof PointerType && dims == 1}?
                template(pe={$pe.st}, ex={$ex.st}) "(*(<pe>))[<ex>]"
+        -> {$pe.start.symbolType != null && $pe.start.symbolType instanceof PointerType && dims == 2}?
+               template(pe={$pe.st}, ex={$ex.st}) "(*(<pe>)).access(<ex>)"
         -> template(pe={$pe.st}, ex={$ex.st}) "(<pe>)[<ex>]"
     |   literal
         -> {$literal.st}
index baf87f8a238d6c0d65007c5665e46f297d5681b2..37309f91a0a8788ed756ffdd73db25ff348c7c94 100644 (file)
@@ -7,7 +7,7 @@ public class ClassSymbol extends SymbolWithScope implements Scope, Type {
 
     public ClassSymbol superClass;
     public List<String> interfaceImpls;
-    public List<String> templateArgs;
+    public List<Type> templateArgs;
     public List<VariableInitializer> initializers;
     public List<VariableInitializer> pupInitializers;
     public List<CharjAST> varsToPup;
@@ -137,19 +137,26 @@ public class ClassSymbol extends SymbolWithScope implements Scope, Type {
      *  packges, walk through imported packages again, trying to load from
      *  disk.
      */
-    public Type resolveType(String type) {
-        if (debug()) System.out.println(
-                "ClassSymbol.resolveType(" + type + "): context is " + name +
-                ":" + members.keySet());
+    public Type resolveType(List<TypeName> type) {
+        String typeStr = "";
+        
+        if (debug()) {
+            typeStr = TypeName.typeToString(type);
+            System.out.println("ClassSymbol.resolveType(" + typeStr + 
+                               "): context is " + name + ":" + 
+                               members.keySet());
+        }
 
-        if (type == null) {
+        if (type == null || type.size() == 0) {
             return null;
         }
 
-        if ( name.equals(type) ) {
-            if ( debug() ) System.out.println(
-                    "ClassSymbol.resolveType(" + type +
-                    "): surrounding class " + name + ":" + members.keySet());
+        // Assume that the first part of the type is in position 0
+        if ( name.equals(type.get(0).name) ) {
+            if (debug()) 
+                System.out.println("ClassSymbol.resolveType(" + typeStr +
+                                   "): surrounding class " + name + ":" + 
+                                   members.keySet());
             return this;
         }
 
@@ -162,12 +169,12 @@ public class ClassSymbol extends SymbolWithScope implements Scope, Type {
         // 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);
+                    typeStr + " 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 +
+                        "ClassSymbol.resolveType(" + typeStr +
                         "): found in context " + name + ":" +
                         members.keySet());
                 return cs;
@@ -175,7 +182,7 @@ public class ClassSymbol extends SymbolWithScope implements Scope, Type {
         }
 
         if ( debug() ) System.out.println(
-                "ClassSymbol.resolveType(" + type +
+                "ClassSymbol.resolveType(" + typeStr +
                 "): not in context " + name + ":" + members.keySet());
         return null;
     }
@@ -217,7 +224,7 @@ public class ClassSymbol extends SymbolWithScope implements Scope, Type {
 
     public String toString() {
         if (isPrimitive) return name;
-        else return getFullyQualifiedName() + members;
+        else return getFullyQualifiedName() + members + templateArgs;
     }
 
     public String getFullyQualifiedName() {
@@ -323,7 +330,8 @@ public class ClassSymbol extends SymbolWithScope implements Scope, Type {
     public List<String> generateInits(List<VariableInitializer> inits) {
         List<String> strInits = new ArrayList<String>();
         for (VariableInitializer init : inits) {
-            strInits.add(init.emit());
+            if (init.init != null)
+                strInits.add(init.emit());
         }
         return strInits;
     }
index 7bbdfc076ed5331f1a0c900caefa54eb89cd919d..f7b6e904965842d9e522be52066cf8c1d50ac75b 100644 (file)
@@ -3,6 +3,8 @@ package charj.translator;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.List;
+import java.util.ArrayList;
 
 public class PackageScope extends SymbolWithScope {
 
@@ -28,26 +30,29 @@ public class PackageScope extends SymbolWithScope {
      *  in package lang which is in package charj.  Next time, Chare will
      *  be found.
      */
-    public ClassSymbol resolveType(String type) {
+    public ClassSymbol resolveType(List<TypeName> type) {
         if (type == null) return null;
-        if (debug()) System.out.println(
-                " PackageScope.resolveType(" + type + 
-                "): examine " + toString());
+
+        String typeStr = "";
+
+        if (debug()) { 
+            typeStr = TypeName.typeToString(type);
+            System.out.println(" PackageScope.resolveType(" + typeStr + 
+                                "): examine " + toString());
+        }
 
         ClassSymbol cs = symtab.primitiveTypes.get(type);
         if (cs != null) return cs;
 
-        // break off leading package names and look them up,
-        // then look up the base class name within the appropriate package scope.
-        String[] nameParts = type.split("[.]", 2);
-        if (nameParts.length == 1) return (ClassSymbol)members.get(type);
-        PackageScope innerPackage = (PackageScope)members.get(nameParts[0]);
+        if (type.size() == 1) return (ClassSymbol)members.get(type.get(0).name);
+        PackageScope innerPackage = (PackageScope)members.get(type.get(0).name);
         if (innerPackage == null) {
             if (debug()) System.out.println("Package lookup for " +
-                    nameParts[0] + "failed.\n");
+                                            type.get(0) + "failed.\n");
             return null;
         }
-        return innerPackage.resolveType(nameParts[1]);
+
+        return innerPackage.resolveType(TypeName.createTypeName(type.get(1).name));
     }
 
     public String getFullyQualifiedName() {
index 84581ac12fc828cdc5d67730db787f677cea8933..5fa8175272c6f45601f7717c32c0fc74c5d591f6 100644 (file)
@@ -2,6 +2,7 @@
 package charj.translator;
 
 import java.util.Map;
+import java.util.List;
 
 public interface Scope {
     
@@ -28,7 +29,7 @@ public interface Scope {
     /** Look up a typename in this scope or in enclosing scope if not here.
      *  Load from disk if necessary.
      */
-    public Type resolveType(String name);
+    public Type resolveType(List<TypeName> name);
 
     /** To look up a method, we need to know number of arguments for overloading
      *  so we need separate method to distinguish from resolve().
index 8bcaa04cdeb5f11e0cb966bfbe7a287451f67e12..66ed97b843905e56801eecc909ec7b14ab8703a0 100644 (file)
@@ -81,10 +81,10 @@ boolean entry = false;
             type IDENT .*)
         {
             //System.out.println("entering method scope " + $IDENT.text);
-            String typeName = $type.typeName;
-            if (typeName == null) {
+            List<TypeName> typeName = $type.typeName;
+            if (typeName == null || typeName.size() == 0) {
                 /*System.out.println("Warning: return type of " + $IDENT.text + " has null text, using void");*/
-                typeName = "void";
+                typeName.add(new TypeName("void"));
             }
             boolean isTraced = false;
             if ($MODIFIER_LIST != null) {
@@ -155,7 +155,9 @@ enterClass
                 OBJECT_VAR_DECLARATION | CONSTRUCTOR_DECL | ENTRY_CONSTRUCTOR_DECL) .*))*)
         {
             ClassSymbol sym = new ClassSymbol(symtab, $IDENT.text,
-                    (ClassSymbol)currentScope.resolveType($parent.text), currentScope);
+                    (ClassSymbol)currentScope.
+                      resolveType(TypeName.createTypeName($parent.text)),
+                                  currentScope);
             currentScope.define(sym.name, sym);
             currentClass = sym;
             sym.definition = $IDENT;
@@ -234,33 +236,45 @@ varDeclaration
     ;
 
 
-type returns [String typeName]
+type returns [List<TypeName> typeName]
 @init {
-    $typeName = "";
+    $typeName = new ArrayList<TypeName>();
     if (currentScope == null) System.out.println("*****ERROR: null type scope");
     assert currentScope != null;
-}
-@after {
-    $typeName = $typeName.substring(1);
 }
     :   VOID {
             $VOID.scope = currentScope;
-            $typeName = ".void";
+            $typeName.add(new TypeName("void"));
         }
     |   ^(SIMPLE_TYPE t=. .*) {
             $SIMPLE_TYPE.scope = currentScope;
-            $typeName = "." + $t;
+            $typeName.add(new TypeName($t.toString()));
         }
-    |   ^(OBJECT_TYPE ^(QUALIFIED_TYPE_IDENT (^(IDENT {$typeName += "." + $IDENT.text;} .*))+) .*)
+    |   ^(OBJECT_TYPE ^(QUALIFIED_TYPE_IDENT (^(i1=IDENT {$typeName.add(new TypeName($IDENT.text));} .*))+) .*)
             { $OBJECT_TYPE.scope = currentScope; }
-    |   ^(REFERENCE_TYPE ^(QUALIFIED_TYPE_IDENT (^(IDENT {$typeName += "." + $IDENT.text;} .*))+) .*)
+    |   ^(REFERENCE_TYPE ^(QUALIFIED_TYPE_IDENT (^(IDENT {$typeName.add(new TypeName($IDENT.text));} .*))+) .*)
             { $REFERENCE_TYPE.scope = currentScope; }
-    |   ^(PROXY_TYPE ^(QUALIFIED_TYPE_IDENT (^(IDENT {$typeName += "." + $IDENT.text;} .*))+) .*)
+    |   ^(PROXY_TYPE ^(QUALIFIED_TYPE_IDENT (^(IDENT {$typeName.add(new TypeName($IDENT.text));} .*))+) .*)
             { $PROXY_TYPE.scope = currentScope; }
-    |   ^(POINTER_TYPE ^(QUALIFIED_TYPE_IDENT (^(IDENT {$typeName += "." + $IDENT.text;} .*))+) .*)
+    |   ^(POINTER_TYPE ^(QUALIFIED_TYPE_IDENT (^(i1=IDENT {$typeName.add(new TypeName($i1.text));} .*))+) .*)
             { $POINTER_TYPE.scope = currentScope; }
     ;
 
+literal returns [String lit]
+@init {
+$lit = $start.getText().toString();
+}
+    :   HEX_LITERAL
+    |   OCTAL_LITERAL
+    |   DECIMAL_LITERAL
+    |   FLOATING_POINT_LITERAL
+    |   CHARACTER_LITERAL
+    |   STRING_LITERAL
+    |   TRUE
+    |   FALSE
+    |   NULL
+    ;
+
 classType
     :   CLASS
     |   CHARE
index 9abbb0498f1302e577cac8afda74a2d7fadf57c2..89b787aca2c7a6743371d4ceaa6afba794d11068 100644 (file)
@@ -9,6 +9,8 @@ options {
 
 @header {
 package charj.translator;
+
+import java.util.Iterator;
 }
 
 @members {
@@ -322,16 +324,39 @@ literal returns [Type type]
         }
     ;
 
+literalVal returns [Type type]
+@init { String lit = $start.getText().toString(); }
+@after { $start.symbolType = $type; }
+    :   (HEX_LITERAL | OCTAL_LITERAL | DECIMAL_LITERAL) {
+            $type = symtab.resolveBuiltinLitType("int", lit);
+        }
+    |   FLOATING_POINT_LITERAL {
+            $type = symtab.resolveBuiltinLitType("double", lit);
+        }
+    |   CHARACTER_LITERAL {
+            $type = symtab.resolveBuiltinLitType("char", lit);
+        }
+    |   STRING_LITERAL {
+            $type = symtab.resolveBuiltinLitType("string", lit);
+        }
+    |   (TRUE | FALSE) {
+            $type = symtab.resolveBuiltinLitType("boolean", lit);
+        }
+    |   NULL {
+            $type = symtab.resolveBuiltinLitType("null", lit);
+        }
+    ;
+
 type returns [Type sym]
 @init {
-    String typeText = "";
+    List<TypeName> typeText = new ArrayList<TypeName>();
+    List<Type> tparams = new ArrayList<Type>();
     CharjAST head = null;
     Scope scope = null;
     boolean proxy = false;
     boolean pointer = false;
 }
 @after {
-    typeText = typeText.substring(1);
     //System.out.println("\ntype string: " + typeText);
     //System.out.println("direct scope: " + scope);
     $start.symbolType = scope.resolveType(typeText);
@@ -339,10 +364,21 @@ type returns [Type sym]
     if (proxy && $start.symbolType != null) $start.symbolType = new ProxyType(symtab, $start.symbolType);
     if (pointer && $start.symbolType != null) $start.symbolType = new PointerType(symtab, $start.symbolType);
 
-    // TODO: Special case for Arrays, should be fixed
-    if (typeText.equals("Array") && $start.symbolType == null) {
-        System.out.println("found Array XXXX");
+    // TODO: Special case for Arrays, change this?
+    if (typeText != null && typeText.size() > 0 &&
+        typeText.get(0).name.equals("Array") && $start.symbolType == null) {
+
+        int numDims = 1;
+
         ClassSymbol cs = new ClassSymbol(symtab, "Array");
+        cs.templateArgs = typeText.get(0).parameters;
+
+        if (cs.templateArgs != null &&
+            cs.templateArgs.size() > 1) {
+            if (cs.templateArgs.get(1) instanceof LiteralType) {
+                numDims = Integer.valueOf(((LiteralType)cs.templateArgs.get(1)).literal);
+            }
+        }
         $start.symbolType = new PointerType(symtab, cs);
     }
 
@@ -351,20 +387,24 @@ type returns [Type sym]
 }
     :   VOID {
             scope = $VOID.scope;
-            typeText = ".void";
+            typeText.add(new TypeName("void"));
         }
     |   ^(SIMPLE_TYPE t=. {
             scope = $SIMPLE_TYPE.scope;
-            typeText += "." + $t.getText();
+            typeText.add(new TypeName($t.getText()));
         } .*)
     |   ^(OBJECT_TYPE { scope = $OBJECT_TYPE.scope; }
-            ^(QUALIFIED_TYPE_IDENT (^(IDENT {typeText += "." + $IDENT.text;} .*))+) .*)
+            ^(QUALIFIED_TYPE_IDENT (^(IDENT (^(TEMPLATE_INST
+                (t1=type {tparams.add($t1.sym);} | lit1=literalVal {tparams.add($lit1.type);} )*))?
+                {typeText.add(new TypeName($IDENT.text, tparams));}))+) .*)
     |   ^(REFERENCE_TYPE { scope = $REFERENCE_TYPE.scope; }
-            ^(QUALIFIED_TYPE_IDENT (^(IDENT  {typeText += "." + $IDENT.text;} .*))+) .*)
+            ^(QUALIFIED_TYPE_IDENT (^(IDENT  {typeText.add(new TypeName($IDENT.text));} .*))+) .*)
     |   ^(PROXY_TYPE { scope = $PROXY_TYPE.scope; proxy = true; }
-            ^(QUALIFIED_TYPE_IDENT (^(IDENT {typeText += "." + $IDENT.text;} .*))+) .*)
+            ^(QUALIFIED_TYPE_IDENT (^(IDENT {typeText.add(new TypeName($IDENT.text));} .*))+) .*)
     |   ^(POINTER_TYPE { scope = $POINTER_TYPE.scope; pointer = true; }
-            ^(QUALIFIED_TYPE_IDENT (^(IDENT {typeText += "." + $IDENT.text;} .*))+) .*)
+            ^(QUALIFIED_TYPE_IDENT (^(IDENT (^(TEMPLATE_INST
+            (t1=type {tparams.add($t1.sym);} | lit1=literalVal {tparams.add($lit1.type);} )*))?
+            {typeText.add(new TypeName($IDENT.text, tparams));}))+) .*)
     ;
 
 classType
index 72b8e84ed1bc5009d870348e55107281d8128fa5..409e5ddce2d2229ec4bc5d550944ec1105d32fae 100644 (file)
@@ -86,7 +86,23 @@ public class SymbolTable {
     public ClassSymbol resolveBuiltinType(String type) {
         ClassSymbol ptype = primitiveTypes.get(type);
         if (ptype != null) return ptype;
-        return (ClassSymbol)objectRoot.resolveType(type);
+        return (ClassSymbol)objectRoot.resolveType(TypeName.createTypeName(type));
+    }
+
+    public ClassSymbol resolveBuiltinLitType(String type, String literal) {
+        ClassSymbol ptype = primitiveTypes.get(type);
+        if (ptype != null) {
+            LiteralType t = new LiteralType(this, ptype);
+            t.literal = literal;
+            return (ClassSymbol)t;
+        }
+        return (ClassSymbol)objectRoot.resolveType(TypeName.createTypeName(type));
+    }
+
+    public ClassSymbol resolveBuiltinType(String type, String lit) {
+        ClassSymbol ptype = primitiveTypes.get(type);
+        if (ptype != null) return ptype;
+        return (ClassSymbol)objectRoot.resolveType(TypeName.createTypeName(type));
     }
 
     public ClassSymbol getEnclosingClass(Scope scope) {
index 011097308778579859458a6d618cf22583d26d2c..c2bc4ec2238b7d44e7ae98622c13e4efcd1d4bce 100644 (file)
@@ -2,6 +2,7 @@
 package charj.translator;
 
 import java.util.Map;
+import java.util.List;
 
 public abstract class SymbolWithScope 
     extends Symbol 
@@ -37,7 +38,7 @@ public abstract class SymbolWithScope
     /** Scopes other than package and class don't know how to resolve types
      *  (e.g., MethodSymbol).  Look to enclosing scope.
      */
-    public Type resolveType(String type) {
+    public Type resolveType(List<TypeName> type) {
         if ( getEnclosingScope()!=null ) {
             return getEnclosingScope().resolveType(type);
         }
index 9f8b210b437d1a47726d768057fc9a7f4ee7e017..6a543cc6d6c61fcc433b6e77cd8ffdda1d69d2e4 100644 (file)
@@ -79,6 +79,7 @@ public class Translator {
 
     public String translate(String filename) throws Exception {
         m_basename = filename.substring(0, filename.lastIndexOf("."));
+        m_basename = m_basename.substring(m_basename.lastIndexOf("/") + 1);
 
         ANTLRFileStream input = new ANTLRFileStream(filename);
             
diff --git a/src/langs/charj/src/charj/translator/TypeName.java b/src/langs/charj/src/charj/translator/TypeName.java
new file mode 100644 (file)
index 0000000..dfd9831
--- /dev/null
@@ -0,0 +1,54 @@
+
+package charj.translator;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+public class TypeName {
+    public String name;
+    public List<Type> parameters;
+
+    public TypeName(String _name, List<Type> _parameters) {
+        name = _name;
+        parameters = _parameters;
+    }
+
+    public TypeName(String _name) {
+        name = _name;
+        parameters = null;
+    }
+
+    public String toString() {
+        String params = "";
+        if (parameters != null) {
+            StringBuilder sb = new StringBuilder();
+            Iterator<Type> it = parameters.iterator();
+            while (it.hasNext()) {
+                sb.append(it.next().toString());
+                sb.append(",");
+            }
+            params = sb.toString();
+        }
+        return name + "<" + params + ">";
+    }
+
+    public static List<TypeName> createTypeName(String name) {
+        List<TypeName> list = new ArrayList<TypeName>();
+        list.add(new TypeName(name));
+        return list;
+    }
+
+    public static String typeToString(List<TypeName> type) {
+        if (type != null && type.size() != 0) {
+            StringBuilder sb = new StringBuilder();
+            Iterator<TypeName> it = type.iterator();
+            while (it.hasNext()) {
+                sb.append(it.next().toString());
+            }
+            return sb.toString();
+        } else {
+            return "";
+        }
+    }
+}
index 066b7b977d9ec16d6754281bdac6d47fad159b4d..163495ba33f2e5ff943b8e6633f315ace48c2b40 100644 (file)
@@ -11,7 +11,7 @@ import org.antlr.stringtemplate.language.AngleBracketTemplateLexer;
  *  reference of the AST to the emitter. 
  */
 public class VariableInitializer {
-    private CharjAST init;
+    public CharjAST init;
     private CharjAST ident;
 
     public VariableInitializer(CharjAST init_, CharjAST ident_) {
index a51344d0f3545af5385f80e375d6165d5820cb87..dd9aa7b4029ac574dbd54a5e53a26977937acaf4 100644 (file)
@@ -1,25 +1,56 @@
 
 public mainchare ArrayTest {
-      Array<int> test1 = new Array<int>([10]);
+  Array<int, 2> foobar = new Array<int, 2>([5, 3]);
 
-      public entry ArrayTest(CkArgMsg msg) {
-           thisProxy@entry1();
-      }
+  public entry ArrayTest(CkArgMsg msg) {
+    thisProxy@entry1();
+  }
+
+  public entry void entry1() {
+    Array<int> foo = new Array<int>([10]);
+
+    for (int i = 0; i < foo.size(); i++) {
+      foo[i] = i;
+    }
 
-      public entry void entry1() {
-           Array<int> test2 = new Array<int>([10]);
+    for (int i = 0; i < foo.size(); i++) {
+      printf("foo[%d]: %d\n", i, foo[i]);
+    }
 
-          for (int i = 0; i < test1.size(); i++) {
-               test1[i] = i;
-               test2[i] = i + 1;
-           }
+    delete foo;
 
-           for (int i = 0; i < test1.size(); i++) {
-                printf("%d %d\n", test1[i], test2[i]);
-           }
+    int dim1 = 2;
+    int dim2 = 3;
+    Array<int, 2> bar = new Array<int, 2>([dim1, dim2]);
 
-           delete test1;
+    for (int i = 0; i < dim1; i++) {
+      for (int j = 0; j < dim2; j++) {
+        bar[i, j] = i;
+      }
+    }
 
-           CkExit();
+    for (int i = 0; i < dim1; i++) {
+      for (int j = 0; j < dim2; j++) {
+        printf("bar[%d, %d]: %d\n", i, j, bar[i, j]);
       }
+    }
+
+    delete bar;
+
+    for (int i = 0; i < foobar.size(0); i++) {
+      for (int j = 0; j < foobar.size(1); j++) {
+        foobar[i, j] = 10 * i + j;
+      }
+    }
+
+    for (int i = 0; i < foobar.size(0); i++) {
+      for (int j = 0; j < foobar.size(1); j++) {
+        printf("foobar[%d, %d]: %d\n", i, j, foobar[i, j]);
+      }
+    }
+
+    delete foobar;
+
+    CkExit();
+  }
 }
index 456fed094f778e85ab83a79542ce6af7c0f9f65d..c24f3054de3c6ec56f9f903d106af3ee9c40cedc 100644 (file)
@@ -460,6 +460,9 @@ pup_c.o: pup_c.C $(CVHEADERS) $(UTILHEADERS)
 pup_paged.o: pup_paged.C $(CVHEADERS) $(UTILHEADERS)
        $(CHARMC) -o pup_paged.o pup_paged.C
 
+pup_f.f90: pup_f.f90.sh
+       ./pup_f.f90.sh
+
 pup_f.o: pup_f.f90 $(CVHEADERS)
        -$(CHARMC) -c pup_f.f90 && $(CHARMC) -cpmod ../include pupmod.M || touch pup_f.o
 
index ee82de3529d11547a86222ad94fa1e1264bc9a41..71ab253e41f13a7b1bdc0dea71308865b3b21f9a 100755 (executable)
@@ -1,3 +1,4 @@
+!     DON NOT EDIT THIS FILE, GENERATE IT FROM RUNNING pup_f.f90.sh
       module pupmod
       implicit none
       interface
index 83b8ee3a96a8bef864427a11429c97314d4156ce..ba5caad12a7965a041979f55c98586def066cfd3 100755 (executable)
@@ -4,6 +4,7 @@
 #  Used to avoid duplicate copy-and-paste codein pup_f.f90.
 
 cat > pup_f.f90 << END_OF_HEADER
+!     DON NOT EDIT THIS FILE, GENERATE IT FROM RUNNING pup_f.f90.sh
       module pupmod
       implicit none
       interface