Cross-platform script to build MuseScore on Windows, Mac or Linux

musescore_build.sh

#!/usr/bin/env bash

source "path_functions.sh" # Bash-Essential-Functions: FilePaths module (BEF-FP)

# Cross-platform symlink function.
function symlink() {
  if [[ "$1" == "-s" ]]; then
    shift
  fi
  local target="$1" name="$2"
  if [[ "${OSTYPE}" == "msys" ]]; then
    # Windows needs to be told if it's a directory or not. Infer that.
    # Also: note that we convert `/` to `\`. In this case it's necessary.
    local args=""
    if [[ -d "${target}" ]]; then
      args="/J"
    fi
    cmd  >/dev/null  <<EOF
mklink ${args} "${name}" "${target//\//\\}"
EOF
  else
    ln -s "${target}" "${name}"
  fi
}

function safe_symlink() {
  local -r target="$1" name="$2"
  if [[ -e "${name}" ]] && [[ ! -L "${name}" ]]; then
    echo >&2 "Error: File '${name}' exists and is not a symlink. Will not overwrite."
    exit 1
  fi
  rm -f "${name}"
  symlink -s "${target}" "${name}"
}

# cross-platform copy function.
# create copy-on-write clones if possible, otherwise make an ordinary copy
function cp() {
  if [[ "${OSTYPE}" == darwin* ]]; then
    command cp -c "$@" || command cp "$@"
  else
    command cp --reflink=auto "$@"
  fi
}

# function make() {
#   local target="$1"
#   if [[ "${PLATFORM}" == "macOS" ]]; then
#     [[ "${target}" ]] || target="ALL_BUILD"
#     xcodebuild -jobs ${CPUS} -project mscore.xcodeproj -configuration Debug -target "${target}"
#   else
#     local -r make="$(which make 2>/dev/null || which mingw32-make 2>/dev/null || echo "make")"
#     command "${make}" -j ${CPUS} "$@"
#   fi
# }

function cmake_build() {
  # CMAKE's build tool mode simply calls the native build tool that the
  # project was configured for. It translates command line options for us.
  local cmake_options=("$@") native_options=()
  if [[ "${PLATFORM}" == "Windows" ]] || [[ "${PLATFORM}" == "macOS" ]]; then
    # users on these platforms can easily upgrade CMAKE to the latest version
    cmake_options+=(-j ${CPUS}) # requires cmake version >= 3.12
  else
    # users on these platforms are stuck with their distribution's CMAKE
    native_options+=(-j ${CPUS}) # native tool must accept -j option
  fi
  cmake --build . "${cmake_options[@]}" -- "${native_options[@]}"
}

function set_variables() {
  QTDIR="${QTDIR//\\/\/}" # change Windows-style path to Unix-style

  CPUS="$( getconf _NPROCESSORS_ONLN 2>/dev/null \
        || getconf NPROCESSORS_ONLN 2>/dev/null \
        || echo ${NUMBER_OF_PROCESSORS} )"

  (($CPUS > 0)) || CPUS=1

  bef_fp__setvar_basename "${QTDIR}"
  COMPILER="${basename}"

  bef_fp__setvar_dirname "${QTDIR}" && bef_fp__setvar_basename "${dirname}"
  QT_VERSION="${basename}"

  GIT_BRANCH="$(git rev-parse --abbrev-ref HEAD)"

  case "${OSTYPE}" in
    msys )    PLATFORM="Windows"  ;;
    darwin* ) PLATFORM="macOS"    ;;
    * )       PLATFORM="other"    ;;
  esac

  if [[ "${PLATFORM}" == "macOS" ]]; then
    # PATH set in .bash_profile will not be set in Qt Creator. Set it here:
    export PATH="/usr/local/bin:${PATH}" # homebrew
  fi

  case "${COMPILER}" in
    msvc* )
      GENERATOR_FAMILY="MSVC"
      GENERATOR="Visual Studio 16 2019"
      BUILD_64="OFF"
      if [[ "${COMPILER}" == msvc*_64 ]]; then
        # GENERATOR="${GENERATOR} Win64"
        BUILD_64="ON"
      fi
      ;;
    mingw* )
    GENERATOR_FAMILY="MINGW"
    GENERATOR="MinGW Makefiles"
    BUILD_64="OFF"
    if [[ "${COMPILER}" == mingw*_64 ]]; then
      # GENERATOR="${GENERATOR} Win64"
      BUILD_64="ON"
    fi
    ;;
  esac
}

