buildme

#!/bin/bash

# created by vector sigma on July 15 2019
# modified by LAbyOne on My 2021
# Remastered by YBronst in Aug 2025.
# github version

export TERM=xterm-256color
export LC_ALL=C.UTF-8

# Defining the base directory
BASE_DIR="$(dirname "$0")"

# $1 argument overrides MYTOOLCHAIN variable (e.g., GCC53)
MYTOOLCHAIN="${1:-GCC151}"  # Default to GCC151 if no argument provided

# ====== COLORS ======
# Основные цвета
COL_RED=$(tput setaf 1)      # Red
COL_GREEN=$(tput setaf 2)    # Green
COL_YELLOW=$(tput setaf 3)   # Yellow
COL_BLUE=$(tput setaf 4)     # Blue
COL_PURPLE=$(tput setaf 5)   # Purple
COL_CYAN=$(tput setaf 6)     # Cyan
COL_WHITE=$(tput setaf 7)    # White

# Light shades
COL_LIGHT_RED=$(tput setaf 9)    # Light Red
COL_LIGHT_GREEN=$(tput setaf 10) # Light Green
COL_LIGHT_YELLOW=$(tput setaf 229) # Light Yellow (замена для setaf 11)
COL_LIGHT_BLUE=$(tput setaf 153)   # Light Blue (замена для setaf 12)
COL_LIGHT_PURPLE=$(tput setaf 183) # Light Purple (замена для setaf 13)
COL_LIGHT_CYAN=$(tput setaf 14)    # Light Cyan

# Dark shades
COL_DARK_RED=$(tput setaf 124)   # Dark Red
COL_DARK_GREEN=$(tput setaf 22)  # Dark Green
COL_DARK_YELLOW=$(tput setaf 94) # Dark Yellow
COL_DARK_BLUE=$(tput setaf 18)   # Dark Blue
COL_DARK_PURPLE=$(tput setaf 54) # Dark Purple
COL_DARK_CYAN=$(tput setaf 30)   # Dark Cyan

# Bold options
COL_RED_BOLD=$(tput bold; tput setaf 1)      # Bold Red
COL_GREEN_BOLD=$(tput bold; tput setaf 2)    # Bold Green
COL_YELLOW_BOLD=$(tput bold; tput setaf 3)   # Bold Yellow
COL_BLUE_BOLD=$(tput bold; tput setaf 4)     # Bold Blue
COL_PURPLE_BOLD=$(tput bold; tput setaf 5)   # Bold Purple
COL_CYAN_BOLD=$(tput bold; tput setaf 6)     # Bold Cyan
COL_WHITE_BOLD=$(tput bold; tput setaf 7)    # Bold White

# Italic variants
COL_RED_ITALIC=$(tput sitm; tput setaf 1)    # Italic Red
COL_GREEN_ITALIC=$(tput sitm; tput setaf 2)  # Italic Green
COL_YELLOW_ITALIC=$(tput sitm; tput setaf 3) # Italic Yellow
COL_BLUE_ITALIC=$(tput sitm; tput setaf 4)   # Italic Blue
COL_PURPLE_ITALIC=$(tput sitm; tput setaf 5) # Italic Purple
COL_CYAN_ITALIC=$(tput sitm; tput setaf 6)   # Italic Cyan
COL_WHITE_ITALIC=$(tput sitm; tput setaf 7)  # Italic White

# Reset all attributes
COL_RESET=$(tput sgr0)

# Checking the availability of the Downloads folder
if [[ ! -w "$HOME/Downloads" ]]; then
  echo "${COL_RED}Error: Cannot write to $HOME/Downloads. Please check permissions.${COL_RESET}"
  exit 1
fi

# ====== Main Window SetUp ======
if [[ "$2" != "ci" ]]; then
    osascript <<EOF
        tell application "System Events"
            tell application "Terminal"
                try
                    activate
                    set bounds of front window to {0, 23, 615, 420}
                on error errMsg
                    display dialog "Error setting Terminal window: " & errMsg buttons {"OK"} default button "OK" with icon caution
                end try
            end tell
        end tell
