scripts/functions
author "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
Tue Nov 16 10:00:27 2010 +0100 (2010-11-16)
changeset 2203 ac3e215141a1
parent 2155 5374ab57d331
child 2204 ea1c9143e1e3
permissions -rw-r--r--
scripts: remove aria2c as downloader, retain only curl and wget

Signed-off-by: "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
     1 # This file contains some usefull common functions -*- sh -*-
     2 # Copyright 2007 Yann E. MORIN
     3 # Licensed under the GPL v2. See COPYING in the root of this package
     4 
     5 # Prepare the fault handler
     6 CT_OnError() {
     7     ret=$?
     8     # Bail out early in subshell, the upper level shell will act accordingly.
     9     [ ${BASH_SUBSHELL} -eq 0 ] || exit $ret
    10     CT_DoLog ERROR "Build failed in step '${CT_STEP_MESSAGE[${CT_STEP_COUNT}]}'"
    11     for((step=(CT_STEP_COUNT-1); step>1; step--)); do
    12         CT_DoLog ERROR "      called in step '${CT_STEP_MESSAGE[${step}]}'"
    13     done
    14     CT_DoLog ERROR "Error happened in '${BASH_SOURCE[1]}' in function '${FUNCNAME[1]}' (line unknown, sorry)"
    15     for((depth=2; ${BASH_LINENO[$((${depth}-1))]}>0; depth++)); do
    16         CT_DoLog ERROR "      called from '${BASH_SOURCE[${depth}]}' at line # ${BASH_LINENO[${depth}-1]} in function '${FUNCNAME[${depth}]}'"
    17     done
    18     [ "${CT_LOG_TO_FILE}" = "y" ] && CT_DoLog ERROR "Look at '${CT_LOG_FILE}' for more info on this error."
    19     CT_STEP_COUNT=1
    20     CT_DoEnd ERROR
    21     exit $ret
    22 }
    23 
    24 # Install the fault handler
    25 trap CT_OnError ERR
    26 
    27 # Inherit the fault handler in subshells and functions
    28 set -E
    29 
    30 # Make pipes fail on the _first_ failed command
    31 # Not supported on bash < 3.x, but we need it, so drop the obsoleting bash-2.x
    32 set -o pipefail
    33 
    34 # Don't hash commands' locations, and search every time it is requested.
    35 # This is slow, but needed because of the static/shared core gcc which shall
    36 # always match to shared if it exists, and only fallback to static if the
    37 # shared is not found
    38 set +o hashall
    39 
    40 # Log policy:
    41 #  - first of all, save stdout so we can see the live logs: fd #6
    42 exec 6>&1
    43 #  - then point stdout to the log file (temporary for now)
    44 tmp_log_file="${CT_TOP_DIR}/log.$$"
    45 exec >>"${tmp_log_file}"
    46 
    47 # The different log levels:
    48 CT_LOG_LEVEL_ERROR=0
    49 CT_LOG_LEVEL_WARN=1
    50 CT_LOG_LEVEL_INFO=2
    51 CT_LOG_LEVEL_EXTRA=3
    52 CT_LOG_LEVEL_CFG=4
    53 CT_LOG_LEVEL_FILE=5
    54 CT_LOG_LEVEL_STATE=6
    55 CT_LOG_LEVEL_ALL=7
    56 CT_LOG_LEVEL_DEBUG=8
    57 
    58 # Make it easy to use \n and !
    59 CR=$(printf "\n")
    60 BANG='!'
    61 
    62 # A function to log what is happening
    63 # Different log level are available:
    64 #   - ERROR:   A serious, fatal error occurred
    65 #   - WARN:    A non fatal, non serious error occurred, take your responsbility with the generated build
    66 #   - INFO:    Informational messages
    67 #   - EXTRA:   Extra informational messages
    68 #   - CFG:     Output of various "./configure"-type scripts
    69 #   - FILE:    File / archive unpacking.
    70 #   - STATE:   State save & restore
    71 #   - ALL:     Component's build messages
    72 #   - DEBUG:   Internal debug messages
    73 # Usage: CT_DoLog <level> [message]
    74 # If message is empty, then stdin will be logged.
    75 CT_DoLog() {
    76     local max_level LEVEL level cur_l cur_L
    77     local l
    78     eval max_level="\${CT_LOG_LEVEL_${CT_LOG_LEVEL_MAX}}"
    79     # Set the maximum log level to DEBUG if we have none
    80     [ -z "${max_level}" ] && max_level=${CT_LOG_LEVEL_DEBUG}
    81 
    82     LEVEL="$1"; shift
    83     eval level="\${CT_LOG_LEVEL_${LEVEL}}"
    84 
    85     if [ $# -eq 0 ]; then
    86         cat -
    87     else
    88         printf "%s\n" "${*}"
    89     fi |( IFS="${CR}" # We want the full lines, even leading spaces
    90           _prog_bar_cpt=0
    91           _prog_bar[0]='/'
    92           _prog_bar[1]='-'
    93           _prog_bar[2]='\'
    94           _prog_bar[3]='|'
    95           indent=$((2*CT_STEP_COUNT))
    96           while read line; do
    97               case "${CT_LOG_SEE_TOOLS_WARN},${line}" in
    98                 y,*"warning:"*)         cur_L=WARN; cur_l=${CT_LOG_LEVEL_WARN};;
    99                 y,*"WARNING:"*)         cur_L=WARN; cur_l=${CT_LOG_LEVEL_WARN};;
   100                 *"error:"*)             cur_L=ERROR; cur_l=${CT_LOG_LEVEL_ERROR};;
   101                 *"make["*"]: *** ["*)   cur_L=ERROR; cur_l=${CT_LOG_LEVEL_ERROR};;
   102                 *)                      cur_L="${LEVEL}"; cur_l="${level}";;
   103               esac
   104               # There will always be a log file (stdout, fd #1), be it /dev/null
   105               printf "[%-5s]%*s%s%s\n" "${cur_L}" "${indent}" " " "${line}"
   106               if [ ${cur_l} -le ${max_level} ]; then
   107                   # Only print to console (fd #6) if log level is high enough.
   108                   printf "\r[%-5s]%*s%s%s\n" "${cur_L}" "${indent}" " " "${line}" >&6
   109               fi
   110               if [ "${CT_LOG_PROGRESS_BAR}" = "y" ]; then
   111                   printf "\r[%02d:%02d] %s " $((SECONDS/60)) $((SECONDS%60)) "${_prog_bar[$((_prog_bar_cpt/10))]}" >&6
   112                   _prog_bar_cpt=$(((_prog_bar_cpt+1)%40))
   113               fi
   114           done
   115         )
   116 
   117     return 0
   118 }
   119 
   120 # Execute an action, and log its messages
   121 # Usage: [VAR=val...] CT_DoExecLog <level> <command [parameters...]>
   122 CT_DoExecLog() {
   123     local level="$1"
   124     shift
   125     CT_DoLog DEBUG "==> Executing: '${*}'"
   126     "${@}" 2>&1 |CT_DoLog "${level}"
   127 }
   128 
   129 # Tail message to be logged whatever happens
   130 # Usage: CT_DoEnd <level>
   131 CT_DoEnd()
   132 {
   133     local level="$1"
   134     CT_STOP_DATE=$(CT_DoDate +%s%N)
   135     CT_STOP_DATE_HUMAN=$(CT_DoDate +%Y%m%d.%H%M%S)
   136     if [ "${level}" != "ERROR" ]; then
   137         CT_DoLog "${level:-INFO}" "Build completed at ${CT_STOP_DATE_HUMAN}"
   138     fi
   139     elapsed=$((CT_STOP_DATE-CT_STAR_DATE))
   140     elapsed_min=$((elapsed/(60*1000*1000*1000)))
   141     elapsed_sec=$(printf "%02d" $(((elapsed%(60*1000*1000*1000))/(1000*1000*1000))))
   142     elapsed_csec=$(printf "%02d" $(((elapsed%(1000*1000*1000))/(10*1000*1000))))
   143     CT_DoLog ${level:-INFO} "(elapsed: ${elapsed_min}:${elapsed_sec}.${elapsed_csec})"
   144 }
   145 
   146 # Remove entries referring to . and other relative paths
   147 # Usage: CT_SanitizePath
   148 CT_SanitizePath() {
   149     local new
   150     local p
   151     local IFS=:
   152     for p in $PATH; do
   153         # Only accept absolute paths;
   154         # Note: as a special case the empty string in PATH is equivalent to .
   155         if [ -n "${p}" -a -z "${p%%/*}" ]; then
   156             new="${new}${new:+:}${p}"
   157         fi
   158     done
   159     PATH="${new}"
   160 }
   161 
   162 # Abort the execution with an error message
   163 # Usage: CT_Abort <message>
   164 CT_Abort() {
   165     CT_DoLog ERROR "$1"
   166     exit 1
   167 }
   168 
   169 # Test a condition, and print a message if satisfied
   170 # Usage: CT_Test <message> <tests>
   171 CT_Test() {
   172     local ret
   173     local m="$1"
   174     shift
   175     CT_DoLog DEBUG "Testing '! ( $* )'"
   176     test "$@" && CT_DoLog WARN "$m"
   177     return 0
   178 }
   179 
   180 # Test a condition, and abort with an error message if satisfied
   181 # Usage: CT_TestAndAbort <message> <tests>
   182 CT_TestAndAbort() {
   183     local m="$1"
   184     shift
   185     CT_DoLog DEBUG "Testing '! ( $* )'"
   186     test "$@" && CT_Abort "$m"
   187     return 0
   188 }
   189 
   190 # Test a condition, and abort with an error message if not satisfied
   191 # Usage: CT_TestAndAbort <message> <tests>
   192 CT_TestOrAbort() {
   193     local m="$1"
   194     shift
   195     CT_DoLog DEBUG "Testing '$*'"
   196     test "$@" || CT_Abort "$m"
   197     return 0
   198 }
   199 
   200 # Test the presence of a tool, or abort if not found
   201 # Usage: CT_HasOrAbort <tool>
   202 CT_HasOrAbort() {
   203     CT_TestAndAbort "'${1}' not found and needed for successful toolchain build." -z "$(CT_Which "${1}")"
   204     return 0
   205 }
   206 
   207 # Search a program: wrap "which" for those system where
   208 # "which" verbosely says there is no match (Mandriva is
   209 # such a sucker...)
   210 # Usage: CT_Which <filename>
   211 CT_Which() {
   212   which "$1" 2>/dev/null || true
   213 }
   214 
   215 # Get current date with nanosecond precision
   216 # On those system not supporting nanosecond precision, faked with rounding down
   217 # to the highest entire second
   218 # Usage: CT_DoDate <fmt>
   219 CT_DoDate() {
   220     date "$1" |sed -r -e 's/N$/000000000/;'
   221 }
   222 
   223 CT_STEP_COUNT=1
   224 CT_STEP_MESSAGE[${CT_STEP_COUNT}]="<none>"
   225 # Memorise a step being done so that any error is caught
   226 # Usage: CT_DoStep <loglevel> <message>
   227 CT_DoStep() {
   228     local start=$(CT_DoDate +%s%N)
   229     CT_DoLog "$1" "================================================================="
   230     CT_DoLog "$1" "$2"
   231     CT_STEP_COUNT=$((CT_STEP_COUNT+1))
   232     CT_STEP_LEVEL[${CT_STEP_COUNT}]="$1"; shift
   233     CT_STEP_START[${CT_STEP_COUNT}]="${start}"
   234     CT_STEP_MESSAGE[${CT_STEP_COUNT}]="$1"
   235     return 0
   236 }
   237 
   238 # End the step just being done
   239 # Usage: CT_EndStep
   240 CT_EndStep() {
   241     local stop=$(CT_DoDate +%s%N)
   242     local duration=$(printf "%032d" $((stop-${CT_STEP_START[${CT_STEP_COUNT}]})) |sed -r -e 's/([[:digit:]]{2})[[:digit:]]{7}$/\.\1/; s/^0+//; s/^\./0\./;')
   243     local elapsed=$(printf "%02d:%02d" $((SECONDS/60)) $((SECONDS%60)))
   244     local level="${CT_STEP_LEVEL[${CT_STEP_COUNT}]}"
   245     local message="${CT_STEP_MESSAGE[${CT_STEP_COUNT}]}"
   246     CT_STEP_COUNT=$((CT_STEP_COUNT-1))
   247     CT_DoLog "${level}" "${message}: done in ${duration}s (at ${elapsed})"
   248     return 0
   249 }
   250 
   251 # Pushes into a directory, and pops back
   252 CT_Pushd() {
   253     pushd "$1" >/dev/null 2>&1
   254 }
   255 CT_Popd() {
   256     popd >/dev/null 2>&1
   257 }
   258 
   259 # Creates a temporary directory
   260 # $1: variable to assign to
   261 # Usage: CT_MktempDir foo
   262 CT_MktempDir() {
   263     # Some mktemp do not allow more than 6 Xs
   264     eval "$1"=$(mktemp -q -d "${CT_BUILD_DIR}/tmp.XXXXXX")
   265     CT_TestOrAbort "Could not make temporary directory" -n "${!1}" -a -d "${!1}"
   266     CT_DoLog DEBUG "Made temporary directory '${!1}'"
   267     return 0
   268 }
   269 
   270 # Removes one or more directories, even if it is read-only, or its parent is
   271 # Usage: CT_DoForceRmdir dir [...]
   272 CT_DoForceRmdir() {
   273     local dir
   274     local mode
   275     for dir in "${@}"; do
   276         [ -d "${dir}" ] || continue
   277         case "$CT_SYS_OS" in
   278             Linux|CYGWIN*)
   279                 mode="$(stat -c '%a' "$(dirname "${dir}")")"
   280                 ;;
   281             Darwin|*BSD)
   282                 mode="$(stat -f '%Lp' "$(dirname "${dir}")")"
   283                 ;;
   284             *)
   285                 CT_Abort "Unhandled host OS $CT_SYS_OS"
   286                 ;;
   287         esac
   288         CT_DoExecLog ALL chmod u+w "$(dirname "${dir}")"
   289         CT_DoExecLog ALL chmod -R u+w "${dir}"
   290         CT_DoExecLog ALL rm -rf "${dir}"
   291         CT_DoExecLog ALL chmod ${mode} "$(dirname "${dir}")"
   292     done
   293 }
   294 
   295 # Echoes the specified string on stdout until the pipe breaks.
   296 # Doesn't fail
   297 # $1: string to echo
   298 # Usage: CT_DoYes "" |make oldconfig
   299 CT_DoYes() {
   300     yes "$1" || true
   301 }
   302 
   303 # Add the specified directory to LD_LIBRARY_PATH, and export it
   304 # If the specified patch is already present, just export
   305 # $1: path to add
   306 # $2: add as 'first' or 'last' path, 'first' is assumed if $2 is empty
   307 # Usage CT_SetLibPath /some/where/lib [first|last]
   308 CT_SetLibPath() {
   309     local path="$1"
   310     local pos="$2"
   311 
   312     case ":${LD_LIBRARY_PATH}:" in
   313         *:"${path}":*)  ;;
   314         *)  case "${pos}" in
   315                 last)
   316                     CT_DoLog DEBUG "Adding '${path}' at end of LD_LIBRARY_PATH"
   317                     LD_LIBRARY_PATH="${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}${path}"
   318                     ;;
   319                 first|"")
   320                     CT_DoLog DEBUG "Adding '${path}' at start of LD_LIBRARY_PATH"
   321                     LD_LIBRARY_PATH="${path}${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}"
   322                     ;;
   323                 *)
   324                     CT_Abort "Incorrect position '${pos}' to add '${path}' to LD_LIBRARY_PATH"
   325                     ;;
   326             esac
   327             ;;
   328     esac
   329     CT_DoLog DEBUG "==> LD_LIBRARY_PATH='${LD_LIBRARY_PATH}'"
   330     export LD_LIBRARY_PATH
   331 }
   332 
   333 # Get the file name extension of a component
   334 # Usage: CT_GetFileExtension <component_name-component_version> [extension]
   335 # If found, echoes the extension to stdout, and return 0
   336 # If not found, echoes nothing on stdout, and return !0.
   337 CT_GetFileExtension() {
   338     local ext
   339     local file="$1"
   340     shift
   341     local first_ext="$1"
   342 
   343     # we need to also check for an empty extension for those very
   344     # peculiar components that don't have one (such as sstrip from
   345     # buildroot).
   346     for ext in ${first_ext} .tar.gz .tar.bz2 .tgz .tar /.git ''; do
   347         if [ -e "${CT_TARBALLS_DIR}/${file}${ext}" ]; then
   348             echo "${ext}"
   349             exit 0
   350         fi
   351     done
   352 
   353     exit 1
   354 }
   355 
   356 # Download an URL using wget
   357 # Usage: CT_DoGetFileWget <URL>
   358 CT_DoGetFileWget() {
   359     # Need to return true because it is legitimate to not find the tarball at
   360     # some of the provided URLs (think about snapshots, different layouts for
   361     # different gcc versions, etc...)
   362     # Some (very old!) FTP server might not support the passive mode, thus
   363     # retry without
   364     # With automated download as we are doing, it can be very dangerous to use
   365     # -c to continue the downloads. It's far better to simply overwrite the
   366     # destination file
   367     # Some company networks have firewalls to connect to the internet, but it's
   368     # not easy to detect them, and wget does not timeout by default while
   369     # connecting, so force a global ${CT_CONNECT_TIMEOUT}-second timeout.
   370     CT_DoExecLog ALL wget -T ${CT_CONNECT_TIMEOUT} -nc --progress=dot:binary --tries=3 --passive-ftp "$1"    \
   371     || CT_DoExecLog ALL wget -T ${CT_CONNECT_TIMEOUT} -nc --progress=dot:binary --tries=3 "$1"               \
   372     || rm -f "${1##*/}"
   373 }
   374 
   375 # Download an URL using curl
   376 # Usage: CT_DoGetFileCurl <URL>
   377 CT_DoGetFileCurl() {
   378     # Note: comments about wget method (above) are also valid here
   379     # Plus: no good progress indicator is available with curl,
   380     #       so, be silent.
   381     CT_DoExecLog ALL curl -s --ftp-pasv -O --retry 3 "$1" --connect-timeout ${CT_CONNECT_TIMEOUT} -L -f  \
   382     || CT_DoExecLog ALL curl -s -O --retry 3 "$1" --connect-timeout ${CT_CONNECT_TIMEOUT} -L -f          \
   383     || rm -f "${1##*/}"
   384 }
   385 
   386 # OK, just look if we have them...
   387 _wget=$(CT_Which wget)
   388 _curl=$(CT_Which curl)
   389 
   390 # Wrapper function to call one of, in order of preference:
   391 #   curl
   392 #   wget
   393 # Usage: CT_DoGetFile <URL>
   394 CT_DoGetFile() {
   395     if   [ -n "${_curl}" ]; then
   396         CT_DoGetFileCurl "$1"
   397     elif [ -n "${_wget}" ]; then
   398         CT_DoGetFileWget "$1"
   399     else
   400         CT_Abort "Could find neither wget nor curl"
   401     fi
   402 }
   403 
   404 # This function tries to retrieve a tarball form a local directory
   405 # Usage: CT_GetLocal <basename> [.extension]
   406 CT_GetLocal() {
   407     local basename="$1"
   408     local first_ext="$2"
   409     local ext
   410 
   411     # Do we already have it in *our* tarballs dir?
   412     if ext="$( CT_GetFileExtension "${basename}" ${first_ext} )"; then
   413         CT_DoLog DEBUG "Already have '${basename}'"
   414         return 0
   415     fi
   416 
   417     if [ -n "${CT_LOCAL_TARBALLS_DIR}" ]; then
   418         CT_DoLog DEBUG "Trying to retrieve an already downloaded copy of '${basename}'"
   419         # We'd rather have a bzip2'ed tarball, then gzipped tarball, plain tarball,
   420         # or, as a failover, a file without extension.
   421         for ext in ${first_ext} .tar.bz2 .tar.gz .tgz .tar ''; do
   422             CT_DoLog DEBUG "Trying '${CT_LOCAL_TARBALLS_DIR}/${basename}${ext}'"
   423             if [ -r "${CT_LOCAL_TARBALLS_DIR}/${basename}${ext}" -a \
   424                  "${CT_FORCE_DOWNLOAD}" != "y" ]; then
   425                 CT_DoLog DEBUG "Got '${basename}' from local storage"
   426                 CT_DoExecLog ALL ln -s "${CT_LOCAL_TARBALLS_DIR}/${basename}${ext}" "${CT_TARBALLS_DIR}/${basename}${ext}"
   427                 return 0
   428             fi
   429         done
   430     fi
   431     return 1
   432 }
   433 
   434 # This function saves the specified to local storage if possible,
   435 # and if so, symlinks it for later usage
   436 # Usage: CT_SaveLocal </full/path/file.name>
   437 CT_SaveLocal() {
   438     local file="$1"
   439     local basename="${file##*/}"
   440 
   441     if [ "${CT_SAVE_TARBALLS}" = "y" ]; then
   442         CT_DoLog EXTRA "Saving '${basename}' to local storage"
   443         # The file may already exist if downloads are forced: remove it first
   444         CT_DoExecLog ALL rm -f "${CT_LOCAL_TARBALLS_DIR}/${basename}"
   445         CT_DoExecLog ALL mv -f "${file}" "${CT_LOCAL_TARBALLS_DIR}"
   446         CT_DoExecLog ALL ln -s "${CT_LOCAL_TARBALLS_DIR}/${basename}" "${file}"
   447     fi
   448 }
   449 
   450 # Download the file from one of the URLs passed as argument
   451 # Usage: CT_GetFile <basename> [.extension] <url> [url ...]
   452 CT_GetFile() {
   453     local ext
   454     local url URLS LAN_URLS
   455     local file="$1"
   456     local first_ext
   457     shift
   458     # If next argument starts with a dot, then this is not an URL,
   459     # and we can consider that it is a preferred extension.
   460     case "$1" in
   461         .*) first_ext="$1"
   462             shift
   463             ;;
   464     esac
   465 
   466     # Does it exist localy?
   467     CT_GetLocal "${file}" ${first_ext} && return 0 || true
   468     # No, it does not...
   469 
   470     # Try to retrieve the file
   471     CT_DoLog EXTRA "Retrieving '${file}'"
   472     CT_Pushd "${CT_TARBALLS_DIR}"
   473 
   474     URLS="$@"
   475 
   476     # Add URLs on the LAN mirror
   477     LAN_URLS=
   478     if [ "${CT_USE_MIRROR}" = "y" ]; then
   479         CT_TestOrAbort "Please set the mirror base URL" -n "${CT_MIRROR_BASE_URL}"
   480         LAN_URLS="${LAN_URLS} ${CT_MIRROR_BASE_URL}/${file%-*}"
   481         LAN_URLS="${LAN_URLS} ${CT_MIRROR_BASE_URL}"
   482 
   483         if [ "${CT_PREFER_MIRROR}" = "y" ]; then
   484             CT_DoLog DEBUG "Pre-pending LAN mirror URLs"
   485             URLS="${LAN_URLS} ${URLS}"
   486         else
   487             CT_DoLog DEBUG "Appending LAN mirror URLs"
   488             URLS="${URLS} ${LAN_URLS}"
   489         fi
   490     fi
   491 
   492     # Scan all URLs in turn, and try to grab a tarball from there
   493     # Do *not* try git trees (ext=/.git), this is handled in a specific
   494     # wrapper, below
   495     for ext in ${first_ext} .tar.bz2 .tar.gz .tgz .tar ''; do
   496         # Try all urls in turn
   497         for url in ${URLS}; do
   498             CT_DoLog DEBUG "Trying '${url}/${file}${ext}'"
   499             CT_DoGetFile "${url}/${file}${ext}"
   500             if [ -f "${file}${ext}" ]; then
   501                 CT_DoLog DEBUG "Got '${file}' from the Internet"
   502                 CT_SaveLocal "${CT_TARBALLS_DIR}/${file}${ext}"
   503                 return 0
   504             fi
   505         done
   506     done
   507     CT_Popd
   508 
   509     CT_Abort "Could not retrieve '${file}'."
   510 }
   511 
   512 # Checkout from CVS, and build the associated tarball
   513 # The tarball will be called ${basename}.tar.bz2
   514 # Prerequisite: either the server does not require password,
   515 # or the user must already be logged in.
   516 # 'tag' is the tag to retrieve. Must be specified, but can be empty.
   517 # If dirname is specified, then module will be renamed to dirname
   518 # prior to building the tarball.
   519 # Usage: CT_GetCVS <basename> <url> <module> <tag> [dirname[=subdir]]
   520 # Note: if '=subdir' is given, then it is used instead of 'module'.
   521 CT_GetCVS() {
   522     local basename="$1"
   523     local uri="$2"
   524     local module="$3"
   525     local tag="${4:+-r ${4}}"
   526     local dirname="$5"
   527     local tmp_dir
   528 
   529     # Does it exist localy?
   530     CT_GetLocal "${basename}" && return 0 || true
   531     # No, it does not...
   532 
   533     CT_DoLog EXTRA "Retrieving '${basename}'"
   534 
   535     CT_MktempDir tmp_dir
   536     CT_Pushd "${tmp_dir}"
   537 
   538     CT_DoExecLog ALL cvs -z 9 -d "${uri}" co -P ${tag} "${module}"
   539     if [ -n "${dirname}" ]; then
   540         case "${dirname}" in
   541             *=*)
   542                 CT_DoExecLog DEBUG mv "${dirname#*=}" "${dirname%%=*}"
   543                 CT_DoExecLog ALL tar cjf "${CT_TARBALLS_DIR}/${basename}.tar.bz2" "${dirname%%=*}"
   544                 ;;
   545             *)
   546                 CT_DoExecLog ALL mv "${module}" "${dirname}"
   547                 CT_DoExecLog ALL tar cjf "${CT_TARBALLS_DIR}/${basename}.tar.bz2" "${dirname:-${module}}"
   548                 ;;
   549         esac
   550     fi
   551     CT_SaveLocal "${CT_TARBALLS_DIR}/${basename}.tar.bz2"
   552 
   553     CT_Popd
   554     CT_DoExecLog ALL rm -rf "${tmp_dir}"
   555 }
   556 
   557 # Check out from SVN, and build the associated tarball
   558 # The tarball will be called ${basename}.tar.bz2
   559 # Prerequisite: either the server does not require password,
   560 # or the user must already be logged in.
   561 # 'rev' is the revision to retrieve
   562 # Usage: CT_GetSVN <basename> <url> [rev]
   563 CT_GetSVN() {
   564     local basename="$1"
   565     local uri="$2"
   566     local rev="$3"
   567 
   568     # Does it exist localy?
   569     CT_GetLocal "${basename}" && return 0 || true
   570     # No, it does not...
   571 
   572     CT_DoLog EXTRA "Retrieving '${basename}'"
   573 
   574     CT_MktempDir tmp_dir
   575     CT_Pushd "${tmp_dir}"
   576 
   577     CT_DoExecLog ALL svn export ${rev:+-r ${rev}} "${uri}" "${basename}"
   578     CT_DoExecLog ALL tar cjf "${CT_TARBALLS_DIR}/${basename}.tar.bz2" "${basename}"
   579     CT_SaveLocal "${CT_TARBALLS_DIR}/${basename}.tar.bz2"
   580 
   581     CT_Popd
   582     CT_DoExecLog ALL rm -rf "${tmp_dir}"
   583 }
   584 
   585 # Clone a git tree
   586 # Tries the given URLs in turn until one can get cloned. No tarball will be created.
   587 # Prerequisites: either the server does not require password,
   588 # or the user has already taken any action to authenticate to the server.
   589 # The cloned tree will *not* be stored in the local tarballs dir!
   590 # Usage: CT_GetGit <basename> <url [url ...]>
   591 CT_GetGit() {
   592     local basename="$1"; shift
   593     local url
   594     local cloned=0
   595 
   596     # Do we have it in our tarballs dir?
   597     if [ -d "${CT_TARBALLS_DIR}/${basename}/.git" ]; then
   598         CT_DoLog EXTRA "Updating git tree '${basename}'"
   599         CT_Pushd "${CT_TARBALLS_DIR}/${basename}"
   600         CT_DoExecLog ALL git pull
   601         CT_Popd
   602     else
   603         CT_DoLog EXTRA "Retrieving git tree '${basename}'"
   604         for url in "${@}"; do
   605             CT_DoLog ALL "Trying to clone from '${url}'"
   606             CT_DoForceRmdir "${CT_TARBALLS_DIR}/${basename}"
   607             if git clone "${url}" "${CT_TARBALLS_DIR}/${basename}" 2>&1 |CT_DoLog ALL; then
   608                 cloned=1
   609                 break
   610             fi
   611         done
   612         CT_TestOrAbort "Could not clone '${basename}'" ${cloned} -ne 0
   613     fi
   614 }
   615 
   616 # Extract a tarball
   617 # Some tarballs need to be extracted in specific places. Eg.: glibc addons
   618 # must be extracted in the glibc directory; uCLibc locales must be extracted
   619 # in the extra/locale sub-directory of uClibc. This is taken into account
   620 # by the caller, that did a 'cd' into the correct path before calling us
   621 # and sets nochdir to 'nochdir'.
   622 # Note also that this function handles the git trees!
   623 # Usage: CT_Extract <basename> [nochdir] [options]
   624 # where 'options' are dependent on the source (eg. git branch/tag...)
   625 CT_Extract() {
   626     local nochdir="$1"
   627     local basename
   628     local ext
   629 
   630     if [ "${nochdir}" = "nochdir" ]; then
   631         shift
   632         nochdir="$(pwd)"
   633     else
   634         nochdir="${CT_SRC_DIR}"
   635     fi
   636 
   637     basename="$1"
   638     shift
   639 
   640     if ! ext="$(CT_GetFileExtension "${basename}")"; then
   641       CT_Abort "'${basename}' not found in '${CT_TARBALLS_DIR}'"
   642     fi
   643     local full_file="${CT_TARBALLS_DIR}/${basename}${ext}"
   644 
   645     # Check if already extracted
   646     if [ -e "${CT_SRC_DIR}/.${basename}.extracted" ]; then
   647         CT_DoLog DEBUG "Already extracted '${basename}'"
   648         return 0
   649     fi
   650 
   651     # Check if previously partially extracted
   652     if [ -e "${CT_SRC_DIR}/.${basename}.extracting" ]; then
   653         CT_DoLog ERROR "The '${basename}' sources were partially extracted."
   654         CT_DoLog ERROR "Please remove first:"
   655         CT_DoLog ERROR " - the source dir for '${basename}', in '${CT_SRC_DIR}'"
   656         CT_DoLog ERROR " - the file '${CT_SRC_DIR}/.${basename}.extracting'"
   657         CT_Abort "I'll stop now to avoid any carnage..."
   658     fi
   659     CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.${basename}.extracting"
   660 
   661     CT_Pushd "${nochdir}"
   662 
   663     CT_DoLog EXTRA "Extracting '${basename}'"
   664     case "${ext}" in
   665         .tar.bz2)     CT_DoExecLog FILE tar xvjf "${full_file}";;
   666         .tar.gz|.tgz) CT_DoExecLog FILE tar xvzf "${full_file}";;
   667         .tar)         CT_DoExecLog FILE tar xvf  "${full_file}";;
   668         /.git)        CT_ExtractGit "${basename}" "${@}";;
   669         *)            CT_Abort "Don't know how to handle '${basename}${ext}': unknown extension";;
   670     esac
   671 
   672     # Some tarballs have read-only files... :-(
   673     # Because of nochdir, we don't know where we are, so chmod all
   674     # the src tree
   675     CT_DoExecLog DEBUG chmod -R u+w "${CT_SRC_DIR}"
   676 
   677     # Don't mark as being extracted for git
   678     case "${ext}" in
   679         /.git)  ;;
   680         *)      CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.${basename}.extracted";;
   681     esac
   682     CT_DoExecLog DEBUG rm -f "${CT_SRC_DIR}/.${basename}.extracting"
   683 
   684     CT_Popd
   685 }
   686 
   687 # Create a working git clone
   688 # Usage: CT_ExtractGit <basename> [ref]
   689 # where 'ref' is the reference to use:
   690 #   the full name of a branch, like "remotes/origin/branch_name"
   691 #   a date as understandable by git, like "YYYY-MM-DD[ hh[:mm[:ss]]]"
   692 #   a tag name
   693 CT_ExtractGit() {
   694     local basename="${1}"
   695     local ref="${2}"
   696     local clone_dir
   697     local ref_type
   698 
   699     # pushd now to be able to get git revlist in case ref is a date
   700     clone_dir="${CT_TARBALLS_DIR}/${basename}"
   701     CT_Pushd "${clone_dir}"
   702 
   703     # What kind of reference is ${ref} ?
   704     if [ -z "${ref}" ]; then
   705         # Don't update the clone, keep as-is
   706         ref_type=none
   707     elif git tag |grep -E "^${ref}$" >/dev/null 2>&1; then
   708         ref_type=tag
   709     elif git branch -a --no-color |grep -E "^. ${ref}$" >/dev/null 2>&1; then
   710         ref_type=branch
   711     elif date -d "${ref}" >/dev/null 2>&1; then
   712         ref_type=date
   713         ref=$(git rev-list -n1 --before="${ref}")
   714     else
   715         CT_Abort "Reference '${ref}' is an incorrect git reference: neither tag, branch nor date"
   716     fi
   717 
   718     CT_DoExecLog DEBUG rm -f "${CT_SRC_DIR}/${basename}"
   719     CT_DoExecLog ALL ln -sf "${clone_dir}" "${CT_SRC_DIR}/${basename}"
   720 
   721     case "${ref_type}" in
   722         none)   ;;
   723         *)      CT_DoExecLog FILE git checkout "${ref}";;
   724     esac
   725 
   726     CT_Popd
   727 }
   728 
   729 # Patches the specified component
   730 # See CT_Extract, above, for explanations on 'nochdir'
   731 # Usage: CT_Patch [nochdir] <packagename> <packageversion>
   732 # If the package directory is *not* packagename-packageversion, then
   733 # the caller must cd into the proper directory first, and call us
   734 # with nochdir
   735 CT_Patch() {
   736     local nochdir="$1"
   737     local pkgname
   738     local version
   739     local pkgdir
   740     local base_file
   741     local ver_file
   742     local d
   743     local -a patch_dirs
   744     local bundled_patch_dir
   745     local local_patch_dir
   746 
   747     if [ "${nochdir}" = "nochdir" ]; then
   748         shift
   749         pkgname="$1"
   750         version="$2"
   751         pkgdir="${pkgname}-${version}"
   752         nochdir="$(pwd)"
   753     else
   754         pkgname="$1"
   755         version="$2"
   756         pkgdir="${pkgname}-${version}"
   757         nochdir="${CT_SRC_DIR}/${pkgdir}"
   758     fi
   759 
   760     # Check if already patched
   761     if [ -e "${CT_SRC_DIR}/.${pkgdir}.patched" ]; then
   762         CT_DoLog DEBUG "Already patched '${pkgdir}'"
   763         return 0
   764     fi
   765 
   766     # Check if already partially patched
   767     if [ -e "${CT_SRC_DIR}/.${pkgdir}.patching" ]; then
   768         CT_DoLog ERROR "The '${pkgdir}' sources were partially patched."
   769         CT_DoLog ERROR "Please remove first:"
   770         CT_DoLog ERROR " - the source dir for '${pkgdir}', in '${CT_SRC_DIR}'"
   771         CT_DoLog ERROR " - the file '${CT_SRC_DIR}/.${pkgdir}.extracted'"
   772         CT_DoLog ERROR " - the file '${CT_SRC_DIR}/.${pkgdir}.patching'"
   773         CT_Abort "I'll stop now to avoid any carnage..."
   774     fi
   775     touch "${CT_SRC_DIR}/.${pkgdir}.patching"
   776 
   777     CT_Pushd "${nochdir}"
   778 
   779     CT_DoLog EXTRA "Patching '${pkgdir}'"
   780 
   781     bundled_patch_dir="${CT_LIB_DIR}/patches/${pkgname}/${version}"
   782     local_patch_dir="${CT_LOCAL_PATCH_DIR}/${pkgname}/${version}"
   783 
   784     case "${CT_PATCH_ORDER}" in
   785         bundled)        patch_dirs=("${bundled_patch_dir}");;
   786         local)          patch_dirs=("${local_patch_dir}");;
   787         bundled,local)  patch_dirs=("${bundled_patch_dir}" "${local_patch_dir}");;
   788         local,bundled)  patch_dirs=("${local_patch_dir}" "${bundled_patch_dir}");;
   789         none)           patch_dirs=;;
   790     esac
   791 
   792     for d in "${patch_dirs[@]}"; do
   793         CT_DoLog DEBUG "Looking for patches in '${d}'..."
   794         if [ -n "${d}" -a -d "${d}" ]; then
   795             for p in "${d}"/*.patch; do
   796                 if [ -f "${p}" ]; then
   797                     CT_DoLog DEBUG "Applying patch '${p}'"
   798                     CT_DoExecLog ALL patch --no-backup-if-mismatch -g0 -F1 -p1 -f <"${p}"
   799                 fi
   800             done
   801             if [ "${CT_PATCH_SINGLE}" = "y" ]; then
   802                 break
   803             fi
   804         fi
   805     done
   806 
   807     if [ "${CT_OVERIDE_CONFIG_GUESS_SUB}" = "y" ]; then
   808         CT_DoLog ALL "Overiding config.guess and config.sub"
   809         for cfg in config_guess config_sub; do
   810             eval ${cfg}="${CT_LIB_DIR}/scripts/${cfg/_/.}"
   811             [ -e "${CT_TOP_DIR}/scripts/${cfg/_/.}" ] && eval ${cfg}="${CT_TOP_DIR}/scripts/${cfg/_/.}"
   812             # Can't use CT_DoExecLog because of the '{} \;' to be passed un-mangled to find
   813             find . -type f -name "${cfg/_/.}" -exec cp -v "${!cfg}" {} \; |CT_DoLog ALL
   814         done
   815     fi
   816 
   817     CT_DoExecLog DEBUG touch "${CT_SRC_DIR}/.${pkgdir}.patched"
   818     CT_DoExecLog DEBUG rm -f "${CT_SRC_DIR}/.${pkgdir}.patching"
   819 
   820     CT_Popd
   821 }
   822 
   823 # Two wrappers to call config.(guess|sub) either from CT_TOP_DIR or CT_LIB_DIR.
   824 # Those from CT_TOP_DIR, if they exist, will be be more recent than those from CT_LIB_DIR.
   825 CT_DoConfigGuess() {
   826     if [ -x "${CT_TOP_DIR}/scripts/config.guess" ]; then
   827         "${CT_TOP_DIR}/scripts/config.guess"
   828     else
   829         "${CT_LIB_DIR}/scripts/config.guess"
   830     fi
   831 }
   832 
   833 CT_DoConfigSub() {
   834     if [ -x "${CT_TOP_DIR}/scripts/config.sub" ]; then
   835         "${CT_TOP_DIR}/scripts/config.sub" "$@"
   836     else
   837         "${CT_LIB_DIR}/scripts/config.sub" "$@"
   838     fi
   839 }
   840 
   841 # Compute the target tuple from what is provided by the user
   842 # Usage: CT_DoBuildTargetTuple
   843 # In fact this function takes the environment variables to build the target
   844 # tuple. It is needed both by the normal build sequence, as well as the
   845 # sample saving sequence.
   846 CT_DoBuildTargetTuple() {
   847     # Set the endianness suffix, and the default endianness gcc option
   848     case "${CT_ARCH_BE},${CT_ARCH_LE}" in
   849         y,) target_endian_eb=eb
   850             target_endian_el=
   851             CT_ARCH_ENDIAN_CFLAG="-mbig-endian"
   852             CT_ARCH_ENDIAN_LDFLAG="-EB"
   853             ;;
   854         ,y) target_endian_eb=
   855             target_endian_el=el
   856             CT_ARCH_ENDIAN_CFLAG="-mlittle-endian"
   857             CT_ARCH_ENDIAN_LDFLAG="-EL"
   858             ;;
   859     esac
   860 
   861     # Build the default architecture tuple part
   862     CT_TARGET_ARCH="${CT_ARCH}"
   863 
   864     # Set defaults for the system part of the tuple. Can be overriden
   865     # by architecture-specific values.
   866     case "${CT_LIBC}" in
   867         *glibc) CT_TARGET_SYS=gnu;;
   868         uClibc) CT_TARGET_SYS=uclibc;;
   869         *)      CT_TARGET_SYS=elf;;
   870     esac
   871 
   872     # Set the default values for ARCH, ABI, CPU, TUNE, FPU and FLOAT
   873     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
   874     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
   875     [ "${CT_ARCH_ARCH}"     ] && { CT_ARCH_ARCH_CFLAG="-march=${CT_ARCH_ARCH}";  CT_ARCH_WITH_ARCH="--with-arch=${CT_ARCH_ARCH}"; }
   876     [ "${CT_ARCH_ABI}"      ] && { CT_ARCH_ABI_CFLAG="-mabi=${CT_ARCH_ABI}";     CT_ARCH_WITH_ABI="--with-abi=${CT_ARCH_ABI}";    }
   877     [ "${CT_ARCH_CPU}"      ] && { CT_ARCH_CPU_CFLAG="-mcpu=${CT_ARCH_CPU}";     CT_ARCH_WITH_CPU="--with-cpu=${CT_ARCH_CPU}";    }
   878     [ "${CT_ARCH_TUNE}"     ] && { CT_ARCH_TUNE_CFLAG="-mtune=${CT_ARCH_TUNE}";  CT_ARCH_WITH_TUNE="--with-tune=${CT_ARCH_TUNE}"; }
   879     [ "${CT_ARCH_FPU}"      ] && { CT_ARCH_FPU_CFLAG="-mfpu=${CT_ARCH_FPU}";     CT_ARCH_WITH_FPU="--with-fpu=${CT_ARCH_FPU}";    }
   880     [ "${CT_ARCH_FLOAT_SW}" ] && { CT_ARCH_FLOAT_CFLAG="-msoft-float";           CT_ARCH_WITH_FLOAT="--with-float=soft";          }
   881 
   882     # Build the default kernel tuple part
   883     CT_TARGET_KERNEL="${CT_KERNEL}"
   884 
   885     # Overide the default values with the components specific settings
   886     CT_DoArchTupleValues
   887     CT_DoKernelTupleValues
   888 
   889     # Finish the target tuple construction
   890     CT_TARGET="${CT_TARGET_ARCH}"
   891     CT_TARGET="${CT_TARGET}${CT_TARGET_VENDOR:+-${CT_TARGET_VENDOR}}"
   892     CT_TARGET="${CT_TARGET}${CT_TARGET_KERNEL:+-${CT_TARGET_KERNEL}}"
   893     CT_TARGET="${CT_TARGET}${CT_TARGET_SYS:+-${CT_TARGET_SYS}}"
   894 
   895     # Sanity checks
   896     __sed_alias=""
   897     if [ -n "${CT_TARGET_ALIAS_SED_EXPR}" ]; then
   898         __sed_alias=$(echo "${CT_TARGET}" |sed -r -e "${CT_TARGET_ALIAS_SED_EXPR}")
   899     fi
   900     case ":${CT_TARGET_VENDOR}:${CT_TARGET_ALIAS}:${__sed_alias}:" in
   901       :*" "*:*:*:) CT_Abort "Don't use spaces in the vendor string, it breaks things.";;
   902       :*"-"*:*:*:) CT_Abort "Don't use dashes in the vendor string, it breaks things.";;
   903       :*:*" "*:*:) CT_Abort "Don't use spaces in the target alias, it breaks things.";;
   904       :*:*:*" "*:) CT_Abort "Don't use spaces in the target sed transform, it breaks things.";;
   905     esac
   906 
   907     # Canonicalise it
   908     CT_TARGET=$(CT_DoConfigSub "${CT_TARGET}")
   909     # Prepare the target CFLAGS
   910     CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_ENDIAN_CFLAG}"
   911     CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_ARCH_CFLAG}"
   912     CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_ABI_CFLAG}"
   913     CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_CPU_CFLAG}"
   914     CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_TUNE_CFLAG}"
   915     CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_FPU_CFLAG}"
   916     CT_ARCH_TARGET_CFLAGS="${CT_ARCH_TARGET_CFLAGS} ${CT_ARCH_FLOAT_CFLAG}"
   917 
   918     # Now on for the target LDFLAGS
   919     CT_ARCH_TARGET_LDFLAGS="${CT_ARCH_TARGET_LDFLAGS} ${CT_ARCH_ENDIAN_LDFLAG}"
   920 }
   921 
   922 # This function does pause the build until the user strikes "Return"
   923 # Usage: CT_DoPause [optional_message]
   924 CT_DoPause() {
   925     local foo
   926     local message="${1:-Pausing for your pleasure}"
   927     CT_DoLog INFO "${message}"
   928     read -p "Press 'Enter' to continue, or Ctrl-C to stop..." foo >&6
   929     return 0
   930 }
   931 
   932 # This function creates a tarball of the specified directory, but
   933 # only if it exists
   934 # Usage: CT_DoTarballIfExists <dir> <tarball_basename> [extra_tar_options [...]]
   935 CT_DoTarballIfExists() {
   936     local dir="$1"
   937     local tarball="$2"
   938     shift 2
   939     local -a extra_tar_opts=( "$@" )
   940     local -a compress
   941 
   942     case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
   943         y)  compress=( gzip -c -3 - ); tar_ext=.gz;;
   944         *)  compress=( cat - );        tar_ext=;;
   945     esac
   946 
   947     if [ -d "${dir}" ]; then
   948         CT_DoLog DEBUG "  Saving '${dir}'"
   949         { tar c -C "${dir}" -v -f - "${extra_tar_opts[@]}" .    \
   950           |"${compress[@]}" >"${tarball}.tar${tar_ext}"         ;
   951         } 2>&1 |sed -r -e 's/^/    /;' |CT_DoLog STATE
   952     else
   953         CT_DoLog STATE "  Not saving '${dir}': does not exist"
   954     fi
   955 }
   956 
   957 # This function extracts a tarball to the specified directory, but
   958 # only if the tarball exists
   959 # Usage: CT_DoExtractTarballIfExists <tarball_basename> <dir> [extra_tar_options [...]]
   960 CT_DoExtractTarballIfExists() {
   961     local tarball="$1"
   962     local dir="$2"
   963     shift 2
   964     local -a extra_tar_opts=( "$@" )
   965     local -a uncompress
   966 
   967     case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
   968         y)  uncompress=( gzip -c -d ); tar_ext=.gz;;
   969         *)  uncompress=( cat );        tar_ext=;;
   970     esac
   971 
   972     if [ -f "${tarball}.tar${tar_ext}" ]; then
   973         CT_DoLog DEBUG "  Restoring '${dir}'"
   974         CT_DoForceRmdir "${dir}"
   975         CT_DoExecLog DEBUG mkdir -p "${dir}"
   976         { "${uncompress[@]}" "${tarball}.tar${tar_ext}"     \
   977           |tar x -C "${dir}" -v -f - "${extra_tar_opts[@]}" ;
   978         } 2>&1 |sed -r -e 's/^/    /;' |CT_DoLog STATE
   979     else
   980         CT_DoLog STATE "  Not restoring '${dir}': does not exist"
   981     fi
   982 }
   983 
   984 # This function saves the state of the toolchain to be able to restart
   985 # at any one point
   986 # Usage: CT_DoSaveState <next_step_name>
   987 CT_DoSaveState() {
   988 	[ "${CT_DEBUG_CT_SAVE_STEPS}" = "y" ] || return 0
   989     local state_name="$1"
   990     local state_dir="${CT_STATE_DIR}/${state_name}"
   991 
   992     # Log this to the log level required by the user
   993     CT_DoLog ${CT_LOG_LEVEL_MAX} "Saving state to restart at step '${state_name}'..."
   994 
   995     rm -rf "${state_dir}"
   996     mkdir -p "${state_dir}"
   997 
   998     CT_DoLog STATE "  Saving environment and aliases"
   999     # We must omit shell functions, and some specific bash variables
  1000     # that break when restoring the environment, later. We could do
  1001     # all the processing in the awk script, but a sed is easier...
  1002     set |awk '
  1003               BEGIN { _p = 1; }
  1004               $0~/^[^ ]+ \(\)/ { _p = 0; }
  1005               _p == 1
  1006               $0 == "}" { _p = 1; }
  1007               ' |sed -r -e '/^BASH_(ARGC|ARGV|LINENO|SOURCE|VERSINFO)=/d;
  1008                            /^(UID|EUID)=/d;
  1009                            /^(FUNCNAME|GROUPS|PPID|SHELLOPTS)=/d;' >"${state_dir}/env.sh"
  1010 
  1011     if [ "${CT_COMPLIBS_BACKUP}" = "y" ]; then
  1012         CT_DoTarballIfExists "${CT_COMPLIBS_DIR}" "${state_dir}/complibs_dir"
  1013     fi
  1014     CT_DoTarballIfExists "${CT_CONFIG_DIR}" "${state_dir}/config_dir"
  1015     CT_DoTarballIfExists "${CT_CC_CORE_STATIC_PREFIX_DIR}" "${state_dir}/cc_core_static_prefix_dir"
  1016     CT_DoTarballIfExists "${CT_CC_CORE_SHARED_PREFIX_DIR}" "${state_dir}/cc_core_shared_prefix_dir"
  1017     CT_DoTarballIfExists "${CT_PREFIX_DIR}" "${state_dir}/prefix_dir" --exclude '*.log'
  1018 
  1019     if [ "${CT_LOG_TO_FILE}" = "y" ]; then
  1020         CT_DoLog STATE "  Saving log file"
  1021         exec >/dev/null
  1022         case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
  1023             y)  gzip -3 -c "${CT_LOG_FILE}"  >"${state_dir}/log.gz";;
  1024             *)  cat "${CT_LOG_FILE}" >"${state_dir}/log";;
  1025         esac
  1026         exec >>"${CT_LOG_FILE}"
  1027     fi
  1028 }
  1029 
  1030 # This function restores a previously saved state
  1031 # Usage: CT_DoLoadState <state_name>
  1032 CT_DoLoadState(){
  1033     local state_name="$1"
  1034     local state_dir="${CT_STATE_DIR}/${state_name}"
  1035     local old_RESTART="${CT_RESTART}"
  1036     local old_STOP="${CT_STOP}"
  1037 
  1038     CT_TestOrAbort "The previous build did not reach the point where it could be restarted at '${CT_RESTART}'" -d "${state_dir}"
  1039 
  1040     # We need to do something special with the log file!
  1041     if [ "${CT_LOG_TO_FILE}" = "y" ]; then
  1042         exec >"${state_dir}/tail.log"
  1043     fi
  1044 
  1045     # Log this to the log level required by the user
  1046     CT_DoLog ${CT_LOG_LEVEL_MAX} "Restoring state at step '${state_name}', as requested."
  1047 
  1048     CT_DoExtractTarballIfExists "${state_dir}/prefix_dir" "${CT_PREFIX_DIR}"
  1049     CT_DoExtractTarballIfExists "${state_dir}/cc_core_shared_prefix_dir" "${CT_CC_CORE_SHARED_PREFIX_DIR}"
  1050     CT_DoExtractTarballIfExists "${state_dir}/cc_core_static_prefix_dir" "${CT_CC_CORE_STATIC_PREFIX_DIR}"
  1051     CT_DoExtractTarballIfExists "${state_dir}/config_dir" "${CT_CONFIG_DIR}"
  1052     if [ "${CT_COMPLIBS_BACKUP}" = "y" ]; then
  1053         CT_DoExtractTarballIfExists "${state_dir}/complibs_dir" "${CT_COMPLIBS_DIR}"
  1054     fi
  1055 
  1056     # Restore the environment, discarding any error message
  1057     # (for example, read-only bash internals)
  1058     CT_DoLog STATE "  Restoring environment"
  1059     . "${state_dir}/env.sh" >/dev/null 2>&1 || true
  1060 
  1061     # Restore the new RESTART and STOP steps
  1062     CT_RESTART="${old_RESTART}"
  1063     CT_STOP="${old_STOP}"
  1064     unset old_stop old_restart
  1065 
  1066     if [ "${CT_LOG_TO_FILE}" = "y" ]; then
  1067         CT_DoLog STATE "  Restoring log file"
  1068         exec >/dev/null
  1069         case "${CT_DEBUG_CT_SAVE_STEPS_GZIP}" in
  1070             y)  zcat "${state_dir}/log.gz" >"${CT_LOG_FILE}";;
  1071             *)  cat "${state_dir}/log" >"${CT_LOG_FILE}";;
  1072         esac
  1073         cat "${state_dir}/tail.log" >>"${CT_LOG_FILE}"
  1074         exec >>"${CT_LOG_FILE}"
  1075         rm -f "${state_dir}/tail.log"
  1076     fi
  1077 }