dxvk-wine-autobuilder/debian/wineroot/winebuild.sh

#!/bin/env bash

#    Wine/Wine Staging build script for Debian & variants (amd64)
#    Copyright (C) 2018  Pekka Helenius
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <https://www.gnu.org/licenses/>.

########################################################

# DO NOT RUN INDIVIDUALLY, ONLY VIA ../../updatewine.sh PARENT SCRIPT!

########################################################

# datedir variable supplied by ../updatewine_debian.sh script file
datedir="${1}"

########################################################

# The directory this script is running at

BUILDROOT="${PWD}"

########################################################

# Staging patchsets. Default: all patchsets.
# Applies only if Wine Staging is set to be compiled
# Please see Wine Staging patchinstall.sh file for individual patchset names.
staging_patchsets=(--all)

########################################################

# Wine build dependency lists on Debian

wine_deps_build_common=(
'make'
'gcc-multilib'
'g++-multilib'
'libxml-simple-perl'
'libxml-parser-perl'
'libxml-libxml-perl'
'lzma'
'flex'
'bison'
'quilt'
'gettext'
# 'oss4-dev' # Not available on Debian
'sharutils'
'pkg-config'
'dctrl-tools'
'khronos-api'
'unicode-data'
# 'freebsd-glue' # Not available anymore
'icoutils'
'librsvg2-bin'
'imagemagick'
'fontforge'
)

wine_deps_build_amd64=(
'libxi-dev:amd64'
'libxt-dev:amd64'
'libxmu-dev:amd64'
'libgl-dev:amd64'
'libglx-dev:amd64|optional'
'libx11-dev:amd64'
'libxext-dev:amd64'
'libxfixes-dev:amd64'
'libxrandr-dev:amd64'
'libxcursor-dev:amd64'
'libxrender-dev:amd64'
'libxkbfile-dev:amd64'
'libxxf86vm-dev:amd64'
'libxxf86dga-dev:amd64'
'libxinerama-dev:amd64'
'libgl1-mesa-dev:amd64'
'libglu1-mesa-dev:amd64'
'libxcomposite-dev:amd64'
'libpng-dev:amd64'
'libssl-dev:amd64'
'libv4l-dev:amd64'
'libxml2-dev:amd64'
'libgsm1-dev:amd64'
'libjpeg-dev:amd64'
# 'libkrb5-dev:amd64'
'libtiff-dev:amd64'
'libsane-dev:amd64'
'libudev-dev:amd64'
'libpulse-dev:amd64'
'liblcms2-dev:amd64'
# 'libldap2-dev:amd64'
'libxslt1-dev:amd64'
'unixodbc-dev:amd64'
'libcups2-dev:amd64'
'libcapi20-dev:amd64'
'libopenal-dev:amd64'
'libdbus-1-dev:amd64'
'freeglut3-dev:amd64'
'libmpg123-dev:amd64'
'libasound2-dev:amd64'
'libgphoto2-dev:amd64'
'libosmesa6-dev:amd64'
'libpcap0.8-dev:amd64'
'libgnutls28-dev:amd64'
'libncurses5-dev:amd64'
'libgettextpo-dev:amd64'
'libfreetype6-dev:amd64'
'libfontconfig1-dev:amd64'
'libgstreamer-plugins-base1.0-dev:amd64'
'ocl-icd-opencl-dev:amd64'
'libvulkan-dev:amd64'
)

