This is the mail archive of the crossgcc@sourceware.org mailing list for the crossgcc project.

See crosstool-NG for lots more information.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] Added support for AC_ARG_WITH([grep]...) and sed substitution fixes


-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA512

- From 3847ffad3f1c7757d34b7a24279f5bb3b64b4c87 Mon Sep 17 00:00:00 2001

Hi,

On 26/09/12 18:56, Yann E. MORIN wrote:
> On Wednesday 26 September 2012 17:30:12 Blair Burtan wrote:
>> That was the problem but not quite the complete solution.  I had to modify
>> the grep path to point to the MacPorts verison when I built ct-ng.  I also
>> had to use ginstall instead of the OSX install.
> 
> ./configure --help
> [--SNIP--]
> Optional Packages:
>   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
>   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
>   --with-install=PATH     Specify the full PATH to a BSD-compatible install
>   --with-sed=PATH         Specify the full PATH to GNU sed
>   --with-objcopy=PATH     Specify the full PATH to GNU objcopy
>   --with-objdump=PATH     Specify the full PATH to GNU objdump
>   --with-ranlib=PATH      Specify the full PATH to GNU ranlib
>   --with-readelf=PATH     Specify the full PATH to GNU readelf
>   --with-bash=PATH        Specify the full PATH to GNU bash >= 3.1
>   --with-awk=PATH         Specify the full PATH to GNU awk
>   --with-make=PATH        Specify the full PATH to GNU make >= 3.80
>   --with-libtool=PATH     Specify the full PATH to GNU libtool >= 1.5.26
>   --with-libtoolize=PATH  Specify the full PATH to GNU libtoolize >= 1.5.26
>   --with-automake=PATH    Specify the full PATH to GNU automake >= 1.10
> [--SNIP--]
> 
> That's how you tell crosstool-NG what tools to use if the default ones are
> not the GNU ones.

While it is possible to tell crosstool-NG to use custom GNU tools for several
tools, it is not possible for all tools, especially for grep and sed. This 
causes ct-ng build to fail:

  [ERROR]  >>
  [ERROR]  >>  Build failed in step '(top-level)'
  [ERROR]  >>
  [ERROR]  >>  Error happened in: CT_DoForceRmdir[scripts/functions@458]
  [ERROR]  >>        called from: main[scripts/crosstool-NG.sh@238]
  [ERROR]  >>

One of the problems here is also that on BSD installs, including OS X, GNU
tools are often installed with a prefixed 'g', in this case "ggrep" and "gsed".
There is no way to tell crosstool-NG to use ggrep instead of grep, and
adjusting $PATH does not help either.

I have created a small (not counting the changes due to the scripts/functions
rename) patch that adds --with-grep and substitues @@CT_sed@@ for sed in a few
places where sed from PATH is used and GNU-specific options are used. I can 
confirm this works for me on Darwin using GNU tools installed via homebrew using
the following ./configure options:

./configure --prefix=$(pwd) --exec-prefix=$(pwd) \
	--with-objcopy=gobjcopy \
	--with-objdump=gobjdump \
	--with-readelf=greadelf \
	--with-libtool=glibtool \
	--with-libtoolize=glibtoolize \
	--with-install=ginstall \
	--with-sed=gsed \
	--with-awk=gawk \
	--with-grep=ggrep

I have not yet tested that this patch works flawlessly on Linux using default
./configure options. I'd like to submit the following patch for testing.

Regards,
Fabian Freyer

- ---
 Makefile.in                |    5 +-
 configure.ac               |    6 +
 scripts/crosstool-NG.sh.in |    6 +-
 scripts/functions          | 1395 --------------------------------------------
 scripts/functions.in       | 1395 ++++++++++++++++++++++++++++++++++++++++++++
 scripts/xldd.in            |    2 +-
 6 files changed, 1409 insertions(+), 1400 deletions(-)
 delete mode 100644 scripts/functions
 create mode 100644 scripts/functions.in

diff --git a/Makefile.in b/Makefile.in
index 01759b6..cd68baa 100644
- --- a/Makefile.in
+++ b/Makefile.in
@@ -59,7 +59,7 @@ export datarootdir     := @datarootdir@
 export install         := @INSTALL@
 export bash            := @_BASH@
 export awk             := @_AWK@
- -export grep            := @GREP@
+export grep            := @_GREP@
 export make            := @MAKE@
 export sed             := @SED@
 export libtool         := @LIBTOOL@
@@ -142,6 +142,7 @@ uninstall: real-uninstall
 # Build rules
 
 build-bin: $(PROG_NAME)             \
+           scripts/functions        \
            scripts/crosstool-NG.sh  \
            scripts/saveSample.sh    \
            scripts/showTuple.sh
@@ -174,6 +175,8 @@ define sed_it
 	           -e 's,@@CT_make@@,$(make),g;'            \
 	           -e 's,@@CT_bash@@,$(bash),g;'            \
 	           -e 's,@@CT_awk@@,$(awk),g;'              \
+	           -e 's,@@CT_grep@@,$(grep),g;'            \
+	           -e 's,@@CT_sed@@,$(sed),g;'              \
 	           $< >$@
 endef
 
diff --git a/configure.ac b/configure.ac
index f8c67be..27238ab 100644
- --- a/configure.ac
+++ b/configure.ac
@@ -94,6 +94,12 @@ AC_ARG_WITH([install],
                    [Specify the full PATH to a BSD-compatible install]),
     [INSTALL=$withval])
 AC_PROG_INSTALL