EOF
fi

# ====== Display Menu ======
echo -e "${COL_GREEN} ---------------------------------------------------------------------------------"
echo -e "${COL_GREEN}                           🍀 Clover r5163 ${COL_WHITE}(SHA: 64d434947)"
echo -e "${COL_WHITE}                              Default TOOLCHAIN: ${COL_CYAN}GCC151${COL_WHITE}"
echo -e "${COL_WHITE}                     Switch to ${COL_CYAN}XCODE${COL_WHITE} select: ${COL_CYAN}build (with XCode)"
echo -e "${COL_WHITE}     Depending on your ${COL_CYAN}XCODE version${COL_WHITE} the Toolset will be ${COL_CYAN}automatically chosen"
echo -e "${COL_GREEN} ---------------------- ${COL_CYAN}Current Python version: ${COL_WHITE}Python 3.13.7${COL_GREEN} -------------------- ${COL_RESET}"

# ====== Clover workspace SetUp ======
cd "$(dirname $([ -L $0 ] && readlink $0 || echo $0))"
declare -r CLOVERROOT="$PWD"
declare -r SYSNAME="$(uname)"
MYTOOLCHAIN=${1:-GCC151}
revision=$(git describe --tags $(git rev-list --tags --max-count=1))
lsha1="not a git repo"
pyversion=$(echo "${COL_CYAN}Current Python version: ${COL_WHITE}$($(which python3) --version)")
pynone=$(echo -e "${COL_RED}    Python3 seems missing on this machine, it is required to build Clover ")
export DIR_OUT=${DIR_OUT:-"$CLOVERROOT/toolchain/tools/output"}
export DIR_SCT=${DIR_SCT:-"$CLOVERROOT/toolchain/tools/Scripts"}
if [[ ! -d ${DIR_SCT} ]] || [[ ! -d ${DIR_OUT} ]]; then
  mkdir -p ${DIR_SCT} ${DIR_OUT}
fi
if [[ -d .git ]]; then
  lsha1=$(git rev-parse --short HEAD)
fi

# Functions
pathmunge() {
if [[ ! $PATH =~ (^|:)$1(:|$) ]]; then
  if [[ "${2:-}" = "after" ]]; then
    export PATH=$PATH:$1
  else
    export PATH=$1:$PATH
  fi
fi
}

checkXCODE() {
echo "[CHECK XCODE]"
if [[ ! -x /usr/bin/xcodebuild ]]; then
  echo "ERROR: Install Xcode Tools from Apple before using this script."
  exit 1
fi

if [[ ! -d "$(xcode-select --print-path)" ]]; then
  echo "ERROR: Xcode Command Line Tools not selected:"
  echo "       open Xcode.app and go in Preferences->Locations,"
  echo "       and select the Command Line Tools"
  exit 1
fi
}

checkGETTEXT() {
exportPaths
local locations=($(which msgmerge))
if [ "${#locations[@]}" -eq 0 ]; then
  export GETTEXT_PREFIX="${TOOLCHAIN_DIR}"
  "${CLOVERROOT}/buildgettext.sh"
else
  export GETTEXT_PREFIX="$(dirname "${locations[0]}")"
fi
}

exportPaths() {
if [[ "$SYSNAME" == Linux ]]; then
  local TOOLCHAIN_DIR=${TOOLCHAIN_DIR:-/usr}
elif [[ "$SYSNAME" == Darwin ]]; then
  pathmunge "$(xcode-select --print-path)/usr/bin"
  if [[ -d "$BASE_DIR/opt/local" ]]; then
    TOOLCHAIN_DIR="$BASE_DIR/opt/local"
  else
    TOOLCHAIN_DIR=${TOOLCHAIN_DIR:-"$CLOVERROOT/toolchain"}
  fi
fi

pathmunge "$TOOLCHAIN_DIR/bin"
export TOOLCHAIN_DIR=$TOOLCHAIN_DIR
export DIR_MAIN=${DIR_MAIN:-"$CLOVERROOT/toolchain"}
export DIR_TOOLS=${DIR_TOOLS:-"$DIR_MAIN/tools"}
export DIR_DOWNLOADS=${DIR_DOWNLOADS:-"$DIR_TOOLS/download"}
export DIR_LOGS=${DIR_LOGS:-"$DIR_TOOLS/logs"}
export PREFIX=${TOOLCHAIN_DIR}
}

