/* sbt -- Simple Build Tool
 * Copyright 2008 Mark Harrah
 */
package sbt

abstract class class CompilerCore extends java.lang.Object with ScalaObjectCompilerCore
{
	val java.lang.StringClasspathOptionString = java.lang.String("-classpath")"-classpath"
	val java.lang.StringOutputOptionString = java.lang.String("-d")"-d"
	
	// Returns false if there were errors, true if there were not.
	protected def (List[String],sbt.Logger)Booleanprocess(List[String]args: List[String]List[String], sbt.Loggerlog: sbt.LoggerLogger): BooleanBoolean
	// Returns false if there were errors, true if there were not.
	protected def (List[String],sbt.Logger)BooleanprocessJava(List[String]args: List[String]List[String], sbt.Loggerlog: sbt.LoggerLogger): BooleanBoolean = Boolean(true)true
	def (String)StringactionStartMessage(Stringlabel: StringString): StringString
	def => StringactionNothingToDoMessage: StringString
	def => StringactionSuccessfulMessage: StringString
	def => StringactionUnsuccessfulMessage: StringString

	final def (String,Iterable[sbt.Path],String,sbt.Path,Iterable[String],sbt.Logger)Option[String]apply(Stringlabel: StringString, Iterable[sbt.Path]sources: Iterable[sbt.Path]Iterable[Path], StringclasspathString: StringString, sbt.PathoutputDirectory: sbt.PathPath, Iterable[String]options: Iterable[String]Iterable[String], sbt.Loggerlog: sbt.LoggerLogger) =
	{
		sbt.Loggerlog.(=> String)Unitinfo((String)StringactionStartMessage(Stringlabel))
		val List[String]classpathOption: List[String]List[String] =
			List[String]if(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringclasspathString.=> BooleanisEmpty)
				object NilNil
			else
				(String*)List[String]List(=> java.lang.StringClasspathOptionString, StringclasspathString)
		val java.io.FileoutputDir = sbt.PathoutputDirectory.=> java.io.FileasFile
		object sbt.FileUtilitiesFileUtilities.(java.io.File,sbt.Logger)Option[String]createDirectory(java.io.FileoutputDir, sbt.Loggerlog) (=> Option[String])Option[String]orElse
		{
			val List[String]classpathAndOut: List[String]List[String] = => java.lang.StringOutputOptionString (String)List[String]:: java.io.FileoutputDir.()java.lang.StringgetAbsolutePath (String)List[String]:: List[String]classpathOption
			
			object sbt.ControlControl.(=> String,sbt.Logger)(=> Option[String])Option[String]trapUnit(java.lang.String("Compiler error: ")"Compiler error: ", sbt.Loggerlog)
			{
				val List[java.lang.String]sourceList = Iterable[sbt.Path]sources.((sbt.Path) => java.lang.String)Iterable[java.lang.String]map(sbt.Path_.=> java.io.FileasFile.()java.lang.StringgetAbsolutePath).=> List[java.lang.String]toList
				Option[String]if(List[java.lang.String]sourceList.=> BooleanisEmpty)
				{
					sbt.Loggerlog.(=> String)Unitinfo(=> StringactionNothingToDoMessage)
					object NoneNone
				}
				else
				{
					val List[String]arguments = (Iterable[String]options (Iterable[String])Collection[String]++ List[String]classpathAndOut (Iterable[String])Collection[String]++ List[java.lang.String]sourceList).=> List[String]toList
					sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Scala arguments: ")"Scala arguments: " (Any)java.lang.String+ List[String]arguments.(String)StringmkString(java.lang.String(" ")" "))
					Option[String]if((List[String],sbt.Logger)Booleanprocess(List[String]arguments, sbt.Loggerlog))
					{
						val List[java.lang.String]javaSourceList = List[java.lang.String]sourceList.((java.lang.String) => Boolean)List[java.lang.String]filter(java.lang.String_.(java.lang.String)BooleanendsWith(java.lang.String(".java")".java"))
						Option[String]if(List[java.lang.String]javaSourceList.=> BooleanisEmpty)
							(sbt.Logger)object Nonesuccess(sbt.Loggerlog)
						else
						{
							val List[java.lang.String]javaArguments = List[String]classpathAndOut (List[java.lang.String])List[java.lang.String]::: List[java.lang.String]javaSourceList
							sbt.Loggerlog.(=> String)Unitdebug(java.lang.String("Java arguments: ")"Java arguments: " (Any)java.lang.String+ List[java.lang.String]javaArguments.(String)StringmkString(java.lang.String(" ")" "))
							Option[String]if((List[String],sbt.Logger)BooleanprocessJava(List[java.lang.String]javaArguments, sbt.Loggerlog))
								(sbt.Logger)object Nonesuccess(sbt.Loggerlog)
							else
								=> Some[String]failure
						}
					}
					else
						=> Some[String]failure
				}
			}
		}
	}
	private def (sbt.Logger)object Nonesuccess(sbt.Loggerlog: sbt.LoggerLogger) =
	{
		sbt.Loggerlog.(=> String)Unitinfo(=> StringactionSuccessfulMessage)
		object NoneNone
	}
	private def => Some[String]failure = (String)Some[String]Some(=> StringactionUnsuccessfulMessage)
}
// The following code is based on scala.tools.nsc.Main and scala.tools.nsc.ScalaDoc
// Copyright 2005-2008 LAMP/EPFL
// Original author: Martin Odersky
	