function set_build_dir() {
  BUILD_DIR="builds/${GIT_BRANCH}/${OSTYPE}-${HOSTTYPE}/Qt${QT_VERSION}-${COMPILER}"
}

function link_build_dir() {
  local invpath
  mkdir -p "${BUILD_DIR}/install"
  bef_fp__setvar_invpath "${BUILD_DIR}" && SOURCE_DIR="${invpath}"
  safe_symlink "${BUILD_DIR}" "build.debug"
  case "${PLATFORM}" in
    Windows ) INSTALL_LINK="win32install" ;;
    macOS   ) INSTALL_LINK="applebuild"   ;;
    *       ) INSTALL_LINK=""             ;;
  esac
  if [[ "${INSTALL_LINK}" ]]; then
    safe_symlink "build.debug/install" "${INSTALL_LINK}"
  fi
  echo "BUILD_DIR: ${BUILD_DIR}  SOURCE_DIR: ${SOURCE_DIR} INSTALL_LINK: ${INSTALL_LINK}"
}

function configure() {
  local cmake_options=(-DCMAKE_INSTALL_PREFIX=install -DBUILD_WEBENGINE=OFF -DBUILD_WEBEBENGINE=OFF -DDOWNLOAD_ASSETS=ON)
  if [[ "${PLATFORM}" == "macOS" ]]; then
    cmake_options+=(-DCMAKE_BUILD_TYPE=RELEASE) # don't build mtest
  else
    cmake_options+=(-DCMAKE_BUILD_TYPE=DEBUG)
  fi
  case "${PLATFORM}" in
    Windows )
      cmake_options+=(-G "${GENERATOR}" -DBUILD_64="${BUILD_64}")
      if [[ "${GENERATOR_FAMILY}" == "MINGW" ]]; then
        cmake_options+=(-DCMAKE_MAKE_PROGRAM=mingw32-make.exe)
      fi
      ;;
    macOS   ) cmake_options+=(-G "Xcode") ;;
  esac
  cmake "${cmake_options[@]}" "${SOURCE_DIR}"
  # make lrelease # do this in configure step since we don't need to do it on every build
  cmake_build --target lrelease
}

function build() {
  # make
  cmake_build
}

function install() {
  # make install
  cmake_build --target install
}

function clean() {
  rm -rf "${BUILD_DIR}"
}

function copy() {
  # copy the build directory of an existing branch to speed up a clean build
  local dest_dir branch="$1"
  dest_dir="${BUILD_DIR}"
  GIT_BRANCH="${branch}" set_build_dir
  if [[ ! -d "${BUILD_DIR}" ]]; then
    echo "$0: error: no suitable build found for branch '${branch}'." >&2
    exit 1
  fi
  if [[ -d "${dest_dir}" ]]; then
    echo "$0: error: build dir not clean for branch '${dest_dir}'." >&2
    exit 1
  fi
  echo "$0: copying build directory for branch '${branch}'." >&2
  time cp -rp "${BUILD_DIR}" "${dest_dir}"
  echo "$0: deleting 'CMakeCache.txt' to avoid CMake warnings." >&2
  rm "${dest_dir}/CMakeCache.txt"
  BUILD_DIR="${dest_dir}"
}

