Build Clover

Posted 2020-10-13

#!/bin/bash
#set -x

# made by Micky1979 on 07/05/2016 based on Slice, Zenith432, STLVNUB, JrCs, cvad, Rehabman, and ErmaC works

# Tested in OSX using both GNU gcc and clang (Xcode 6.4, 7.2.1, 7.3.1 and Xcode 8).
# Preferred OS is El Capitan with Xcode >= 7.3.1 and Sierra with Xcode >= 8.
# In older version of OS X is better to use GNU gcc.

# Tested in linux Ubuntu (16.04 and 16.10) / Debian Jessie amd64 (x86_64).
# This script install all missing dependencies in the iso images you
# can download at the official download page here: http://releases.ubuntu.com/16.04/ubuntu-16.04.1-desktop-amd64.iso
# where nasm, subversion, curl (wget if installed is used as replacement) and or uuid-dev headers are missing.
# gcc 5.4 coming with Ubuntu 16.04 is well compiled for Clover, so no need to make a "cross" compilation of it, and 
# I hope will be the same for future version installed here. Debian Jessie instead use gcc 4.9.2 and is already good.
# Note that Debian comes without "sudo" installed (you well know this), but this script require dependecies
# described above so that you have install them by your self, or install sudo and enable it for your account.
#
# May you have apported radical and incompatible changes to your installation, but this is not my fault!
# New incoming release of Ubuntu/Debian should be compatible as well..

#
# Big thanks to the following testers:
# droples, Riley Freeman, pico joe, fantomas1, Fljagd, calibre, Mork vom Ork, Maniac10, Matgen84,
# Sherlocks, ellaosx, magnifico, AsusFreak, badruzeus, LabyOne, Ukr55, D-an-W, SavageAUS, bronxteck,
# artur_pt
# and all others (I‘ll be happy to increase this list and to not forgot anyone)
#

# --------------------------------------
SCRIPTVER="v4.5.6"
export LC_ALL=C
SYSNAME="$( uname )"
BUILDER=$USER # don‘t touch!
# ---------------------------->
# default behavior (don‘t touch these vars)
NASM_PREFERRED="2.13.01"
FORCEREBUILD=""
MAKEPKG_CMD="make pkg"
UPDATE_FLAG="YES"
BUILD_FLAG="NO"
LTO_FLAG="" # default for Xcode >= 7.3, will automatically adjusted for older ones
MOD_PKG_FLAG="YES" # used only when you add custom macros. Does nothing for normal build.
ARCH="IA32_X64" # will ask if you want IA32 (deprecated) or X64 only
DEFINED_MACRO=""
CUSTOM_BUILD="NO"
START_BUILD=""
TIMES=0
ForceEDK2Update=0 # cause edk2 to be re-updated again if > 0 (handeled by the script in more places)
SYMLINKPATH=‘/usr/local/bin/buildclover‘
SCRIPT_ABS_PATH=""
SCRIPT_ABS_LOC=""
DOWNLOADER_CMD=""
DOWNLOADER_PATH=""
SELF_UPDATE_OPT="NO" # show hide selfUpdate option
PING_RESPONSE="NO" # show hide option with connection dependency
REMOTE_EDK2_REV="" # info for developer submenu this mean to show latest rev avaiable

edk2array=(
	MdePkg
	MdeModulePkg
	CryptoPkg
	DuetPkg
	EdkCompatibilityPkg
	IntelFrameworkModulePkg
	IntelFrameworkPkg
	OvmfPkg
	OptionRomPkg
	PcAtChipsetPkg
	ShellPkg
	UefiCpuPkg
	FatPkg
	BaseTools
	)

# ---------------------------->
# additional macro to compile Clover EFI
macros=(
	USE_APPLE_HFSPLUS_DRIVER
	USE_Bios_BLOCKIO
	DISABLE_USB_SUPPORT
	NO_GRUB_DRIVERS
	NO_GRUB_DRIVERS_EMBEDDED
	ONLY_SATA_0
	DISABLE_UDMA_SUPPORT
	ENABLE_VBIOS_PATCH_CLOVEREFI
	ENABLE_PS2MOUSE_LEGACYBOOT
	DEBUG_ON_SERIAL_PORT
	ENABLE_SECURE_BOOT
	USE_ION
	DISABLE_USB_MASS_STORAGE
	ENABLE_USB_OHCI
	ENABLE_USB_XHCI
	REAL_NVRAM
	)
# defaults for all the variables, taken from the config file 
var_defaults=(
	"XCODE",,,
	"GNU",,,
	"Build_Tool",,,"XCODE"
	"SUGGESTED_CLOVER_REV",,,
	"MODE",,,"S"
	"DEFAULT_MACROS",,,"-D NO_GRUB_DRIVERS_EMBEDDED"
	"PATCHES",,,"$HOME/CloverPatches"
	"BUILD_PKG",,,"YES"
	"BUILD_ISO",,,"NO"
	"USEHFSPLUS",,,"NO"
	"USEAPFS",,,"NO"
	"USENTFS",,,"NO"
	"GITHUB",,,"https://raw.githubusercontent.com/Micky1979/Build_Clover/master/Build_Clover.command"
	"CLOVER_REP",,,"svn://svn.code.sf.net/p/cloverefiboot/code"
	"EDK2_REP",,,"svn://svn.code.sf.net/p/edk2/code/trunk/edk2"
	"DISABLE_CLEAR",,,"NO"
	"MY_SCRIPT",,,
	"FAST_UPDATE",,,"NO"
	)
# --------------------------------------
# FUNCTIONS
# --------------------------------------
usage () {
printf "\n\e[1m%s\e[0m" "Usage: $0 [--edk2rev <revision>] [--defaults]"
echo
printf "\n%s" "The following optional arguments are recognized:"
echo
printf "\n\e[1m%s\e[0m\t%s" "--edk2rev <revision>" "Overrides the defauls EDK2 revision. If <revision> is ommited or not numeric-only,"
printf "\n\t\t\t%s" "the default EDK2 revision will be used instead."
echo
printf "\n\e[1m%s\e[0m\t\t%s" "--defaults" "Ignores the config file and loads the default values for all settings in that file."
echo
printf "\n\e[1m%s\e[0m\t\t%s" "--cfg <path>" "Overrides the path to the config file. If <path> is ommited or doesn‘t exist,"
printf "\n\t\t\t%s" "the \$HOME / \$BUILD_CLOVER_CFG_PATH variables will be used instead."
echo
printf "\n%s" "If no argument is provided, the script starts in interactive mode, using the default edk2 revision"
printf "\n%s" "and the settings from the config file."
echo
}
ClearScreen() {
if [[ "$DISABLE_CLEAR" != "YES" ]]; then clear; fi
}
LoadDefaults () {
for i in "${var_defaults[@]}"
do
	eval "export \"${i%,,,*}=${i#*,,,}\""
done
}
CreateDefaultConf () {
if [[ ! -f "${userconf}" ]]; then touch "${userconf}"; fi
for i in "${var_defaults[@]}"
do
	echo "${i%,,,*}=${i#*,,,}" >> "${userconf}"
done
}
ReadConf () {
for i in "${var_defaults[@]}"
do
	if cat "${userconf}" | grep "^${i%,,,*}=" 1>/dev/null 2>&1; then
#		echo "Variable ${i%,,,*} found, loading..."
		eval "export \"$(cat ${userconf} | grep ^${i%,,,*}=)\""
	else
#		echo "Variable ${i%,,,*} not found in config, restoring defaut value..."
		echo "${i%,,,*}=${i#*,,,}" >> "${userconf}"
		eval "export \"${i%,,,*}=${i#*,,,}\""
	fi
done
}
CheckProprietary() {
local drivers_off="${DIR_MAIN}/edk2/Clover/CloverPackage/CloverV2/drivers-Off"
local ghlink="https://github.com/Micky1979/Build_Clover/raw/work/Files"
local efifiles=()

if [[ "$USEHFSPLUS" == "YES" ]]; then efifiles+=(‘HFSPlus_ia32.efi‘); efifiles+=(‘HFSPlus_x64.efi‘); fi
if [[ "$USEAPFS" == "YES" ]]; then efifiles+=(‘apfs.efi‘); fi
if [[ "$USENTFS" == "YES" ]]; then efifiles+=(‘NTFS.efi‘); fi
	
if [[ "${#efifiles[@]}" -ge "1" ]]; then
	printMessage "The following proprietary EFI drivers will be added to the Clover package:"
	printWarning "\n${efifiles[*]}\n"
else
	return 0
fi

for fname in "${efifiles[@]}"
do
	if [[ ! -f "${DIR_MAIN}/tools/${fname}" ]]; then
		printWarning "\n${fname} not found, downloading..."
		downloader "${ghlink}/${fname}" "${DIR_MAIN}/tools" "${fname}"
	fi
	printMessage "\nAdding ${fname}..."
	if [[ "${fname}" == *"_ia32"* ]]; then
		if [[ -d "${drivers_off}/drivers32" ]]; then
			cp -f "${DIR_MAIN}/tools/${fname}" "${drivers_off}/drivers32/${fname//_ia32/-32}"
		else
			printWarning "\ndrivers32 not found, maybe that arch hasn‘t been selected, skipping..."
		fi
	else
		if [[ -d "${drivers_off}/drivers64" ]]; then
			if [[ "${fname}" == *"_x64"* ]]; then
				cp -f "${DIR_MAIN}/tools/${fname}" "${drivers_off}/drivers64/${fname//_x64/-64}"
			else
				cp -f "${DIR_MAIN}/tools/${fname}" "${drivers_off}/drivers64/${fname//.efi/-64.efi}"
			fi
		else
			printWarning "\ndrivers64 not found, maybe that arch hasn‘t been selected, skipping..."
		fi
		if [[ -d "${drivers_off}/drivers64UEFI" ]]; then
			if [[ "${fname}" == *"_x64"* ]]; then
				cp -f "${DIR_MAIN}/tools/${fname}" "${drivers_off}/drivers64UEFI/${fname//_x64}"
			else
				cp -f "${DIR_MAIN}/tools/${fname}" "${drivers_off}/drivers64UEFI/${fname}"
			fi
		else
			printWarning "\ndrivers64UEFI not found, maybe that arch hasn‘t been selected, skipping..."
		fi
	fi
done
}
# --------------------------------------
CleanExit () {
if [[ -f /tmp/Build_Clover.tmp ]]; then rm -f /tmp/Build_Clover.tmp; fi
exit 0
}
# --------------------------------------
OsOpen () {
if [[ "$SYSNAME" == Darwin ]]; then
	open "${1}" > /dev/null 2>&1
else
	if which xdg-open > /dev/null; then
		xdg-open "${1}" > /dev/null 2>&1
	elif which gnome-open > /dev/null; then
		gnome-open "${1}" > /dev/null 2>&1
	fi
fi
}
# --------------------------------------
FindScriptPath () {
	local s_path s_name l_path
	local s_orig=$(which "${0}")
	if [[ -L "$s_orig" ]]; then
		[[ "$SYSNAME" == Linux ]] && l_path=$(readlink -f "$s_orig") || l_path=$(readlink "$s_orig")
		s_path=$(dirname "$l_path"); s_name=$(basename "$l_path")
	else
		s_path=$(dirname "$s_orig"); s_name=$(basename "$s_orig")
	fi
	SCRIPT_ABS_PATH=$( cd "${s_path}" && pwd )
	SCRIPT_ABS_LOC="${SCRIPT_ABS_PATH}"/"${s_name}"
}
# --------------------------------------
IsNumericOnly() {
[[ "${1}" =~ ^-?[0-9]+$ ]] && return 0 || return 1
}
# --------------------------------------
pressAnyKey(){
[[ "${2}" != noclear ]] && ClearScreen
printf "${1}\n"
read -rsp $‘Press any key to continue...\n‘ -n1 key
ClearScreen
}
# --------------------------------------
selfUpdate() {
printHeader "SELF UPDATE"
printf "\nA new Build_Clover.command is available,\n"
printf "do you want to overwrite the script? (Y/n): "
read answer
case $answer in
	Y | y)
		if [[ -f /tmp/Build_Clover.tmp ]]; then
			cat /tmp/Build_Clover.tmp > "${SCRIPT_ABS_LOC}"
			exec "${SCRIPT_ABS_LOC}"
		else
			pressAnyKey ‘Was not possible to update Build_Clover.command,‘
		fi;;