object object sbt.CompileCompile extends sbt.CompilerCoreCompilerCore
{
	protected def (List[String],sbt.Logger)Booleanprocess(List[String]arguments: List[String]List[String], sbt.Loggerlog: sbt.LoggerLogger) =
	{
		import scala.tools.nsc.{CompilerCommand, FatalError, Global, Settings, reporters, util}
		import util.FakePos
		var sbt.LoggerReporterreporter = sbt.LoggerReporternew sbt.LoggerReporterLoggerReporter(sbt.Loggerlog)
		val scala.tools.nsc.Settingssettings = scala.tools.nsc.Settingsnew scala.tools.nsc.SettingsSettings(sbt.LoggerReporterreporter.(String)Uniterror)
		val scala.tools.nsc.CompilerCommandcommand = (List[String],scala.tools.nsc.Settings,(String) => Unit,Boolean)scala.tools.nsc.CompilerCommandnew scala.tools.nsc.CompilerCommandCompilerCommand(List[String]arguments, scala.tools.nsc.Settingssettings, (String)Nothingerror, Boolean(false)false)
		
		object object compilercompiler extends scala.tools.nsc.GlobalGlobal(scala.tools.nsc.CompilerCommandcommand.=> scala.tools.nsc.Settingssettings, sbt.LoggerReporterreporter)
		Unitif(=> Boolean!sbt.LoggerReporterreporter.=> BooleanhasErrors)
		{
			val compiler.Runrun = compiler.Runnew object compilercompiler.compiler.RunRun
			compiler.Runrun (List[String])Unitcompile scala.tools.nsc.CompilerCommandcommand.=> List[String]files
			sbt.LoggerReporterreporter.()UnitprintSummary()
		}
		=> Boolean!sbt.LoggerReporterreporter.=> BooleanhasErrors
	}
	override protected def (List[String],sbt.Logger)BooleanprocessJava(List[String]args: List[String]List[String], sbt.Loggerlog: sbt.LoggerLogger): BooleanBoolean =
	{
		val sbt.ProcessRunnerprocess = ((String,Seq[String])sbt.ProcessRunnernew sbt.ProcessRunnerProcessRunner(java.lang.String("javac")"javac", List[String]args) ).(sbt.Logger)sbt.ProcessRunnerlogIO(sbt.Loggerlog)
		sbt.ProcessRunnerprocess.=> sbt.SProcessrun.()IntexitValue (Int)Boolean== Int(0)0
	}
	def (String)java.lang.StringactionStartMessage(Stringlabel: StringString) = java.lang.String("Compiling ")"Compiling " (Any)java.lang.String+ Stringlabel (Any)java.lang.String+ java.lang.String(" sources...")" sources..."
	val java.lang.StringactionNothingToDoMessage = java.lang.String("Nothing to compile.")"Nothing to compile."
	val java.lang.StringactionSuccessfulMessage = java.lang.String("Compilation successful.")"Compilation successful."
	val java.lang.StringactionUnsuccessfulMessage = java.lang.String("Compilation unsuccessful.")"Compilation unsuccessful."
}
object object sbt.ScaladocScaladoc extends sbt.CompilerCoreCompilerCore
{
	protected def (List[String],sbt.Logger)Booleanprocess(List[String]arguments: List[String]List[String], sbt.Loggerlog: sbt.LoggerLogger) =
	{
		import scala.tools.nsc.{doc, CompilerCommand, FatalError, Global, reporters, util}
		import util.FakePos
		val sbt.LoggerReporterreporter = sbt.LoggerReporternew sbt.LoggerReporterLoggerReporter(sbt.Loggerlog)
		val scala.tools.nsc.doc.SettingsdocSettings: doc.scala.tools.nsc.doc.SettingsSettings = scala.tools.nsc.doc.Settingsnew doc.scala.tools.nsc.doc.SettingsSettings(sbt.LoggerReporterreporter.(String)Uniterror)
		val scala.tools.nsc.CompilerCommandcommand = (List[String],scala.tools.nsc.Settings,(String) => Unit,Boolean)scala.tools.nsc.CompilerCommandnew scala.tools.nsc.CompilerCommandCompilerCommand(List[String]arguments, scala.tools.nsc.doc.SettingsdocSettings, (String)Nothingerror, Boolean(false)false)
		object object compilercompiler extends scala.tools.nsc.GlobalGlobal(scala.tools.nsc.CompilerCommandcommand.=> scala.tools.nsc.Settingssettings, sbt.LoggerReporterreporter)
		{
			override val BooleanonlyPresentation = Boolean(true)true
		}
		Unitif(=> Boolean!sbt.LoggerReporterreporter.=> BooleanhasErrors)
		{
			val compiler.Runrun = compiler.Runnew object compilercompiler.compiler.RunRun
			compiler.Runrun (List[String])Unitcompile scala.tools.nsc.CompilerCommandcommand.=> List[String]files
			val <refinement> extends scala.tools.nsc.doc.DefaultDocDrivergenerator = template $anon extends scala.tools.nsc.doc.DefaultDocDrivernew doc.scala.tools.nsc.doc.DefaultDocDriverDefaultDocDriver
			{
				lazy val compiler.typeglobal: compiler.type = object compilercompiler
				lazy val scala.tools.nsc.doc.Settingssettings = scala.tools.nsc.doc.SettingsdocSettings
			}
			<refinement> extends scala.tools.nsc.doc.DefaultDocDrivergenerator.(Iterator[generator.global.CompilationUnit])Unitprocess(compiler.Runrun.=> Iterator[compiler.CompilationUnit]units)
			sbt.LoggerReporterreporter.()UnitprintSummary()
		}
		=> Boolean!sbt.LoggerReporterreporter.=> BooleanhasErrors
	}
	def (String)java.lang.StringactionStartMessage(Stringlabel: StringString) = java.lang.String("Generating API documentation for ")"Generating API documentation for " (Any)java.lang.String+ Stringlabel (Any)java.lang.String+ java.lang.String(" sources...")" sources..."
	val java.lang.StringactionNothingToDoMessage = java.lang.String("No sources specified.")"No sources specified."
	val java.lang.StringactionSuccessfulMessage = java.lang.String("API documentation generation successful.")"API documentation generation successful."
	def => java.lang.StringactionUnsuccessfulMessage = java.lang.String("API documentation generation unsuccessful.")"API documentation generation unsuccessful."
}