+AC_CACHE_VAL([ac_cv_path_GREP],
+    [AC_ARG_WITH([grep],
+        AS_HELP_STRING([--with-grep=PATH],
+                       [Specify the full PATH to GNU grep]),
+        [ac_cv_path_GREP=$withval])])
+AC_SUBST([_GREP], [$ac_cv_path_GREP])
 AC_PROG_GREP
 AC_PROG_EGREP
 AS_IF(
diff --git a/scripts/crosstool-NG.sh.in b/scripts/crosstool-NG.sh.in
index 3699500..4b9011d 100644
- --- a/scripts/crosstool-NG.sh.in
+++ b/scripts/crosstool-NG.sh.in
@@ -125,7 +125,7 @@ CT_DoLog INFO "Build started ${CT_STAR_DATE_HUMAN}"
 # We really need to extract from ,config and not .config.2, as we
 # do want the kconfig's values, not our mangled config with arrays.
 CT_DoStep DEBUG "Dumping user-supplied crosstool-NG configuration"
- -CT_DoExecLog DEBUG grep -E '^(# |)CT_' .config
+CT_DoExecLog DEBUG @@CT_grep@@ -E '^(# |)CT_' .config
 CT_EndStep
 
 CT_DoLog DEBUG "Unsetting and unexporting MAKEFLAGS"
@@ -570,9 +570,9 @@ if [ -z "${CT_RESTART}" ]; then
     CT_DoLog EXTRA "  build  = ${CT_REAL_BUILD}"
     CT_DoLog EXTRA "  host   = ${CT_REAL_HOST}"
     CT_DoLog EXTRA "  target = ${CT_TARGET}"
- -    set |grep -E '^CT_.+=' |sort |CT_DoLog DEBUG
+    set |@@CT_grep@@ -E '^CT_.+=' |sort |CT_DoLog DEBUG
     CT_DoLog DEBUG "Other environment:"
- -    printenv |grep -v -E '^CT_.+=' |CT_DoLog DEBUG
+    printenv |@@CT_grep@@ -v -E '^CT_.+=' |CT_DoLog DEBUG
     CT_EndStep
 fi
 
diff --git a/scripts/functions b/scripts/functions
deleted file mode 100644
index 2e4d4fa..0000000
- --- a/scripts/functions
+++ /dev/null
@@ -1,1395 +0,0 @@
- -# This file contains some usefull common functions -*- sh -*-
- -# Copyright 2007 Yann E. MORIN
- -# Licensed under the GPL v2. See COPYING in the root of this package
- -
- -# Prepare the fault handler
- -CT_OnError() {
- -    local ret=$?
- -    local result
- -    local old_trap
- -    local intro
- -    local file line func
- -    local step step_depth
- -
- -    # To avoid printing the backtace for each sub-shell
- -    # up to the top-level, just remember we've dumped it
- -    if [ ! -f "${CT_WORK_DIR}/backtrace" ]; then
- -        touch "${CT_WORK_DIR}/backtrace"
- -
- -        # Print steps backtrace
- -        step_depth=${CT_STEP_COUNT}
- -        CT_STEP_COUNT=1     # To have a zero-indentation
- -        CT_DoLog ERROR ""
- -        CT_DoLog ERROR ">>"
- -        intro="Build failed"
- -        for((step=step_depth; step>0; step--)); do
- -            CT_DoLog ERROR ">>  ${intro} in step '${CT_STEP_MESSAGE[${step}]}'"
- -            intro="      called"
- -        done
- -
- -        # Print functions backtrace
- -        intro="Error happened in"
- -        CT_DoLog ERROR ">>"
- -        for((depth=1; ${BASH_LINENO[$((${depth}-1))]}>0; depth++)); do
- -            file="${BASH_SOURCE[${depth}]#${CT_LIB_DIR}/}"
- -            func="${FUNCNAME[${depth}]}"
- -            line="@${BASH_LINENO[${depth}-1]:-?}"
- -            CT_DoLog ERROR ">>  ${intro}: ${func}[${file}${line}]"
- -            intro="      called from"
- -        done
- -
- -        # If the user asked for interactive debugging, dump him/her to a shell
- -        if [ "${CT_DEBUG_INTERACTIVE}" = "y" ]; then
- -            # We do not want this sub-shell exit status to be caught, because
- -            # it is absolutely legit that it exits with non-zero.
- -            # Save the trap handler to restore it after our debug-shell
- -            old_trap="$(trap -p ERR)"
- -            trap -- ERR
- -            (
- -                exec >&6 2>&7 <&8
- -                printf "\r         \n\nCurrent command"
- -                if [ -n "${cur_cmd}" ]; then
- -                    printf ":\n  %s\n" "${cur_cmd}"
- -                else
- -                    printf " (unknown), "
- -                fi
- -                printf "exited with error code: %d\n" ${ret}
- -                printf "Please fix it up and finish by exiting the shell with one of these values:\n"
- -                printf "    1  fixed, continue with next build command\n"
- -                if [ -n "${cur_cmd}" ]; then
- -                    printf "    2  repeat this build command\n"
- -                fi
- -                printf "    3  abort build\n\n"
- -                while true; do
- -                    ${bash} --rcfile <(printf "PS1='ct-ng:\w> '\nPROMPT_COMMAND=''\n") -i
- -                    result=$?
- -                    case $result in
- -                        1)  printf "\nContinuing past the failed command.\n\n"
- -                            break
- -                            ;;
- -                        2)  if [ -n "${cur_cmd}" ]; then
- -                                printf "\nRe-trying last command.\n\n"
- -                                break
- -                            fi
- -                            ;;
- -                        3)  break;;
- -                    esac
- -                    printf "\nPlease exit with one of these values:\n"
- -                    printf "    1  fixed, continue with next build command\n"
- -                    if [ -n "${cur_cmd}" ]; then
- -                        printf "    2  repeat this build command\n"
- -                    fi
- -                    printf "    3  abort build\n"
- -                done
- -                exit $result
- -            )
- -            result=$?
- -            # Restore the trap handler
- -            eval "${old_trap}"
- -            case "${result}" in
- -                1)  rm -f "${CT_WORK_DIR}/backtrace"; touch "${CT_BUILD_DIR}/skip"; return;;
- -                2)  rm -f "${CT_WORK_DIR}/backtrace"; touch "${CT_BUILD_DIR}/repeat"; return;;
- -                # 3 is an abort, continue...
- -            esac
- -        fi
- -    fi
- -
- -    # And finally, in top-level shell, print some hints
- -    if [ ${BASH_SUBSHELL} -eq 0 ]; then
- -        # Help diagnose the error
- -        CT_STEP_COUNT=1     # To have a zero-indentation
- -        CT_DoLog ERROR ">>"
- -        if [ "${CT_LOG_TO_FILE}" = "y" ]; then
- -            CT_DoLog ERROR ">>  For more info on this error, look at the file: '${tmp_log_file#${CT_TOP_DIR}/}'"
- -        fi
- -        CT_DoLog ERROR ">>  There is a list of known issues, some with workarounds, in:"
- -        CT_DoLog ERROR ">>      '${CT_DOC_DIR#${CT_TOP_DIR}/}/B - Known issues.txt'"
- -
- -        CT_DoLog ERROR ""
- -        CT_DoEnd ERROR
- -        rm -f "${CT_WORK_DIR}/backtrace"
- -    fi
- -    exit $ret
- -}
- -
- -# Install the fault handler
- -trap CT_OnError ERR
- -
- -# Inherit the fault handler in subshells and functions
- -set -E
- -
- -# Make pipes fail on the _first_ failed command
- -# Not supported on bash < 3.x, but we need it, so drop the obsoleting bash-2.x
- -set -o pipefail
- -
- -# Don't hash commands' locations, and search every time it is requested.
- -# This is slow, but needed because of the static/shared core gcc which shall
- -# always match to shared if it exists, and only fallback to static if the
- -# shared is not found
- -set +o hashall
- -
- -# Log policy:
- -#  - first of all, save stdout so we can see the live logs: fd #6
- -# (also save stdin and stderr for use by CT_DEBUG_INTERACTIVE)
- -exec 6>&1 7>&2 8<&0
- -#  - then point stdout to the log file
- -tmp_log_file="${CT_TOP_DIR}/build.log"
- -rm -f "${tmp_log_file}"
- -exec >>"${tmp_log_file}"
- -
- -# The different log levels:
- -CT_LOG_LEVEL_ERROR=0
- -CT_LOG_LEVEL_WARN=1
- -CT_LOG_LEVEL_INFO=2
- -CT_LOG_LEVEL_EXTRA=3
- -CT_LOG_LEVEL_CFG=4
- -CT_LOG_LEVEL_FILE=5
- -CT_LOG_LEVEL_STATE=6
- -CT_LOG_LEVEL_ALL=7
- -CT_LOG_LEVEL_DEBUG=8
- -
- -# Make it easy to use \n and !
- -CR=$(printf "\n")
- -BANG='!'
- -
- -# A function to log what is happening
- -# Different log level are available:
- -#   - ERROR:   A serious, fatal error occurred
- -#   - WARN:    A non fatal, non serious error occurred, take your responsbility with the generated build
- -#   - INFO:    Informational messages
- -#   - EXTRA:   Extra informational messages
- -#   - CFG:     Output of various "./configure"-type scripts
- -#   - FILE:    File / archive unpacking.
- -#   - STATE:   State save & restore
- -#   - ALL:     Component's build messages
- -#   - DEBUG:   Internal debug messages
- -# Usage: CT_DoLog <level> [message]
- -# If message is empty, then stdin will be logged.
- -CT_DoLog() {
- -    local max_level LEVEL level cur_l cur_L
- -    local l
- -    eval max_level="\${CT_LOG_LEVEL_${CT_LOG_LEVEL_MAX}}"
- -    # Set the maximum log level to DEBUG if we have none
- -    [ -z "${max_level}" ] && max_level=${CT_LOG_LEVEL_DEBUG}
- -
- -    LEVEL="$1"; shift
- -    eval level="\${CT_LOG_LEVEL_${LEVEL}}"
- -
- -    if [ $# -eq 0 ]; then
- -        cat -
- -    else
- -        printf "%s\n" "${*}"
- -    fi |( IFS="${CR}" # We want the full lines, even leading spaces
- -          _prog_bar_cpt=0
- -          _prog_bar[0]='/'
- -          _prog_bar[1]='-'
- -          _prog_bar[2]='\'
- -          _prog_bar[3]='|'
- -          indent=$((2*CT_STEP_COUNT))
- -          while read line; do
- -              case "${CT_LOG_SEE_TOOLS_WARN},${line}" in
- -                y,*"warning:"*)         cur_L=WARN; cur_l=${CT_LOG_LEVEL_WARN};;
- -                y,*"WARNING:"*)         cur_L=WARN; cur_l=${CT_LOG_LEVEL_WARN};;
- -                *"error:"*)             cur_L=ERROR; cur_l=${CT_LOG_LEVEL_ERROR};;
- -                *"make["*"]: *** ["*)   cur_L=ERROR; cur_l=${CT_LOG_LEVEL_ERROR};;
- -                *)                      cur_L="${LEVEL}"; cur_l="${level}";;
- -              esac
- -              # There will always be a log file (stdout, fd #1), be it /dev/null
- -              printf "[%-5s]%*s%s%s\n" "${cur_L}" "${indent}" " " "${line}"
- -              if [ ${cur_l} -le ${max_level} ]; then
- -                  # Only print to console (fd #6) if log level is high enough.
- -                  printf "${CT_LOG_PROGRESS_BAR:+\r}[%-5s]%*s%s%s\n" "${cur_L}" "${indent}" " " "${line}" >&6
- -              fi
- -              if [ "${CT_LOG_PROGRESS_BAR}" = "y" ]; then
- -                  printf "\r[%02d:%02d] %s " $((SECONDS/60)) $((SECONDS%60)) "${_prog_bar[$((_prog_bar_cpt/10))]}" >&6
- -                  _prog_bar_cpt=$(((_prog_bar_cpt+1)%40))
- -              fi
- -          done
- -        )
- -
- -    return 0
- -}
- -
- -# Execute an action, and log its messages
- -# It is possible to even log local variable assignments (a-la: var=val ./cmd opts)
- -# Usage: CT_DoExecLog <level> [VAR=val...] <command> [parameters...]
- -CT_DoExecLog() {
- -    local level="$1"
- -    local cur_cmd
- -    local ret
- -    shift
- -    (
- -    for i in "$@"; do
- -        cur_cmd+="'${i}' "
- -    done
- -    while true; do
- -        case "${1}" in
- -            *=*)    eval export "'${1}'"; shift;;
- -            *)      break;;
- -        esac
- -    done
- -    # This while-loop goes hand-in-hand with the ERR trap handler:
- -    # - if the command terminates successfully, then we hit the break
- -    #   statement, and we exit the loop
- -    # - if the command terminates in error, then the ERR handler kicks
- -    #   in, then:
- -    #     - if the user did *not* ask for interactive debugging, the ERR
- -    #       handler exits, and we hit the end of the sub-shell
- -    #     - if the user did ask for interactive debugging, the ERR handler
- -    #       spawns a shell. Upon termination of this shell, the ERR handler
- -    #       examines the exit status of the shell:
- -    #         - if 1, the ERR handler returns; then we hit the else statement,
- -    #           then the break, and we exit the 'while' loop, to continue the
- -    #           build;
- -    #         - if 2, the ERR handler touches the repeat file, and returns;
- -    #           then we hit the if statement, and we loop for one more
- -    #           iteration;
- -    #         - if 3, the ERR handler exits with the command's exit status,
- -    #           and we're dead;
- -    #         - for any other exit status of the shell, the ERR handler
- -    #           prints an informational message, and respawns the shell
- -    #
- -    # This allows a user to get an interactive shell that has the same
- -    # environment (PATH and so on) that the failed command was ran with.
- -    while true; do
- -        rm -f "${CT_BUILD_DIR}/repeat"
- -        CT_DoLog DEBUG "==> Executing: ${cur_cmd}"
- -        "${@}" 2>&1 |CT_DoLog "${level}"
- -        ret="${?}"
- -        if [ -f "${CT_BUILD_DIR}/repeat" ]; then
- -            rm -f "${CT_BUILD_DIR}/repeat"
- -            continue
- -        elif [ -f "${CT_BUILD_DIR}/skip" ]; then
- -            rm -f "${CT_BUILD_DIR}/skip"
- -            ret=0
- -            break
- -        else
- -            break
- -        fi
- -    done
- -    exit ${ret}
- -    )
- -    # Catch failure of the sub-shell
- -    [ $? -eq 0 ]
- -}
- -
- -# Tail message to be logged whatever happens
- -# Usage: CT_DoEnd <level>
- -CT_DoEnd()
- -{
- -    local level="$1"
- -    CT_STOP_DATE=$(CT_DoDate +%s%N)
- -    CT_STOP_DATE_HUMAN=$(CT_DoDate +%Y%m%d.%H%M%S)
- -    if [ "${level}" != "ERROR" ]; then
- -        CT_DoLog "${level:-INFO}" "Build completed at ${CT_STOP_DATE_HUMAN}"
- -    fi
- -    elapsed=$((CT_STOP_DATE-CT_STAR_DATE))
- -    elapsed_min=$((elapsed/(60*1000*1000*1000)))
- -    elapsed_sec=$(printf "%02d" $(((elapsed%(60*1000*1000*1000))/(1000*1000*1000))))
- -    elapsed_csec=$(printf "%02d" $(((elapsed%(1000*1000*1000))/(10*1000*1000))))
- -    CT_DoLog ${level:-INFO} "(elapsed: ${elapsed_min}:${elapsed_sec}.${elapsed_csec})"
- -}
- -
- -# Remove entries referring to . and other relative paths
- -# Usage: CT_SanitizePath
- -CT_SanitizePath() {
- -    local new
- -    local p
- -    local IFS=:
- -    for p in $PATH; do
- -        # Only accept absolute paths;
- -        # Note: as a special case the empty string in PATH is equivalent to .
- -        if [ -n "${p}" -a -z "${p%%/*}" ]; then
- -            new="${new}${new:+:}${p}"
- -        fi
- -    done
- -    PATH="${new}"
- -}
- -
- -# Sanitise the directory name contained in the variable passed as argument:
- -# - remove duplicate /
- -# Usage: CT_SanitiseVarDir CT_PREFIX_DIR
- -CT_SanitiseVarDir() {
- -    local var
- -    local old_dir
- -    local new_dir
- -
- -    for var in "$@"; do
- -        eval "old_dir=\"\${${var}}\""
- -        new_dir="$( printf "${old_dir}"     \
- -                    |sed -r -e 's:/+:/:g;'  \
- -                  )"
- -        eval "${var}=\"${new_dir}\""
- -        CT_DoLog DEBUG "Sanitised '${var}': '${old_dir}' -> '${new_dir}'"
- -    done
- -}
- -
- -# Abort the execution with an error message
- -# Usage: CT_Abort <message>
- -CT_Abort() {
- -    CT_DoLog ERROR "$1"
- -    false
- -}
- -
- -# Test a condition, and print a message if satisfied
- -# Usage: CT_Test <message> <tests>
- -CT_Test() {
- -    local ret
- -    local m="$1"
- -    shift
- -    CT_DoLog DEBUG "Testing '! ( $* )'"
- -    test "$@" && CT_DoLog WARN "$m"
- -    return 0
- -}
- -
- -# Test a condition, and abort with an error message if satisfied
- -# Usage: CT_TestAndAbort <message> <tests>
- -CT_TestAndAbort() {
- -    local m="$1"
- -    shift
- -    CT_DoLog DEBUG "Testing '! ( $* )'"
- -    test "$@" && CT_Abort "$m"
- -    return 0
- -}
- -
- -# Test a condition, and abort with an error message if not satisfied
- -# Usage: CT_TestAndAbort <message> <tests>
- -CT_TestOrAbort() {
- -    local m="$1"
- -    shift
- -    CT_DoLog DEBUG "Testing '$*'"
- -    test "$@" || CT_Abort "$m"
- -    return 0
- -}
- -
- -# Test the presence of a tool, or abort if not found
- -# Usage: CT_HasOrAbort <tool>
- -CT_HasOrAbort() {
- -    CT_TestAndAbort "'${1}' not found and needed for successful toolchain build." -z "$(CT_Which "${1}")"
- -    return 0
- -}
- -
- -# Search a program: wrap "which" for those system where "which"
- -# verbosely says there is no match (such as on Mandriva).
- -# Usage: CT_Which <filename>
- -CT_Which() {
- -  which "$1" 2>/dev/null || true
- -}
- -
- -# Get current date with nanosecond precision
- -# On those system not supporting nanosecond precision, faked with rounding down
- -# to the highest entire second
- -# Usage: CT_DoDate <fmt>
- -CT_DoDate() {
- -    date "$1" |sed -r -e 's/%?N$/000000000/;'
- -}
- -
- -CT_STEP_COUNT=1
- -CT_STEP_MESSAGE[${CT_STEP_COUNT}]="(top-level)"
- -# Memorise a step being done so that any error is caught
- -# Usage: CT_DoStep <loglevel> <message>
- -CT_DoStep() {
- -    local start=$(CT_DoDate +%s%N)
- -    CT_DoLog "$1" "================================================================="
- -    CT_DoLog "$1" "$2"
- -    CT_STEP_COUNT=$((CT_STEP_COUNT+1))
- -    CT_STEP_LEVEL[${CT_STEP_COUNT}]="$1"; shift
- -    CT_STEP_START[${CT_STEP_COUNT}]="${start}"
- -    CT_STEP_MESSAGE[${CT_STEP_COUNT}]="$1"
- -    return 0
- -}
- -
- -# End the step just being done
- -# Usage: CT_EndStep
- -CT_EndStep() {
- -    local stop=$(CT_DoDate +%s%N)
- -    local duration=$(printf "%032d" $((stop-${CT_STEP_START[${CT_STEP_COUNT}]})) |sed -r -e 's/([[:digit:]]{2})[[:digit:]]{7}$/\.\1/; s/^0+//; s/^\./0\./;')
- -    local elapsed=$(printf "%02d:%02d" $((SECONDS/60)) $((SECONDS%60)))
- -    local level="${CT_STEP_LEVEL[${CT_STEP_COUNT}]}"
- -    local message="${CT_STEP_MESSAGE[${CT_STEP_COUNT}]}"
- -    CT_STEP_COUNT=$((CT_STEP_COUNT-1))
- -    CT_DoLog "${level}" "${message}: done in ${duration}s (at ${elapsed})"
- -    return 0
- -}
- -
- -# Pushes into a directory, and pops back
- -CT_Pushd() {
- -    CT_DoLog DEBUG "Entering '$1'"
- -    pushd "$1" >/dev/null 2>&1
- -}
- -CT_Popd() {
- -    popd >/dev/null 2>&1
- -}
- -
- -# Create a dir and cd or pushd into it
- -# Usage: CT_mkdir_cd <dir/to/create>
- -#        CT_mkdir_pushd <dir/to/create>
- -CT_mkdir_cd() {
- -    local dir="${1}"
- -
- -    mkdir -p "${dir}"
- -    cd "${dir}"
- -}
- -CT_mkdir_pushd() {
- -    local dir="${1}"
- -
- -    mkdir -p "${dir}"
- -    CT_Pushd "${dir}"
- -}
- -
- -# Creates a temporary directory
- -# $1: variable to assign to
- -# Usage: CT_MktempDir foo
- -CT_MktempDir() {
- -    # Some mktemp do not allow more than 6 Xs
- -    eval "$1"=$(mktemp -q -d "${CT_BUILD_DIR}/tmp.XXXXXX")
- -    CT_TestOrAbort "Could not make temporary directory" -n "${!1}" -a -d "${!1}"
- -    CT_DoLog DEBUG "Made temporary directory '${!1}'"
- -    return 0
- -}
- -
- -# Removes one or more directories, even if it is read-only, or its parent is
- -# Usage: CT_DoForceRmdir dir [...]
- -CT_DoForceRmdir() {
- -    local dir
- -    local mode
- -    for dir in "${@}"; do
- -        [ -d "${dir}" ] || continue
- -        case "$CT_SYS_OS" in
- -            Linux|CYGWIN*)
- -                mode="$(stat -c '%a' "$(dirname "${dir}")")"
- -                ;;
- -            Darwin|*BSD)
- -                mode="$(stat -f '%Lp' "$(dirname "${dir}")")"
- -                ;;
- -            *)
- -                CT_Abort "Unhandled host OS $CT_SYS_OS"
- -                ;;
- -        esac
- -        CT_DoExecLog ALL chmod u+w "$(dirname "${dir}")"
- -        CT_DoExecLog ALL chmod -R u+w "${dir}"
- -        CT_DoExecLog ALL rm -rf "${dir}"
- -        CT_DoExecLog ALL chmod ${mode} "$(dirname "${dir}")"
- -    done
- -}
- -
- -# Echoes the specified string on stdout until the pipe breaks.
- -# Doesn't fail
- -# $1: string to echo
- -# Usage: CT_DoYes "" |make oldconfig
- -CT_DoYes() {
- -    yes "$1" || true
- -}
- -
- -# Add the specified directory to LD_LIBRARY_PATH, and export it
- -# If the specified patch is already present, just export
- -# $1: path to add
- -# $2: add as 'first' or 'last' path, 'first' is assumed if $2 is empty
- -# Usage CT_SetLibPath /some/where/lib [first|last]
- -CT_SetLibPath() {
- -    local path="$1"
- -    local pos="$2"
- -
- -    case ":${LD_LIBRARY_PATH}:" in
- -        *:"${path}":*)  ;;
- -        *)  case "${pos}" in
- -                last)
- -                    CT_DoLog DEBUG "Adding '${path}' at end of LD_LIBRARY_PATH"
- -                    LD_LIBRARY_PATH="${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}${path}"
- -                    ;;
- -                first|"")
- -                    CT_DoLog DEBUG "Adding '${path}' at start of LD_LIBRARY_PATH"
- -                    LD_LIBRARY_PATH="${path}${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}"
- -                    ;;
- -                *)
- -                    CT_Abort "Incorrect position '${pos}' to add '${path}' to LD_LIBRARY_PATH"
- -                    ;;
- -            esac
- -            ;;
- -    esac
- -    CT_DoLog DEBUG "==> LD_LIBRARY_PATH='${LD_LIBRARY_PATH}'"
- -    export LD_LIBRARY_PATH
- -}
- -
- -# Build up the list of allowed tarball extensions
- -# Add them in the prefered order; most preferred comes first
- -CT_DoListTarballExt() {
- -    if [ "${CT_CONFIGURE_has_xz}" = "y" ]; then
- -        printf ".tar.xz\n"
- -    fi
- -    if [    "${CT_CONFIGURE_has_lzma}" = "y"    \
- -         -o "${CT_CONFIGURE_has_xz}" = "y" ]; then
- -        printf ".tar.lzma\n"
- -    fi
- -    printf ".tar.bz2\n"
- -    printf ".tar.gz\n.tgz\n"
- -    printf ".tar\n"
- -    printf ".zip\n"
- -}
- -
- -# Get the file name extension of a component
- -# Usage: CT_GetFileExtension <component_name-component_version> [extension]
- -# If found, echoes the extension to stdout, and return 0
- -# If not found, echoes nothing on stdout, and return !0.
- -CT_GetFileExtension() {
- -    local ext
- -    local file="$1"
- -    shift
- -    local first_ext="$1"
- -
- -    # we need to also check for an empty extension for those very
- -    # peculiar components that don't have one (such as sstrip from
- -    # buildroot).
- -    for ext in ${first_ext} $(CT_DoListTarballExt) /.git ''; do
- -        if [ -e "${CT_TARBALLS_DIR}/${file}${ext}" ]; then
- -            echo "${ext}"
- -            exit 0
- -        fi
- -    done
- -
- -    exit 1
- -}
- -
- -# Try to retrieve the specified URL (HTTP or FTP)
- -# Usage: CT_DoGetFile <URL>
- -# This functions always returns true (0), as it can be legitimate not
- -# to find the requested URL (think about snapshots, different layouts
- -# for different gcc versions, etc...).
- -CT_DoGetFile() {
- -    local url="${1}"
- -    local dest="${CT_TARBALLS_DIR}/${url##*/}"
- -    local tmp="${dest}.tmp-dl"
- -
- -    # Remove potential left-over from a previous run
- -    rm -f "${tmp}"
- -
- -    # We also retry a few times, in case there is a transient error (eg. behind
- -    # a dynamic IP that changes during the transfer...)
- -    # With automated download as we are doing, it can be very dangerous to
- -    # continue the downloads. It's far better to simply overwrite the
- -    # destination file.
- -    # Some company networks have firewalls to connect to the internet, but it's
- -    # not easy to detect them, so force a global ${CT_CONNECT_TIMEOUT}-second
- -    # timeout.
- -    if [ ${CT_CONNECT_TIMEOUT} = -1 ]; then
- -        T=
- -    else
- -        T="-T ${CT_CONNECT_TIMEOUT}"
- -    fi
- -    if CT_DoExecLog ALL wget --passive-ftp --tries=3 -nc    \
- -                             --progress=dot:binary          \
- -                             ${T}                           \
- -                             -O "${tmp}"                    \
- -                             "${url}"
- -    then
- -        # Success, we got it, good!
- -        mv "${tmp}" "${dest}"
- -        CT_DoLog DEBUG "Got it from: \"${url}\""
- -    else
- -        # Woops...
- -        rm -f "${tmp}"
- -        CT_DoLog DEBUG "Not at this location: \"${url}\""
- -    fi
- -}
- -
- -# This function tries to retrieve a tarball form a local directory
- -# Usage: CT_GetLocal <basename> [.extension]
- -CT_GetLocal() {
- -    local basename="$1"
- -    local first_ext="$2"
- -    local ext
- -
- -    # Do we already have it in *our* tarballs dir?
- -    if ext="$( CT_GetFileExtension "${basename}" ${first_ext} )"; then
- -        CT_DoLog DEBUG "Already have '${basename}'"
- -        return 0
- -    fi
- -
- -    if [ -n "${CT_LOCAL_TARBALLS_DIR}" ]; then
- -        CT_DoLog DEBUG "Trying to retrieve an already downloaded copy of '${basename}'"
- -        # We'd rather have a bzip2'ed tarball, then gzipped tarball, plain tarball,
- -        # or, as a failover, a file without extension.
- -        for ext in ${first_ext} $(CT_DoListTarballExt) ''; do
- -            CT_DoLog DEBUG "Trying '${CT_LOCAL_TARBALLS_DIR}/${basename}${ext}'"
- -            if [ -r "${CT_LOCAL_TARBALLS_DIR}/${basename}${ext}" -a \
- -                 "${CT_FORCE_DOWNLOAD}" != "y" ]; then
- -                CT_DoLog DEBUG "Got '${basename}' from local storage"
- -                CT_DoExecLog ALL ln -s "${CT_LOCAL_TARBALLS_DIR}/${basename}${ext}" "${CT_TARBALLS_DIR}/${basename}${ext}"
- -                return 0
- -            fi
- -        done
- -    fi
- -    return 1
- -}
- -
- -# This function gets the custom source from either a tarball or directory
- -# Usage: CT_GetCustom <component> <custom_version> <custom_location>
- -CT_GetCustom() {
- -    local custom_component="$1"
- -    local custom_version="$2"
- -    local custom_location="$3"
- -    local custom_name="${custom_component}-${custom_version}"
- -
- -    CT_TestAndAbort "${custom_name}: CT_CUSTOM_LOCATION_ROOT_DIR or ${custom_component}'s CUSTOM_LOCATION must be set." \
- -                    -z "${CT_CUSTOM_LOCATION_ROOT_DIR}" -a -z "${custom_location}"
- -
- -    if [ -n "${CT_CUSTOM_LOCATION_ROOT_DIR}" \
- -         -a -z "${custom_location}"          ]; then
- -        custom_location="${CT_CUSTOM_LOCATION_ROOT_DIR}/${custom_component}"
- -    fi
- -
- -    CT_DoLog EXTRA "Using '${custom_name}' from custom location"
- -    if [ ! -d "${custom_location}" ]; then
- -        # We need to know the custom tarball extension,
- -        # so we can create a properly-named symlink, which
- -        # we use later on in 'extract'
- -        case "${custom_location}" in
- -            *.tar.xz)       custom_name="${custom_name}.tar.xz";;
- -            *.tar.bz2)      custom_name="${custom_name}.tar.bz2";;
- -            *.tar.gz|*.tgz) custom_name="${custom_name}.tar.gz";;
- -            *.tar)          custom_name="${custom_name}.tar";;
- -            *)  CT_Abort "Unknown extension for custom tarball '${custom_location}'";;
- -        esac
- -        CT_DoExecLog DEBUG ln -sf "${custom_location}"  \
- -                                  "${CT_TARBALLS_DIR}/${custom_name}"
- -    else
- -        CT_DoExecLog DEBUG ln -snf "${custom_location}" \
- -                                   "${CT_SRC_DIR}/${custom_name}"
- -    fi
- -}
- -
- -# This function saves the specified to local storage if possible,
- -# and if so, symlinks it for later usage
- -# Usage: CT_SaveLocal </full/path/file.name>
- -CT_SaveLocal() {
- -    local file="$1"
- -    local basename="${file##*/}"
- -
- -    if [ "${CT_SAVE_TARBALLS}" = "y" ]; then
- -        CT_DoLog EXTRA "Saving '${basename}' to local storage"
- -        # The file may already exist if downloads are forced: remove it first
- -        CT_DoExecLog ALL rm -f "${CT_LOCAL_TARBALLS_DIR}/${basename}"
- -        CT_DoExecLog ALL mv -f "${file}" "${CT_LOCAL_TARBALLS_DIR}"
- -        CT_DoExecLog ALL ln -s "${CT_LOCAL_TARBALLS_DIR}/${basename}" "${file}"
- -    fi
- -}
- -
- -# Download the file from one of the URLs passed as argument
- -# Usage: CT_GetFile <basename> [.extension] <url> [url ...]
- -CT_GetFile() {
- -    local ext
- -    local -a URLS
- -    local url
- -    local file="$1"
- -    local first_ext
- -    shift
- -    # If next argument starts with a dot, then this is not an URL,
- -    # and we can consider that it is a preferred extension.
- -    case "$1" in
- -        .*) first_ext="$1"
- -            shift
- -            ;;
- -    esac
- -
- -    # Does it exist localy?
- -    if CT_GetLocal "${file}" ${first_ext}; then
- -        return 0
- -    fi
- -    # No, it does not...
- -
- -    # If not allowed to download from the Internet, don't
- -    if [ "${CT_FORBID_DOWNLOAD}" = "y" ]; then
- -        CT_DoLog DEBUG "Not allowed to download from the Internet, aborting ${file} download"
- -        return 1
- -    fi
- -
- -    # Try to retrieve the file
- -    CT_DoLog EXTRA "Retrieving '${file}'"
- -
- -    # Add URLs on the LAN mirror
- -    if [ "${CT_USE_MIRROR}" = "y" ]; then
- -        CT_TestOrAbort "Please set the mirror base URL" -n "${CT_MIRROR_BASE_URL}"
- -        URLS+=( "${CT_MIRROR_BASE_URL}/${file%-*}" )
- -        URLS+=( "${CT_MIRROR_BASE_URL}" )
- -    fi
- -
- -    if [ "${CT_FORCE_MIRROR}" != "y" ]; then
- -        URLS+=( "${@}" )
- -    fi
- -
- -    # Scan all URLs in turn, and try to grab a tarball from there
- -    # Do *not* try git trees (ext=/.git), this is handled in a specific
- -    # wrapper, below
- -    for ext in ${first_ext} $(CT_DoListTarballExt) ''; do
- -        # Try all urls in turn
- -        for url in "${URLS[@]}"; do
- -            [ -n "${url}" ] || continue
- -            CT_DoLog DEBUG "Trying '${url}/${file}${ext}'"
- -            CT_DoGetFile "${url}/${file}${ext}"
- -            if [ -f "${CT_TARBALLS_DIR}/${file}${ext}" ]; then
- -                CT_DoLog DEBUG "Got '${file}' from the Internet"
- -                CT_SaveLocal "${CT_TARBALLS_DIR}/${file}${ext}"
- -                return 0
- -            fi
- -        done
- -    done
- -
- -    # Just return error, someone may want to catch and handle the error
- -    # (eg. glibc/eglibc add-ons can be missing).
- -    return 1
- -}
- -
- -# Checkout from CVS, and build the associated tarball
- -# The tarball will be called ${basename}.tar.bz2
- -# Prerequisite: either the server does not require password,
- -# or the user must already be logged in.
- -# 'tag' is the tag to retrieve. Must be specified, but can be empty.
- -# If dirname is specified, then module will be renamed to dirname
- -# prior to building the tarball.
- -# Usage: CT_GetCVS <basename> <url> <module> <tag> [dirname[=subdir]]
- -# Note: if '=subdir' is given, then it is used instead of 'module'.
- -CT_GetCVS() {
- -    local basename="$1"
- -    local uri="$2"
- -    local module="$3"
- -    local tag="${4:+-r ${4}}"
- -    local dirname="$5"
- -    local tmp_dir
- -
- -    # First try locally, then the mirror
- -    if CT_GetFile "${basename}"; then
- -        # Got it! Return early! :-)
- -        return 0
- -    fi
- -
- -    if [ "${CT_FORBID_DOWNLOAD}" = "y" ]; then
- -        CT_DoLog WARN "Downloads forbidden, not trying cvs retrieval"
- -        return 1
- -    fi
- -
- -    CT_MktempDir tmp_dir
- -    CT_Pushd "${tmp_dir}"
- -
- -    CT_DoExecLog ALL cvs -z 9 -d "${uri}" co -P ${tag} "${module}"
- -    if [ -n "${dirname}" ]; then
- -        case "${dirname}" in
- -            *=*)
- -                CT_DoExecLog DEBUG mv "${dirname#*=}" "${dirname%%=*}"
- -                CT_DoExecLog ALL tar cjf "${CT_TARBALLS_DIR}/${basename}.tar.bz2" "${dirname%%=*}"
- -                ;;
- -            *)
- -                CT_DoExecLog ALL mv "${module}" "${dirname}"
- -                CT_DoExecLog ALL tar cjf "${CT_TARBALLS_DIR}/${basename}.tar.bz2" "${dirname:-${module}}"
- -                ;;
- -        esac
- -    fi
- -    CT_SaveLocal "${CT_TARBALLS_DIR}/${basename}.tar.bz2"
- -
- -    CT_Popd
- -    CT_DoExecLog ALL rm -rf "${tmp_dir}"
- -}
- -
- -# Check out from SVN, and build the associated tarball
- -# The tarball will be called ${basename}.tar.bz2
- -# Prerequisite: either the server does not require password,
- -# or the user must already be logged in.
- -# 'rev' is the revision to retrieve
- -# Usage: CT_GetSVN <basename> <url> [rev]
- -CT_GetSVN() {
- -    local basename="$1"
- -    local uri="$2"
- -    local rev="$3"
- -
- -    # First try locally, then the mirror
- -    if CT_GetFile "${basename}"; then
- -        # Got it! Return early! :-)
- -        return 0
- -    fi
- -
- -    if [ "${CT_FORBID_DOWNLOAD}" = "y" ]; then
- -        CT_DoLog WARN "Downloads forbidden, not trying svn retrieval"
- -        return 1
- -    fi
- -
- -    CT_MktempDir tmp_dir
- -    CT_Pushd "${tmp_dir}"
- -
- -    if ! CT_DoExecLog ALL svn export ${rev:+-r ${rev}} "${uri}" "${basename}"; then
- -        CT_DoLog WARN "Could not retrieve '${basename}'"
- -        return 1
- -    fi
- -    CT_DoExecLog ALL tar cjf "${CT_TARBALLS_DIR}/${basename}.tar.bz2" "${basename}"
- -    CT_SaveLocal "${CT_TARBALLS_DIR}/${basename}.tar.bz2"
- -
- -    CT_Popd
- -    CT_DoExecLog ALL rm -rf "${tmp_dir}"
- -}
- -
- -# Clone a git tree
- -# Tries the given URLs in turn until one can get cloned. No tarball will be created.
- -# Prerequisites: either the server does not require password,
- -# or the user has already taken any action to authenticate to the server.
- -# The cloned tree will *not* be stored in the local tarballs dir!
- -# Usage: CT_GetGit <basename> <cset> <url>
- -CT_GetGit() {
- -    local basename="${1}"
- -    local cset="${2}"
- -    local url="${3}"
- -    local file="${basename}-${cset}.tar.gz"
- -    local dir="${CT_TARBALLS_DIR}/${basename}-${cset}.git"
- -    local dest="${CT_TARBALLS_DIR}/${file}"
- -    local tmp="${CT_TARBALLS_DIR}/${file}.tmp-dl"
- -
- -    # Do we alreadyhave it?
- -    if CT_GetLocal "${file}"; then
- -        return 0
- -    fi
- -    # Nope...
- -
- -    if [ "${CT_FORBID_DOWNLOAD}" = "y" ]; then
- -        CT_DoLog WARN "Downloads forbidden, not trying git retrieval"
- -        return 1
- -    fi
- -
- -    # Add URLs on the LAN mirror
- -    # We subvert the normal download method, just to look for
- -    # looking at the local mirror
- -    if CT_GetFile "${basename}-${cset}" .tar.gz; then
- -        return 0
- -    fi
- -
- -    CT_DoLog EXTRA "Retrieving '${basename}-${cset}' (git)"
- -
- -    # Remove potential left-over from a previous run
- -    CT_DoExecLog ALL rm -rf "${tmp}.tar.gz" "${tmp}.tar" "${tmp}" "${dir}"
- -
- -    if CT_DoExecLog ALL git clone "${url}" "${dir}"; then
- -        # Yep, cloned OK
- -        CT_Pushd "${dir}"
- -        CT_DoExecLog ALL git archive --format=tar                       \
- -                                     --prefix="${basename}-${cset}/"    \
- -                                     -o "${tmp}.tar"                    \
- -                                     "${cset}"
- -        CT_DoExecLog ALL gzip -9 "${tmp}.tar"
- -        CT_DoExecLog ALL mv -f "${tmp}.tar.gz" "${dest}"
- -        CT_SaveLocal "${dest}"
- -        CT_DoExecLog ALL rm -rf "${tmp}.tar.gz" "${tmp}.tar" "${tmp}" "${dir}"
- -        CT_Popd
- -    else
- -        # Woops...
- -        CT_DoExecLog ALL rm -rf "${dir}"
- -        CT_DoLog Debug "Could not clone '${basename}'"
- -        return 1
- -    fi
- -}
- -
- -# Extract a tarball
- -# Some tarballs need to be extracted in specific places. Eg.: glibc addons
- -# must be extracted in the glibc directory; uCLibc locales must be extracted
- -# in the extra/locale sub-directory of uClibc. This is taken into account
- -# by the caller, that did a 'cd' into the correct path before calling us
- -# and sets nochdir to 'nochdir'.
- -# Note also that this function handles the git trees!
- -# Usage: CT_Extract [nochdir] <basename> [options]
- -# where 'options' are dependent on the source (eg. git branch/tag...)
- -CT_Extract() {
- -    local nochdir="$1"
- -    local basename
- -    local ext
- -    local lzma_prog
- -    local -a tar_opts
- -
- -    if [ "${nochdir}" = "nochdir" ]; then
- -        shift
- -        nochdir="$(pwd)"
- -    else
- -        nochdir="${CT_SRC_DIR}"
- -    fi
- -
- -    basename="$1"
- -    shift
- -
- -    if ! ext="$(CT_GetFileExtension "${basename}")"; then
- -        CT_DoLog WARN "'${basename}' not found in '${CT_TARBALLS_DIR}'"
- -        return 1
- -    fi
- -    local full_file="${CT_TARBALLS_DIR}/${basename}${ext}"
- -
- -    # Check if already extracted
- -    if [ -e "${CT_SRC_DIR}/.${basename}.extracted" ]; then
- -        CT_DoLog DEBUG "Already extracted '${basename}'"
- -        return 0
- -    fi
- -
- -    # Check if previously partially extracted
- -    if [ -e "${CT_SRC_DIR}/.${basename}.extracting" ]; then
- -        CT_DoLog ERROR "The '${basename}' sources were partially extracted."
- -        CT_DoLog ERROR "Please remove first:"
- -        CT_DoLog ERROR " - the source dir for '${basename}', in '${CT_SRC_DIR}'"
- -        CT_DoLog ERROR " - the file '${CT_SRC_DIR}/.${basename}.extracting'"
- -        CT_Abort "I'll stop now to avoid any carnage..."
- -    fi
- -    CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.${basename}.extracting"
- -
- -    CT_Pushd "${nochdir}"
- -
- -    CT_DoLog EXTRA "Extracting '${basename}'"
- -    CT_DoExecLog FILE mkdir -p "${basename}"
- -    tar_opts=( "--strip-components=1" )
- -    tar_opts+=( "-C" "${basename}" )
- -    tar_opts+=( "-xv" )
- -
- -    # One note here:
- -    # - lzma can be handled either with 'xz' or 'lzma'
- -    # - we get lzma tarball only if either or both are available
- -    # - so, if we get an lzma tarball, and either 'xz' or 'lzma' is
- -    #   missing, we can assume the other is available
- -    if [ "${CT_CONFIGURE_has_lzma}" = "y" ]; then
- -        lzma_prog="lzma -fdc"
- -    else
- -        lzma_prog="xz -fdc"
- -    fi
- -    case "${ext}" in
- -        .tar.xz)      xz -fdc "${full_file}" | CT_DoExecLog FILE tar "${tar_opts[@]}" -f -;;
- -        .tar.lzma)    ${lzma_prog} "${full_file}" | CT_DoExecLog FILE tar "${tar_opts[@]}" -f -;;
- -        .tar.bz2)     bzip2 -dc "${full_file}" | CT_DoExecLog FILE tar "${tar_opts[@]}" -f -;;
- -        .tar.gz|.tgz) gzip -dc "${full_file}" | CT_DoExecLog FILE tar "${tar_opts[@]}" -f -;;
- -        .tar)         CT_DoExecLog FILE tar "${tar_opts[@]}" -f "${full_file}";;
- -        .zip)         CT_DoExecLog FILE unzip "${@}" "${full_file}";;
- -        /.git)        CT_ExtractGit "${basename}" "${@}";;
- -        *)            CT_DoLog WARN "Don't know how to handle '${basename}${ext}': unknown extension"
- -                      return 1
- -                      ;;
- -    esac
- -
- -    # Don't mark as being extracted for git
- -    case "${ext}" in
- -        /.git)  ;;
- -        *)      CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.${basename}.extracted";;
- -    esac
- -    CT_DoExecLog DEBUG rm -f "${CT_SRC_DIR}/.${basename}.extracting"
- -
- -    CT_Popd
- -}
- -
- -# Create a working git clone of a local git repository
- -# Usage: CT_ExtractGit <basename> [ref]
- -# where 'ref' is the reference to use:
- -#   the full name of a branch, like "remotes/origin/branch_name"
- -#   a date as understandable by git, like "YYYY-MM-DD[ hh[:mm[:ss]]]"
- -#   a tag name
- -# If 'ref' is not given, the current repository HEAD will be used
- -CT_ExtractGit() {
- -    local basename="${1}"
- -    local ref="${2}"
- -    local repo
- -    local ref_type
- -
- -    # pushd now to be able to get git revlist in case ref is a date
- -    repo="${CT_TARBALLS_DIR}/${basename}"
- -    CT_Pushd "${repo}"
- -
- -    # What kind of reference is ${ref} ?
- -    if [ -z "${ref}" ]; then
- -        ref_type=head
- -        ref=$(git rev-list -n1 HEAD)
- -    elif git tag |grep -E "^${ref}$" >/dev/null 2>&1; then
- -        ref_type=tag
- -    elif git branch -a --no-color |grep -E "^. ${ref}$" >/dev/null 2>&1; then
- -        ref_type=branch
- -    elif date -d "${ref}" >/dev/null 2>&1; then
- -        ref_type=date
- -        ref=$(git rev-list -n1 --before="${ref}")
- -    else
- -        CT_Abort "Reference '${ref}' is an incorrect git reference: neither tag, branch nor date"
- -    fi
- -
- -    CT_Popd
- -
- -    CT_DoExecLog FILE rmdir "${basename}"
- -    case "${ref_type}" in
- -        branch) CT_DoExecLog FILE git clone -b "${ref}" "${repo}" "${basename}" ;;
- -        *)      CT_DoExecLog FILE git clone "${repo}" "${basename}"
- -                CT_Pushd "${basename}"
- -                CT_DoExecLog FILE git checkout "${ref}"
- -                CT_Popd
- -                ;;
- -    esac
- -}
- -
- -# Patches the specified component
- -# See CT_Extract, above, for explanations on 'nochdir'
- -# Usage: CT_Patch [nochdir] <packagename> <packageversion>
- -# If the package directory is *not* packagename-packageversion, then
- -# the caller must cd into the proper directory first, and call us
- -# with nochdir
- -CT_Patch() {
- -    local nochdir="$1"
- -    local pkgname
- -    local version
- -    local pkgdir
- -    local base_file
- -    local ver_file
- -    local d
- -    local -a patch_dirs
- -    local bundled_patch_dir
- -    local local_patch_dir
- -    local bundled_exp_patch_dir
- -    local local_exp_patch_dir
- -
- -    if [ "${nochdir}" = "nochdir" ]; then
- -        shift
- -        pkgname="$1"
- -        version="$2"
- -        pkgdir="${pkgname}-${version}"
- -        nochdir="$(pwd)"
- -    else
- -        pkgname="$1"
- -        version="$2"
- -        pkgdir="${pkgname}-${version}"
- -        nochdir="${CT_SRC_DIR}/${pkgdir}"
- -    fi
- -
- -    # Check if already patched
- -    if [ -e "${CT_SRC_DIR}/.${pkgdir}.patched" ]; then
- -        CT_DoLog DEBUG "Already patched '${pkgdir}'"
- -        return 0
- -    fi
- -
- -    # Check if already partially patched
- -    if [ -e "${CT_SRC_DIR}/.${pkgdir}.patching" ]; then
- -        CT_DoLog ERROR "The '${pkgdir}' sources were partially patched."
- -        CT_DoLog ERROR "Please remove first:"
- -        CT_DoLog ERROR " - the source dir for '${pkgdir}', in '${CT_SRC_DIR}'"
- -        CT_DoLog ERROR " - the file '${CT_SRC_DIR}/.${pkgdir}.extracted'"
- -        CT_DoLog ERROR " - the file '${CT_SRC_DIR}/.${pkgdir}.patching'"
- -        CT_Abort "I'll stop now to avoid any carnage..."
- -    fi
- -    touch "${CT_SRC_DIR}/.${pkgdir}.patching"
- -
- -    CT_Pushd "${nochdir}"
- -
- -    CT_DoLog EXTRA "Patching '${pkgdir}'"
- -
- -    bundled_patch_dir="${CT_LIB_DIR}/patches/${pkgname}/${version}"
- -    local_patch_dir="${CT_LOCAL_PATCH_DIR}/${pkgname}/${version}"
- -
- -    # Check for experimental patches, if enabled.
- -    if [ "${CT_EXPERIMENTAL_PATCHES}" = "y" ]; then
- -        bundled_exp_patch_dir="${CT_LIB_DIR}/patches/experimental/${pkgname}/${version}"
- -        local_exp_patch_dir="${CT_LOCAL_PATCH_DIR}/experimental/${pkgname}/${version}"
- -    fi
- -
- -    case "${CT_PATCH_ORDER}" in
- -        bundled)        patch_dirs=("${bundled_patch_dir}" "${bundled_exp_patch_dir}");;
- -        local)          patch_dirs=("${local_patch_dir}" "${local_exp_patch_dir}");;
- -        bundled,local)  patch_dirs=("${bundled_patch_dir}" "${bundled_exp_patch_dir}" "${local_patch_dir}" "${local_exp_patch_dir}");;
- -        local,bundled)  patch_dirs=("${local_patch_dir}" "${local_exp_patch_dir}" "${bundled_patch_dir}" "${bundled_exp_patch_dir}");;
- -        none)           patch_dirs=;;
- -    esac
- -
- -    for d in "${patch_dirs[@]}"; do
- -        CT_DoLog DEBUG "Looking for patches in '${d}'..."
- -        if [ -n "${d}" -a -d "${d}" ]; then
- -            for p in "${d}"/*.patch; do
- -                if [ -f "${p}" ]; then
- -                    CT_DoExecLog ALL patch --no-backup-if-mismatch -g0 -F1 -p1 -f -i "${p}"
- -                fi
- -            done
- -            if [ "${CT_PATCH_SINGLE}" = "y" ]; then
- -                break
- -            fi
- -        fi
- -    done
- -
- -    if [ "${CT_OVERIDE_CONFIG_GUESS_SUB}" = "y" ]; then
- -        CT_DoLog ALL "Overiding config.guess and config.sub"
- -        for cfg in config_guess config_sub; do
- -            eval ${cfg}="${CT_LIB_DIR}/scripts/${cfg/_/.}"
- -            [ -e "${CT_TOP_DIR}/scripts/${cfg/_/.}" ] && eval ${cfg}="${CT_TOP_DIR}/scripts/${cfg/_/.}"
- -            # Can't use CT_DoExecLog because of the '{} \;' to be passed un-mangled to find
- -            find . -type f -name "${cfg/_/.}" -exec cp -v "${!cfg}" {} \; |CT_DoLog ALL
- -        done
- -    fi
- -
- -    CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.${pkgdir}.patched"
- -    CT_DoExecLog DEBUG rm -f "${CT_SRC_DIR}/.${pkgdir}.patching"
- -
- -    CT_Popd
- -}
- -
- -# Two wrappers to call config.(guess|sub) either from CT_TOP_DIR or CT_LIB_DIR.
- -# Those from CT_TOP_DIR, if they exist, will be be more recent than those from CT_LIB_DIR.
- -CT_DoConfigGuess() {
- -    if [ -x "${CT_TOP_DIR}/scripts/config.guess" ]; then
- -        "${CT_TOP_DIR}/scripts/config.guess"
- -    else
- -        "${CT_LIB_DIR}/scripts/config.guess"
- -    fi
- -}
- -
- -CT_DoConfigSub() {
- -    if [ -x "${CT_TOP_DIR}/scripts/config.sub" ]; then
- -        "${CT_TOP_DIR}/scripts/config.sub" "$@"
- -    else
- -        "${CT_LIB_DIR}/scripts/config.sub" "$@"
- -    fi
- -}
- -
- -# Compute the target tuple from what is provided by the user
- -# Usage: CT_DoBuildTargetTuple
- -# In fact this function takes the environment variables to build the target
- -# tuple. It is needed both by the normal build sequence, as well as the
- -# sample saving sequence.
- -CT_DoBuildTargetTuple() {
- -    # Set the endianness suffix, and the default endianness gcc option
- -    case "${CT_ARCH_ENDIAN}" in
- -        big)
- -            target_endian_eb=eb
- -            target_endian_be=be
- -            target_endian_el=
- -            target_endian_le=
- -            CT_ARCH_ENDIAN_CFLAG="-mbig-endian"
- -            CT_ARCH_ENDIAN_LDFLAG="-Wl,-EB"
- -            ;;
- -        little)
- -            target_endian_eb=
- -            target_endian_be=
- -            target_endian_el=el
- -            target_endian_le=le
- -            CT_ARCH_ENDIAN_CFLAG="-mlittle-endian"
- -            CT_ARCH_ENDIAN_LDFLAG="-Wl,-EL"
- -            ;;
- -    esac
- -
- -    # Set the bitness suffix
- -    case "${CT_ARCH_BITNESS}" in
- -        32)
- -            target_bits_32=32
- -            target_bits_64=
- -            ;;
- -        64)
- -            target_bits_32=
- -            target_bits_64=64
- -            ;;
- -    esac
- -
- -    # Build the default architecture tuple part
- -    CT_TARGET_ARCH="${CT_ARCH}${CT_ARCH_SUFFIX}"
- -
- -    # Set defaults for the system part of the tuple. Can be overriden
- -    # by architecture-specific values.
- -    case "${CT_LIBC}" in
- -        *glibc) CT_TARGET_SYS=gnu;;
- -        uClibc) CT_TARGET_SYS=uclibc;;
- -        *)      CT_TARGET_SYS=elf;;
- -    esac
- -
- -    # Set the default values for ARCH, ABI, CPU, TUNE, FPU and FLOAT
- -    unset CT_ARCH_ARCH_CFLAG CT_ARCH_ABI_CFLAG CT_ARCH_CPU_CFLAG CT_ARCH_TUNE_CFLAG CT_ARCH_FPU_CFLAG CT_ARCH_FLOAT_CFLAG
- -    unset CT_ARCH_WITH_ARCH CT_ARCH_WITH_ABI CT_ARCH_WITH_CPU CT_ARCH_WITH_TUNE CT_ARCH_WITH_FPU CT_ARCH_WITH_FLOAT
- -    [ "${CT_ARCH_ARCH}"     ] && { CT_ARCH_ARCH_CFLAG="-march=${CT_ARCH_ARCH}";  CT_ARCH_WITH_ARCH="--with-arch=${CT_ARCH_ARCH}"; }
- -    [ "${CT_ARCH_ABI}"      ] && { CT_ARCH_ABI_CFLAG="-mabi=${CT_ARCH_ABI}";     CT_ARCH_WITH_ABI="--with-abi=${CT_ARCH_ABI}";    }
- -    [ "${CT_ARCH_CPU}"      ] && { CT_ARCH_CPU_CFLAG="-mcpu=${CT_ARCH_CPU}";     CT_ARCH_WITH_CPU="--with-cpu=${CT_ARCH_CPU}";    }
- -    [ "${CT_ARCH_TUNE}"     ] && { CT_ARCH_TUNE_CFLAG="-mtune=${CT_ARCH_TUNE}";  CT_ARCH_WITH_TUNE="--with-tune=${CT_ARCH_TUNE}"; }
- -    [ "${CT_ARCH_FPU}"      ] && { CT_ARCH_FPU_CFLAG="-mfpu=${CT_ARCH_FPU}";     CT_ARCH_WITH_FPU="--with-fpu=${CT_ARCH_FPU}";    }
- -
- -    case "${CT_ARCH_FLOAT}" in
- -        hard)
- -            CT_ARCH_FLOAT_CFLAG="-mhard-float"
- -            CT_ARCH_WITH_FLOAT="--with-float=hard"
- -            ;;
- -        soft)
- -            CT_ARCH_FLOAT_CFLAG="-msoft-float"
- -            CT_ARCH_WITH_FLOAT="--with-float=soft"
- -            ;;
- -        softfp)
- -            CT_ARCH_FLOAT_CFLAG="-mfloat-abi=softfp"
- -            CT_ARCH_WITH_FLOAT="--with-float=softfp"
- -            ;;
- -    esac
- -
- -    # Build the default kernel tuple part
- -    CT_TARGET_KERNEL="${CT_KERNEL}"
- -
- -    # Overide the default values with the components specific settings
- -    CT_DoArchTupleValues
- -    CT_DoKernelTupleValues
- -
- -    # Finish the target tuple construction
- -    CT_TARGET="${CT_TARGET_ARCH}"
- -    CT_TARGET="${CT_TARGET}${CT_TARGET_VENDOR:+-${CT_TARGET_VENDOR}}"
- -    CT_TARGET="${CT_TARGET}${CT_TARGET_KERNEL:+-${CT_TARGET_KERNEL}}"
- -    CT_TARGET="${CT_TARGET}${CT_TARGET_SYS:+-${CT_TARGET_SYS}}"
- -
- -    # Sanity checks
- -    __sed_alias=""
- -    if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
- -        __sed_alias=$(echo "${CT_TARGET}" |sed -r -e "${CT_TARGET_ALIAS_SED_EXPR}")
- -    fi
- -    case ":${CT_TARGET_VENDOR}:${CT_TARGET_ALIAS}:${__sed_alias}:" in
- -      :*" "*:*:*:) CT_Abort "Don't use spaces in the vendor string, it breaks things.";;
- -      :*"-"*:*:*:) CT_Abort "Don't use dashes in the vendor string, it breaks things.";;
- -      :*:*" "*:*:) CT_Abort "Don't use spaces in the target alias, it breaks things.";;
- -      :*:*:*" "*:) CT_Abort "Don't use spaces in the target sed transform, it breaks things.";;
- -    esac
- -
- -    # Canonicalise it
- -    CT_TARGET=$(CT_DoConfigSub "${CT_TARGET}")
- -    # Prepare the target CFLAGS
- -    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_ENDIAN_CFLAG}"
- -    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_ARCH_CFLAG}"
- -    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_ABI_CFLAG}"
- -    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_CPU_CFLAG}"
- -    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_TUNE_CFLAG}"
- -    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_FPU_CFLAG}"
- -    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_FLOAT_CFLAG}"
- -
- -    # Now on for the target LDFLAGS
- -    CT_ARCH_TARGET_LDFLAGS="${CT_ARCH_TARGET_LDFLAGS} ${CT_ARCH_ENDIAN_LDFLAG}"
- -}
- -
- -# This function does pause the build until the user strikes "Return"
- -# Usage: CT_DoPause [optional_message]
- -CT_DoPause() {
- -    local foo
- -    local message="${1:-Pausing for your pleasure}"
- -    CT_DoLog INFO "${message}"
- -    read -p "Press 'Enter' to continue, or Ctrl-C to stop..." foo >&6
- -    return 0
- -}
- -
- -# This function creates a tarball of the specified directory, but
- -# only if it exists
- -# Usage: CT_DoTarballIfExists <dir> <tarball_basename> [extra_tar_options [...]]
- -CT_DoTarballIfExists() {
- -    local dir="$1"
- -    local tarball="$2"
- -    shift 2
- -    local -a extra_tar_opts=( "$@" )
- -    local -a compress
- -
- -    case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
- -        y)  compress=( gzip -c -3 - ); tar_ext=.gz;;
- -        *)  compress=( cat - );        tar_ext=;;
- -    esac
- -
- -    if [ -d "${dir}" ]; then
- -        CT_DoLog DEBUG "  Saving '${dir}'"
- -        { tar c -C "${dir}" -v -f - "${extra_tar_opts[@]}" .    \
- -          |"${compress[@]}" >"${tarball}.tar${tar_ext}"         ;
- -        } 2>&1 |sed -r -e 's/^/    /;' |CT_DoLog STATE
- -    else
- -        CT_DoLog STATE "  Not saving '${dir}': does not exist"
- -    fi
- -}
- -
- -# This function extracts a tarball to the specified directory, but
- -# only if the tarball exists
- -# Usage: CT_DoExtractTarballIfExists <tarball_basename> <dir> [extra_tar_options [...]]
- -CT_DoExtractTarballIfExists() {
- -    local tarball="$1"
- -    local dir="$2"
- -    shift 2
- -    local -a extra_tar_opts=( "$@" )
- -    local -a uncompress
- -
- -    case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
- -        y)  uncompress=( gzip -c -d ); tar_ext=.gz;;
- -        *)  uncompress=( cat );        tar_ext=;;
- -    esac
- -
- -    if [ -f "${tarball}.tar${tar_ext}" ]; then
- -        CT_DoLog DEBUG "  Restoring '${dir}'"
- -        CT_DoForceRmdir "${dir}"
- -        CT_DoExecLog DEBUG mkdir -p "${dir}"
- -        { "${uncompress[@]}" "${tarball}.tar${tar_ext}"     \
- -          |tar x -C "${dir}" -v -f - "${extra_tar_opts[@]}" ;
- -        } 2>&1 |sed -r -e 's/^/    /;' |CT_DoLog STATE
- -    else
- -        CT_DoLog STATE "  Not restoring '${dir}': does not exist"
- -    fi
- -}
- -
- -# This function saves the state of the toolchain to be able to restart
- -# at any one point
- -# Usage: CT_DoSaveState <next_step_name>
- -CT_DoSaveState() {
- -	[ "${CT_DEBUG_CT_SAVE_STEPS}" = "y" ] || return 0
- -    local state_name="$1"
- -    local state_dir="${CT_STATE_DIR}/${state_name}"
- -
- -    # Log this to the log level required by the user
- -    CT_DoLog ${CT_LOG_LEVEL_MAX} "Saving state to restart at step '${state_name}'..."
- -
- -    rm -rf "${state_dir}"
- -    mkdir -p "${state_dir}"
- -
- -    CT_DoLog STATE "  Saving environment and aliases"
- -    # We must omit shell functions, and some specific bash variables
- -    # that break when restoring the environment, later. We could do
- -    # all the processing in the awk script, but a sed is easier...
- -    set |awk '
- -              BEGIN { _p = 1; }
- -              $0~/^[^ ]+ \(\)/ { _p = 0; }
- -              _p == 1
- -              $0 == "}" { _p = 1; }
- -              ' |sed -r -e '/^BASH_(ARGC|ARGV|LINENO|SOURCE|VERSINFO)=/d;
- -                           /^(UID|EUID)=/d;
- -                           /^(FUNCNAME|GROUPS|PPID|SHELLOPTS)=/d;' >"${state_dir}/env.sh"
- -
- -    CT_DoTarballIfExists "${CT_BUILDTOOLS_PREFIX_DIR}" "${state_dir}/buildtools_dir"
- -    CT_DoTarballIfExists "${CT_CONFIG_DIR}" "${state_dir}/config_dir"
- -    CT_DoTarballIfExists "${CT_PREFIX_DIR}" "${state_dir}/prefix_dir" --exclude '*.log'
- -
- -    CT_DoLog STATE "  Saving log file"
- -    exec >/dev/null
- -    case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
- -        y)  gzip -3 -c "${tmp_log_file}"  >"${state_dir}/log.gz";;
- -        *)  cat "${tmp_log_file}" >"${state_dir}/log";;
- -    esac
- -    exec >>"${tmp_log_file}"
- -}
- -
- -# This function restores a previously saved state
- -# Usage: CT_DoLoadState <state_name>
- -CT_DoLoadState(){
- -    local state_name="$1"
- -    local state_dir="${CT_STATE_DIR}/${state_name}"
- -    local old_RESTART="${CT_RESTART}"
- -    local old_STOP="${CT_STOP}"
- -
- -    CT_TestOrAbort "The previous build did not reach the point where it could be restarted at '${CT_RESTART}'" -d "${state_dir}"
- -
- -    # We need to do something special with the log file!
- -    if [ "${CT_LOG_TO_FILE}" = "y" ]; then
- -        exec >"${state_dir}/tail.log"
- -    fi
- -
- -    # Log this to the log level required by the user
- -    CT_DoLog ${CT_LOG_LEVEL_MAX} "Restoring state at step '${state_name}', as requested."
- -
- -    CT_DoExtractTarballIfExists "${state_dir}/prefix_dir" "${CT_PREFIX_DIR}"
- -    CT_DoExtractTarballIfExists "${state_dir}/config_dir" "${CT_CONFIG_DIR}"
- -    CT_DoExtractTarballIfExists "${state_dir}/buildtools_dir" "${CT_BUILDTOOLS_PREFIX_DIR}"
- -
- -    # Restore the environment, discarding any error message
- -    # (for example, read-only bash internals)
- -    CT_DoLog STATE "  Restoring environment"
- -    . "${state_dir}/env.sh" >/dev/null 2>&1 || true
- -
- -    # Restore the new RESTART and STOP steps
- -    CT_RESTART="${old_RESTART}"
- -    CT_STOP="${old_STOP}"
- -    unset old_stop old_restart
- -
- -    CT_DoLog STATE "  Restoring log file"
- -    exec >/dev/null
- -    case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
- -        y)  gzip -dc "${state_dir}/log.gz" >"${tmp_log_file}";;
- -        *)  cat "${state_dir}/log" >"${tmp_log_file}";;
- -    esac
- -    cat "${state_dir}/tail.log" >>"${tmp_log_file}"
- -    exec >>"${tmp_log_file}"
- -    rm -f "${state_dir}/tail.log"
- -}
diff --git a/scripts/functions.in b/scripts/functions.in
new file mode 100644
index 0000000..51bf4a1
- --- /dev/null
+++ b/scripts/functions.in
@@ -0,0 +1,1395 @@
+# This file contains some usefull common functions -*- sh -*-
+# Copyright 2007 Yann E. MORIN
+# Licensed under the GPL v2. See COPYING in the root of this package
+
+# Prepare the fault handler
+CT_OnError() {
+    local ret=$?
+    local result
+    local old_trap
+    local intro
+    local file line func
+    local step step_depth
+
+    # To avoid printing the backtace for each sub-shell
+    # up to the top-level, just remember we've dumped it
+    if [ ! -f "${CT_WORK_DIR}/backtrace" ]; then
+        touch "${CT_WORK_DIR}/backtrace"
+
+        # Print steps backtrace
+        step_depth=${CT_STEP_COUNT}
+        CT_STEP_COUNT=1     # To have a zero-indentation
+        CT_DoLog ERROR ""
+        CT_DoLog ERROR ">>"
+        intro="Build failed"
+        for((step=step_depth; step>0; step--)); do
+            CT_DoLog ERROR ">>  ${intro} in step '${CT_STEP_MESSAGE[${step}]}'"
+            intro="      called"
+        done
+
+        # Print functions backtrace
+        intro="Error happened in"
+        CT_DoLog ERROR ">>"
+        for((depth=1; ${BASH_LINENO[$((${depth}-1))]}>0; depth++)); do
+            file="${BASH_SOURCE[${depth}]#${CT_LIB_DIR}/}"
+            func="${FUNCNAME[${depth}]}"
+            line="@${BASH_LINENO[${depth}-1]:-?}"
+            CT_DoLog ERROR ">>  ${intro}: ${func}[${file}${line}]"
+            intro="      called from"
+        done
+
+        # If the user asked for interactive debugging, dump him/her to a shell
+        if [ "${CT_DEBUG_INTERACTIVE}" = "y" ]; then
+            # We do not want this sub-shell exit status to be caught, because
+            # it is absolutely legit that it exits with non-zero.
+            # Save the trap handler to restore it after our debug-shell
+            old_trap="$(trap -p ERR)"
+            trap -- ERR
+            (
+                exec >&6 2>&7 <&8
+                printf "\r         \n\nCurrent command"
+                if [ -n "${cur_cmd}" ]; then
+                    printf ":\n  %s\n" "${cur_cmd}"
+                else
+                    printf " (unknown), "
+                fi
+                printf "exited with error code: %d\n" ${ret}
+                printf "Please fix it up and finish by exiting the shell with one of these values:\n"
+                printf "    1  fixed, continue with next build command\n"
+                if [ -n "${cur_cmd}" ]; then
+                    printf "    2  repeat this build command\n"
+                fi
+                printf "    3  abort build\n\n"
+                while true; do
+                    ${bash} --rcfile <(printf "PS1='ct-ng:\w> '\nPROMPT_COMMAND=''\n") -i
+                    result=$?
+                    case $result in
+                        1)  printf "\nContinuing past the failed command.\n\n"
+                            break
+                            ;;
+                        2)  if [ -n "${cur_cmd}" ]; then
+                                printf "\nRe-trying last command.\n\n"
+                                break
+                            fi
+                            ;;
+                        3)  break;;
+                    esac
+                    printf "\nPlease exit with one of these values:\n"
+                    printf "    1  fixed, continue with next build command\n"
+                    if [ -n "${cur_cmd}" ]; then
+                        printf "    2  repeat this build command\n"
+                    fi
+                    printf "    3  abort build\n"
+                done
+                exit $result
+            )
+            result=$?
+            # Restore the trap handler
+            eval "${old_trap}"
+            case "${result}" in
+                1)  rm -f "${CT_WORK_DIR}/backtrace"; touch "${CT_BUILD_DIR}/skip"; return;;
+                2)  rm -f "${CT_WORK_DIR}/backtrace"; touch "${CT_BUILD_DIR}/repeat"; return;;
+                # 3 is an abort, continue...
+            esac
+        fi
+    fi
+
+    # And finally, in top-level shell, print some hints
+    if [ ${BASH_SUBSHELL} -eq 0 ]; then
+        # Help diagnose the error
+        CT_STEP_COUNT=1     # To have a zero-indentation
+        CT_DoLog ERROR ">>"
+        if [ "${CT_LOG_TO_FILE}" = "y" ]; then
+            CT_DoLog ERROR ">>  For more info on this error, look at the file: '${tmp_log_file#${CT_TOP_DIR}/}'"
+        fi
+        CT_DoLog ERROR ">>  There is a list of known issues, some with workarounds, in:"
+        CT_DoLog ERROR ">>      '${CT_DOC_DIR#${CT_TOP_DIR}/}/B - Known issues.txt'"
+
+        CT_DoLog ERROR ""
+        CT_DoEnd ERROR
+        rm -f "${CT_WORK_DIR}/backtrace"
+    fi
+    exit $ret
+}
+
+# Install the fault handler
+trap CT_OnError ERR
+
+# Inherit the fault handler in subshells and functions
+set -E
+
+# Make pipes fail on the _first_ failed command
+# Not supported on bash < 3.x, but we need it, so drop the obsoleting bash-2.x
+set -o pipefail
+
+# Don't hash commands' locations, and search every time it is requested.
+# This is slow, but needed because of the static/shared core gcc which shall
+# always match to shared if it exists, and only fallback to static if the
+# shared is not found
+set +o hashall
+
+# Log policy:
+#  - first of all, save stdout so we can see the live logs: fd #6
+# (also save stdin and stderr for use by CT_DEBUG_INTERACTIVE)
+exec 6>&1 7>&2 8<&0
+#  - then point stdout to the log file
+tmp_log_file="${CT_TOP_DIR}/build.log"
+rm -f "${tmp_log_file}"
+exec >>"${tmp_log_file}"
+
+# The different log levels:
+CT_LOG_LEVEL_ERROR=0
+CT_LOG_LEVEL_WARN=1
+CT_LOG_LEVEL_INFO=2
+CT_LOG_LEVEL_EXTRA=3
+CT_LOG_LEVEL_CFG=4
+CT_LOG_LEVEL_FILE=5
+CT_LOG_LEVEL_STATE=6
+CT_LOG_LEVEL_ALL=7
+CT_LOG_LEVEL_DEBUG=8
+
+# Make it easy to use \n and !
+CR=$(printf "\n")
+BANG='!'
+
+# A function to log what is happening
+# Different log level are available:
+#   - ERROR:   A serious, fatal error occurred
+#   - WARN:    A non fatal, non serious error occurred, take your responsbility with the generated build
+#   - INFO:    Informational messages
+#   - EXTRA:   Extra informational messages
+#   - CFG:     Output of various "./configure"-type scripts
+#   - FILE:    File / archive unpacking.
+#   - STATE:   State save & restore
+#   - ALL:     Component's build messages
+#   - DEBUG:   Internal debug messages
+# Usage: CT_DoLog <level> [message]
+# If message is empty, then stdin will be logged.
+CT_DoLog() {
+    local max_level LEVEL level cur_l cur_L
+    local l
+    eval max_level="\${CT_LOG_LEVEL_${CT_LOG_LEVEL_MAX}}"
+    # Set the maximum log level to DEBUG if we have none
+    [ -z "${max_level}" ] && max_level=${CT_LOG_LEVEL_DEBUG}
+
+    LEVEL="$1"; shift
+    eval level="\${CT_LOG_LEVEL_${LEVEL}}"
+
+    if [ $# -eq 0 ]; then
+        cat -
+    else
+        printf "%s\n" "${*}"
+    fi |( IFS="${CR}" # We want the full lines, even leading spaces
+          _prog_bar_cpt=0
+          _prog_bar[0]='/'
+          _prog_bar[1]='-'
+          _prog_bar[2]='\'
+          _prog_bar[3]='|'
+          indent=$((2*CT_STEP_COUNT))
+          while read line; do
+              case "${CT_LOG_SEE_TOOLS_WARN},${line}" in
+                y,*"warning:"*)         cur_L=WARN; cur_l=${CT_LOG_LEVEL_WARN};;
+                y,*"WARNING:"*)         cur_L=WARN; cur_l=${CT_LOG_LEVEL_WARN};;
+                *"error:"*)             cur_L=ERROR; cur_l=${CT_LOG_LEVEL_ERROR};;
+                *"make["*"]: *** ["*)   cur_L=ERROR; cur_l=${CT_LOG_LEVEL_ERROR};;
+                *)                      cur_L="${LEVEL}"; cur_l="${level}";;
+              esac
+              # There will always be a log file (stdout, fd #1), be it /dev/null
+              printf "[%-5s]%*s%s%s\n" "${cur_L}" "${indent}" " " "${line}"
+              if [ ${cur_l} -le ${max_level} ]; then
+                  # Only print to console (fd #6) if log level is high enough.
+                  printf "${CT_LOG_PROGRESS_BAR:+\r}[%-5s]%*s%s%s\n" "${cur_L}" "${indent}" " " "${line}" >&6
+              fi
+              if [ "${CT_LOG_PROGRESS_BAR}" = "y" ]; then
+                  printf "\r[%02d:%02d] %s " $((SECONDS/60)) $((SECONDS%60)) "${_prog_bar[$((_prog_bar_cpt/10))]}" >&6
+                  _prog_bar_cpt=$(((_prog_bar_cpt+1)%40))
+              fi
+          done
+        )
+
+    return 0
+}
+
+# Execute an action, and log its messages
+# It is possible to even log local variable assignments (a-la: var=val ./cmd opts)
+# Usage: CT_DoExecLog <level> [VAR=val...] <command> [parameters...]
+CT_DoExecLog() {
+    local level="$1"
+    local cur_cmd
+    local ret
+    shift
+    (
+    for i in "$@"; do
+        cur_cmd+="'${i}' "
+    done
+    while true; do
+        case "${1}" in
+            *=*)    eval export "'${1}'"; shift;;
+            *)      break;;
+        esac
+    done
+    # This while-loop goes hand-in-hand with the ERR trap handler:
+    # - if the command terminates successfully, then we hit the break
+    #   statement, and we exit the loop
+    # - if the command terminates in error, then the ERR handler kicks
+    #   in, then:
+    #     - if the user did *not* ask for interactive debugging, the ERR
+    #       handler exits, and we hit the end of the sub-shell
+    #     - if the user did ask for interactive debugging, the ERR handler
+    #       spawns a shell. Upon termination of this shell, the ERR handler
+    #       examines the exit status of the shell:
+    #         - if 1, the ERR handler returns; then we hit the else statement,
+    #           then the break, and we exit the 'while' loop, to continue the
+    #           build;
+    #         - if 2, the ERR handler touches the repeat file, and returns;
+    #           then we hit the if statement, and we loop for one more
+    #           iteration;
+    #         - if 3, the ERR handler exits with the command's exit status,
+    #           and we're dead;
+    #         - for any other exit status of the shell, the ERR handler
+    #           prints an informational message, and respawns the shell
+    #
+    # This allows a user to get an interactive shell that has the same
+    # environment (PATH and so on) that the failed command was ran with.
+    while true; do
+        rm -f "${CT_BUILD_DIR}/repeat"
+        CT_DoLog DEBUG "==> Executing: ${cur_cmd}"
+        "${@}" 2>&1 |CT_DoLog "${level}"
+        ret="${?}"
+        if [ -f "${CT_BUILD_DIR}/repeat" ]; then
+            rm -f "${CT_BUILD_DIR}/repeat"
+            continue
+        elif [ -f "${CT_BUILD_DIR}/skip" ]; then
+            rm -f "${CT_BUILD_DIR}/skip"
+            ret=0
+            break
+        else
+            break
+        fi
+    done
+    exit ${ret}
+    )
+    # Catch failure of the sub-shell
+    [ $? -eq 0 ]
+}
+
+# Tail message to be logged whatever happens
+# Usage: CT_DoEnd <level>
+CT_DoEnd()
+{
+    local level="$1"
+    CT_STOP_DATE=$(CT_DoDate +%s%N)
+    CT_STOP_DATE_HUMAN=$(CT_DoDate +%Y%m%d.%H%M%S)
+    if [ "${level}" != "ERROR" ]; then
+        CT_DoLog "${level:-INFO}" "Build completed at ${CT_STOP_DATE_HUMAN}"
+    fi
+    elapsed=$((CT_STOP_DATE-CT_STAR_DATE))
+    elapsed_min=$((elapsed/(60*1000*1000*1000)))
+    elapsed_sec=$(printf "%02d" $(((elapsed%(60*1000*1000*1000))/(1000*1000*1000))))
+    elapsed_csec=$(printf "%02d" $(((elapsed%(1000*1000*1000))/(10*1000*1000))))
+    CT_DoLog ${level:-INFO} "(elapsed: ${elapsed_min}:${elapsed_sec}.${elapsed_csec})"
+}
+
+# Remove entries referring to . and other relative paths
+# Usage: CT_SanitizePath
+CT_SanitizePath() {
+    local new
+    local p
+    local IFS=:
+    for p in $PATH; do
+        # Only accept absolute paths;
+        # Note: as a special case the empty string in PATH is equivalent to .
+        if [ -n "${p}" -a -z "${p%%/*}" ]; then
+            new="${new}${new:+:}${p}"
+        fi
+    done
+    PATH="${new}"
+}
+
+# Sanitise the directory name contained in the variable passed as argument:
+# - remove duplicate /
+# Usage: CT_SanitiseVarDir CT_PREFIX_DIR
+CT_SanitiseVarDir() {
+    local var
+    local old_dir
+    local new_dir
+
+    for var in "$@"; do
+        eval "old_dir=\"\${${var}}\""
+        new_dir="$( printf "${old_dir}"     \
+                    |@@CT_sed@@ -r -e 's:/+:/:g;'  \
+                  )"
+        eval "${var}=\"${new_dir}\""
+        CT_DoLog DEBUG "Sanitised '${var}': '${old_dir}' -> '${new_dir}'"
+    done
+}
+
+# Abort the execution with an error message
+# Usage: CT_Abort <message>
+CT_Abort() {
+    CT_DoLog ERROR "$1"
+    false
+}
+
+# Test a condition, and print a message if satisfied
+# Usage: CT_Test <message> <tests>
+CT_Test() {
+    local ret
+    local m="$1"
+    shift
+    CT_DoLog DEBUG "Testing '! ( $* )'"
+    test "$@" && CT_DoLog WARN "$m"
+    return 0
+}
+
+# Test a condition, and abort with an error message if satisfied
+# Usage: CT_TestAndAbort <message> <tests>
+CT_TestAndAbort() {
+    local m="$1"
+    shift
+    CT_DoLog DEBUG "Testing '! ( $* )'"
+    test "$@" && CT_Abort "$m"
+    return 0
+}
+
+# Test a condition, and abort with an error message if not satisfied
+# Usage: CT_TestAndAbort <message> <tests>
+CT_TestOrAbort() {
+    local m="$1"
+    shift
+    CT_DoLog DEBUG "Testing '$*'"
+    test "$@" || CT_Abort "$m"
+    return 0
+}
+
+# Test the presence of a tool, or abort if not found
+# Usage: CT_HasOrAbort <tool>
+CT_HasOrAbort() {
+    CT_TestAndAbort "'${1}' not found and needed for successful toolchain build." -z "$(CT_Which "${1}")"
+    return 0
+}
+
+# Search a program: wrap "which" for those system where "which"
+# verbosely says there is no match (such as on Mandriva).
+# Usage: CT_Which <filename>
+CT_Which() {
+  which "$1" 2>/dev/null || true
+}
+
+# Get current date with nanosecond precision
+# On those system not supporting nanosecond precision, faked with rounding down
+# to the highest entire second
+# Usage: CT_DoDate <fmt>
+CT_DoDate() {
+    date "$1" |@@CT_sed@@ -r -e 's/%?N$/000000000/;'
+}
+
+CT_STEP_COUNT=1
+CT_STEP_MESSAGE[${CT_STEP_COUNT}]="(top-level)"
+# Memorise a step being done so that any error is caught
+# Usage: CT_DoStep <loglevel> <message>
+CT_DoStep() {
+    local start=$(CT_DoDate +%s%N)
+    CT_DoLog "$1" "================================================================="
+    CT_DoLog "$1" "$2"
+    CT_STEP_COUNT=$((CT_STEP_COUNT+1))
+    CT_STEP_LEVEL[${CT_STEP_COUNT}]="$1"; shift
+    CT_STEP_START[${CT_STEP_COUNT}]="${start}"
+    CT_STEP_MESSAGE[${CT_STEP_COUNT}]="$1"
+    return 0
+}
+
+# End the step just being done
+# Usage: CT_EndStep
+CT_EndStep() {
+    local stop=$(CT_DoDate +%s%N)
+    local duration=$(printf "%032d" $((stop-${CT_STEP_START[${CT_STEP_COUNT}]})) |@@CT_sed@@ -r -e 's/([[:digit:]]{2})[[:digit:]]{7}$/\.\1/; s/^0+//; s/^\./0\./;')
+    local elapsed=$(printf "%02d:%02d" $((SECONDS/60)) $((SECONDS%60)))
+    local level="${CT_STEP_LEVEL[${CT_STEP_COUNT}]}"
+    local message="${CT_STEP_MESSAGE[${CT_STEP_COUNT}]}"
+    CT_STEP_COUNT=$((CT_STEP_COUNT-1))
+    CT_DoLog "${level}" "${message}: done in ${duration}s (at ${elapsed})"
+    return 0
+}
+
+# Pushes into a directory, and pops back
+CT_Pushd() {
+    CT_DoLog DEBUG "Entering '$1'"
+    pushd "$1" >/dev/null 2>&1
+}
+CT_Popd() {
+    popd >/dev/null 2>&1
+}
+
+# Create a dir and cd or pushd into it
+# Usage: CT_mkdir_cd <dir/to/create>
+#        CT_mkdir_pushd <dir/to/create>
+CT_mkdir_cd() {
+    local dir="${1}"
+
+    mkdir -p "${dir}"
+    cd "${dir}"
+}
+CT_mkdir_pushd() {
+    local dir="${1}"
+
+    mkdir -p "${dir}"
+    CT_Pushd "${dir}"
+}
+
+# Creates a temporary directory
+# $1: variable to assign to
+# Usage: CT_MktempDir foo
+CT_MktempDir() {
+    # Some mktemp do not allow more than 6 Xs
+    eval "$1"=$(mktemp -q -d "${CT_BUILD_DIR}/tmp.XXXXXX")
+    CT_TestOrAbort "Could not make temporary directory" -n "${!1}" -a -d "${!1}"
+    CT_DoLog DEBUG "Made temporary directory '${!1}'"
+    return 0
+}
+
+# Removes one or more directories, even if it is read-only, or its parent is
+# Usage: CT_DoForceRmdir dir [...]
+CT_DoForceRmdir() {
+    local dir
+    local mode
+    for dir in "${@}"; do
+        [ -d "${dir}" ] || continue
+        case "$CT_SYS_OS" in
+            Linux|CYGWIN*)
+                mode="$(stat -c '%a' "$(dirname "${dir}")")"
+                ;;
+            Darwin|*BSD)
+                mode="$(stat -f '%Lp' "$(dirname "${dir}")")"
+                ;;
+            *)
+                CT_Abort "Unhandled host OS $CT_SYS_OS"
+                ;;
+        esac
+        CT_DoExecLog ALL chmod u+w "$(dirname "${dir}")"
+        CT_DoExecLog ALL chmod -R u+w "${dir}"
+        CT_DoExecLog ALL rm -rf "${dir}"
+        CT_DoExecLog ALL chmod ${mode} "$(dirname "${dir}")"
+    done
+}
+
+# Echoes the specified string on stdout until the pipe breaks.
+# Doesn't fail
+# $1: string to echo
+# Usage: CT_DoYes "" |make oldconfig
+CT_DoYes() {
+    yes "$1" || true
+}
+
+# Add the specified directory to LD_LIBRARY_PATH, and export it
+# If the specified patch is already present, just export
+# $1: path to add
+# $2: add as 'first' or 'last' path, 'first' is assumed if $2 is empty
+# Usage CT_SetLibPath /some/where/lib [first|last]
+CT_SetLibPath() {
+    local path="$1"
+    local pos="$2"
+
+    case ":${LD_LIBRARY_PATH}:" in
+        *:"${path}":*)  ;;
+        *)  case "${pos}" in
+                last)
+                    CT_DoLog DEBUG "Adding '${path}' at end of LD_LIBRARY_PATH"
+                    LD_LIBRARY_PATH="${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}${path}"
+                    ;;
+                first|"")
+                    CT_DoLog DEBUG "Adding '${path}' at start of LD_LIBRARY_PATH"
+                    LD_LIBRARY_PATH="${path}${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}"
+                    ;;
+                *)
+                    CT_Abort "Incorrect position '${pos}' to add '${path}' to LD_LIBRARY_PATH"
+                    ;;
+            esac
+            ;;
+    esac
+    CT_DoLog DEBUG "==> LD_LIBRARY_PATH='${LD_LIBRARY_PATH}'"
+    export LD_LIBRARY_PATH
+}
+
+# Build up the list of allowed tarball extensions
+# Add them in the prefered order; most preferred comes first
+CT_DoListTarballExt() {
+    if [ "${CT_CONFIGURE_has_xz}" = "y" ]; then
+        printf ".tar.xz\n"
+    fi
+    if [    "${CT_CONFIGURE_has_lzma}" = "y"    \
+         -o "${CT_CONFIGURE_has_xz}" = "y" ]; then
+        printf ".tar.lzma\n"
+    fi
+    printf ".tar.bz2\n"
+    printf ".tar.gz\n.tgz\n"
+    printf ".tar\n"
+    printf ".zip\n"
+}
+
+# Get the file name extension of a component
+# Usage: CT_GetFileExtension <component_name-component_version> [extension]
+# If found, echoes the extension to stdout, and return 0
+# If not found, echoes nothing on stdout, and return !0.
+CT_GetFileExtension() {
+    local ext
+    local file="$1"
+    shift
+    local first_ext="$1"
+
+    # we need to also check for an empty extension for those very
+    # peculiar components that don't have one (such as sstrip from
+    # buildroot).
+    for ext in ${first_ext} $(CT_DoListTarballExt) /.git ''; do
+        if [ -e "${CT_TARBALLS_DIR}/${file}${ext}" ]; then
+            echo "${ext}"
+            exit 0
+        fi
+    done
+
+    exit 1
+}
+
+# Try to retrieve the specified URL (HTTP or FTP)
+# Usage: CT_DoGetFile <URL>
+# This functions always returns true (0), as it can be legitimate not
+# to find the requested URL (think about snapshots, different layouts
+# for different gcc versions, etc...).
+CT_DoGetFile() {
+    local url="${1}"
+    local dest="${CT_TARBALLS_DIR}/${url##*/}"
+    local tmp="${dest}.tmp-dl"
+
+    # Remove potential left-over from a previous run
+    rm -f "${tmp}"
+
+    # We also retry a few times, in case there is a transient error (eg. behind
+    # a dynamic IP that changes during the transfer...)
+    # With automated download as we are doing, it can be very dangerous to
+    # continue the downloads. It's far better to simply overwrite the
+    # destination file.
+    # Some company networks have firewalls to connect to the internet, but it's
+    # not easy to detect them, so force a global ${CT_CONNECT_TIMEOUT}-second
+    # timeout.
+    if [ ${CT_CONNECT_TIMEOUT} = -1 ]; then
+        T=
+    else
+        T="-T ${CT_CONNECT_TIMEOUT}"
+    fi
+    if CT_DoExecLog ALL wget --passive-ftp --tries=3 -nc    \
+                             --progress=dot:binary          \
+                             ${T}                           \
+                             -O "${tmp}"                    \
+                             "${url}"
+    then
+        # Success, we got it, good!
+        mv "${tmp}" "${dest}"
+        CT_DoLog DEBUG "Got it from: \"${url}\""
+    else
+        # Woops...
+        rm -f "${tmp}"
+        CT_DoLog DEBUG "Not at this location: \"${url}\""
+    fi
+}
+
+# This function tries to retrieve a tarball form a local directory
+# Usage: CT_GetLocal <basename> [.extension]
+CT_GetLocal() {
+    local basename="$1"
+    local first_ext="$2"
+    local ext
+
+    # Do we already have it in *our* tarballs dir?
+    if ext="$( CT_GetFileExtension "${basename}" ${first_ext} )"; then
+        CT_DoLog DEBUG "Already have '${basename}'"
+        return 0
+    fi
+
+    if [ -n "${CT_LOCAL_TARBALLS_DIR}" ]; then
+        CT_DoLog DEBUG "Trying to retrieve an already downloaded copy of '${basename}'"
+        # We'd rather have a bzip2'ed tarball, then gzipped tarball, plain tarball,
+        # or, as a failover, a file without extension.
+        for ext in ${first_ext} $(CT_DoListTarballExt) ''; do
+            CT_DoLog DEBUG "Trying '${CT_LOCAL_TARBALLS_DIR}/${basename}${ext}'"
+            if [ -r "${CT_LOCAL_TARBALLS_DIR}/${basename}${ext}" -a \
+                 "${CT_FORCE_DOWNLOAD}" != "y" ]; then
+                CT_DoLog DEBUG "Got '${basename}' from local storage"
+                CT_DoExecLog ALL ln -s "${CT_LOCAL_TARBALLS_DIR}/${basename}${ext}" "${CT_TARBALLS_DIR}/${basename}${ext}"
+                return 0
+            fi
+        done
+    fi
+    return 1
+}
+
+# This function gets the custom source from either a tarball or directory
+# Usage: CT_GetCustom <component> <custom_version> <custom_location>
+CT_GetCustom() {
+    local custom_component="$1"
+    local custom_version="$2"
+    local custom_location="$3"
+    local custom_name="${custom_component}-${custom_version}"
+
+    CT_TestAndAbort "${custom_name}: CT_CUSTOM_LOCATION_ROOT_DIR or ${custom_component}'s CUSTOM_LOCATION must be set." \
+                    -z "${CT_CUSTOM_LOCATION_ROOT_DIR}" -a -z "${custom_location}"
+
+    if [ -n "${CT_CUSTOM_LOCATION_ROOT_DIR}" \
+         -a -z "${custom_location}"          ]; then
+        custom_location="${CT_CUSTOM_LOCATION_ROOT_DIR}/${custom_component}"
+    fi
+
+    CT_DoLog EXTRA "Using '${custom_name}' from custom location"
+    if [ ! -d "${custom_location}" ]; then
+        # We need to know the custom tarball extension,
+        # so we can create a properly-named symlink, which
+        # we use later on in 'extract'
+        case "${custom_location}" in
+            *.tar.xz)       custom_name="${custom_name}.tar.xz";;
+            *.tar.bz2)      custom_name="${custom_name}.tar.bz2";;
+            *.tar.gz|*.tgz) custom_name="${custom_name}.tar.gz";;
+            *.tar)          custom_name="${custom_name}.tar";;
+            *)  CT_Abort "Unknown extension for custom tarball '${custom_location}'";;
+        esac
+        CT_DoExecLog DEBUG ln -sf "${custom_location}"  \
+                                  "${CT_TARBALLS_DIR}/${custom_name}"
+    else
+        CT_DoExecLog DEBUG ln -snf "${custom_location}" \
+                                   "${CT_SRC_DIR}/${custom_name}"
+    fi
+}
+
+# This function saves the specified to local storage if possible,
+# and if so, symlinks it for later usage
+# Usage: CT_SaveLocal </full/path/file.name>
+CT_SaveLocal() {
+    local file="$1"
+    local basename="${file##*/}"
+
+    if [ "${CT_SAVE_TARBALLS}" = "y" ]; then
+        CT_DoLog EXTRA "Saving '${basename}' to local storage"
+        # The file may already exist if downloads are forced: remove it first
+        CT_DoExecLog ALL rm -f "${CT_LOCAL_TARBALLS_DIR}/${basename}"
+        CT_DoExecLog ALL mv -f "${file}" "${CT_LOCAL_TARBALLS_DIR}"
+        CT_DoExecLog ALL ln -s "${CT_LOCAL_TARBALLS_DIR}/${basename}" "${file}"
+    fi
+}
+
+# Download the file from one of the URLs passed as argument
+# Usage: CT_GetFile <basename> [.extension] <url> [url ...]
+CT_GetFile() {
+    local ext
+    local -a URLS
+    local url
+    local file="$1"
+    local first_ext
+    shift
+    # If next argument starts with a dot, then this is not an URL,
+    # and we can consider that it is a preferred extension.
+    case "$1" in
+        .*) first_ext="$1"
+            shift
+            ;;
+    esac
+
+    # Does it exist localy?
+    if CT_GetLocal "${file}" ${first_ext}; then
+        return 0
+    fi
+    # No, it does not...
+
+    # If not allowed to download from the Internet, don't
+    if [ "${CT_FORBID_DOWNLOAD}" = "y" ]; then
+        CT_DoLog DEBUG "Not allowed to download from the Internet, aborting ${file} download"
+        return 1
+    fi
+
+    # Try to retrieve the file
+    CT_DoLog EXTRA "Retrieving '${file}'"
+
+    # Add URLs on the LAN mirror
+    if [ "${CT_USE_MIRROR}" = "y" ]; then
+        CT_TestOrAbort "Please set the mirror base URL" -n "${CT_MIRROR_BASE_URL}"
+        URLS+=( "${CT_MIRROR_BASE_URL}/${file%-*}" )
+        URLS+=( "${CT_MIRROR_BASE_URL}" )
+    fi
+
+    if [ "${CT_FORCE_MIRROR}" != "y" ]; then
+        URLS+=( "${@}" )
+    fi
+
+    # Scan all URLs in turn, and try to grab a tarball from there
+    # Do *not* try git trees (ext=/.git), this is handled in a specific
+    # wrapper, below
+    for ext in ${first_ext} $(CT_DoListTarballExt) ''; do
+        # Try all urls in turn
+        for url in "${URLS[@]}"; do
+            [ -n "${url}" ] || continue
+            CT_DoLog DEBUG "Trying '${url}/${file}${ext}'"
+            CT_DoGetFile "${url}/${file}${ext}"
+            if [ -f "${CT_TARBALLS_DIR}/${file}${ext}" ]; then
+                CT_DoLog DEBUG "Got '${file}' from the Internet"
+                CT_SaveLocal "${CT_TARBALLS_DIR}/${file}${ext}"
+                return 0
+            fi
+        done
+    done
+
+    # Just return error, someone may want to catch and handle the error
+    # (eg. glibc/eglibc add-ons can be missing).
+    return 1
+}
+
+# Checkout from CVS, and build the associated tarball
+# The tarball will be called ${basename}.tar.bz2
+# Prerequisite: either the server does not require password,
+# or the user must already be logged in.
+# 'tag' is the tag to retrieve. Must be specified, but can be empty.
+# If dirname is specified, then module will be renamed to dirname
+# prior to building the tarball.
+# Usage: CT_GetCVS <basename> <url> <module> <tag> [dirname[=subdir]]
+# Note: if '=subdir' is given, then it is used instead of 'module'.
+CT_GetCVS() {
+    local basename="$1"
+    local uri="$2"
+    local module="$3"
+    local tag="${4:+-r ${4}}"
+    local dirname="$5"
+    local tmp_dir
+
+    # First try locally, then the mirror
+    if CT_GetFile "${basename}"; then
+        # Got it! Return early! :-)
+        return 0
+    fi
+
+    if [ "${CT_FORBID_DOWNLOAD}" = "y" ]; then
+        CT_DoLog WARN "Downloads forbidden, not trying cvs retrieval"
+        return 1
+    fi
+
+    CT_MktempDir tmp_dir
+    CT_Pushd "${tmp_dir}"
+
+    CT_DoExecLog ALL cvs -z 9 -d "${uri}" co -P ${tag} "${module}"
+    if [ -n "${dirname}" ]; then
+        case "${dirname}" in
+            *=*)
+                CT_DoExecLog DEBUG mv "${dirname#*=}" "${dirname%%=*}"
+                CT_DoExecLog ALL tar cjf "${CT_TARBALLS_DIR}/${basename}.tar.bz2" "${dirname%%=*}"
+                ;;
+            *)
+                CT_DoExecLog ALL mv "${module}" "${dirname}"
+                CT_DoExecLog ALL tar cjf "${CT_TARBALLS_DIR}/${basename}.tar.bz2" "${dirname:-${module}}"
+                ;;
+        esac
+    fi
+    CT_SaveLocal "${CT_TARBALLS_DIR}/${basename}.tar.bz2"
+
+    CT_Popd
+    CT_DoExecLog ALL rm -rf "${tmp_dir}"
+}
+
+# Check out from SVN, and build the associated tarball
+# The tarball will be called ${basename}.tar.bz2
+# Prerequisite: either the server does not require password,
+# or the user must already be logged in.
+# 'rev' is the revision to retrieve
+# Usage: CT_GetSVN <basename> <url> [rev]
+CT_GetSVN() {
+    local basename="$1"
+    local uri="$2"
+    local rev="$3"
+
+    # First try locally, then the mirror
+    if CT_GetFile "${basename}"; then
+        # Got it! Return early! :-)
+        return 0
+    fi
+
+    if [ "${CT_FORBID_DOWNLOAD}" = "y" ]; then
+        CT_DoLog WARN "Downloads forbidden, not trying svn retrieval"
+        return 1
+    fi
+
+    CT_MktempDir tmp_dir
+    CT_Pushd "${tmp_dir}"
+
+    if ! CT_DoExecLog ALL svn export ${rev:+-r ${rev}} "${uri}" "${basename}"; then
+        CT_DoLog WARN "Could not retrieve '${basename}'"
+        return 1
+    fi
+    CT_DoExecLog ALL tar cjf "${CT_TARBALLS_DIR}/${basename}.tar.bz2" "${basename}"
+    CT_SaveLocal "${CT_TARBALLS_DIR}/${basename}.tar.bz2"
+
+    CT_Popd
+    CT_DoExecLog ALL rm -rf "${tmp_dir}"
+}
+
+# Clone a git tree
+# Tries the given URLs in turn until one can get cloned. No tarball will be created.
+# Prerequisites: either the server does not require password,
+# or the user has already taken any action to authenticate to the server.
+# The cloned tree will *not* be stored in the local tarballs dir!
+# Usage: CT_GetGit <basename> <cset> <url>
+CT_GetGit() {
+    local basename="${1}"
+    local cset="${2}"
+    local url="${3}"
+    local file="${basename}-${cset}.tar.gz"
+    local dir="${CT_TARBALLS_DIR}/${basename}-${cset}.git"
+    local dest="${CT_TARBALLS_DIR}/${file}"
+    local tmp="${CT_TARBALLS_DIR}/${file}.tmp-dl"
+
+    # Do we alreadyhave it?
+    if CT_GetLocal "${file}"; then
+        return 0
+    fi
+    # Nope...
+
+    if [ "${CT_FORBID_DOWNLOAD}" = "y" ]; then
+        CT_DoLog WARN "Downloads forbidden, not trying git retrieval"
+        return 1
+    fi
+
+    # Add URLs on the LAN mirror
+    # We subvert the normal download method, just to look for
+    # looking at the local mirror
+    if CT_GetFile "${basename}-${cset}" .tar.gz; then
+        return 0
+    fi
+
+    CT_DoLog EXTRA "Retrieving '${basename}-${cset}' (git)"
+
+    # Remove potential left-over from a previous run
+    CT_DoExecLog ALL rm -rf "${tmp}.tar.gz" "${tmp}.tar" "${tmp}" "${dir}"
+
+    if CT_DoExecLog ALL git clone "${url}" "${dir}"; then
+        # Yep, cloned OK
+        CT_Pushd "${dir}"
+        CT_DoExecLog ALL git archive --format=tar                       \
+                                     --prefix="${basename}-${cset}/"    \
+                                     -o "${tmp}.tar"                    \
+                                     "${cset}"
+        CT_DoExecLog ALL gzip -9 "${tmp}.tar"
+        CT_DoExecLog ALL mv -f "${tmp}.tar.gz" "${dest}"
+        CT_SaveLocal "${dest}"
+        CT_DoExecLog ALL rm -rf "${tmp}.tar.gz" "${tmp}.tar" "${tmp}" "${dir}"
+        CT_Popd
+    else
+        # Woops...
+        CT_DoExecLog ALL rm -rf "${dir}"
+        CT_DoLog Debug "Could not clone '${basename}'"
+        return 1
+    fi
+}
+
+# Extract a tarball
+# Some tarballs need to be extracted in specific places. Eg.: glibc addons
+# must be extracted in the glibc directory; uCLibc locales must be extracted
+# in the extra/locale sub-directory of uClibc. This is taken into account
+# by the caller, that did a 'cd' into the correct path before calling us
+# and sets nochdir to 'nochdir'.
+# Note also that this function handles the git trees!
+# Usage: CT_Extract [nochdir] <basename> [options]
+# where 'options' are dependent on the source (eg. git branch/tag...)
+CT_Extract() {
+    local nochdir="$1"
+    local basename
+    local ext
+    local lzma_prog
+    local -a tar_opts
+
+    if [ "${nochdir}" = "nochdir" ]; then
+        shift
+        nochdir="$(pwd)"
+    else
+        nochdir="${CT_SRC_DIR}"
+    fi
+
+    basename="$1"
+    shift
+
+    if ! ext="$(CT_GetFileExtension "${basename}")"; then
+        CT_DoLog WARN "'${basename}' not found in '${CT_TARBALLS_DIR}'"
+        return 1
+    fi
+    local full_file="${CT_TARBALLS_DIR}/${basename}${ext}"
+
+    # Check if already extracted
+    if [ -e "${CT_SRC_DIR}/.${basename}.extracted" ]; then
+        CT_DoLog DEBUG "Already extracted '${basename}'"
+        return 0
+    fi
+
+    # Check if previously partially extracted
+    if [ -e "${CT_SRC_DIR}/.${basename}.extracting" ]; then
+        CT_DoLog ERROR "The '${basename}' sources were partially extracted."
+        CT_DoLog ERROR "Please remove first:"
+        CT_DoLog ERROR " - the source dir for '${basename}', in '${CT_SRC_DIR}'"
+        CT_DoLog ERROR " - the file '${CT_SRC_DIR}/.${basename}.extracting'"
+        CT_Abort "I'll stop now to avoid any carnage..."
+    fi
+    CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.${basename}.extracting"
+
+    CT_Pushd "${nochdir}"
+
+    CT_DoLog EXTRA "Extracting '${basename}'"
+    CT_DoExecLog FILE mkdir -p "${basename}"
+    tar_opts=( "--strip-components=1" )
+    tar_opts+=( "-C" "${basename}" )
+    tar_opts+=( "-xv" )
+
+    # One note here:
+    # - lzma can be handled either with 'xz' or 'lzma'
+    # - we get lzma tarball only if either or both are available
+    # - so, if we get an lzma tarball, and either 'xz' or 'lzma' is
+    #   missing, we can assume the other is available
+    if [ "${CT_CONFIGURE_has_lzma}" = "y" ]; then
+        lzma_prog="lzma -fdc"
+    else
+        lzma_prog="xz -fdc"
+    fi
+    case "${ext}" in
+        .tar.xz)      xz -fdc "${full_file}" | CT_DoExecLog FILE tar "${tar_opts[@]}" -f -;;
+        .tar.lzma)    ${lzma_prog} "${full_file}" | CT_DoExecLog FILE tar "${tar_opts[@]}" -f -;;
+        .tar.bz2)     bzip2 -dc "${full_file}" | CT_DoExecLog FILE tar "${tar_opts[@]}" -f -;;
+        .tar.gz|.tgz) gzip -dc "${full_file}" | CT_DoExecLog FILE tar "${tar_opts[@]}" -f -;;
+        .tar)         CT_DoExecLog FILE tar "${tar_opts[@]}" -f "${full_file}";;
+        .zip)         CT_DoExecLog FILE unzip "${@}" "${full_file}";;
+        /.git)        CT_ExtractGit "${basename}" "${@}";;
+        *)            CT_DoLog WARN "Don't know how to handle '${basename}${ext}': unknown extension"
+                      return 1
+                      ;;
+    esac
+
+    # Don't mark as being extracted for git
+    case "${ext}" in
+        /.git)  ;;
+        *)      CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.${basename}.extracted";;
+    esac
+    CT_DoExecLog DEBUG rm -f "${CT_SRC_DIR}/.${basename}.extracting"
+
+    CT_Popd
+}
+
+# Create a working git clone of a local git repository
+# Usage: CT_ExtractGit <basename> [ref]
+# where 'ref' is the reference to use:
+#   the full name of a branch, like "remotes/origin/branch_name"
+#   a date as understandable by git, like "YYYY-MM-DD[ hh[:mm[:ss]]]"
+#   a tag name
+# If 'ref' is not given, the current repository HEAD will be used
+CT_ExtractGit() {
+    local basename="${1}"
+    local ref="${2}"
+    local repo
+    local ref_type
+
+    # pushd now to be able to get git revlist in case ref is a date
+    repo="${CT_TARBALLS_DIR}/${basename}"
+    CT_Pushd "${repo}"
+
+    # What kind of reference is ${ref} ?
+    if [ -z "${ref}" ]; then
+        ref_type=head
+        ref=$(git rev-list -n1 HEAD)
+    elif git tag |@@CT_grep@@ -E "^${ref}$" >/dev/null 2>&1; then
+        ref_type=tag
+    elif git branch -a --no-color | @@CT_grep@@ -E "^. ${ref}$" >/dev/null 2>&1; then
+        ref_type=branch
+    elif date -d "${ref}" >/dev/null 2>&1; then
+        ref_type=date
+        ref=$(git rev-list -n1 --before="${ref}")
+    else
+        CT_Abort "Reference '${ref}' is an incorrect git reference: neither tag, branch nor date"
+    fi
+
+    CT_Popd
+
+    CT_DoExecLog FILE rmdir "${basename}"
+    case "${ref_type}" in
+        branch) CT_DoExecLog FILE git clone -b "${ref}" "${repo}" "${basename}" ;;
+        *)      CT_DoExecLog FILE git clone "${repo}" "${basename}"
+                CT_Pushd "${basename}"
+                CT_DoExecLog FILE git checkout "${ref}"
+                CT_Popd
+                ;;
+    esac
+}
+
+# Patches the specified component
+# See CT_Extract, above, for explanations on 'nochdir'
+# Usage: CT_Patch [nochdir] <packagename> <packageversion>
+# If the package directory is *not* packagename-packageversion, then
+# the caller must cd into the proper directory first, and call us
+# with nochdir
+CT_Patch() {
+    local nochdir="$1"
+    local pkgname
+    local version
+    local pkgdir
+    local base_file
+    local ver_file
+    local d
+    local -a patch_dirs
+    local bundled_patch_dir
+    local local_patch_dir
+    local bundled_exp_patch_dir
+    local local_exp_patch_dir
+
+    if [ "${nochdir}" = "nochdir" ]; then
+        shift
+        pkgname="$1"
+        version="$2"
+        pkgdir="${pkgname}-${version}"
+        nochdir="$(pwd)"
+    else
+        pkgname="$1"
+        version="$2"
+        pkgdir="${pkgname}-${version}"
+        nochdir="${CT_SRC_DIR}/${pkgdir}"
+    fi
+
+    # Check if already patched
+    if [ -e "${CT_SRC_DIR}/.${pkgdir}.patched" ]; then
+        CT_DoLog DEBUG "Already patched '${pkgdir}'"
+        return 0
+    fi
+
+    # Check if already partially patched
+    if [ -e "${CT_SRC_DIR}/.${pkgdir}.patching" ]; then
+        CT_DoLog ERROR "The '${pkgdir}' sources were partially patched."
+        CT_DoLog ERROR "Please remove first:"
+        CT_DoLog ERROR " - the source dir for '${pkgdir}', in '${CT_SRC_DIR}'"
+        CT_DoLog ERROR " - the file '${CT_SRC_DIR}/.${pkgdir}.extracted'"
+        CT_DoLog ERROR " - the file '${CT_SRC_DIR}/.${pkgdir}.patching'"
+        CT_Abort "I'll stop now to avoid any carnage..."
+    fi
+    touch "${CT_SRC_DIR}/.${pkgdir}.patching"
+
+    CT_Pushd "${nochdir}"
+
+    CT_DoLog EXTRA "Patching '${pkgdir}'"
+
+    bundled_patch_dir="${CT_LIB_DIR}/patches/${pkgname}/${version}"
+    local_patch_dir="${CT_LOCAL_PATCH_DIR}/${pkgname}/${version}"
+
+    # Check for experimental patches, if enabled.
+    if [ "${CT_EXPERIMENTAL_PATCHES}" = "y" ]; then
+        bundled_exp_patch_dir="${CT_LIB_DIR}/patches/experimental/${pkgname}/${version}"
+        local_exp_patch_dir="${CT_LOCAL_PATCH_DIR}/experimental/${pkgname}/${version}"
+    fi
+
+    case "${CT_PATCH_ORDER}" in
+        bundled)        patch_dirs=("${bundled_patch_dir}" "${bundled_exp_patch_dir}");;
+        local)          patch_dirs=("${local_patch_dir}" "${local_exp_patch_dir}");;
+        bundled,local)  patch_dirs=("${bundled_patch_dir}" "${bundled_exp_patch_dir}" "${local_patch_dir}" "${local_exp_patch_dir}");;
+        local,bundled)  patch_dirs=("${local_patch_dir}" "${local_exp_patch_dir}" "${bundled_patch_dir}" "${bundled_exp_patch_dir}");;
+        none)           patch_dirs=;;
+    esac
+
+    for d in "${patch_dirs[@]}"; do
+        CT_DoLog DEBUG "Looking for patches in '${d}'..."
+        if [ -n "${d}" -a -d "${d}" ]; then
+            for p in "${d}"/*.patch; do
+                if [ -f "${p}" ]; then
+                    CT_DoExecLog ALL patch --no-backup-if-mismatch -g0 -F1 -p1 -f -i "${p}"
+                fi
+            done
+            if [ "${CT_PATCH_SINGLE}" = "y" ]; then
+                break
+            fi
+        fi
+    done
+
+    if [ "${CT_OVERIDE_CONFIG_GUESS_SUB}" = "y" ]; then
+        CT_DoLog ALL "Overiding config.guess and config.sub"
+        for cfg in config_guess config_sub; do
+            eval ${cfg}="${CT_LIB_DIR}/scripts/${cfg/_/.}"
+            [ -e "${CT_TOP_DIR}/scripts/${cfg/_/.}" ] && eval ${cfg}="${CT_TOP_DIR}/scripts/${cfg/_/.}"
+            # Can't use CT_DoExecLog because of the '{} \;' to be passed un-mangled to find
+            find . -type f -name "${cfg/_/.}" -exec cp -v "${!cfg}" {} \; |CT_DoLog ALL
+        done
+    fi
+
+    CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.${pkgdir}.patched"
+    CT_DoExecLog DEBUG rm -f "${CT_SRC_DIR}/.${pkgdir}.patching"
+
+    CT_Popd
+}
+
+# Two wrappers to call config.(guess|sub) either from CT_TOP_DIR or CT_LIB_DIR.
+# Those from CT_TOP_DIR, if they exist, will be be more recent than those from CT_LIB_DIR.
+CT_DoConfigGuess() {
+    if [ -x "${CT_TOP_DIR}/scripts/config.guess" ]; then
+        "${CT_TOP_DIR}/scripts/config.guess"
+    else
+        "${CT_LIB_DIR}/scripts/config.guess"
+    fi
+}
+
+CT_DoConfigSub() {
+    if [ -x "${CT_TOP_DIR}/scripts/config.sub" ]; then
+        "${CT_TOP_DIR}/scripts/config.sub" "$@"
+    else
+        "${CT_LIB_DIR}/scripts/config.sub" "$@"
+    fi
+}
+
+# Compute the target tuple from what is provided by the user
+# Usage: CT_DoBuildTargetTuple
+# In fact this function takes the environment variables to build the target
+# tuple. It is needed both by the normal build sequence, as well as the
+# sample saving sequence.
+CT_DoBuildTargetTuple() {
+    # Set the endianness suffix, and the default endianness gcc option
+    case "${CT_ARCH_ENDIAN}" in
+        big)
+            target_endian_eb=eb
+            target_endian_be=be
+            target_endian_el=
+            target_endian_le=
+            CT_ARCH_ENDIAN_CFLAG="-mbig-endian"
+            CT_ARCH_ENDIAN_LDFLAG="-Wl,-EB"
+            ;;
+        little)
+            target_endian_eb=
+            target_endian_be=
+            target_endian_el=el
+            target_endian_le=le
+            CT_ARCH_ENDIAN_CFLAG="-mlittle-endian"
+            CT_ARCH_ENDIAN_LDFLAG="-Wl,-EL"
+            ;;
+    esac
+
+    # Set the bitness suffix
+    case "${CT_ARCH_BITNESS}" in
+        32)
+            target_bits_32=32
+            target_bits_64=
+            ;;
+        64)
+            target_bits_32=
+            target_bits_64=64
+            ;;
+    esac
+
+    # Build the default architecture tuple part
+    CT_TARGET_ARCH="${CT_ARCH}${CT_ARCH_SUFFIX}"
+
+    # Set defaults for the system part of the tuple. Can be overriden
+    # by architecture-specific values.
+    case "${CT_LIBC}" in
+        *glibc) CT_TARGET_SYS=gnu;;
+        uClibc) CT_TARGET_SYS=uclibc;;
+        *)      CT_TARGET_SYS=elf;;
+    esac
+
+    # Set the default values for ARCH, ABI, CPU, TUNE, FPU and FLOAT
+    unset CT_ARCH_ARCH_CFLAG CT_ARCH_ABI_CFLAG CT_ARCH_CPU_CFLAG CT_ARCH_TUNE_CFLAG CT_ARCH_FPU_CFLAG CT_ARCH_FLOAT_CFLAG
+    unset CT_ARCH_WITH_ARCH CT_ARCH_WITH_ABI CT_ARCH_WITH_CPU CT_ARCH_WITH_TUNE CT_ARCH_WITH_FPU CT_ARCH_WITH_FLOAT
+    [ "${CT_ARCH_ARCH}"     ] && { CT_ARCH_ARCH_CFLAG="-march=${CT_ARCH_ARCH}";  CT_ARCH_WITH_ARCH="--with-arch=${CT_ARCH_ARCH}"; }
+    [ "${CT_ARCH_ABI}"      ] && { CT_ARCH_ABI_CFLAG="-mabi=${CT_ARCH_ABI}";     CT_ARCH_WITH_ABI="--with-abi=${CT_ARCH_ABI}";    }
+    [ "${CT_ARCH_CPU}"      ] && { CT_ARCH_CPU_CFLAG="-mcpu=${CT_ARCH_CPU}";     CT_ARCH_WITH_CPU="--with-cpu=${CT_ARCH_CPU}";    }
+    [ "${CT_ARCH_TUNE}"     ] && { CT_ARCH_TUNE_CFLAG="-mtune=${CT_ARCH_TUNE}";  CT_ARCH_WITH_TUNE="--with-tune=${CT_ARCH_TUNE}"; }
+    [ "${CT_ARCH_FPU}"      ] && { CT_ARCH_FPU_CFLAG="-mfpu=${CT_ARCH_FPU}";     CT_ARCH_WITH_FPU="--with-fpu=${CT_ARCH_FPU}";    }
+
+    case "${CT_ARCH_FLOAT}" in
+        hard)
+            CT_ARCH_FLOAT_CFLAG="-mhard-float"
+            CT_ARCH_WITH_FLOAT="--with-float=hard"
+            ;;
+        soft)
+            CT_ARCH_FLOAT_CFLAG="-msoft-float"
+            CT_ARCH_WITH_FLOAT="--with-float=soft"
+            ;;
+        softfp)
+            CT_ARCH_FLOAT_CFLAG="-mfloat-abi=softfp"
+            CT_ARCH_WITH_FLOAT="--with-float=softfp"
+            ;;
+    esac
+
+    # Build the default kernel tuple part
+    CT_TARGET_KERNEL="${CT_KERNEL}"
+
+    # Overide the default values with the components specific settings
+    CT_DoArchTupleValues
+    CT_DoKernelTupleValues
+
+    # Finish the target tuple construction
+    CT_TARGET="${CT_TARGET_ARCH}"
+    CT_TARGET="${CT_TARGET}${CT_TARGET_VENDOR:+-${CT_TARGET_VENDOR}}"
+    CT_TARGET="${CT_TARGET}${CT_TARGET_KERNEL:+-${CT_TARGET_KERNEL}}"
+    CT_TARGET="${CT_TARGET}${CT_TARGET_SYS:+-${CT_TARGET_SYS}}"
+
+    # Sanity checks
+    __sed_alias=""
+    if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
+        __sed_alias=$(echo "${CT_TARGET}" |@@CT_sed@@ -r -e "${CT_TARGET_ALIAS_SED_EXPR}")
+    fi
+    case ":${CT_TARGET_VENDOR}:${CT_TARGET_ALIAS}:${__sed_alias}:" in
+      :*" "*:*:*:) CT_Abort "Don't use spaces in the vendor string, it breaks things.";;
+      :*"-"*:*:*:) CT_Abort "Don't use dashes in the vendor string, it breaks things.";;
+      :*:*" "*:*:) CT_Abort "Don't use spaces in the target alias, it breaks things.";;
+      :*:*:*" "*:) CT_Abort "Don't use spaces in the target sed transform, it breaks things.";;
+    esac
+
+    # Canonicalise it
+    CT_TARGET=$(CT_DoConfigSub "${CT_TARGET}")
+    # Prepare the target CFLAGS
+    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_ENDIAN_CFLAG}"
+    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_ARCH_CFLAG}"
+    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_ABI_CFLAG}"
+    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_CPU_CFLAG}"
+    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_TUNE_CFLAG}"
+    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_FPU_CFLAG}"
+    CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_FLOAT_CFLAG}"
+
+    # Now on for the target LDFLAGS
+    CT_ARCH_TARGET_LDFLAGS="${CT_ARCH_TARGET_LDFLAGS} ${CT_ARCH_ENDIAN_LDFLAG}"
+}
+
+# This function does pause the build until the user strikes "Return"
+# Usage: CT_DoPause [optional_message]
+CT_DoPause() {
+    local foo
+    local message="${1:-Pausing for your pleasure}"
+    CT_DoLog INFO "${message}"
+    read -p "Press 'Enter' to continue, or Ctrl-C to stop..." foo >&6
+    return 0
+}
+
+# This function creates a tarball of the specified directory, but
+# only if it exists
+# Usage: CT_DoTarballIfExists <dir> <tarball_basename> [extra_tar_options [...]]
+CT_DoTarballIfExists() {
+    local dir="$1"
+    local tarball="$2"
+    shift 2
+    local -a extra_tar_opts=( "$@" )
+    local -a compress
+
+    case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
+        y)  compress=( gzip -c -3 - ); tar_ext=.gz;;
+        *)  compress=( cat - );        tar_ext=;;
+    esac
+
+    if [ -d "${dir}" ]; then
+        CT_DoLog DEBUG "  Saving '${dir}'"
+        { tar c -C "${dir}" -v -f - "${extra_tar_opts[@]}" .    \
+          |"${compress[@]}" >"${tarball}.tar${tar_ext}"         ;
+        } 2>&1 |@@CT_sed@@ -r -e 's/^/    /;' |CT_DoLog STATE
+    else
+        CT_DoLog STATE "  Not saving '${dir}': does not exist"
+    fi
+}
+
+# This function extracts a tarball to the specified directory, but
+# only if the tarball exists
+# Usage: CT_DoExtractTarballIfExists <tarball_basename> <dir> [extra_tar_options [...]]
+CT_DoExtractTarballIfExists() {
+    local tarball="$1"
+    local dir="$2"
+    shift 2
+    local -a extra_tar_opts=( "$@" )
+    local -a uncompress
+
+    case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
+        y)  uncompress=( gzip -c -d ); tar_ext=.gz;;
+        *)  uncompress=( cat );        tar_ext=;;
+    esac
+
+    if [ -f "${tarball}.tar${tar_ext}" ]; then
+        CT_DoLog DEBUG "  Restoring '${dir}'"
+        CT_DoForceRmdir "${dir}"
+        CT_DoExecLog DEBUG mkdir -p "${dir}"
+        { "${uncompress[@]}" "${tarball}.tar${tar_ext}"     \
+          |tar x -C "${dir}" -v -f - "${extra_tar_opts[@]}" ;
+        } 2>&1 |@@CT_sed@@ -r -e 's/^/    /;' |CT_DoLog STATE
+    else
+        CT_DoLog STATE "  Not restoring '${dir}': does not exist"
+    fi
+}
+
+# This function saves the state of the toolchain to be able to restart
+# at any one point
+# Usage: CT_DoSaveState <next_step_name>
+CT_DoSaveState() {
+	[ "${CT_DEBUG_CT_SAVE_STEPS}" = "y" ] || return 0
+    local state_name="$1"
+    local state_dir="${CT_STATE_DIR}/${state_name}"
+
+    # Log this to the log level required by the user
+    CT_DoLog ${CT_LOG_LEVEL_MAX} "Saving state to restart at step '${state_name}'..."
+
+    rm -rf "${state_dir}"
+    mkdir -p "${state_dir}"
+
+    CT_DoLog STATE "  Saving environment and aliases"
+    # We must omit shell functions, and some specific bash variables
+    # that break when restoring the environment, later. We could do
+    # all the processing in the awk script, but a sed is easier...
+    set |awk '
+              BEGIN { _p = 1; }
+              $0~/^[^ ]+ \(\)/ { _p = 0; }
+              _p == 1
+              $0 == "}" { _p = 1; }
+              ' |@@CT_sed@@ -r -e '/^BASH_(ARGC|ARGV|LINENO|SOURCE|VERSINFO)=/d;
+                           /^(UID|EUID)=/d;
+                           /^(FUNCNAME|GROUPS|PPID|SHELLOPTS)=/d;' >"${state_dir}/env.sh"
+
+    CT_DoTarballIfExists "${CT_BUILDTOOLS_PREFIX_DIR}" "${state_dir}/buildtools_dir"
+    CT_DoTarballIfExists "${CT_CONFIG_DIR}" "${state_dir}/config_dir"
+    CT_DoTarballIfExists "${CT_PREFIX_DIR}" "${state_dir}/prefix_dir" --exclude '*.log'
+
+    CT_DoLog STATE "  Saving log file"
+    exec >/dev/null
+    case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
+        y)  gzip -3 -c "${tmp_log_file}"  >"${state_dir}/log.gz";;
+        *)  cat "${tmp_log_file}" >"${state_dir}/log";;
+    esac
+    exec >>"${tmp_log_file}"
+}
+
+# This function restores a previously saved state
+# Usage: CT_DoLoadState <state_name>
+CT_DoLoadState(){
+    local state_name="$1"
+    local state_dir="${CT_STATE_DIR}/${state_name}"
+    local old_RESTART="${CT_RESTART}"
+    local old_STOP="${CT_STOP}"
+
+    CT_TestOrAbort "The previous build did not reach the point where it could be restarted at '${CT_RESTART}'" -d "${state_dir}"
+
+    # We need to do something special with the log file!
+    if [ "${CT_LOG_TO_FILE}" = "y" ]; then
+        exec >"${state_dir}/tail.log"
+    fi
+
+    # Log this to the log level required by the user
+    CT_DoLog ${CT_LOG_LEVEL_MAX} "Restoring state at step '${state_name}', as requested."
+
+    CT_DoExtractTarballIfExists "${state_dir}/prefix_dir" "${CT_PREFIX_DIR}"
+    CT_DoExtractTarballIfExists "${state_dir}/config_dir" "${CT_CONFIG_DIR}"
+    CT_DoExtractTarballIfExists "${state_dir}/buildtools_dir" "${CT_BUILDTOOLS_PREFIX_DIR}"
+
+    # Restore the environment, discarding any error message
+    # (for example, read-only bash internals)
+    CT_DoLog STATE "  Restoring environment"
+    . "${state_dir}/env.sh" >/dev/null 2>&1 || true
+
+    # Restore the new RESTART and STOP steps
+    CT_RESTART="${old_RESTART}"
+    CT_STOP="${old_STOP}"
+    unset old_stop old_restart
+
+    CT_DoLog STATE "  Restoring log file"
+    exec >/dev/null
+    case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
+        y)  gzip -dc "${state_dir}/log.gz" >"${tmp_log_file}";;
+        *)  cat "${state_dir}/log" >"${tmp_log_file}";;
+    esac
+    cat "${state_dir}/tail.log" >>"${tmp_log_file}"
+    exec >>"${tmp_log_file}"
+    rm -f "${state_dir}/tail.log"
+}
diff --git a/scripts/xldd.in b/scripts/xldd.in
index c906240..4cbe333 100755
- --- a/scripts/xldd.in
+++ b/scripts/xldd.in
@@ -159,7 +159,7 @@ fi
 sysroot="$( "${gcc}" -print-sysroot 2>/dev/null )"
 if [ -z "${sysroot}" ]; then
     sysroot="$( "${gcc}" -print-file-name=libc.so 2>/dev/null   \
- -                |sed -r -e 's:/usr/lib/libc.so$::;'             \
+                |"${sed}" -r -e 's:/usr/lib/libc.so$::;'             \
               )"
 fi
 if [ -z "${sysroot}" ]; then
- -- 
1.8.5.2 (Apple Git-48)


-----BEGIN PGP SIGNATURE-----
Version: GnuPG/MacGPG2 v2.0.22 (Darwin)
Comment: GPGTools - https://gpgtools.org
Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/

iQIcBAEBCgAGBQJT4ZKSAAoJEHYXgoVc4PRjKYUQAIqsmgvc2vZpG+TNhRhm37cw
DBSoncpD7B9eTiaKhVRVTbeS1Tx/Fh0WvstULbQYmnnF6ovdkW1XNEjBYXLP24T/
pogcxRcr8imHGVXvem+CwQ7pQq83dW/idYnvqd7gqP/Ib/CfibQrJlGxgIXDanNq
4+xLi+Hdjt3eCf2fAkDCQ7e2x0xUZwyAoY42JqgpbZAugk4uyum7c+7N38kQcera
HHve5B4/F87KEHJp+xT07DIcTschYgWYZIz/lmEkgm0ptBDtcJePinZpSUTbrZ+l
UqtbSldLpn/pV0FsnHjSGKsHSXd4ylFhZL5YsFvYteB+6q0lfPe1MkbLdx78YE8K
dITbWcpJAZFX6Ci+l3X70lf5B4wHBR2R+f+FArhCpT76Zf0V+KJFVIsL6dx6qmir
s/LZvJQB4QVzgJvlXBkTe5MTLQ6smMQDhQelQQWJ7oUjqRrgvywv4pdIMoLWLDqc
rgp3540JVVz1Y97/sSUNI+YNUkYDxvpB31RY4T9WTT1YXhP6dnzU8clYfZI9phBc
cuZDnyDPnPojio9BnBMJeqnMojDknyc9npNi5qfjWYm7jqW4bJ5mt/7YFzSMKjcn
E3O58IDdcDM7BNGFYTnaIfP0a5FxpDBYd5y4m13NSUlXMBWADLbJV0W4Y1iq+vA1
cZnevMrW531Eu1KTQUnw
=6M3V
-----END PGP SIGNATURE-----

--
For unsubscribe information see http://sourceware.org/lists.html#faq


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]