esac
}
# --------------------------------------
printThickLine() {
printf "%*s\n" 80 | tr " " "="
}
# --------------------------------------
printLine() {
printf "\n%*s\n" 80 $( printf "<%*s\n" 50 | tr " " "-" )
}
# --------------------------------------
printHeader() {
printThickLine
printf "\e[1;34m${1}\e[0m"
printLine
}
# --------------------------------------
printError() {
printf "\e[1;31m${1}\e[0m"
#exit 1
}
# --------------------------------------
printWarning() {
printf "\e[1;33m${1}\e[0m"
}
# --------------------------------------
printMessage() {
printf "\e[1;32m${1}\e[0m\040"
}
# --------------------------------------
addSymlink() {
ClearScreen
if [[ ! -d "$(dirname $SYMLINKPATH)" ]]; then
	printError "$(dirname $SYMLINKPATH) does not exist, cannot add a symlink..\n"
	pressAnyKey ‘\n‘
	build
fi
[[ "$USER" != root ]] && echo "type your password to add the symlink:"
[[ -d "${SYMLINKPATH}" ]] && sudo rm -rf "${SYMLINKPATH}" # just in case there‘s a folder with the same name
eval "sudo ln -nfs \"${SCRIPT_ABS_LOC}\" $SYMLINKPATH"
if [[ $? -ne 0 ]] ; then
	printError "\no_Ops, something wrong, cannot add the symlink..\n"
	pressAnyKey ‘\n‘ noclear
	sudo -k && build
else
	echo "now is possible to open the Terminal and type \"buildclover\""
	echo "to simply run Build_Clover.command.."
	pressAnyKey ‘..the script will be closed to allow you to do that!\n‘ noclear
	sudo -k && CleanExit
fi
}
# --------------------------------------
initialChecks() {
if [[ "$SYSNAME" == Linux ]]; then
	local depend=""
	if [[ "$(uname -m)" != x86_64 ]]; then
		printError "\nBuild_Clover.command is tested only on x86_64 architecture, aborting..\n"
		exit 1
	fi
	# check if the Universally Unique ID library - headers are installed
	[[ "$(apt-cache policy uuid-dev | grep ‘Installed: (none)‘)" =~ ‘Installed: (none)‘ ]] && depend+=" uuid-dev"
	# check if subversion is installed
	[[ ! -x $(which svn) ]] && depend+=" subversion"
	# check if python is installed
	[[ ! -x $(which python) ]] && depend+=" python"
	# check if gcc or is installed. As a workaround for Linux Mint, it checks for g++ as well
	[[ ! -x $(which gcc) || ! -x $(which g++) ]] && depend+=" build-essential"
	# check whether at least one of curl or wget are installed
	[[ ! -x $(which wget) && ! -x $(which curl) ]] && depend+=" wget"
	# installing the dependencies
	if [[ "$depend" != "" ]]; then ClearScreen; aptInstall "$depend"; fi
	# set the donloader command path
	if [[ -x $(which wget) ]]; then
		DOWNLOADER_PATH=$(dirname $(which wget))
		DOWNLOADER_CMD="wget"
	elif [[ -x $(which curl) ]]; then
		DOWNLOADER_PATH=$(dirname $(which curl))
		DOWNLOADER_CMD="curl"
	else
		printError "\nNo curl nor wget are installed! Install one of them and retry..\n"; exit 1
	fi
else
	# /usr/bin/curl!! (philip_petev)
	DOWNLOADER_PATH=/usr/bin
	DOWNLOADER_CMD="curl"
fi
}
# --------------------------------------
printCloverScriptRev() {
initialChecks
ClearScreen
local LVALUE RVALUE SVERSION RSCRIPTVER RSDATA
local SNameVer="Build_Clover script ${SCRIPTVER}"

if ping -c 1 github.com >> /dev/null 2>&1; then
	# Retrive and filter remote script version
	downloader "$GITHUB" "/tmp" "Build_Clover.tmp"
	RSCRIPTVER=$( cat /tmp/Build_Clover.tmp | grep ‘^SCRIPTVER="v‘ | tr -cd ‘.0-9‘ )
	LVALUE=$( echo $SCRIPTVER | tr -cd [:digit:] )
	RVALUE=$( echo $RSCRIPTVER | tr -cd [:digit:] )

	printThickLine
	if IsNumericOnly $RVALUE; then
		# Compare local and remote script version
		[[ $LVALUE -ge $RVALUE ]] && SELF_UPDATE_OPT="NO" || SELF_UPDATE_OPT="YES"
		[[ $LVALUE -eq $RVALUE ]] && printf "\e[1;34m${SNameVer}\e[1;32m%*s\e[0m" $((80-${#SNameVer})) "No update available."
		[[ $LVALUE -gt $RVALUE ]] && printf "\e[1;34m${SNameVer}\e[1;33m%*s\e[0m" $((80-${#SNameVer})) "Wow, are you coming from the future?"
		[[ $LVALUE -lt $RVALUE ]] && printf "\e[1;34m${SNameVer}\e[1;5;33m%*s\e[0m" $((80-${#SNameVer})) "Update available (v$RSCRIPTVER)"
	else
		printf "${SNameVer}\e[1;31m\n%s\e[0m" "Remote version unavailable due to unknown reasons!"
	fi
else
	printThickLine
	printf "${SNameVer}\e[1;31m\n%s\n%s\e[0m" "Remote version unavailable, because GitHub is unreachable," "check your internet connection!"
fi
printLine
}
# --------------------------------------
printRevisions() {
local Clover_Remote Clover_Local EDK2_Remote EDK2_Local
local Unknown="\e[1;31munknown"
# Checking if the local and remote revisions are empty or not
[[ -z "$REMOTE_REV" || -z "$REMOTE_EDK2_REV" ]] && PING_RESPONSE="NO" || PING_RESPONSE="YES"
[[ -z "$REMOTE_REV" ]] && Clover_Remote="$Unknown" || Clover_Remote="$REMOTE_REV"
[[ -z "$LOCAL_REV" ]] && Clover_Local="$Unknown" || Clover_Local="$LOCAL_REV"
[[ -z "$REMOTE_EDK2_REV" ]] && EDK2_Remote="$Unknown" || EDK2_Remote="$REMOTE_EDK2_REV"
[[ -z "$LOCAL_EDK2_REV" ]] && EDK2_Local="$Unknown" || EDK2_Local="$LOCAL_EDK2_REV"

# Coloring the local revisions green (if they‘re equal to the remote revisions) or yellow (if they‘re not)
[[ "${Clover_Local}" == "${Clover_Remote}" ]] && Clover_Remote="\e[1;32m${Clover_Remote}" || Clover_Remote="\e[1;33m${Clover_Remote}"
[[ "${EDK2_Local}" == "${EDK2_Remote}" ]] && EDK2_Remote="\e[1;32m${EDK2_Remote}" || EDK2_Remote="\e[1;33m${EDK2_Remote}"

# Printing the results on screen	
printf "\e[1;32mCLOVER\tRemote revision: %b\t\e[1;32mLocal revision: %b\e[0m" "${Clover_Remote}" "${Clover_Local}"
printf "\n\e[1;32mEDK2\tRemote revision: %b\t\e[1;32mLocal revision: %b\e[0m\n" "${EDK2_Remote}" "${EDK2_Local}"

# Printing the error messages in case the local and remote revisions are empty
[[ "$Clover_Remote" == "$Unknown" ]] && printError "Something went wrong while getting the CLOVER remote revision,\ncheck your internet connection!\n"
[[ "$Clover_Local" == "$Unknown" ]] && printError "Something went wrong while getting the CLOVER local revision!\n"
[[ "$EDK2_Remote" == "$Unknown" ]] && printError "Something went wrong while getting the EDK2 remote revision,\ncheck your internet connection!\n"
[[ "$EDK2_Local" == "$Unknown" ]] && printError "Something went wrong while getting the EDK2 local revision!\n"

# Checking if the local EDK2 revision is the suggested one or not
echo
if [[ "${cus_edk2}" == "Y" ]]; then
	printWarning "User-provided EDK2 revision: ${EDK2_REV}\n\n"
fi
if [[ "${LOCAL_EDK2_REV}" == "${EDK2_REV}" ]]; then
	printMessage "The current local EDK2 revision is the suggested one (${EDK2_REV})."
else
	printWarning "\e[5mThe current local EDK2 revision is not the suggested one (${EDK2_REV})!"
	printWarning "\nIt‘s recommended to change it to the suggested one,"
	printWarning "\nusing the \e[1;32mupdate Clover + force edk2 update\e[1;33m option!"
fi
if [[ "${useDefaults}" == "Y" ]]; then
	printMessage "\nUsed settings: default"
else
	printMessage "\nUsed settings: \e[1;33m${userconf}\e[0m"
fi
printLine
}
# --------------------------------------
downloader(){
#$1 link
#$2 path (where will be saved)
#$3 file name
local cmd=""
case "$DOWNLOADER_CMD" in
	wget )	cmd="${DOWNLOADER_PATH}/${DOWNLOADER_CMD} -qO- ${1}";;
	curl )	cmd="${DOWNLOADER_PATH}/${DOWNLOADER_CMD} -sL ${1}";;
	* ) printError "\nNo curl nor wget are installed! Install one of them and retry..\n"; exit 1;;
esac
if [[ ! -z "${2}" && ! -z "${3}" && -d "${2}" ]]; then
	case "$DOWNLOADER_CMD" in
		wget ) cmd="${DOWNLOADER_PATH}/${DOWNLOADER_CMD} -qO ${2}/${3} ${1}";;
		curl ) cmd="${DOWNLOADER_PATH}/${DOWNLOADER_CMD} -sL -o ${2}/${3} ${1}";;
	esac
	if [[ -d "${2}/${3}" ]]; then rm -rf "${2}/${3}"; fi
fi
eval "${cmd}"
}
# --------------------------------------
aptInstall() {
if [[ -z "${1}" ]]; then return; fi
printWarning "Build_Clover need this:\n"
printError "${1:1}\n"
printWarning "..to be installed, but was not found.\n"
printWarning "Would you allow to install it? (Y/N)\n"
read answer
case $answer in
	Y | y ) if [[ "$USER" != root ]]; then echo "type your password to install:"; fi
			sudo apt-get update
			sudo apt-get install$1;;
	*) printError "Build_Clover cannot go ahead without it/them, process aborted!\n"; exit 1;;
esac
sudo -k
}
# --------------------------------------
# Upgrage SVN working copy
svnUpgrade () {
svn info "${DIR_MAIN}/edk2/Clover" 2>&1 | grep ‘svn upgrade‘
# if the svn working directory is outdated, let the user know
if [[ $? -eq 0 ]]; then
	printError "Error: You need to upgrade the working copy first.\n"
	for workingCopy in `find "${DIR_MAIN}/edk2" -name "*.svn"`
	do
		if [[ -d "$(dirname $workingCopy)" ]]; then
			printWarning "Would you like to upgrade the, $(dirname $workingCopy), working copy? (y/n)\n"
			read input
			case $input in
				Y | y) printWarning "Upgrading $(dirname $workingCopy).\n"; svn upgrade "$(dirname $workingCopy)";;
				*) printWarning "You may encounter errors!\n";;
			esac
		fi
	done
fi
}
# --------------------------------------
# Remote and local revisions
getRev() {
if ping -c 1 svn.code.sf.net >> /dev/null 2>&1; then
	REMOTE_REV=$(svn info ${CLOVER_REP} | grep ‘^Revision:‘ | tr -cd [:digit:])
	REMOTE_EDK2_REV=$(svn info ${EDK2_REP} | grep ‘^Revision:‘ | tr -cd [:digit:])
else
	REMOTE_REV=""
	REMOTE_EDK2_REV=""
fi

if [[ -d "${DIR_MAIN}"/edk2/Clover/.svn ]]; then
	svnUpgrade # upgrade the working copy to avoid errors
	LOCAL_REV=$(svn info "${DIR_MAIN}"/edk2/Clover | grep ‘^Revision:‘ | tr -cd [:digit:])
else
	LOCAL_REV=""
fi
if [[ -d "${DIR_MAIN}"/edk2/.svn ]]; then
	LOCAL_EDK2_REV=$(svn info "${DIR_MAIN}"/edk2 | grep ‘^Revision:‘ | tr -cd [:digit:])
else
	LOCAL_EDK2_REV=""
fi
}
# --------------------------------------
selectArch () {
archs=(
	‘Standard x64 only‘
	‘ia32 and x64 (ia32 is deprecated)‘
	‘ia32 only (deprecated)‘
	‘Back to Main Menu‘
	‘Exit‘
)
ClearScreen
printHeader "Select the desired architecture"
if [[ -n "$1" ]]; then echo "$1"; echo; fi
local count=1
for op in "${archs[@]}"
do
	case "${op}" in
		‘Standard x64 only‘ ) printf "\e[1;36m\t ${count}) ${op}\e[0m\n";;
		* ) printf "\t $count) ${op}\n";;
	esac
	((count+=1))
