DynamicJava Test Coverage (dynamicjava-20130615-r5436)

Clover coverage report - DynamicJava Test Coverage (dynamicjava-20130615-r5436)

Coverage timestamp: Sat Jun 15 2013 03:01:32 CDT

FRAMES NO FRAMES

file stats:	LOC:	79		Methods:	6
	NCLOC:	55		Classes:	1

Source file

Conditionals

Statements

Methods

TOTAL

TreeClassLoader.java

50%

95%

100%

92.9%

1		package edu.rice.cs.dynamicjava.interpreter;
2
3		import java.util.Map;
4		import java.util.HashMap;
5		import edu.rice.cs.dynamicjava.Options;
6		import edu.rice.cs.dynamicjava.symbol.TreeClass;
7		import edu.rice.cs.plt.reflect.AbstractClassLoader;
8		import edu.rice.cs.plt.reflect.ShadowingClassLoader;
9		import edu.rice.cs.plt.reflect.ComposedClassLoader;
10		import edu.rice.cs.plt.iter.IterUtil;
11
12		/**
13		* A class loader with the additional ability of loading classes from their (type-checked)
14		* AST representations.
15		*/
16		public class TreeClassLoader extends AbstractClassLoader {
17
18		private final Options _opt;
19		// trees that have been declared but not yet loaded
20		private final Map<String, TreeClass> _registeredTrees;
21		private final Map<String, TreeCompiler.EvaluationAdapter> _adapters;
22
23	89	public TreeClassLoader(ClassLoader parent, Options opt) {
24	89	this(parent, opt, new HashMap<String, TreeClass>());
25		}
26
27	89	private TreeClassLoader(ClassLoader parent, Options opt, Map<String, TreeClass> registeredTrees) {
28	89	super(makeParent(parent, registeredTrees.keySet()));
29	89	_opt = opt;
30	89	_registeredTrees = registeredTrees;
31	89	_adapters = new HashMap<String, TreeCompiler.EvaluationAdapter>();
32		}
33
34	89	private static ClassLoader makeParent(ClassLoader p, Iterable<String> registeredNames) {
35		// Classes that must be loaded by the implementation's class loader
36		// (the compiled tree classes need to be able to refer to these classes
37		// and be talking about the ones that are loaded in the implementation code):
38	89	Iterable<String> includes =
39		IterUtil.make(Object.class.getName(),
40		String.class.getName(),
41		RuntimeBindings.class.getName(),
42		TreeClassLoader.class.getName(),
43		TreeCompiler.EvaluationAdapter.class.getName(),
44		TreeCompiler.BindingsFactory.class.getName());
45		// For maximum flexibility, we let p load bootstrap classes
46		// (except those listed above)
47	89	ClassLoader implementationLoader =
48		new ShadowingClassLoader(TreeClassLoader.class.getClassLoader(), false,
49		includes, true);
50		// Allow shadowing by hiding parent classes redefined here
51	89	ClassLoader parentLoader = new ShadowingClassLoader(p, true, registeredNames, true);
52	89	return new ComposedClassLoader(implementationLoader, parentLoader);
53		}
54
55	89	public void registerTree(TreeClass treeClass) {
56	89	_registeredTrees.put(treeClass.fullName(), treeClass);
57		}
58
59	35	protected Class<?> findClass(String name) throws ClassNotFoundException {
60	35	TreeClass treeClass = _registeredTrees.get(name);
61	0	if (treeClass == null) { throw new ClassNotFoundException(); }
62		else {
63	35	TreeCompiler compiler = new TreeCompiler(treeClass, _opt);
64	35	byte[] bytes = compiler.bytecode();
65	35	_adapters.put(name, compiler.evaluationAdapter());
66
67		// define package
68	35	definePackageForClass(name);
69
70	35	Class<?> result = defineClass(name, bytes, 0, bytes.length);
71	35	return result;
72		}
73		}
74
75	35	public TreeCompiler.EvaluationAdapter getAdapter(String className) {
76	35	return _adapters.get(className);
77		}
78
79		}