function refresh() {
  # ensure ignored IDE project files match repository versions
  local platform
  case "${PLATFORM}" in
    Windows ) platform="Windows"  ;;
    macOS )   platform="Mac"      ;;
    * )       platform="Linux"    ;;
  esac
  local project_files=(
    bef-filepaths.sh
    musescore_build.sh
    musescore_build_windows.bat
    MuseScore_${platform}.config
    MuseScore_${platform}.creator
    MuseScore_${platform}.creator.user
    MuseScore_${platform}.files
    MuseScore_${platform}.includes
  )
  for file in "${project_files[@]}"; do
    refresh_file "${file}"
  done
  refresh_file exclude .git/info/exclude
}

function refresh_file() {
  local -r here="${HOME}/ssrc/MuseScore/musescore_build"
  local -r stored="${here}/$1" ignored="${2:-$1}"
  if [[ -e "${stored}" ]]; then
    if [[ "${stored}" -nt "${ignored}" ]] ; then
      echo "$0: refreshing file: ${ignored}" >&2
      cp -p "${stored}" "${ignored}"
    elif [[ "${ignored}" -nt "${stored}" ]]; then
      echo "$0: refreshing file: ${stored} (remember to commit)" >&2
      cp -p "${ignored}" "${stored}"
    fi
  else
    echo "$0: file not found: ${stored}" >&2
  fi
}

function parse_args() {
  local arg param
  # local get_param='param="${arg:2}" ; [[ "${param}" ]] || { param="$1"; shift ;}'
  unset arg_clean arg_configure arg_build arg_install # build steps
  unset arg_copy # other arguments
  # unset arg_generator arg_build_type # cmake options
  while (($# > 0)); do
    arg="$1"
    shift
    case "${arg}" in
      # BUILD STEPS
      clean )
        arg_clean=1
        if [[ "$1" == "--copy" ]]; then
          # copy another branch's build dir to speed up build
          arg_copy="$2"
          shift 2
        fi
        ;;
      configure ) arg_configure=1 ;;
      build )     arg_build=1     ;;
      install )   arg_install=1   ;;
      # CMAKE OPTIONS
      # -G* ) eval "${get_param}" ; arg_generator="${param}" ;;
      # -D* ) eval "${get_param}" ; arg_generator="${param}"
      * ) echo "$0: unrecognised option: ${arg}" >&2 ;;
    esac
  done
}

function main() {
  set -e # exit immediately on error
  if ((${BASH_VERSION:0:1} < 4)); then
    echo "$0: Error: Bash version 4 or later required. Please upgrade!" >&2
    local mac_help="https://coderwall.com/p/dmuxma/upgrade-bash-on-your-mac-os"
    echo "macOS users please read <${mac_help}>." >&2
    exit 1
  fi
  parse_args "$@"
  set_variables
  set_build_dir
  link_build_dir

  refresh

  if [[ "${arg_clean}"     ]]; then
    clean
    if [[ "${arg_copy}" ]]; then copy "${arg_copy}"; fi
  fi

  if [[ "${arg_configure}${arg_build}${arg_install}" ]]; then
    cd "${BUILD_DIR}" || { echo "$0: error: not yet configured!" >&2 ; exit 1 ;}
    if [[ "${arg_configure}" ]]; then configure; fi
    if [[ "${arg_build}"     ]]; then build    ; fi
    if [[ "${arg_install}"   ]]; then install  ; fi
  fi
}

printf "%q " "$0" "$@" && echo # display script name and arguments passed by user
main "$@" # call main function

musescore_build_windows.bat