done
printf ‘? ‘ && read opt
case $opt in
	1 ) ARCH="X64";;
	2 ) ARCH="IA32_X64";;
	3 ) ARCH="IA32";;
	4 ) ClearScreen && BUILDER=$USER && build;;
	5 ) CleanExit;;
	* ) selectArch "invalid choice!";;
esac
if [[ "$SYSNAME" == Darwin && "$LOCAL_REV" -ge "4073" ]]; then slimPKG; fi
}
# --------------------------------------
slimPKG () {
archs=(
	‘Standard‘
	‘slim pkg that skip themes and CloverThemeManager.app‘
	‘slim pkg that skip themes and CloverThemeManager.app, updater and PrefPanel‘
	‘slim pkg UEFI only, without RC Scripts, themes & CTM, updater and PrefPanel‘
	‘Back to Select architecture menu‘
	‘Exit‘
)
ClearScreen
printHeader "Select the desired pkg type"
if [[ -n "$1" ]]; then echo "$1" && echo; fi
local count=1
for op in "${archs[@]}"
do
	case "${op}" in
		‘Standard‘ ) printf "\e[1;36m\t ${count}) ${op}\e[0m\n";;
		* ) printf "\t $count) ${op}\n";;
	esac
	((count+=1))
done
printf ‘? ‘ && read opt
case $opt in
	1 ) MAKEPKG_CMD="make pkg";;
	2 ) MAKEPKG_CMD="make slimpkg1";;
	3 ) MAKEPKG_CMD="make slimpkg2";;
	4 ) MAKEPKG_CMD="make slimpkg3";;
	5 ) ClearScreen && selectArch;;
	6 ) CleanExit;;
	* ) slimPKG "invalid choice!";;
