src/Pure/System/isabelle_tool.scala

 import java.net.URLClassLoader
 import scala.reflect.runtime.universe
 import scala.tools.reflect.{ToolBox, ToolBoxError}
 
 
-object Isabelle_Tool
-{
+object Isabelle_Tool {
   /* Scala source tools */
 
   abstract class Body extends Function[List[String], Unit]
 
-  private def compile(path: Path): Body =
-  {
+  private def compile(path: Path): Body = {
     def err(msg: String): Nothing =
       cat_error(msg, "The error(s) above occurred in Isabelle/Scala tool " + path)
 
     val source = File.read(path)
 

 
   /* external tools */
 
   private def dirs(): List[Path] = Path.split(Isabelle_System.getenv_strict("ISABELLE_TOOLS"))
 
-  private def is_external(dir: Path, file_name: String): Boolean =
-  {
+  private def is_external(dir: Path, file_name: String): Boolean = {
     val file = (dir + Path.explode(file_name)).file
     try {
       file.isFile && file.canRead &&
         (file_name.endsWith(".scala") || file.canExecute) &&
         !file_name.endsWith("~") && !file_name.endsWith(".orig")

   private def find_external(name: String): Option[List[String] => Unit] =
     dirs().collectFirst({
       case dir if is_external(dir, name + ".scala") =>
         compile(dir + Path.explode(name + ".scala"))
       case dir if is_external(dir, name) =>
-        (args: List[String]) =>
-          {
-            val tool = dir + Path.explode(name)
-            val result = Isabelle_System.bash(File.bash_path(tool) + " " + Bash.strings(args))
-            sys.exit(result.print_stdout.rc)
-          }
+        (args: List[String]) => {
+          val tool = dir + Path.explode(name)
+          val result = Isabelle_System.bash(File.bash_path(tool) + " " + Bash.strings(args))
+          sys.exit(result.print_stdout.rc)
+        }
     })
 
 
   /* internal tools */
 

       })
 
 
   /* list tools */
 
-  abstract class Entry
-  {
+  abstract class Entry {
     def name: String
     def position: Properties.T
     def description: String
     def print: String =
       description match {
         case "" => name
         case descr => name + " - " + descr
       }
   }
 
-  sealed case class External(name: String, path: Path) extends Entry
-  {
+  sealed case class External(name: String, path: Path) extends Entry {
     def position: Properties.T = Position.File(path.absolute.implode)
-    def description: String =
-    {
+    def description: String = {
       val Pattern = """.*\bDESCRIPTION: *(.*)""".r
       split_lines(File.read(path)).collectFirst({ case Pattern(s) => s }) getOrElse ""
     }
   }
 
-  def external_tools(): List[External] =
-  {
+  def external_tools(): List[External] = {
     for {
       dir <- dirs() if dir.is_dir
       file_name <- File.read_dir(dir) if is_external(dir, file_name)
     } yield {
       val path = dir + Path.explode(file_name)

   }
 
   def isabelle_tools(): List[Entry] =
     (external_tools() ::: internal_tools).sortBy(_.name)
 
-  object Isabelle_Tools extends Scala.Fun_String("isabelle_tools")
-  {
+  object Isabelle_Tools extends Scala.Fun_String("isabelle_tools") {
     val here = Scala_Project.here
     def apply(arg: String): String =
       if (arg.nonEmpty) error("Bad argument: " + quote(arg))
       else {
         val result = isabelle_tools().map(entry => (entry.name, entry.position))

   }
 
 
   /* command line entry point */
 
-  def main(args: Array[String]): Unit =
-  {
+  def main(args: Array[String]): Unit = {
     Command_Line.tool {
       args.toList match {
         case Nil | List("-?") =>
           val tool_descriptions = isabelle_tools().map(_.print)
           Getopts("""

 
 sealed case class Isabelle_Tool(
   name: String,
   description: String,
   here: Scala_Project.Here,
-  body: List[String] => Unit) extends Isabelle_Tool.Entry
-{
+  body: List[String] => Unit
+) extends Isabelle_Tool.Entry {
   def position: Position.T = here.position
 }
 
 class Isabelle_Scala_Tools(val tools: Isabelle_Tool*) extends Isabelle_System.Service