checkTools() {
if [[ "$SYSNAME" == Darwin ]]; then
  checkXCODE
  exportPaths
  local GCC151_BIN="$PREFIX/cross/bin/x86_64-clover-linux-gnu-gcc"
  if [[ $MYTOOLCHAIN == GCC* ]] && [[ ! -x "${GCC151_BIN}" ]]; then
    if [[ $MYTOOLCHAIN == GCC151 ]]; then
      cd "${CLOVERROOT}"
      ./build_gcc15.sh
    else
      MYTOOLCHAIN="XCODE$(defaults read /Applications/Xcode.app/Contents/version.plist CFBundleShortVersionString | cut -d. -f1)"
    fi
  fi
else
  exportPaths
fi
}

# Clone OR Update OpenCorePkg
function clone_OpenCorePkg() {
cd "${CLOVERROOT}"
if [ ! -d OpenCorePkg/AppleModels ]; then
  echo "Cloning OpenCorePkg...."
  git clone https://github.com/CloverHackyColor/OpenCorePkg.git > /dev/null
  cd "${OpenCorePkg}"
  git submodule update --init
else
  echo "Updating OpenCorePkg...."
  cd "${OpenCorePkg}"
  git pull > /dev/null
fi
}

updateClover() {
echo "[UPDATE CLOVER]"
cd "${CLOVERROOT}"
clone_OpenCorePkg
if [[ -d .git ]]; then
  git fetch --all --recurse-submodules
  git pull --recurse-submodules origin master
else
  echo "Error: this is not a git repository, can't update!"
fi
}

updateResetClover() {
echo "[UPDATE RESET CLOVER]"
cd "${CLOVERROOT}"
if [[ -d .git ]]; then
  git fetch --all --recurse-submodules
  git submodule foreach --recursive git clean -d -f -f
  git clean -d -f -f
  git submodule foreach --recursive git reset --hard origin/master
  git reset --hard origin/master
  git pull --recurse-submodules origin master
else
  echo "Error: this is not a git repository, can't update!"
fi
}

buildCloverHFSPlus() {
if [[ -f "${CLOVERROOT}/FileSystems/HFSPlus/X64/HFSPlus.efi" ]]; then
  echo "building Clover with HFSPlus"
  buildClover HFSPlus
else
  echo "${CLOVERROOT}/FileSystems/HFSPlus/X64/HFSPlus.efi: no such file!"
  sleep 3
  menu
fi
}

makeRelease() {
checkTools
rm -rf "$CLOVERROOT/Conf"
mkdir "$CLOVERROOT/Conf"
cd "${CLOVERROOT}"
if [[ -z "$WORKSPACE" ]]; then
  export EDK_TOOLS_PATH="${PWD}/BaseTools"
  set +u
  source ./edksetup.sh BaseTools
  set -u
  cd "$CLOVERROOT"
  WORKSPACE="${PWD}"
fi

echo "[BUILD CLOVER RELEASE]"
./ebuild.sh -fr -mc --no-usb -D NO_GRUB_DRIVERS_EMBEDDED -t $MYTOOLCHAIN
./ebuild.sh -fr -D NO_GRUB_DRIVERS_EMBEDDED -D LESS_DEBUG -t $MYTOOLCHAIN
if [[ -x "${DIR_TOOLS}/CloverScripts/postbuild.sh" ]]; then
  chmod +x "${DIR_TOOLS}/CloverScripts/postbuild.sh"
  echo "Running Clover postbuild script"
  "${DIR_TOOLS}/CloverScripts/postbuild.sh" "${CLOVERROOT}" $MYTOOLCHAIN
fi
}