wine_deps_build_i386=(
'libxi-dev:i386'
'libxt-dev:i386'
'libxmu-dev:i386'
'libgl-dev:i386'
'libglx-dev:i386|optional'
'libx11-dev:i386'
'libxext-dev:i386'
'libxfixes-dev:i386'
'libxrandr-dev:i386'
'libxcursor-dev:i386'
'libxrender-dev:i386'
'libxkbfile-dev:i386'
'libxxf86vm-dev:i386'
'libxxf86dga-dev:i386'
'libxinerama-dev:i386'
'libgl1-mesa-dev:i386'
'libglu1-mesa-dev:i386'
'libxcomposite-dev:i386'
'libpng-dev:i386'
'libssl-dev:i386'
'libv4l-dev:i386'
'libgsm1-dev:i386'
'libjpeg-dev:i386'
# 'libkrb5-dev:i386'
'libsane-dev:i386'
'libudev-dev:i386'
'libpulse-dev:i386'
'liblcms2-dev:i386'
# 'libldap2-dev:i386'
'unixodbc-dev:i386'
'libcapi20-dev:i386'
'libopenal-dev:i386'
'libdbus-1-dev:i386'
'freeglut3-dev:i386'
'libmpg123-dev:i386'
'libasound2-dev:i386'
'libgphoto2-dev:i386'
'libosmesa6-dev:i386'
'libpcap0.8-dev:i386'
'libncurses5-dev:i386'
'libgettextpo-dev:i386'
'libfreetype6-dev:i386'
'libfontconfig1-dev:i386'
'ocl-icd-opencl-dev:i386'
'libvulkan-dev:i386'
'libicu-dev:i386'
'libxml2-dev:i386'
'libxslt1-dev:i386'
'libtiff-dev:i386'
'libcups2-dev:i386'
'libgnutls28-dev:i386'
'gir1.2-gstreamer-1.0:i386' #required by libgstreamer1.0-dev:i386
'libgstreamer1.0-dev:i386'
'libgstreamer-plugins-base1.0-dev:i386'
)

########################################################

# Wine runtime dependency lists on Debian

wine_deps_runtime_common=(
'desktop-file-utils'
)

wine_deps_runtime_i386=(
'libxcursor1:i386'
'libxrandr2:i386'
'libxi6:i386'
# 'gettext:i386' # Conflicts with amd64 version on multiple distros
'libsm6:i386'
'libvulkan1:i386'
'libasound2:i386'
'libc6:i386'
'libfontconfig1:i386'
'libfreetype6:i386'
'libgcc1:i386'
'libglib2.0-0:i386'
'libgphoto2-6:i386'
'libgphoto2-port12:i386'
'liblcms2-2:i386'
# 'libldap-2.4-2:i386'
'libmpg123-0:i386'
'libncurses5:i386'
'libopenal1:i386'
'libpcap0.8:i386'
'libpulse0:i386'
'libtinfo5:i386'
'libudev1:i386'
'libx11-6:i386'
'libxext6:i386'
'libxml2:i386'
'ocl-icd-libopencl1:i386'
'zlib1g:i386'
'libgstreamer-plugins-base1.0-0:i386'
'libgstreamer1.0-0:i386'
)

wine_deps_runtime_amd64=(
'fontconfig:amd64'
'libxcursor1:amd64'
'libxrandr2:amd64'
'libxi6:amd64'
'gettext:amd64'
'libsm6:amd64'
'libvulkan1:amd64'
'libasound2:amd64'
'libc6:amd64'
'libfontconfig1:amd64'
'libfreetype6:amd64'
'libgcc1:amd64'
'libglib2.0-0:amd64'
'libgphoto2-6:amd64'
'libgphoto2-port12:amd64'
'liblcms2-2:amd64'
# 'libldap-2.4-2:amd64'
'libmpg123-0:amd64'
'libncurses5:amd64'
'libopenal1:amd64'
'libpcap0.8:amd64'
'libpulse0:amd64'
'libtinfo5:amd64'
'libudev1:amd64'
'libx11-6:amd64'
'libxext6:amd64'
'libxml2:amd64'
'ocl-icd-libopencl1:amd64'
'zlib1g:amd64'
'libgstreamer-plugins-base1.0-0:amd64'
'libgstreamer1.0-0:amd64'
)

########################################################

# Wine staging override list
# Wine Staging replaces and conflicts with these packages
# Applies to debian/control file

wine_overr_pkgs=(
'wine'
'wine-development'
'wine64-development'
'wine1.6'
'wine1.6-i386'
'wine1.6-amd64'
'libwine:amd64'
'libwine:i386'
'wine-stable'
'wine32'
'wine64'
'fonts-wine'
)

############################

# Suggests section in debian/control file