// The following code is based on scala.tools.nsc.reporters.{AbstractReporter, ConsoleReporter}
// Copyright 2002-2008 LAMP/EPFL
// Original author: Martin Odersky
class class LoggerReporter extends scala.tools.nsc.reporters.Reporter with ScalaObjectLoggerReporter(sbt.Loggerlog: sbt.LoggerLogger) extends scala.tools.nsc.reporters.scala.tools.nsc.reporters.ReporterReporter
{
	import scala.tools.nsc.util.{FakePos,Position}
	private val scala.collection.mutable.HashMap[scala.tools.nsc.util.Position,LoggerReporter.this.Severity]positions = scala.collection.mutable.HashMap[scala.tools.nsc.util.Position,LoggerReporter.this.Severity]new scala.collection.mutable.scala.collection.mutable.HashMap[scala.tools.nsc.util.Position,LoggerReporter.this.Severity]HashMap[Position, Severity]
	
	def (String)Uniterror(Stringmsg: StringString) { (scala.tools.nsc.util.Position,String)Uniterror((String)scala.tools.nsc.util.FakePosFakePos(java.lang.String("scalac")"scalac"), Stringmsg) }

	def ()UnitprintSummary()
	{
		Unitif(=> LoggerReporter.this.SeverityWARNING.=> Intcount (Int)Boolean> Int(0)0)
			sbt.Loggerlog.(=> String)Unitwarn((Int,String)StringcountElementsAsString(=> LoggerReporter.this.SeverityWARNING.=> Intcount, java.lang.String("warning")"warning") (Any)java.lang.String+ java.lang.String(" found")" found")
		Unitif(=> LoggerReporter.this.SeverityERROR.=> Intcount (Int)Boolean> Int(0)0)
			sbt.Loggerlog.(=> String)Uniterror((Int,String)StringcountElementsAsString(=> LoggerReporter.this.SeverityERROR.=> Intcount, java.lang.String("error")"error") (Any)java.lang.String+ java.lang.String(" found")" found")
	}
	