makeReleaseXC() {
checkTools
rm -rf "$CLOVERROOT/Conf"
mkdir "$CLOVERROOT/Conf"
cd "${CLOVERROOT}"
if [[ -z "$WORKSPACE" ]]; then
  export EDK_TOOLS_PATH="${PWD}/BaseTools"
  set +u
  source ./edksetup.sh BaseTools
  set -u
  cd "$CLOVERROOT"
  WORKSPACE="${PWD}"
fi

echo "[BUILD CLOVER RELEASE WITH XCODE]"
local xrel="XCODE$(defaults read /Applications/Xcode.app/Contents/version.plist CFBundleShortVersionString | cut -d. -f1)"
./ebuild.sh -fr -mc --no-usb -D NO_GRUB_DRIVERS_EMBEDDED -t $xrel
./ebuild.sh -fr -D NO_GRUB_DRIVERS_EMBEDDED -t $xrel
if [[ -x "${DIR_TOOLS}/CloverScripts/postbuild.sh" ]]; then
  chmod +x "${DIR_TOOLS}/CloverScripts/postbuild.sh"
  echo "Running Clover postbuild script"
  "${DIR_TOOLS}/CloverScripts/postbuild.sh" "${CLOVERROOT}" $MYTOOLCHAIN
fi
}

buildClover() {
checkTools
rm -rf "$CLOVERROOT/Conf"
mkdir "$CLOVERROOT/Conf"
cd "${CLOVERROOT}"
if [[ -z "$WORKSPACE" ]]; then
  export EDK_TOOLS_PATH="${PWD}/BaseTools"
  set +u
  source ./edksetup.sh BaseTools
  set -u
  cd "$CLOVERROOT"
  WORKSPACE="${PWD}"
fi

echo "[BUILD CLOVER]"
if [[ -x "${DIR_TOOLS}/Scripts/build.sh" ]]; then
  echo "Running custom build script"
  "${DIR_TOOLS}/Scripts/build.sh" "${CLOVERROOT}" $MYTOOLCHAIN
else
  local parameter=${1:-none}
  if [[ "${parameter}" == HFSPlus ]]; then
    ./ebuild.sh -fr -D NO_GRUB_DRIVERS_EMBEDDED -D USE_APPLE_HFSPLUS_DRIVER -t $MYTOOLCHAIN
  else
    ./ebuild.sh -fr -D NO_GRUB_DRIVERS_EMBEDDED -D LESS_DEBUG -t $MYTOOLCHAIN
  fi
fi
if [[ -x "${DIR_TOOLS}/CloverScripts/postbuild.sh" ]]; then
  chmod +x "${DIR_TOOLS}/CloverScripts/postbuild.sh"
  echo "Running Clover postbuild script"
  "${DIR_TOOLS}/CloverScripts/postbuild.sh" "${CLOVERROOT}" $MYTOOLCHAIN
fi
if [[ -x "${DIR_TOOLS}/Scripts/postbuild.sh" ]]; then
  echo "Running postbuild script"
  "${DIR_TOOLS}/Scripts/postbuild.sh" "${CLOVERROOT}" $MYTOOLCHAIN
fi
}