wine_suggested_pkgs=(
'winbind'
'winetricks'
'playonlinux'
'wine-binfmt'
'dosbox'
)

########################################################

# Architecture check. We do not support independent
# i386 environments

if [[ $(uname -a | grep -c x86_64) -eq 0 ]]; then
  echo "\e[1mERROR:\e[0m This script supports 64-bit architectures only."
  exit 1
fi

########################################################

# Divide input args into array indexes
i=0
for p in ${@:2}; do
  params[$i]=${p}
  let i++
done

########################################################

# Parse input git override hashes
# This order is mandatory!
# If you change the order or contents of 'githash_overrides'
# array in ../updatewine.sh, make sure to update these
# variables!
#
git_commithash_wine=${params[5]}
git_branch_wine=${params[11]}

git_source_wine_debian=${params[22]}
git_source_winestaging_debian=${params[23]}

########################################################

# Parse input arguments, filter user parameters
# The range is defined in ../updatewine.sh
# All input arguments are:
# <datedir> 4*<githash_override> 4*<gitbranch_override> <args>
# 0         1 2 3 4              5 6 7 8                9...
# Filter all but <args>, i.e. the first 0-8 arguments

i=0
for arg in ${params[@]:8}; do
  args[$i]="${arg}"
  let i++
done

for check in ${args[@]}; do

  case ${check} in
    --no-staging)
      NO_STAGING=
      ;;
    --no-install)
      NO_INSTALL=
      ;;
    --buildpkg-rm)
      BUILDPKG_RM=
      ;;
  esac

done

############################

# Package name and website

if [[ ! -v NO_STAGING ]]; then
  pkgname="wine-staging-git"
else
  pkgname="wine-git"
fi

pkgurl="https://www.winehq.org"

########################################################

# If the script is interrupted (Ctrl+C/SIGINT), do the following

function Wine_intCleanup() {
  cd "${BUILDROOT}"
  rm -rf "winebuild_${datedir}"
  exit 0
}

# Allow interruption of the script at any time (Ctrl + C)
trap "Wine_intCleanup" INT

# Error event
#trap "Wine_intCleanup" ERR

########################################################

# This is specifically for Debian
# Must be done in order to install Wine i386 buildtime dependencies on amd64 environment
#
if [[ $(dpkg --print-foreign-architectures | grep i386 | wc -w) -eq 0 ]]; then
  sudo dpkg --add-architecture i386
  sudo apt update
fi

########################################################

# If user has gstreamer girl (amd64) package installed on the system
# before Wine compilation, then reinstall it after the compilation process
#
function girl_check() {

  girlpkg="gir1.2-gstreamer-1.0:amd64"

  if [[ $(echo $(dpkg -s ${girlpkg} &>/dev/null)$?) -eq 0 ]]; then
    GIRL_CHECK=
  fi
}

########################################################

