bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/runtime/ExpressionClassLoader.java

   1 package org.simantics.scl.compiler.runtime;
   2
   3 import java.util.Map;
   4
   5 import org.simantics.scl.compiler.constants.Constant;
   6
   7 import gnu.trove.map.hash.THashMap;
   8
   9 public class ExpressionClassLoader extends ClassLoader implements MutableClassLoader {
  10     public static final boolean VALIDATE_CLASS_NAMES = true;
  11     public static final boolean TRACE_CLASS_CREATION = false;
  12
  13     String basePackageName;
  14     THashMap<String, byte[]> localClasses = new THashMap<String, byte[]>();
  15     THashMap<String, RuntimeModule> runtimeModuleMap;
  16     int transientPackageId = 0;
  17     THashMap<Constant,Object> valueCache = new THashMap<Constant,Object>();
  18
  19     public ExpressionClassLoader(ClassLoader parent, THashMap<String, RuntimeModule> runtimeModuleMap, String basePackageName) {
  20         super(parent);
  21         this.basePackageName = basePackageName;
  22         this.runtimeModuleMap = runtimeModuleMap;
  23     }
  24
  25     public synchronized void addClass(String name, byte[] class_) {
  26         if(TRACE_CLASS_CREATION)
  27             System.out.println("addClass " + name + " (" + class_.length + " bytes)");
  28         if(VALIDATE_CLASS_NAMES)
  29             validateClassName(name);
  30         localClasses.put(name, class_);
  31     }
  32
  33     public synchronized void addClasses(Map<String, byte[]> classes) {
  34         if(TRACE_CLASS_CREATION)
  35             for(String name : classes.keySet())
  36                 System.out.println("addClass " + name + " (" + classes.get(name).length + " bytes)");
  37         if(VALIDATE_CLASS_NAMES)
  38             for(String name : classes.keySet())
  39                 validateClassName(name);
  40         localClasses.putAll(classes);
  41     }
  42
  43     private void validateClassName(String name) {
  44         /*if(!name.startsWith(SCL_PACKAGE_PREFIX) || !extractClassLoaderId(name).equals(basePackageName))
  45             throw new IllegalArgumentException("Class name " + name + " does not start with '" +
  46                     SCL_PACKAGE_PREFIX + basePackageName + "$'.");*/
  47     }
  48
  49     private synchronized Class<?> getLocalClass(String name) throws ClassNotFoundException {
  50         // Is class already loaded
  51         Class<?> clazz = findLoadedClass(name);
  52         if(clazz != null)
  53             return clazz;
  54
  55         // If we have bytecode for it, let's define the class
  56         byte[] bytes = localClasses.get(name.replace('.', '/'));
  57         if(bytes == null)
  58             throw new ClassNotFoundException(name);
  59
  60         return defineClass(name, bytes, 0, bytes.length);
  61     }
  62
  63     @Override
  64     public byte[] getBytes(String name) {
  65         // Non-SCL classes are not handled here
  66         if(!name.startsWith(SCL_PACKAGE_PREFIX))
  67             return null;
  68
  69         // Determine the id of the class loader which is responsible of the class
  70         String requestedModuleName = RuntimeModule.extractClassLoaderId(name);
  71
  72         // Is class defined locally in this class loader?
  73         if(requestedModuleName.equals(basePackageName)) {
  74             String internalName = name.replace('.', '/');
  75             byte[] bytes = localClasses.get(internalName);
  76             if(bytes != null)
  77                 return bytes;
  78             return localClasses.get(internalName);
  79         }
  80
  81         // Find suitable class loader that has this class locally
  82         {
  83             RuntimeModule parentModule = runtimeModuleMap.get(requestedModuleName);
  84             if(parentModule == null)
  85                 return null;
  86
  87             // Find the class from the ancestor class loader
  88             return parentModule.classLoader.getBytes(name);
  89         }
  90     }
  91
  92     private Class<?> getClass(String name) throws ClassNotFoundException {
  93         //System.out.println("getClass " + name);
  94
  95         // If the class is not generated from SCL, use parent class loader
  96         if(!name.startsWith(SCL_PACKAGE_PREFIX)) {
  97             try {
  98                 return getParent().loadClass(name);
  99             } catch(ClassNotFoundException e) {
 100                 for(RuntimeModule module : runtimeModuleMap.values())
 101                     try {
 102                         return module.classLoader.getParent().loadClass(name);
 103                     } catch(ClassNotFoundException e2) {
 104                     }
 105             }
 106             throw new ClassNotFoundException(name);
 107         }
 108
 109         // Determine the id of the class loader which is responsible of the class
 110         String requestedModuleName = RuntimeModule.extractClassLoaderId(name);
 111
 112         // Is class defined locally in this class loader?
 113         if(requestedModuleName.equals(basePackageName))
 114             return getLocalClass(name);
 115
 116         // Find suitable class loader that has this class locally
 117         else {
 118             RuntimeModule parentModule = runtimeModuleMap.get(requestedModuleName);
 119             if(parentModule == null)
 120                 throw new ClassNotFoundException(name);
 121
 122             // Find the class from the ancestor class loader
 123             return parentModule.classLoader.getLocalClass(name);
 124         }
 125     }
 126
 127     @Override
 128     public synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
 129         Class<?> clazz = getClass(name);
 130         if (resolve)
 131             resolveClass(clazz);
 132         return clazz;
 133     }
 134
 135     public synchronized String getFreshPackageName() {
 136         return basePackageName + "$" + (++transientPackageId);
 137     }
 138
 139     @Override
 140     public THashMap<Constant, Object> getConstantCache() {
 141         return valueCache;
 142     }
 143
 144     @Override
 145     public ClassLoader getClassLoader() {
 146         return this;
 147     }
 148 }