configure.win

#!/bin/sh
# To manually specify a location for JASP_BUILD_DIR or JASP_SOURCE_DIR do
#
# options(configure.vars = c(jaspSyntax = "JASP_SOURCE_DIR='<path>'"))
# install.packages("jaspSyntax", repos = NULL, type = "source")

set -e

# ---------- GitHub Release configuration ----------
GITHUB_RELEASE_TAG="${JASPSYNTAX_RELEASE_TAG:-v0.98.2}"
GITHUB_RELEASE_REPO="${JASPSYNTAX_RELEASE_REPO:-jasp-stats/jaspSyntax}"
GITHUB_RELEASE_URL="https://github.com/${GITHUB_RELEASE_REPO}/releases/download/${GITHUB_RELEASE_TAG}"
SOURCE_BUNDLE_ASSET="SyntaxInterface-sources.tar.gz"
SOURCE_BUNDLE_PROVENANCE_ORIGIN=""
SOURCE_BUNDLE_JASP_DESKTOP_REF=""
SOURCE_BUNDLE_JASP_DESKTOP_SHA=""
SOURCE_BUNDLE_JASP_SYNTAX_SHA=""
SOURCE_BUNDLE_QT_VERSION=""

sourceBundleProvenanceValue() {
	_sbpv_path="$1"
	_sbpv_key="$2"

	if [ -f "${_sbpv_path}" ]; then
		grep -E "^${_sbpv_key}=" "${_sbpv_path}" | head -n 1 | sed 's/^[^=][^=]*=//'
	fi
}


downloadFile() {
	URL="$1"
	OUTPUT="$2"
	DOWNLOAD_SUCCESS=1

	if command -v curl >/dev/null 2>&1; then
		echo "Downloading ${URL}"
		curl --fail --silent --location --output "${OUTPUT}" "${URL}"
		DOWNLOAD_SUCCESS=$?
	fi

	if [ "${DOWNLOAD_SUCCESS}" -ne "0" ]; then
		if command -v wget >/dev/null 2>&1; then
			echo "Trying wget for ${URL}"
			wget --quiet -O "${OUTPUT}" "${URL}"
			DOWNLOAD_SUCCESS=$?
		fi
	fi

	if [ "${DOWNLOAD_SUCCESS}" -ne "0" ]; then
		echo "Failed to download: ${URL}"
		return 1
	fi
	return 0
}

loadFile() {
	if ! downloadFile "$1/$2" "src/$2"; then
		printf "Installing jaspSyntax failed because the required file %s is missing.\n\
Normally this is downloaded automatically if either curl or wget is available, but apparently this failed.\n\
Either download from \"https://github.com/jasp-stats/jasp-desktop/\" manually and specify the path through configure.vars: options(configure.vars = c(jaspSyntax = \"JASP_SOURCE_DIR='<path>'\"))\n" "$2"
		exit 1
	fi
}

loadReleaseSourceBundle() {
	ARCHIVE_PATH="src/${SOURCE_BUNDLE_ASSET}"
	EXTRACT_DIR="src/.SyntaxInterface-sources"

	if ! downloadFile "${GITHUB_RELEASE_URL}/${SOURCE_BUNDLE_ASSET}" "${ARCHIVE_PATH}"; then
		printf "Installing jaspSyntax failed because the SyntaxInterface source bundle is missing from release %s.\n\
Set JASP_SOURCE_DIR to a matching jasp-desktop checkout, or publish %s together with the SyntaxInterface binaries.\n" "${GITHUB_RELEASE_TAG}" "${SOURCE_BUNDLE_ASSET}"
		exit 1
	fi

	rm -rf "${EXTRACT_DIR}"
	mkdir -p "${EXTRACT_DIR}" "src/json"
	tar -xzf "${ARCHIVE_PATH}" -C "${EXTRACT_DIR}"

	if [ ! -f "${EXTRACT_DIR}/SyntaxInterface/syntaxbridge_interface.h" ]; then
		echo "Installing jaspSyntax failed because ${SOURCE_BUNDLE_ASSET} does not contain SyntaxInterface/syntaxbridge_interface.h"
		exit 1
	fi

	cp "${EXTRACT_DIR}/SyntaxInterface/syntaxbridge_interface.h" "${SYNTAXINTERFACE_HEADER_PATH}"
	for FILE_NAME in ${JSON_FILES}; do
		cp "${EXTRACT_DIR}/Common/json/${FILE_NAME}" "src/json/${FILE_NAME}"
	done

	if [ -f "${EXTRACT_DIR}/BUILD_PROVENANCE" ]; then
		SOURCE_BUNDLE_PROVENANCE_ORIGIN="${GITHUB_RELEASE_URL}/${SOURCE_BUNDLE_ASSET}:BUILD_PROVENANCE"
		SOURCE_BUNDLE_JASP_DESKTOP_REF=$(sourceBundleProvenanceValue "${EXTRACT_DIR}/BUILD_PROVENANCE" "jasp_desktop_ref")
		SOURCE_BUNDLE_JASP_DESKTOP_SHA=$(sourceBundleProvenanceValue "${EXTRACT_DIR}/BUILD_PROVENANCE" "jasp_desktop_sha")
		SOURCE_BUNDLE_JASP_SYNTAX_SHA=$(sourceBundleProvenanceValue "${EXTRACT_DIR}/BUILD_PROVENANCE" "jasp_syntax_sha")
		SOURCE_BUNDLE_QT_VERSION=$(sourceBundleProvenanceValue "${EXTRACT_DIR}/BUILD_PROVENANCE" "qt_version")
	fi

	rm -rf "${EXTRACT_DIR}" "${ARCHIVE_PATH}"
	SYNTAXINTERFACE_HEADER_ORIGIN="${GITHUB_RELEASE_URL}/${SOURCE_BUNDLE_ASSET}:SyntaxInterface/syntaxbridge_interface.h"
}