function getWine() {

  local winesrc_url
  local winestagingsrc_url

  winesrc_url="${git_source_wine_debian}"
  winestagingsrc_url="${git_source_winestaging_debian}"

  function cleanOldBuilds() {
    if [[ $(find "${BUILDROOT}" -type d -name "winebuild_*" | wc -l) -ne 0 ]]; then
      echo -e "Removing old Wine build folders. This can take a while.\n"
      rm -rf "${BUILDROOT}"/winebuild_*
    fi
  }

  cleanOldBuilds

##########

  mkdir "${BUILDROOT}/winebuild_${datedir}"
  cd "${BUILDROOT}/winebuild_${datedir}"
  WINEROOT="${PWD}"

##########

  echo -e "Retrieving source code of Wine$(if [[ ! -v NO_STAGING ]]; then echo ' & Wine Staging' ; fi)\n"

  git clone ${winesrc_url}
  if [[ ! -v NO_STAGING ]]; then
    git clone ${winestagingsrc_url}
    WINEDIR_STAGING="${WINEROOT}/wine-staging"
  fi

##########

  mkdir wine-{patches,32-build,32-install,64-build,64-install,package}

  for file in ../../../wine_custom_patches/*.{patch,diff}; do
    if [[ $(echo "${file}") == *"_staging"* ]] && [[ -v NO_STAGING ]]; then
      continue
    fi

    if [[ $(echo "${file}") == *"_nostaging"* ]] && [[ ! -v NO_STAGING ]]; then
      continue
    fi

    cp -rf "${file}" wine-patches/ 2>/dev/null
  done

  WINEDIR="${WINEROOT}/wine"
  WINEDIR_PATCHES="${WINEROOT}/wine-patches"
  WINEDIR_BUILD_32="${WINEROOT}/wine-32-build"
  WINEDIR_BUILD_64="${WINEROOT}/wine-64-build"
  WINEDIR_INSTALL_32="${WINEROOT}/wine-32-install"
  WINEDIR_INSTALL_64="${WINEROOT}/wine-64-install"
  WINEDIR_PACKAGE="${WINEROOT}/wine-package"

}

function getDebianFiles() {

  local debian_archive

  debian_archive=wine_3.0-1ubuntu1.debian.tar.xz

  cd "${WINEDIR}"
  wget http://archive.ubuntu.com/ubuntu/pool/universe/w/wine/${debian_archive}
  tar xvf ${debian_archive}
  rm ${debian_archive}

}

########################################################

# Parse Wine hash override if Staging is set to be installed

function check_gitOverride() {

  # If staging is to be installed and Wine git is frozen to a specific commit
  # We need to determine exact commit to use for Wine Staging
  # to avoid any mismatches
  #
  # Basically, when user has defined 'git_commithash_wine' variable (commit), we
  # iterate through Wine commits and try to determine previously set
  # Wine Staging commit. We use that Wine Staging commit instead of
  # the one user has defined in 'git_commithash_wine' variable
  #
  if [[ ! -v NO_STAGING ]] && [[ "${git_commithash_wine}" != HEAD ]]; then

    function form_commit_array() {

      local array_name
      local commits_raw
    
      cd "${commit_dir}"

      if [[ $? -ne 0 ]]; then
        echo -e "\e[1mERROR:\e[0m Couldn't access Wine folder ${commit_dir} to check commits. Aborting\n"
        exit 1
      fi

      array_name=${1}
      commits_raw=$(eval ${2})

      local i=0
      for commit in ${commits_raw[*]}; do
        eval ${array_name}[$i]="${commit}"
        let i++
      done

      if [[ $? -ne 0 ]]; then
        echo -e "\e[1mERROR:\e[0m Couldn't parse Wine commits in ${commit_dir}. Aborting\n"
        exit 1
      fi

      cd "${WINEROOT}"

    }

    function staging_change_freeze_commit() {

      local wine_commits_raw
      local staging_refcommits_raw
      local staging_rebasecommits_raw
      local i
      local k
      local wine_dropcommits
    
      wine_commits_raw="git log --pretty=oneline | awk '{print \$1}' | tr '\n' ' '"

      # TODO this check may break quite easily
      # It depends on the exact comment syntax Wine Staging developers are using (Rebase against ...)
      # Length and order of these two "array" variables MUST MATCH!
      staging_refcommits_raw="git log --pretty=oneline | awk '{ if ((length(\$NF)==40 || length(\$NF)==41) && \$(NF-1)==\"against\") print \$1; }'"
      staging_rebasecommits_raw="git log --pretty=oneline | awk '{ if ((length(\$NF)==40 || length(\$NF)==41) && \$(NF-1)==\"against\") print substr(\$NF,1,40); }' | tr '\n' ' '"

      # Syntax: <function> <array_name> <raw_commit_list>
      commit_dir="${WINEDIR}"
      form_commit_array wine_commits "${wine_commits_raw}"

      commit_dir="${WINEDIR_STAGING}"
      form_commit_array staging_refcommits "${staging_refcommits_raw}"
      form_commit_array staging_rebasecommits "${staging_rebasecommits_raw}"

      # User has selected vanilla Wine commit to freeze to
      # We must get the previous Staging commit from rebase_commits array, and
      # change git_commithash_wine value to that

      # Get all vanilla Wine commits
      # Filter all newer than defined in 'git_commithash_wine'
      #
      echo -e "Determining valid Wine Staging git commit. This takes a while.\n"
      i=0
      for dropcommit in ${wine_commits[@]}; do
        if [[ "${dropcommit}" == "${git_commithash_wine}" ]]; then
          break
        else
          wine_dropcommits[$i]="${dropcommit}"
          let i++
        fi
      done
      wine_commits=("${wine_commits[@]:${#wine_dropcommits[*]}}")

      # For the filtered array list, iterate through 'staging_rebasecommits' array list until
      # we get a match
      for vanilla_commit in ${wine_commits[@]}; do
        k=0
        for rebase_commit in ${staging_rebasecommits[@]}; do
          if [[ "${vanilla_commit}" == "${rebase_commit}" ]]; then
            # This is the commit we use for vanilla Wine
            git_commithash_wine="${vanilla_commit}"
            # This is equal commit we use for Wine Staging
            git_commithash_winestaging="${staging_refcommits[$k]}"
            break 2
          fi
        let k++
        done
      done

    }
    git_branch_wine=master
    staging_change_freeze_commit

  elif [[ ! -v NO_STAGING ]] && [[ "${git_commithash_wine}" == HEAD ]]; then
    git_branch_wine=master
    git_commithash_winestaging=HEAD
  fi
}

########################################################

# Wine dependencies removal/installation

# Global variable to track buildtime dependencies
z=0

function WineDeps() {

  local method
  local deps
  local depsname
  local pkgtype
  local str
  local mgrcmd

  method=${1}
  deps="${2}"
  depsname=${3}
  pkgtype=${4}

  case ${method} in
    install)
      str="Installing"
      mgrcmd="sudo apt install -y"
      ;;
    remove)
      str="Removing"
      mgrcmd="sudo apt purge --remove -y"
      ;;
    *)
      echo -e "\e[1mERROR:\e[0m Unknown package management input method. Aborting\n"
      exit 1
  esac

  echo -e "${str} Wine dependencies (${depsname}).\n"

  # Check and install/remove package related dependencies if they are missing/installed
  function pkgdependencies() {

    local deplist
    local checkstatus
    local a
    local b
    local validlist

    deplist="${1}"

    # Get a valid logic for generating 'list' array below
    case ${method} in
      install)
        # Package is not installed, install it
        checkstatus=0
        ;;
      remove)
        # Package is installed, remove it
        checkstatus=1
        ;;
    esac

    # Generate a list of missing/removable dependencies, depending on the logic
    a=0
    for p in ${deplist[@]}; do
      pf=$(printf "%s" ${p} | sed -r 's/^(.*)\|.*/\1/')
      if [[ $(echo $(dpkg -s ${pf} &>/dev/null)$?) -ne ${checkstatus} ]]; then
        validlist[$a]=${p}
        let a++

        # Global array to track installed build dependencies
        if [[ ${method} == "install" ]] && [[ ${pkgtype} == "buildtime" ]]; then
          buildpkglist[$z]=${p}
          let z++
        fi

      fi
    done

    # Install missing/Remove existing dependencies, be informative
    b=0
    for pkgdep in ${validlist[@]}; do

      optional=0
      if [[ ${pkgdep} =~ \|optional ]]; then
        pkgdep=$(printf "%s" ${pkgdep} | sed -r 's/^(.*)\|.*/\1/')
        optional=1
      fi

      echo -e "$(( $b + 1 ))/$(( ${#validlist[*]} )) - ${str} ${depsname} dependency ${pkgdep}"
      eval ${mgrcmd} ${pkgdep} &> /dev/null
      if [[ $? -eq 0 ]] || [[ ${optional} == 1 ]]; then
        let b++
      else
        echo -e "\n\e[1mERROR:\e[0m Error occured while processing ${pkgdep}. Aborting.\n"
        exit 1
      fi
    done
    if [[ -n ${validlist[*]} ]]; then
      # Add empty newline
      echo ""
    fi
  }

  pkgdependencies "${deps[*]}"

}

