Merge pull request #288 from bhundven/custom_locations_rewrite

Custom locations rewrite

17 files changed, 188 insertions, 283 deletions

diff --git a/scripts/addToolVersion.sh b/scripts/addToolVersion.sh
index bd419f8..0144e4f 100755
--- a/scripts/addToolVersion.sh
+++ b/scripts/addToolVersion.sh
@@ -14,37 +14,37 @@ myname="$0"
 
 doHelp() {
     cat <<-EOF
-		Usage: ${myname} <--tool> <[options] version [...]> ...
-		  'tool' in one of:
-		    gcc, binutils, glibc, uClibc, newlib, linux, gdb, dmalloc,
-		    duma, strace, ltrace, libelf, gmp, mpfr, isl, cloog, mpc,
-		    mingw-w64, expat, ncurses
-		
-		  Valid options for all tools:
-		    --stable, -s, +x   (default)
-		      mark the version as being stable (as opposed to experimental, below)
-		
-		    --experimental, -x, +s
-		      mark the version as being experimental (as opposed to stable, above)
-		
-		    --current, -c, +o   (default)
-		      mark the version as being cuurent (as opposed to obsolete, below)
-		
-		    --obsolete, -o, +c
-		      mark the version as being obsolete (as opposed to current, above)
-		
-		  Note: setting a new tool resets to the defaults: 'stable' and 'current'.
-		
-		  'version' is a valid version for the specified tool.
-		
-		  Examples:
-		    add stable current version 2.6.19.2 to linux kernel:
-		      ${myname} --linux 2.6.19.2
-		
-		    add experimental obsolete version 2.3.5 and stable current versions 2.6.1
-		    and 2.6.2 to glibc, add stable obsolete version 3.3.3 to gcc:
-		      ${myname} --glibc -x -o 2.3.5 -s -c 2.6.1 2.6.2 --gcc -o 3.3.3
-		EOF
+        Usage: ${myname} <--tool> <[options] version [...]> ...
+          'tool' in one of:
+            gcc, binutils, glibc, uClibc, newlib, linux, gdb, dmalloc,
+            duma, strace, ltrace, libelf, gmp, mpfr, isl, cloog, mpc,
+            mingw-w64, expat, ncurses
+
+          Valid options for all tools:
+            --stable, -s, +x   (default)
+              mark the version as being stable (as opposed to experimental, below)
+
+            --experimental, -x, +s
+              mark the version as being experimental (as opposed to stable, above)
+
+            --current, -c, +o   (default)
+              mark the version as being cuurent (as opposed to obsolete, below)
+
+            --obsolete, -o, +c
+              mark the version as being obsolete (as opposed to current, above)
+
+          Note: setting a new tool resets to the defaults: 'stable' and 'current'.
+
+          'version' is a valid version for the specified tool.
+
+          Examples:
+            add stable current version 2.6.19.2 to linux kernel:
+              ${myname} --linux 2.6.19.2
+
+            add experimental obsolete version 2.3.5 and stable current versions 2.6.1
+            and 2.6.2 to glibc, add stable obsolete version 3.3.3 to gcc:
+              ${myname} --glibc -x -o 2.3.5 -s -c 2.6.1 2.6.2 --gcc -o 3.3.3
+        EOF
 }
 
 # Extract field $3 from version $1 with separator $2
@@ -187,7 +187,7 @@ while [ $# -gt 0 ]; do
         --ltrace)   EXP=; OBS=; cat=LTRACE;         tool=ltrace;    tool_prefix=debug;          dot2suffix=;;
         --gmp)      EXP=; OBS=; cat=GMP;            tool=gmp;       tool_prefix=companion_libs; dot2suffix=;;
         --mpfr)     EXP=; OBS=; cat=MPFR;           tool=mpfr;      tool_prefix=companion_libs; dot2suffix=;;
-	--isl)      EXP=; OBS=; cat=ISL;            tool=isl;       tool_prefix=companion_libs; dot2suffix=;;
+        --isl)      EXP=; OBS=; cat=ISL;            tool=isl;       tool_prefix=companion_libs; dot2suffix=;;
         --cloog)    EXP=; OBS=; cat=CLOOG;          tool=cloog;     tool_prefix=companion_libs; dot2suffix=;;
         --mpc)      EXP=; OBS=; cat=MPC;            tool=mpc;       tool_prefix=companion_libs; dot2suffix=;;
         --libelf)   EXP=; OBS=; cat=LIBELF;         tool=libelf;    tool_prefix=companion_libs; dot2suffix=;;