verifyChecksum() {
	# verifyChecksum <file_path> <asset_name>
	# Verifies the checksum of <file_path> against SHA256SUMS from the GitHub Release.
	_vc_path="$1"
	_vc_asset="$2"

	if command -v sha256sum >/dev/null 2>&1; then
		CHECKSUM_CMD="sha256sum"
	elif command -v shasum >/dev/null 2>&1; then
		CHECKSUM_CMD="shasum -a 256"
	else
		echo "Warning: no sha256 tool found, skipping checksum verification"
		return 0
	fi

	echo "Verifying checksum for ${_vc_asset}..."
	if downloadFile "${GITHUB_RELEASE_URL}/SHA256SUMS" "src/SHA256SUMS"; then
		EXPECTED=$(grep "${_vc_asset}" src/SHA256SUMS | awk '{print $1}')
		ACTUAL=$(${CHECKSUM_CMD} "${_vc_path}" | awk '{print $1}')

		if [ -z "${EXPECTED}" ]; then
			echo "Warning: no checksum found for ${_vc_asset} in SHA256SUMS"
		elif [ "${ACTUAL}" != "${EXPECTED}" ]; then
			echo "Checksum verification FAILED for ${_vc_asset}!"
			echo "  Expected: ${EXPECTED}"
			echo "  Got:      ${ACTUAL}"
			rm -f "${_vc_path}" src/SHA256SUMS
			exit 1
		else
			echo "Checksum verified OK"
		fi
		rm -f src/SHA256SUMS
	else
		echo "Warning: could not download SHA256SUMS, skipping checksum verification"
	fi
}

findRuntimeCandidate() {
	_frc_fname="$1"
	shift
	_frc_srcdir=""
	_frc_candidate=""

	for _frc_srcdir in "$@"; do
		if [ -z "${_frc_srcdir}" ] || [ ! -d "${_frc_srcdir}" ]; then
			continue
		fi

		if [ -f "${_frc_srcdir}/${_frc_fname}" ]; then
			echo "${_frc_srcdir}/${_frc_fname}"
			return 0
		fi

		_frc_candidate=$(find "${_frc_srcdir}" -maxdepth 1 -type f -iname "${_frc_fname}" 2>/dev/null | head -n 1)
		if [ -n "${_frc_candidate}" ]; then
			echo "${_frc_candidate}"
			return 0
		fi
	done

	return 1
}

copyOptionalFile() {
	_cof_fname="$1"
	shift
	_cof_candidate=""
	_cof_dest="src/${_cof_fname}"

	_cof_candidate=$(findRuntimeCandidate "${_cof_fname}" "$@" || true)
	if [ -n "${_cof_candidate}" ]; then
		echo "Copying ${_cof_fname} from ${_cof_candidate%/*}"
		chmod u+w "${_cof_dest}" 2>/dev/null || true
		cp -f "${_cof_candidate}" "${_cof_dest}"
		chmod u+w "${_cof_dest}" 2>/dev/null || true
		return 0
	fi

	return 1
}

addRuntimeSearchDir() {
	_arsd_dir="$1"

	if [ -z "${_arsd_dir}" ] || [ ! -d "${_arsd_dir}" ]; then
		return 0
	fi

	# deduplicate: only add if not already in RUNTIME_DIRS_FILE
	if grep -Fx "${_arsd_dir}" "${RUNTIME_DIRS_FILE}" >/dev/null 2>&1; then
		return 0
	fi

	printf '%s\n' "${_arsd_dir}" >> "${RUNTIME_DIRS_FILE}"
	return 0
}