########################################################

# Feed the following data to Wine debian/control file

# If we separate i386 build to be an independent one, this function
# must be improved, if built with amd64 package together
# If we just bundle them together, single package description for
# debian/control file is enough

function feed_debiancontrol() {

cat << CONTROLFILE > debian/control
Source: ${pkgname}
Section: otherosfs
Priority: optional
Maintainer: ${USER} <${USER}@unknown>
Build-Depends: debhelper (>=9), $(echo "${wine_deps_build[*]}" | sed 's/\s/, /g')
Standards-Version: 4.1.2
Homepage: ${pkgurl}

Package: ${pkgname}
Architecture: any
Depends: $(echo ${wine_deps_runtime[*]} | sed 's/\s/, /g')
Suggests: $(echo ${wine_suggested_pkgs[*]} | sed 's/\s/, /g')
Conflicts: $(echo ${wine_overr_pkgs[*]} | sed 's/\s/, /g')
Breaks: $(echo ${wine_overr_pkgs[*]} | sed 's/\s/, /g')
Replaces: $(echo ${wine_overr_pkgs[*]} | sed 's/\s/, /g')
Provides: $(echo ${wine_overr_pkgs[*]} | sed 's/\s/, /g')
Description: A compatibility layer for running Windows programs.
 Wine is an open source Microsoft Windows API implementation for
 POSIX-compliant operating systems, including Linux.
 Git version includes the latest updates available for Wine.

CONTROLFILE

}