esac
}
# --------------------------------------
cleanCloverV2 () {
c2paths=(
	"Bootloaders/ia32/boot3"
	"Bootloaders/x64/boot6"
	"Bootloaders/x64/boot7"
	"EFI/BOOT/BOOTIA32.efi"
	"EFI/BOOT/BOOTX64.efi"
	"EFI/CLOVER/CLOVERIA32.efi"
	"EFI/CLOVER/CLOVERX64.efi"
	"EFI/CLOVER/drivers32"
	"EFI/CLOVER/drivers32UEFI"
	"EFI/CLOVER/drivers64"
	"EFI/CLOVER/drivers64UEFI"
	"drivers-Off/drivers32"
	"drivers-Off/drivers32UEFI"
	"drivers-Off/drivers64"
	"drivers-Off/drivers64UEFI"
)
if [[ -d "${CLOVERV2_PATH}" ]]; then
	for i in "${c2paths[@]}"
	do
		rm -rf "${CLOVERV2_PATH}/${i}"
	done
fi
}
# --------------------------------------
# Function: to manage PATH
pathmunge () {
if [[ ! $PATH =~ (^|:)$1(:|$) ]]; then
	if [[ "${2:-}" = "after" ]]; then
		export PATH=$PATH:$1
	else
		export PATH=$1:$PATH
	fi
fi
}
# --------------------------------------
checkXcode () {
if [[ ! -x /usr/bin/gcc ]]; then printError "Xcode clt not found, exiting!\n"; exit 1; fi
if [[ ! -x /usr/bin/xcodebuild ]]; then printError "xcodebuild not found, exiting!\n"; exit 1; fi
# Autodetect the Xcode version if no specific version is set (XCODE) and disable LTO if Xcode is version 7.2.x or earlier
if [[ "$XCODE" == "" ]]; then
	local xcversion=$(/usr/bin/xcodebuild -version | grep ‘Xcode‘ | awk ‘{print $NF}‘)
	case "$xcversion" in
		[1-6]* | 7 | 7.[0-2]*) XCODE="XCODE5"; LTO_FLAG="--no-lto";;
		7.[34]*) XCODE="XCODE5";;
		8*) XCODE="XCODE8";;
		9*) XCODE="XCODE8";;
		*) printError "Unknown Xcode version format, exiting!\n"; exit 1;;
	esac
fi
}
# --------------------------------------
doSomething() {
# $1 = option
# $2 = cmd
# $3 = first argument
# $4 = second argument
# $5 = ... and so on
local cmd=""
case "$1" in
	--run-script ) 
		if [[ -x "${2}" ]]; then
			# rebuild the cmd + all args
			cmd=$(echo "[email protected]" | sed -e ‘s:--run-script ::g‘ | sed -e ‘s/[[:space:]]*$//‘)
		else
			echo
			echo "doSomething: \"--run-script\" option require you to add a script somewhere.."
			echo
		fi;;
		* ) printError "doSomething: invalid \"--run-script\" long option not specified\n"; exit 1;;