discoverLocalRtoolsRuntimeDirs() {
	_dlrt_gccpath=""
	_dlrt_gccdir=""
	_dlrt_rtroot=""
	_dlrt_envname=""
	_dlrt_envval=""
	_dlrt_pathdir=""
	_dlrt_oldifs=""

	if command -v g++ >/dev/null 2>&1; then
		_dlrt_gccpath=$(command -v g++)
		_dlrt_gccdir=$(dirname "${_dlrt_gccpath}")
		addRuntimeSearchDir "${_dlrt_gccdir}"

		case "${_dlrt_gccdir}" in
			*/x86_64-w64-mingw32.static.posix/bin)
				_dlrt_rtroot="${_dlrt_gccdir%/x86_64-w64-mingw32.static.posix/bin}"
				addRuntimeSearchDir "${_dlrt_rtroot}/ucrt64/bin"
				;;
			*/ucrt64/bin)
				addRuntimeSearchDir "${_dlrt_gccdir}"
				;;
		esac
	fi

	for _dlrt_envname in RTOOLS45_HOME RTOOLS44_HOME RTOOLS43_HOME RTOOLS42_HOME; do
		_dlrt_envval=$(printenv "${_dlrt_envname}" 2>/dev/null || true)
		addRuntimeSearchDir "${_dlrt_envval}"
		addRuntimeSearchDir "${_dlrt_envval}/bin"
		addRuntimeSearchDir "${_dlrt_envval}/ucrt64/bin"
		case "${_dlrt_envval}" in
			*/ucrt64)
				addRuntimeSearchDir "${_dlrt_envval}/bin"
				;;
		esac
	done

	for _dlrt_rtroot in /c/rtools45 /c/rtools44 /c/rtools43 /c/rtools42; do
		addRuntimeSearchDir "${_dlrt_rtroot}/ucrt64/bin"
	done

	_dlrt_oldifs="${IFS}"
	IFS=':'
	for _dlrt_pathdir in ${PATH}; do
		case "${_dlrt_pathdir}" in
			*rtools*/ucrt64/bin)
				addRuntimeSearchDir "${_dlrt_pathdir}"
				;;
			*rtools*/x86_64-w64-mingw32.static.posix/bin)
				_dlrt_rtroot="${_dlrt_pathdir%/x86_64-w64-mingw32.static.posix/bin}"
				addRuntimeSearchDir "${_dlrt_rtroot}/ucrt64/bin"
				;;
		esac
	done
	IFS="${_dlrt_oldifs}"
}

discoverWindowsSystemRuntimeDirs() {
	_dwsr_sysroot=""
	_dwsr_sysdir=""

	_dwsr_sysroot=$(printenv SystemRoot 2>/dev/null || printenv SYSTEMROOT 2>/dev/null || true)
	if [ -n "${_dwsr_sysroot}" ]; then
		_dwsr_sysdir="${_dwsr_sysroot}/System32"
		if command -v cygpath >/dev/null 2>&1; then
			addRuntimeSearchDir "$(cygpath -u "${_dwsr_sysdir}")"
		fi
		addRuntimeSearchDir "${_dwsr_sysdir}"
	fi

	addRuntimeSearchDir "/c/Windows/System32"
}

addQtRuntimeDirFromCMakeCache() {
	_aqrd_cache="$1"
	_aqrd_prefix=""
	_aqrd_qtcore=""

	if [ ! -f "${_aqrd_cache}" ]; then
		return 0
	fi

	_aqrd_prefix=$(grep -E '^CMAKE_PREFIX_PATH:PATH=' "${_aqrd_cache}" | sed 's/^[^=][^=]*=//' | head -n 1)
	addRuntimeSearchDir "${_aqrd_prefix}/bin"

	_aqrd_qtcore=$(grep -E '^Qt6Core_DIR:PATH=' "${_aqrd_cache}" | sed 's/^[^=][^=]*=//' | head -n 1)
	case "${_aqrd_qtcore}" in
		*/lib/cmake/Qt6Core)
			addRuntimeSearchDir "${_aqrd_qtcore%/lib/cmake/Qt6Core}/bin"
			;;
	esac
}

discoverLocalQtRuntimeDirs() {
	_dlqd_pathdir=""
	_dlqd_qtdir=""
	_dlqd_oldifs=""

	addRuntimeSearchDir "${JASPSYNTAX_QT_DIR}"
	addRuntimeSearchDir "${JASPSYNTAX_QT_DIR}/bin"
	addQtRuntimeDirFromCMakeCache "${JASP_BUILD_DIR}/CMakeCache.txt"

	for _dlqd_qtdir in /c/Qt/*/msvc*/bin /c/Qt/*/mingw*/bin /c/Qt/*/*/bin; do
		addRuntimeSearchDir "${_dlqd_qtdir}"
	done

	_dlqd_oldifs="${IFS}"
	IFS=':'
	for _dlqd_pathdir in ${PATH}; do
		case "${_dlqd_pathdir}" in
			*Qt*/bin)
				addRuntimeSearchDir "${_dlqd_pathdir}"
				;;
		esac
	done
	IFS="${_dlqd_oldifs}"
}

dllNameLower() {
	echo "$1" | tr '[:upper:]' '[:lower:]'
}

findObjdumpTool() {
	_fot_dir=""
	_fot_candidate=""

	if [ -n "${OBJDUMP_TOOL}" ] && [ -x "${OBJDUMP_TOOL}" ]; then
		echo "${OBJDUMP_TOOL}"
		return 0
	fi

	if command -v objdump >/dev/null 2>&1; then
		OBJDUMP_TOOL=$(command -v objdump)
		echo "${OBJDUMP_TOOL}"
		return 0
	fi

	while IFS= read -r _fot_dir; do
		if [ -z "${_fot_dir}" ] || [ ! -d "${_fot_dir}" ]; then
			continue
		fi

		for _fot_candidate in "${_fot_dir}/objdump.exe" "${_fot_dir}/objdump"; do
			if [ -x "${_fot_candidate}" ]; then
				OBJDUMP_TOOL="${_fot_candidate}"
				echo "${OBJDUMP_TOOL}"
				return 0
			fi
		done
	done < "${RUNTIME_DIRS_FILE}"

	return 1
}

