Merged arrays into Charj mainline.
[charm.git] / src / langs / charj / src / charj / translator / ClassSymbol.java
index f5f228bebf2dbde655179a4fd5a4e651b88d777a..e4c727df5e46617f96700f839eac96cf705921e1 100644 (file)
@@ -12,28 +12,26 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
 
     public CharjAST constructor;
 
-    Map<String, PackageScope> imports = 
+    Map<String, PackageScope> imports =
         new LinkedHashMap<String, PackageScope>();
+    List<String> includes = new ArrayList<String>();
+    List<String> usings = new ArrayList<String>();
+    List<String> externs = new ArrayList<String>();
 
-    /** List of all fields and methods */
+    /** Record of all fields and methods */
     public Map<String, Symbol> members = new LinkedHashMap<String, Symbol>();
-    public Map<String, String> aliases = new LinkedHashMap<String, String>();
-
-    /** The set of method names (without signatures) for this class.  Maps
-     *  to a list of methods with same name but different args
-     protected Map<String, List<MethodSymbol>> methods =
-     new HashMap<String, List<MethodSymbol>>();
-     */
-
-    /** List of unmangled methods for this class. Used to distinguish
-     *  var from method name in expressions.  x = f; // what is f?
-     */
-    protected Set<String> methodNames = new HashSet<String>();
+    public Map<String, VariableSymbol> fields = new LinkedHashMap<String, VariableSymbol>();
+    public Map<String, MethodSymbol> methods = new LinkedHashMap<String, MethodSymbol>();
 
     public boolean hasCopyCtor = false;
