src/Pure/System/scala.scala
changeset 75443 d6f2fbdc6322
parent 75442 d5041b68a237
child 75444 331f96a67924
equal deleted inserted replaced
75442:d5041b68a237 75443:d6f2fbdc6322
    78       elems = System.getProperty(prop, "") if elems.nonEmpty
    78       elems = System.getProperty(prop, "") if elems.nonEmpty
    79       elem <- space_explode(JFile.pathSeparatorChar, elems) if elem.nonEmpty
    79       elem <- space_explode(JFile.pathSeparatorChar, elems) if elem.nonEmpty
    80     } yield elem
    80     } yield elem
    81 
    81 
    82   object Compiler {
    82   object Compiler {
       
    83     def default_print_writer: PrintWriter =
       
    84       new NewLinePrintWriter(new ConsoleWriter, true)
       
    85 
    83     def context(
    86     def context(
       
    87       print_writer: PrintWriter = default_print_writer,
    84       error: String => Unit = Exn.error,
    88       error: String => Unit = Exn.error,
    85       jar_dirs: List[JFile] = Nil,
    89       jar_dirs: List[JFile] = Nil,
    86       class_loader: Option[ClassLoader] = None
    90       class_loader: Option[ClassLoader] = None
    87     ): Context = {
    91     ): Context = {
    88       def find_jars(dir: JFile): List[String] =
    92       def find_jars(dir: JFile): List[String] =
    91 
    95 
    92       val settings = new GenericRunnerSettings(error)
    96       val settings = new GenericRunnerSettings(error)
    93       settings.classpath.value =
    97       settings.classpath.value =
    94         (class_path() ::: jar_dirs.flatMap(find_jars)).mkString(JFile.pathSeparator)
    98         (class_path() ::: jar_dirs.flatMap(find_jars)).mkString(JFile.pathSeparator)
    95 
    99 
    96       new Context(settings, class_loader)
   100       new Context(settings, print_writer, class_loader)
    97     }
   101     }
    98 
       
    99     def default_print_writer: PrintWriter =
       
   100       new NewLinePrintWriter(new ConsoleWriter, true)
       
   101 
   102 
   102     class Context private [Compiler](
   103     class Context private [Compiler](
   103       val settings: GenericRunnerSettings,
   104       val settings: GenericRunnerSettings,
       
   105       val print_writer: PrintWriter,
   104       val class_loader: Option[ClassLoader]
   106       val class_loader: Option[ClassLoader]
   105     ) {
   107     ) {
   106       override def toString: String = settings.toString
   108       override def toString: String = settings.toString
   107 
   109 
   108       def interpreter(print_writer: PrintWriter = default_print_writer): IMain = {
   110       val interp: IMain =
   109         new IMain(settings, new ReplReporterImpl(settings, print_writer)) {
   111         new IMain(settings, new ReplReporterImpl(settings, print_writer)) {
   110           override def parentClassLoader: ClassLoader =
   112           override def parentClassLoader: ClassLoader =
   111             class_loader getOrElse super.parentClassLoader
   113             class_loader getOrElse super.parentClassLoader
   112         }
   114         }
   113       }
   115     }
   114 
   116 
   115       def toplevel(interpret: Boolean, source: String): List[String] = {
   117     def toplevel(interpret: Boolean, source: String): List[String] = {
   116         val out = new StringWriter
   118       val out = new StringWriter
   117         val interp = interpreter(new PrintWriter(out))
   119       val interp = Compiler.context(print_writer = new PrintWriter(out)).interp
   118         val marker = '\u000b'
   120       val marker = '\u000b'
   119         val ok =
   121       val ok =
   120           interp.withLabel(marker.toString) {
   122         interp.withLabel(marker.toString) {
   121             if (interpret) interp.interpret(source) == Results.Success
   123           if (interpret) interp.interpret(source) == Results.Success
   122             else (new interp.ReadEvalPrint).compile(source)
   124           else (new interp.ReadEvalPrint).compile(source)
   123           }
   125         }
   124         out.close()
   126       out.close()
   125 
   127 
   126         val Error = """(?s)^\S* error: (.*)$""".r
   128       val Error = """(?s)^\S* error: (.*)$""".r
   127         val errors =
   129       val errors =
   128           space_explode(marker, Library.strip_ansi_color(out.toString)).
   130         space_explode(marker, Library.strip_ansi_color(out.toString)).
   129             collect({ case Error(msg) => "Scala error: " + Library.trim_line(msg) })
   131           collect({ case Error(msg) => "Scala error: " + Library.trim_line(msg) })
   130 
   132 
   131         if (!ok && errors.isEmpty) List("Error") else errors
   133       if (!ok && errors.isEmpty) List("Error") else errors
   132       }
       
   133     }
   134     }
   134   }
   135   }
   135 
   136 
   136   object Toplevel extends Fun_String("scala_toplevel") {
   137   object Toplevel extends Fun_String("scala_toplevel") {
   137     val here = Scala_Project.here
   138     val here = Scala_Project.here
   141           case Nil => (false, "")
   142           case Nil => (false, "")
   142           case List(XML.Text(source)) => (false, source)
   143           case List(XML.Text(source)) => (false, source)
   143           case body => import XML.Decode._; pair(bool, string)(body)
   144           case body => import XML.Decode._; pair(bool, string)(body)
   144         }
   145         }
   145       val errors =
   146       val errors =
   146         try { Compiler.context().toplevel(interpret, source) }
   147         try { Compiler.toplevel(interpret, source) }
   147         catch { case ERROR(msg) => List(msg) }
   148         catch { case ERROR(msg) => List(msg) }
   148       locally { import XML.Encode._; YXML.string_of_body(list(string)(errors)) }
   149       locally { import XML.Encode._; YXML.string_of_body(list(string)(errors)) }
   149     }
   150     }
   150   }
   151   }
   151 
   152