importedDllsForFile() {
	_idf_bin="$1"
	_idf_objdump=""

	_idf_objdump=$(findObjdumpTool || true)
	if [ -z "${_idf_objdump}" ]; then
		return 1
	fi

	"${_idf_objdump}" -p "${_idf_bin}" 2>/dev/null |
		sed -n 's/^[[:space:]]*DLL Name:[[:space:]]*//p'
}

syntaxInterfaceImportedDlls() {
	if importedDllsForFile "${SYNTAXINTERFACE_BINARY_PATH}"; then
		return 0
	fi

	if command -v strings >/dev/null 2>&1; then
		strings "${SYNTAXINTERFACE_BINARY_PATH}" 2>/dev/null |
			grep -E '^[A-Za-z0-9_.-]+\.dll$' || true
	else
		return 1
	fi
}

isPlatformRuntimeDll() {
	_iprd_lower=""
	_iprd_lower=$(dllNameLower "$1")

	case "${_iprd_lower}" in
		api-ms-*.dll|ext-ms-*.dll|advapi32.dll|authz.dll|bcrypt.dll|cfgmgr32.dll|clbcatq.dll|combase.dll|comctl32.dll|comdlg32.dll|coremessaging.dll|coreuicomponents.dll|crypt32.dll|cryptbase.dll|cryptsp.dll|d3d*.dll|dcomp.dll|dnsapi.dll|dwmapi.dll|dwrite.dll|dxgi.dll|gdi32.dll|gdi32full.dll|glu32.dll|icu*.dll|imm32.dll|iphlpapi.dll|kernel32.dll|kernelbase.dll|mpr.dll|msasn1.dll|msvcp140*.dll|msvcp_win.dll|msvcrt.dll|ncrypt.dll|ncryptsslp.dll|normaliz.dll|ntasn1.dll|ntdll.dll|ole32.dll|oleacc.dll|oleaut32.dll|opengl32.dll|powrprof.dll|profapi.dll|propsys.dll|psapi.dll|rpcrt4.dll|secur32.dll|setupapi.dll|shell32.dll|shlwapi.dll|sspicli.dll|textinputframework.dll|uiautomationcore.dll|user32.dll|userenv.dll|usp10.dll|ucrtbase.dll|uxtheme.dll|vcruntime140*.dll|version.dll|win32u.dll|windows.storage.dll|winhttp.dll|wininet.dll|winmm.dll|wldp.dll|ws2_32.dll|wtsapi32.dll|xmllite.dll|r.dll|rgraphapp.dll|rblas.dll|rlapack.dll)
			return 0
			;;
	esac

	return 1
}

wasRuntimeBinaryProcessed() {
	grep -Fx "$1" "${PROCESSED_FILE}" >/dev/null 2>&1
}

markRuntimeBinaryProcessed() {
	printf '%s\n' "$1" >> "${PROCESSED_FILE}"
}

addMissingTransitiveRuntimeDll() {
	_amtd_dll="$1"
	_amtd_importer="$2"
	_amtd_entry="${_amtd_dll} imported by ${_amtd_importer}"

	# deduplicate
	if grep -Fx "${_amtd_entry}" "${MISSING_DLLS_FILE}" >/dev/null 2>&1; then
		return 0
	fi

	printf '%s\n' "${_amtd_entry}" >> "${MISSING_DLLS_FILE}"
}