########################################################

# Refresh Wine GIT

function refreshWineGIT() {

  # Restore the wine tree to its git origin state, without wine-staging patches
  # (necessary for reapllying wine-staging patches in succedent builds,
  # otherwise the patches will fail to be reapplied)
  cd "${WINEDIR}"

  if [[ -v NO_STAGING ]]; then
    git checkout ${git_branch_wine} # Get Wine branch
  fi

  git reset --hard ${git_commithash_wine} # Get Wine commit
  if [[ $? -ne 0 ]]; then
    echo "\e[1mERROR:\e[0m Couldn't find git commit '${git_commithash_wine}' for Wine. Aborting\n"
    exit 1
  fi
  git clean -d -x -f # Delete untracked files

  if [[ ! -v NO_STAGING ]]; then

    if [[ ${git_commithash_wine} == HEAD ]]; then
      # Change back to the wine upstream commit that this version of wine-staging is based on
      git checkout $(bash "${WINEDIR_STAGING}"/patches/patchinstall.sh --upstream-commit)

    else
      cd "${WINEDIR_STAGING}"
      git reset --hard ${git_commithash_winestaging}
      if [[ $? -ne 0 ]]; then
        echo "\e[1mERROR:\e[0m Couldn't find git commit '${git_commithash_winestaging}' for Wine Staging. Aborting\n"
        exit 1
      fi
    fi
  fi
}

########################################################

# Get Wine version tag

function wine_version() {
  cd "${WINEDIR}"
  git describe | sed 's/^[a-z]*-//; s/-[0-9]*-[a-z0-9]*$//'
}

########################################################

# Apply patches

