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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/* NSC -- new Scala compiler
* Copyright 2006-2009 LAMP/EPFL
* @author Lex Spoon
*/
// $Id$
package scala.tools.nsc
import java.io.{File, IOException}
import java.lang.{ClassNotFoundException, NoSuchMethodException}
import java.lang.reflect.InvocationTargetException
import java.net.URL
import util.ClassPath
/** An object that runs Scala code. It has three possible
* sources for the code to run: pre-compiled code, a script file,
* or interactive entry.
*/
object MainGenericRunner {
/** Append jars found in ${scala.home}/lib to
* a specified classpath. Also append "." if the
* input classpath is empty; otherwise do not.
*
* @param classpath
* @return ...
*/
private def addClasspathExtras(classpath: String): String = {
val scalaHome = Properties.scalaHome
val extraClassPath =
if (scalaHome eq null)
""
else {
def listDir(name:String):Array[File] = {
val libdir = new File(new File(scalaHome), name)
if (!libdir.exists || libdir.isFile)
Array()
else
libdir.listFiles
}
{
val filesInLib = listDir("lib")
val jarsInLib =
filesInLib.filter(f =>
f.isFile && f.getName.endsWith(".jar"))
jarsInLib.toList
} ::: {
val filesInClasses = listDir("classes")
val dirsInClasses =
filesInClasses.filter(f => f.isDirectory)
dirsInClasses.toList
}
}.mkString("", File.pathSeparator, "")
if (classpath == "")
extraClassPath + File.pathSeparator + "."
else
classpath + File.pathSeparator + extraClassPath
}
def main(args: Array[String]) {
def error(str: String) = Console.println(str)
val command = new GenericRunnerCommand(args.toList, error)
val settings = command.settings
def sampleCompiler = new Global(settings)
if (!command.ok) {
println(command.usageMsg)
println(sampleCompiler.pluginOptionsHelp)
return
}
settings.classpath.value =
addClasspathExtras(settings.classpath.value)
settings.defines.applyToCurrentJVM
if (settings.version.value) {
Console.println(
"Scala code runner " +
Properties.versionString + " -- " +
Properties.copyrightString)
return
}
if (command.shouldStopWithInfo) {
Console.println(command.getInfoMessage(sampleCompiler))
return
}
def exitSuccess : Nothing = exit(0)
def exitFailure : Nothing = exit(1)
def exitCond(b: Boolean) : Nothing = if(b) exitSuccess else exitFailure
def fileToURL(f: File): Option[URL] =
try { Some(f.toURL) }
catch { case e => Console.println(e); None }
def paths(str: String): List[URL] =
for (
file <- ClassPath.expandPath(str) map (new File(_)) if file.exists;
val url = fileToURL(file); if !url.isEmpty
) yield url.get
def jars(dirs: String): List[URL] =
for (
libdir <- ClassPath.expandPath(dirs) map (new File(_)) if libdir.isDirectory;
jarfile <- libdir.listFiles if jarfile.isFile && jarfile.getName.endsWith(".jar");
val url = fileToURL(jarfile); if !url.isEmpty
) yield url.get
def specToURL(spec: String): Option[URL] =
try { Some(new URL(spec)) }
catch { case e => Console.println(e); None }
def urls(specs: String): List[URL] =
if (specs == null || specs.length == 0) Nil
else for (
spec <- specs.split(" ").toList;
val url = specToURL(spec); if !url.isEmpty
) yield url.get
val classpath: List[URL] =
paths(settings.bootclasspath.value) :::
paths(settings.classpath.value) :::
jars(settings.extdirs.value) :::
urls(settings.Xcodebase.value)
command.thingToRun match {
case _ if settings.execute.value != "" =>
val fullArgs =
command.thingToRun.toList ::: command.arguments
exitCond(ScriptRunner.runCommand(settings,
settings.execute.value,
fullArgs))
case None =>
(new InterpreterLoop).main(settings)
case Some(thingToRun) =>
val isObjectName =
settings.howtorun.value match {
case "object" => true
case "script" => false
case "guess" =>
ObjectRunner.classExists(classpath, thingToRun)
}
if (isObjectName) {
try {
ObjectRunner.run(classpath, thingToRun, command.arguments)
} catch {
case e: ClassNotFoundException =>
Console.println(e)
exitFailure
case e: NoSuchMethodException =>
Console.println(e)
exitFailure
case e: InvocationTargetException =>
e.getCause.printStackTrace
exitFailure
}
} else {
try {
exitCond(ScriptRunner.runScript(settings,
thingToRun,
command.arguments))
} catch {
case e: IOException =>
Console.println(e.getMessage())
exitFailure
case e: SecurityException =>
Console.println(e)
exitFailure
}
}
}
}
}
|
