"""
InstallFromWorkspace.cobra

This program installs Cobra onto your system out of the workspace. It's a great
convenience for users who only grab the workspace to get the very latest
version of Cobra (e.g., they are not developing on the compiler). But even for
developers, it's convenient to "snapshot" the compiler for your system when
desired.

Normally the compiler and libraries to be installed are compiled with -turbo.
However, you can pass an argument to this program such as -debug which will
replace -turbo. This is useful for troubleshooting.

Why not a .bat file? Won't run on Mac, Linux, etc.

Why not a bash script? Won't run on Windows-sans-cygwin.

Also, as a .NET program this installer has easy access to the GAC and any other
.NET resources. Furthermore, as a Cobra programmer, any Cobra user could
potentially hack on it.


TO RUN

	On Windows

		Update, if desired:
		> cd \path\to\Workspace
		> svn up

		Get into the Source:
		> cd Source

		Use the batch file:
		> install-from-workspace

	On Mac, Linux, etc.

		Update, if desired:
		$ cd /path/to/Workspace
		$ svn up

		Get into the Source:
		$ cd Source

		Use the script:
		$ sudo ./install-from-workspace


	The installer prints "Success!" at the end, if successful.
	Otherwise you will see an error message.

	It's safe to run the installer more than once.

	The installer does not change any workspace files that are under source code control.

	To test the installation, try invoking Cobra from *outside* the workspace.


NOTES

	In some special cases, users have required that Cobra.Lang.dll not be
	installed to the GAC. There is an option for this called -skip-std-lib.
	Any other command line options are passed to the Cobra snapshot compiler
	when invoked to compile the compiler source code. If no options are
	specified, -turbo is the default.

	
ASSUMPTIONS

	* Your system meets the requirements for Novell Mono 2.6 or .NET 2.0
	  http://msdn.microsoft.com/en-us/library/ms229070.aspx

	* This program is run in the Workspace\Source directory.

	* This program is run by Snapshot\cobra.exe. *NOT* .\cobra.exe

	* The current Cobra compiler in Source\ will report a -version equal to the
	  last released version plus optional additional text. If the last release
	  was "0.8.0" then the new release should be "0.8.0 post".

	* The current Cobra compiler in Source\ will have three components to its
	  base version *number*. Form: x.y.z  Example: 0.8.0


TODO

	[ ] Create an install log

	[ ] Various "TODO" items in the source itself

"""

use System.Diagnostics
use System.Reflection
use System.Security.Principal
use System.Text.RegularExpressions

# for GAC installation
use System.EnterpriseServices
use System.EnterpriseServices.Internal