collectBundledRuntimeBinaries() {
	_cbrb_candidate=""

	for _cbrb_candidate in src/*.dll src/platforms/*.dll; do
		if [ -f "${_cbrb_candidate}" ]; then
			echo "${_cbrb_candidate}"
		fi
	done
}

bundleTransitiveRuntimeDlls() {
	_btd_queue="/tmp/jaspsyntax-queue.$$"
	_btd_index=0
	_btd_bin=""
	_btd_dll=""
	_btd_candidate=""
	_btd_entry=""
	_btd_dir=""
	_btd_objdump=""
	_btd_tmp="/tmp/jaspsyntax-imports.$$"
	_btd_missing_count=0

	: > "${_btd_queue}"

	_btd_objdump=$(findObjdumpTool || true)
	if [ -z "${_btd_objdump}" ]; then
		printf "Warning: objdump is not available; jaspSyntax cannot inspect transitive Windows DLL dependencies automatically.\n\
If package loading later fails with a DLL load error, reinstall with JASPSYNTAX_RUNTIME_DIR pointing to Rtools/ucrt64/bin and, for dynamic Qt builds, JASPSYNTAX_QT_DIR pointing to the Qt bin directory.\n"
		return 0
	fi

	for _btd_bin in "$@"; do
		if [ -f "${_btd_bin}" ]; then
			printf '%s\n' "${_btd_bin}" >> "${_btd_queue}"
		fi
	done

	while true; do
		_btd_index=$((_btd_index + 1))
		_btd_bin=$(sed -n "${_btd_index}p" "${_btd_queue}" 2>/dev/null)
		[ -z "${_btd_bin}" ] && break

		if wasRuntimeBinaryProcessed "${_btd_bin}"; then
			continue
		fi
		markRuntimeBinaryProcessed "${_btd_bin}"

		importedDllsForFile "${_btd_bin}" | sort -u > "${_btd_tmp}"
		while IFS= read -r _btd_dll; do
			if [ -z "${_btd_dll}" ] || isPlatformRuntimeDll "${_btd_dll}"; then
				continue
			fi

			_btd_candidate=""
			# collect runtime dirs from file, pass as args to copyOptionalFile
			set --
			while IFS= read -r _btd_dir; do
				[ -n "${_btd_dir}" ] && set -- "$@" "${_btd_dir}"
			done < "${RUNTIME_DIRS_FILE}"
			if copyOptionalFile "${_btd_dll}" "$@"; then
				_btd_candidate="src/${_btd_dll}"
			elif [ -f "src/${_btd_dll}" ]; then
				_btd_candidate="src/${_btd_dll}"
			elif [ -f "src/platforms/${_btd_dll}" ]; then
				_btd_candidate="src/platforms/${_btd_dll}"
			else
				addMissingTransitiveRuntimeDll "${_btd_dll}" "${_btd_bin}"
				continue
			fi

			printf '%s\n' "${_btd_candidate}" >> "${_btd_queue}"
		done < "${_btd_tmp}"
		rm -f "${_btd_tmp}"
	done

	rm -f "${_btd_queue}" "${_btd_tmp}"

	_btd_missing_count=$(wc -l < "${MISSING_DLLS_FILE}" 2>/dev/null | tr -d '[:space:]')
	if [ -n "${_btd_missing_count}" ] && [ "${_btd_missing_count}" -gt 0 ]; then
		printf "Installing jaspSyntax failed because transitive Windows runtime DLL dependencies could not be bundled automatically.\n\
Set JASPSYNTAX_RUNTIME_DIR to the Rtools/ucrt64/bin directory and, for dynamic Qt builds, set JASPSYNTAX_QT_DIR to the Qt bin directory. If you are using a local Desktop build, prefer JASPSYNTAX_LIB_DIR or JASP_BUILD_DIR from the same build tree.\n"
		echo "Missing DLL dependencies:"
		while IFS= read -r _btd_entry; do
			echo "  ${_btd_entry}"
		done < "${MISSING_DLLS_FILE}"
		echo "Searched runtime directories:"
		while IFS= read -r _btd_dir; do
			if [ -n "${_btd_dir}" ]; then
				echo "  ${_btd_dir}"
			fi
		done < "${RUNTIME_DIRS_FILE}"
		exit 1
	fi
}

requireRuntimeFile() {
	_rrf_fname="$1"
	shift
	_rrf_dir=""

	if [ -f "src/${_rrf_fname}" ]; then
		return 0
	fi

	if copyOptionalFile "${_rrf_fname}" "$@"; then
		return 0
	fi

	printf "Installing jaspSyntax failed because the required runtime DLL %s could not be located.\n\
The selected SyntaxInterface binary requires matching runtime DLLs. For Rtools \
DLLs set JASPSYNTAX_RUNTIME_DIR; for dynamic Qt builds set JASPSYNTAX_QT_DIR, \
for example:\n\
options(configure.vars = c(jaspSyntax = \"JASPSYNTAX_RUNTIME_DIR='<path-to-rtools>/ucrt64/bin' JASPSYNTAX_QT_DIR='<path-to-qt>/bin'\"))\n" "${_rrf_fname}"

	if [ "$#" -gt 0 ]; then
		echo "Searched runtime directories:"
		for _rrf_dir in "$@"; do
			if [ -n "${_rrf_dir}" ]; then
				echo "  ${_rrf_dir}"
			fi
		done
	fi

	exit 1
}

findQtPlatformPlugin() {
	_fqpp_name="$1"
	_fqpp_dir=""
	_fqpp_candidate=""

	while IFS= read -r _fqpp_dir; do
		if [ -z "${_fqpp_dir}" ]; then
			continue
		fi

		_fqpp_candidate="${_fqpp_dir}/../plugins/platforms/${_fqpp_name}"
		if [ -f "${_fqpp_candidate}" ]; then
			echo "${_fqpp_candidate}"
			return 0
		fi

		_fqpp_candidate="${_fqpp_dir}/plugins/platforms/${_fqpp_name}"
		if [ -f "${_fqpp_candidate}" ]; then
			echo "${_fqpp_candidate}"
			return 0
		fi
	done < "${RUNTIME_DIRS_FILE}"

	return 1
}

requireQtPlatformPlugin() {
	_rqpp_name="$1"
	_rqpp_path=""

	mkdir -p "src/platforms"
	if [ -f "src/platforms/${_rqpp_name}" ]; then
		return 0
	fi

	_rqpp_path=$(findQtPlatformPlugin "${_rqpp_name}" || true)
	if [ -n "${_rqpp_path}" ]; then
		echo "Copying Qt platform plugin ${_rqpp_name} from ${_rqpp_path%/*}"
		cp "${_rqpp_path}" "src/platforms/${_rqpp_name}"
		return 0
	fi

	printf "Installing jaspSyntax failed because the Qt platform plugin %s could not be located.\n\
For dynamic Qt builds set JASPSYNTAX_QT_DIR to the Qt bin directory or its parent, for example:\n\
options(configure.vars = c(jaspSyntax = \"JASPSYNTAX_QT_DIR='<path-to-qt>/bin'\"))\n" "${_rqpp_name}"

	exit 1
}

if [ "${R_HOME}" ]; then
	echo "Found R_HOME: ${R_HOME}"
else
	echo "No R_HOME found!"
fi

PKG_CXXFLAGS=""
JASP_SOURCE_DIR="${JASP_SOURCE_DIR:-}"
JASP_BUILD_DIR="${JASP_BUILD_DIR:-}"
# JASPSYNTAX_LIB_DIR: directory containing pre-built SyntaxInterface.dll (and optionally libR-InterfaceNoRInside.dll)
JASPSYNTAX_LIB_DIR="${JASPSYNTAX_LIB_DIR:-}"
JASPSYNTAX_RUNTIME_DIR="${JASPSYNTAX_RUNTIME_DIR:-}"
JASPSYNTAX_QT_DIR="${JASPSYNTAX_QT_DIR:-}"

if [ -z "${JASP_SOURCE_DIR}" ] && [ -n "${JASP_BUILD_DIR}" ]; then
	JASP_BUILD_PARENT="$(cd "${JASP_BUILD_DIR}/.." 2>/dev/null && pwd)"
	if [ -f "${JASP_BUILD_PARENT}/SyntaxInterface/syntaxbridge_interface.h" ]; then
		JASP_SOURCE_DIR="${JASP_BUILD_PARENT}"
	fi
fi

RUNTIME_DIRS_FILE="/tmp/jaspsyntax-rtdirs.$$"
PROCESSED_FILE="/tmp/jaspsyntax-processed.$$"
MISSING_DLLS_FILE="/tmp/jaspsyntax-missingdlls.$$"
: > "${RUNTIME_DIRS_FILE}"
: > "${PROCESSED_FILE}"
: > "${MISSING_DLLS_FILE}"
OBJDUMP_TOOL=""
SYNTAXINTERFACE_HEADER_PATH="src/syntaxbridge_interface.h"
SYNTAXINTERFACE_HEADER_ORIGIN=""
SYNTAXINTERFACE_BINARY_PATH="src/SyntaxInterface.dll"
SYNTAXINTERFACE_BINARY_ORIGIN=""

fileSha256() {
	_fs_path="$1"

	if [ ! -f "${_fs_path}" ]; then
		echo "unavailable"
	elif command -v sha256sum >/dev/null 2>&1; then
		sha256sum "${_fs_path}" | awk '{print $1}'
	elif command -v shasum >/dev/null 2>&1; then
		shasum -a 256 "${_fs_path}" | awk '{print $1}'
	else
		echo "unavailable"
	fi
}

writeSyntaxInterfaceProvenance() {
	if [ -z "${SYNTAXINTERFACE_HEADER_ORIGIN}" ]; then
		SYNTAXINTERFACE_HEADER_ORIGIN="local:${SYNTAXINTERFACE_HEADER_PATH}"
	fi
	if [ -z "${SYNTAXINTERFACE_BINARY_ORIGIN}" ]; then
		SYNTAXINTERFACE_BINARY_ORIGIN="local:${SYNTAXINTERFACE_BINARY_PATH}"
	fi

	cat > "src/SyntaxInterface.provenance" <<EOF
schema=1
recorded_at=$(date -u '+%Y-%m-%dT%H:%M:%SZ' 2>/dev/null || date)
platform=Windows
architecture=x86_64
release_tag=${GITHUB_RELEASE_TAG}
release_repo=${GITHUB_RELEASE_REPO}
header_path=${SYNTAXINTERFACE_HEADER_PATH}
header_origin=${SYNTAXINTERFACE_HEADER_ORIGIN}
binary_path=${SYNTAXINTERFACE_BINARY_PATH}
binary_origin=${SYNTAXINTERFACE_BINARY_ORIGIN}
header_sha256=$(fileSha256 "${SYNTAXINTERFACE_HEADER_PATH}")
binary_sha256=$(fileSha256 "${SYNTAXINTERFACE_BINARY_PATH}")
source_bundle_provenance_origin=${SOURCE_BUNDLE_PROVENANCE_ORIGIN}
source_bundle_jasp_desktop_ref=${SOURCE_BUNDLE_JASP_DESKTOP_REF}
source_bundle_jasp_desktop_sha=${SOURCE_BUNDLE_JASP_DESKTOP_SHA}
source_bundle_jasp_syntax_sha=${SOURCE_BUNDLE_JASP_SYNTAX_SHA}
source_bundle_qt_version=${SOURCE_BUNDLE_QT_VERSION}
jasp_source_dir=${JASP_SOURCE_DIR}
jasp_build_dir=${JASP_BUILD_DIR}
jaspsyntax_lib_dir=${JASPSYNTAX_LIB_DIR}
jaspsyntax_runtime_dir=${JASPSYNTAX_RUNTIME_DIR}
jaspsyntax_qt_dir=${JASPSYNTAX_QT_DIR}
check_exports=${JASPSYNTAX_CHECK_EXPORTS:-auto}
EOF
}

# ---------- Download header files if needed ----------

JSON_FILES="allocator.h assertions.h config.h forwards.h json.h json_features.h json_reader.cpp json_tool.h json_value.cpp json_valueiterator.inl json_writer.cpp reader.h value.h version.h writer.h"

if [ -n "${JASP_SOURCE_DIR}" ]; then
	echo "JASP_SOURCE_DIR: ${JASP_SOURCE_DIR}"
	PKG_CXXFLAGS="-I\"${JASP_SOURCE_DIR}/SyntaxInterface\" -I\"${JASP_SOURCE_DIR}/Common\""
	mkdir -p 'src/json'
	SYNTAXINTERFACE_HEADER_ORIGIN="${JASP_SOURCE_DIR}/SyntaxInterface/syntaxbridge_interface.h"
	cp "${SYNTAXINTERFACE_HEADER_ORIGIN}" "${SYNTAXINTERFACE_HEADER_PATH}"

	for i in ${JSON_FILES}; do
		cp "${JASP_SOURCE_DIR}/Common/json/${i}" "src/json/${i}"
	done
elif [ -n "${GITHUB_JASP_DESKTOP_FILES}" ]; then
	loadFile "${GITHUB_JASP_DESKTOP_FILES}/SyntaxInterface" "syntaxbridge_interface.h"
	SYNTAXINTERFACE_HEADER_ORIGIN="${GITHUB_JASP_DESKTOP_FILES}/SyntaxInterface/syntaxbridge_interface.h"

	mkdir -p 'src/json'

	for i in ${JSON_FILES}; do
		loadFile "${GITHUB_JASP_DESKTOP_FILES}/Common" "json/${i}"
	done
else
	loadReleaseSourceBundle
fi

# ---------- Download SyntaxInterface.dll ----------

SYNTAXINTERFACE_DLL="SyntaxInterface.dll"
SYNTAXINTERFACE_ASSET="SyntaxInterface-windows-x86_64.dll"

if [ -n "${JASPSYNTAX_LIB_DIR}" ]; then
	echo "Using JASPSYNTAX_LIB_DIR: ${JASPSYNTAX_LIB_DIR}"
	SYNTAXINTERFACE_BINARY_ORIGIN="${JASPSYNTAX_LIB_DIR}/${SYNTAXINTERFACE_DLL}"
	cp "${SYNTAXINTERFACE_BINARY_ORIGIN}" "src/${SYNTAXINTERFACE_DLL}"
elif [ -n "${JASP_BUILD_DIR}" ]; then
	echo "JASP_BUILD_DIR: ${JASP_BUILD_DIR}"
	for CANDIDATE in \
		"${JASP_BUILD_DIR}/${SYNTAXINTERFACE_DLL}" \
		"${JASP_BUILD_DIR}/SyntaxInterface/${SYNTAXINTERFACE_DLL}" \
		"${JASP_BUILD_DIR}/bin/${SYNTAXINTERFACE_DLL}"
	do
		if [ -f "${CANDIDATE}" ]; then
			SYNTAXINTERFACE_BINARY_ORIGIN="${CANDIDATE}"
			break
		fi
	done
	if [ -z "${SYNTAXINTERFACE_BINARY_ORIGIN}" ]; then
		echo "ERROR: Could not locate ${SYNTAXINTERFACE_DLL} under JASP_BUILD_DIR=${JASP_BUILD_DIR}"
		echo "  Tried: ${JASP_BUILD_DIR}/${SYNTAXINTERFACE_DLL}"
		echo "         ${JASP_BUILD_DIR}/SyntaxInterface/${SYNTAXINTERFACE_DLL}"
		echo "         ${JASP_BUILD_DIR}/bin/${SYNTAXINTERFACE_DLL}"
		exit 1
	fi
	cp "${SYNTAXINTERFACE_BINARY_ORIGIN}" "src/${SYNTAXINTERFACE_DLL}"
else
	echo "Downloading pre-built ${SYNTAXINTERFACE_ASSET} from GitHub Release (${GITHUB_RELEASE_TAG})..."
	if ! downloadFile "${GITHUB_RELEASE_URL}/${SYNTAXINTERFACE_ASSET}" "src/${SYNTAXINTERFACE_DLL}"; then
		echo "ERROR: Could not download ${SYNTAXINTERFACE_ASSET}"
		echo "  URL: ${GITHUB_RELEASE_URL}/${SYNTAXINTERFACE_ASSET}"
		exit 1
	fi
	verifyChecksum "src/${SYNTAXINTERFACE_DLL}" "${SYNTAXINTERFACE_ASSET}"
	SYNTAXINTERFACE_BINARY_ORIGIN="${GITHUB_RELEASE_URL}/${SYNTAXINTERFACE_ASSET}"
fi

# ---------- Download libR-InterfaceNoRInside.dll ----------

RINTERFACE_DLL="libR-InterfaceNoRInside.dll"
RINTERFACE_ASSET="libR-InterfaceNoRInside-windows-x86_64.dll"

if [ -n "${JASPSYNTAX_LIB_DIR}" ] && [ -f "${JASPSYNTAX_LIB_DIR}/${RINTERFACE_DLL}" ]; then
	cp "${JASPSYNTAX_LIB_DIR}/${RINTERFACE_DLL}" src/
elif [ -n "${JASP_BUILD_DIR}" ]; then
	RINTERFACE_ORIGIN=""
	for CANDIDATE in \
		"${JASP_BUILD_DIR}/R-Interface/${RINTERFACE_DLL}" \
		"${JASP_BUILD_DIR}/${RINTERFACE_DLL}" \
		"${JASP_BUILD_DIR}/bin/${RINTERFACE_DLL}"
	do
		if [ -f "${CANDIDATE}" ]; then
			RINTERFACE_ORIGIN="${CANDIDATE}"
			break
		fi
	done
	if [ -z "${RINTERFACE_ORIGIN}" ]; then
		echo "ERROR: Could not locate ${RINTERFACE_DLL} under JASP_BUILD_DIR=${JASP_BUILD_DIR}"
		echo "  Tried: ${JASP_BUILD_DIR}/R-Interface/${RINTERFACE_DLL}"
		echo "         ${JASP_BUILD_DIR}/${RINTERFACE_DLL}"
		echo "         ${JASP_BUILD_DIR}/bin/${RINTERFACE_DLL}"
		exit 1
	fi
	cp "${RINTERFACE_ORIGIN}" src/
else
	echo "Downloading pre-built ${RINTERFACE_ASSET} from GitHub Release (${GITHUB_RELEASE_TAG})..."
	if ! downloadFile "${GITHUB_RELEASE_URL}/${RINTERFACE_ASSET}" "src/${RINTERFACE_DLL}"; then
		echo "ERROR: Could not download ${RINTERFACE_ASSET}"
		echo "  URL: ${GITHUB_RELEASE_URL}/${RINTERFACE_ASSET}"
		exit 1
	fi
	verifyChecksum "src/${RINTERFACE_DLL}" "${RINTERFACE_ASSET}"
fi

RUNTIME_DLLS="libgcc_s_seh-1.dll libstdc++-6.dll libwinpthread-1.dll"

addRuntimeSearchDir "${JASPSYNTAX_RUNTIME_DIR}"
addRuntimeSearchDir "${JASPSYNTAX_LIB_DIR}"
addRuntimeSearchDir "${JASP_BUILD_DIR}/R-Interface"
addRuntimeSearchDir "${JASP_BUILD_DIR}"
discoverLocalRtoolsRuntimeDirs
discoverWindowsSystemRuntimeDirs

for RUNTIME_DLL in ${RUNTIME_DLLS}; do
	# Collect runtime dirs as positional arguments
	set --
	while IFS= read -r _rrf_d; do
		[ -n "${_rrf_d}" ] && set -- "$@" "${_rrf_d}"
	done < "${RUNTIME_DIRS_FILE}"
	requireRuntimeFile "${RUNTIME_DLL}" "$@"
done

discoverLocalQtRuntimeDirs
QT_RUNTIME_DLLS=$(syntaxInterfaceImportedDlls | grep -E '^Qt6.*\.dll$' | sort -u || true)
for QT_RUNTIME_DLL in ${QT_RUNTIME_DLLS}; do
	# Collect runtime dirs as positional arguments
	set --
	while IFS= read -r _rrf_d; do
		[ -n "${_rrf_d}" ] && set -- "$@" "${_rrf_d}"
	done < "${RUNTIME_DIRS_FILE}"
	requireRuntimeFile "${QT_RUNTIME_DLL}" "$@"
done
if [ -n "${QT_RUNTIME_DLLS}" ]; then
	requireQtPlatformPlugin "qminimal.dll"
fi

bundleTransitiveRuntimeDlls $(collectBundledRuntimeBinaries)
if ls src/Qt6*.dll >/dev/null 2>&1; then
	requireQtPlatformPlugin "qminimal.dll"
	bundleTransitiveRuntimeDlls $(collectBundledRuntimeBinaries)
fi

writeSyntaxInterfaceProvenance

SYNTAXINTERFACE_HEADER_ORIGIN="${SYNTAXINTERFACE_HEADER_ORIGIN}" \
SYNTAXINTERFACE_BINARY_ORIGIN="${SYNTAXINTERFACE_BINARY_ORIGIN}" \
	"${BASH:-bash}" tools/check-syntaxinterface-symbols.sh "${SYNTAXINTERFACE_HEADER_PATH}" "${SYNTAXINTERFACE_BINARY_PATH}" "src/syntaxfunctions.cpp"

PKG_CXXFLAGS=${PKG_CXXFLAGS}\ -DUNICODE\ -DWIN32\ -DWIN32_LEAN_AND_MEAN\ -DWIN64\ -D_ENABLE_EXTENDED_ALIGNED_STORAGE

PKG_LIBS="-l:${SYNTAXINTERFACE_DLL} -l:${RINTERFACE_DLL}"

sed -e "s|@cppflags@|${PKG_CXXFLAGS}|" -e "s|@libflags@|${PKG_LIBS}|" -e "s|@rpathflags@||" src/Makevars.in > src/Makevars

exit 0