esac
eval "${cmd}"
if [[ $? -ne 0 ]] ; then printError "\no_Ops, $2 exited with error(s), aborting..\n"; exit 1; fi
}
# --------------------------------------
exportPaths() {
# STLVNUB
if [[ "$SYSNAME" == Linux ]]; then
	export TOOLCHAIN_DIR="/usr"
else
	export TOOLCHAIN_DIR="${DIR_MAIN}"/opt/local
fi
export PREFIX="$TOOLCHAIN_DIR"
if [[ -f "/opt/local/bin/nasm" ]]; then
	export NASM_PREFIX="/opt/local/bin/"
elif [[ -f "${TOOLCHAIN_DIR}/bin/nasm" ]]; then
	export NASM_PREFIX="${TOOLCHAIN_DIR}/bin/"
else
	# default for this script!
	export NASM_PREFIX="${TOOLCHAIN_DIR}/bin/"
fi
export DIR_TOOLS=${DIR_TOOLS:-$DIR_MAIN/tools}
export DIR_DOWNLOADS=${DIR_DOWNLOADS:-$DIR_TOOLS/download}
export DIR_LOGS=${DIR_LOGS:-$DIR_TOOLS/logs}
}
# --------------------------------------
exportXcodePaths() {
# Add XCode bin directory for the command line tools to the PATH
pathmunge "$(xcode-select --print-path)"/usr/bin
# Add toolchain bin directory to the PATH
pathmunge "$TOOLCHAIN_DIR"/bin
}
# --------------------------------------
svnWithErrorCheck() {
# $1 = svn command to be execute
# $2 = containing folder of our /.svn we are attempting to work on
# $3 = reserved argument ("once") indicating we are calling ‘svn resolve‘
# $4 = reserved argument equal to initial $1 command string

if [[ -z "${1}" ]]; then return; fi

local cmd="${1}"
if [[ -n "${4}" ]]; then cmd="${4}"; fi

echo "" > "${SVN_STDERR_LOG}"
if [[ ! -x $(which tee) ]]; then
	eval "${cmd}" 2> "${SVN_STDERR_LOG}"
else
	eval "${cmd}" 2>&1  | tee -a "${SVN_STDERR_LOG}"
fi

local errors=(
	"svn: E"
	"Unable to connect"
	"Unknown hostname"
	"timeout"
	"time out" 
)
local ErrCount=0

# try to resolve conflicts if any
if [[ -n "${2}" && "${3}" != once ]]; then
	if grep -q "Tree conflict can only be resolved to ‘working‘ state" "${SVN_STDERR_LOG}" || 		grep -q "Node remains in conflict" "${SVN_STDERR_LOG}"; then
		printWarning "Calling svn resolve..\n"
		svnWithErrorCheck "svn resolve ${2}" "${2}" once "${1}"
	fi
fi

for err in "${errors[@]}"
do
	if grep -q "${err}" "${SVN_STDERR_LOG}"; then ((ErrCount+=1)); break; fi
done
if [[ "${ErrCount}" -ge "1" ]];then
	echo
	printError "An error was encountered syncing the repository:\n"
	echo "------------------------------"
	echo "$( cat ${SVN_STDERR_LOG} )"
	echo
	echo "------------------------------"
	printError "Can be temporarily, retry later or seek for help.\n"
	exit 1
fi
}
# --------------------------------------
IsLinkOnline() {
if [[ $FAST_UPDATE != NO ]]; then return 1; fi
if [[ -z "${1}" ]]; then printError "IsLinkOnline() require a link as argument!"; exit 1; fi

((TIMES+=1))
printf "\e[1;35mchecking..\e[0m"
svn info "${1}" > /dev/null
if [[ $? -eq 0 ]]; then
	printf "\e[1;32mavailable, continuing..\e[0m\n"
	TIMES=0
	return 1 # Success!
else
	if [[ $TIMES -ge 5 ]]; then
		printError "\nError: unable to access ${1} after $TIMES attempts.";
		printError "\nBuild_Clover go to fail voluntarily to avoid problems,";
		printError "\ncheck your internet connection or retry later!\n\n";
		return 0
	else
		# retry..
		IsLinkOnline "${1}"
	fi
fi
}
# --------------------------------------
IsPathWritable() {
local result=1
# file/folder exists?
if [[ ! -e "${1}" ]]; then printWarning "${1} does not exist!\n"; return $result; fi
if [[ -w "${1}" ]]; then
	printMessage "${1} is writable!\n"
	result=0
else
	printWarning "${1} is not writable!\n"
fi
return $result
}
# --------------------------------------
edk2() {
local revision="-r $EDK2_REV"
local updatelink="https://sourceforge.net/p/cloverefiboot/code/HEAD/tree/update.sh?format=raw"
local edk2ArrayOnline=(
	$( downloader "$updatelink" | grep ‘cd ..‘ | sed -e ‘s/^cd ..\///‘ | sed -e ‘s/\/$//‘ | sed -e ‘/Clover/d‘ 	| sed -e ‘s:BaseTools/Conf:BaseTools:g‘ )
)
# use only if populated, otherwise use the static "edk2array"
if [[ "${#edk2ArrayOnline[@]}" -ge "1" ]]; then unset -v edk2array; edk2array=( "${edk2ArrayOnline[@]}" ); fi

if [[ "$ForceEDK2Update" -ne "1979" ]]; then
	if [[ ! -d "${DIR_MAIN}/edk2/.svn" ]]; then ForceEDK2Update=1; fi
	for d in "${edk2array[@]}"
	do
		if [[ "$d" != Source && "$d" != Scripts ]]; then
			if [[ ! -d "${DIR_MAIN}/edk2/${d}/.svn" ]]; then ForceEDK2Update=1; fi
		fi
	done
fi

if [[ "$ForceEDK2Update" -eq "0" ]]; then
	if [[ "${LOCAL_EDK2_REV}" == "${EDK2_REV}" ]]; then
		printWarning "edk2 appear to be up to date, skipping ...\n"
	else
		printWarning "edk2 is not up to date, but no forced edk2 update is selected, skipping ...\n"
	fi
else
	echo
	if [[ ! -d "${DIR_MAIN}/edk2" ]]; then
		printHeader ‘Downloading edk2‘
		mkdir -p "${DIR_MAIN}"/edk2
	else
		if [[ "$ForceEDK2Update" -eq "1979" ]]; then
			printHeader ‘Updating edk2 (forced)‘
		else
			printHeader ‘Updating edk2‘
		fi
	fi
	TIMES=0
	cd "${DIR_MAIN}"/edk2
	IsLinkOnline $EDK2_REP
	# I want ".svn", also empty at the specified revision! .. so I can update!
	svnWithErrorCheck "svn --depth empty co $revision --non-interactive --trust-server-cert $EDK2_REP ."
	printf "\n\e[1;34medksetup.sh:\e[0m\n"
	IsLinkOnline $EDK2_REP/edksetup.sh
	svnWithErrorCheck "svn update --accept tf --non-interactive --trust-server-cert $revision edksetup.sh" "$(pwd)"
	for d in "${edk2array[@]}"
	do
		if [[ "$d" != "Source" && "$d" != "Scripts" ]]; then
			printf "\n\e[1;34m${d}:\e[0m\n"
			TIMES=0
			IsLinkOnline "$EDK2_REP/${d}"
			cd "${DIR_MAIN}"/edk2
			if [[ -d "${DIR_MAIN}/edk2/${d}" ]] ; then
				if [[ -d "${DIR_MAIN}/edk2/${d}/.svn" ]] ; then
					cd "${DIR_MAIN}/edk2/${d}"
					svnWithErrorCheck "svn update --accept tf --non-interactive --trust-server-cert $revision" "$(pwd)"
					if [[ "$d" == "BaseTools" ]]; then ForceEDK2Update=1979; fi
				else
					printWarning ".svn missing, the ${d} repo may be corrupted, re-downloading...\n"
					cd "${DIR_MAIN}/edk2/${d}"
					rm -rf ./* > /dev/null 2>&1
					svnWithErrorCheck "svn co $revision --non-interactive --trust-server-cert $EDK2_REP/${d} ."
				fi
			else
				cd "${DIR_MAIN}"/edk2
				svnWithErrorCheck "svn co $revision --non-interactive --trust-server-cert $EDK2_REP/${d}"
			fi
		fi
	done
	if [[ "$ForceEDK2Update" -eq "1979" ]]; then
		printHeader "cleaning BaseTools and Clover / Clover Package"
		echo
		if [[ -d "${DIR_MAIN}/edk2/BaseTools" ]]; then cd "${DIR_MAIN}/edk2/BaseTools"; make clean; fi
		if [[ -d "${DIR_MAIN}/edk2/Clover" ]]; then cd "${DIR_MAIN}/edk2/Clover"; ./ebuild.sh clean; fi
		if [[ -d "${DIR_MAIN}/edk2/Clover/CloverPackage" ]]; then cd "${DIR_MAIN}/edk2/Clover/CloverPackage"; make clean; fi
		FORCEREBUILD="-fr"
	fi
	ForceEDK2Update=0
fi
}
# --------------------------------------
clover() {
local cmd=""
# check if SUGGESTED_CLOVER_REV is set
if [[ -z "$SUGGESTED_CLOVER_REV" ]]; then
	echo
	if [[ ! -d "${DIR_MAIN}/edk2/Clover" ]]; then
		printHeader ‘Downloading Clover, using the latest revision‘
		if IsNumericOnly "${REMOTE_REV}"; then
			mkdir -p "${DIR_MAIN}"/edk2/Clover
			cmd="svn co -r $REMOTE_REV --non-interactive --trust-server-cert ${CLOVER_REP} ."
		else
			printError "Unable to get latest Clover revision, check your internet connection or try later.\n"
			exit 1
		fi
	else
		if [[ "${LOCAL_REV}" == "" ]]; then
			printHeader ‘Clover local repo not found or damaged, downloading the latest revision‘
			rm -rf "${DIR_MAIN}"/edk2/Clover/* > /dev/null 2>&1
			cmd="svn co -r $REMOTE_REV --non-interactive --trust-server-cert ${CLOVER_REP} ."
		else
			printHeader ‘Updating Clover, using the latest revision‘
			cmd="svn up --accept tf --non-interactive --trust-server-cert"
		fi
	fi
else
	if [[ ! -d "${DIR_MAIN}/edk2/Clover" ]] ; then
		printHeader "Downloading Clover, using the specific revision r${SUGGESTED_CLOVER_REV}"
		mkdir -p "${DIR_MAIN}"/edk2/Clover
		cmd="svn co -r $SUGGESTED_CLOVER_REV --non-interactive --trust-server-cert ${CLOVER_REP} ."
	else
		if [[ "${LOCAL_REV}" == "" ]]; then
			printHeader "Clover local repo not found or damaged, downloading the specific revision r${SUGGESTED_CLOVER_REV}"
			rm -rf "${DIR_MAIN}"/edk2/Clover/* > /dev/null 2>&1
			cmd="svn co -r $SUGGESTED_CLOVER_REV --non-interactive --trust-server-cert ${CLOVER_REP} ."
		else 
			printHeader "Updating Clover, using the specific revision r${SUGGESTED_CLOVER_REV}"
			cmd="svn up --accept tf --non-interactive --trust-server-cert -r $SUGGESTED_CLOVER_REV"
		fi
	fi
fi
TIMES=0
IsLinkOnline ${CLOVER_REP}
cd "${DIR_MAIN}"/edk2/Clover
svnWithErrorCheck "$cmd" "$(pwd)"
printHeader ‘Apply Edk2 patches‘
cp -R "${DIR_MAIN}"/edk2/Clover/Patches_for_EDK2/* "${DIR_MAIN}"/edk2/

# in Lion cp cause error with subversion (comment this line and enable next)
# rsync -rv --exclude=.svn "${DIR_MAIN}"/edk2/Clover/Patches_for_EDK2/ "${DIR_MAIN}"/edk2
}
# --------------------------------------
needGETTEXT() {
local gettextPath=""
local gettextArray=( $(which -a gettext) )
local needInstall=1
if [[ ${#gettextArray[@]} -ge "1" ]]; then
	for i in "${gettextArray[@]}"
	do
		echo "found gettext at $(dirname ${i})"
	done
else
	needInstall=0
	echo "gettext not found.."
fi
return $needInstall
}
# --------------------------------------
isNASMGood() {
# nasm should be greater or equal to 2.12.02 to be good building Clover.
# There was a bad macho relocation in outmacho.c, fixed by Zenith432
# and accepted by nasm devel during 2.12.rcxx (release candidate)
result=1
local nasmver=$( "${1}" -v | grep ‘NASM version‘ | awk ‘{print $3}‘ )
case "$nasmver" in
	2.12.0[2-9]* | 2.12.[1-9]* | 2.1[3-9]* | 2.[2-9]* | [3-9]* | [1-9][1-9]* ) result=0;;
	* ) printWarning "Unknown or unsupported NASM version found at:\n${1}\nDownloading the preferred one (${NASM_PREFERRED})...\n\n";;
esac
return $result
}
# --------------------------------------
ebuildBorg () {
if [[ "$MOD_PKG_FLAG" != YES ]]; then return; fi
local NR=0
if [[ "$SYSNAME" == Darwin ]]; then printHeader ‘Modding package resources‘; fi
	
case "$ARCH" in
IA32_X64 | X64 )
	local oldTitle=‘cloverEFI.64.blockio_title‘
	local oldDesc=‘cloverEFI.64.blockio_description‘
	local newTitle=‘"cloverEFI.64.blockio_title" = "Custom CloverEFI 64-bits (boot7)";‘
	local newDesc=$(echo "\"cloverEFI.64.blockio_description\" = \"Built using Build_Clover.command with: ${DEFINED_MACRO}\";")
	if grep -q "cloverEFIFile=boot\$((6 + USE_BIOS_BLOCKIO))" "${ebuild}"; then
		cat "${ebuild}" 			| sed -e ‘s/cloverEFIFile=boot\$((6 + USE_BIOS_BLOCKIO))/cloverEFIFile=boot7/g‘ > "${ebuildB}"
		chmod +x "${ebuildB}"
	else
		printError "Error: ebuild.sh changed, this script need to be updated!\n"
		exit 1
	fi;;
IA32 )
	local oldTitle=‘cloverEFI.32_title‘
	local oldDesc=‘cloverEFI.32_description‘
	local newTitle=‘"cloverEFI.32_title" = "Custom CloverEFI 32-bits (boot3)";‘
	local newDesc=$(echo "\"cloverEFI.32_description\" = \"Built using Build_Clover.command with: ${DEFINED_MACRO}\";");;
esac

if [[ "$SYSNAME" != Darwin ]]; then return; fi

# modding po files
cp -R "${LOCALIZABLE_FILE}" /tmp/
set +e # handle the error by ourself
err=0

if [[ -f /tmp/Localizable.strings ]]; then
	NR=$(grep -n "${oldTitle}" /tmp/Localizable.strings | grep -Eo ‘^[^:]+‘)
	sed -i "" "${NR}s/.*/${newTitle}/" /tmp/Localizable.strings
	# waiting file reappear
	until [ -f /tmp/Localizable.strings ]; do sleep 0.3; done
	NR=$(grep -n "${oldDesc}" /tmp/Localizable.strings | grep -Eo ‘^[^:]+‘)
	sed -i "" "${NR}s/.*/${newDesc}/" /tmp/Localizable.strings
	# waiting file reappear
	until [ -f /tmp/Localizable.strings ]; do sleep 0.3; done
	if (! grep -q "${newTitle}" /tmp/Localizable.strings); then
		printError "Error: in /tmp/Localizable.strings, no changes applied..\n"
		((err+=1))
	fi
	if (! grep -qe "${DEFINED_MACRO}" /tmp/Localizable.strings); then
		printError "Error: in /tmp/Localizable.strings, no changes applied..\n"
		((err+=1))
	fi
else
	printError "Error: Localizable.strings not found\n"
	((err+=1))
fi
if [[ "$err" -eq 0 ]]; then
	mv -f "${LOCALIZABLE_FILE}" "${LOCALIZABLE_FILE}.back"
	mv /tmp/Localizable.strings "${LOCALIZABLE_FILE}"
	cp -R "${PKG_PATH}/po" "${PKG_PATH}/po_back"
	echo "success!"
	echo $ThickLine
fi
set -e
}
# --------------------------------------
restoreClover () {
if [[ -f "${LOCALIZABLE_FILE}.back" ]]; then
	mv -f "${LOCALIZABLE_FILE}.back" "${LOCALIZABLE_FILE}"
fi
if [[ -f "${CLOVERV2_PATH}/Bootloaders/x64/boot7-MCP79.back" ]]; then
	mv -f "${CLOVERV2_PATH}/Bootloaders/x64/boot7-MCP79.back" "${CLOVERV2_PATH}/Bootloaders/x64/boot7-MCP79"
fi
if [[ -d "${PKG_PATH}/po_back" ]]; then
	cp -R "${PKG_PATH}/po_back" "${PKG_PATH}/po"
	rm -rf "${PKG_PATH}/po_back"
fi
if [[ -f "${ebuildB}" ]]; then
	rm -f "${ebuildB}"
fi
}
# --------------------------------------
buildEssentials() {
echo
# ensure custom paths exists
mkdir -p "${TOOLCHAIN_DIR}"/bin
mkdir -p "${DIR_TOOLS}"
mkdir -p "${DIR_DOWNLOADS}"
mkdir -p "${DIR_LOGS}"

# no mach-o in linux,
printHeader "nasm check:"
if [[ ! -x "${NASM_PREFIX}"nasm ]] || ! isNASMGood "${NASM_PREFIX}"nasm; then
	FORCEREBUILD="-fr" # the path to nasm can now be different in generated make files: it is safe to autogen it again!
	printWarning "NASM not found or not the proper version, installing the preferred one..."
	if [[ -d "${DIR_DOWNLOADS}"/source.download ]]; then rm -rf "${DIR_DOWNLOADS}"/source.download/*; else mkdir -p "${DIR_DOWNLOADS}"/source.download; fi
	# NASM_PREFIX (the folder) can be writable or not, but also NASM_PREFIX can be writable and an old nasm inside it not writable because owned by root!
	cd "${DIR_DOWNLOADS}"/source.download

	case "$SYSNAME" in
		Linux )
			printMessage "\nDownloading the preferred version (${NASM_PREFERRED})..."
			downloader "http://www.nasm.us/pub/nasm/releasebuilds/${NASM_PREFERRED}/nasm-${NASM_PREFERRED}.tar.gz" "${DIR_DOWNLOADS}/source.download" "${NASM_PREFERRED}.tar.gz"
			tar -zxf "${NASM_PREFERRED}".tar.gz
			cd "${DIR_DOWNLOADS}/source.download/nasm-${NASM_PREFERRED}"
			printMessage "\n[ NASM ] configure..."
			./configure --prefix="${PREFIX}" 1> /dev/null 2> "${DIR_LOGS}"/nasm-"${NASM_PREFERRED}".config.log.txt
			printMessage "\n[ NASM ] make..."
			make CC=gcc 1> /dev/null 2> "${DIR_LOGS}"/nasm-"${NASM_PREFERRED}".make.log.txt
			printMessage "\n[ NASM ] make install..."
			if ! IsPathWritable "${NASM_PREFIX}"; then
				echo
				echo "installing nasm to ${NASM_PREFIX} require sudo because"
				echo "is not writable by $BUILDER:"
				sudo make install 1> /dev/null 2> "${DIR_LOGS}"/nasm-"${NASM_PREFERRED}".install.log.txt
				sudo -k
			else
				make install 1> /dev/null 2> "${DIR_LOGS}"/nasm-"${NASM_PREFERRED}".install.log.txt
			fi;;
		Darwin )
			printMessage "\nDownloading the preferred version for macOS (${NASM_PREFERRED})..."
			downloader "http://www.nasm.us/pub/nasm/releasebuilds/${NASM_PREFERRED}/macosx/nasm-${NASM_PREFERRED}-macosx.zip" "${DIR_DOWNLOADS}/source.download" "${NASM_PREFERRED}.zip"
			printMessage "\nInstalling..."
			unzip "${NASM_PREFERRED}".zip 1> /dev/null
			if ! IsPathWritable "${NASM_PREFIX}"; then
				echo
				echo "installing nasm to ${NASM_PREFIX} require sudo because"
				echo "is not writable by $BUILDER:"
				sudo cp -R "nasm-${NASM_PREFERRED}"/nasm "${NASM_PREFIX}" && sudo -k # exiting sudo immediately!
			else
				cp -R "nasm-${NASM_PREFERRED}"/nasm "${NASM_PREFIX}"
			fi;;
	esac

	# check the installation made:
	if [[ -x "${NASM_PREFIX}"nasm ]] && isNASMGood "${NASM_PREFIX}"nasm; then
		printMessage "\nDone\n"; echo
	else
		printMessage "\nNASM installation error, check the log!\n"; exit 1
	fi
else
	echo "$(${NASM_PREFIX}nasm -v)"
fi

# ...gettext does nothing in Linux because we cannot compile the .pkg
if [[ "$SYSNAME" == Darwin ]]; then
	printHeader "gettext check:"
	if needGETTEXT && [[ ! -x "${TOOLCHAIN_DIR}"/bin/gettext ]]; then
		# buildgettext.sh is buggie:
		# suppose during the download a problem occour you can have an incomplete "gettext-latest.tar.gz" from a previous execution,
		# but buildgettext.sh think that is already downloaded and will try to decompress this incomplete archive, always failing!
		# That‘s why we remove the archive!
		if [[ -f "${DIR_DOWNLOADS}"/gettext-latest.tar.gz ]]; then rm -f "${DIR_DOWNLOADS}"/gettext-latest.tar.gz; fi
		"${DIR_MAIN}"/edk2/Clover/buildgettext.sh
	fi
fi
rm -rf "${DIR_DOWNLOADS}"/source.download
}
# --------------------------------------
showMacros() {
ClearScreen
CUSTOM_BUILD="YES"
case "$ARCH" in
	IA32_X64 ) printHeader "BUILD boot3 and boot7 with additional macros";;
	X64 ) printHeader "BUILD boot7 with additional macros";;
	IA32 ) printHeader "BUILD boot3 with additional macros";;
esac
local count=1;

for macro in ${macros[@]}
do
	printf "\t $count) ${macro}\n"
	((count+=1))
done
echo $1
printf ‘actual macros defined: ‘
if [[ ( "${#DEFINED_MACRO} " < 1 ) ]] ; then
	printf "\e[1;30mno one\e[0m\n"
else
	printf "\e[1;36m\n${DEFINED_MACRO}\e[0m\n"
fi
echo
if [[ "${#macros[@]}" -gt "0" ]]; then
	echo "enter you choice or press \"b\" to build:"
	printf ‘? ‘ && read choice
	if [[ "${choice}" == "b" || "${choice}" == "B" ]]; then
		echo "going to build as requested.."
	elif [[ ${choice} =~ ^[0-9]+$ ]]; then
		if [[ "$choice" -gt "0" && "$choice" -le ${#macros[@]} ]]; then
			local chosed="${macros[choice -1]}"
			DEFINED_MACRO=$(echo "$DEFINED_MACRO -D ${chosed}" | sed -e ‘s/^[ \t]*//‘)
			macros=(${macros[@]/${macros[choice -1]}/})
			showMacros "${chosed} added!"
		else
			showMacros "invalid choice!"
		fi
	else
		showMacros "invalid choice!"
	fi
fi
}
# --------------------------------------
backupBoot7MCP79() {
if [[ -f "${CLOVERV2_PATH}/Bootloaders/x64/boot7-MCP79" ]]; then
	mv -f "${CLOVERV2_PATH}/Bootloaders/x64/boot7-MCP79" "${CLOVERV2_PATH}/Bootloaders/x64/boot7-MCP79.back"
fi
}
# --------------------------------------
build() {
if [[ -d "${DIR_MAIN}/edk2/Clover/.svn" ]] ; then
	echo ‘Please enter your choice: ‘
	local options=()

	if [[ ! -f "$SYMLINKPATH" ]]; then
		options+=("add \"buildclover\" symlink to $(dirname $SYMLINKPATH)") # add the option to link the script
	else
		# such file exists, but is it really symlink
		if [[ -L "$SYMLINKPATH" ]]; then
			[[ "$SYSNAME" == Linux ]] && symPath="$(readlink -f ${SYMLINKPATH})" || symPath="$(readlink ${SYMLINKPATH})"
			# is that symlink pointing to the currently running script
			[[ "$symPath" != "$SCRIPT_ABS_LOC" ]] && options+=("update \"buildclover\" symlink")
		else
			# not a symlink
			options+=("restore \"buildclover\" symlink")
		fi
	fi
	if [[ "$SELF_UPDATE_OPT" == YES ]]; then options+=("update Build_Clover.command"); fi

	if [[ "$PING_RESPONSE" == YES && "$BUILDER" != ‘slice‘ ]]; then
		options+=("update Clover only (no building)")
		options+=("update Clover + force edk2 update (no building)")
	fi
	if [[ "$BUILDER" == ‘slice‘ ]]; then
		printf "   \e[1;97;104m EDK2 revision used r$EDK2_REV latest avaiable is r$REMOTE_EDK2_REV \e[0m\n"
		set +e
		options+=("build with ./ebuild.sh -nb")
		options+=("build with ./ebuild.sh --module=rEFIt_UEFI/refit.inf")
		options+=("build binaries w/o -fr (boot6 and 7)")
		options+=("build binaries with -fr (boot6 and 7)")
		options+=("build boot6/7 with -fr --std-ebda")
		if [[ "$SYSNAME" == Darwin ]]; then
			options+=("build pkg")
			options+=("build iso")
			options+=("build pkg+iso")
			options+=("build all for Release")
		fi
		options+=("Back to Main Menu")
		options+=("Exit")
	else
		options+=("run my script on the source")
		options+=("build existing revision (no update, for testing only)")
		options+=("build existing revision for release (no update, standard build)")
		options+=("build existing revision with custom macros enabled")
		options+=("enter Developers mode (only for devs)")
		options+=("edit the configuration file")
		options+=("Exit")
	fi

	local count=1
	for opt in "${options[@]}"
	do
		case $opt in
			"update Build_Clover.command" 			| "add \"buildclover\" symlink to $(dirname $SYMLINKPATH)" 			| "restore \"buildclover\" symlink" 			| "update \"buildclover\" symlink" ) printf "\e[1;31m ${count}) ${opt}\e[0m\n";;
			"build existing revision for release (no update, standard build)" 			| "update Clover + force edk2 update (no building)" 			| "build all for Release" 			| "build binaries with FORCEREBUILD (boot3, 6 and 7 also)" ) printf "\e[1;36m ${count}) ${opt}\e[0m\n";;
			* ) printf " ${count}) ${opt}\n";;
		esac
		((count+=1))
	done

	local choice=""
	local lastIndex="${#options[@]}"
	((lastIndex-=1))
	printf ‘? ‘ && read opt

	if IsNumericOnly $opt; then
		((opt-=1))
		if [[ "$opt" -ge "0" && "$opt" -le "$lastIndex" ]]; then choice="$(echo ${options[$opt]})"; fi
	fi

	case $choice in
		"add \"buildclover\" symlink to $(dirname $SYMLINKPATH)" 		| "restore \"buildclover\" symlink" 		| "update \"buildclover\" symlink" ) addSymlink;;
		"update Build_Clover.command" ) selfUpdate; build;;
		"enter Developers mode (only for devs)" )
			ClearScreen
			if [[ -d "${DIR_MAIN}/edk2/Clover" ]] ; then
				set +e
				BUILDER="slice"
			else
				BUILDER=$USER
				echo "yep... you are a Dev, but at least download Clover firstly :-)"
			fi
			build;;
		"update Clover only (no building)" )
			UPDATE_FLAG="YES"
			BUILD_FLAG="NO"
			ForceEDK2Update=0;;
		"update Clover + force edk2 update (no building)" )
			UPDATE_FLAG="YES"
			BUILD_FLAG="NO"
			ForceEDK2Update=1979;; # 1979 has a special meaning ...i.e force clean BaseTools
		"build existing revision (no update, for testing only)" )
			UPDATE_FLAG="NO"
			BUILD_FLAG="YES"
			selectArch;;
		"build with ./ebuild.sh -nb" )
			printHeader ‘ebuild.sh -nb‘
			cd "${DIR_MAIN}"/edk2/Clover
			START_BUILD=$(date)
			./ebuild.sh -nb;;
		"build with ./ebuild.sh --module=rEFIt_UEFI/refit.inf" )
			cd "${DIR_MAIN}"/edk2/Clover
			printHeader ‘ebuild.sh --module=rEFIt_UEFI/refit.inf‘
			START_BUILD=$(date)
			./ebuild.sh --module=rEFIt_UEFI/refit.inf
			echo && printf "build started at:\n${START_BUILD}\nfinished at\n$(date)\n\nDone!\n";;
		"build binaries w/o -fr (boot6 and 7)" )
			cd "${DIR_MAIN}"/edk2/Clover
			START_BUILD=$(date)
			printHeader ‘boot6‘
			./ebuild.sh -x64 -D NO_GRUB_DRIVERS_EMBEDDED -t $BUILDTOOL
			printHeader ‘boot7‘
			./ebuild.sh -mc --no-usb -D NO_GRUB_DRIVERS_EMBEDDED -t $BUILDTOOL
			echo && printf "build started at:\n${START_BUILD}\nfinished at\n$(date)\n\nDone!\n";;
		"build binaries with -fr (boot6 and 7)" )
			cd "${DIR_MAIN}"/edk2/Clover
			START_BUILD=$(date)
			printHeader ‘boot6‘
			./ebuild.sh -fr -x64 -D NO_GRUB_DRIVERS_EMBEDDED -t $BUILDTOOL
			printHeader ‘boot7‘
			./ebuild.sh -fr -mc --no-usb -D NO_GRUB_DRIVERS_EMBEDDED -t $BUILDTOOL
			echo && printf "build started at:\n${START_BUILD}\nfinished at\n$(date)\n\nDone!\n";;
		"build boot6/7 with -fr --std-ebda" )
			cd "${DIR_MAIN}"/edk2/Clover
			START_BUILD=$(date)
			printHeader ‘boot6‘
			./ebuild.sh -fr -x64 --std-ebda -D NO_GRUB_DRIVERS_EMBEDDED -t $BUILDTOOL
			printHeader ‘boot7‘
			./ebuild.sh -fr -mc --std-ebda --no-usb -D NO_GRUB_DRIVERS_EMBEDDED -t $BUILDTOOL
			echo && printf "build started at:\n${START_BUILD}\nfinished at\n$(date)\n\nDone!\n";;
		"build pkg" )
			cd "${DIR_MAIN}"/edk2/Clover/CloverPackage
			START_BUILD=$(date)
			printHeader ‘make pkg‘
			make pkg
			echo && printf "build started at:\n${START_BUILD}\nfinished at\n$(date)\n\nDone!\n";;
		"build iso" )
			cd "${DIR_MAIN}"/edk2/Clover/CloverPackage
			printHeader ‘make iso‘
			make iso
			echo && printf "build started at:\n${START_BUILD}\nfinished at\n$(date)\n\nDone!\n";;
		"build pkg+iso" )
			cd "${DIR_MAIN}"/edk2/Clover/CloverPackage
			START_BUILD=$(date)
			printHeader ‘make pkg + make iso‘
			make pkg
			make iso
			echo && printf "build started at:\n${START_BUILD}\nfinished at\n$(date)\n\nDone!\n";;
		"build all for Release" )
			cd "${DIR_MAIN}"/edk2/Clover
			START_BUILD=$(date)
			printHeader ‘boot6‘
			./ebuild.sh -fr -x64 -D NO_GRUB_DRIVERS_EMBEDDED -t $BUILDTOOL
			printHeader ‘boot7‘
			./ebuild.sh -fr -mc --no-usb -D NO_GRUB_DRIVERS_EMBEDDED -t $BUILDTOOL

			cd "${DIR_MAIN}"/edk2/Clover/CloverPackage
			make clean
			printHeader ‘make pkg‘
			make pkg
			printHeader ‘make iso‘
			make iso
			echo && printf "build started at:\n${START_BUILD}\nfinished at\n$(date)\n\nDone!\n";;
		"build existing revision for release (no update, standard build)" )
			FORCEREBUILD="-fr"
			UPDATE_FLAG="NO"
			BUILD_FLAG="YES"
			selectArch;;
		"build existing revision with custom macros enabled" )
			DEFINED_MACRO=""
			UPDATE_FLAG="NO"
			BUILD_FLAG="YES"
			selectArch
			showMacros "";;
		"run my script on the source" )
			eval "${MY_SCRIPT}" || printHeader "You should export MY_SCRIPT with the path to your script.." && CleanExit;;
		"Back to Main Menu" ) ClearScreen && BUILDER=$USER && build;;
		"edit the configuration file" ) OsOpen "${userconf}"; CleanExit;;
		"Exit" ) CleanExit;;
		* ) ClearScreen && echo "invalid option!!" && build;;
	esac