class InstallFromWorkspace

	var installDirectories = [r'C:\Cobra', '/usr/local/cobra']

	const configFileName = 'install-directory.text'

	var libs = [
		{
			'name': 'Cobra.Lang',
			'flags': '-build-standard-library',
			'files': 'Cobra.Lang/AssemblyAttrs.cobra',
		},
		{
			'name': 'Cobra.Lang.Compiler',
			'flags': '-c -t:lib -namespace:Cobra.Lang.Compiler -files:files-to-compile.text',
			'files': 'cobra.cobra',
		},
	]

	def main is shared
		InstallFromWorkspace().run

	var _lastCommand as String?

	var _snapshotCompilerPath as String?
	var _gacutil as String?
	var _baseVersion as String?       # ex: '0.8.0-post', '0.8.0-post-2009-03-01'
	var _targetDir as String?         # ex: 'C:\Cobra', '/usr/local/cobra'
	var _versionDir as String?        # ex: 'C:\Cobra\Cobra-0.8.0-post', 'C:\Cobra\Cobra-0.8.0-post-2009-03-01', '/usr/local/cobra/Cobra-0.8.1-post'
	var _cobraCommandPath as String?  # ex: 'C:\Cobra\bin\cobra.bat', '/usr/local/cobra/bin/cobra'
	var _args = List<of String>()
	var _skipStdLib = false
	var _willForceDotNet4 = false

	def run
		print
		print 'The Cobra Programming Language'
		print 'Install From Workspace'
		print
		print 'Working...'
		print
		.printPlatform
		_args = .parseCommandLineArgs
		.verifyElevatedPermissions
		.verifyInstallDirectory
		.verifyInWorkspace
		.askNet4
		.verifyVirtualMachineVersion
		.locateSnapshotCompiler
		# .locateGacUtil
		.buildCobraCompiler
		.getBaseVersion
		if not _skipStdLib
			for lib in .libs
				# keys: name, flags
				libName = lib['name']
				assert not libName.endsWith('.dll')
				.installLibrary(libName, lib['flags'], lib['files'].replace('/', .slash.toString))
		.verifyNewlyBuiltCobra
		.copyFilesToInstallDirectory
		.verifyNewlyInstalledCobra
		.cleanUpWorkspace
		.installInPath
		print
		print 'Visit http://cobra-language.com/ for discussion, wiki, samples, irc and more.'
		print
		print 'Success!'


	## Self utils

	get compileFlags as String
		if _args.count > 0, return _args.join(' ')
		else, return '-turbo'

	def isRunningOnCLR2 as bool
		ver = Assembly.getAssembly(Object).imageRuntimeVersion
		return ver.startsWith('v2.') or ver.startsWith('2.')

	def isRunningOnWindows as bool
		return not .isRunningOnUnix

	def isRunningOnUnix as bool
		"""
		Returns true if the current process is running on Unix/Posix/Linux/BSD/etc.
		"""
		return CobraCore.isRunningOnUnix

	get lastCommand from var

	get slash as char
		return Path.directorySeparatorChar

	def parseCommandLineArgs as List<of String>
		args = CobraCore.commandLineArgs
		args = args[1:]

		i = args.indexOf('-skip-std-lib')
		if i > -1
			args.removeAt(i)
			_skipStdLib = true

		i = args.indexOf('-net4')
		if i == -1, i = args.indexOf('-dotnet4')
		if i > -1
			args.removeAt(i)
			_willForceDotNet4 = true

		return args

	def setUpCLR4(args as List<of String>)
		# locate the external C# .NET 4 compiler
		if CobraCore.isRunningOnMono
			.setUpCLR4InMono(args)
		else if .isRunningOnUnix
			# does not compute. hmmm maybe DotGNU?
			.error('Running on UNIX, but not running Mono. Cannot support -net4.')
		else
			.setUpCLR4InDotNet4(args)
		args.add('-turbo')

	def setUpCLR4InMono(args as List<of String>)
		# look for dmcs - the Mono C# .NET 4 compiler
		found = false
		for path in Environment.getEnvironmentVariable('PATH').split(c':')
			dmcs = Path.combine(path, 'dmcs')
			if File.exists(dmcs)
				found = true
				break
		if not found
			.error('Cannot find the Mono dmcs compiler required by -net4. Make sure you have Mono 2.10+ installed and that dmcs is on your path.')
		args.add('-native-compiler:' + dmcs)

	def setUpCLR4InDotNet4(args as List<of String>)
		# should be on Windows and Microsoft.NET at this point
		# look for the Microsoft .NET 4.0 compiler
		# Unfortunately, it's mere existance can be a red herring--
		# a Windows 7 Ult 32-bit user for example, will have this file, but will still need to
		# install either .NET 4.0 or one of the Microsoft Visual 2010 products.
		
		# the 'Windows' enum is only in .NET 4:
		# windowsPath = Environment.getFolderPath(Environment.SpecialFolder.Windows)  # typically C:\Windows

		for envVarName in ['windir', 'WINDIR', 'systemroot', 'SYSTEMROOT']
			windowsPath = Environment.getEnvironmentVariable(envVarName)
			if windowsPath and windowsPath <> ''
				break
		if windowsPath is nil or windowsPath == ''
			.error('Cannot locate the Windows system directory required by -net4.')
		csc = Path.combine(windowsPath, r'Microsoft.NET\Framework\v4.0.30319\csc.exe')
		if not File.exists(csc)
			.error('Cannot find the Microsoft csc compiler required by -net4. Try installing MS .NET 4.0, or the 4.0+SDK or one of the Visual 2010 products (the Express ones are free).')
		args.add('-native-compiler:' + csc)

	def error(msg)
		print '** ERROR:', msg
		print 'Need help with the above error?'
		if .isRunningOnUnix
			print ' * Make sure you ran with sudo or as root.'
			print ' * Mono 2.6.x or Mono 2.10.x or higher are recommended.'
		else
			print ' * Make sure you ran as a Windows Administrator.'
			print ' * Install .NET or a Visual Studio product if you have not before.'
		print ' * Review http://cobra-language.com/troubleshooting'
		print ' * Ask at http://cobra-language.com/discuss'
		print ' * Ask at http://cobra-language.com/irc'
		Environment.exit(1)
		print 'Exiting from error.'

	def warning(msg)
		print '** WARNING:', msg

	def isAdmin as bool
		wi = WindowsIdentity.getCurrent
		wp = WindowsPrincipal(wi)
		return wp.isInRole(WindowsBuiltInRole.Administrator) or wi.token == IntPtr.zero


	## File system

	def copyContents(source as String, target as String)
		print 'copy from:', source
		print '       to:', target
		.copyContents(DirectoryInfo(source), DirectoryInfo(target))

	def copyContents(source as DirectoryInfo, target as DirectoryInfo)
		if not target.exists, target.create
		for sourceFile in source.getFiles
			sourceFile.copyTo(Path.combine(target.fullName, sourceFile.name), true)
		for sourceSubDir in source.getDirectories
			targetSubDir = target.createSubdirectory(sourceSubDir.name)
			.copyContents(sourceSubDir, targetSubDir)

	def deleteDir(dir as String)
		if Directory.exists(dir)
			print 'del dir  :', dir
			spacer = '          '
			_unReadOnly(dir)
			numAttempts = 3
			for attempt in 1 : numAttempts + 1
				try
					Directory.delete(dir, true)  # true = recursive
				catch IOException
					# sometimes "The directory is not empty." occurs
					if attempt == numAttempts, throw
					print spacer, 'Having trouble deleting directory. Try again in [attempt] seconds.'
					System.Threading.Thread.sleep(attempt*1_000)
					if not Directory.exists(dir)  # and sometimes it goes away!
						print spacer, 'Directory is gone.'
				if not Directory.exists(dir), break

	def _unReadOnly(dirName as String)
		_unReadOnly(DirectoryInfo(dirName))

	def _unReadOnly(dir as DirectoryInfo)
		# print 'checking -', dir
		for file in dir.getFiles
			if sharp'file.Attributes & System.IO.FileAttributes.ReadOnly'
				# print 'changing -', file
				file.attributes = sharp'file.Attributes & ~System.IO.FileAttributes.ReadOnly'
				# file.attributes = file.attributes & ~FileAttributes.ReadOnly
		for subDir in dir.getDirectories
			_unReadOnly(subDir)

	def findAndDeleteDir(baseDir as String, findDir as String)
		.findAndDeleteDir(DirectoryInfo(baseDir), findDir)

	def findAndDeleteDir(baseDir as DirectoryInfo, findDir as String)
		for sourceSubDir in baseDir.getDirectories
			if sourceSubDir.name == findDir
				.deleteDir(sourceSubDir.fullName)
			else
				.findAndDeleteDir(sourceSubDir, findDir)

	def requireDir(dir as String)
		if Directory.exists(dir)
			print 'found dir:', dir
		else
			print 'make dir :', dir
			try
				Directory.createDirectory(dir)
			catch ex as SystemException
				.error('Unable to create installation directory.\n[ex.message]\nRun as admin, or put a correct install path into a file called "[.configFileName]".')

	def startStage(description as String)
		print '====', description
		print
		# this installer relies on there being no directory changes
		assert Environment.currentDirectory.endsWith('Source')


	## Running external commands

	def runCommand(command as String, args as String) as String
		return .runCommand(command, args, true)

	def runCommand(command as String, args as String, displayOutput as bool) as String
		process as Process?
		output = .runCommand(command, args, out process, displayOutput)
		if process.exitCode, .error('Exit code from above command: [process.exitCode]')
		return output

	def runCommand(command as String, args as String, process as out Process?) as String
		return .runCommand(command, args, out process, true)

	def runCommand(command as String, args as String, process as out Process?, displayOutput as bool) as String
		"""
		Runs the given external command with the given args.
		Sets the process to the instance of Process created for this purpose.
		Returns the output, which is also displayed if displayOutput is true.
		Does not check process.exitCode.
		"""
		print 'run: [command] [args]'
		_lastCommand = command + ' ' + args
		p = Process()
		p.startInfo.fileName = command
		p.startInfo.arguments = args
		output = CobraCore.runAndCaptureAllOutput(p).trim
		process = p
		if displayOutput and output <> ''
			for line in output.replace('\r', '').split(c'\n')
				print '   : [line]'
		print
		return output

	def runSnapshotCobra(args as String) as String
		"""
		Runs the Cobra compiler.
		Prints the output and returns it.
		If Cobra gives an error, calls .error.
		"""
		process as Process?
		output = .runSnapshotCobra(args, out process)
		if process.exitCode, .error('Exit code from running SnapshotCobra: [process.exitCode]')
		return output

	def runSnapshotCobra(args as String, process as out Process?) as String
		"""
		Runs the Cobra compiler.
		Creates and "returns" the Process instance via the `process` argument.
		Prints the output and returns it.
		This does not exit on any errors. Check the process yourself.
		"""
		return .runCommand(_snapshotCompilerPath to !, args, out process)

	def runSourceCobra(args as String) as String
		process as Process?
		output = .runSourceCobra(args, out process)
		if process.exitCode, .error('Exit code from running Source Cobra: [process.exitCode]')
		return output

	def runSourceCobra(args as String, process as out Process?) as String
		return .runCommand('cobra.exe', args, out process)


	## Stages

	def printPlatform
		.startStage('Print Platform Description')
		if .isRunningOnUnix
			.printPlatformCommand('sw_vers')  # Mac OS X
			.printPlatformCommand('lsb_release -a')  # could try /etc/*-release if this fails
			.printPlatformPairCommand('Uname', 'uname -a')
		else
			.printPlatformPairCommand('WMI Op Sys Ver', 'wmic os get Caption,CSDVersion /value')
			.printPlatformCommand('system info', ['OS Name:', 'OS Version:'])
			.printPlatformPairCommand('Cmd Op Sys Ver', 'ver')
		.printPlatformPair('Virtual Machine', if(CobraCore.isRunningOnMono, 'Mono', '.NET'))
		.printPlatformPair('CLR Version', Assembly.getAssembly(Object).imageRuntimeVersion)
		.printPlatformPair('Env Command Line', Environment.commandLine)
		.printPlatformPair('Env Current Dir', Environment.currentDirectory)
		.printPlatformPair('Env OS Version', Environment.osVersion)
		.printPlatformPair('Env System Dir', Environment.systemDirectory)
		.printPlatformPair('Env Version', Environment.version)
		if .isRunningOnUnix
			.printPlatformPairCommand('Mono', 'mono --version')
		else
			.printPlatformCommand(r'dir %WINDIR%\Microsoft.Net\Framework\v* /O:-N /B')
		print

	def printPlatformPair(key as String, value)
		key += ':'
		print '[key.padRight(18)] [value]'

	def printPlatformPairCommand(key as String, command as String)
		.printPlatformPair(key, _platformCommand(command))

	def printPlatformCommand(command as String)	
		.printPlatformCommand(command, List<of String>())

	def printPlatformCommand(command as String, grepList as IList<of String>)
		output = _platformCommand(command)
		if output is nil, return
		if grepList.count > 0
			for line in output.splitLines
				found = false
				for grep in grepList
					if line.contains(grep)
						found = true
						break
				if found, _printRawLine(line)
		else
			for line in output.splitLines
				_printRawLine(line)

	def _platformCommand(command as String) as String?
		# fails silently as some platform commands may not be available
		if ' ' in command
			command, args = command.split(@[c' '], 2)
		else
			args = ''
		p = Process()
		p.startInfo.fileName = command
		p.startInfo.arguments = args
		try
			return CobraCore.runAndCaptureAllOutput(p).trim
		catch
			return nil

	def _printRawLine(line as String)
		i = line.indexOf(': ')
		if i == -1, i = line.indexOf(':\t')
		if i <> -1
			.printPlatformPair(line[:i].trim, line[i+1:].trim)
		else
			print line

	def verifyElevatedPermissions
		.startStage('Verify running as admin user')
		if not .isAdmin
			.error('Please run this executable as an admin user.')

	def verifyInstallDirectory
		.startStage('Verify installation directory')
		default = if(.isRunningOnUnix, .installDirectories[1], .installDirectories[0])
		if File.exists(.configFileName)
			# get install directory from first line of the file
			useDir = File.openText(.configFileName).readLine
			if useDir and useDir.trim.length, default = useDir.trim
		# TODO: prompt the user for the location
		.requireDir(default)
		_targetDir = default
		print

	def verifyInWorkspace
		.startStage('Verify running in workspace')
		msg = 'The current directory does not appear to be a workspace. This program is for installing from the workspace.'
		if not File.exists('Compiler.cobra'), .error(msg)
		if not Directory.exists('Snapshot'), .error(msg)
		print 'Verified.'
		print

	def askNet4
		.startStage('.NET 4.0 Prompt')
		if _willForceDotNet4
			print '-net4 was passed on the command line'
			answer = 'y'
		else
			print 'Cobra can be installed for .NET 2.0/3.0/3.5 or .NET 4.0.'
			default = 'n'
			if CobraCore.isRunningOnMono
				mono = CobraCore.monoVersionString
				if mono and mono.length >= 'x.y'.length
					if mono.startsWith('3.')
						default = 'y'
					else if mono.startsWith('2.') and mono.split(c'.')[1] in ['10', '11', '12']
						default = 'y'
			else if .isRunningOnWindows
				# windowsPath = Environment.getFolderPath(Environment.SpecialFolder.Windows) # .NET 4 only
				windowsPath = Environment.getEnvironmentVariable('WINDIR') ? Environment.getEnvironmentVariable('SYSTEMROOT')
				if windowsPath
					net4Path = Path.combine(windowsPath, r'Microsoft.NET\Framework\v4.0.30319\csc.exe')
					if File.exists(net4Path), default = 'y'
			while true
				print 'Do you want to install for .NET 4.0? \[[default]] ' stop
				answer = Console.readLine.trim
				if answer == '', answer = default
				answer = answer[0].toString.toLower
				if answer in 'yn', break
		print
		if answer == 'y'
			_willForceDotNet4 = true
			.setUpCLR4(_args)

	def verifyVirtualMachineVersion
		if CobraCore.isRunningOnMono
			.startStage('Verify Novell Mono version')
			minMonoVersion = if(_willForceDotNet4, '2.10', '2.6')
			vers = CobraCore.monoVersionString
			if vers is nil or vers.trim == ''
				.error('Cannot determine Mono version. Please install Mono [minMonoVersion] or higher.')
			else
				print 'Mono Version', vers
				parts = vers.split(c'.')
				if parts and parts[0] >= '2'
					print 'Verified >= [minMonoVersion]'
					print
				else
					.error('Mono version must be [minMonoVersion] or higher.')

	def locateSnapshotCompiler
		.startStage('Locate and test Cobra Snapshot compiler')
		_snapshotCompilerPath = 'Snapshot[.slash]cobra.exe'
		if not File.exists(_snapshotCompilerPath)
			.error('Cannot locate [_snapshotCompilerPath].')
		# Not needed; clutters the output; tends to obscure when the Snapshot is being used;
		# _snapshotCompilerPath = Path.getFullPath(_snapshotCompilerPath)
		output = .runSnapshotCobra('-about')
		assert 'The Cobra Programming Language' in output
		assert 'Copyright' in output
		assert 'Usage' in output

	def locateGacUtil(startStage as bool)
		if startStage, .startStage('Locate gacutil.exe')
		errorMsg = 'Cannot locate a gacutil. Maybe you can try again using the "Visual Studio Command Prompt" or ".NET SDK Command Prompt".'
		if _willForceDotNet4 and .isRunningOnCLR2 and .isRunningOnWindows
			programFilesDir = Environment.getFolderPath(Environment.SpecialFolder.ProgramFiles)
			if programFilesDir.length >= 2
				drive = programFilesDir[0].toString
			else
				drive = 'C'
			# the following is wrong as it will be gacutil 3.5:
			# gacutil = drive + r':\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\GacUtil.exe'
			# gacutil 4.0 lives here:
			gacutil = drive + r':\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin\NETFX 4.0 Tools\GacUtil.exe'
			if File.exists(gacutil)
				_gacutil = gacutil
				return
			.error(errorMsg)
		slash = .slash
		gacutil = 'gacutil'
		p = Process()
		p.startInfo.fileName = gacutil
		p.startInfo.arguments = '-silent'
		try
			CobraCore.runAndCaptureAllOutput(p)
			found = true
			print 'found in system PATH'
		catch FileNotFoundException
			pass
		catch ComponentModel.Win32Exception
			pass

		if not found
			# try to find the gacutil
			print 'Searching for gacutil...'
			gacutil = 'gacutil.exe'

			dirs = [
				r'Microsoft.NET\SDK\v2.0\bin',        # VS 2005 / SDK .NET 2.0
				r'Microsoft SDKs\Windows\v6.0A\bin',  # VS 2008
				r'Microsoft Visual Studio 8\SDK\v2.0\Bin',
			]

			# search %ProgramFiles% (which can differ internationally)
			programFilesDir = Environment.getFolderPath(Environment.SpecialFolder.ProgramFiles)
			for dir in dirs
				path = '[programFilesDir][slash][dir][slash][gacutil]'
				print 'checking:', path
				if File.exists(path)
					print 'found:', path
					gacutil = path
					found = true
					break
				# else, print path

			if not found
				for dir in dirs
					# search drives for X:\Program Files\...
					for drive in Directory.getLogicalDrives
						drive = drive[:1]  # normalize to just one character
						if drive <= 'B', continue
						path = '[drive]:[slash]Program Files[slash][dir][slash][gacutil]'
						print 'checking:', path
						if File.exists(path)
							print 'found:', path
							gacutil = path
							found = true
							break
						# else, print path
					if found, break

		if not found, .error(errorMsg)
		_gacutil = gacutil
		if startStage, print

	def buildCobraCompiler
		.startStage('Build new Cobra compiler')
		.runSnapshotCobra('-compile [.compileFlags] -ert:yes cobra.cobra -files:files-to-compile.text')
		if not File.exists('cobra.exe'), .error('No cobra.exe file was produced.')

	def getBaseVersion
		.startStage('Retrieve Cobra base version number')
		# It's called "base version" because it doesn't include any text after the numbers
		# "0.8.0 post release" --> "0.8.0"
		output = .runSourceCobra('-version')
		reMatch = Regex.match(output, r'svn:(\d+)')
		if reMatch.success
			assert reMatch.value
			_baseVersion = 'svn-' + reMatch.groups[1].toString
		else
			reMatch = Regex.match(output, r'\d+\.\d+\.\d+')
			if reMatch.success
				assert reMatch.value
				_baseVersion = reMatch.value
			else
				.error('Could not extract base version number.')
			_baseVersion += '-post'
		# check for an informal release
		parent = Path.getFullPath('..')
		if File.exists('[parent][.slash]InformalRelease.text')
			output = File.readAllText('[parent][.slash]InformalRelease.text')
			re = Regex(r'\d+\-\d+\-\d+')
			reMatch = re.match(output)
			if reMatch.success
				assert reMatch.value
				_baseVersion += '-' + reMatch.value
			else
				.error('Could not extract date from InformalRelease.text')
		print 'base version: [_baseVersion]'
		print

	def installLibrary(name as String, flags as String, files as String)
		.buildLibrary(name, flags, files as String)
		.installLibraryToGAC(name)
		.verifyGacInstallation(name)

	def buildLibrary(name as String, flags as String, files as String)
		"""
		Builds the copy of the Cobra Standard Library for installation to the GAC.
		Must build the library using the Source cobra.exe, not the Snapshot
		Always build with -debug since this is the copy for GAC installation. The debug info (mdb file)
		will be installed to the GAC along with the dll. This is required for the -d compiler option.
		"""
		.startStage('Build [name] library')
		.runSourceCobra('[flags] -debug [.compileFlags] -out:[name].dll -key-file:Cobra.Lang[.slash]Cobra.Lang.snk [files]')

	def installLibraryToGAC(name as String)
		.startStage('Install [name] library to the GAC')
		dllName = name + '.dll'
		if _willForceDotNet4 and .isRunningOnCLR2 and .isRunningOnWindows
			# have to run gacutil command line
			.locateGacUtil(false)
			.runCommand(_gacutil, '-i [dllName] -f')
		else
			try
				print 'Invoking Publish.GacInstall...'
				Publish().gacInstall(dllName)
				print 'Done.'
				print
			catch NotImplementedException
				print 'Not implemented exception.'
				print 'Will attempt to use gacutil.exe.'
				.locateGacUtil(false)
				.runCommand(_gacutil, '-i [dllName] -f')
			catch e as Exception
				print '[e.getType] e.message'

	def verifyGacInstallation(name as String)
		# TODO: verify the version number: Cobra.Lang, Version=0.0.1.0
		dllName = name + '.dll'
		.startStage('Verifying [dllName] installed to the GAC')
		if _willForceDotNet4 and .isRunningOnCLR2
			print 'Skipping due to running on .NET 2, but installed for .NET 4.'
			print
			return
		try 
			# temporarily rename the standard library to ensure that assembly
			# loading is attempted from the GAC.
			tmpFileName = 'temp-[Process.getCurrentProcess.id]-[dllName]'
			File.move(dllName, tmpFileName)
			# avoid warning: "System.Reflection.Assembly.LoadWithPartialName(string)" is obsolete
			# a = Assembly.loadWithPartialName(name)
			# with dynamic binding:
			assemblyType = Assembly to dynamic
			a = assemblyType.loadWithPartialName(name)
			if a is nil
				.error('After installing the library "[name]", it cannot be loaded.')
			if a.globalAssemblyCache
				print '[dllName] has been successfully installed to the GAC.'
			else
				.warning('After installing the library "[name]", it can be loaded, but does not report that it is in the GAC.')
			File.move(tmpFileName, dllName)
		catch NotImplementedException
			print 'Attempting to use gacutil.'
			if not _gacutil, .locateGacUtil(false)
			output = .runCommand(_gacutil, '-l Cobra.Lang')
			if '[dllName], Version=' in output
				print '[dllName] has been successfully installed to the GAC.'
			else
				.error('Installing the library "[name]" to the GAC was unsuccessful.')
		print		

	def verifyNewlyBuiltCobra
		.startStage('Verify newly built Cobra compiler')
		.runSourceCobra('-about')
		msg = 'Cannot run hello.cobra with new compiler.'
		if not _skipStdLib
			if File.exists('hello.exe'), File.delete('hello.exe')  # fresh start
			File.copy('Misc[.slash]hello.cobra', 'hello.cobra', true)
			hello = 'hello.cobra'
			output = .runSourceCobra('-ert:no [hello]')
			if not output.startsWith('Hello'), .error(msg)
			output = .runSourceCobra('[hello]')
			if not output.startsWith('Hello'), .error(msg)
		output = .runSourceCobra('-ert:yes [hello]')
		if not output.startsWith('Hello'), .error(msg)

	def copyFilesToInstallDirectory
		require _targetDir is not nil
		.startStage('Copy files to install directory')
		slash = .slash
		targetDir = _targetDir

		if targetDir, .requireDir(targetDir)
		if Directory.exists(Path.combine(targetDir, 'Source'))
			print 'The directory "[targetDir]" appears to contain a workspace or snapshot of the'
			print 'Cobra source code, due to containing the subdirectory "Source".'
			print 'Installing to that location can lead to confusion and technical difficulties.'
			print 'Consider clearing out "[targetDir]" and creating a workspace *inside* it called,'
			print 'for example, "Workspace".'
			print
			.error('Cannot install to workspace or workspace snapshot. See message above.')

		versionDir = '[targetDir][slash]Cobra-[_baseVersion]'  # ex: /usr/local/cobra/Cobra-0.8.0-post
		.deleteDir(versionDir)
		.requireDir(versionDir)
		_versionDir = versionDir

		# TODO: readme file?
		parent = Path.getFullPath('..')

		versionOutput = ''
		if File.exists('[parent][slash]InformalRelease.text')
			versionOutput = File.readAllText('[parent][slash]InformalRelease.text')
		else if File.exists('.svn') or File.exists('_svn')
			# record "svn info" in the installation directory
			svnFailed = 'Cannot find Subversion revision information. The svn program is not installed or it failed. This only means that the revision number of the workspace is not recorded in the installation directory for your convenience. The compiler and libraries do not rely on this.'
			try
				process as Process?
				versionOutput = .runCommand('svn', 'info', out process, false)
				if process.exitCode
					print '"svn info" failed. Check your svn installation.'
					print '[versionOutput]'
					print
					.warning(svnFailed)
			catch ex as SystemException
				# user could be on TortoiseSVN
				print 'svn is not installed or it is not in the PATH. ', ex.message
				.warning(svnFailed)
		if versionOutput <> ''
			fileName = '[versionDir][slash]Version.text'
			print 'writing  :', fileName
			File.writeAllText(fileName, versionOutput)
		print

		for dir in ['HowTo', 'Reusables', 'Samples', 'Supplements']
			.copyContents('[parent][slash][dir]', '[versionDir][slash][dir]')

		versionBinDir = '[versionDir][slash]bin'
		.requireDir(versionBinDir)
		print 'copy  bin: [versionBinDir]'
		binFiles = 'cobra.exe Cobra.Lang.dll Cobra.Sharp.*.dll WebAssets styles-cobra-doc.css styles-cobra-help.css styles-cobra-shl.css styles-exception-report.css styles-output-html.css'.split
		for fileName in binFiles
			if Directory.exists(fileName)
				.copyContents(fileName, '[versionBinDir][slash][fileName]')
			else
				for fileName2 in Directory.getFiles('.', fileName)  # glob
					File.copy(fileName2, '[versionBinDir][slash][fileName2]')

		.copyContents('Cobra.Lang', '[versionBinDir][slash]Cobra.Lang')

		# delete _svn or .svn from the installation directory
		.findAndDeleteDir(versionDir, '_svn')
		.findAndDeleteDir(versionDir, '.svn')

		# create cobra.bat / cobra for invoking the latest version
		baseBinDir = '[targetDir][slash]bin'
		.requireDir(baseBinDir)
		if .isRunningOnUnix
			_cobraCommandPath = '[baseBinDir][slash]cobra'
			print 'writing  :', _cobraCommandPath
			using f = File.createText(_cobraCommandPath)
				f.writeLine('#!/bin/sh')
				f.writeLine('exec mono "[versionDir][slash]bin[slash]cobra.exe" "$@"')
			.runCommand('chmod', "a+x '[_cobraCommandPath]'")
		else
			_cobraCommandPath = '[baseBinDir][slash]cobra.bat'
			print 'writing  :', _cobraCommandPath
			using f = File.createText(_cobraCommandPath)
				f.writeLine('@"[versionDir][slash]bin[slash]cobra.exe" %*')
			print

	def verifyNewlyInstalledCobra
		.startStage('Verify newly installed Cobra compiler')
		output = .runCommand(_cobraCommandPath, '-about', true)
		if not output.startsWith('The Cobra Programming Language')
			.error('Cannot run the installed Cobra with -about')
		output = .runCommand(_cobraCommandPath, '-ert:yes Misc[.slash]hello.cobra', true)
		if not output.startsWith('Hello')
			.error('Cannot run the installed Cobra on "hello.cobra"')

	def cleanUpWorkspace
		.startStage('Clean up workspace')
		# By removing cobra.exe and friends from the workspace,
		# we minimize the chances that the user runs the local Cobra compiler
		# instead of the installed one.
		fileNames = ['cobra.exe']
		for lib in .libs, fileNames.add(lib['name'] + '.dll')
		for fileName in fileNames
			for ext in ['', '.mdb', '.pdb']
				try, File.delete(fileName+ext)
				catch Exception, pass

	def installInPath
		.startStage('Install "cobra" into a system path directory')
		commandName = if(.isRunningOnUnix, 'cobra', 'cobra.bat')
		slash = .slash
		paths = (Environment.getEnvironmentVariable('PATH') ? '').split(Path.pathSeparator).toList
		for commandDir in paths
			if commandDir == '.', continue  # skip the 'cobra' in the <workspace>/Source directory
			# print 'checking path:', commandDir
			if commandDir.startsWith('~')
				home = Environment.getEnvironmentVariable('HOME')
				if home, commandDir = home + commandDir[1:]
			commandPath = Path.getFullPath('[commandDir][slash][commandName]')
			if File.exists(commandPath)
				print 'found in PATH:', commandPath
				found = true
				break