	def (scala.tools.nsc.util.Position,String,LoggerReporter.this.Severity)Unitdisplay(scala.tools.nsc.util.Positionpos: scala.tools.nsc.util.PositionPosition, Stringmsg: StringString, LoggerReporter.this.Severityseverity: LoggerReporter.this.SeveritySeverity)
	{
		LoggerReporter.this.Severityseverity.(Int)Unitcount (Int)Int+= Int(1)1
		Unitif(LoggerReporter.this.Severityseverity (AnyRef)Boolean!= => LoggerReporter.this.SeverityERROR (Boolean)Boolean|| LoggerReporter.this.Severityseverity.=> Intcount (Int)Boolean<= object sbt.LoggerReporterLoggerReporter.=> IntErrorLimit)
			(sbt.Level.Value,scala.tools.nsc.util.Position,String)Unitprint((LoggerReporter.this.Severity)sbt.Level.ValueseverityToLevel(LoggerReporter.this.Severityseverity), scala.tools.nsc.util.Positionpos, Stringmsg)
	}
	private def (LoggerReporter.this.Severity)sbt.Level.ValueseverityToLevel(LoggerReporter.this.Severityseverity: LoggerReporter.this.SeveritySeverity): Level.sbt.Level.ValueValue =
		LoggerReporter.this.Severityseverity sbt.Level.Valuematch
		{
			sbt.Level.Valuecase => LoggerReporter.this.SeverityERROR => object sbt.LevelLevel.=> sbt.Level.ValueError
			sbt.Level.Valuecase => LoggerReporter.this.SeverityWARNING => object sbt.LevelLevel.=> sbt.Level.ValueWarn
			sbt.Level.Valuecase => LoggerReporter.this.SeverityINFO => object sbt.LevelLevel.=> sbt.Level.ValueInfo
		}
	
	private def (sbt.Level.Value,scala.tools.nsc.util.Position,String)Unitprint(sbt.Level.Valuelevel: Level.sbt.Level.ValueValue, scala.tools.nsc.util.PositionposIn: scala.tools.nsc.util.PositionPosition, Stringmsg: StringString)
	{
		Unitif(scala.tools.nsc.util.PositionposIn (AnyRef)Boolean== Null(null)null)
			sbt.Loggerlog.(sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel, Stringmsg)
		else
		{
			val scala.tools.nsc.util.Positionpos = scala.tools.nsc.util.PositionposIn.(scala.tools.nsc.util.SourceFile)scala.tools.nsc.util.PositioninUltimateSource(scala.tools.nsc.util.PositionposIn.=> Option[scala.tools.nsc.util.SourceFile]source.(=> scala.tools.nsc.util.SourceFile)scala.tools.nsc.util.SourceFilegetOrElse(Null(null)null))
			def => java.lang.Stringmessage =
			{
				val java.lang.StringsourcePrefix =
					scala.tools.nsc.util.Positionpos java.lang.Stringmatch
					{
						java.lang.Stringcase FakePos(Stringmsg) => Stringmsg (Any)java.lang.String+ java.lang.String(" ")" "
						Stringcase _ => scala.tools.nsc.util.Positionpos.=> Option[scala.tools.nsc.util.SourceFile]source.((scala.tools.nsc.util.SourceFile) => String)Option[String]map(scala.tools.nsc.util.SourceFile_.=> scala.tools.nsc.io.AbstractFilefile.=> Stringpath).(=> String)StringgetOrElse(java.lang.String("")"")
					}
				val java.lang.StringlineNumberString = scala.tools.nsc.util.Positionpos.=> Option[Int]line.((Int) => java.lang.String)Option[java.lang.String]map(Intline => java.lang.String(":")":" (Any)java.lang.String+ Intline (Any)java.lang.String+ java.lang.String(":")":").(=> java.lang.String)java.lang.StringgetOrElse(java.lang.String(":")":") (Any)java.lang.String+ java.lang.String(" ")" "
				java.lang.StringsourcePrefix (Any)java.lang.String+ java.lang.StringlineNumberString (Any)java.lang.String+ Stringmsg
			}
			sbt.Loggerlog.(sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel, => java.lang.Stringmessage)
			Unitif (=> Boolean!scala.tools.nsc.util.Positionpos.=> Option[Int]line.=> BooleanisEmpty)
			{
				sbt.Loggerlog.(sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel, scala.tools.nsc.util.Positionpos.implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringlineContent.=> StringstripLineEnd) // source line with error/warning
				for(((Int) => Unit)Unitcolumn <- scala.tools.nsc.util.Positionpos.=> Option[Int]column if Intcolumn (Int)Boolean> Int(0)0) // pointer to the column position of the error/warning
					sbt.Loggerlog.(sbt.Level.Value,=> String)Unitlog(sbt.Level.Valuelevel, (implicit scala.Predef.stringWrapper : (String)scala.runtime.RichString" " (Int)String* (Intcolumn(Int)Int-Int(1)1)) (Any)java.lang.String+ Char('^')'^')
			}
		}
	}
	override def => Unitreset =
	{
		super.=> Unitreset
		=> scala.collection.mutable.HashMap[scala.tools.nsc.util.Position,LoggerReporter.this.Severity]positions.()Unitclear
	}