fi

if [[ "$BUILDER" == ‘slice‘ ]]; then ClearScreen && build; fi

# show info about the running OS and its gcc
case "$SYSNAME" in
	Darwin ) printHeader "Running from: macOS $(sw_vers -productVersion)\n$(/usr/bin/xcodebuild -version)";;
	Linux ) if [[ -x "/usr/bin/lsb_release" ]]; then
				printHeader "Running from: $(lsb_release -sir | sed -e ‘:a;N;$!ba;s/\n/ /g‘)"
			else
				printHeader "Running from: Linux"
			fi;;
	* ) printHeader "Running from: Unknown OS";;
esac
	
printHeader "Compiler settings"
if [[ "${Build_Tool}" == "GNU" ]]; then
	if [[ -x "${DIR_MAIN}/opt/local/bin/gcc" ]]; then
		printf "\e[1;34m%s\e[0m" "$(${DIR_MAIN}/opt/local/bin/gcc -v 2>&1)"
	elif [[ -x "${DIR_MAIN}/opt/local/cross/bin/x86_64-clover-linux-gnu-gcc" ]]; then
		printf "\e[1;34m%s\e[0m" "$(${DIR_MAIN}/opt/local/cross/bin/x86_64-clover-linux-gnu-gcc -v 2>&1)"
	else
		printWarning "GNU toolchain not found or incomplete, installing the missing parts now..."
	fi