buildCloverXC() {
checkTools
rm -rf "$CLOVERROOT/Conf"
mkdir "$CLOVERROOT/Conf"
cd "${CLOVERROOT}"
if [[ -z "$WORKSPACE" ]]; then
  export EDK_TOOLS_PATH="${PWD}/BaseTools"
  set +u
  source ./edksetup.sh BaseTools
  set -u
  cd "$CLOVERROOT"
  WORKSPACE="${PWD}"
fi

echo "[BUILD CLOVER WITH XCODE]"
if [[ -x "${DIR_TOOLS}/Scripts/build.sh" ]]; then
  echo "Running custom build script"
  "${DIR_TOOLS}/Scripts/build.sh" "${CLOVERROOT}" $MYTOOLCHAIN
else
  xrel="XCODE$(defaults read /Applications/Xcode.app/Contents/version.plist CFBundleShortVersionString | cut -d. -f1)"
  ./ebuild.sh -fr -D NO_GRUB_DRIVERS_EMBEDDED -D USE_APPLE_HFSPLUS_DRIVER -t $xrel
fi
if [[ -x "${DIR_TOOLS}/CloverScripts/postbuild.sh" ]]; then
  chmod +x "${DIR_TOOLS}/CloverScripts/postbuild.sh"
  echo "Running Clover postbuild script"
  "${DIR_TOOLS}/CloverScripts/postbuild.sh" "${CLOVERROOT}" $MYTOOLCHAIN
fi
if [[ -x "${DIR_TOOLS}/Scripts/postbuild.sh" ]]; then
  echo "Running postbuild script"
  "${DIR_TOOLS}/Scripts/postbuild.sh" "${CLOVERROOT}" $MYTOOLCHAIN
fi
}

buildtestsix() {
checkTools
rm -rf "$CLOVERROOT/Conf"
mkdir "$CLOVERROOT/Conf"
cd "${CLOVERROOT}"
echo "[BUILD CLOVERDB]"
./hebuild.sh -t $MYTOOLCHAIN
}

buildtestsev() {
checkTools
rm -rf "$CLOVERROOT/Conf"
mkdir "$CLOVERROOT/Conf"
cd "${CLOVERROOT}"
echo "[BUILD CLOVERDB]"
./hebuild.sh -mc --no-usb -D NO_GRUB_DRIVERS_EMBEDDED -t $MYTOOLCHAIN
}

buildCloverTest() {
checkTools
cd "${CLOVERROOT}"
if [[ -z "$WORKSPACE" ]]; then
  export EDK_TOOLS_PATH="${PWD}/BaseTools"
  set +u
  source ./edksetup.sh BaseTools
  set -u
  cd "$CLOVERROOT"
  WORKSPACE="${PWD}"
fi

echo "[BUILD CLOVER TEST]"
./ebuild.sh -nb -t $MYTOOLCHAIN
}

buildPkg() {
if [[ "$SYSNAME" == Darwin ]]; then
  cd "${CLOVERROOT}/CloverPackage"
  checkXCODE
  checkGETTEXT
  echo "[BUILD PKG]"
  echo "The log will be created in the CloverPackage folder."
  rm -f mpkg.log
  make pkg | tee mpkg.log
else
  echo && echo "can't build pkg on a non Darwin OS!"
fi
}

buildApp() {
local withClover=${1-"none"}
if [[ "$SYSNAME" == Darwin ]]; then
  if [[ -f "${CLOVERROOT}/CloverPackage/CloverV2/EFI/CLOVER/CLOVERX64.efi" ]]; then
    rm -f "${CLOVERROOT}/CloverPackage/sym/.withV2"
    mkdir -p "${CLOVERROOT}/CloverPackage/sym"
    if [[ $withClover == withV2 ]]; then
      touch "${CLOVERROOT}/CloverPackage/sym/.withV2"
    fi
    cd "${CLOVERROOT}/CloverApp"
    echo "[BUILD APP]"
    checkXCODE
    make
  else
    echo && echo "please, build Clover first!"
    sleep 3
  fi
else
  echo && echo "Clover.app can only be built in macOS!"
fi
}

buildIso() {
cd "${CLOVERROOT}/CloverPackage"
echo "[BUILD ISO]"
make iso
}

makeV2() {
export V2=${V2:-"${CLOVERROOT}/CloverPackage/CloverV2"}
if [[ -f "$V2/EFI/CLOVER/CLOVERX64.efi" ]]; then
  cd "${CLOVERROOT}/CloverPackage"
  echo "" && echo -e "${COL_CYAN}[BUILD CloverV2]"
  make zip
else
  echo "" && echo -e "${COL_RED}please, Compile Clover first!!"
  sleep 3
fi
}

