/* sbt -- Simple Build Tool
 * Copyright 2008, 2009  Steven Blundy, Mark Harrah, David MacIver, Mikko Peltonen
 */
package sbt

import scala.collection.immutable.TreeSet

private trait trait RunCompleteAction extends java.lang.Object with NotNullRunCompleteAction extends NotNullNotNull
private class class Exit extends java.lang.Object with sbt.RunCompleteAction with ScalaObjectExit(val Intcode: IntInt) extends sbt.RunCompleteActionRunCompleteAction
private object object sbt.ReloadReload extends sbt.RunCompleteActionRunCompleteAction

/** This class is the entry point for sbt.  If it is given any arguments, it interprets them
* as actions, executes the corresponding actions, and exits.  If there were no arguments provided,
* sbt enters interactive mode.*/
object object sbt.MainMain
{
	/** The entry point for sbt.  If arguments are specified, they are interpreted as actions, executed,
	* and then the program terminates.  If no arguments are specified, the program enters interactive
	* mode. Call run if you need to run sbt in the same JVM.*/
	def (Array[String])Unitmain(Array[String]args: Array[String]Array[String])
	{
		val IntexitCode = (Array[String])Intrun(Array[String]args)
		Unitif(IntexitCode (Int)Boolean== => IntRebootExitCode)
		{
			(Any)Unitprintln(java.lang.String("Rebooting is not supported when the sbt loader is not used.")"Rebooting is not supported when the sbt loader is not used.")
			(Any)Unitprintln(java.lang.String("Please manually restart sbt.")"Please manually restart sbt.")
		}
		object java.lang.SystemSystem.(Int)Unitexit(IntexitCode)
	}
	val IntRebootExitCode = -Int(-1)1
	val IntNormalExitCode = Int(0)0
	val IntSetupErrorExitCode = Int(1)1
	val IntSetupDeclinedExitCode = Int(2)2
	val IntLoadErrorExitCode = Int(3)3
	val IntUsageErrorExitCode = Int(4)4
	val IntBuildErrorExitCode = Int(5)5
	def (Array[String])Intrun(Array[String]args: Array[String]Array[String]): IntInt =
	{
		val LongstartTime = object java.lang.SystemSystem.()LongcurrentTimeMillis
		object sbt.ProjectProject.=> sbt.LoadResultloadProject Intmatch
		{
			Intcase sbt.LoadSetupErrorerr: sbt.LoadSetupErrorLoadSetupError =>
				(Any)Unitprintln(java.lang.String("\012")"\n" (Any)java.lang.String+ sbt.LoadSetupErrorerr.=> Stringmessage)
				object sbt.ExitHooksExitHooks.(sbt.Logger)UnitrunExitHooks(object sbt.ProjectProject.=> sbt.ConsoleLoggerbootLogger)
				=> IntSetupErrorExitCode
			Intcase object sbt.LoadSetupDeclinedLoadSetupDeclined =>
				object sbt.ExitHooksExitHooks.(sbt.Logger)UnitrunExitHooks(object sbt.ProjectProject.=> sbt.ConsoleLoggerbootLogger)
				=> IntSetupDeclinedExitCode
			Intcase sbt.LoadErrorerr: sbt.LoadErrorLoadError =>
			{
				val sbt.ConsoleLoggerlog = object sbt.ProjectProject.=> sbt.ConsoleLoggerbootLogger
				(Any)Unitprintln(sbt.LoadErrorerr.=> Stringmessage)
				object sbt.ExitHooksExitHooks.(sbt.Logger)UnitrunExitHooks(sbt.ConsoleLoggerlog)
				// Because this is an error that can probably be corrected, prompt user to try again.
				val Option[String]line =
					try { (String)Some[String]Some((String,Any*)StringreadLine(java.lang.String("\012 Hit enter to retry or 'exit' to quit: ")"\n Hit enter to retry or 'exit' to quit: ")).((String) => Boolean)Option[String]filter(String_ (AnyRef)Boolean!= Null(null)null) }
					catch
					{
						None.typecase java.lang.Throwablee =>
							sbt.ConsoleLoggerlog.(=> Throwable)Unittrace(java.lang.Throwablee)
							sbt.ConsoleLoggerlog.(=> String)Uniterror(java.lang.Throwablee.()java.lang.StringtoString)
							object NoneNone
					}
				Option[String]line Intmatch
				{
					Intcase Some(Stringl) => Intif(=> Boolean!(String)BooleanisTerminateAction(Stringl)) (Array[String])Intrun(Array[String]args) else => IntNormalExitCode
					Intcase object NoneNone => => IntLoadErrorExitCode
				}
			}
			Intcase sbt.LoadSuccesssuccess: sbt.LoadSuccessLoadSuccess =>
			{
				import success.project
				val sbt.RunCompleteActiondoNext: sbt.RunCompleteActionRunCompleteAction =
					// in interactive mode, fill all undefined properties
					sbt.RunCompleteActionif(Array[String]args.=> Intlength (Int)Boolean> Int(0)0 (Boolean)Boolean|| (List[sbt.Project])BooleanfillUndefinedProjectProperties(=> sbt.Projectproject.=> List[sbt.Project]topologicalSort.=> List[sbt.Project]toList.=> List[sbt.Project]reverse))
						(sbt.Project,Array[String],Long)sbt.RunCompleteActionstartProject(=> sbt.Projectproject, Array[String]args, LongstartTime)
					else
						sbt.Exitnew sbt.ExitExit(=> IntNormalExitCode)
				object sbt.ExitHooksExitHooks.(sbt.Logger)UnitrunExitHooks(=> sbt.Projectproject.=> sbt.Loggerlog)
				sbt.RunCompleteActiondoNext Intmatch
				{
					Intcase object sbt.ReloadReload => (Array[String])Intrun(Array[String]args)
					Intcase sbt.Exitx: sbt.ExitExit => sbt.Exitx.=> Intcode
				}
			}
		}
	}
	/** Returns true if the project should be reloaded, false if sbt should exit.*/
	private def (sbt.Project,Array[String],Long)sbt.RunCompleteActionstartProject(sbt.Projectproject: sbt.ProjectProject, Array[String]args: Array[String]Array[String], LongstartTime: LongLong): sbt.RunCompleteActionRunCompleteAction =
	{
		sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Building project ")"Building project " (Any)java.lang.String+ sbt.Projectproject.=> Stringname (Any)java.lang.String+ java.lang.String(" ")" " (Any)java.lang.String+ sbt.Projectproject.=> sbt.Versionversion.()java.lang.StringtoString (Any)java.lang.String+ java.lang.String(" using ")" using " (Any)java.lang.String+ sbt.Projectproject.()java.lang.Class[_ <: java.lang.Object]getClass.()java.lang.StringgetName)
		for(((String) => Unit)UnitsbtVersion <- sbt.Projectproject.=> project.Property[String]sbtVersion.=> Option[String]get; ((String) => Unit)UnitscalaVersion <- sbt.Projectproject.=> project.Property[String]scalaVersion.=> Option[String]get if => Boolean!implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringsbtVersion.=> BooleanisEmpty  (Boolean)Boolean&& => Boolean!implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringscalaVersion.=> BooleanisEmpty)
			sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("   with sbt ")"   with sbt " (Any)java.lang.String+ StringsbtVersion (Any)java.lang.String+ java.lang.String(" and Scala ")" and Scala " (Any)java.lang.String+ StringscalaVersion)
		sbt.RunCompleteActionif(Array[String]args.=> Intlength (Int)Boolean== Int(0)0)
		{
			sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("No actions specified, interactive session started. Execute 'help' for more information.")"No actions specified, interactive session started. Execute 'help' for more information.")
			val sbt.RunCompleteActiondoNext = (sbt.Project)sbt.RunCompleteActioninteractive(sbt.Projectproject)
			(sbt.Project,Long,String)UnitprintTime(sbt.Projectproject, LongstartTime, java.lang.String("session")"session")
			sbt.RunCompleteActiondoNext
		}
		else
		{
			val IntexitCode =
				object sbt.ControlControl.(List[String])((String) => Option[String])Option[String]lazyFold(Array[String]args.=> List[String]toList)((sbt.Project)(String)Option[String]handleBatchCommand(sbt.Projectproject)) Intmatch
				{
					Intcase object NoneNone => sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitsuccess(java.lang.String("Build completed successfully.")"Build completed successfully."); => IntNormalExitCode
					Intcase Some(StringerrorMessage) =>
						sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Error during build")"Error during build" (Any)java.lang.String+ (Anyif(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringerrorMessage.=> BooleanisEmpty) java.lang.String(".")"." else java.lang.String(": ")": " (Any)java.lang.String+ StringerrorMessage) )
						=> IntBuildErrorExitCode
				}
			(sbt.Project,Long,String)UnitprintTime(sbt.Projectproject, LongstartTime, java.lang.String("build")"build")
			sbt.Exitnew sbt.ExitExit(IntexitCode)
		}
	}
	
	/** The name of the command that shows the current project and logging level of that project.*/
	val java.lang.StringShowCurrent = java.lang.String("current")"current"
	/** The name of the command that shows all available actions.*/
	val java.lang.StringShowActions = java.lang.String("actions")"actions"
	/** The name of the command that shows all available methods.*/
	val java.lang.StringShowMethods = java.lang.String("methods")"methods"
	/** The name of the command that sets the currently active project.*/
	val java.lang.StringProjectAction = java.lang.String("project")"project"
	/** The name of the command that shows all available projects.*/
	val java.lang.StringShowProjectsAction = java.lang.String("projects")"projects"
	/** The list of lowercase command names that may be used to terminate the program.*/
	val Iterable[String]TerminateActions: Iterable[String]Iterable[String] = java.lang.String("exit")"exit" (java.lang.String)List[java.lang.String]:: java.lang.String("quit")"quit" (java.lang.String)List[java.lang.String]:: object NilNil
	/** The name of the command that sets the value of the property given as its argument.*/
	val java.lang.StringSetAction = java.lang.String("set")"set"
	/** The name of the command that gets the value of the property given as its argument.*/
	val java.lang.StringGetAction = java.lang.String("get")"get"
	/** The name of the command that displays the help message. */
	val java.lang.StringHelpAction = java.lang.String("help")"help"
	/** The command for rebooting sbt. Requires sbt to have been launched by the loader.*/
	val java.lang.StringRebootCommand = java.lang.String("reboot")"reboot"
	/** The name of the command that reloads a project.  This is useful for when the project definition has changed. */
	val java.lang.StringReloadAction = java.lang.String("reload")"reload"
	/** The name of the command that toggles logging stacktraces. */
	val java.lang.StringTraceCommand = java.lang.String("trace")"trace"
	/** The name of the command that compiles all sources continuously when they are modified. */
	val java.lang.StringContinuousCompileCommand = java.lang.String("cc")"cc"
	/** The prefix used to identify a request to execute the remaining input on source changes.*/
	val java.lang.StringContinuousExecutePrefix = java.lang.String("~")"~"
	
	/** The number of seconds between polling by the continuous compile command.*/
	val IntContinuousCompilePollDelaySeconds = Int(1)1

	/** The list of all available commands at the interactive prompt in addition to the tasks defined
	* by a project.*/
	protected def => Iterable[String]interactiveCommands: Iterable[String]Iterable[String] = => Iterable[String]basicCommands.=> List[String]toList (Iterable[String])List[String]++ => Iterable[String]logLevels.=> List[String]toList
	/** The list of logging levels.*/
	private def => Iterable[String]logLevels: Iterable[String]Iterable[String] = object scala.collection.immutable.TreeSetTreeSet.(implicit (String) => Ordered[String])scala.collection.immutable.TreeSet[String]empty[StringString] (Iterator[String])scala.collection.immutable.Set[String]++ object sbt.LevelLevel.=> Iterator[sbt.Level.Value]elements.((sbt.Level.Value) => java.lang.String)Iterator[java.lang.String]map(sbt.Level.Value_.()java.lang.StringtoString)
	/** The list of all interactive commands other than logging level.*/
	private def => Iterable[String]basicCommands: Iterable[String]Iterable[String] = (java.lang.String*)(implicit (java.lang.String) => Ordered[java.lang.String])scala.collection.immutable.SortedSet[java.lang.String]TreeSet(=> java.lang.StringShowProjectsAction, => java.lang.StringShowActions, => java.lang.StringShowMethods, => java.lang.StringShowCurrent, => java.lang.StringHelpAction,
		=> java.lang.StringRebootCommand, => java.lang.StringReloadAction, => java.lang.StringTraceCommand, => java.lang.StringContinuousCompileCommand)
	
	/** Enters interactive mode for the given root project.  It uses JLine for tab completion and
	* history.  It returns normally when the user terminates or reloads the interactive session.  That is,
	* it does not call System.exit to quit.
	**/
	private def (sbt.Project)sbt.RunCompleteActioninteractive(sbt.ProjectbaseProject: sbt.ProjectProject): sbt.RunCompleteActionRunCompleteAction =
	{
		val List[String]projectNames = sbt.ProjectbaseProject.=> List[sbt.Project]topologicalSort.((sbt.Project) => String)List[String]map(sbt.Project_.=> Stringname)
		val List[java.lang.String]prefixes = java.lang.String("~")"~" (java.lang.String)List[java.lang.String]:: object NilNil
		val sbt.Completorscompletors = sbt.Completorsnew sbt.CompletorsCompletors(=> java.lang.StringProjectAction, List[String]projectNames, => Iterable[String]interactiveCommands, (java.lang.String*)List[java.lang.String]List(=> java.lang.StringGetAction, => java.lang.StringSetAction), List[java.lang.String]prefixes)
		val sbt.JLineReaderreader = sbt.JLineReadernew sbt.JLineReaderJLineReader(sbt.ProjectbaseProject.=> Some[sbt.Path]historyPath, sbt.Completorscompletors, sbt.ProjectbaseProject.=> sbt.Loggerlog)
		def (sbt.Project)UnitupdateTaskCompletions(sbt.Projectproject: sbt.ProjectProject)
		{
			val Iterable[(String, List[String])]methodCompletions = for( (((String, project.MethodTask)) => (String, List[String]))Iterable[(String, List[String])](Stringname, project.MethodTaskmethod) <- sbt.Projectproject.=> scala.collection.Map[String,project.MethodTask]methods) yield (String,List[String])(String, List[String])(Stringname, project.MethodTaskmethod.=> List[String]completions)
			sbt.JLineReaderreader.(Iterable[String],Iterable[String],Iterable[(String, Iterable[String])])UnitsetVariableCompletions(sbt.Projectproject.=> Iterable[String]taskNames, sbt.Projectproject.=> Iterable[String]propertyNames, Iterable[(String, List[String])]methodCompletions)
		}
		(sbt.Project)UnitupdateTaskCompletions(sbt.ProjectbaseProject)
		
		/** Prompts the user for the next command using 'currentProject' as context.
		* If the command indicates that the user wishes to terminate or reload the session,
		*   the function returns the appropriate value.
		* Otherwise, the command is handled and this function is called again
		*   (tail recursively) to prompt for the next command. */
		def (sbt.Project)sbt.RunCompleteActionloop(sbt.ProjectcurrentProject: sbt.ProjectProject): sbt.RunCompleteActionRunCompleteAction =
		{
			sbt.JLineReaderreader.(String)Option[String]readLine(java.lang.String("> ")"> ") sbt.RunCompleteActionmatch
			{
				sbt.RunCompleteActioncase Some(Stringline) =>
				{
					val java.lang.Stringtrimmed = Stringline.()java.lang.Stringtrim
					sbt.RunCompleteActionif(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringtrimmed.=> BooleanisEmpty)
						(sbt.Project)sbt.RunCompleteActionloop(sbt.ProjectcurrentProject)
					else sbt.RunCompleteActionif((String)BooleanisTerminateAction(java.lang.Stringtrimmed))
						sbt.Exitnew sbt.ExitExit(=> IntNormalExitCode)
					else sbt.RunCompleteActionif(=> java.lang.StringReloadAction (AnyRef)Boolean== java.lang.Stringtrimmed)
						object sbt.ReloadReload
					else sbt.RunCompleteActionif(=> java.lang.StringRebootCommand (AnyRef)Boolean== java.lang.Stringtrimmed)
						sbt.Exitnew sbt.ExitExit(=> IntRebootExitCode)
					else sbt.RunCompleteActionif(java.lang.Stringtrimmed.(java.lang.String)BooleanstartsWith(=> java.lang.StringProjectAction (Any)java.lang.String+ java.lang.String(" ")" "))
					{
						val java.lang.StringprojectName = java.lang.Stringtrimmed.(Int)java.lang.Stringsubstring(=> java.lang.StringProjectAction.()Intlength (Int)Int+ Int(1)1)
						sbt.ProjectbaseProject.=> List[sbt.Project]topologicalSort.((sbt.Project) => Boolean)Option[sbt.Project]find(sbt.Project_.=> Stringname (AnyRef)Boolean== java.lang.StringprojectName) sbt.RunCompleteActionmatch
						{
							sbt.RunCompleteActioncase Some(sbt.ProjectnewProject) =>
							{
								(String,sbt.Project)UnitprintProject(java.lang.String("Set current project to ")"Set current project to ", sbt.ProjectnewProject)
								(sbt.Project)UnitupdateTaskCompletions(sbt.ProjectnewProject)
								(sbt.Project)sbt.RunCompleteActionloop(sbt.ProjectnewProject)
							}
							sbt.RunCompleteActioncase object NoneNone =>
							{
								sbt.ProjectcurrentProject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Invalid project name '")"Invalid project name '" (Any)java.lang.String+ java.lang.StringprojectName (Any)java.lang.String+ java.lang.String("' (type 'projects' to list available projects).")"' (type 'projects' to list available projects).")
								(sbt.Project)sbt.RunCompleteActionloop(sbt.ProjectcurrentProject)
							}
						}
					}
					else
					{
						Unitif(java.lang.Stringtrimmed (AnyRef)Boolean== => java.lang.StringHelpAction)
							()UnitdisplayInteractiveHelp()
						else Unitif(java.lang.Stringtrimmed (AnyRef)Boolean== => java.lang.StringShowProjectsAction)
							sbt.ProjectbaseProject.=> List[sbt.Project]topologicalSort.((sbt.Project) => Unit)Unitforeach((sbt.Project)UnitlistProject)
						else Unitif(java.lang.Stringtrimmed.(java.lang.String)BooleanstartsWith(=> java.lang.StringSetAction (Any)java.lang.String+ java.lang.String(" ")" "))
							(sbt.Project,String)UnitsetProperty(sbt.ProjectcurrentProject, java.lang.Stringtrimmed.(Int)java.lang.Stringsubstring(=> java.lang.StringSetAction.()Intlength (Int)Int+ Int(1)1))
						else Unitif(java.lang.Stringtrimmed.(java.lang.String)BooleanstartsWith(=> java.lang.StringGetAction (Any)java.lang.String+ java.lang.String(" ")" "))
							(sbt.Project,String)UnitgetProperty(sbt.ProjectcurrentProject, java.lang.Stringtrimmed.(Int)java.lang.Stringsubstring(=> java.lang.StringGetAction.()Intlength (Int)Int+ Int(1)1))
						else
							(sbt.Project,String)UnithandleInteractiveCommand(sbt.ProjectcurrentProject, java.lang.Stringtrimmed)
						(sbt.Project)sbt.RunCompleteActionloop(sbt.ProjectcurrentProject)
					}
				}
				sbt.Exitcase object NoneNone => sbt.Exitnew sbt.ExitExit(=> IntNormalExitCode)
			}
		}
		
		(sbt.Project)sbt.RunCompleteActionloop(sbt.ProjectbaseProject)
	}
	private def (String,String)UnitprintCmd(Stringname:StringString, Stringdesc:StringString) = object ConsoleConsole.(Any)Unitprintln(java.lang.String("\011")"\t" (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ Stringdesc)
	private def ()UnitdisplayBatchHelp() = {
		object ConsoleConsole.(Any)Unitprintln(java.lang.String("You may execute any project action or method or one of the commands described below.")"You may execute any project action or method or one of the commands described below.")
		object ConsoleConsole.(Any)Unitprintln(java.lang.String("Available Commands:")"Available Commands:")
		()UnitprintCommonCommands()
	}
	private def ()UnitprintCommonCommands()
	{
		(String,String)UnitprintCmd(java.lang.String("<action name>")"<action name>", java.lang.String("Executes the project specified action.")"Executes the project specified action.")
		(String,String)UnitprintCmd(java.lang.String("<method name> <parameter>*")"<method name> <parameter>*", java.lang.String("Executes the project specified method.")"Executes the project specified method.")
		(String,String)UnitprintCmd(java.lang.String("~ <command>")"~ <command>", java.lang.String("Executes the project specified action or method whenever source files change.")"Executes the project specified action or method whenever source files change.")
		(String,String)UnitprintCmd(=> java.lang.StringShowActions, java.lang.String("Shows all available actions.")"Shows all available actions.")
		(String,String)UnitprintCmd(=> java.lang.StringShowMethods, java.lang.String("Shows all available methods.")"Shows all available methods.")
		(String,String)UnitprintCmd(=> java.lang.StringRebootCommand, java.lang.String("Changes to scala.version or sbt.version are processed and the project definition is reloaded.")"Changes to scala.version or sbt.version are processed and the project definition is reloaded.")
		(String,String)UnitprintCmd(=> java.lang.StringHelpAction, java.lang.String("Displays this help message.")"Displays this help message.")
	}
	private def ()UnitdisplayInteractiveHelp() = {
		object ConsoleConsole.(Any)Unitprintln("You may execute any project action or one of the commands described below. Only one action " +
			"may be executed at a time in interactive mode and is entered by name, as it would be at the command line." java.lang.String("You may execute any project action or one of the commands described below. Only one action may be executed at a time in interactive mode and is entered by name, as it would be at the command line. Also, tab completion is available.")+
			" Also, tab completion is available.")
		object ConsoleConsole.(Any)Unitprintln(java.lang.String("Available Commands:")"Available Commands:")

		()UnitprintCommonCommands()
		(String,String)UnitprintCmd(=> java.lang.StringReloadAction, java.lang.String("Reloads sbt, recompiling modified project definitions if necessary.")"Reloads sbt, recompiling modified project definitions if necessary.")
		(String,String)UnitprintCmd(=> java.lang.StringShowCurrent, java.lang.String("Shows the current project and logging level of that project.")"Shows the current project and logging level of that project.")
		(String,String)UnitprintCmd(object sbt.LevelLevel.=> Iterator[sbt.Level.Value]elements.(String)StringmkString(java.lang.String(", ")", "), java.lang.String("Set logging for the current project to the specified level.")"Set logging for the current project to the specified level.")
		(String,String)UnitprintCmd(=> java.lang.StringTraceCommand, java.lang.String("Toggles whether logging stack traces is enabled.")"Toggles whether logging stack traces is enabled.")
		(String,String)UnitprintCmd(=> java.lang.StringProjectAction (Any)java.lang.String+ java.lang.String(" <project name>")" <project name>", java.lang.String("Sets the currently active project.")"Sets the currently active project.")
		(String,String)UnitprintCmd(=> java.lang.StringShowProjectsAction, java.lang.String("Shows all available projects.")"Shows all available projects.")
		(String,String)UnitprintCmd(=> Iterable[String]TerminateActions.=> Iterator[String]elements.(String)StringmkString(java.lang.String(", ")", "), java.lang.String("Terminates the program.")"Terminates the program.")
		(String,String)UnitprintCmd(=> java.lang.StringSetAction (Any)java.lang.String+ java.lang.String(" <property> <value>")" <property> <value>", java.lang.String("Sets the value of the property given as its argument.")"Sets the value of the property given as its argument.")
		(String,String)UnitprintCmd(=> java.lang.StringGetAction (Any)java.lang.String+ java.lang.String(" <property>")" <property>", java.lang.String("Gets the value of the property given as its argument.")"Gets the value of the property given as its argument.")
	}
	private def (sbt.Project)UnitlistProject(sbt.Projectp: sbt.ProjectProject) = (String,sbt.Project)UnitprintProject(java.lang.String("\011")"\t", sbt.Projectp)
	private def (String,sbt.Project)UnitprintProject(Stringprefix: StringString, sbt.Projectp: sbt.ProjectProject)
	{
		object ConsoleConsole.(Any)Unitprintln(Stringprefix (Any)java.lang.String+ sbt.Projectp.=> Stringname (Any)java.lang.String+ java.lang.String(" ")" " (Any)java.lang.String+ sbt.Projectp.=> sbt.Versionversion)
	}
	
	/** Handles the given command string provided by batch mode execution..*/
	private def (sbt.Project)(String)Option[String]handleBatchCommand(sbt.Projectproject: sbt.ProjectProject)(Stringcommand: StringString): Option[String]Option[String] =
	{
		Stringcommand.()java.lang.Stringtrim Option[String]match
		{
			None.typecase => java.lang.StringHelpAction => ()UnitdisplayBatchHelp(); object NoneNone
			None.typecase => java.lang.StringShowActions => object ConsoleConsole.(Any)Unitprintln(sbt.Projectproject.=> StringtaskList); object NoneNone
			None.typecase => java.lang.StringShowMethods => object ConsoleConsole.(Any)Unitprintln(sbt.Projectproject.=> StringmethodList); object NoneNone
			Option[String]case java.lang.Stringaction => Option[String]if((sbt.Project,String)BooleanhandleAction(sbt.Projectproject, java.lang.Stringaction)) object NoneNone else (java.lang.String)Some[java.lang.String]Some(java.lang.String("")"")
		}
	}
	
	/** Handles the given command string provided at the command line.*/
	private def (sbt.Project,String)UnithandleInteractiveCommand(sbt.Projectproject: sbt.ProjectProject, Stringcommand: StringString)
	{
		Stringcommand Unitmatch
		{
			Unitcase => java.lang.StringGetAction => (sbt.Logger)UnitgetArgumentError(sbt.Projectproject.=> sbt.Loggerlog)
			Unitcase => java.lang.StringSetAction => (sbt.Logger)UnitsetArgumentError(sbt.Projectproject.=> sbt.Loggerlog)
			Unitcase => java.lang.StringProjectAction => (sbt.Logger)UnitsetProjectError(sbt.Projectproject.=> sbt.Loggerlog)
			Unitcase => java.lang.StringShowCurrent =>
			{
				(String,sbt.Project)UnitprintProject(java.lang.String("Current project is ")"Current project is ", sbt.Projectproject)
				object ConsoleConsole.(Any)Unitprintln(java.lang.String("Current log level is ")"Current log level is " (Any)java.lang.String+ sbt.Projectproject.=> sbt.Loggerlog.=> sbt.Level.ValuegetLevel)
				(sbt.Project)UnitprintTraceEnabled(sbt.Projectproject)
			}
			Unitcase => java.lang.StringShowActions => object ConsoleConsole.(Any)Unitprintln(sbt.Projectproject.=> StringtaskList)
			Unitcase => java.lang.StringShowMethods => object ConsoleConsole.(Any)Unitprintln(sbt.Projectproject.=> StringmethodList)
			Unitcase => java.lang.StringTraceCommand => (sbt.Project)UnittoggleTrace(sbt.Projectproject)
			Unitcase (String)Option[sbt.Level.Value]Level(sbt.Level.Valuelevel) => (sbt.Project,sbt.Level.Value)UnitsetLevel(sbt.Projectproject, sbt.Level.Valuelevel)
			Unitcase => java.lang.StringContinuousCompileCommand => (sbt.Project)UnitcompileContinuously(sbt.Projectproject)
			Unitcase Stringaction if Stringaction.(java.lang.String)BooleanstartsWith(=> java.lang.StringContinuousExecutePrefix) =>
				(sbt.Project,String)UnitexecuteContinuously(sbt.Projectproject, Stringaction.(Int)java.lang.Stringsubstring(=> java.lang.StringContinuousExecutePrefix.()Intlength).()java.lang.Stringtrim)
			Unitcase Stringaction => (sbt.Project,String)BooleanhandleAction(sbt.Projectproject, Stringaction)
		}
	}
	// returns true if it succeeded (needed by noninteractive handleCommand)
	private def (sbt.Project,String)BooleanhandleAction(sbt.Projectproject: sbt.ProjectProject, Stringaction: StringString): BooleanBoolean =
	{
		def (Option[String])BooleanshowResult(Option[String]result: Option[String]Option[String]): BooleanBoolean =
		{
			Option[String]result Booleanmatch
			{
				Booleancase Some(StringerrorMessage) => sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(StringerrorMessage); Boolean(false)false
				Booleancase object NoneNone => sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitsuccess(java.lang.String("Successful.")"Successful."); Boolean(true)true
			}
		}
		val LongstartTime = object java.lang.SystemSystem.()LongcurrentTimeMillis
		val Booleanresult = (sbt.Project,String)((String, Array[String]) => Boolean)((String) => Boolean)BooleanwithAction(sbt.Projectproject, Stringaction)( (Stringname, Array[String]params) => (Option[String])BooleanshowResult(sbt.Projectproject.(String,Array[String])Option[String]call(Stringname, Array[String]params)))( Stringname => (Option[String])BooleanshowResult(sbt.Projectproject.(String)Option[String]act(Stringname)))
		(sbt.Project,Long,String)UnitprintTime(sbt.Projectproject, LongstartTime, java.lang.String("")"")
		Booleanresult
	}
	// true if the action exists
	private def (sbt.Project,String)BooleancheckAction(sbt.Projectproject: sbt.ProjectProject, StringactionString: StringString): BooleanBoolean =
		(sbt.Project,String)((String, Array[String]) => Boolean)((String) => Boolean)BooleanwithAction(sbt.Projectproject, StringactionString)(  (Stringn,Array[String]p) => Boolean(true)true)( Stringn => Boolean(true)true)
	private def (sbt.Project,String)((String, Array[String]) => Boolean)((String) => Boolean)BooleanwithAction(sbt.Projectproject: sbt.ProjectProject, StringactionString: StringString)((String, Array[String]) => BooleanifMethod: (String, Array[String]) => Boolean)((String) => BooleanifAction: String => Boolean): BooleanBoolean =
	{
		def (String,String)BooleandidNotExist(StringtaskType: StringString, Stringname: StringString) =
		{
			sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("No ")"No " (Any)java.lang.String+ StringtaskType (Any)java.lang.String+ java.lang.String(" named '")" named '" (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String("' exists.")"' exists.")
			sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo("Execute 'help' for a list of commands, " +
				"'actions' for a list of available project actions, or " java.lang.String("Execute 'help' for a list of commands, 'actions' for a list of available project actions, or 'methods' for a list of available project methods.")+
				"'methods' for a list of available project methods.")
			Boolean(false)false
		}
		impl.object sbt.impl.CommandParserCommandParser.(String)Either[String,(String, List[String])]parse(StringactionString) Booleanmatch
		{
			Booleancase Left(StringerrMsg) => sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(StringerrMsg); Boolean(false)false
			Booleancase Right((Stringname, List[String]parameters)) =>
				Booleanif(sbt.Projectproject.=> scala.collection.Map[String,project.MethodTask]methods.(String)Booleancontains(Stringname))
					(String,Array[String])BooleanifMethod(Stringname, List[String]parameters.Array[String]toArray)
				else Booleanif(=> Boolean!List[String]parameters.=> BooleanisEmpty)
					(String,String)BooleandidNotExist(java.lang.String("method")"method", Stringname)
				else Booleanif(sbt.Projectproject.=> scala.collection.Map[String,sbt.Project#Task]deepTasks.(String)Booleancontains(Stringname))
					(String)BooleanifAction(Stringname)
				else
					(String,String)BooleandidNotExist(java.lang.String("action")"action", Stringname)
		}
	}
	
	/** Toggles whether stack traces are enabled.*/
	private def (sbt.Project)UnittoggleTrace(sbt.Projectproject: sbt.ProjectProject)
	{
		val BooleannewValue = => Boolean!sbt.Projectproject.=> sbt.Loggerlog.=> BooleantraceEnabled
		sbt.Projectproject.=> List[sbt.Project]topologicalSort.((sbt.Project) => Unit)Unitforeach(sbt.Project_.=> sbt.Loggerlog.(Boolean)UnitenableTrace(BooleannewValue))
		(sbt.Project)UnitprintTraceEnabled(sbt.Projectproject)
	}
	private def (sbt.Project)UnitprintTraceEnabled(sbt.Projectproject: sbt.ProjectProject)
	{
		object ConsoleConsole.(Any)Unitprintln(java.lang.String("Stack traces are ")"Stack traces are " (Any)java.lang.String+ (Anyif(sbt.Projectproject.=> sbt.Loggerlog.=> BooleantraceEnabled) java.lang.String("enabled")"enabled" else java.lang.String("disabled")"disabled"))
	}
	/** Sets the logging level on the given project.*/
	private def (sbt.Project,sbt.Level.Value)UnitsetLevel(sbt.Projectproject: sbt.ProjectProject, sbt.Level.Valuelevel: Level.sbt.Level.ValueValue)
	{
		sbt.Projectproject.=> List[sbt.Project]topologicalSort.((sbt.Project) => Unit)Unitforeach(sbt.Project_.=> sbt.Loggerlog.(sbt.Level.Value)UnitsetLevel(sbt.Level.Valuelevel))
		object ConsoleConsole.(Any)Unitprintln(java.lang.String("Set log level to ")"Set log level to " (Any)java.lang.String+ sbt.Projectproject.=> sbt.Loggerlog.=> sbt.Level.ValuegetLevel)
	}
	/** Prints the elapsed time to the given project's log using the given
	* initial time and the label 's'.*/
	private def (sbt.Project,Long,String)UnitprintTime(sbt.Projectproject: sbt.ProjectProject, LongstartTime: LongLong, Strings: StringString)
	{
		val LongendTime = object java.lang.SystemSystem.()LongcurrentTimeMillis()
		sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("")"")
		val java.lang.Stringss = java.lang.Stringif(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStrings.=> BooleanisEmpty) java.lang.String("")"" else Strings (Any)java.lang.String+ java.lang.String(" ")" "
		sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String("Total ")"Total " (Any)java.lang.String+ java.lang.Stringss (Any)java.lang.String+ java.lang.String("time: ")"time: " (Any)java.lang.String+ (LongendTime (Long)Long- LongstartTime (Int)Long+ Int(500)500) (Int)Long/ Int(1000)1000 (Any)java.lang.String+ java.lang.String(" s")" s")
	}
	/** Provides a partial message describing why the given property is undefined. */
	private def (sbt.Project#UserProperty[_])StringundefinedMessage(sbt.Project#UserProperty[_]property: sbt.Project#UserProperty[_]Project#UserProperty[_]): StringString =
	{
		sbt.Project#UserProperty[_]property.=> sbt.PropertyResolution[Any]resolve Stringmatch
		{
			java.lang.String(" is not defined.")case sbt.UndefinedValuevu: sbt.UndefinedValueUndefinedValue => java.lang.String(" is not defined.")" is not defined."
			java.lang.Stringcase sbt.ResolutionExceptione: sbt.ResolutionExceptionResolutionException => java.lang.String(" has invalid value: ")" has invalid value: " (Any)java.lang.String+ sbt.ResolutionExceptione.()java.lang.StringtoString
			java.lang.String("")case _ => java.lang.String("")""
		}
	}
	/** Prompts the user for the value of undefined properties.  'first' is true if this is the first time
	* that the current property has been prompted.*/
	private def (sbt.Project,List[(String, sbt.Project#Property[_])],Boolean)BooleanfillUndefinedProperties(sbt.Projectproject: sbt.ProjectProject, List[(String, sbt.Project#Property[_])]properties: List[(String, sbt.Project#Property[_])]List[(String, Project#Property[_])], Booleanfirst: BooleanBoolean): BooleanBoolean =
	{
		List[(String, sbt.Project#Property[_])]properties Booleanmatch
		{
			Booleancase (Stringname, sbt.Project#Property[?]variable) :: List[(String, sbt.Project#Property[_])]tail =>
			{
				val Option[Boolean]shouldAdvanceOrQuit =
					sbt.Project#Property[?]variable Option[Boolean]match
					{
						Option[Boolean]case sbt.Project#UserProperty[_]property: Project#sbt.Project#UserProperty[_]UserProperty[_] =>
							Unitif(Booleanfirst)
								sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String(" Property '")" Property '" (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String("' ")"' " (Any)java.lang.String+ (sbt.Project#UserProperty[_])StringundefinedMessage(sbt.Project#UserProperty[_]property))
							val StringnewValue = object ConsoleConsole.(String,Any*)StringreadLine(java.lang.String("  Enter new value for ")"  Enter new value for " (Any)java.lang.String+ Stringname (Any)java.lang.String+ java.lang.String(" : ")" : ")
							object ConsoleConsole.()Unitprintln()
							Option[Boolean]if(StringnewValue (AnyRef)Boolean== Null(null)null)
								object NoneNone
							else
							{
								try
								{
									sbt.Project#UserProperty[_]property.(String)UnitsetStringValue(StringnewValue)
									(Boolean)Some[Boolean]Some(Boolean(true)true)
								}
								catch
								{
									Some[Boolean]case java.lang.Throwablee =>
										sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Invalid value: ")"Invalid value: " (Any)java.lang.String+ java.lang.Throwablee.()java.lang.StringgetMessage)
										(Boolean)Some[Boolean]Some(Boolean(false)false)
								}
							}
						Some[Boolean]case _ => (Boolean)Some[Boolean]Some(Boolean(true)true)
					}
				Option[Boolean]shouldAdvanceOrQuit Booleanmatch
				{
					Booleancase Some(BooleanshouldAdvance) => (sbt.Project,List[(String, sbt.Project#Property[_])],Boolean)BooleanfillUndefinedProperties(sbt.Projectproject, List[(String, sbt.Project#Property[_])]if(BooleanshouldAdvance) List[(String, sbt.Project#Property[_])]tail else List[(String, sbt.Project#Property[_])]properties, BooleanshouldAdvance)
					Boolean(false)case object NoneNone => Boolean(false)false
				}
			}
			Boolean(true)case object NilNil => Boolean(true)true
		}
	}
	/** Iterates over the undefined properties in the given projects, prompting the user for the value of each undefined
	* property.*/
	private def (List[sbt.Project])BooleanfillUndefinedProjectProperties(List[sbt.Project]projects: List[sbt.Project]List[Project]): BooleanBoolean =
	{
		List[sbt.Project]projects Booleanmatch
		{
			Booleancase sbt.Projectproject :: List[sbt.Project]remaining =>
			{
				val List[(String, project.Property[_])]uninitialized = sbt.Projectproject.=> Iterable[(String, project.Property[_])]uninitializedProperties.=> List[(String, project.Property[_])]toList
				Booleanif(List[(String, project.Property[_])]uninitialized.=> BooleanisEmpty)
					(List[sbt.Project])BooleanfillUndefinedProjectProperties(List[sbt.Project]remaining)
				else
				{
					sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Project in ")"Project in " (Any)java.lang.String+ sbt.Projectproject.=> sbt.ProjectInfoinfo.=> java.io.FileprojectDirectory.()java.lang.StringgetAbsolutePath (Any)java.lang.String+ java.lang.String(" has undefined properties.")" has undefined properties.")
					val Booleanresult = (sbt.Project,List[(String, sbt.Project#Property[_])],Boolean)BooleanfillUndefinedProperties(sbt.Projectproject, List[(String, project.Property[_])]uninitialized, Boolean(true)true) (Boolean)Boolean&& (List[sbt.Project])BooleanfillUndefinedProjectProperties(List[sbt.Project]remaining)
					sbt.Projectproject.()Option[String]saveEnvironment()
					Booleanresult
				}
			}
			Boolean(true)case object NilNil => Boolean(true)true
		}
	}
	/** Prints the value of the property with the given name in the given project. */
	private def (sbt.Project,String)UnitgetProperty(sbt.Projectproject: sbt.ProjectProject, StringpropertyName: StringString)
	{
		Unitif(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringpropertyName.=> BooleanisEmpty)
			sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("No property name specified.")"No property name specified.")
		else
		{
			sbt.Projectproject.(String)Option[project.UserProperty[_]]getPropertyNamed(StringpropertyName) Unitmatch
			{
				Unitcase Some(project.UserProperty[?]property) =>
				{
					project.UserProperty[?]property.=> sbt.PropertyResolution[?]resolve Unitmatch
					{
						Unitcase sbt.UndefinedValueu: sbt.UndefinedValueUndefinedValue => sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Value of property '")"Value of property '" (Any)java.lang.String+ StringpropertyName (Any)java.lang.String+ java.lang.String("' is undefined.")"' is undefined.")
						Unitcase ResolutionException(Stringm, Option[Throwable]e) => sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(Stringm)
						Unitcase DefinedValue(Anyvalue, BooleanisInherited, BooleanisDefault) => object ConsoleConsole.(Any)Unitprintln(Anyvalue.()java.lang.StringtoString)
					}
				}
				Unitcase object NoneNone =>
				{
					val java.lang.Stringvalue = object java.lang.SystemSystem.(java.lang.String)java.lang.StringgetProperty(StringpropertyName)
					Unitif(java.lang.Stringvalue (AnyRef)Boolean== Null(null)null)
						sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("No property named '")"No property named '" (Any)java.lang.String+ StringpropertyName (Any)java.lang.String+ java.lang.String("' is defined.")"' is defined.")
					else
						object ConsoleConsole.(Any)Unitprintln(java.lang.Stringvalue)
				}
			}
		}
	}
	/** Separates the space separated property name/value pair and stores the value in the user-defined property
	* with the given name in the given project.  If no such property exists, the value is stored in a system
	* property. */
	private def (sbt.Project,String)UnitsetProperty(sbt.Projectproject: sbt.ProjectProject, StringpropertyNameAndValue: StringString)
	{
		val java.util.regex.Matcherm = implicit scala.Predef.stringWrapper : (String)scala.runtime.RichString"""(\S+)(\s+\S.*)?""".=> scala.util.matching.Regexr.=> java.util.regex.Patternpattern.(java.lang.CharSequence)java.util.regex.Matchermatcher(StringpropertyNameAndValue)
		Unitif(java.util.regex.Matcherm.()Booleanmatches())
		{
			val java.lang.Stringname = java.util.regex.Matcherm.(Int)java.lang.Stringgroup(Int(1)1)
			val java.lang.StringnewValue =
			{
				val java.lang.Stringv = java.util.regex.Matcherm.(Int)java.lang.Stringgroup(Int(2)2)
				java.lang.Stringif(java.lang.Stringv (AnyRef)Boolean== Null(null)null) java.lang.String("")"" else java.lang.Stringv.()java.lang.Stringtrim
			}
			sbt.Projectproject.(String)Option[project.UserProperty[_]]getPropertyNamed(java.lang.Stringname) Unitmatch
			{
				Unitcase Some(project.UserProperty[?]property) =>
				{
					val Unitsucceeded =
						try
						{
							project.UserProperty[?]property.(String)UnitsetStringValue(java.lang.StringnewValue)
							val BooleanisScalaVersion = project.UserProperty[?]property (AnyRef)Boolean== sbt.Projectproject.=> project.Property[String]scalaVersion
							val BooleanisSbtVersion = project.UserProperty[?]property (AnyRef)Boolean== sbt.Projectproject.=> project.Property[String]sbtVersion
							Unitif(BooleanisScalaVersion (Boolean)Boolean|| BooleanisSbtVersion)
							{
								val java.lang.Stringchanged = java.lang.Stringif(BooleanisSbtVersion) java.lang.String("sbt ")"sbt " else java.lang.String("Scala ")"Scala "
								object ConsoleConsole.(Any)Unitprintln(java.lang.String(" Build will use ")" Build will use " (Any)java.lang.String+ java.lang.Stringchanged (Any)java.lang.String+ java.lang.StringnewValue (Any)java.lang.String+ java.lang.String(" after running 'reboot' command or restarting sbt.")" after running 'reboot' command or restarting sbt.")
							}
							else
								object ConsoleConsole.(Any)Unitprintln(java.lang.String(" Set property '")" Set property '" (Any)java.lang.String+ java.lang.Stringname (Any)java.lang.String+ java.lang.String("' = '")"' = '" (Any)java.lang.String+ java.lang.StringnewValue (Any)java.lang.String+ java.lang.String("'")"'")
						}
						catch { Unitcase java.lang.Throwablee => sbt.Projectproject.=> sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Error setting property '")"Error setting property '" (Any)java.lang.String+ java.lang.Stringname (Any)java.lang.String+ java.lang.String("' in ")"' in " (Any)java.lang.String+ sbt.Projectproject.=> java.lang.StringenvironmentLabel (Any)java.lang.String+ java.lang.String(": ")": " (Any)java.lang.String+ java.lang.Throwablee.()java.lang.StringtoString) }
					sbt.Projectproject.()Option[String]saveEnvironment()
				}
				Unitcase object NoneNone =>
				{
					object java.lang.SystemSystem.(java.lang.String,java.lang.String)java.lang.StringsetProperty(java.lang.Stringname, java.lang.StringnewValue)
					sbt.Projectproject.=> sbt.Loggerlog.(=> String)Unitinfo(java.lang.String(" Set system property '")" Set system property '" (Any)java.lang.String+ java.lang.Stringname (Any)java.lang.String+ java.lang.String("' = '")"' = '" (Any)java.lang.String+ java.lang.StringnewValue (Any)java.lang.String+ java.lang.String("'")"'")
				}
			}
		}
		else
			(sbt.Logger)UnitsetArgumentError(sbt.Projectproject.=> sbt.Loggerlog)
	}

	private def (sbt.Project)UnitcompileContinuously(sbt.Projectproject: sbt.ProjectProject) = (sbt.Project,String)UnitexecuteContinuously(sbt.Projectproject, java.lang.String("test-compile")"test-compile")
	private def (sbt.Project,String)UnitexecuteContinuously(sbt.Projectproject: sbt.ProjectProject, Stringaction: StringString)
	{
		Unitif((sbt.Project,String)BooleancheckAction(sbt.Projectproject, Stringaction))
		{
			object sbt.SourceModificationWatchSourceModificationWatch.(sbt.Project,Int)(=> Boolean)(=> Unit)UnitwatchUntil(sbt.Projectproject, => IntContinuousCompilePollDelaySeconds)(object java.lang.SystemSystem.java.io.InputStreamin.()Intavailable() (Int)Boolean> Int(0)0)
			{
				(sbt.Project,String)BooleanhandleAction(sbt.Projectproject, Stringaction)
				object ConsoleConsole.(Any)Unitprintln(java.lang.String("Waiting for source changes... (press any key to interrupt)")"Waiting for source changes... (press any key to interrupt)")
			}
			Unitwhile (object java.lang.SystemSystem.java.io.InputStreamin.()Intavailable() (Int)Boolean> Int(0)0) object java.lang.SystemSystem.java.io.InputStreamin.()Intread()
		}
	}

	private def (String)BooleanisTerminateAction(Strings: StringString) = => Iterable[String]TerminateActions.=> Iterator[String]elements.(Any)Booleancontains(Strings.()java.lang.StringtoLowerCase)
	private def (sbt.Logger)UnitsetArgumentError(sbt.Loggerlog: sbt.LoggerLogger) { sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Invalid arguments for 'set': expected property name and new value.")"Invalid arguments for 'set': expected property name and new value.") }
	private def (sbt.Logger)UnitgetArgumentError(sbt.Loggerlog: sbt.LoggerLogger) { sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Invalid arguments for 'get': expected property name.")"Invalid arguments for 'get': expected property name.") }
	private def (sbt.Logger)UnitsetProjectError(sbt.Loggerlog: sbt.LoggerLogger) { sbt.Loggerlog.(=> String)Uniterror(java.lang.String("Invalid arguments for 'project': expected project name.")"Invalid arguments for 'project': expected project name.") }
	
}