:: I recommend installing Git via Scoop (https://scoop.sh/)

set BASH="%USERPROFILE%\scoop\apps\git-with-openssh\current\bin\bash.exe"

:: If you prefer to install Git manually, uncomment next line

:: set BASH="C:\Program Files (x86)\Git\bin\bash.exe"

%BASH% --login -i -c "./musescore_build.sh %*"

path_functions.sh

#!/usr/bin/env bash
############# BASH ESSENTIAL FUNCTIONS - FILEPATHS MODULE (BEF-FP) #############
# If copying the contents of this module into your own script be sure to comment
# out the next line, otherwise this library's usage message will be displayed.
if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then case "$1" in -l*|--l*) message='
################################## LICENSE #####################################
# Bash Essential Functions - FilePaths module (BEF-FP)
#
# The Bash Essential Functions library is licensed under the MIT License (a.k.a.
# the "Expat License"), details of which are below. Code contributions are
# welcome at <https://github.com/shoogle/bash-essential-functions>.
#
# MIT License
#
# Copyright (c) 2017 Peter Jonas
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
################################################################################
#' ;; -h*|-h*) message='
#################################### HELP ######################################
# Bash Essential Functions - FilePaths module (BEF-FP)
#
# Source this file to get access to the functions it contains:
#
#   $  source  bef-filepaths.sh  [--no-convenience-functions]
#
# Functions in this module are named `bef_fp__function_name` to avoid polluting
# the global namespace. After souring the file you can list the functions with:
#
#   $ declare -F | grep "bef_fp"  # `declare -f` includes function definitions!
#
# BEF modules provide convenience functions that accept data piped from STDIN
# and echo the result to STDOUT, which can be saved using command substitution:
#
#   $  myvar="$(pipeline  |  bef_fp__function_name  "${args}")"  # convenient!
#
# However, this is not recommended because command substitution strips trailing
# newlines, which, although rarely used, are valid characters in Unix filenames.
# Instead, you should consider using the "setvar" functions:
#
#   $  declare funcvar  &&  bef_fp__setvar_funcvar "${arg}"  # faster & safer!
#
# This sets the variable "funcvar" to the output of the first function, without
# losing any trailing newline characters. Using the setvar function is faster
# than command substitution because it avoids spawning a subshell. Most setvar
# functions do not accept piped data because this could spawn a subshell.
#
# If you want to disable the convenience functions entirely and keep only setvar
# functions then source the file with the `--no-convenience-functions` option.
################################################################################
#' ;; *) message="
#################################### USAGE #####################################
# Bash Essential Functions - FilePaths module (BEF-FP)
#
# This script is a Bash function library and should be sourced rather than run.
#
# Usage: .|source  bef-filepaths.sh  [--no-convenience-functions]
#
# However, it may be run with the following options to display info messages:
#
# Usage: [bash] ./bef-filepaths.sh [-h|--help] [-l|--license]
#
# Please submit code contributions and bug reports to the upstream repository
# at <https://github.com/shoogle/bash-essential-functions>. Thanks!
################################################################################
#" ;; esac; IFS=$'\n' read -d '' -n ${#message} -a lines <<<"${message}
#" ; for ((i=1;i<${#lines[@]}-2;i++)); do echo "${lines[i]:2}"; done; exit; fi
################################################################################

if [[ "$1" != "--no-convenience-functions" ]]; then

  function bef_fp__basename() {
    local path basename \
      && bef_fp__setvar_path_from_args_or_stdin "$@" \
      && bef_fp__setvar_basename "${path}" \
      && echo "${basename}"
  }

  function bef_fp__dirname() {
    local path dirname \
      && bef_fp__setvar_path_from_args_or_stdin "$@" \
      && bef_fp__setvar_dirname "${path}" \
      && echo "${dirname}"
  }

  # Appends $PWD to $path if $path is relative (does not start with '/'). $path
  # does not have to exist. Output is not normalized or canonicalized.
  function bef_fp__absolute_path() {
    local path abspath \
      && bef_fp__setvar_path_from_args_or_stdin "$@" \
      && bef_fp__setvar_abspath "${path}" \
      && echo "${abspath}"
  }

  function bef_fp__normalized_path() {
    local path normpath \
      && bef_fp__setvar_path_from_args_or_stdin "$@" \
      && bef_fp__setvar_normpath "${path}" \
      && echo "${normpath}"
  }

  function bef_fp__inverse_path() {
    local path invpath \
      && bef_fp__setvar_path_from_args_or_stdin "$@" \
      && bef_fp__setvar_invpath "${path}" \
      && echo "${invpath}"
  }

  function bef_fp__canonical_path() {
    local path canonpath \
      && bef_fp__setvar_path_from_args_or_stdin "$@" \
      && bef_fp__setvar_canonpath "${path}" \
      && echo "${canonpath}"
  }