checkStatus() {
if [[ -d .git ]]; then
  git fetch --recurse-submodules origin
  git log -n 1 > "${DIR_OUT}"/status_${revision}-$(date +%Y%m%d-%H.%M.%S).txt
  git status >> "${DIR_OUT}"/status_${revision}-$(date +%Y%m%d-%H.%M.%S).txt
  git submodule foreach --recursive "git log -n 1 && git status" >> "${DIR_OUT}"/status_${revision}-$(date +%Y%m%d-%H.%M.%S).txt && open "${DIR_OUT}"/status_${revision}-*.txt
else
  echo "Error: this is not a git repository, can't get info!"
fi
}

showdiff() {
if [[ -d .git ]]; then
    git fetch --recurse-submodules origin
    git diff > "${DIR_OUT}"/diff_${revision}-$(date +%Y%m%d-%H.%M.%S).txt && open "${DIR_OUT}"/diff_${revision}-*.txt
else
  echo "Error: this is not a git repository, can't get info!"
fi
}

cleanBaseTools() {
cd "${CLOVERROOT}/BaseTools"
make clean
}

makeBaseTools() {
cd "${CLOVERROOT}"
make -C BaseTools "BUILD_CC=clang"
}

testing() {
echo
echo -e "${COL_GREEN} ---------------------------------------------------------------------------------"
echo -e "                          🍀 Clover r${revision}${COL_WHITE} (SHA: ${lsha1})"
echo -e "${COL_CYAN}                                     Test Builds${COL_RESET}"
echo -e "${COL_GREEN} ---------------------------------------------------------------------------------${COL_RESET}"
echo -e "\n\n\n\n\n\n\n\n\n\n\n"

PS3='
Please enter your choice: '
options=( 'test Clover with boot6'
          'test Clover with boot7'
          'test build (no autogen, no boot files)'
          'back to Cloverbuilds'
          'Exit')
select opt in "${options[@]}" 
do
  case $opt in
    "test Clover with boot6")
      buildtestsix
      break
    ;;
    "test Clover with boot7")
      buildtestsev
      break
    ;;
    "test build (no autogen, no boot files)")
      buildCloverTest
      break
    ;;
    "back to Cloverbuilds")
      menu
      break
    ;;
    "Exit")
      exit
      break
    ;;
    *)
      echo "invalid option $REPLY"
      break
    ;;
  esac
done
testing
}

Extra() {
echo
echo -e "${COL_GREEN} ---------------------------------------------------------------------------------"
if [[ ! -x "$(which python3)" ]]; then
  echo -e " ${pynone}"
fi
echo -e "${COL_GREEN}                           🍀 Clover r${revision}${COL_WHITE} (SHA: ${lsha1})"
echo -e "${COL_WHITE}                              Default TOOLCHAIN:${COL_CYAN} $MYTOOLCHAIN${COL_WHITE}"
echo -e "${COL_WHITE}                     Switch to${COL_CYAN} XCODE${COL_WHITE} can be done on${COL_CYAN} Cloverbuilds${COL_RESET}"
if [[ -x "$(which python3)" ]]; then
  echo -e "${COL_GREEN} ---------------------- ${pyversion}${COL_GREEN} -------------------- ${COL_RESET}"
  echo -e "\n\n\n\n\n\n\n\n\n\n"
else
  echo -e "${COL_GREEN} ---------------------------------------------------------------------------------${COL_RESET}"
  echo -e "\n\n\n\n\n\n\n\n\n"
fi
PS3='
Please enter your choice:'
options=( 'back to main menu' 
          'make BaseTools'
          'test Clover'
          'check status'
          'show diff'
          'open CloverV2 directory'
          'update Clover (reset changes)'
          'clean BaseTools'
          'Exit')

select opt in "${options[@]}" 
do
  case $opt in
    "back to main menu")
      menu
      break
    ;;
    "make BaseTools")
      makeBaseTools
      break
    ;;
    "test Clover")	
      testing
      break
    ;;
    "check status")	
      checkStatus
      break
    ;;
    "show diff")
      showdiff
      break
    ;;
    "open CloverV2 directory")
      if [[ -d "${CLOVERROOT}/CloverPackage/CloverV2/EFI/CLOVER" ]]; then
        open "${CLOVERROOT}/CloverPackage/CloverV2/EFI/CLOVER"
      else
        echo && echo "Directory not found. Compile Clover first!!"
        sleep 2
      fi
      break
    ;;
    "update Clover (reset changes)")
      read -p "Are you sure? (type y to confirm or any other to negate) " -n 1 -r
      echo
      if [[ $REPLY =~ ^[Yy]$ ]]; then
        updateResetClover
      fi
      break
    ;;
    "clean BaseTools")
      read -p "Are you sure? (type y to confirm or any other to negate) " -n 1 -r
      echo
      if [[ $REPLY =~ ^[Yy]$ ]]; then
        cleanBaseTools
      fi
      break
    ;;
    "Utilities")
      Utilities
      break
    ;;
    "Exit")
      exit 0
    ;;
    *)
      echo "invalid option $REPLY"
      break
    ;;
  esac