function patchWineSource() {

  if [[ ! -v NO_STAGING ]]; then
    bash "${WINEDIR_STAGING}/patches/patchinstall.sh" DESTDIR="${WINEDIR}" ${staging_patchsets[*]}
  fi

  cp -r ${WINEROOT}/../../../wine_custom_patches/* "${WINEDIR_PATCHES}/"

  if [[ $(find "${WINEDIR_PATCHES}" -mindepth 1 -maxdepth 1 -regex ".*\.\(patch\|diff\)$") ]]; then
    cd "${WINEDIR}"
    for i in "${WINEDIR_PATCHES}"/*.{patch,diff}; do
        patch -Np1 < $i
    done
  fi

}

########################################################

# 64-bit build

function wine64Build() {

  cd "${WINEDIR_BUILD_64}"
  "${WINEDIR}"/configure \
  --with-x \
  --without-mingw \
  --with-gstreamer \
  --enable-win64 \
  --with-xattr \
  --disable-mscoree \
  --with-vulkan \
  --prefix=/usr \
  --libdir=/usr/lib/x86_64-linux-gnu/
  make -j$(nproc --ignore 1)

  make -j$(nproc --ignore 1) prefix="${WINEDIR_INSTALL_64}/usr" \
  libdir="${WINEDIR_INSTALL_64}/usr/lib/x86_64-linux-gnu/" \
  dlldir="${WINEDIR_INSTALL_64}/usr/lib/x86_64-linux-gnu/wine" install

}

# 32-bit build

function wine32Build() {

  cd "${WINEDIR_BUILD_32}"

  # Revert Wine commit 8f732c66ab37b54c30d63c74f7822ba1d4f04996
  # Ref: https://source.winehq.org/git/wine.git/commit/8f732c66ab37b54c30d63c74f7822ba1d4f04996
  # CFLAGS="${CFLAGS} -fPIC" \
  "${WINEDIR}"/configure \
  --with-x \
  --without-mingw \
  --with-gstreamer \
  --with-xattr \
  --disable-mscoree \
  --with-vulkan \
  --libdir=/usr/lib/i386-linux-gnu/ \
  --with-wine64="${WINEDIR_BUILD_64}" \
  --prefix=/usr
  make -j$(nproc --ignore 1)

  make -j$(nproc --ignore 1) prefix="${WINEDIR_INSTALL_32}/usr" \
  libdir="${WINEDIR_INSTALL_32}/usr/lib/i386-linux-gnu/" \
  dlldir="${WINEDIR_INSTALL_32}/usr/lib/i386-linux-gnu/wine" install

}

########################################################

# Merge compiled files, build Debian archive
# Prepare compiled Wine for dpkg-buildpackage

function mergeWineBuilds() {

  cp -r "${WINEDIR_INSTALL_64}"/* "${WINEDIR_PACKAGE}"/

  cp -r "${WINEDIR_INSTALL_32}"/usr/bin/{wine,wine-preloader} "${WINEDIR_PACKAGE}"/usr/bin/
  cp -r "${WINEDIR_INSTALL_32}"/usr/lib/* "${WINEDIR_PACKAGE}"/usr/lib/

}

############################

# Trigger Wine compilation process
# Create a new deb package

function buildDebianArchive() {
  cd "${WINEROOT}"
  mv "${WINEDIR_PACKAGE}" "${WINEROOT}/${pkgname}-$(wine_version)"
  cd "${WINEROOT}/${pkgname}-$(wine_version)"
  dh_make --createorig -s -y -c lgpl
  rm debian/*.{ex,EX}
  printf "usr/* /usr" > debian/install
  printf "12" > debian/compat
  feed_debiancontrol

  # Start compilation process
  DEB_BUILD_OPTIONS="strip nodocs noddebs" dpkg-buildpackage -b -us -uc

}

############################

# Install created deb package

function installDebianArchive() {
  cd "${WINEROOT}"
  # TODO Although the package name ends with 'amd64', this contains both 32 and 64 bit Wine versions
  echo -e "\nInstalling Wine$(if [[ ! -v NO_STAGING ]]; then printf " Staging"; fi).\n"
  sudo dpkg -i ${pkgname}_$(wine_version)-1_amd64.deb
}

############################

# Store deb package for later use

function storeDebianArchive() {
  cd "${WINEROOT}"
  mv ${pkgname}_$(wine_version)-1_amd64.deb ../../compiled_deb/"${datedir}" && \
  echo -e "Compiled ${pkgname} is stored at '$(readlink -f ../../compiled_deb/"${datedir}")/'\n"
  rm -rf winebuild_${datedir}
}

############################

# Clean temporary build files

function cleanTree() {
  rm -rf "${WINEROOT}"
}

########################################################

# Check presence of Wine if compiled deb is going to be installed
# This function is not relevant if --no-install switch is used

function wineCheck() {

  # Known Wine package names to check on Debian
  local known_wines=(
    'wine'
    'wine32'
    'wine64'
    'wine-git'
    'wine-staging-git'
    'libwine:amd64'
    'libwine:i386'
    'fonts-wine'
  )

  # Check if any of these Wine packages are present on the system
  for winepkg in ${known_wines[@]}; do
    if [[ $(echo $(dpkg -s ${winepkg} &>/dev/null)$?) -eq 0 ]]; then
      sudo apt purge --remove -y ${winepkg}
    fi
  done

}

########################################################

# Check existence of gstreamer girl package before further operations
girl_check

############################

# Get Wine (& Wine-Staging) sources
getWine

############################

# Check whether we need to update possible hash override
check_gitOverride

############################

# Refresh & sync Wine (+ Wine Staging) git sources
refreshWineGIT

# Update Wine source files
patchWineSource

########################################################

# Compile 64 & 32 bit Wine/Wine Staging

# WE MUST BUILD 64-BIT FIRST, THEN 32-BIT. THIS ORDER IS MANDATORY!

# We split 64-bit & 32-bit compilation due to two major reasons:
# - pure Debian has major conflicts between 32/64 bit dev packages
# - on Mint/Ubuntu, some 32-bit dev packages must be excluded due to conflicts, too

##########################

# Install Wine common buildtime dependencies
WineDeps install "${wine_deps_build_common[*]}" "Wine common build time" buildtime

##########################

# TODO If we do architecture separation in the future, add if check for amd64 here
# Condition would be: if amd64, then
#
# Purge i386 buildtime dependencies
# On Debian, we can't have them with i386 at the same time
#
echo -e "Preparing system for 64-bit Wine compilation.\n"
WineDeps remove "${wine_deps_build_i386[*]}" "Wine build time (32-bit)" buildtime

WineDeps install "${wine_deps_build_amd64[*]}" "Wine build time (64-bit)" buildtime
wine64Build && \
echo -e "\nWine 64-bit build process finished.\n"

##########################

# TODO If we do architecture separation in the future, add if check for i386 here
# Condition would be: if i386 or amd64, then
#
# Purge amd64 buildtime dependencies
# On Debian, we can't have them with i386 at the same time
#
echo -e "Preparing system for 32-bit Wine compilation.\n"
WineDeps remove "${wine_deps_build_amd64[*]}" "Wine build time (64-bit)" buildtime

WineDeps install "${wine_deps_build_i386[*]}" "Wine build time (32-bit)" buildtime
wine32Build &&
echo -e "\nWine 32-bit build process finished.\n"

############################

# Remove i386 buildtime dependencies after successful compilation process
WineDeps remove "${wine_deps_build_i386[*]}" "Wine build time (32-bit)" buildtime

############################

# i386/amd64 runtime dependencies have been tested and they are able to co-exist on Debian system

if [[ ! -v NO_INSTALL ]]; then

  # Install Wine common runtime dependencies
  WineDeps install "${wine_deps_runtime_common[*]}" "Wine common runtime" runtime

  # Install architecture-dependent Wine runtime dependencies
  WineDeps install "${wine_deps_runtime_amd64[*]}" "Wine runtime (64-bit)" runtime
  WineDeps install "${wine_deps_runtime_i386[*]}" "Wine runtime (32-bit)" runtime

  # Check presence of already installed Wine packages and remove them
  wineCheck

fi

############################

# Build time dependencies which were installed but no longer needed
if [[ -v buildpkglist ]]; then
  if [[ -v BUILDPKG_RM ]]; then
    sudo apt purge --remove -y ${buildpkglist[*]}
  else
    echo -e "The following build time dependencies were installed and no longer required:\n\n$(for l in ${buildpkglist[*]}; do echo -e ${l}; done)\n"
  fi
fi

############################

if [[ -v GIRL_CHECK ]]; then
  sudo apt install -y ${girlpkg}
fi

########################################################

# Bundle compiled Wine/Wine-Staging files
mergeWineBuilds

# Bundle and install Debian deb archive
buildDebianArchive

if [[ ! -v NO_INSTALL ]]; then
  installDebianArchive
fi

storeDebianArchive

# Clean all temporary files
cleanTree