fi # [[ "$1" != "--no-convenience-functions" ]]

# set $path variable in caller shell with input from $1 or STDIN
# Usage: local path && bef_fp__setvar_path_from_args_or_stdin "$@"
function bef_fp__setvar_path_from_args_or_stdin() {
  if (($# > 0)); then
    path="$1"
  else
    read -d '' -r path # path from STDIN (path may contain newlines)
    path="${path%$'\n'}" # strip extra newline added by read -d ''
  fi
}

# set $nodes array in caller shell with result of splitting $1 on "/"
# Usage: local nodes=() && bef_fp__setvar_nodes_array "${path}"
function bef_fp__setvar_nodes_array() {
  local length=${#1} IFS="/" # split path on "/"
  # read $path into array. Only read $lenght chars to avoid extra '\n' chars.
  ((length == 0)) || read -d '' -n $length -r -a nodes <<<"$1"
}

# set $basename variable in caller shell with basename of $1. Avoids subshell.
# Usage: local basename && bef_fp__setvar_basename "${path}"
function bef_fp__setvar_basename() {
  local path="$1"
  if [[ "${path}" =~ ^/+$ ]]; then
    basename="/" # path consists only of slashes
    return # '/////' gives '/'
  fi
  while [[ "${path}" == *"/" ]]; do
    path="${path%/}" # strip trailing slash(es): 'foo/bar//' goes to 'foo/bar'
  done
  # return everything after final slash, or everything if there are no slashes
  basename="${path##*/}" # 'foo/bar' or 'bar' gives 'bar'
}

# set $dirname variable in caller function dirname of $1. Avoids subshell.
# Usage: local dirname && bef_fp__setvar_dirname "${path}"
function bef_fp__setvar_dirname() {
  local path="$1"
  if [[ "${path}" =~ ^/*[^/]*/*$ ]]; then # path only has one node: //foo///
    if [[ "${path:0:1}" == / ]]; then
      dirname="/" # '//foo///', '//foo' or '//' gives '/' (shortest abs. path)
    else
      dirname="." # 'foo///', 'foo' or '' gives '.' (shortest relative path)
    fi
    return
  fi
  while [[ "${path}" == */ ]]; do # strip any trailing slash(es)
    path="${path%/}" # 'foo///bar///' goes to 'foo///bar'
  done
  # only keep characters before the final slash, or everything if no slashes
  path="${path%/*}" # 'foo///bar' goes to 'foo//', 'foo' goes to 'foo'
  while [[ "${path}" == */ ]]; do
    path="${path%/}" # strip trailing slash(es):  'foo//' goes to 'foo'
  done
  dirname="${path}"
}

# Prepends $PWD to $path if $path is relative (does not start with '/'). $path
# does not have to exist. Output is not normalized or canonicalized.
function bef_fp__setvar_abspath() {
  local path="$1"
  if [[ "${path:0:1}" == "/" ]]; then
    abspath="${path}"
  else
    abspath="${PWD}/${path}"
  fi
}

# Removes unnecessary slashes and resolves '.' and '..' to return the shortest
# path equivalent to the one given as input. The path does not have to exist.
function bef_fp__setvar_normpath() {
  local path="$1" basename dirname abs skip=0
  [[ "${path:0:1}" == "/" ]] && abs="/" || abs="" # relative or absolute path?
  while [[ ! "${path}" =~ ^\.?/*$ ]]; do
    bef_fp__setvar_basename "${path}"
    bef_fp__setvar_dirname "${path}"
    if [[ "${basename}" == "." ]]; then
      : # ignore node
    elif [[ "${basename}" == ".."  ]]; then
      ((skip++)) # skip next node that isn't '.' or '..' or already skipped
    elif ((skip > 0)); then
      ((skip--)) # skipping this node due to prior '..'
    else
      normpath="${basename}/${normpath}" # add node to normpath
    fi
    path="${dirname}" # move to next node
  done
  if [[ ! "${abs}" ]]; then
    while ((skip > 0)); do
      normpath="../${normpath}"
      ((skip--))
    done
  fi
  if [[ "${normpath}" ]]; then
    normpath="${abs}${normpath%/}" # strip trailing slash
  elif [[ "${abs}" ]]; then
    normpath="/"
  else
    normpath="."
  fi
}

# Gives location of working directory relative to specified path
# The path does not have to exist.
function bef_fp__setvar_invpath() {
  local path="$1" compath="$2" normpath bk=0 fd=0
  if [[ ! "${compath}" ]]; then
    compath="${PWD}"
  fi
  bef_fp__setvar_normpath "${path}"
  path="${normpath}"
  if [[ "${path:0:1}" == "/" ]]; then
    invpath="${PWD}"
  elif [[ "${path}" == "." ]]; then
    invpath="."
  else
    while [[ "${path}" != "." ]]; do
      bef_fp__setvar_dirname "${path}"
      bef_fp__setvar_basename "${path}"
      if [[ "${basename}" == ".." ]]; then
        ((bk++))
      else
        ((fd++))
      fi
      path="${dirname}"
    done
    while ((bk > 0)); do
      bef_fp__setvar_basename "${compath}"
      invpath="${basename}/${invpath}"
      bef_fp__setvar_dirname "${compath}"
      compath="${dirname}"
      ((bk--))
    done
    while ((fd > 0)); do
      invpath="../${invpath}"
      ((fd--))
    done
    invpath="${invpath%/}" # strip trailing slash
  fi
}

function bef_fp__setvar_canondirpath() {
  local dirpath="$1"
   # `cd` to $dirpath and back again. ${OLDPWD} created automatically by shell.
  CDPATH="" cd -P "${dirpath}" \
    && canondirpath="${PWD}" \
    && CDPATH="" cd "${OLDPWD}" \
    || echo "${FUNCNAME[0]}: error: unable to access: ${dirpath}" >&2
}

# Prints physical path without symbolic links. ${path} must exist on system.
function bef_fp__setvar_canonpath() {
  local path="$1" canonpath canondirpath
  if [[ -d "${path}" ]]; then
    bef_fp__setvar_canondirpath "${path}"
    canonpath="${canondirpath}"
  elif [[ ! -e "${path}" ]]; then
    if [[ -L "${path}" ]]; then
      echo "${FUNCNAME[0]}: error: no target found for symlink: ${path}" >&2
      return 2
    else
      echo "${FUNCNAME[0]}: error: file not found: ${path}" >&2
      return 1
    fi
  else
    local basename dirname symlinks=0 max_symlinks=40
    while [[ -L "${path}" ]]; do
      if ((symlinks++ && symlinks > max_symlinks)); then
        echo "${FUNCNAME[0]}: error: too many symlinks: ${path}" >&2
        return 3
      fi
      # Must read the link. Can we avoid using subshell and external binary?
      canonpath="$(readlink "${path}")" # XXX: Can we avoid this?
      if [[ "${canonpath:0:1}" == "/" ]]; then
        path="${canonpath}"
      else
        bef_fp__setvar_dirname "${path}"
        path="${dirname}/${canonpath}"
      fi
    done
    bef_fp__setvar_basename "${path}"
    bef_fp__setvar_dirname "${path}"
    bef_fp__setvar_canondirpath "${dirname}"
    canonpath="${canondirpath}/${basename}"
  fi
}