done
Extra
}

menu() {
echo
echo -e "${COL_GREEN} ---------------------------------------------------------------------------------"
if [[ ! -x "$(which python3)" ]]; then
  echo -e " ${pynone}"
fi
echo -e "${COL_GREEN}                           🍀 Clover r${revision}${COL_WHITE} (SHA: ${lsha1})"
echo -e "${COL_WHITE}                              Default TOOLCHAIN:${COL_CYAN} $MYTOOLCHAIN${COL_WHITE}"
echo -e "${COL_WHITE}                     Switch to${COL_CYAN} XCODE${COL_WHITE} select:${COL_CYAN} build (with XCode)"
echo -e "${COL_WHITE}     Depending on your${COL_CYAN} XCODE version${COL_WHITE} the Toolset will be${COL_CYAN} automatically chosen"
if [[ -x "$(which python3)" ]]; then
  echo -e "${COL_GREEN} ---------------------- ${pyversion}${COL_GREEN} -------------------- ${COL_RESET}"
  echo -e "\n\n\n\n\n\n\n"
else
  echo -e "${COL_GREEN} ---------------------------------------------------------------------------------${COL_RESET}"
  echo -e "\n\n\n\n\n\n\n"
fi
PS3='
Please enter your choice: '
options=( 'build Clover (Default Toolchain)'
          'build all (Default Toolchain)'
          'make Release (Default Toolchain)'
          'update Clover'
          'make pkg'
          'make iso'
          'make Clover_V2'
          'build Clover (with XCode)'
          'build all (with XCode)'
          'make Release (with XCode)'
          'build Clover with HFSPlus'
          'Extra Options'
          'Exit')

select opt in "${options[@]}" 
do
  case $opt in
    "build Clover (Default Toolchain)")
      buildClover
      break
    ;;
    "build all (Default Toolchain)")
      buildClover
      buildPkg
      buildIso
      makeV2 
      break
    ;;
    "make Release (Default Toolchain)")
      makeRelease
      buildPkg
      buildIso
      makeV2
      break
    ;;
    "update Clover")
      updateClover
      break
    ;;
    "make pkg")
      buildPkg
      break
    ;;
    "make iso")
      buildIso
      break
    ;;
    "make Clover_V2")
      makeV2
      break
    ;;
    "build Clover (with XCode)")
      buildCloverXC
      break
    ;;
    "build all (with XCode)")
      buildCloverXC
      buildPkg
      buildIso
      makeV2
      break
    ;;
    "make Release (with XCode)")
      makeReleaseXC
      buildPkg
      buildIso
      makeV2
      break
    ;;
    "build Clover with HFSPlus")
      buildCloverHFSPlus
      break
    ;;
    "Extra Options")
      Extra
      break	
    ;;
    "Exit")
      exit 0
    ;;
    *)
      echo "invalid option $REPLY"
      break
    ;;
  esac
done
menu
}

# Main
clone_OpenCorePkg
set -e
if [[ "$2" == ci ]]; then
  makeRelease
  buildPkg
  buildIso
  makeV2
else
  menu
fi