	protected def (scala.tools.nsc.util.Position,String,LoggerReporter.this.Severity,Boolean)Unitinfo0(scala.tools.nsc.util.Positionpos: scala.tools.nsc.util.PositionPosition, Stringmsg: StringString, LoggerReporter.this.Severityseverity: LoggerReporter.this.SeveritySeverity, Booleanforce: BooleanBoolean)
	{
		LoggerReporter.this.Severityseverity Unitmatch
		{
			Unitcase => LoggerReporter.this.SeverityWARNING | => LoggerReporter.this.SeverityERROR =>
			{
				Unitif(=> Boolean!(scala.tools.nsc.util.Position,LoggerReporter.this.Severity)BooleantestAndLog(scala.tools.nsc.util.Positionpos, LoggerReporter.this.Severityseverity))
					(scala.tools.nsc.util.Position,String,LoggerReporter.this.Severity)Unitdisplay(scala.tools.nsc.util.Positionpos, Stringmsg, LoggerReporter.this.Severityseverity)
			}
			Unitcase _ => (scala.tools.nsc.util.Position,String,LoggerReporter.this.Severity)Unitdisplay(scala.tools.nsc.util.Positionpos, Stringmsg, LoggerReporter.this.Severityseverity)
		}
	}
	
	private def (scala.tools.nsc.util.Position,LoggerReporter.this.Severity)BooleantestAndLog(scala.tools.nsc.util.Positionpos: scala.tools.nsc.util.PositionPosition, LoggerReporter.this.Severityseverity: LoggerReporter.this.SeveritySeverity): BooleanBoolean =
	{
		Booleanif(scala.tools.nsc.util.Positionpos (AnyRef)Boolean== Null(null)null (Boolean)Boolean|| scala.tools.nsc.util.Positionpos.=> Option[Int]offset.=> BooleanisEmpty)
			Boolean(false)false
		else Booleanif(=> scala.collection.mutable.HashMap[scala.tools.nsc.util.Position,LoggerReporter.this.Severity]positions.(scala.tools.nsc.util.Position)Option[LoggerReporter.this.Severity]get(scala.tools.nsc.util.Positionpos).((LoggerReporter.this.Severity) => Boolean)Option[Boolean]map(LoggerReporter.this.Severity_ (LoggerReporter.this.severity.Value)Boolean>= LoggerReporter.this.Severityseverity).(=> Boolean)BooleangetOrElse(Boolean(false)false))
			Boolean(true)true
		else
		{
			=> scala.collection.mutable.HashMap[scala.tools.nsc.util.Position,LoggerReporter.this.Severity]positions(scala.tools.nsc.util.Positionpos) = LoggerReporter.this.Severityseverity
			Boolean(false)false
		}
	}
}
object object sbt.LoggerReporterLoggerReporter
{
	val IntErrorLimit = Int(100)100
}