else
	printf "\e[1;34m%s\e[0m" "$(gcc -v 2>&1)"
fi
printLine

if [[ "$BUILDER" != ‘slice‘ ]]; then restoreClover; fi
if [[ "$UPDATE_FLAG" == YES && "$BUILDER" != ‘slice‘ ]]; then getRev; edk2; clover; fi

if [[ "$BUILD_FLAG" == NO ]]; then
	ClearScreen
	# print updated remote and local revision
	if [[ -d "${DIR_MAIN}"/edk2 ]]; then getRev; printRevisions; fi;
	build
fi

set -e

exportPaths

case "$BUILDTOOL" in
GCC49 )
	printHeader "BUILDTOOL is $BUILDTOOL"
	if [[ "$SYSNAME" == Darwin ]]; then "${DIR_MAIN}"/edk2/Clover/buildgcc-4.9.sh; fi;;
GCC53 )
	printHeader "BUILDTOOL is $BUILDTOOL"
	if [[ "$SYSNAME" == Darwin ]]; then "${DIR_MAIN}"/edk2/Clover/build_gcc6.sh; fi;;
XCODE* ) exportXcodePaths; printHeader "BUILDTOOL is $BUILDTOOL";;
esac

if [[ "$BUILDER" != ‘slice‘ ]]; then buildEssentials; cleanCloverV2; fi