+    public boolean isPrimitive = false;
+    public boolean isChare = false;
+    public boolean isMainChare = false;
+
+    public CharjAST migrationCtor = null;
 
     public ClassSymbol(
-            SymbolTable symtab, 
+            SymbolTable symtab,
             String name) {
         super(symtab, name);
         type = this;
@@ -45,7 +43,7 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
     }
 
     public ClassSymbol(
-            SymbolTable symtab, 
+            SymbolTable symtab,
             String name,
             ClassSymbol superClass,
             Scope scope) {
@@ -56,11 +54,23 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
        constructor = null;
 
         // manually add automatic class methods and symbols here
+        this.includes.add("charm++.h");
+        this.includes.add("list");
+        this.usings.add("std::list");
+        this.includes.add("string");
+        this.usings.add("std::string");
+        this.includes.add("vector");
+        this.usings.add("std::vector");
+        this.includes.add("map");
+        this.usings.add("std::map");
+        this.includes.add("iostream");
+        this.usings.add("std::cout");
+        this.usings.add("std::endl");
     }
 
     public Scope getEnclosingScope() {
         // at root?  Then use enclosing scope
-        if ( superClass==null ) { 
+        if ( superClass==null ) {
             return scope;
         }
         return superClass;
@@ -73,7 +83,7 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
     /** Importing a package means adding the package to list of "filters"
      *  used by resolvePackage.  The resolve operation can only see classes
      *  defined in the imported packages.  This method asks the sym tab if
-     *  it is known before looking at corresponding dir on disk to see if it 
+     *  it is known before looking at corresponding dir on disk to see if it
      *  exists.
      *
      *  Return null if this class is not in sym tab and was not found in path.
@@ -82,7 +92,7 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
         if (debug()) System.out.println(
                 "ClassSymbol.importPackage(" + packageName +
                 "): add to " + toString());
-        
+
         PackageScope p = symtab.resolvePackage(packageName);
         if ( p!=null ) {
             imports.put(packageName, p);
@@ -97,36 +107,11 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
         }
 
         if ( p==null && debug() ) System.out.println(
-                "ClassSymbol.importPackage(" + packageName + 
+                "ClassSymbol.importPackage(" + packageName +
                 "): dir not found");
         return p;
     }
 
-    public void alias(
-            CharjAST aliasAST, 
-            CharjAST methodNameAST) {
-        String op = aliasAST.getToken().getText();
-        op = op.substring(1,op.length()-1);
-        String method = methodNameAST.getToken().getText();
-        method = method.substring(1,method.length()-1);
-        alias(op, method);
-    }
-
-    public void alias(
-            String alias, 
-            String methodName) {
-        aliases.put(alias, methodName);
-    }
-
-    public String getMethodNameForOperator(String op) {
-        String name = aliases.get(op);
-        if ( name==null ) {
-            symtab.translator.error(
-                    "no such operator for " + this.name + ": " + op);
-        }
-        return name;
-    }
-
     /** Using the list of imports, resolve a package name like charj.lang.
      *  There may be many packages defined and visible to the symbol table
      *  but this class can only see those packages in the implicit or explicit
@@ -136,13 +121,13 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
         return imports.get(packageName);
     }
 
-    /** To resolve a type in a class, look it up in each imported package 
-     *  including the current package. Classes cannot be defined in the 
+    /** To resolve a type in a class, look it up in each imported package
+     *  including the current package. Classes cannot be defined in the
      *  superclass so don't look upwards for types.
      *
      *  First check to see if we are resolving enclosing class then
      *  look for type in each imported package.  If not found in existing
-     *  packges, walk through imported packages again, trying to load from 
+     *  packges, walk through imported packages again, trying to load from
      *  disk.
      */
     public ClassSymbol resolveType(String type) {
@@ -156,62 +141,59 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
 
         if ( name.equals(type) ) {
             if ( debug() ) System.out.println(
-                    "ClassSymbol.resolveType(" + type + 
+                    "ClassSymbol.resolveType(" + type +
                     "): surrounding class " + name + ":" + members.keySet());
             return this;
         }
 
         // look for type in classes already defined in imported packages
         for (String packageName : imports.keySet()) {
+            if ( debug() ) System.out.println( "Looking for type " +
+                    type + " in package " + packageName);
             PackageScope pkg = resolvePackage(packageName);
             ClassSymbol cs = pkg.resolveType(type);
             if ( cs != null) { // stop looking, found it
                 if ( debug() ) System.out.println(
-                        "ClassSymbol.resolveType(" + type + 
-                        "): found in context " + name + ":" + 
+                        "ClassSymbol.resolveType(" + type +
+                        "): found in context " + name + ":" +
                         members.keySet());
                 return cs;
             }
         }
 
         // not already seen in one of the imported packages, look on disk
-        for (String packageName : imports.keySet()) {
-            PackageScope pkg = resolvePackage(packageName);
-            ClassSymbol cs = symtab.translator.loadType(
-                    pkg.getFullyQualifiedName(), type);
-            if ( cs!=null ) {
-                pkg.define(type, cs); // add to symbol table
-                if ( debug() ) System.out.println(
-                        "ClassSymbol.resolveType(" + type +
-                        "): found after loading in context " + name +
-                        ":" + members.keySet());
-                return cs;
-            }
-        }
+        //for (String packageName : imports.keySet()) {
+        //    PackageScope pkg = resolvePackage(packageName);
+        //    ClassSymbol cs = symtab.translator.loadType(
+        //            pkg.getFullyQualifiedName(), type);
+        //    if ( cs!=null ) {
+        //        pkg.define(type, cs); // add to symbol table
+        //        if ( debug() ) System.out.println(
+        //                "ClassSymbol.resolveType(" + type +
+        //                "): found after loading in context " + name +
+        //                ":" + members.keySet());
+        //        return cs;
+        //    }
+        //}
 
         if ( debug() ) System.out.println(
-                "ClassSymbol.resolveType(" + type + 
+                "ClassSymbol.resolveType(" + type +
                 "): not in context " + name + ":" + members.keySet());
         return null;
     }
 
     public MethodSymbol resolveMethodLocally(
-            String name, 
+            String name,
             int numargs) {
-        if ( numargs>0 ) {
+        if (numargs > 0) {
             name += numargs;
         }
-     
-        Symbol s = members.get(name);
-        if ( s!=null && s.getClass() == MethodSymbol.class ) {
-            return (MethodSymbol)s;
-        }
 
-        return null;
+        return methods.get(name);
     }
 
     public boolean isMethod(String name) {
-        if ( methodNames.contains(name) ) {
+        if ( methods.containsKey(name) ) {
             return true;
         }
         if ( getEnclosingScope()!=null ) {
@@ -221,10 +203,16 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
     }
 
     public Symbol define(
-            String name, 
+            String name,
             Symbol sym) {
-        if ( sym instanceof MethodSymbol ) {
-            methodNames.add(sym.name);
+        if (sym == null) {
+            System.out.println("ClassSymbol.define: Uh oh, defining null symbol");
+        }
+        members.put(name, sym);
+        if (sym instanceof MethodSymbol) {
+            methods.put(name, (MethodSymbol)sym);
+        } else if (sym instanceof VariableSymbol) {
+            fields.put(name, (VariableSymbol)sym);
         }
         return super.define(name, sym);
     }
@@ -239,16 +227,73 @@ public class ClassSymbol extends SymbolWithScope implements Scope {
             parent = scope.getFullyQualifiedName();
         }
         if ( parent!=null ) {
-            return parent+"."+name;
+            return parent+"::"+name;
         }
         return name;
     }
 
-    public String getMangledName() {
-        if ( SymbolTable.TYPE_NAMES_TO_MANGLE.contains(name) ) {
-            return "m"+name;
+    public void addInclude(String includeName) {
+        includes.add(includeName);
+    }
+
+    public void addExtern(String externName) {
+        externs.add(externName);
+    }
+
+    public void getUsings(String usingName) {
+        usings.add(usingName);
+    }
+
+    public List<String> getIncludes()
+    {
+        return includes;
+    }
+
+    public List<String> getUsings()
+    {
+        return usings;
+    }
+
+    public List<String> getExterns()
+    {
+        return externs;
+    }
+
+    public List<String> getPackageNames()
+    {
+        List<String> list = new LinkedList<String>();
+        for(Scope currentScope = scope;
+                currentScope.getEnclosingScope() != null;
+                currentScope = currentScope.getEnclosingScope()) {
+            list.add(0, currentScope.getScopeName());
         }
-        return name;
+        return list;
+    }
+
+    private Set<ClassSymbol> getMemberTypes()
+    {
+        Set<ClassSymbol> types = new HashSet<ClassSymbol>();
+        for (Map.Entry<String, VariableSymbol> entry : fields.entrySet()) {
+            // note: type info may be null for unknown types, but this might
+            // need to be changed at some point.
+            ClassSymbol type = ((VariableSymbol)entry.getValue()).type;
+            if (type != null) types.add(type);
+        }
+        return types;
+    }
+
+    public List<String> getMemberTypeNames()
+    {
+        List<String> names = new ArrayList<String>();
+        for (ClassSymbol c : getMemberTypes()) {
+            if (c.isPrimitive) continue;
+            names.add(c.getName());
+        }
+        return names;
     }
 
+    public String getName()
+    {
+        return name;
+    }
 }