diff --git a/scripts/build/arch/xtensa.sh b/scripts/build/arch/xtensa.sh
index 7e49312..c7bd432 100644
--- a/scripts/build/arch/xtensa.sh
+++ b/scripts/build/arch/xtensa.sh
@@ -22,13 +22,7 @@ CT_ConfigureXtensa() {
         custom_overlay="xtensa-overlay.tar"
     fi
 
-    if [ -n "${CT_CUSTOM_LOCATION_ROOT_DIR}" \
-         -a -z "${custom_location}" ]; then
-             custom_location="${CT_CUSTOM_LOCATION_ROOT_DIR}"
-    fi
-
-    CT_TestAndAbort "${custom_overlay}: CT_CUSTOM_LOCATION_ROOT_DIR or CT_ARCH_XTENSA_CUSTOM_OVERLAY_LOCATION must be set." \
-        -z "${CT_CUSTOM_LOCATION_ROOT_DIR}" -a -z "${custom_location}"
+    CT_TestAndAbort "${custom_overlay}: CT_ARCH_XTENSA_CUSTOM_OVERLAY_LOCATION must be set." -z "${custom_location}"
 
     local full_file="${custom_location}/${custom_overlay}"
     local basename="${component}-${version}"
diff --git a/scripts/build/binutils/binutils.sh b/scripts/build/binutils/binutils.sh
index afb797d..6318163 100644
--- a/scripts/build/binutils/binutils.sh
+++ b/scripts/build/binutils/binutils.sh
@@ -5,8 +5,8 @@
 # Download binutils
 do_binutils_get() {
     if [ "${CT_BINUTILS_CUSTOM}" = "y" ]; then
-        CT_GetCustom "binutils" "${CT_BINUTILS_VERSION}" \
-                     "${CT_BINUTILS_CUSTOM_LOCATION}"
+        CT_GetCustom "binutils" "${CT_BINUTILS_CUSTOM_VERSION}" \
+            "${CT_BINUTILS_CUSTOM_LOCATION}"
     else
         if echo ${CT_BINUTILS_VERSION} |${grep} -q linaro; then
             YYMM=`echo ${CT_BINUTILS_VERSION} |cut -d- -f3 |${sed} -e 's,^..,,'`
@@ -22,8 +22,8 @@ do_binutils_get() {
 
     if [ -n "${CT_ARCH_BINFMT_FLAT}" ]; then
         if [ "${CT_ELF2FLT_CUSTOM}" = "y" ]; then
-            CT_GetCustom "elf2flt" "${CT_ELF2FLT_VERSION}"  \
-                         "${CT_ELF2FLT_CUSTOM_LOCATION}"
+            CT_GetCustom "elf2flt" "${CT_ELF2FLT_CUSTOM_VERSION}" \
+                "${CT_ELF2FLT_CUSTOM_LOCATION}"
         else
             CT_GetGit elf2flt "${CT_ELF2FLT_GIT_CSET}" git://wh0rd.org/elf2flt.git
         fi
@@ -32,19 +32,12 @@ do_binutils_get() {
 
 # Extract binutils
 do_binutils_extract() {
-    # If using custom directory location, nothing to do
-    if ! [ "${CT_BINUTILS_CUSTOM}" = "y" \
-         -a -d "${CT_SRC_DIR}/binutils-${CT_BINUTILS_VERSION}" ]; then
-        CT_Extract "binutils-${CT_BINUTILS_VERSION}"
-        CT_Patch "binutils" "${CT_BINUTILS_VERSION}"
-    fi
+    CT_Extract "binutils-${CT_BINUTILS_VERSION}"
+    CT_Patch "binutils" "${CT_BINUTILS_VERSION}"
 
     if [ -n "${CT_ARCH_BINFMT_FLAT}" ]; then
-        if ! [ "${CT_ELF2FLT_CUSTOM}" = "y" \
-             -a -d "${CT_SRC_DIR}/elf2flt-${CT_ELF2FLT_VERSION}" ]; then
-            CT_Extract "elf2flt-${CT_ELF2FLT_GIT_CSET}"
-            CT_Patch "elf2flt" "${CT_ELF2FLT_GIT_CSET}"
-        fi
+        CT_Extract "elf2flt-${CT_ELF2FLT_GIT_CSET}"
+        CT_Patch "elf2flt" "${CT_ELF2FLT_GIT_CSET}"
     fi
 
     if [ -n "${CT_ARCH_XTENSA_CUSTOM_NAME}" ]; then
diff --git a/scripts/build/cc.sh b/scripts/build/cc.sh
index 3c8aaef..0db6b9c 100644
--- a/scripts/build/cc.sh
+++ b/scripts/build/cc.sh
@@ -38,21 +38,21 @@ do_cc_core_pass_1() {
 
 # Core pass 2 the cc facilities
 do_cc_core_pass_2() {
-	for f in ${CT_CC_FACILITY_LIST}; do
+    for f in ${CT_CC_FACILITY_LIST}; do
         do_${f}_core_pass_2
     done
 }
 
 # Build for build the cc facilities
 do_cc_for_build() {
-	for f in ${CT_CC_FACILITY_LIST}; do
+    for f in ${CT_CC_FACILITY_LIST}; do
         do_${f}_for_build
     done
 }
 
 # Build for host the cc facilities
 do_cc_for_host() {
-	for f in ${CT_CC_FACILITY_LIST}; do
+    for f in ${CT_CC_FACILITY_LIST}; do
         do_${f}_for_host
     done
 }
diff --git a/scripts/build/cc/100-gcc.sh b/scripts/build/cc/100-gcc.sh
index 359bb15..0640452 100644
--- a/scripts/build/cc/100-gcc.sh
+++ b/scripts/build/cc/100-gcc.sh
@@ -8,7 +8,8 @@ do_gcc_get() {
     local linaro_series=""
 
     if [ "${CT_CC_GCC_CUSTOM}" = "y" ]; then
-        CT_GetCustom "gcc" "${CT_CC_GCC_VERSION}" "${CT_CC_GCC_CUSTOM_LOCATION}"
+        CT_GetCustom "gcc" "${CT_CC_GCC_CUSTOM_VERSION}" \
+            "${CT_CC_GCC_CUSTOM_LOCATION}"
     else
         # Account for the Linaro versioning
         linaro_version="$( echo "${CT_CC_GCC_VERSION}"  \
@@ -48,12 +49,6 @@ do_gcc_get() {
 
 # Extract gcc
 do_gcc_extract() {
-    # If using custom directory location, nothing to do
-    if [ "${CT_CC_GCC_CUSTOM}" = "y"                    \
-         -a -d "${CT_SRC_DIR}/gcc-${CT_CC_GCC_VERSION}" ]; then
-        return 0
-    fi
-
     CT_Extract "gcc-${CT_CC_GCC_VERSION}"
     CT_Patch "gcc" "${CT_CC_GCC_VERSION}"
 
@@ -148,7 +143,7 @@ do_gcc_core_pass_2() {
             ;;
         *)
             core_opts+=( "mode=static" )
-	    core_opts+=( "build_libgcc=yes" )
+            core_opts+=( "build_libgcc=yes" )
             ;;
     esac
 
@@ -318,9 +313,9 @@ do_gcc_core_backend() {
         if [ "${CT_ISL}" = "y" ]; then
             extra_config+=("--with-isl=${complibs}")
         fi
-	if [ "${CT_CLOOG}" = "y" ]; then
-	    extra_config+=("--with-cloog=${complibs}")
-	fi
+        if [ "${CT_CLOOG}" = "y" ]; then
+            extra_config+=("--with-cloog=${complibs}")
+        fi
     elif [ "${CT_CC_GCC_HAS_GRAPHITE}" = "y" ]; then
         extra_config+=("--with-isl=no")
         extra_config+=("--with-cloog=no")
@@ -477,8 +472,8 @@ do_gcc_core_backend() {
             CT_DoExecLog ALL ${make} ${JOBSFLAGS} -C libbacktrace
         fi
 
-	libgcc_rule="libgcc.mvars"
-	core_targets=( gcc target-libgcc )
+        libgcc_rule="libgcc.mvars"
+        core_targets=( gcc target-libgcc )
 
         # On bare metal and canadian build the host-compiler is used when
         # actually the build-system compiler is required. Choose the correct
@@ -715,7 +710,7 @@ do_gcc_backend() {
         extra_config+=("--enable-cxx-flags=${CT_CC_GCC_ENABLE_CXX_FLAGS}")
     fi
     if [ "${CT_THREADS}" = "none" ]; then
-	extra_config+=(--disable-libatomic)
+        extra_config+=(--disable-libatomic)
     fi
     if [ "${CT_CC_GCC_LIBMUDFLAP}" = "y" ]; then
         extra_config+=(--enable-libmudflap)
@@ -795,9 +790,9 @@ do_gcc_backend() {
         if [ "${CT_ISL}" = "y" ]; then
             extra_config+=("--with-isl=${complibs}")
         fi
-	if [ "${CT_CLOOG}" = "y" ]; then
-	    extra_config+=("--with-cloog=${complibs}")
-	fi
+        if [ "${CT_CLOOG}" = "y" ]; then
+            extra_config+=("--with-cloog=${complibs}")
+        fi
     elif [ "${CT_CC_GCC_HAS_GRAPHITE}" = "y" ]; then
         extra_config+=("--with-isl=no")
         extra_config+=("--with-cloog=no")
diff --git a/scripts/build/companion_libs/130-cloog.sh b/scripts/build/companion_libs/130-cloog.sh
index 1b37167..2376570 100644
--- a/scripts/build/companion_libs/130-cloog.sh
+++ b/scripts/build/companion_libs/130-cloog.sh
@@ -87,9 +87,9 @@ do_cloog_backend() {
     done
 
     if [ "${CT_CLOOG_0_18_or_later}" = y ]; then
-	cloog_opts+=( --with-gmp=system --with-gmp-prefix="${prefix}" )
-	cloog_opts+=( --with-isl=system --with-isl-prefix="${prefix}" )
-	cloog_opts+=( --without-osl )
+        cloog_opts+=( --with-gmp=system --with-gmp-prefix="${prefix}" )
+        cloog_opts+=( --with-isl=system --with-isl-prefix="${prefix}" )
+        cloog_opts+=( --without-osl )
     fi
 
     CT_DoLog EXTRA "Configuring CLooG"
@@ -99,13 +99,13 @@ do_cloog_backend() {
     LDFLAGS="${ldflags}"                                \
     LIBS="-lm"                                          \
     "${CT_SRC_DIR}/cloog-${CT_CLOOG_VERSION}/configure" \
-	--build=${CT_BUILD}                             \
-	--host=${host}                                  \
-	--prefix="${prefix}"                            \
-	--with-bits=gmp                                 \
-	--with-host-libstdcxx='-lstdc++'                \
-	--disable-shared                                \
-	--enable-static                                 \
+        --build=${CT_BUILD}                             \
+        --host=${host}                                  \
+        --prefix="${prefix}"                            \
+        --with-bits=gmp                                 \
+        --with-host-libstdcxx='-lstdc++'                \
+        --disable-shared                                \
+        --enable-static                                 \
         "${cloog_opts[@]}"
 
     CT_DoLog EXTRA "Building CLooG"
diff --git a/scripts/build/debug/300-gdb.sh b/scripts/build/debug/300-gdb.sh
index beef5ff..418e85c 100644
--- a/scripts/build/debug/300-gdb.sh
+++ b/scripts/build/debug/300-gdb.sh
@@ -7,7 +7,8 @@ do_debug_gdb_get() {
     local linaro_series=""
 
     if [ "${CT_GDB_CUSTOM}" = "y" ]; then
-        CT_GetCustom "gdb" "${CT_GDB_VERSION}" "${CT_GDB_CUSTOM_LOCATION}"
+        CT_GetCustom "gdb" "${CT_GDB_CUSTOM_VERSION}" \
+            "${CT_GDB_CUSTOM_LOCATION}"
     else
         # Account for the Linaro versioning
         linaro_version="$( echo "${CT_GDB_VERSION}"      \
@@ -33,12 +34,6 @@ do_debug_gdb_get() {
 }
 
 do_debug_gdb_extract() {
-    # If using custom directory location, nothing to do
-    if [    "${CT_GDB_CUSTOM}" = "y" \
-         -a -d "${CT_SRC_DIR}/gdb-${CT_GDB_VERSION}" ]; then
-        return 0
-    fi
-
     CT_Extract "gdb-${CT_GDB_VERSION}"
     CT_Patch "gdb" "${CT_GDB_VERSION}"
 
@@ -100,10 +95,10 @@ do_debug_gdb_build() {
             LD_for_gdb="${CT_HOST}-ld -static"
         fi
 
-	# Disable binutils options when building from the binutils-gdb repo.
-	cross_extra_config+=("--disable-binutils")
-	cross_extra_config+=("--disable-ld")
-	cross_extra_config+=("--disable-gas")
+    # Disable binutils options when building from the binutils-gdb repo.
+    cross_extra_config+=("--disable-binutils")
+    cross_extra_config+=("--disable-ld")
+    cross_extra_config+=("--disable-gas")
 
         CT_DoLog DEBUG "Extra config passed: '${cross_extra_config[*]}'"
 
@@ -191,10 +186,10 @@ do_debug_gdb_build() {
 
         export ac_cv_func_strncmp_works=yes
 
-	# Disable binutils options when building from the binutils-gdb repo.
-	native_extra_config+=("--disable-binutils")
-	native_extra_config+=("--disable-ld")
-	native_extra_config+=("--disable-gas")
+        # Disable binutils options when building from the binutils-gdb repo.
+        native_extra_config+=("--disable-binutils")
+        native_extra_config+=("--disable-ld")
+        native_extra_config+=("--disable-gas")
 
         CT_DoLog DEBUG "Extra config passed: '${native_extra_config[*]}'"
 
@@ -261,10 +256,10 @@ do_debug_gdb_build() {
             fi
         fi
 
-	# Disable binutils options when building from the binutils-gdb repo.
-	gdbserver_extra_config+=("--disable-binutils")
-	gdbserver_extra_config+=("--disable-ld")
-	gdbserver_extra_config+=("--disable-gas")
+        # Disable binutils options when building from the binutils-gdb repo.
+        gdbserver_extra_config+=("--disable-binutils")
+        gdbserver_extra_config+=("--disable-ld")
+        gdbserver_extra_config+=("--disable-gas")
 
         CT_DoExecLog CFG                                \
         CC="${CT_TARGET}-gcc"                           \
diff --git a/scripts/build/kernel/linux.sh b/scripts/build/kernel/linux.sh
index 49fe613..f0f2402 100644
--- a/scripts/build/kernel/linux.sh
+++ b/scripts/build/kernel/linux.sh
@@ -23,13 +23,9 @@ do_kernel_get() {
     local rel_dir
     local korg_base mirror_base
 
-    if [ "${CT_KERNEL_LINUX_USE_CUSTOM_HEADERS}" = "y"  ]; then
-        return 0
-    fi
-
     if [ "${CT_KERNEL_LINUX_CUSTOM}" = "y" ]; then
-        CT_GetCustom "linux" "${CT_KERNEL_VERSION}"     \
-                     "${CT_KERNEL_LINUX_CUSTOM_LOCATION}"
+        CT_GetCustom "linux" "${CT_KERNEL_LINUX_CUSTOM_VERSION}" \
+            "${CT_KERNEL_LINUX_CUSTOM_LOCATION}"
     else # Not a custom tarball
         case "${CT_KERNEL_VERSION}" in
             2.6.*.*|3.*.*|4.*.*)
@@ -59,11 +55,6 @@ do_kernel_get() {
 
 # Extract kernel
 do_kernel_extract() {
-    # If using a custom headers tree, nothing to do
-    if [ "${CT_KERNEL_LINUX_USE_CUSTOM_HEADERS}" = "y" ]; then
-        return 0
-    fi
-
     # If using a custom directory location, nothing to do
     if [ "${CT_KERNEL_LINUX_CUSTOM}" = "y"    \
          -a -d "${CT_SRC_DIR}/linux-${CT_KERNEL_VERSION}" ]; then
@@ -81,32 +72,16 @@ do_kernel_extract() {
     CT_Patch "linux" "${CT_KERNEL_VERSION}"
 }
 
-# Wrapper to the actual headers install method
-do_kernel_headers() {
-    CT_DoStep INFO "Installing kernel headers"
-
-    if [ "${CT_KERNEL_LINUX_USE_CUSTOM_HEADERS}" = "y" ]; then
-        do_kernel_custom
-    else
-        do_kernel_install
-    fi
-
-    CT_EndStep
-}
-
 # Install kernel headers using headers_install from kernel sources.
-do_kernel_install() {
+do_kernel_headers() {
     local kernel_path
     local kernel_arch
 
-    CT_DoLog DEBUG "Using kernel's headers_install"
+    CT_DoStep INFO "Installing kernel headers"
 
     mkdir -p "${CT_BUILD_DIR}/build-kernel-headers"
 
     kernel_path="${CT_SRC_DIR}/linux-${CT_KERNEL_VERSION}"
-    if [ "${CT_KERNEL_LINUX_CUSTOM}" = "y" ]; then
-        kernel_path="${CT_SRC_DIR}/linux-custom"
-    fi
     V_OPT="V=${CT_KERNEL_LINUX_VERBOSE_LEVEL}"
 
     kernel_arch="${CT_ARCH}"
@@ -145,28 +120,6 @@ do_kernel_install() {
                                 -o -name '..check.cmd'      \
                              \)                             \
                              -exec rm {} \;
-}
 
-# Use custom headers (most probably by using make headers_install in a
-# modified (read: customised) kernel tree, or using pre-2.6.18 headers, such
-# as 2.4). In this case, simply copy the headers in place
-do_kernel_custom() {
-    local tar_opt
-
-    CT_DoLog EXTRA "Installing custom kernel headers"
-
-    mkdir -p "${CT_SYSROOT_DIR}/usr"
-    cd "${CT_SYSROOT_DIR}/usr"
-    if [ "${CT_KERNEL_LINUX_CUSTOM_IS_TARBALL}" = "y" ]; then
-        case "${CT_KERNEL_LINUX_CUSTOM_PATH}" in
-            *.tar)      ;;
-            *.tgz)      tar_opt=--gzip;;
-            *.tar.gz)   tar_opt=--gzip;;
-            *.tar.bz2)  tar_opt=--bzip2;;
-            *.tar.xz)   tar_opt=--xz;;
-        esac
-        CT_DoExecLog ALL tar x ${tar_opt} -vf ${CT_KERNEL_LINUX_CUSTOM_PATH}
-    else
-        CT_DoExecLog ALL cp -rv "${CT_KERNEL_LINUX_CUSTOM_PATH}/include" .
-    fi
+    CT_EndStep
 }
diff --git a/scripts/build/libc/avr-libc.sh b/scripts/build/libc/avr-libc.sh
index 103a795..b73f990 100644
--- a/scripts/build/libc/avr-libc.sh
+++ b/scripts/build/libc/avr-libc.sh
@@ -6,24 +6,14 @@ do_libc_get() {
     libc_src="http://download.savannah.gnu.org/releases/avr-libc"
 
     if [ "${CT_LIBC_AVR_LIBC_CUSTOM}" = "y" ]; then
-        CT_GetCustom "avr-libc" "${CT_LIBC_VERSION}"      \
-                     "${CT_LIBC_AVR_LIBC_CUSTOM_LOCATION}"
+        CT_GetCustom "avr-libc" "${CT_LIBC_AVR_LIBC_CUSTOM_VERSION}" \
+            "${CT_LIBC_AVR_LIBC_CUSTOM_LOCATION}"
     else # ! custom location
         CT_GetFile "avr-libc-${CT_LIBC_VERSION}" "${libc_src}"
     fi # ! custom location
 }
 
 do_libc_extract() {
-    # If using custom directory location, nothing to do.
-    if [ "${CT_LIBC_AVR_LIBC_CUSTOM}" = "y" ]; then
-        # Abort if the custom directory is not found.
-        if ! [ -d "${CT_SRC_DIR}/avr-libc-${CT_LIBC_VERSION}" ]; then
-            CT_Abort "Directory not found: ${CT_SRC_DIR}/avr-libc-${CT_LIBC_VERSION}"
-        fi
-
-        return 0
-    fi
-
     CT_Extract "avr-libc-${CT_LIBC_VERSION}"
     CT_Patch "avr-libc" "${CT_LIBC_VERSION}"
 }
diff --git a/scripts/build/libc/glibc.sh b/scripts/build/libc/glibc.sh
index 126e9e0..d45248a 100644
--- a/scripts/build/libc/glibc.sh
+++ b/scripts/build/libc/glibc.sh
@@ -6,16 +6,10 @@
 do_libc_extract() {
     local addon
 
-    # Attempt CT_EXTRACT only if NOT custom, or CUSTOM_LOCATION is not a directory
-    if [ "${CT_LIBC_CUSTOM}" != "y" \
-         -o ! -d "${CT_LIBC_CUSTOM_LOCATION}" ]; then
-        CT_Extract "${CT_LIBC}-${CT_LIBC_VERSION}"
-    fi
+    CT_Extract "${CT_LIBC}-${CT_LIBC_VERSION}"
     CT_Pushd "${CT_SRC_DIR}/${CT_LIBC}-${CT_LIBC_VERSION}"
     # Attempt CT_PATCH only if NOT custom
-    if [ "${CT_LIBC_CUSTOM}" != "y" ]; then
-        CT_Patch nochdir "${CT_LIBC}" "${CT_LIBC_VERSION}"
-    fi
+    CT_Patch nochdir "${CT_LIBC}" "${CT_LIBC_VERSION}"
 
     # Extract the add-opns if => 2.17
     if [ "${CT_LIBC_GLIBC_2_17_or_later}" != "y" ]; then
@@ -554,9 +548,9 @@ do_libc_get() {
     addons_list=($(do_libc_add_ons_list " "))
 
     # Main source
-    if [ "${CT_LIBC_CUSTOM}" = "y" ]; then
-        CT_GetCustom "glibc" "${CT_LIBC_VERSION}" "${CT_LIBC_GLIBC_CUSTOM_LOCATION}"
-        CT_LIBC_CUSTOM_LOCATION="${CT_SRC_DIR}/glibc-${CT_LIBC_VERSION}"
+    if [ "${CT_LIBC_GLIBC_CUSTOM}" = "y" ]; then
+        CT_GetCustom "glibc" "${CT_LIBC_GLIBC_CUSTOM_VERSION}" \
+            "${CT_LIBC_GLIBC_CUSTOM_LOCATION}"
     else
         if echo ${CT_LIBC_VERSION} |${grep} -q linaro; then
             # Linaro glibc releases come from regular downloads...
diff --git a/scripts/build/libc/musl.sh b/scripts/build/libc/musl.sh
index f8f135c..f7dbb97 100644
--- a/scripts/build/libc/musl.sh
+++ b/scripts/build/libc/musl.sh
@@ -8,24 +8,14 @@ do_libc_get() {
     libc_src="http://www.musl-libc.org/releases"
 
     if [ "${CT_LIBC_MUSL_CUSTOM}" = "y" ]; then
-        CT_GetCustom "musl" "${CT_LIBC_VERSION}"      \
-                     "${CT_LIBC_MUSL_CUSTOM_LOCATION}"
+        CT_GetCustom "musl" "${CT_LIBC_MUSL_CUSTOM_VERSION}" \
+            "${CT_LIBC_MUSL_CUSTOM_LOCATION}"
     else # ! custom location
         CT_GetFile "musl-${CT_LIBC_VERSION}" "${libc_src}"
     fi # ! custom location
 }
 
 do_libc_extract() {
-    # If using custom directory location, nothing to do.
-    if [ "${CT_LIBC_MUSL_CUSTOM}" = "y" ]; then
-        # Abort if the custom directory is not found.
-        if ! [ -d "${CT_SRC_DIR}/musl-${CT_LIBC_VERSION}" ]; then
-            CT_Abort "Directory not found: ${CT_SRC_DIR}/musl-${CT_LIBC_VERSION}"
-        fi
-
-        return 0
-    fi
-
     CT_Extract "musl-${CT_LIBC_VERSION}"
     CT_Patch "musl" "${CT_LIBC_VERSION}"
 }
diff --git a/scripts/build/libc/newlib.sh b/scripts/build/libc/newlib.sh
index a4fe82e..ba52268 100644
--- a/scripts/build/libc/newlib.sh
+++ b/scripts/build/libc/newlib.sh
@@ -14,8 +14,8 @@ do_libc_get() {
                      ftp://sourceware.org/pub/newlib}"
 
     if [ "${CT_LIBC_NEWLIB_CUSTOM}" = "y" ]; then
-        CT_GetCustom "newlib" "${CT_LIBC_VERSION}"      \
-                     "${CT_LIBC_NEWLIB_CUSTOM_LOCATION}"
+        CT_GetCustom "newlib" "${CT_LIBC_NEWLIB_CUSTOM_VERSION}" \
+            "${CT_LIBC_NEWLIB_CUSTOM_LOCATION}"
     else # ! custom location
         if echo ${CT_LIBC_VERSION} |${grep} -q linaro; then
             YYMM=`echo ${CT_LIBC_VERSION} |cut -d- -f3 |${sed} -e 's,^..,,'`
@@ -30,12 +30,6 @@ do_libc_get() {
 }
 
 do_libc_extract() {
-    # If using custom directory location, nothing to do
-    if [    "${CT_LIBC_NEWLIB_CUSTOM}" = "y"             \
-         -a -d "${CT_SRC_DIR}/newlib-${CT_LIBC_VERSION}" ]; then
-        return 0
-    fi
-
     CT_Extract "newlib-${CT_LIBC_VERSION}"
     CT_Patch "newlib" "${CT_LIBC_VERSION}"
 
diff --git a/scripts/build/libc/uClibc.sh b/scripts/build/libc/uClibc.sh
index f5b871c..422412c 100644
--- a/scripts/build/libc/uClibc.sh
+++ b/scripts/build/libc/uClibc.sh
@@ -19,8 +19,8 @@ fi
 # Download uClibc
 do_libc_get() {
     if [ "${CT_LIBC_UCLIBC_CUSTOM}" = "y" ]; then
-        CT_GetCustom "${uclibc_name}" "${CT_LIBC_VERSION}" \
-                     "${CT_LIBC_UCLIBC_CUSTOM_LOCATION}"
+        CT_GetCustom "${uclibc_name}" "${CT_LIBC_UCLIBC_CUSTOM_VERSION}" \
+            "${CT_LIBC_UCLIBC_CUSTOM_LOCATION}"
     else
         CT_GetFile "${uclibc_name}-${CT_LIBC_VERSION}" ${libc_src}
     fi
@@ -34,16 +34,8 @@ do_libc_get() {
 
 # Extract uClibc
 do_libc_extract() {
-    # If not using custom directory location, extract and patch
-    # Note: we do the inverse test we do in other components,
-    # because here we still need to extract the locales, even for
-    # custom location directory. Just use negate the whole test,
-    # to keep it the same as for other components.
-    if ! [ "${CT_LIBC_UCLIBC_CUSTOM}" = "y" \
-         -a -d "${CT_SRC_DIR}/${uclibc_name}-${CT_LIBC_VERSION}" ]; then
-        CT_Extract "${uclibc_name}-${CT_LIBC_VERSION}"
-        CT_Patch "${uclibc_name}" "${CT_LIBC_VERSION}"
-    fi
+    CT_Extract "${uclibc_name}-${CT_LIBC_VERSION}"
+    CT_Patch "${uclibc_name}" "${CT_LIBC_VERSION}"
 
     # uClibc locales
     # Extracting pregen locales ourselves is kinda
diff --git a/scripts/functions b/scripts/functions
index e266626..5a64232 100644
--- a/scripts/functions
+++ b/scripts/functions
@@ -1,4 +1,6 @@
-# This file contains some usefull common functions -*- sh -*-
+# -*- mode: sh; tab-width: 4 -*-
+# vi: ts=4:sw=4:sts=4:et
+# This file contains some usefull common functions
 # Copyright 2007 Yann E. MORIN
 # Licensed under the GPL v2. See COPYING in the root of this package
 
@@ -625,39 +627,58 @@ CT_GetLocal() {
 }
 
 # This function gets the custom source from either a tarball or directory
-# Usage: CT_GetCustom <component> <custom_version> <custom_location>
+# Usage: CT_GetCustom <name> <version> <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}"
+    local component_name="$1"
+    local component_version="$2"
+    local component_location="$3"
+
+    # Some local variables we use to help us figure out what to do
+    local component_location_type="dir" # str: 'file' or 'dir'
+    local component_location_filename="" # filename... if it's a file
+
+    CT_TestAndAbort \
+        "${component_name}: Custom location setting is empty" \
+        -z "${component_location}"
+
+    CT_TestAndAbort \
+        "${component_name}: Custom version setting is empty" \
+        -z "${component_version}"
+
+    if [ -f "${component_location}" ]; then
+        component_location_type="file"
+        component_location_filename="$(basename ${component_location})"
+    elif [ -d "${component_location}" ]; then
+        # Yes, it's the default, but it rules out the else case in the `if'.
+        component_location_type="dir"
+        # as -d and -f say: it's a <directory|file> and is readable!
+    else
+        CT_Abort "${component_name}: Unable to read ${component_location}, make sure the setting is correct and double check the permissions!"
     fi
 
-    CT_DoLog EXTRA "Using '${custom_name}' from custom location"
-    if [ ! -d "${custom_location}" ]; then
+    if [ "${component_location_type}" = "file" ]; then
+        CT_DoLog EXTRA "Got '${component_location}' from custom location"
         # 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}'";;
+        case "${component_location}" in
+            *.tar.xz|*.tar.bz2|*.tar.lzma|*.tar.gz|*.tgz|*.tar|*.zip) ;;
+            *) CT_Abort "Unknown extension for custom tarball '${component_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}"
+        [ ! -L "${CT_TARBALLS_DIR}/${component_location_filename}" ] && \
+            CT_DoExecLog DEBUG ln -sf "${component_location}" \
+            "${CT_TARBALLS_DIR}/${component_location_filename}"
+    elif [ "${component_location_type}" = "dir" ]; then
+        CT_DoLog EXTRA "Got '${component_location}' from custom location"
+        [ ! -d "${CT_SRC_DIR}/${component_name}-${component_version}" ] && \
+            CT_DoExecLog DEBUG cp -al "${component_location}" \
+            "${CT_SRC_DIR}/${component_name}-${component_version}"
+
+        # Don't try to extract from source directory, it's extracted!
+        touch "${CT_SRC_DIR}/.${component_name}-${component_version}.extracted"
     fi
+    # Don't patch a custom source, it's custom!
+    touch "${CT_SRC_DIR}/.${component_name}-${component_version}.patched"
 }
 
 # This function saves the specified to local storage if possible,
@@ -938,18 +959,18 @@ CT_Extract() {
     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
 
+    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 previously partially extracted
     if [ -e "${CT_SRC_DIR}/.${basename}.extracting" ]; then
         CT_DoLog ERROR "The '${basename}' sources were partially extracted."
diff --git a/scripts/patch-rework.sh b/scripts/patch-rework.sh
index 2809348..d05d2c1 100755
--- a/scripts/patch-rework.sh
+++ b/scripts/patch-rework.sh
@@ -11,35 +11,35 @@ diff="$@"
 
 do_help() {
     cat <<-_EOF_
-		${0##*/}: transform a patchset of non-p1 patches into -p1 patches
-		
-		Usage:
-		    ${0##*/} <basedir> <src> <dst> [diffopts ...]
-		
-		Where:
-		    basedir
-		        points to the directory of the component to patch
-		
-		    src
-		        points to the directory containing the existing patchset
-		        to transform
-		
-		    dst
-		        points to the directory where to put transformed patches
-		
-		    diffopts
-		        optional options to pass to diff, for debug purposes. You
-		        should not need it
-		
-		Example:
-		    Transform Gentoo patches against gcc-4.4.2 (some of which are
-		    -p0, -p1 or even -p2 patches) into all -p1 patches:
-		
-		        tar xjf gcc-4.4.2.tar.bz2
-		        patch-rework.sh gcc-4.4.2                   \\
-		                        /path/to/gentoo/gcc/patches \\
-		                        gcc-4.4.2.patches
-		_EOF_
+        ${0##*/}: transform a patchset of non-p1 patches into -p1 patches
+        
+        Usage:
+            ${0##*/} <basedir> <src> <dst> [diffopts ...]
+        
+        Where:
+            basedir
+                points to the directory of the component to patch
+        
+            src
+                points to the directory containing the existing patchset
+                to transform
+        
+            dst
+                points to the directory where to put transformed patches
+        
+            diffopts
+                optional options to pass to diff, for debug purposes. You
+                should not need it
+        
+        Example:
+            Transform Gentoo patches against gcc-4.4.2 (some of which are
+            -p0, -p1 or even -p2 patches) into all -p1 patches:
+        
+                tar xjf gcc-4.4.2.tar.bz2
+                patch-rework.sh gcc-4.4.2                   \\
+                                /path/to/gentoo/gcc/patches \\
+                                gcc-4.4.2.patches
+        _EOF_
 }
 
 # Sanity checks
@@ -48,8 +48,8 @@ if [    -z "${base}"                    \
      -o ! -d "${src}"                   \
      -o -e "${dst}" -a ! -d "${dst}"    \
    ]; then
-	do_help
-	exit 1
+    do_help
+    exit 1
 fi
 
 mkdir -p "${dst}"
diff --git a/scripts/saveSample.sh.in b/scripts/saveSample.sh.in
index 34e6594..a070dc2 100644
--- a/scripts/saveSample.sh.in
+++ b/scripts/saveSample.sh.in
@@ -37,12 +37,6 @@ if [ "${CT_CUSTOM_PATCH}" = "y" ]; then
     echo "You will not be able to (easily) share this sample in this case."
     read -p "Press Ctrl-C to stop now, or Enter to continue..."
 fi
-if [ "${CT_KERNEL_LINUX_USE_CUSTOM_HEADERS}" = "y" ]; then
-    exec >&7
-    echo "You are using custom Linux headers."
-    echo "You will not be able to (easily) share this sample in this case."
-    read -p "Press Ctrl-C to stop now, or Enter to continue..."
-fi
 
 # Do not use a progress bar
 unset CT_LOG_PROGRESS_BAR
diff --git a/scripts/showSamples.sh b/scripts/showSamples.sh
index b6d81c1..aed3dd1 100755
--- a/scripts/showSamples.sh
+++ b/scripts/showSamples.sh
@@ -69,7 +69,7 @@ dump_single_sample() {
             printf "    %-*s : %s\n" ${width} "OS" "${CT_KERNEL}${CT_KERNEL_VERSION:+-}${CT_KERNEL_VERSION}"
             if [    -n "${CT_GMP}"              \
                  -o -n "${CT_MPFR}"             \
-		 -o -n "${CT_ISL}"              \
+                 -o -n "${CT_ISL}"              \
                  -o -n "${CT_CLOOG}"            \
                  -o -n "${CT_MPC}"              \
                  -o -n "${CT_LIBELF}"           \
@@ -77,7 +77,7 @@ dump_single_sample() {
                  -o -n "${CT_NCURSES}"          \
                  -o -n "${CT_GMP_TARGET}"       \
                  -o -n "${CT_MPFR_TARGET}"      \
-		 -o -n "${CT_ISL_TARGET}"       \
+                 -o -n "${CT_ISL_TARGET}"       \
                  -o -n "${CT_CLOOG_TARGET}"     \
                  -o -n "${CT_MPC_TARGET}"       \
                  -o -n "${CT_LIBELF_TARGET}"    \
@@ -89,8 +89,8 @@ dump_single_sample() {
             fi
             [ -z "${CT_GMP}"     -a -z "${CT_GMP_TARGET}"     ] || printf " gmp-%s"       "${CT_GMP_VERSION}"
             [ -z "${CT_MPFR}"    -a -z "${CT_MPFR_TARGET}"    ] || printf " mpfr-%s"      "${CT_MPFR_VERSION}"
-	    [ -z "${CT_ISL}"     -a -z "${CT_ISL_TARGET}"     ] || printf " isl-%s"       "${CT_ISL_VERSION}"
-	    [ -z "${CT_CLOOG}"   -a -z "${CT_CLOOG_TARGET}"   ] || printf " cloog-%s"     "${CT_CLOOG_VERSION}"
+            [ -z "${CT_ISL}"     -a -z "${CT_ISL_TARGET}"     ] || printf " isl-%s"       "${CT_ISL_VERSION}"
+            [ -z "${CT_CLOOG}"   -a -z "${CT_CLOOG_TARGET}"   ] || printf " cloog-%s"     "${CT_CLOOG_VERSION}"
             [ -z "${CT_MPC}"     -a -z "${CT_MPC_TARGET}"     ] || printf " mpc-%s"       "${CT_MPC_VERSION}"
             [ -z "${CT_LIBELF}"  -a -z "${CT_LIBELF_TARGET}"  ] || printf " libelf-%s"    "${CT_LIBELF_VERSION}"
             [ -z "${CT_EXPAT}"   -a -z "${CT_EXPAT_TARGET}"   ] || printf " expat-%s"     "${CT_EXPAT_VERSION}"