1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
/* NSC -- new Scala compiler
* Copyright 2005-2013 LAMP/EPFL
*/
package scala
package reflect.internal.util
import scala.collection.{ mutable, immutable }
import scala.reflect.io.{ AbstractFile, Streamable }
import java.net.{ URL, URLConnection, URLStreamHandler }
import java.security.cert.Certificate
import java.security.{ ProtectionDomain, CodeSource }
import java.util.{ Collections => JCollections, Enumeration => JEnumeration }
/** A class loader that loads files from a [[scala.reflect.io.AbstractFile]].
*
* @author Lex Spoon
*/
class AbstractFileClassLoader(val root: AbstractFile, parent: ClassLoader)
extends ClassLoader(parent)
with ScalaClassLoader
{
protected def classNameToPath(name: String): String =
if (name endsWith ".class") name
else s"${name.replace('.', '/')}.class"
protected def findAbstractFile(name: String): AbstractFile = {
var file: AbstractFile = root
val pathParts = name split '/'
for (dirPart <- pathParts.init) {
file = file.lookupName(dirPart, directory = true)
if (file == null)
return null
}
file.lookupName(pathParts.last, directory = false) match {
case null => null
case file => file
}
}
protected def dirNameToPath(name: String): String =
name.replace('.', '/')
protected def findAbstractDir(name: String): AbstractFile = {
var file: AbstractFile = root
val pathParts = dirNameToPath(name) split '/'
for (dirPart <- pathParts) {
file = file.lookupName(dirPart, directory = true)
if (file == null)
return null
}
file
}
override protected def findClass(name: String): Class[_] = {
val bytes = classBytes(name)
if (bytes.length == 0)
throw new ClassNotFoundException(name)
else
defineClass(name, bytes, 0, bytes.length, protectionDomain)
}
override protected def findResource(name: String): URL = findAbstractFile(name) match {
case null => null
case file => new URL(null, s"memory:${file.path}", new URLStreamHandler {
override def openConnection(url: URL): URLConnection = new URLConnection(url) {
override def connect() = ()
override def getInputStream = file.input
}
})
}
override protected def findResources(name: String): JEnumeration[URL] = findResource(name) match {
case null => JCollections.enumeration(JCollections.emptyList[URL]) //JCollections.emptyEnumeration[URL]
case url => JCollections.enumeration(JCollections.singleton(url))
}
lazy val protectionDomain = {
val cl = Thread.currentThread().getContextClassLoader()
val resource = cl.getResource("scala/runtime/package.class")
if (resource == null || resource.getProtocol != "jar") null else {
val s = resource.getPath
val n = s.lastIndexOf('!')
if (n < 0) null else {
val path = s.substring(0, n)
new ProtectionDomain(new CodeSource(new URL(path), null.asInstanceOf[Array[Certificate]]), null, this, null)
}
}
}
private val packages = mutable.Map[String, Package]()
override def definePackage(name: String, specTitle: String, specVersion: String, specVendor: String, implTitle: String, implVersion: String, implVendor: String, sealBase: URL): Package = {
throw new UnsupportedOperationException()
}
override def getPackage(name: String): Package = findAbstractDir(name) match {
case null => super.getPackage(name)
case file => packages.getOrElseUpdate(name, {
val ctor = classOf[Package].getDeclaredConstructor(classOf[String], classOf[String], classOf[String], classOf[String], classOf[String], classOf[String], classOf[String], classOf[URL], classOf[ClassLoader])
ctor.setAccessible(true)
ctor.newInstance(name, null, null, null, null, null, null, null, this)
})
}
override def getPackages(): Array[Package] =
root.iterator.filter(_.isDirectory).map(dir => getPackage(dir.name)).toArray
}
|