#		print
		baseBinDir = '[_targetDir][slash]bin'
		if found
			if String.compare(commandPath, '[baseBinDir][slash][commandName]', not .isRunningOnUnix) == 0
				# e.g., if the PATH already points to the install directory
				print 'Your PATH already contains [baseBinDir]'
				print 'so you can invoke "cobra" from any directory.'
			else
				if .newlyCompiledFileIsSymlinkedFromOneFoundOnPath(_cobraCommandPath, commandPath)
					print 'The existing "cobra" in your path is the correct'
					print 'symbolic link and has not been changed.'
				else
					.copyCobraCommandTo(commandPath, true)
		else if '/usr/local/bin' in paths
			.copyCobraCommandTo('/usr/local/bin/[commandName]', false)
		else
			# TODO: on unix, create a symlink in /usr/local/bin or /usr/bin if they exist and are in the path
			print 'The Cobra compiler is not in your PATH. To remedy you can:'
			print '1. Add [Path.getDirectoryName(_cobraCommandPath)] to your PATH'
			print '2. Copy [_cobraCommandPath] to any directory in your PATH'

	def newlyCompiledFileIsSymlinkedFromOneFoundOnPath(cobraCommandPath, commandPath) as bool
		if .isRunningOnUnix
			monoAssembly = Assembly.load('Mono.Posix, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756')
			unixFileSystemInfo = monoAssembly.getType('Mono.Unix.UnixFileSystemInfo') to dynamic
			if unixFileSystemInfo
				fileInfo = unixFileSystemInfo.getFileSystemEntry(commandPath)
				if fileInfo.isSymbolicLink and fileInfo.contentsPath == cobraCommandPath
					return true
		return false

	def copyCobraCommandTo(commandPath as String, alreadyExisted as bool)
		require commandPath.length
		print 'copy from:', _cobraCommandPath
		print '       to:', commandPath
		try, File.delete(commandPath)
		catch Exception, pass
		File.copy(_cobraCommandPath, commandPath, true)
		print
		if alreadyExisted
			print 'The existing "cobra" in your path at'
			print commandPath
			print 'has been replaced with the new one.'
		else
			print 'The "cobra" command has been installed in your PATH at'
			print commandPath