DOS/mkdostools - brltty - Git at Google


            
            #!/bin/bash -p

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

            
            # BRLTTY - A background process providing access to the console screen (when in

            
            #          text mode) for a blind person using a refreshable braille display.

            
            #

            
            # Copyright (C) 1995-2023 by The BRLTTY Developers.

            
            #

            
            # BRLTTY comes with ABSOLUTELY NO WARRANTY.

            
            #

            
            # This is free software, placed under the terms of the

            
            # GNU Lesser General Public License, as published by the Free Software

            
            # Foundation; either version 2.1 of the License, or (at your option) any

            
            # later version. Please see the file LICENSE-LGPL for details.

            
            #

            
            # Web Page: http://brltty.app/

            
            #

            
            # This software is maintained by Dave Mielke <dave@mielke.cc>.

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


            set -e

            
            umask 022

            
            shopt -s nullglob


            readonly autoconfOldVersion=2.13

            
            readonly autoconfNewVersion=2.59

            
            readonly automakeVersion=1.9.6

            
            readonly crxVersion=2.04


            readonly defaultArchivesSubdirectory="Archives"

            
            readonly defaultBuildSubdirectory="Build"

            
            readonly defaultInstallSubdirectory="Tools"

            
            readonly defaultTargetSystem="i586-pc-msdosdjgpp"


            function setVariable {

            
               local variable="${1}"

            
               local value="${2}"


               eval "${variable}"'="${value}"'

            
            }


            function setArrayElement {

            
               local array="${1}"

            
               local index="${2}"

            
               local value="${3}"


               setVariable "${array}[${index}]" "${value}"

            
            }


            function defineEnumeration {

            
               local array="${1}"

            
               shift 1


               declare -g -i -A "${array}"

            
               local value=0


               while [ "${#}" -gt 0 ]

            
               do

            
                  setArrayElement "${array}" "${1}" $((value++))

            
                  shift 1

            
               done


               readonly "${array}"

            
            }


            readonly programName="${0##*/}"

            
            readonly programDirectory="$(realpath "$(dirname "${0}")")"


            function programMessage {

            
               local message="${1}"


               echo >&2 "${programName}: ${message}"

            
            }


            defineEnumeration logLevels error warning task step detail

            
            declare -i logLevel="${logLevels[task]}"


            function logMore {

            
               ((logLevel += 1)) || :

            
            }


            function logLess {

            
               ((logLevel -= 1)) || :

            
            }


            function logMessage {

            
               local level="${1}"

            
               local message="${2}"


               local value="${logLevels[$level]}"


               [ -n "${value}" ] || {

            
                  logWarning "undefined log level: ${level}"

            
                  value=0

            
               }


               [ "${value}" -gt "${logLevel}" ] || programMessage "${message}"

            
            }


            function syntaxError {

            
               local message="${1}"


               logError "${message}"

            
               exit 2

            
            }


            function semanticError {

            
               local message="${1}"


               logError "${message}"

            
               exit 3

            
            }


            function externalError {

            
               local message="${1}"


               logError "${message}"

            
               exit 4

            
            }


            function showUsage {

            
               cat <<-END-OF-USAGE

            
            	usage: ${programName} [-option ...]

            
            	-h            display a usage summary (this text), and then exit

            
            	-q            decrease output verbosity (may be specified more than once)

            
            	-v            increase output verbosity (may be specified more than once)

            
            	-d directory  specify the ROOT directory (default is the current directory)

            
            	-a directory  specify the archives directory (default is ROOT/${defaultArchivesSubdirectory})

            
            	-b directory  specify the build directory (default is ROOT/${defaultBuildSubdirectory})

            
            	-i directory  specify the install directory (default is ROOT/${defaultInstallSubdirectory})

            
            	-t system     specify the target system (default is ${defaultTargetSystem})

            
            	-g version    the gcc version to build (defaults if only one is archived)

            
            	END-OF-USAGE


               exit 0

            
            }


            function handleDirectoryOption {

            
               local variable="${1}"

            
               local default="${2}"

            
               local name="${3}"


               [ -n "${!variable}" ] || setVariable "${variable}" "${default}"

            
               setVariable "${variable}" "$(realpath "${!variable}")"

            
               readonly "${variable}"


               [ -z "${name}" ] || logMessage detail "${name} directory: ${!variable}"

            
            }


            function logArrayElements {

            
               local array="${1}"

            
               local name="${2}"


               message="${name} properties:"


               eval local 'indeces="${!'"${array}"'[*]}"'

            
               local index


               for index in ${indeces}

            
               do

            
                  local variable="${array}[${index}]"

            
                  message+=" ${index}=${!variable}"

            
               done


               logMessage detail "${message}"

            
            }


            function findHostCommand {

            
               local variable="${1}"

            
               shift 1


               local command

            
               for command

            
               do

            
                  local path="$(type -p "${command}")"


                  [ -z "${path}" ] || {

            
                     setVariable "${variable}" "${path}"

            
                     export "${variable}"

            
                     logMessage detail "host command location: ${variable} -> ${!variable}"

            
                     return 0

            
                  }

            
               done


               semanticError "host command not found: ${variable} (${*})"

            
            }


            function pathChange {

            
               local newPath="${1}"


               export PATH="${newPath}"

            
               logMessage detail "host command search path: ${PATH}"

            
            }


            function pathPrepend {

            
               local directory="${1}"


               pathChange "${directory}:${PATH}"

            
            }


            function makeDirectory {

            
               local path="${1}"


               mkdir -p "${path}"

            
            }


            function emptyDirectory {

            
               local path="${1}"


               rm -f -r "${path}/"*

            
            }


            function initializeDirectory {

            
               local path="${1}"


               makeDirectory "${path}"

            
               emptyDirectory "${path}"

            
            }


            function verifyArchive {

            
               local array="${1}"

            
               local type="${2}"

            
               local prefix="${3}"

            
               local suffix="${4}"

            
               local version="${5}"


               declare -g -A "${array}"

            
               setArrayElement "${array}" type "${type}"

            
               setArrayElement "${array}" prefix "${prefix}"

            
               setArrayElement "${array}" suffix "${suffix}"


               local name="${prefix%-}"

            
               setArrayElement "${array}" name "${name}"


               local originalDirectory="${PWD}"

            
               cd "${archivesDirectory}"

            
               if [ -n "${version}" ]

            
               then

            
                  local file="${prefix}${version}${suffix}"

            
                  [ -f "${file}" ] || semanticError "${type} archive not found: ${file}"

            
               else

            
                  local files=("${prefix}"*"${suffix}")

            
                  local count="${#files[*]}"

            
                  ((count > 0)) || semanticError "${type} archive not found: ${name}"

            
                  ((count == 1)) || semanticError "${type} package with multiple archives: ${files[*]}"


                  local file="${files[0]}"

            
                  version="${file%${suffix}}"

            
                  version="${version:${#prefix}}"

            
               fi

            
               cd "${originalDirectory}"


               [[ "${version}" =~ ^[0-9]{3}$ ]] && version="${version:0:1}.${version:1}"

            
               setArrayElement "${array}" version "${version}"


               setArrayElement "${array}" file "${file}"

            
               setArrayElement "${array}" path "${archivesDirectory}/${file}"


               local source="${name}-${version}"

            
               setArrayElement "${array}" source "${source}"


               readonly "${array}"

            
               logArrayElements "${array}" "archive"

            
            }


            function gnuVerifyArchive {

            
               local array="${1}"

            
               local name="${2}"

            
               local version="${3}"


               verifyArchive "${array}" Gnu "${name}-" ".tar.gz" "${version}"

            
            }


            function djgppVerifyArchive {

            
               local array="${1}"

            
               local name="${2}"

            
               local type="${3}"

            
               local version="${4}"


               verifyArchive "${array}" DJGPP "${name}" "${type}.zip" "${version//./}"

            
            }


            function logPackageTask {

            
               local array="${1}"

            
               local task="${2}"


               local nameVariable="${array}[name]"

            
               local versionVariable="${array}[version]"

            
               logMessage task "${task}: ${!nameVariable}-${!versionVariable}"

            
            }


            function unpackArchive {

            
               local array="${1}"


               local typeVariable="${array}[type]"

            
               local pathVariable="${array}[path]"


               logPackageTask "${array}" "unpacking ${!typeVariable} archive"

            
               "unpackArchive_${!typeVariable}" "${!pathVariable}"

            
            }


            function unpackArchive_Gnu {

            
               local path="${1}"


               tar xfz "${path}"

            
            }


            function unpackArchive_DJGPP {

            
               local path="${1}"


               unzip -q -a "${path}"

            
            }


            function changeScriptVariable {

            
               local script="${1}"

            
               local variable="${2}"

            
               local value="${3}"


               sed -e "/^ *${variable} *=/s%=.*%='${value}'%" -i "${script}"

            
            }


            function logBuildDirectory {

            
               logNote "build directory: ${PWD}"

            
            }


            function runBuildCommand {

            
               local logFile="${1}"

            
               shift 1


               logNote "build command: ${*}"

            
               "${@}" >&"${logFile}" || externalError "build error: for details, see ${PWD}/${logFile}"

            
            }


            function configurePackage {

            
               local source="${1}"

            
               shift 1


               runBuildCommand configure.log "${source}/configure" "${@}"

            
            }


            function makePackage {

            
               runBuildCommand make.log make "${@}"

            
            }


            function installPackage {

            
               runBuildCommand install.log make install "${@}"

            
            }


            function buildHostPackage {

            
               local array="${1}"

            
               shift 1


               logPackageTask "${array}" "building host package"


               local sourceVariable="${array}[source]"

            
               local build="${!sourceVariable}-host"

            
               local prefix="$(realpath "${!sourceVariable}-install")"


               makeDirectory "${build}"

            
               cd "${build}"

            
               logBuildDirectory

            
               configurePackage "../${!sourceVariable}" --prefix="${prefix}"

            
               makePackage

            
               installPackage

            
               cd ..


               local bin="${prefix}/bin"

            
               pathPrepend "${bin}"


               while [ "${#}" -gt 0 ]

            
               do

            
                  local command="${1}"

            
                  local variable="${2}"

            
                  shift 2


                  changeScriptVariable "${gccUnpackScript}" "${variable}" "${bin}/${command}"

            
               done

            
            }


            function buildHostArchive {

            
               local array="${1}"

            
               shift 1


               unpackArchive "${array}"

            
               buildHostPackage "${array}" "${@}"

            
            }


            function buildHostAutoconf {

            
               local array="${1}"

            
               local autoconfVariable="${2}"

            
               local autoheaderVariable="${3}"


               buildHostArchive "${array}" autoconf "${autoconfVariable}" autoheader "${autoheaderVariable}"

            
            }


            function configureTargetPackage {

            
               local array="${1}"

            
               shift 1


               local sourceVariable="${array}[source]"

            
               configurePackage "../${!sourceVariable}" \

            
                  "--prefix=${installDirectory}" \

            
                  "--target=${targetSystem}" \

            
                  "${@}"

            
            }


            function buildTargetPackage {

            
               local array="${1}"

            
               shift 1


               logPackageTask "${array}" "building target package"


               cd gnu

            
               local sourceVariable="${array}[source]"

            
               local build="${!sourceVariable}-target"

            
               makeDirectory "${build}"

            
               cd "${build}"

            
               logBuildDirectory

            
               configureTargetPackage "${array}" "${@}"

            
               makePackage

            
               installPackage

            
               cd ../..

            
            }


            rootDirectory=""

            
            archivesDirectory=""

            
            buildDirectory=""

            
            installDirectory=""


            targetSystem=""

            
            gccVersion=""


            while getopts ":hqvd:a:b:i:t:g:" option

            
            do

            
               case "${option}"

            
               in

            
                  h) showUsage;;


                  q) logLess;;

            
                  v) logMore;;


                  d) rootDirectory="${OPTARG}";;

            
                  a) archivesDirectory="${OPTARG}";;

            
                  b) buildDirectory="${OPTARG}";;

            
                  i) installDirectory="${OPTARG}";;


                  t) targetSystem="${OPTARG}";;

            
                  g) gccVersion="${OPTARG}";;


                  :) syntaxError "missing ooperand: -${OPTARG}";;

            
                 \?) syntaxError "unknown option: -${OPTARG}";;

            
                  *) syntaxError "unimplemented option: -${option}";;

            
               esac

            
            done


            shift $((OPTIND - 1))

            
            [ "${#}" -eq 0 ] || syntaxError "too many parameters"


            handleDirectoryOption rootDirectory "${PWD}" "root"

            
            handleDirectoryOption archivesDirectory "${rootDirectory}/${defaultArchivesSubdirectory}" "archives"

            
            handleDirectoryOption buildDirectory "${rootDirectory}/${defaultBuildSubdirectory}" "build"

            
            handleDirectoryOption installDirectory "${rootDirectory}/${defaultInstallSubdirectory}" "install"


            [ -n "${targetSystem}" ] || targetSystem="${defaultTargetSystem}"

            
            readonly targetSystem


            pathChange "$(getconf PATH)"

            
            unset MAKEFLAGS


            logMessage task "finding host commands"

            
            findHostCommand CC cc gcc

            
            findHostCommand CXX c++ g++ cxx gxx

            
            findHostCommand LIBTOOL libtool


            logMessage task "verifying archives"

            
            gnuVerifyArchive gnuAutoconfOld autoconf "${autoconfOldVersion}"

            
            gnuVerifyArchive gnuAutoconfNew autoconf "${autoconfNewVersion}"

            
            gnuVerifyArchive gnuAutomake automake "${automakeVersion}"

            
            gnuVerifyArchive gnuBinutils binutils

            
            gnuVerifyArchive gnuGcc gcc "${gccVersion}"

            
            djgppVerifyArchive djgppGcc gcc s2 "${gnuGcc[version]}"

            
            djgppVerifyArchive djgppCrx djcrx "" "${crxVersion}"


            logMessage task "preparing build directory"

            
            initializeDirectory "${buildDirectory}"

            
            cd "${buildDirectory}"


            unpackArchive djgppCrx

            
            unpackArchive djgppGcc


            gccUnpackScript="unpack-gcc.sh"

            
            buildHostAutoconf gnuAutoconfOld AUTOCONF_OLD AUTOHEADER_OLD

            
            buildHostAutoconf gnuAutoconfNew AUTOCONF AUTOHEADER

            
            buildHostArchive gnuAutomake


            logMessage task "patching gcc source"

            
            logBuildDirectory

            
            chmod u=rwx,go=r "${gccUnpackScript}"

            
            runBuildCommand unpack-gcc.log "./${gccUnpackScript}" "$(realpath --relative-to=. "${gnuGcc["path"]}")"


            cd gnu

            
            unpackArchive gnuBinutils

            
            cd ..


            logMessage task "preparing install directory"

            
            initializeDirectory "${installDirectory}"

            
            pathPrepend "$${installDirectory}/bin"

            
            readonly targetDirectory="${installDirectory}/${targetSystem}"

            
            makeDirectory "${targetDirectory}"

            
            makeDirectory "${targetDirectory}/bin"

            
            cp -r lib "${targetDirectory}"

            
            cp -r include "${targetDirectory}"


            logMessage task "building stubify"

            
            cd src/stub

            
            logBuildDirectory

            
            runBuildCommand compile.log "${CC}" -O2 stubify.c -o "${targetDirectory}/bin/stubify"

            
            cd ../..


            buildTargetPackage gnuBinutils

            
            buildTargetPackage djgppGcc --with-headers="${targetDirectory}/include"


            logMessage task "creating symbolic links"

            
            cd "${targetDirectory}/lib"

            
            ln -s libstdc++.a libstdcxx.a

            
            ln -s libsupc++.a libsupcxx.a


            logMessage task "cleaning up"

            
            cd /

            
            emptyDirectory "${buildDirectory}"


            logMessage task "done"

            
            exit 0
	#!/bin/bash -p
	###############################################################################
	# BRLTTY - A background process providing access to the console screen (when in
	# text mode) for a blind person using a refreshable braille display.
	#
	# Copyright (C) 1995-2023 by The BRLTTY Developers.
	#
	# BRLTTY comes with ABSOLUTELY NO WARRANTY.
	#
	# This is free software, placed under the terms of the
	# GNU Lesser General Public License, as published by the Free Software
	# Foundation; either version 2.1 of the License, or (at your option) any
	# later version. Please see the file LICENSE-LGPL for details.
	#
	# Web Page: http://brltty.app/
	#
	# This software is maintained by Dave Mielke <dave@mielke.cc>.
	###############################################################################

	set -e
	umask 022
	shopt -s nullglob

	readonly autoconfOldVersion=2.13
	readonly autoconfNewVersion=2.59
	readonly automakeVersion=1.9.6
	readonly crxVersion=2.04

	readonly defaultArchivesSubdirectory="Archives"
	readonly defaultBuildSubdirectory="Build"
	readonly defaultInstallSubdirectory="Tools"
	readonly defaultTargetSystem="i586-pc-msdosdjgpp"

	function setVariable {
	local variable="${1}"
	local value="${2}"

	eval "${variable}"'="${value}"'
	}

	function setArrayElement {
	local array="${1}"
	local index="${2}"
	local value="${3}"

	setVariable "${array}[${index}]" "${value}"
	}

	function defineEnumeration {
	local array="${1}"
	shift 1

	declare -g -i -A "${array}"
	local value=0

	while [ "${#}" -gt 0 ]
	do
	setArrayElement "${array}" "${1}" $((value++))
	shift 1
	done

	readonly "${array}"
	}

	readonly programName="${0##*/}"
	readonly programDirectory="$(realpath "$(dirname "${0}")")"

	function programMessage {
	local message="${1}"

	echo >&2 "${programName}: ${message}"
	}

	defineEnumeration logLevels error warning task step detail
	declare -i logLevel="${logLevels[task]}"

	function logMore {
	((logLevel += 1)) \|\| :
	}

	function logLess {
	((logLevel -= 1)) \|\| :
	}

	function logMessage {
	local level="${1}"
	local message="${2}"

	local value="${logLevels[$level]}"

	[ -n "${value}" ] \|\| {
	logWarning "undefined log level: ${level}"
	value=0
	}

	[ "${value}" -gt "${logLevel}" ] \|\| programMessage "${message}"
	}

	function syntaxError {
	local message="${1}"

	logError "${message}"
	exit 2
	}

	function semanticError {
	local message="${1}"

	logError "${message}"
	exit 3
	}

	function externalError {
	local message="${1}"

	logError "${message}"
	exit 4
	}

	function showUsage {
	cat <<-END-OF-USAGE
	usage: ${programName} [-option ...]
	-h display a usage summary (this text), and then exit
	-q decrease output verbosity (may be specified more than once)
	-v increase output verbosity (may be specified more than once)
	-d directory specify the ROOT directory (default is the current directory)
	-a directory specify the archives directory (default is ROOT/${defaultArchivesSubdirectory})
	-b directory specify the build directory (default is ROOT/${defaultBuildSubdirectory})
	-i directory specify the install directory (default is ROOT/${defaultInstallSubdirectory})
	-t system specify the target system (default is ${defaultTargetSystem})
	-g version the gcc version to build (defaults if only one is archived)
	END-OF-USAGE

	exit 0
	}

	function handleDirectoryOption {
	local variable="${1}"
	local default="${2}"
	local name="${3}"

	[ -n "${!variable}" ] \|\| setVariable "${variable}" "${default}"
	setVariable "${variable}" "$(realpath "${!variable}")"
	readonly "${variable}"

	[ -z "${name}" ] \|\| logMessage detail "${name} directory: ${!variable}"
	}

	function logArrayElements {
	local array="${1}"
	local name="${2}"

	message="${name} properties:"

	eval local 'indeces="${!'"${array}"'[*]}"'
	local index

	for index in ${indeces}
	do
	local variable="${array}[${index}]"
	message+=" ${index}=${!variable}"
	done

	logMessage detail "${message}"
	}

	function findHostCommand {
	local variable="${1}"
	shift 1

	local command
	for command
	do
	local path="$(type -p "${command}")"

	[ -z "${path}" ] \|\| {
	setVariable "${variable}" "${path}"
	export "${variable}"
	logMessage detail "host command location: ${variable} -> ${!variable}"
	return 0
	}
	done

	semanticError "host command not found: ${variable} (${*})"
	}

	function pathChange {
	local newPath="${1}"

	export PATH="${newPath}"
	logMessage detail "host command search path: ${PATH}"
	}

	function pathPrepend {
	local directory="${1}"

	pathChange "${directory}:${PATH}"
	}

	function makeDirectory {
	local path="${1}"

	mkdir -p "${path}"
	}

	function emptyDirectory {
	local path="${1}"

	rm -f -r "${path}/"*
	}

	function initializeDirectory {
	local path="${1}"

	makeDirectory "${path}"
	emptyDirectory "${path}"
	}

	function verifyArchive {
	local array="${1}"
	local type="${2}"
	local prefix="${3}"
	local suffix="${4}"
	local version="${5}"

	declare -g -A "${array}"
	setArrayElement "${array}" type "${type}"
	setArrayElement "${array}" prefix "${prefix}"
	setArrayElement "${array}" suffix "${suffix}"

	local name="${prefix%-}"
	setArrayElement "${array}" name "${name}"

	local originalDirectory="${PWD}"
	cd "${archivesDirectory}"
	if [ -n "${version}" ]
	then
	local file="${prefix}${version}${suffix}"
	[ -f "${file}" ] \|\| semanticError "${type} archive not found: ${file}"
	else
	local files=("${prefix}"*"${suffix}")
	local count="${#files[*]}"
	((count > 0)) \|\| semanticError "${type} archive not found: ${name}"
	((count == 1)) \|\| semanticError "${type} package with multiple archives: ${files[*]}"

	local file="${files[0]}"
	version="${file%${suffix}}"
	version="${version:${#prefix}}"
	fi
	cd "${originalDirectory}"

	[[ "${version}" =~ ^[0-9]{3}$ ]] && version="${version:0:1}.${version:1}"
	setArrayElement "${array}" version "${version}"

	setArrayElement "${array}" file "${file}"
	setArrayElement "${array}" path "${archivesDirectory}/${file}"

	local source="${name}-${version}"
	setArrayElement "${array}" source "${source}"

	readonly "${array}"
	logArrayElements "${array}" "archive"
	}

	function gnuVerifyArchive {
	local array="${1}"
	local name="${2}"
	local version="${3}"

	verifyArchive "${array}" Gnu "${name}-" ".tar.gz" "${version}"
	}

	function djgppVerifyArchive {
	local array="${1}"
	local name="${2}"
	local type="${3}"
	local version="${4}"

	verifyArchive "${array}" DJGPP "${name}" "${type}.zip" "${version//./}"
	}

	function logPackageTask {
	local array="${1}"
	local task="${2}"

	local nameVariable="${array}[name]"
	local versionVariable="${array}[version]"
	logMessage task "${task}: ${!nameVariable}-${!versionVariable}"
	}

	function unpackArchive {
	local array="${1}"

	local typeVariable="${array}[type]"
	local pathVariable="${array}[path]"

	logPackageTask "${array}" "unpacking ${!typeVariable} archive"
	"unpackArchive_${!typeVariable}" "${!pathVariable}"
	}

	function unpackArchive_Gnu {
	local path="${1}"

	tar xfz "${path}"
	}

	function unpackArchive_DJGPP {
	local path="${1}"

	unzip -q -a "${path}"
	}

	function changeScriptVariable {
	local script="${1}"
	local variable="${2}"
	local value="${3}"

	sed -e "/^ ${variable} =/s%=.*%='${value}'%" -i "${script}"
	}

	function logBuildDirectory {
	logNote "build directory: ${PWD}"
	}

	function runBuildCommand {
	local logFile="${1}"
	shift 1

	logNote "build command: ${*}"
	"${@}" >&"${logFile}" \|\| externalError "build error: for details, see ${PWD}/${logFile}"
	}

	function configurePackage {
	local source="${1}"
	shift 1

	runBuildCommand configure.log "${source}/configure" "${@}"
	}

	function makePackage {
	runBuildCommand make.log make "${@}"
	}

	function installPackage {
	runBuildCommand install.log make install "${@}"
	}

	function buildHostPackage {
	local array="${1}"
	shift 1

	logPackageTask "${array}" "building host package"

	local sourceVariable="${array}[source]"
	local build="${!sourceVariable}-host"
	local prefix="$(realpath "${!sourceVariable}-install")"

	makeDirectory "${build}"
	cd "${build}"
	logBuildDirectory
	configurePackage "../${!sourceVariable}" --prefix="${prefix}"
	makePackage
	installPackage
	cd ..

	local bin="${prefix}/bin"
	pathPrepend "${bin}"

	while [ "${#}" -gt 0 ]
	do
	local command="${1}"
	local variable="${2}"
	shift 2

	changeScriptVariable "${gccUnpackScript}" "${variable}" "${bin}/${command}"
	done
	}

	function buildHostArchive {
	local array="${1}"
	shift 1

	unpackArchive "${array}"
	buildHostPackage "${array}" "${@}"
	}

	function buildHostAutoconf {
	local array="${1}"
	local autoconfVariable="${2}"
	local autoheaderVariable="${3}"

	buildHostArchive "${array}" autoconf "${autoconfVariable}" autoheader "${autoheaderVariable}"
	}

	function configureTargetPackage {
	local array="${1}"
	shift 1

	local sourceVariable="${array}[source]"
	configurePackage "../${!sourceVariable}" \
	"--prefix=${installDirectory}" \
	"--target=${targetSystem}" \
	"${@}"
	}

	function buildTargetPackage {
	local array="${1}"
	shift 1

	logPackageTask "${array}" "building target package"

	cd gnu
	local sourceVariable="${array}[source]"
	local build="${!sourceVariable}-target"
	makeDirectory "${build}"
	cd "${build}"
	logBuildDirectory
	configureTargetPackage "${array}" "${@}"
	makePackage
	installPackage
	cd ../..
	}

	rootDirectory=""
	archivesDirectory=""
	buildDirectory=""
	installDirectory=""

	targetSystem=""
	gccVersion=""

	while getopts ":hqvd:a:b:i:t:g:" option
	do
	case "${option}"
	in
	h) showUsage;;

	q) logLess;;
	v) logMore;;

	d) rootDirectory="${OPTARG}";;
	a) archivesDirectory="${OPTARG}";;
	b) buildDirectory="${OPTARG}";;
	i) installDirectory="${OPTARG}";;

	t) targetSystem="${OPTARG}";;
	g) gccVersion="${OPTARG}";;

	:) syntaxError "missing ooperand: -${OPTARG}";;
	\?) syntaxError "unknown option: -${OPTARG}";;
	*) syntaxError "unimplemented option: -${option}";;
	esac
	done

	shift $((OPTIND - 1))
	[ "${#}" -eq 0 ] \|\| syntaxError "too many parameters"

	handleDirectoryOption rootDirectory "${PWD}" "root"
	handleDirectoryOption archivesDirectory "${rootDirectory}/${defaultArchivesSubdirectory}" "archives"
	handleDirectoryOption buildDirectory "${rootDirectory}/${defaultBuildSubdirectory}" "build"
	handleDirectoryOption installDirectory "${rootDirectory}/${defaultInstallSubdirectory}" "install"

	[ -n "${targetSystem}" ] \|\| targetSystem="${defaultTargetSystem}"
	readonly targetSystem

	pathChange "$(getconf PATH)"
	unset MAKEFLAGS

	logMessage task "finding host commands"
	findHostCommand CC cc gcc
	findHostCommand CXX c++ g++ cxx gxx
	findHostCommand LIBTOOL libtool

	logMessage task "verifying archives"
	gnuVerifyArchive gnuAutoconfOld autoconf "${autoconfOldVersion}"
	gnuVerifyArchive gnuAutoconfNew autoconf "${autoconfNewVersion}"
	gnuVerifyArchive gnuAutomake automake "${automakeVersion}"
	gnuVerifyArchive gnuBinutils binutils
	gnuVerifyArchive gnuGcc gcc "${gccVersion}"
	djgppVerifyArchive djgppGcc gcc s2 "${gnuGcc[version]}"
	djgppVerifyArchive djgppCrx djcrx "" "${crxVersion}"

	logMessage task "preparing build directory"
	initializeDirectory "${buildDirectory}"
	cd "${buildDirectory}"

	unpackArchive djgppCrx
	unpackArchive djgppGcc

	gccUnpackScript="unpack-gcc.sh"
	buildHostAutoconf gnuAutoconfOld AUTOCONF_OLD AUTOHEADER_OLD
	buildHostAutoconf gnuAutoconfNew AUTOCONF AUTOHEADER
	buildHostArchive gnuAutomake

	logMessage task "patching gcc source"
	logBuildDirectory
	chmod u=rwx,go=r "${gccUnpackScript}"
	runBuildCommand unpack-gcc.log "./${gccUnpackScript}" "$(realpath --relative-to=. "${gnuGcc["path"]}")"

	cd gnu
	unpackArchive gnuBinutils
	cd ..

	logMessage task "preparing install directory"
	initializeDirectory "${installDirectory}"
	pathPrepend "$${installDirectory}/bin"
	readonly targetDirectory="${installDirectory}/${targetSystem}"
	makeDirectory "${targetDirectory}"
	makeDirectory "${targetDirectory}/bin"
	cp -r lib "${targetDirectory}"
	cp -r include "${targetDirectory}"

	logMessage task "building stubify"
	cd src/stub
	logBuildDirectory
	runBuildCommand compile.log "${CC}" -O2 stubify.c -o "${targetDirectory}/bin/stubify"
	cd ../..

	buildTargetPackage gnuBinutils
	buildTargetPackage djgppGcc --with-headers="${targetDirectory}/include"

	logMessage task "creating symbolic links"
	cd "${targetDirectory}/lib"
	ln -s libstdc++.a libstdcxx.a
	ln -s libsupc++.a libsupcxx.a

	logMessage task "cleaning up"
	cd /
	emptyDirectory "${buildDirectory}"

	logMessage task "done"
	exit 0