cd "${DIR_MAIN}"/edk2/Clover

START_BUILD=$(date)

# Slice has removed that flag entirely until new development will comes,
# so the follow is just a momentarily patch for XCODE5
if [[ "$SYSNAME" == Darwin ]]; then LTO_FLAG=""; fi

set +e

if [[ "$CUSTOM_BUILD" == NO ]]; then
	# using standard options
	case "$ARCH" in
	IA32_X64 )
		printHeader ‘boot6‘
		doSomething --run-script ./ebuild.sh $FORCEREBUILD -x64 $DEFAULT_MACROS $LTO_FLAG -t $BUILDTOOL
		printHeader ‘boot7‘
		doSomething --run-script ./ebuild.sh $FORCEREBUILD -mc --no-usb $DEFAULT_MACROS $LTO_FLAG -t $BUILDTOOL
		printHeader ‘boot3‘
		doSomething --run-script ./ebuild.sh $FORCEREBUILD -ia32 $DEFAULT_MACROS $LTO_FLAG -t $BUILDTOOL;;
	X64 )
		printHeader ‘boot6‘
		backupBoot7MCP79
		doSomething --run-script ./ebuild.sh $FORCEREBUILD -x64 $DEFAULT_MACROS $LTO_FLAG -t $BUILDTOOL
		printHeader ‘boot7‘
		doSomething --run-script ./ebuild.sh $FORCEREBUILD -mc --no-usb $DEFAULT_MACROS $LTO_FLAG -t $BUILDTOOL;;
	IA32 )
		printHeader ‘boot3‘
		backupBoot7MCP79
		doSomething --run-script ./ebuild.sh $FORCEREBUILD -ia32 $DEFAULT_MACROS $LTO_FLAG -t $BUILDTOOL;;
	esac
else
	# using custom macros
	case "$ARCH" in
	IA32_X64 )
		printHeader ‘boot6‘
		doSomething --run-script ./ebuild.sh -x64 -fr $LTO_FLAG -t $BUILDTOOL # boot6 is always standard here
		printHeader ‘Custom boot7‘
		ebuildBorg
		doSomething --run-script ./ebuildBorg.sh -x64 -fr ${DEFINED_MACRO} $LTO_FLAG -t $BUILDTOOL
		printHeader ‘boot3‘
		doSomething --run-script ./ebuild.sh -ia32 -fr ${DEFINED_MACRO} $LTO_FLAG -t $BUILDTOOL;;
	X64 )
		printHeader ‘Custom boot7‘ # boot7 is the only target here
		backupBoot7MCP79
		ebuildBorg
		doSomething --run-script ./ebuildBorg.sh -x64 -fr $LTO_FLAG ${DEFINED_MACRO} -t $BUILDTOOL;;
	IA32 )
		printHeader ‘Custom boot3‘
		backupBoot7MCP79
		ebuildBorg
		doSomething --run-script ./ebuild.sh -ia32 -fr ${DEFINED_MACRO} $LTO_FLAG -t $BUILDTOOL;;
	esac
fi

if [[ "$SYSNAME" == Darwin ]]; then
	if [[ "$BUILD_PKG" == YES || "$BUILD_ISO" == YES ]]; then
		cd "${DIR_MAIN}"/edk2/Clover/CloverPackage
		if [[ "$FORCEREBUILD" == "-fr" ]]; then make clean; fi
	fi
	if [[ "$BUILD_PKG" == YES ]]; then printHeader ‘MAKE PKG‘; CheckProprietary; eval "$MAKEPKG_CMD"; fi
	if [[ "$BUILD_ISO" == YES ]]; then printHeader ‘MAKE ISO‘; make iso; fi
else
	OsOpen "${CLOVERV2_PATH}"
fi

if [[ "$BUILDER" != ‘slice‘ ]]; then restoreClover; fi
printHeader "build started at:\n${START_BUILD}\nfinished at\n$(date)\n\nDone!\n"
printf ‘\e[3;0;0t‘
pressAnyKey "Clover was built successfully!" noclear; ClearScreen; build
}
main () {
# don‘t use sudo!
if [[ $EUID -eq 0 ]]; then printError "\nThis script should not be run using sudo!!\n\n"; exit 1; fi
# Cleaning up any old data if exists
if [[ -f /tmp/Build_Clover.tmp ]]; then rm -f /tmp/Build_Clover.tmp; fi

FindScriptPath

# Checking if any command line parameters has passed any value
if [[ "${cus_conf}" != "Y" ]]; then
	if [[ "${BUILD_CLOVER_CFG_PATH:-}" ]]; then
		userconf="${BUILD_CLOVER_CFG_PATH}"
	else
		userconf="$HOME/BuildCloverConfig.txt"
	fi
fi

EDK2_REV="${EDK2_REV:-25480}"

if [[ "${useDefaults}" == "Y" ]]; then
	LoadDefaults
elif [[ -f "$userconf" ]]; then
	ReadConf
else
	CreateDefaultConf
	ReadConf
fi

# setting default paths
case "$MODE" in
	"S" )
		export DIR_MAIN=${DIR_MAIN:-"${HOME}"/src};;
	"R" )
		export DIR_MAIN="${SCRIPT_ABS_PATH}"/src
		if [[ "${DIR_MAIN}" = "${DIR_MAIN%[[:space:]]*}" ]]; then
			echo "good, no blank spaces in DIR_MAIN, continuing.."
		else
			ClearScreen; printError "Error: MODE=\"R\" require a path with no spaces in the middle, exiting!\n"; exit 1
		fi;;
	* )
		ClearScreen; printError "Error: unsupported MODE\n"; exit 1;;
esac

SVN_STDERR_LOG="${DIR_MAIN}/svnLog.txt"
CLOVERV2_PATH="${DIR_MAIN}/edk2/Clover/CloverPackage/CloverV2"
PKG_PATH="${DIR_MAIN}/edk2/Clover/CloverPackage/package"
LOCALIZABLE_FILE="${PKG_PATH}/Resources/templates/Localizable.strings"
ebuildB="${DIR_MAIN}/edk2/Clover/ebuildBorg.sh"
ebuild="${DIR_MAIN}/edk2/Clover/ebuild.sh"

# tools_def.txt provide lto flags for GCC53 in linux
if [[ "$SYSNAME" == Linux ]]; then macros+=(‘DISABLE_LTO‘); fi

# Setting the build tool (Xcode or GCC)
case "$SYSNAME" in
	Darwin ) 
		case "$Build_Tool" in
		"XCODE" | "xcode" ) checkXcode; BUILDTOOL="$XCODE";;
		"GNU" | "gnu" ) [[ "$GNU" == "" ]] && BUILDTOOL="GCC53" || BUILDTOOL="$GNU";;
		* ) printError "Wrong build tool: $Build_Tool. It should be \"XCODE\" or \"GNU\" !!!"; exit 1;;
		esac;;
	Linux ) [[ "$GNU" == "" ]] && BUILDTOOL="GCC53" || BUILDTOOL="$GNU";;
esac

# print local Script revision with relative info
printCloverScriptRev
printHeader "By Micky1979 based on Slice, Zenith432, STLVNUB, JrCs, cecekpawon, Needy,\ncvad, Rehabman, philip_petev, ErmaC\n\nSupported OSes: macOS X, Ubuntu (16.04/16.10), Debian Jessie and Stretch"

# print the remote and the local revision
if [[ -d "${DIR_MAIN}"/edk2 ]]; then getRev; printRevisions; fi;

# readding removed macro CHECK_FLAGS on old source
if [[ "$LOCAL_REV" -lt "4209" ]]; then macros+=("CHECK_FLAGS"); fi

if [[ "$DISABLE_CLEAR" != "YES" ]]; then printf ‘\e[8;34;90t‘; fi
build
}
# --------------------------------------
# MAIN CODE
# --------------------------------------
if [[ $# -eq 0 ]]; then main; fi
while [[ $# -gt 0 ]]; do
	case "${1}" in
		--defaults ) useDefaults="Y";;
		--edk2rev ) if [[ -n "${2}" && "${2}" =~ ^[0-9]+$ ]]; then
						EDK2_REV="${2}"
						cus_edk2="Y"
					fi
					shift;;
			--cfg ) if [[ -n "${2}" && -f "${2}" ]]; then
						userconf="${2}"
						cus_conf="Y"
					fi
					shift;;
		* ) printf "\e[1m%s\e[0m\n" "Invalid option: ${1} !" >&2; usage; exit 1;;
	esac
	shift
done
main