Update cryptest.sh

author: Jeffrey Walton <noloader@gmail.com> 2022-05-07 10:22:41 -0400
committer: Jeffrey Walton <noloader@gmail.com> 2022-05-07 10:22:41 -0400
commit: 5208cca6178e8cf71e96cd8c6636887909f1a308 (patch)
tree: 0ee1f7fadfe4e739f712a06b72fafa3d5b6d4dc8 /TestScripts
parent: 59895be61b03f973416724cfe0274693ce73b6a1 (diff)
download: cryptopp-git-5208cca6178e8cf71e96cd8c6636887909f1a308.tar.gz
1 files changed, 445 insertions, 445 deletions
diff --git a/TestScripts/cryptest.sh b/TestScripts/cryptest.sh
index 35a0a110..1c47f308 100755
--- a/TestScripts/cryptest.sh
+++ b/TestScripts/cryptest.sh
@@ -50,7 +50,7 @@ if [[ (-z "$INSTALL_RESULTS") ]]; then
     INSTALL_RESULTS=cryptest-install.txt
 fi
 
-if [[ -z "$test_prog" ]]; then
+if [[ -z "${test_prog}" ]]; then
     test_prog="TestPrograms/test_cxx.cpp"
 fi
 
@@ -109,41 +109,41 @@ else
 fi
 
 THIS_SYSTEM=$(uname -s 2>&1)
-IS_AIX=$("$GREP" -i -c aix <<< "$THIS_SYSTEM")
-IS_DARWIN=$("$GREP" -i -c darwin <<< "$THIS_SYSTEM")
-IS_HURD=$("$GREP" -i -c gnu <<< "$THIS_SYSTEM")
-IS_LINUX=$("$GREP" -i -c linux <<< "$THIS_SYSTEM")
-IS_CYGWIN=$("$GREP" -i -c cygwin <<< "$THIS_SYSTEM")
-IS_MINGW=$("$GREP" -i -c mingw <<< "$THIS_SYSTEM")
-IS_OPENBSD=$("$GREP" -i -c openbsd <<< "$THIS_SYSTEM")
-IS_DRAGONFLY=$("$GREP" -i -c dragonfly <<< "$THIS_SYSTEM")
-IS_FREEBSD=$("$GREP" -i -c freebsd <<< "$THIS_SYSTEM")
-IS_NETBSD=$("$GREP" -i -c netbsd <<< "$THIS_SYSTEM")
-IS_SOLARIS=$("$GREP" -i -c sunos <<< "$THIS_SYSTEM")
-IS_BSD=$("$GREP" -i -c bsd <<< "$THIS_SYSTEM")
+IS_AIX=$("${GREP}" -i -c aix <<< "$THIS_SYSTEM")
+IS_DARWIN=$("${GREP}" -i -c darwin <<< "$THIS_SYSTEM")
+IS_HURD=$("${GREP}" -i -c gnu <<< "$THIS_SYSTEM")
+IS_LINUX=$("${GREP}" -i -c linux <<< "$THIS_SYSTEM")
+IS_CYGWIN=$("${GREP}" -i -c cygwin <<< "$THIS_SYSTEM")
+IS_MINGW=$("${GREP}" -i -c mingw <<< "$THIS_SYSTEM")
+IS_OPENBSD=$("${GREP}" -i -c openbsd <<< "$THIS_SYSTEM")
+IS_DRAGONFLY=$("${GREP}" -i -c dragonfly <<< "$THIS_SYSTEM")
+IS_FREEBSD=$("${GREP}" -i -c freebsd <<< "$THIS_SYSTEM")
+IS_NETBSD=$("${GREP}" -i -c netbsd <<< "$THIS_SYSTEM")
+IS_SOLARIS=$("${GREP}" -i -c sunos <<< "$THIS_SYSTEM")
+IS_BSD=$("${GREP}" -i -c bsd <<< "$THIS_SYSTEM")
 
 THIS_RELEASE=$(lsb_release -a 2>&1)
-IS_DEBIAN=$("$GREP" -i -c debian <<< "$THIS_RELEASE")
-IS_FEDORA=$("$GREP" -i -c fedora <<< "$THIS_RELEASE")
-IS_UBUNTU=$("$GREP" -i -c ubuntu <<< "$THIS_RELEASE")
-IS_SUSE=$("$GREP" -i -c opensuse <<< "$THIS_RELEASE")
+IS_DEBIAN=$("${GREP}" -i -c debian <<< "$THIS_RELEASE")
+IS_FEDORA=$("${GREP}" -i -c fedora <<< "$THIS_RELEASE")
+IS_UBUNTU=$("${GREP}" -i -c ubuntu <<< "$THIS_RELEASE")
+IS_SUSE=$("${GREP}" -i -c opensuse <<< "$THIS_RELEASE")
 
 THIS_MACHINE=$(uname -m 2>&1)
-IS_X86=$("$GREP" -i -c -E "(i386|i486|i686|i686)" <<< "$THIS_MACHINE")
-IS_X64=$("$GREP" -i -c -E "(amd64|x86_64)" <<< "$THIS_MACHINE")
-IS_PPC32=$("$GREP" -i -c -E "(Power|PPC)" <<< "$THIS_MACHINE")
-IS_PPC64=$("$GREP" -i -c -E "(Power64|PPC64)" <<< "$THIS_MACHINE")
-IS_ARM32=$("$GREP" -i -c -E "(arm|aarch32)" <<< "$THIS_MACHINE")
-IS_ARM64=$("$GREP" -i -c -E  "(arm64|aarch64)" <<< "$THIS_MACHINE")
-IS_S390=$("$GREP" -i -c "s390" <<< "$THIS_MACHINE")
-IS_SPARC=$("$GREP" -i -c "sparc" <<< "$THIS_MACHINE")
+IS_X86=$("${GREP}" -i -c -E "(i386|i486|i686|i686)" <<< "$THIS_MACHINE")
+IS_X64=$("${GREP}" -i -c -E "(amd64|x86_64)" <<< "$THIS_MACHINE")
+IS_PPC32=$("${GREP}" -i -c -E "(Power|PPC)" <<< "$THIS_MACHINE")
+IS_PPC64=$("${GREP}" -i -c -E "(Power64|PPC64)" <<< "$THIS_MACHINE")
+IS_ARM32=$("${GREP}" -i -c -E "(arm|aarch32)" <<< "$THIS_MACHINE")
+IS_ARM64=$("${GREP}" -i -c -E  "(arm64|aarch64)" <<< "$THIS_MACHINE")
+IS_S390=$("${GREP}" -i -c "s390" <<< "$THIS_MACHINE")
+IS_SPARC=$("${GREP}" -i -c "sparc" <<< "$THIS_MACHINE")
 IS_X32=0
 
 # Fixup
 if [[ "$IS_AIX" -ne 0 ]]; then
-    THIS_MACHINE="$(prtconf | "$GREP" -i "Processor Type" | head -n 1 | cut -f 2 -d ':')"
-    IS_PPC32=$("$GREP" -i -c -E "(Power|PPC)" <<< "$THIS_MACHINE")
-    IS_PPC64=$("$GREP" -i -c -E "(Power64|PPC64)" <<< "$THIS_MACHINE")
+    THIS_MACHINE="$(prtconf | "${GREP}" -i "Processor Type" | head -n 1 | cut -f 2 -d ':')"
+    IS_PPC32=$("${GREP}" -i -c -E "(Power|PPC)" <<< "$THIS_MACHINE")
+    IS_PPC64=$("${GREP}" -i -c -E "(Power64|PPC64)" <<< "$THIS_MACHINE")
 fi
 
 # Fixup
@@ -181,57 +181,57 @@ if [[ ("$IS_X86" -ne 0 || "$IS_X64" -ne 0) ]]; then
     elif [[ ("$IS_SOLARIS" -ne 0) ]]; then
         X86_CPU_FLAGS=$(isainfo -v 2>/dev/null)
     elif [[ ("$IS_FREEBSD" -ne 0) ]]; then
-        X86_CPU_FLAGS=$("$GREP" Features /var/run/dmesg.boot)
+        X86_CPU_FLAGS=$("${GREP}" Features /var/run/dmesg.boot)
     elif [[ ("$IS_DRAGONFLY" -ne 0) ]]; then
-        X86_CPU_FLAGS=$(dmesg | "$GREP" Features)
+        X86_CPU_FLAGS=$(dmesg | "${GREP}" Features)
     elif [[ ("$IS_HURD" -ne 0) ]]; then
         : # Do nothing... cpuid is not helpful at the moment
     else
-        X86_CPU_FLAGS="$($AWK '{IGNORECASE=1}{if ($1 == "flags"){print;exit}}' < /proc/cpuinfo | cut -f 2 -d ':')"
+        X86_CPU_FLAGS="$(${AWK} '{IGNORECASE=1}{if ($1 == "flags"){print;exit}}' < /proc/cpuinfo | cut -f 2 -d ':')"
     fi
 elif [[ ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0) ]]; then
     if [[ ("$IS_DARWIN" -ne 0) ]]; then
         ARM_CPU_FLAGS="$(sysctl machdep.cpu.features 2>&1 | cut -f 2 -d ':')"
         # Apple M1 hardware
-        if [[ $(sysctl hw.optional.arm64 2>&1 | "$GREP" -i 'hw.optional.arm64: 1') ]]; then
+        if [[ $(sysctl hw.optional.arm64 2>&1 | "${GREP}" -i 'hw.optional.arm64: 1') ]]; then
             ARM_CPU_FLAGS="asimd crc32 aes pmull sha1 sha2"
         fi
-        if [[ $(sysctl hw.optional.armv8_2_sha3 2>&1 | "$GREP" -i 'hw.optional.armv8_2_sha3: 1') ]]; then
+        if [[ $(sysctl hw.optional.armv8_2_sha3 2>&1 | "${GREP}" -i 'hw.optional.armv8_2_sha3: 1') ]]; then
             ARM_CPU_FLAGS+=" sha3"
         fi
-        if [[ $(sysctl hw.optional.armv8_2_sha512 2>&1 | "$GREP" -i 'hw.optional.armv8_2_sha512: 1') ]]; then
+        if [[ $(sysctl hw.optional.armv8_2_sha512 2>&1 | "${GREP}" -i 'hw.optional.armv8_2_sha512: 1') ]]; then
             ARM_CPU_FLAGS+=" sha512"
         fi
     else
-        ARM_CPU_FLAGS="$($AWK '{IGNORECASE=1}{if ($1 == "Features"){print;exit}}' < /proc/cpuinfo | cut -f 2 -d ':')"
+        ARM_CPU_FLAGS="$(${AWK} '{IGNORECASE=1}{if ($1 == "Features"){print;exit}}' < /proc/cpuinfo | cut -f 2 -d ':')"
     fi
 elif [[ ("$IS_PPC32" -ne 0 || "$IS_PPC64" -ne 0) ]]; then
     if [[ ("$IS_DARWIN" -ne 0) ]]; then
-        PPC_CPU_FLAGS="$(sysctl -a 2>&1 | "$GREP" machdep.cpu.features | cut -f 2 -d ':')"
+        PPC_CPU_FLAGS="$(sysctl -a 2>&1 | "${GREP}" machdep.cpu.features | cut -f 2 -d ':')"
         # PowerMac
-        if [[ $(sysctl hw.optional.altivec 2>&1 | "$GREP" -i 'hw.optional.altivec: 1') ]]; then
+        if [[ $(sysctl hw.optional.altivec 2>&1 | "${GREP}" -i 'hw.optional.altivec: 1') ]]; then
             PPC_CPU_FLAGS+=" altivec"
         fi
     elif [[ ("$IS_AIX" -ne 0) ]]; then
-        CPUINFO="$(prtconf | "$GREP" -i "Processor Type" | head -n 1 | cut -f 2 -d ':')"
-        if echo -n "$CPUINFO" | "$GREP" -q -i -c "power9"; then
+        CPUINFO="$(prtconf | "${GREP}" -i "Processor Type" | head -n 1 | cut -f 2 -d ':')"
+        if echo -n "$CPUINFO" | "${GREP}" -q -i -c "power9"; then
             PPC_CPU_FLAGS="power9 power8 power7 altivec"
-        elif echo -n "$CPUINFO" | "$GREP" -q -i -c "power8"; then
+        elif echo -n "$CPUINFO" | "${GREP}" -q -i -c "power8"; then
             PPC_CPU_FLAGS="power8 power7 altivec"
-        elif echo -n "$CPUINFO" | "$GREP" -q -i -c "power7"; then
+        elif echo -n "$CPUINFO" | "${GREP}" -q -i -c "power7"; then
             PPC_CPU_FLAGS="power7 altivec"
-        elif echo -n "$CPUINFO" | "$GREP" -q -i -c "altivec"; then
+        elif echo -n "$CPUINFO" | "${GREP}" -q -i -c "altivec"; then
             PPC_CPU_FLAGS="altivec"
         fi
     else
-        CPUINFO="$("$GREP" "cpu" /proc/cpuinfo | head -n 1 | cut -f 2 -d ':')"
-        if echo -n "$CPUINFO" | "$GREP" -q -i -c "power9"; then
+        CPUINFO="$("${GREP}" "cpu" /proc/cpuinfo | head -n 1 | cut -f 2 -d ':')"
+        if echo -n "$CPUINFO" | "${GREP}" -q -i -c "power9"; then
             PPC_CPU_FLAGS="power9 power8 power7 altivec"
-        elif echo -n "$CPUINFO" | "$GREP" -q -i -c "power8"; then
+        elif echo -n "$CPUINFO" | "${GREP}" -q -i -c "power8"; then
             PPC_CPU_FLAGS="power8 power7 altivec"
-        elif echo -n "$CPUINFO" | "$GREP" -q -i -c "power7"; then
+        elif echo -n "$CPUINFO" | "${GREP}" -q -i -c "power7"; then
             PPC_CPU_FLAGS="power7 altivec"
-        elif echo -n "$CPUINFO" | "$GREP" -q -i -c "altivec"; then
+        elif echo -n "$CPUINFO" | "${GREP}" -q -i -c "altivec"; then
             PPC_CPU_FLAGS="altivec"
         fi
     fi
@@ -240,13 +240,13 @@ fi
 for ARG in "$@"
 do
     # Recognize "fast" and "quick", which does not perform tests that take more time to execute
-    if [[ ($("$GREP" -ix "fast" <<< "$ARG") || $("$GREP" -ix "quick" <<< "$ARG")) ]]; then
+    if [[ ($("${GREP}" -ix "fast" <<< "$ARG") || $("${GREP}" -ix "quick" <<< "$ARG")) ]]; then
         HAVE_VALGRIND=0
         WANT_BENCHMARKS=0
     # Recognize "farm" and "nice", which uses 1/2 the CPU cores in accordance with GCC Compile Farm policy
-    elif [[ ($("$GREP" -ix "farm" <<< "$ARG") || $("$GREP" -ix "nice" <<< "$ARG")) ]]; then
+    elif [[ ($("${GREP}" -ix "farm" <<< "$ARG") || $("${GREP}" -ix "nice" <<< "$ARG")) ]]; then
         WANT_NICE=1
-    elif [[ ($("$GREP" -ix "orig" <<< "$ARG") || $("$GREP" -ix "original" <<< "$ARG") || $("$GREP" -ix "config.h" <<< "$ARG")) ]]; then
+    elif [[ ($("${GREP}" -ix "orig" <<< "$ARG") || $("${GREP}" -ix "original" <<< "$ARG") || $("${GREP}" -ix "config.h" <<< "$ARG")) ]]; then
         git checkout config.h &>/dev/null
     else
         echo "Unknown option $ARG"
@@ -255,8 +255,8 @@ done
 
 # We need to use the C++ compiler to determine feature availablility. Otherwise
 #   mis-detections occur on a number of platforms.
-if [[ ((-z "$CXX") || ("$CXX" == "gcc")) ]]; then
-    if [[ ("$CXX" == "gcc") ]]; then
+if [[ ((-z "${CXX}") || ("${CXX}" == "gcc")) ]]; then
+    if [[ ("${CXX}" == "gcc") ]]; then
         CXX="g++"
     elif [[ "$IS_DARWIN" -ne 0 ]]; then
         CXX="c++"
@@ -291,31 +291,31 @@ if [[ ((-z "$CXX") || ("$CXX" == "gcc")) ]]; then
     fi
 fi
 
-SUN_COMPILER=$("$CXX" -V 2>&1 | "$GREP" -i -c -E "CC: (Sun|Studio)")
-GCC_COMPILER=$("$CXX" --version 2>&1 | "$GREP" -i -v "clang" | "$GREP" -i -c -E "(gcc|g\+\+)")
-XLC_COMPILER=$("$CXX" -qversion 2>&1 | "$GREP" -i -c "IBM XL")
-INTEL_COMPILER=$("$CXX" --version 2>&1 | "$GREP" -i -c "\(icc\)")
-MACPORTS_COMPILER=$("$CXX" --version 2>&1 | "$GREP" -i -c "MacPorts")
-CLANG_COMPILER=$("$CXX" --version 2>&1 | "$GREP" -i -c "clang")
-GNU_LINKER=$(ld --version 2>&1 | "$GREP" -i -c "GNU ld")
+SUN_COMPILER=$("${CXX}" -V 2>&1 | "${GREP}" -i -c -E "CC: (Sun|Studio)")
+GCC_COMPILER=$("${CXX}" --version 2>&1 | "${GREP}" -i -v "clang" | "${GREP}" -i -c -E "(gcc|g\+\+)")
+XLC_COMPILER=$("${CXX}" -qversion 2>&1 | "${GREP}" -i -c "IBM XL")
+INTEL_COMPILER=$("${CXX}" --version 2>&1 | "${GREP}" -i -c "\(icc\)")
+MACPORTS_COMPILER=$("${CXX}" --version 2>&1 | "${GREP}" -i -c "MacPorts")
+CLANG_COMPILER=$("${CXX}" --version 2>&1 | "${GREP}" -i -c "clang")
+GNU_LINKER=$(ld --version 2>&1 | "${GREP}" -i -c "GNU ld")
 
 if [[ ("$SUN_COMPILER" -eq 0) ]]; then
-    AMD64=$("$CXX" -dM -E - </dev/null 2>/dev/null | "$GREP" -i -c -E "(__x64_64__|__amd64__)")
-    ILP32=$("$CXX" -dM -E - </dev/null 2>/dev/null | "$GREP" -i -c -E "(__ILP32__|__ILP32)")
+    AMD64=$("${CXX}" -dM -E - </dev/null 2>/dev/null | "${GREP}" -i -c -E "(__x64_64__|__amd64__)")
+    ILP32=$("${CXX}" -dM -E - </dev/null 2>/dev/null | "${GREP}" -i -c -E "(__ILP32__|__ILP32)")
     if [[ ("$AMD64" -ne 0) && ("$ILP32" -ne 0) ]]; then
         IS_X32=1
     fi
 fi
 
 # Now that the compiler is fixed, determine the compiler version for fixups
-CXX_VERSION=$("$CXX" -v 2>&1)
-GCC_4_8=$("$GREP" -i -c -E 'gcc version 4\.8' <<< "$CXX_VERSION")
-GCC_4_8_OR_ABOVE=$("$GREP" -i -c -E 'gcc version (4\.[8-9]|[5-9]\.[0-9])' <<< "$CXX_VERSION")
-GCC_11_0_OR_ABOVE=$("$GREP" -i -c -E 'gcc \(GCC\) (1[1-9]\.|[2-9][0-9]\.)' <<< "$CXX_VERSION")
-GCC_12_0_OR_ABOVE=$("$GREP" -i -c -E 'gcc \(GCC\) (1[2-9]\.|[2-9][0-9]\.)' <<< "$CXX_VERSION")
+CXX_VERSION=$("${CXX}" -v 2>&1)
+GCC_4_8=$("${GREP}" -i -c -E 'gcc version 4\.8' <<< "${CXX_VERSION}")
+GCC_4_8_OR_ABOVE=$("${GREP}" -i -c -E 'gcc version (4\.[8-9]|[5-9]\.[0-9])' <<< "${CXX_VERSION}")
+GCC_11_0_OR_ABOVE=$("${GREP}" -i -c -E 'gcc \(GCC\) (1[1-9]\.|[2-9][0-9]\.)' <<< "${CXX_VERSION}")
+GCC_12_0_OR_ABOVE=$("${GREP}" -i -c -E 'gcc \(GCC\) (1[2-9]\.|[2-9][0-9]\.)' <<< "${CXX_VERSION}")
 
-CXX_VERSION=$("$CXX" -V 2>&1)
-SUNCC_5_10_OR_ABOVE=$("$GREP" -c -E "CC: (Sun|Studio) .* (5\.1[0-9]|5\.[2-9]|[6-9]\.)" <<< "$CXX_VERSION")
+CXX_VERSION=$("${CXX}" -V 2>&1)
+SUNCC_5_10_OR_ABOVE=$("${GREP}" -c -E "CC: (Sun|Studio) .* (5\.1[0-9]|5\.[2-9]|[6-9]\.)" <<< "${CXX_VERSION}")
 
 # Fixup, bad code generation
 if [[ ("$SUNCC_5_10_OR_ABOVE" -ne 0) ]]; then
@@ -349,7 +349,7 @@ rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_CXX17") ]]; then
     HAVE_CXX17=0
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -std=c++17 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=c++17 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_CXX17=1
     fi
@@ -358,7 +358,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_GNU17") ]]; then
     HAVE_GNU17=0
-    "$CXX" -std=gnu++17 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=gnu++17 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_GNU17=1
     fi
@@ -368,7 +368,7 @@ rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_CXX20") ]]; then
     HAVE_CXX20=0
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -std=c++20 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=c++20 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_CXX20=1
     fi
@@ -377,7 +377,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_GNU20") ]]; then
     HAVE_GNU20=0
-    "$CXX" -std=gnu++20 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=gnu++20 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_GNU20=1
     fi
@@ -386,7 +386,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_CXX14") ]]; then
     HAVE_CXX14=0
-    "$CXX" -std=c++14 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=c++14 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_CXX14=1
     fi
@@ -395,7 +395,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_GNU14") ]]; then
     HAVE_GNU14=0
-    "$CXX" -std=gnu++14 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=gnu++14 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_GNU14=1
     fi
@@ -404,7 +404,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_CXX11") ]]; then
     HAVE_CXX11=0
-    "$CXX" -std=c++11 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=c++11 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_CXX11=1
     fi
@@ -413,7 +413,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_GNU11") ]]; then
     HAVE_GNU11=0
-    "$CXX" -std=gnu++11 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=gnu++11 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_GNU11=1
     fi
@@ -422,7 +422,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_CXX03") ]]; then
     HAVE_CXX03=0
-    "$CXX" -std=c++03 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=c++03 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_CXX03=1
     fi
@@ -431,7 +431,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_GNU03") ]]; then
     HAVE_GNU03=0
-    "$CXX" -std=gnu++03 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -std=gnu++03 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_GNU03=1
     fi
@@ -441,7 +441,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_LIBSTDCXX") ]]; then
     HAVE_LIBSTDCXX=0
-    "$CXX" -stdlib=libstdc++ "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -stdlib=libstdc++ "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         HAVE_LIBSTDCXX=1
     fi
@@ -450,12 +450,12 @@ fi
 # Use a fallback strategy so OPT_O0 can be used with DEBUG_CXXFLAGS
 OPT_O0=
 rm -f "${TMPDIR}/test.exe" &>/dev/null
-"$CXX" -O0 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+"${CXX}" -O0 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
 if [[ ("$?" -eq 0) ]]; then
     OPT_O0=-O0
 else
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -xO0 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -xO0 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         OPT_O0=-xO0
     fi
@@ -464,13 +464,13 @@ fi
 # Use a fallback strategy so OPT_O1 can be used with VALGRIND_CXXFLAGS
 OPT_O1=
 rm -f "${TMPDIR}/test.exe" &>/dev/null
-"$CXX" -O1 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+"${CXX}" -O1 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
 if [[ ("$?" -eq 0) ]]; then
     HAVE_O1=1
     OPT_O1=-O1
 else
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -xO1 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -xO1 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         HAVE_O1=1
         OPT_O1=-xO1
@@ -480,13 +480,13 @@ fi
 # https://github.com/weidai11/cryptopp/issues/588
 OPT_O2=
 rm -f "${TMPDIR}/test.exe" &>/dev/null
-"$CXX" -O2 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+"${CXX}" -O2 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
 if [[ ("$?" -eq 0) ]]; then
     HAVE_O2=1
     OPT_O2=-O2
 else
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -xO2 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -xO2 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         HAVE_O2=1
         OPT_O2=-xO2
@@ -496,13 +496,13 @@ fi
 # Use a fallback strategy so OPT_O3 can be used with RELEASE_CXXFLAGS
 OPT_O3=
 rm -f "${TMPDIR}/test.exe" &>/dev/null
-"$CXX" -O3 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+"${CXX}" -O3 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
 if [[ ("$?" -eq 0) ]]; then
     HAVE_O3=1
     OPT_O3=-O3
 else
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -xO3 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -xO3 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         HAVE_O3=1
         OPT_O3=-xO3
@@ -514,7 +514,7 @@ if [[ (-z "$HAVE_OS") ]]; then
     HAVE_OS=0
     OPT_OS=
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -Os "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -Os "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         HAVE_OS=1
         OPT_OS=-Os
@@ -526,7 +526,7 @@ if [[ (-z "$HAVE_OZ") ]]; then
     HAVE_OZ=0
     OPT_OZ=
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -Oz "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -Oz "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         HAVE_OZ=1
         OPT_OZ=-Oz
@@ -538,7 +538,7 @@ if [[ (-z "$HAVE_OFAST") ]]; then
     HAVE_OFAST=0
     OPT_OFAST=
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -Ofast "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -Ofast "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         HAVE_OFAST=1
         OPT_OFAST=-Ofast
@@ -548,12 +548,12 @@ fi
 # Use a fallback strategy so OPT_G2 can be used with RELEASE_CXXFLAGS
 OPT_G2=
 rm -f "${TMPDIR}/test.exe" &>/dev/null
-"$CXX" -g2 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+"${CXX}" -g2 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
 if [[ ("$?" -eq 0) ]]; then
     OPT_G2=-g2
 else
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -g "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -g "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         OPT_G2=-g
     fi
@@ -562,12 +562,12 @@ fi
 # Use a fallback strategy so OPT_G3 can be used with DEBUG_CXXFLAGS
 OPT_G3=
 rm -f "${TMPDIR}/test.exe" &>/dev/null
-"$CXX" -g3 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+"${CXX}" -g3 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
 if [[ ("$?" -eq 0) ]]; then
     OPT_G3=-g3
 else
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -g "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -g "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         OPT_G3=-g
     fi
@@ -578,7 +578,7 @@ OPT_PIC=
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_PIC") ]]; then
     HAVE_PIC=0
-    PIC_PROBLEMS=$("$CXX" -fPIC "$test_prog" -o "${TMPDIR}/test.exe" 2>&1 | "$GREP" -i -c -E  '(warning|error)')
+    PIC_PROBLEMS=$("${CXX}" -fPIC "${test_prog}" -o "${TMPDIR}/test.exe" 2>&1 | "${GREP}" -i -c -E  '(warning|error)')
     if [[ "$PIC_PROBLEMS" -eq 0 ]]; then
         HAVE_PIC=1
         OPT_PIC=-fPIC
@@ -592,7 +592,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_UBSAN") ]]; then
     HAVE_UBSAN=0
-    "$CXX" -fsanitize=undefined "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -fsanitize=undefined "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         "${TMPDIR}/test.exe" &>/dev/null
         if [[ ("$?" -eq 0) ]]; then
@@ -605,7 +605,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_ASAN") ]]; then
     HAVE_ASAN=0
-    "$CXX" -fsanitize=address "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -fsanitize=address "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         "${TMPDIR}/test.exe" &>/dev/null
         if [[ ("$?" -eq 0) ]]; then
@@ -618,7 +618,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_BSAN") ]]; then
     HAVE_BSAN=0
-    "$CXX" -fsanitize=bounds-strict "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -fsanitize=bounds-strict "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         "${TMPDIR}/test.exe" &>/dev/null
         if [[ ("$?" -eq 0) ]]; then
@@ -634,7 +634,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_ANALYZER") ]]; then
     HAVE_ANALYZER=0
-    "$CXX" -fanalyzer "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -fanalyzer "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         "${TMPDIR}/test.exe" &>/dev/null
         if [[ ("$?" -eq 0) ]]; then
@@ -647,7 +647,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_CET") ]]; then
     HAVE_CET=0
-    "$CXX" -fcf-protection=full -mcet "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -fcf-protection=full -mcet "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         "${TMPDIR}/test.exe" &>/dev/null
         if [[ ("$?" -eq 0) ]]; then
@@ -660,7 +660,7 @@ fi
 rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_REPTOLINE") ]]; then
     HAVE_REPTOLINE=0
-    "$CXX" -mfunction-return=thunk -mindirect-branch=thunk "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -mfunction-return=thunk -mindirect-branch=thunk "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         "${TMPDIR}/test.exe" &>/dev/null
         if [[ ("$?" -eq 0) ]]; then
@@ -673,25 +673,25 @@ rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_OMP") ]]; then
     HAVE_OMP=0
     if [[ "$GCC_COMPILER" -ne 0 ]]; then
-        "$CXX" -fopenmp -O3 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -fopenmp -O3 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             HAVE_OMP=1
             OMP_FLAGS=("-fopenmp" "-O3")
         fi
     elif [[ "$INTEL_COMPILER" -ne 0 ]]; then
-        "$CXX" -openmp -O3 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -openmp -O3 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             HAVE_OMP=1
             OMP_FLAGS=("-openmp" "-O3")
         fi
     elif [[ "$CLANG_COMPILER" -ne 0 ]]; then
-        "$CXX" -fopenmp=libomp -O3 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -fopenmp=libomp -O3 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             HAVE_OMP=1
             OMP_FLAGS=("-fopenmp=libomp" "-O3")
         fi
     elif [[ "$SUN_COMPILER" -ne 0 ]]; then
-        "$CXX" -xopenmp=parallel -xO3 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -xopenmp=parallel -xO3 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             HAVE_OMP=1
             OMP_FLAGS=("-xopenmp=parallel" "-xO3")
@@ -703,7 +703,7 @@ rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_INTEL_MULTIARCH") ]]; then
     HAVE_INTEL_MULTIARCH=0
     if [[ ("$IS_DARWIN" -ne 0) && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0) ]]; then
-        "$CXX" -arch i386 -arch x86_64 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -arch i386 -arch x86_64 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             HAVE_INTEL_MULTIARCH=1
         fi
@@ -714,7 +714,7 @@ rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_PPC_MULTIARCH") ]]; then
     HAVE_PPC_MULTIARCH=0
     if [[ ("$IS_DARWIN" -ne 0) && ("$IS_PPC32" -ne 0 || "$IS_PPC64" -ne 0) ]]; then
-        "$CXX" -arch ppc -arch ppc64 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -arch ppc -arch ppc64 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             HAVE_PPC_MULTIARCH=1
         fi
@@ -725,7 +725,7 @@ rm -f "${TMPDIR}/test.exe" &>/dev/null
 if [[ (-z "$HAVE_X32") ]]; then
     HAVE_X32=0
     if [[ "$IS_X32" -ne 0 ]]; then
-        "$CXX" -mx32 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -mx32 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             HAVE_X32=1
         fi
@@ -736,7 +736,7 @@ fi
 if [[ (-z "$HAVE_NATIVE_ARCH") ]]; then
     HAVE_NATIVE_ARCH=0
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -march=native "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -march=native "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ ("$?" -eq 0) ]]; then
         HAVE_NATIVE_ARCH=1
     fi
@@ -748,9 +748,9 @@ if [[ (-z "$HAVE_LDGOLD") ]]; then
     LD_GOLD=$(command -v ld.gold 2>/dev/null)
     ELF_FILE=$(command -v file 2>/dev/null)
     if [[ (-n "$LD_GOLD") && (-n "$ELF_FILE") ]]; then
-        LD_GOLD=$(file "$LD_GOLD" | cut -d":" -f 2 | "$GREP" -i -c "elf")
+        LD_GOLD=$(file "$LD_GOLD" | cut -d":" -f 2 | "${GREP}" -i -c "elf")
         if [[ ("$LD_GOLD" -ne 0) ]]; then
-            "$CXX" -fuse-ld=gold "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+            "${CXX}" -fuse-ld=gold "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
             if [[ "$?" -eq 0 ]]; then
                 HAVE_LDGOLD=1
             fi
@@ -762,76 +762,76 @@ fi
 if [[ ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0) ]]; then
 
     if [[ (-z "$HAVE_ARMV7A" && "$IS_ARM32" -ne 0) ]]; then
-        HAVE_ARMV7A=$("$GREP" -i -c 'neon' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARMV7A=$("${GREP}" -i -c 'neon' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARMV7A" -gt 0) ]]; then HAVE_ARMV7A=1; fi
     fi
 
     if [[ (-z "$HAVE_ARMV8" && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; then
-        HAVE_ARMV8=$("$GREP" -i -c -E '(asimd|crc|crypto)' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARMV8=$("${GREP}" -i -c -E '(asimd|crc|crypto)' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARMV8" -gt 0) ]]; then HAVE_ARMV8=1; fi
     fi
 
     if [[ (-z "$HAVE_ARM_VFPV3") ]]; then
-        HAVE_ARM_VFPV3=$("$GREP" -i -c 'vfpv3' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARM_VFPV3=$("${GREP}" -i -c 'vfpv3' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARM_VFPV3" -gt 0) ]]; then HAVE_ARM_VFPV3=1; fi
     fi
 
     if [[ (-z "$HAVE_ARM_VFPV4") ]]; then
-        HAVE_ARM_VFPV4=$("$GREP" -i -c 'vfpv4' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARM_VFPV4=$("${GREP}" -i -c 'vfpv4' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARM_VFPV4" -gt 0) ]]; then HAVE_ARM_VFPV4=1; fi
     fi
 
     if [[ (-z "$HAVE_ARM_VFPV5") ]]; then
-        HAVE_ARM_VFPV5=$("$GREP" -i -c 'fpv5' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARM_VFPV5=$("${GREP}" -i -c 'fpv5' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARM_VFPV5" -gt 0) ]]; then HAVE_ARM_VFPV5=1; fi
     fi
 
     if [[ (-z "$HAVE_ARM_VFPD32") ]]; then
-        HAVE_ARM_VFPD32=$("$GREP" -i -c 'vfpd32' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARM_VFPD32=$("${GREP}" -i -c 'vfpd32' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARM_VFPD32" -gt 0) ]]; then HAVE_ARM_VFPD32=1; fi
     fi
 
     if [[ (-z "$HAVE_ARM_NEON") ]]; then
-        HAVE_ARM_NEON=$("$GREP" -i -c 'neon' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARM_NEON=$("${GREP}" -i -c 'neon' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARM_NEON" -gt 0) ]]; then HAVE_ARM_NEON=1; fi
     fi
 
     if [[ (-z "$HAVE_ARM_CRC") ]]; then
-        HAVE_ARM_CRC=$("$GREP" -i -c 'crc32' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARM_CRC=$("${GREP}" -i -c 'crc32' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARM_CRC" -gt 0) ]]; then HAVE_ARM_CRC=1; fi
     fi
 
     if [[ (-z "$HAVE_ARM_CRYPTO") ]]; then
-        HAVE_ARM_CRYPTO=$("$GREP" -i -c -E '(aes|pmull|sha1|sha2)' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARM_CRYPTO=$("${GREP}" -i -c -E '(aes|pmull|sha1|sha2)' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARM_CRYPTO" -gt 0) ]]; then HAVE_ARM_CRYPTO=1; fi
     fi
 
     if [[ (-z "$HAVE_ARM_SHA3") ]]; then
-        HAVE_ARM_SHA3=$("$GREP" -i -c 'sha3' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARM_SHA3=$("${GREP}" -i -c 'sha3' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARM_SHA3" -gt 0) ]]; then HAVE_ARM_SHA3=1; fi
     fi
 
     if [[ (-z "$HAVE_ARM_SHA512") ]]; then
-        HAVE_ARM_SHA512=$("$GREP" -i -c 'sha512' <<< "$ARM_CPU_FLAGS")
+        HAVE_ARM_SHA512=$("${GREP}" -i -c 'sha512' <<< "$ARM_CPU_FLAGS")
         if [[ ("$HAVE_ARM_SHA512" -gt 0) ]]; then HAVE_ARM_SHA512=1; fi
     fi
 fi
 
 if [[ ("$IS_PPC32" -ne 0 || "$IS_PPC64" -ne 0) ]]; then
     if [[ (-z "$HAVE_PPC_ALTIVEC") ]]; then
-        HAVE_PPC_ALTIVEC=$("$GREP" -i -c 'altivec' <<< "$PPC_CPU_FLAGS")
+        HAVE_PPC_ALTIVEC=$("${GREP}" -i -c 'altivec' <<< "$PPC_CPU_FLAGS")
         if [[ ("$HAVE_PPC_ALTIVEC" -gt 0) ]]; then HAVE_PPC_ALTIVEC=1; fi
     fi
     if [[ (-z "$HAVE_PPC_POWER7") ]]; then
-        HAVE_PPC_POWER7=$("$GREP" -i -c -E 'pwr7|power7' <<< "$PPC_CPU_FLAGS")
+        HAVE_PPC_POWER7=$("${GREP}" -i -c -E 'pwr7|power7' <<< "$PPC_CPU_FLAGS")
         if [[ ("$HAVE_PPC_POWER7" -gt 0) ]]; then HAVE_PPC_POWER7=1; fi
     fi
     if [[ (-z "$HAVE_PPC_POWER8") ]]; then
-        HAVE_PPC_POWER8=$("$GREP" -i -c -E 'pwr8|power8' <<< "$PPC_CPU_FLAGS")
+        HAVE_PPC_POWER8=$("${GREP}" -i -c -E 'pwr8|power8' <<< "$PPC_CPU_FLAGS")
         if [[ ("$HAVE_PPC_POWER8" -gt 0) ]]; then HAVE_PPC_POWER8=1; fi
     fi
     if [[ (-z "$HAVE_PPC_POWER9") ]]; then
-        HAVE_PPC_POWER9=$("$GREP" -i -c -E 'pwr9|power9' <<< "$PPC_CPU_FLAGS")
+        HAVE_PPC_POWER9=$("${GREP}" -i -c -E 'pwr9|power9' <<< "$PPC_CPU_FLAGS")
         if [[ ("$HAVE_PPC_POWER9" -gt 0) ]]; then HAVE_PPC_POWER9=1; fi
     fi
 fi
@@ -868,7 +868,7 @@ fi
 # Used to disassemble object modules so we can verify some aspects of code generation
 if [[ (-z "$HAVE_DISASS") ]]; then
     echo "int main(int argc, char* argv[]) {return 0;}" > "${TMPDIR}/test.cc"
-    "$CXX" "${TMPDIR}/test.cc" -o "${TMPDIR}/testest.exe" &>/dev/null
+    "${CXX}" "${TMPDIR}/test.cc" -o "${TMPDIR}/testest.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         "$DISASS" "${DISASSARGS[@]}" "${TMPDIR}/testest.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
@@ -1039,57 +1039,57 @@ CPU_COUNT=1
 MEM_SIZE=512
 
 if [[ ("$IS_SPARC" -ne 0) && ("$IS_LINUX" -ne 0) ]]; then
-    CPU_COUNT="$($GREP -E 'CPU.*' /proc/cpuinfo | cut -f 1 -d ':' | $SED 's|CPU||g' | sort -n | tail -1)"
-    MEM_SIZE="$($GREP "MemTotal" < /proc/meminfo | $AWK '{print int($2/1024)}')"
+    CPU_COUNT="$(${GREP} -E 'CPU.*' /proc/cpuinfo | cut -f 1 -d ':' | ${SED} 's|CPU||g' | sort -n | tail -1)"
+    MEM_SIZE="$(${GREP} "MemTotal" < /proc/meminfo | ${AWK} '{print int($2/1024)}')"
 elif [[ (-e "/proc/cpuinfo") && (-e "/proc/meminfo") ]]; then
-    CPU_COUNT="$($GREP -c -E "^processor" < /proc/cpuinfo)"
-    MEM_SIZE="$($GREP "MemTotal" < /proc/meminfo | $AWK '{print int($2/1024)}')"
+    CPU_COUNT="$(${GREP} -c -E "^processor" < /proc/cpuinfo)"
+    MEM_SIZE="$(${GREP} "MemTotal" < /proc/meminfo | ${AWK} '{print int($2/1024)}')"
 elif [[ "$IS_DARWIN" -ne 0 ]]; then
-    CPU_COUNT="$(sysctl -a 2>&1 | $GREP "hw.availcpu" | $AWK '{print $3; exit}')"
-    MEM_SIZE="$(sysctl -a 2>&1 | $GREP "hw.memsize" | $AWK '{print int($3/1024/1024); exit;}')"
+    CPU_COUNT="$(sysctl -a 2>&1 | ${GREP} "hw.availcpu" | ${AWK} '{print $3; exit}')"
+    MEM_SIZE="$(sysctl -a 2>&1 | ${GREP} "hw.memsize" | ${AWK} '{print int($3/1024/1024); exit;}')"
 elif [[ "$IS_SOLARIS" -ne 0 ]]; then
-    CPU_COUNT="$(psrinfo 2>/dev/null | wc -l | $AWK '{print $1}')"
-    MEM_SIZE="$(prtconf 2>/dev/null | $GREP "Memory" | $AWK '{print int($3)}')"
+    CPU_COUNT="$(psrinfo 2>/dev/null | wc -l | ${AWK} '{print $1}')"
+    MEM_SIZE="$(prtconf 2>/dev/null | ${GREP} "Memory" | ${AWK} '{print int($3)}')"
 elif [[ "$IS_AIX" -ne 0 ]]; then
-    CPU_COUNT="$(bindprocessor -q 2>/dev/null | cut -f 2 -d ":" | wc -w | $AWK '{print $1}')"
-    MEM_SIZE="$(prtconf -m 2>/dev/null | $GREP "MB" | $AWK '{print int($3); exit;}')"
+    CPU_COUNT="$(bindprocessor -q 2>/dev/null | cut -f 2 -d ":" | wc -w | ${AWK} '{print $1}')"
+    MEM_SIZE="$(prtconf -m 2>/dev/null | ${GREP} "MB" | ${AWK} '{print int($3); exit;}')"
 fi
 
 # Benchmarks expect frequency in GiHz.
 CPU_FREQ=0.5
 if [[ (-e "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq") ]]; then
     CPU_FREQ="$(cat /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq)"
-    CPU_FREQ="$(echo "$CPU_FREQ" | $AWK '{print $0/1024/1024; exit}')"
+    CPU_FREQ="$(echo "$CPU_FREQ" | ${AWK} '{print $0/1024/1024; exit}')"
 elif [[ (-e "/proc/cpuinfo") ]]; then
-    CPU_FREQ="$($GREP 'MHz' < /proc/cpuinfo | $AWK '{print $4; exit}')"
+    CPU_FREQ="$(${GREP} 'MHz' < /proc/cpuinfo | ${AWK} '{print $4; exit}')"
     if [[ -z "$CPU_FREQ" ]]; then CPU_FREQ=512; fi
-    CPU_FREQ="$(echo "$CPU_FREQ" | $AWK '{print $0/1024}')"
+    CPU_FREQ="$(echo "$CPU_FREQ" | ${AWK} '{print $0/1024}')"
 elif [[ "$IS_DARWIN" -ne 0 ]]; then
-    CPU_FREQ="$(sysctl -a 2>&1 | $GREP "hw.cpufrequency" | $AWK '{print int($3); exit;}')"
-    CPU_FREQ="$(echo "$CPU_FREQ" | $AWK '{print int($0/1024/1024/1024)}')"
+    CPU_FREQ="$(sysctl -a 2>&1 | ${GREP} "hw.cpufrequency" | ${AWK} '{print int($3); exit;}')"
+    CPU_FREQ="$(echo "$CPU_FREQ" | ${AWK} '{print int($0/1024/1024/1024)}')"
 elif [[ "$IS_SOLARIS" -ne 0 ]]; then
-    CPU_FREQ="$(psrinfo -v 2>/dev/null | $GREP "MHz" | $AWK '{print $6; exit;}')"
-    CPU_FREQ="$(echo "$CPU_FREQ" | $AWK '{print $0/1024}')"
+    CPU_FREQ="$(psrinfo -v 2>/dev/null | ${GREP} "MHz" | ${AWK} '{print $6; exit;}')"
+    CPU_FREQ="$(echo "$CPU_FREQ" | ${AWK} '{print $0/1024}')"
 elif [[ "$IS_AIX" -ne 0 ]]; then
-    CPU_FREQ="$(prtconf -s 2>/dev/null | $GREP "MHz" | $AWK '{print $4; exit;}')"
-    CPU_FREQ="$(echo "$CPU_FREQ" | $AWK '{print $0/1024}')"
+    CPU_FREQ="$(prtconf -s 2>/dev/null | ${GREP} "MHz" | ${AWK} '{print $4; exit;}')"
+    CPU_FREQ="$(echo "$CPU_FREQ" | ${AWK} '{print $0/1024}')"
 fi
 
 # Fixups for later versions of OS X
 if [[ "$IS_DARWIN" -ne 0 ]]; then
     if [[ (-z "$CPU_COUNT") || ("$CPU_COUNT" -eq 0) ]]; then
-        CPU_COUNT="$(sysctl -a 2>&1 | $GREP "hw.activecpu" | $AWK '{print $2; exit}')"
+        CPU_COUNT="$(sysctl -a 2>&1 | ${GREP} "hw.activecpu" | ${AWK} '{print $2; exit}')"
     fi
     if [[ (-z "$MEM_SIZE") || ("$MEM_SIZE" -eq 0) ]]; then
-        MEM_SIZE="$(sysctl -a 2>&1 | $GREP "hw.memsize" | $AWK '{print int($2/1024/1024); exit;}')"
+        MEM_SIZE="$(sysctl -a 2>&1 | ${GREP} "hw.memsize" | ${AWK} '{print int($2/1024/1024); exit;}')"
     fi
     if [[ (-z "$CPU_FREQ") || ("$CPU_FREQ" -eq 0) ]]; then
-        CPU_FREQ="$(sysctl -a 2>&1 | $GREP "hw.cpufrequency" | $AWK '{print int($2); exit;}')"
-        CPU_FREQ="$(echo "$CPU_FREQ" | $AWK '{print int($0/1024/1024/1024)}')"
+        CPU_FREQ="$(sysctl -a 2>&1 | ${GREP} "hw.cpufrequency" | ${AWK} '{print int($2); exit;}')"
+        CPU_FREQ="$(echo "$CPU_FREQ" | ${AWK} '{print int($0/1024/1024/1024)}')"
     fi
     if [[ (-z "$CPU_FREQ") || ("$CPU_FREQ" -eq 0) ]]; then
-        CPU_FREQ="$(sysctl -a 2>&1 | $GREP "hw.tbfrequency" | $AWK '{print int($2); exit;}')"
-        CPU_FREQ="$(echo "$CPU_FREQ" | $AWK '{print int($0/10/1024/1024)}')"
+        CPU_FREQ="$(sysctl -a 2>&1 | ${GREP} "hw.tbfrequency" | ${AWK} '{print int($2); exit;}')"
+        CPU_FREQ="$(echo "$CPU_FREQ" | ${AWK} '{print int($0/10/1024/1024)}')"
     fi
 fi
 
@@ -1100,7 +1100,7 @@ if [[ "$IS_LINUX" -ne 0 ]]; then
     # If memory is small, then ensure swap space exists
     if [[ "$MEM_SIZE" -lt 4096 ]]; then
         if [[ (-e "/proc/meminfo") ]]; then
-            SWAP_SIZE="$($GREP 'SwapTotal' < /proc/meminfo | "$AWK" '{print $2}')"
+            SWAP_SIZE="$(${GREP} 'SwapTotal' < /proc/meminfo | "${AWK}" '{print $2}')"
             if [[ "$SWAP_SIZE" -eq 0 ]]; then
                 HAVE_SWAP=0
             fi
@@ -1117,7 +1117,7 @@ echo "MEM: $MEM_SIZE MB" | tee -a "$TEST_RESULTS"
 
 if [[ ("$CPU_COUNT" -ge 2 && "$MEM_SIZE" -ge 1280 && "$HAVE_SWAP" -ne 0) ]]; then
     if [[ ("$WANT_NICE" -eq 1) ]]; then
-        CPU_COUNT=$(echo -n "$CPU_COUNT 2" | "$AWK" '{print int($1/$2)}')
+        CPU_COUNT=$(echo -n "$CPU_COUNT 2" | "${AWK}" '{print int($1/$2)}')
     fi
     MAKEARGS=(-j "$CPU_COUNT")
     echo "Using $MAKE -j $CPU_COUNT"
@@ -1125,7 +1125,7 @@ fi
 
 ############################################
 
-GIT_REPO=$(git branch 2>&1 | "$GREP" -v "fatal" | wc -l | "$AWK" '{print $1; exit;}')
+GIT_REPO=$(git branch 2>&1 | "${GREP}" -v "fatal" | wc -l | "${AWK}" '{print $1; exit;}')
 if [[ "$GIT_REPO" -ne 0 ]]; then
     GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
     GIT_HASH=$(git rev-parse HEAD 2>/dev/null | cut -c 1-16)
@@ -1137,17 +1137,17 @@ if [[ -n "$GIT_BRANCH" ]]; then
 fi
 
 if [[ ("$SUN_COMPILER" -ne 0) ]]; then
-    "$CXX" -V 2>&1 | "$SED" 's|CC:|Compiler:|g' | head -1 | tee -a "$TEST_RESULTS"
+    "${CXX}" -V 2>&1 | "${SED}" 's|CC:|Compiler:|g' | head -1 | tee -a "$TEST_RESULTS"
 elif [[ ("$XLC_COMPILER" -ne 0) ]]; then
-    echo "Compiler: $($CXX -qversion | head -1)" | tee -a "$TEST_RESULTS"
+    echo "Compiler: $(${CXX} -qversion | head -1)" | tee -a "$TEST_RESULTS"
 else
-    echo "Compiler: $($CXX --version | head -1)" | tee -a "$TEST_RESULTS"
+    echo "Compiler: $(${CXX} --version | head -1)" | tee -a "$TEST_RESULTS"
 fi
 
-CXX_PATH=$(command -v "$CXX" 2>/dev/null)
-CXX_SYMLINK=$(ls -l "$CXX_PATH" 2>/dev/null | "$GREP" -c '\->' | "$AWK" '{print $1}')
-if [[ ("$CXX_SYMLINK" -ne 0) ]]; then CXX_PATH="$CXX_PATH (symlinked)"; fi
-echo "Pathname: $CXX_PATH" | tee -a "$TEST_RESULTS"
+CXX_PATH=$(command -v "${CXX}" 2>/dev/null)
+CXX_SYMLINK=$(ls -l "${CXX_PATH}" 2>/dev/null | "${GREP}" -c '\->' | "${AWK}" '{print $1}')
+if [[ ("${CXX_SYMLINK}" -ne 0) ]]; then CXX_PATH="${CXX_PATH} (symlinked)"; fi
+echo "Pathname: ${CXX_PATH}" | tee -a "$TEST_RESULTS"
 
 ############################################
 
@@ -1199,21 +1199,21 @@ if true; then
     FAILED=0
 
     # Search for headers. Filter out C++ abd Doxygen comments.
-    COUNT=$(cat ./*.h ./*.cpp | "$GREP" -v '//' | "$GREP" -c -E '(assert.h|cassert)')
+    COUNT=$(cat ./*.h ./*.cpp | "${GREP}" -v '//' | "${GREP}" -c -E '(assert.h|cassert)')
     if [[ "$COUNT" -ne 0 ]]; then
         FAILED=1
         echo "FAILED: found Posix assert headers" | tee -a "$TEST_RESULTS"
     fi
 
     # Search for asserts. Filter out C++, Doxygen comments and static_assert.
-    COUNT=$(cat ./*.h ./*.cpp | "$GREP" -v -E '//|_assert' | "$GREP" -c -E 'assert[[:space:]]*\(')
+    COUNT=$(cat ./*.h ./*.cpp | "${GREP}" -v -E '//|_assert' | "${GREP}" -c -E 'assert[[:space:]]*\(')
     if [[ "$COUNT" -ne 0 ]]; then
         FAILED=1
         echo "FAILED: found use of Posix assert" | tee -a "$TEST_RESULTS"
     fi
 
     # Filter out C++ and Doxygen comments.
-    COUNT=$(cat ./*.h ./*.cpp | "$GREP" -v '//' | "$GREP" -c 'NDEBUG')
+    COUNT=$(cat ./*.h ./*.cpp | "${GREP}" -v '//' | "${GREP}" -c 'NDEBUG')
     if [[ "$COUNT" -ne 0 ]]; then
         FAILED=1
         echo "FAILED: found use of Posix NDEBUG" | tee -a "$TEST_RESULTS"
@@ -1240,14 +1240,14 @@ if true; then
     FAILED=0
 
     # If this fires, then use the library's STDMIN(a,b) or (std::min)(a, b);
-    COUNT=$(cat ./*.h ./*.cpp | "$GREP" -v '//' | "$GREP" -c -E 'std::min[[:space:]]*\(')
+    COUNT=$(cat ./*.h ./*.cpp | "${GREP}" -v '//' | "${GREP}" -c -E 'std::min[[:space:]]*\(')
     if [[ "$COUNT" -ne 0 ]]; then
         FAILED=1
         echo "FAILED: found std::min" | tee -a "$TEST_RESULTS"
     fi
 
     # If this fires, then use the library's STDMAX(a,b) or (std::max)(a, b);
-    COUNT=$(cat ./*.h ./*.cpp | "$GREP" -v '//' | "$GREP" -c -E 'std::max[[:space:]]*\(')
+    COUNT=$(cat ./*.h ./*.cpp | "${GREP}" -v '//' | "${GREP}" -c -E 'std::max[[:space:]]*\(')
     if [[ "$COUNT" -ne 0 ]]; then
         FAILED=1
         echo "FAILED: found std::max" | tee -a "$TEST_RESULTS"
@@ -1277,20 +1277,20 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
         TEST_LIST+=("X86 rotate immediate code generation")
 
         OBJFILE=sha.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        X86_SSE2=$(echo -n "$X86_CPU_FLAGS" | "$GREP" -i -c sse2)
-        X86_SHA256_HASH_BLOCKS=$(echo -n "$DISASS_TEXT" | "$GREP" -c 'SHA256_HashMultipleBlocks_SSE2')
+        X86_SSE2=$(echo -n "$X86_CPU_FLAGS" | "${GREP}" -i -c sse2)
+        X86_SHA256_HASH_BLOCKS=$(echo -n "$DISASS_TEXT" | "${GREP}" -c 'SHA256_HashMultipleBlocks_SSE2')
         if [[ ("$X86_SHA256_HASH_BLOCKS" -ne 0) ]]; then
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E '(rol.*0x|ror.*0x)')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E '(rol.*0x|ror.*0x)')
             if [[ ("$COUNT" -le 250) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate rotate immediate instruction (SHA256_HashMultipleBlocks_SSE2)" | tee -a "$TEST_RESULTS"
             fi
         else
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E '(rol.*0x|ror.*0x)')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E '(rol.*0x|ror.*0x)')
             if [[ ("$COUNT" -le 500) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate rotate immediate instruction" | tee -a "$TEST_RESULTS"
@@ -1313,7 +1313,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
     ############################################
     # Test CRC-32C code generation
 
-    "$CXX" -msse4.2 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -msse4.2 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         X86_CRC32=1
     fi
@@ -1327,19 +1327,19 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
         TEST_LIST+=("X86 CRC32 code generation")
 
         OBJFILE=crc_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c crc32b)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c crc32b)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate crc32b instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c crc32l)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c crc32l)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate crc32l instruction" | tee -a "$TEST_RESULTS"
@@ -1355,7 +1355,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
     ############################################
     # Test AES-NI code generation
 
-    "$CXX" -maes "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -maes "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         X86_AESNI=1
     fi
@@ -1369,43 +1369,43 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
         TEST_LIST+=("X86 AES-NI code generation")
 
         OBJFILE=rijndael_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aesenc)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aesenc)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aesenc instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aesenclast)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aesenclast)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aesenclast instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aesdec)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aesdec)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aesdec instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aesdeclast)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aesdeclast)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aesdeclast instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aesimc)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aesimc)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aesimc instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aeskeygenassist)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aeskeygenassist)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aeskeygenassist instruction" | tee -a "$TEST_RESULTS"
@@ -1421,7 +1421,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
     ############################################
     # X86 carryless multiply code generation
 
-    "$CXX" -mpclmul "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -mpclmul "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         X86_PCLMUL=1
     fi
@@ -1435,19 +1435,19 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
         TEST_LIST+=("X86 carryless multiply code generation")
 
         OBJFILE=gcm_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E '(pclmulqdq|pclmullqhq|vpclmulqdq)')
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E '(pclmulqdq|pclmullqhq|vpclmulqdq)')
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate pclmullqhq instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E '(pclmulqdq|pclmullqlq|vpclmulqdq)')
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E '(pclmulqdq|pclmullqlq|vpclmulqdq)')
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate pclmullqlq instruction" | tee -a "$TEST_RESULTS"
@@ -1463,11 +1463,11 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
     ############################################
     # Test RDRAND and RDSEED code generation
 
-    "$CXX" -mrdrnd "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -mrdrnd "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         X86_RDRAND=1
     fi
-    "$CXX" -mrdseed "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -mrdseed "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         X86_RDSEED=1
     fi
@@ -1481,14 +1481,14 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
         TEST_LIST+=("X86 RDRAND and RDSEED code generation")
 
         OBJFILE=rdrand.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
         if [[ "$X86_RDRAND" -ne 0 ]]; then
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c rdrand)
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c rdrand)
             if [[ ("$COUNT" -eq 0) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate rdrand instruction" | tee -a "$TEST_RESULTS"
@@ -1496,7 +1496,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
         fi
 
         if [[ "$X86_RDSEED" -ne 0 ]]; then
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c rdseed)
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c rdseed)
             if [[ ("$COUNT" -eq 0) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate rdseed instruction" | tee -a "$TEST_RESULTS"
@@ -1513,7 +1513,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
     ############################################
     # X86 SHA code generation
 
-    "$CXX" -msha "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -msha "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         X86_SHA=1
     fi
@@ -1527,49 +1527,49 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_X86" -ne 0 || "$IS_X64" -ne 0)) ]]; then
         TEST_LIST+=("X86 SHA code generation")
 
         OBJFILE=sha_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1rnds4)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1rnds4)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1rnds4 instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1nexte)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1nexte)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1nexte instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1msg1)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1msg1)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1msg1 instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1msg2)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1msg2)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1msg2 instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha256rnds2)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha256rnds2)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha256rnds2 instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha256msg1)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha256msg1)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha256msg1 instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha256msg2)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha256msg2)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha256msg2 instruction" | tee -a "$TEST_RESULTS"
@@ -1590,7 +1590,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
     ############################################
     # ARM NEON code generation
 
-    ARM_NEON=$(echo -n "$ARM_CPU_FLAGS" | "$GREP" -i -c -E '(neon|asimd)')
+    ARM_NEON=$(echo -n "$ARM_CPU_FLAGS" | "${GREP}" -i -c -E '(neon|asimd)')
     if [[ ("$ARM_NEON" -ne 0 || "$HAVE_ARM_NEON" -ne 0) ]]; then
         echo
         echo "************************************" | tee -a "$TEST_RESULTS"
@@ -1600,7 +1600,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
         TEST_LIST+=("ARM NEON code generation")
 
         OBJFILE=aria_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
@@ -1608,14 +1608,14 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
 
         if [[ ("$HAVE_ARMV8" -ne 0) ]]; then
             # ARIA::UncheckedKeySet: 4 ldr q{N}
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'ldr[[:space:]]*q|ldp[[:space:]]*q')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'ldr[[:space:]]*q|ldp[[:space:]]*q')
             if [[ ("$COUNT" -lt 4) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate NEON load instructions" | tee -a "$TEST_RESULTS"
             fi
         else  # ARMv7
             # ARIA::UncheckedKeySet: 4 vld {d1,d2}
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'vld[[:space:]]*')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'vld[[:space:]]*')
             if [[ ("$COUNT" -lt 4) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate NEON load instructions" | tee -a "$TEST_RESULTS"
@@ -1624,14 +1624,14 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
 
         if [[ ("$HAVE_ARMV8" -ne 0) ]]; then
             # ARIA::UncheckedKeySet: 17 str q{N}
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'str[[:space:]]*q|stp[[:space:]]*q')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'str[[:space:]]*q|stp[[:space:]]*q')
             if [[ ("$COUNT" -lt 8) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate NEON store instructions" | tee -a "$TEST_RESULTS"
             fi
         else
             # ARIA::UncheckedKeySet: 17 vstr {d1,d2}
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'vst[[:space:]]*')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'vst[[:space:]]*')
             if [[ ("$COUNT" -lt 16) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate NEON store instructions" | tee -a "$TEST_RESULTS"
@@ -1640,14 +1640,14 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
 
         if [[ ("$HAVE_ARMV8" -ne 0) ]]; then
             # ARIA::UncheckedKeySet: 17 shl v{N}
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'shl[[:space:]]*v|shl.4s')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'shl[[:space:]]*v|shl.4s')
             if [[ ("$COUNT" -lt 16) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate NEON shift left instructions" | tee -a "$TEST_RESULTS"
             fi
         else
             # ARIA::UncheckedKeySet: 17 vshl
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'vshl')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'vshl')
             if [[ ("$COUNT" -lt 16) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate NEON shift left instructions" | tee -a "$TEST_RESULTS"
@@ -1656,14 +1656,14 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
 
         if [[ ("$HAVE_ARMV8" -ne 0) ]]; then
             # ARIA::UncheckedKeySet: 17 shr v{N}
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'shr[[:space:]]*v|shr.4s')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'shr[[:space:]]*v|shr.4s')
             if [[ ("$COUNT" -lt 16) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate NEON shift right instructions" | tee -a "$TEST_RESULTS"
             fi
         else
             # ARIA::UncheckedKeySet: 17 vshr
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'vshr')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'vshr')
             if [[ ("$COUNT" -lt 16) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate NEON shift right instructions" | tee -a "$TEST_RESULTS"
@@ -1672,7 +1672,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
 
         if [[ ("$HAVE_ARMV8" -ne 0) ]]; then
             # ARIA::UncheckedKeySet: 12 ext v{N}
-            COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'ext[[:space:]]*v|ext.*v')
+            COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'ext[[:space:]]*v|ext.*v')
             if [[ ("$COUNT" -lt 12) ]]; then
                 FAILED=1
                 echo "ERROR: failed to generate NEON extract instructions" | tee -a "$TEST_RESULTS"
@@ -1680,7 +1680,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
         fi
 
         # ARIA::UncheckedKeySet: 17 veor
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c -E 'eor.*v|veor')
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c -E 'eor.*v|veor')
         if [[ ("$COUNT" -lt 16) ]]; then
             FAILED=1
             echo "ERROR: failed to generate NEON xor instructions" | tee -a "$TEST_RESULTS"
@@ -1696,7 +1696,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
     ############################################
     # ARM CRC32 code generation
 
-    "$CXX" -march=armv8-a+crc "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -march=armv8-a+crc "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         ARM_CRC32=1
     fi
@@ -1710,31 +1710,31 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
         TEST_LIST+=("ARM CRC32 code generation")
 
         OBJFILE=crc_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c crc32cb)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c crc32cb)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate crc32cb instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c crc32cw)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c crc32cw)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate crc32cw instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c crc32b)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c crc32b)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate crc32b instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c crc32w)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c crc32w)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate crc32w instruction" | tee -a "$TEST_RESULTS"
@@ -1750,7 +1750,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
     ############################################
     # ARM carryless multiply code generation
 
-    "$CXX" -march=armv8-a+crypto "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -march=armv8-a+crypto "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         ARM_PMULL=1
     fi
@@ -1764,19 +1764,19 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
         TEST_LIST+=("ARM carryless multiply code generation")
 
         OBJFILE=gcm_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -v pmull2 | "$GREP" -i -c pmull)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -v pmull2 | "${GREP}" -i -c pmull)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate pmull instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c pmull2)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c pmull2)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate pmull2 instruction" | tee -a "$TEST_RESULTS"
@@ -1792,7 +1792,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
     ############################################
     # ARM AES code generation
 
-    "$CXX" -march=armv8-a+crypto "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -march=armv8-a+crypto "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         ARM_AES=1
     fi
@@ -1806,31 +1806,31 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
         TEST_LIST+=("ARM AES code generation")
 
         OBJFILE=rijndael_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aese)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aese)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aese instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aesmc)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aesmc)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aesmc instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aesd)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aesd)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aesd instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c aesimc)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c aesimc)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate aesimc instruction" | tee -a "$TEST_RESULTS"
@@ -1846,7 +1846,7 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
     ############################################
     # ARM SHA code generation
 
-    "$CXX" -march=armv8-a+crypto "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -march=armv8-a+crypto "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         ARM_SHA1=1
         ARM_SHA2=1
@@ -1861,43 +1861,43 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
         TEST_LIST+=("ARM SHA1 code generation")
 
         OBJFILE=sha_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1c)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1c)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1c instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1m)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1m)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1m instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1p)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1p)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1p instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1h)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1h)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1h instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1su0)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1su0)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1su0 instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha1su1)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha1su1)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha1su1 instruction" | tee -a "$TEST_RESULTS"
@@ -1920,31 +1920,31 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_ARM32" -ne 0 || "$IS_ARM64" -ne 0)) ]]; the
         TEST_LIST+=("ARM SHA2 code generation")
 
         OBJFILE=sha_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -v sha256h2 | "$GREP" -i -c sha256h)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -v sha256h2 | "${GREP}" -i -c sha256h)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha256h instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha256h2)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha256h2)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha256h2 instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha256su0)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha256su0)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha256su0 instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c sha256su1)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c sha256su1)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate sha256su1 instruction" | tee -a "$TEST_RESULTS"
@@ -1967,13 +1967,13 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_PPC32" -ne 0 || "$IS_PPC64" -ne 0)) ]]; the
 
     PPC_ALTIVEC=0
     if [[ ("$PPC_ALTIVEC" -eq 0) ]]; then
-        "$CXX" -maltivec "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -maltivec "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             PPC_ALTIVEC=1
         fi
     fi
     if [[ ("$PPC_ALTIVEC" -eq 0) ]]; then
-        "$CXX" -qarch=altivec "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -qarch=altivec "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             PPC_ALTIVEC=1
         fi
@@ -1988,37 +1988,37 @@ if [[ ("$HAVE_DISASS" -ne 0 && ("$IS_PPC32" -ne 0 || "$IS_PPC64" -ne 0)) ]]; the
         TEST_LIST+=("Altivec code generation")
 
         OBJFILE=speck128_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c lvx)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c lvx)
         if [[ ("$COUNT" -lt 8) ]]; then
             FAILED=1
             echo "ERROR: failed to generate lvx instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c stvx)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c stvx)
         if [[ ("$COUNT" -lt 8) ]]; then
             FAILED=1
             echo "ERROR: failed to generate stvx instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c vsldoi)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c vsldoi)
         if [[ ("$COUNT" -lt 8) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vsldoi instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c vxor)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c vxor)
         if [[ ("$COUNT" -lt 8) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vxor instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c vperm)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c vperm)
         if [[ ("$COUNT" -lt 8) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vperm instruction" | tee -a "$TEST_RESULTS"
@@ -2041,13 +2041,13 @@ if [[ ("$HAVE_DISASS" -ne 0 && "$GCC_4_8_OR_ABOVE" -ne 0 && ("$IS_PPC32" -ne 0 |
 
     PPC_AES=0
     if [[ ("$PPC_AES" -eq 0) ]]; then
-        "$CXX" -mcpu=power8 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -mcpu=power8 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             PPC_AES=1
         fi
     fi
     if [[ ("$PPC_AES" -eq 0) ]]; then
-        "$CXX" -qarch=pwr8 -qaltivec "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -qarch=pwr8 -qaltivec "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             PPC_AES=1
         fi
@@ -2062,31 +2062,31 @@ if [[ ("$HAVE_DISASS" -ne 0 && "$GCC_4_8_OR_ABOVE" -ne 0 && ("$IS_PPC32" -ne 0 |
         TEST_LIST+=("Power8 AES code generation")
 
         OBJFILE=rijndael_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -v vcipherlast | "$GREP" -i -c vcipher)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -v vcipherlast | "${GREP}" -i -c vcipher)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vcipher instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c vcipherlast)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c vcipherlast)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vcipherlast instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -v vncipherlast | "$GREP" -i -c vncipher)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -v vncipherlast | "${GREP}" -i -c vncipher)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vncipher instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c vncipherlast)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c vncipherlast)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vncipherlast instruction" | tee -a "$TEST_RESULTS"
@@ -2104,13 +2104,13 @@ if [[ ("$HAVE_DISASS" -ne 0 && "$GCC_4_8_OR_ABOVE" -ne 0 && ("$IS_PPC32" -ne 0 |
 
     PPC_SHA=0
     if [[ ("$PPC_SHA" -eq 0) ]]; then
-        "$CXX" -mcpu=power8 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -mcpu=power8 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             PPC_SHA=1
         fi
     fi
     if [[ ("$PPC_SHA" -eq 0) ]]; then
-        "$CXX" -qarch=pwr8 -qaltivec "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -qarch=pwr8 -qaltivec "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             PPC_SHA=1
         fi
@@ -2125,19 +2125,19 @@ if [[ ("$HAVE_DISASS" -ne 0 && "$GCC_4_8_OR_ABOVE" -ne 0 && ("$IS_PPC32" -ne 0 |
         TEST_LIST+=("Power8 SHA code generation")
 
         OBJFILE=sha_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c vshasigmaw)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c vshasigmaw)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vshasigmaw instruction" | tee -a "$TEST_RESULTS"
         fi
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c vshasigmad)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c vshasigmad)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vshasigmad instruction" | tee -a "$TEST_RESULTS"
@@ -2155,13 +2155,13 @@ if [[ ("$HAVE_DISASS" -ne 0 && "$GCC_4_8_OR_ABOVE" -ne 0 && ("$IS_PPC32" -ne 0 |
 
     PPC_VMULL=0
     if [[ ("$PPC_VMULL" -eq 0) ]]; then
-        "$CXX" -mcpu=power8 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -mcpu=power8 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             PPC_VMULL=1
         fi
     fi
     if [[ ("$PPC_VMULL" -eq 0) ]]; then
-        "$CXX" -qarch=pwr8 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+        "${CXX}" -qarch=pwr8 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
             PPC_VMULL=1
         fi
@@ -2176,13 +2176,13 @@ if [[ ("$HAVE_DISASS" -ne 0 && "$GCC_4_8_OR_ABOVE" -ne 0 && ("$IS_PPC32" -ne 0 |
         TEST_LIST+=("Power8 carryless multiply code generation")
 
         OBJFILE=gcm_simd.o; rm -f "$OBJFILE" 2>/dev/null
-        CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" $OBJFILE 2>&1 | tee -a "$TEST_RESULTS"
 
         COUNT=0
         FAILED=0
         DISASS_TEXT=$("$DISASS" "${DISASSARGS[@]}" "$OBJFILE" 2>/dev/null)
 
-        COUNT=$(echo -n "$DISASS_TEXT" | "$GREP" -i -c vpmsum)
+        COUNT=$(echo -n "$DISASS_TEXT" | "${GREP}" -i -c vpmsum)
         if [[ ("$COUNT" -eq 0) ]]; then
             FAILED=1
             echo "ERROR: failed to generate vpmsum instruction" | tee -a "$TEST_RESULTS"
@@ -2213,7 +2213,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2247,7 +2247,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2285,7 +2285,7 @@ if [[ "$HAVE_LD_LIBRARY_PATH" -ne 0 ]]; then
     "$MAKE" clean &>/dev/null
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
-    CXX="$CXX" CXXFLAGS="$DEBUG_CXXFLAGS" LINK_LIBRARY=libcryptopp.so \
+    CXX="${CXX}" CXXFLAGS="$DEBUG_CXXFLAGS" LINK_LIBRARY=libcryptopp.so \
         "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
@@ -2313,7 +2313,7 @@ if [[ "$HAVE_LD_LIBRARY_PATH" -ne 0 ]]; then
     "$MAKE" clean &>/dev/null
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
-    CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" LINK_LIBRARY=libcryptopp.so \
+    CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" LINK_LIBRARY=libcryptopp.so \
         "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
@@ -2350,7 +2350,7 @@ if [[ "$HAVE_DYLD_LIBRARY_PATH" -ne 0 ]]; then
     "$MAKE" clean &>/dev/null
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
-    CXX="$CXX" CXXFLAGS="$DEBUG_CXXFLAGS" LINK_LIBRARY=libcryptopp.dylib \
+    CXX="${CXX}" CXXFLAGS="$DEBUG_CXXFLAGS" LINK_LIBRARY=libcryptopp.dylib \
         "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
@@ -2381,7 +2381,7 @@ if [[ "$HAVE_DYLD_LIBRARY_PATH" -ne 0 ]]; then
     "$MAKE" clean &>/dev/null
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
-    CXX="$CXX" CXXFLAGS="$RELEASE_CXXFLAGS" LINK_LIBRARY=libcryptopp.dylib \
+    CXX="${CXX}" CXXFLAGS="$RELEASE_CXXFLAGS" LINK_LIBRARY=libcryptopp.dylib \
         "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
@@ -2508,25 +2508,25 @@ if [[ ("$IS_SUSE" -ne 0) ]]; then
         "-pthread" "-fopenmp")
 
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -fstack-protector-strong "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -fstack-protector-strong "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         SUSE_FLAGS+=("-fstack-protector-strong")
     fi
 
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -fasynchronous-unwind-tables "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -fasynchronous-unwind-tables "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         SUSE_FLAGS+=("-fasynchronous-unwind-tables")
     fi
 
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -fstack-clash-protection "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -fstack-clash-protection "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         SUSE_FLAGS+=("-fstack-clash-protection")
     fi
 
     rm -f "${TMPDIR}/test.exe" &>/dev/null
-    "$CXX" -flto=6 "$test_prog" -o "${TMPDIR}/test.exe" &>/dev/null
+    "${CXX}" -flto=6 "${test_prog}" -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
         SUSE_FLAGS+=("-flto=6")
     fi
@@ -2579,7 +2579,7 @@ if [[ ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0 || "$INTEL_COMPILER" -ne
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$DEBUG_CXXFLAGS -march=i686 $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2610,7 +2610,7 @@ if [[ ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0 || "$INTEL_COMPILER" -ne
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$RELEASE_CXXFLAGS -march=i686 $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2644,7 +2644,7 @@ if [[ ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0 || "$INTEL_COMPILER" -ne
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$DEBUG_CXXFLAGS -march=x86-64 $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2675,7 +2675,7 @@ if [[ ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0 || "$INTEL_COMPILER" -ne
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$RELEASE_CXXFLAGS -march=x86-64 $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2714,11 +2714,11 @@ if [[ ( ("$IS_X86" -ne 0 || "$IS_X32" -ne 0 || "$IS_X64" -ne 0) && "$HAVE_NATIVE
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$DEBUG_CXXFLAGS -march=i686 $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static 2>&1 | tee -a "$TEST_RESULTS"
 
         # The makefile may add -DCRYPTOPP_DISABLE_XXX, so we can't add -march=native
         CXXFLAGS="$DEBUG_CXXFLAGS $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2749,11 +2749,11 @@ if [[ ( ("$IS_X86" -ne 0 || "$IS_X32" -ne 0 || "$IS_X64" -ne 0) && "$HAVE_NATIVE
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$RELEASE_CXXFLAGS -march=i686 $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static 2>&1 | tee -a "$TEST_RESULTS"
 
         # The makefile may add -DCRYPTOPP_DISABLE_XXX, so we can't add -march=native
         CXXFLAGS="$RELEASE_CXXFLAGS $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2787,11 +2787,11 @@ if [[ ( ("$IS_X86" -ne 0 || "$IS_X32" -ne 0 || "$IS_X64" -ne 0) && "$HAVE_NATIVE
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$DEBUG_CXXFLAGS -march=x86-64 $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static 2>&1 | tee -a "$TEST_RESULTS"
 
         # The makefile may add -DCRYPTOPP_DISABLE_XXX, so we can't add -march=native
         CXXFLAGS="$DEBUG_CXXFLAGS $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2822,11 +2822,11 @@ if [[ ( ("$IS_X86" -ne 0 || "$IS_X32" -ne 0 || "$IS_X64" -ne 0) && "$HAVE_NATIVE
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$RELEASE_CXXFLAGS -march=x86-64 $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static 2>&1 | tee -a "$TEST_RESULTS"
 
         # The makefile may add -DCRYPTOPP_DISABLE_XXX, so we can't add -march=native
         CXXFLAGS="$RELEASE_CXXFLAGS $OPT_PIC"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2863,7 +2863,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -DCRYPTOPP_DISABLE_ASM"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2894,7 +2894,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -DCRYPTOPP_DISABLE_ASM"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2930,7 +2930,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -DCRYPTOPP_NO_CPU_FEATURE_PROBES=1"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2961,7 +2961,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -DCRYPTOPP_NO_CPU_FEATURE_PROBES=1"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -2997,7 +2997,7 @@ if [[ "$HAVE_CXX03" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3028,7 +3028,7 @@ if [[ "$HAVE_CXX03" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3064,7 +3064,7 @@ if [[ "$HAVE_GNU03" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=gnu++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3095,7 +3095,7 @@ if [[ "$HAVE_GNU03" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=gnu++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3131,7 +3131,7 @@ if [[ "$HAVE_CXX11" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3162,7 +3162,7 @@ if [[ "$HAVE_CXX11" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3198,7 +3198,7 @@ if [[ "$HAVE_GNU11" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=gnu++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3229,7 +3229,7 @@ if [[ "$HAVE_GNU11" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=gnu++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3265,7 +3265,7 @@ if [[ "$HAVE_CXX14" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++14 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3296,7 +3296,7 @@ if [[ "$HAVE_CXX14" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3332,7 +3332,7 @@ if [[ "$HAVE_GNU14" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=gnu++14 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3363,7 +3363,7 @@ if [[ "$HAVE_GNU14" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=gnu++14 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3399,7 +3399,7 @@ if [[ "$HAVE_CXX17" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++17 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3430,7 +3430,7 @@ if [[ "$HAVE_CXX17" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3466,7 +3466,7 @@ if [[ "$HAVE_GNU17" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=gnu++17 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3497,7 +3497,7 @@ if [[ "$HAVE_GNU17" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=gnu++17 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3533,7 +3533,7 @@ if [[ "$HAVE_CXX20" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++20 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3564,7 +3564,7 @@ if [[ "$HAVE_CXX20" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++20 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3600,7 +3600,7 @@ if [[ "$HAVE_GNU20" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=gnu++20 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3631,7 +3631,7 @@ if [[ "$HAVE_GNU20" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=gnu++20 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3667,7 +3667,7 @@ if [[ "$HAVE_X32" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -mx32 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3698,7 +3698,7 @@ if [[ "$HAVE_X32" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -mx32 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3734,7 +3734,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -DCRYPTOPP_INIT_PRIORITY=0 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3765,7 +3765,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -DCRYPTOPP_INIT_PRIORITY=0 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3801,7 +3801,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -DNO_OS_DEPENDENCE $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3832,7 +3832,7 @@ if true; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -DNO_OS_DEPENDENCE $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3868,7 +3868,7 @@ if [[ "$HAVE_LDGOLD" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" LD="ld.gold" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" LD="ld.gold" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3899,7 +3899,7 @@ if [[ "$HAVE_LDGOLD" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" LD="ld.gold" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" LD="ld.gold" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3935,7 +3935,7 @@ if [[ "$HAVE_O2" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DDEBUG $OPT_O2 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -3966,7 +3966,7 @@ if [[ "$HAVE_O2" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DNDEBUG $OPT_O2 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4002,7 +4002,7 @@ if [[ "$HAVE_O3" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DDEBUG $OPT_O3 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4033,7 +4033,7 @@ if [[ "$HAVE_O3" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DNDEBUG $OPT_O3 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4069,7 +4069,7 @@ if [[ "$HAVE_OS" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DDEBUG $OPT_OS $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4100,7 +4100,7 @@ if [[ "$HAVE_OS" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DNDEBUG $OPT_OS $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4136,7 +4136,7 @@ if [[ "$HAVE_OZ" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DDEBUG $OPT_OZ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4167,7 +4167,7 @@ if [[ "$HAVE_OZ" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DNDEBUG $OPT_OZ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4203,7 +4203,7 @@ if [[ "$HAVE_OFAST" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DDEBUG $OPT_OFAST $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4234,7 +4234,7 @@ if [[ "$HAVE_OFAST" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DNDEBUG $OPT_OFAST $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4270,7 +4270,7 @@ if [[ ("$GNU_LINKER" -eq 1) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" lean 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" lean 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4301,7 +4301,7 @@ if [[ ("$GNU_LINKER" -eq 1) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" lean 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" lean 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4337,7 +4337,7 @@ if [[ ("$HAVE_OMP" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DDEBUG ${OMP_FLAGS[*]} $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4368,7 +4368,7 @@ if [[ ("$HAVE_OMP" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="-DNDEBUG ${OMP_FLAGS[*]} $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4404,7 +4404,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_UBSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4435,7 +4435,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_UBSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4471,7 +4471,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_ASAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4516,7 +4516,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_ASAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4565,7 +4565,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_BSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++03 -fsanitize=bounds-strict $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4610,7 +4610,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_BSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 -fsanitize=bounds-strict $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4659,7 +4659,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_CET" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++03 -fcf-protection=full -mcet $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4690,7 +4690,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_CET" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 -fcf-protection=full -mcet $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4726,7 +4726,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_REPTOLINE" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++03 -mfunction-return=thunk -mindirect-branch=thunk $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4757,7 +4757,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && "$HAVE_REPTOLINE" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 -mfunction-return=thunk -mindirect-branch=thunk $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4793,7 +4793,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_UBSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4824,7 +4824,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_UBSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4860,7 +4860,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_ASAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4905,7 +4905,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_ASAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4954,7 +4954,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_BSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++11 -fsanitize=bounds-strict $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -4999,7 +4999,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_BSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 -fsanitize=bounds-strict $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5048,7 +5048,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_CET" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++11 -fcf-protection=full -mcet $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5079,7 +5079,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_CET" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 -fcf-protection=full -mcet $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5115,7 +5115,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_REPTOLINE" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++11 -mfunction-return=thunk -mindirect-branch=thunk $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5146,7 +5146,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && "$HAVE_REPTOLINE" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 -mfunction-return=thunk -mindirect-branch=thunk $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5179,7 +5179,7 @@ if [[ ("$HAVE_CXX14" -ne 0 && "$HAVE_UBSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5212,7 +5212,7 @@ if [[ ("$HAVE_CXX14" -ne 0 && "$HAVE_ASAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5258,7 +5258,7 @@ if [[ ("$HAVE_CXX14" -ne 0 && "$HAVE_BSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 -fsanitize=bounds-strict $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5291,7 +5291,7 @@ if [[ ("$HAVE_CXX14" -ne 0 && "$HAVE_CET" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 -fcf-protection=full -mcet $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5324,7 +5324,7 @@ if [[ ("$HAVE_CXX14" -ne 0 && "$HAVE_REPTOLINE" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 -mfunction-return=thunk -mindirect-branch=thunk $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5357,7 +5357,7 @@ if [[ ("$HAVE_CXX17" -ne 0 && "$HAVE_UBSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5390,7 +5390,7 @@ if [[ ("$HAVE_CXX17" -ne 0 && "$HAVE_ASAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5436,7 +5436,7 @@ if [[ ("$HAVE_CXX17" -ne 0 && "$HAVE_BSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 -fsanitize=bounds-strict $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5469,7 +5469,7 @@ if [[ ("$HAVE_CXX17" -ne 0 && "$HAVE_CET" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 -fcf-protection=full -mcet $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5502,7 +5502,7 @@ if [[ ("$HAVE_CXX17" -ne 0 && "$HAVE_REPTOLINE" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 -mfunction-return=thunk -mindirect-branch=thunk $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5535,7 +5535,7 @@ if [[ ("$HAVE_CXX20" -ne 0 && "$HAVE_UBSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++20 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" ubsan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5568,7 +5568,7 @@ if [[ ("$HAVE_CXX20" -ne 0 && "$HAVE_ASAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++20 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" asan | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5614,7 +5614,7 @@ if [[ ("$HAVE_CXX20" -ne 0 && "$HAVE_BSAN" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++20 -fsanitize=bounds-strict $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5647,7 +5647,7 @@ if [[ ("$HAVE_CXX20" -ne 0 && "$HAVE_CET" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++20 -fcf-protection=full -mcet $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5680,7 +5680,7 @@ if [[ ("$HAVE_CXX20" -ne 0 && "$HAVE_REPTOLINE" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++20 -mfunction-return=thunk -mindirect-branch=thunk $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5716,7 +5716,7 @@ if [[ "$HAVE_ANALYZER" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -fanalyzer $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5747,7 +5747,7 @@ if [[ "$HAVE_ANALYZER" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -fanalyzer $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5787,7 +5787,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DDEBUG -g -xO0"
-        CXX="/opt/solstudio12.2/bin/CC" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="/opt/solstudio12.2/bin/CC" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5818,7 +5818,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g -xO2"
-        CXX="/opt/solstudio12.2/bin/CC" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="/opt/solstudio12.2/bin/CC" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5854,7 +5854,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DDEBUG -g3 -xO0"
-        CXX=/opt/solarisstudio12.3/bin/CC CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX=/opt/solarisstudio12.3/bin/CC CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5885,7 +5885,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g3 -xO2"
-        CXX=/opt/solarisstudio12.3/bin/CC CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX=/opt/solarisstudio12.3/bin/CC CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5921,7 +5921,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DDEBUG -g3 -xO0"
-        CXX=/opt/solarisstudio12.4/bin/CC CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX=/opt/solarisstudio12.4/bin/CC CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5952,7 +5952,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g2 -xO2"
-        CXX=/opt/solarisstudio12.4/bin/CC CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX=/opt/solarisstudio12.4/bin/CC CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -5988,7 +5988,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DDEBUG -g3 -xO1"
-        CXX=/opt/developerstudio12.5/bin/CC CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX=/opt/developerstudio12.5/bin/CC CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6019,7 +6019,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g2 -xO2"
-        CXX=/opt/developerstudio12.5/bin/CC CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX=/opt/developerstudio12.5/bin/CC CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6055,7 +6055,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DDEBUG -g3 -xO1"
-        CXX=/opt/developerstudio12.6/bin/CC CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX=/opt/developerstudio12.6/bin/CC CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6086,7 +6086,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g2 -xO2"
-        CXX=/opt/developerstudio12.6/bin/CC CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX=/opt/developerstudio12.6/bin/CC CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6122,7 +6122,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DDEBUG -g3 -O0"
-        CXX="/bin/g++" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="/bin/g++" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6153,7 +6153,7 @@ if [[ "$IS_SOLARIS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g2 -O3"
-        CXX="/bin/g++" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="/bin/g++" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6190,7 +6190,7 @@ if [[ ("$IS_DARWIN" -ne 0) && ("$HAVE_CXX03" -ne 0 && "$CLANG_COMPILER" -ne 0) ]
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 -stdlib=libc++ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6223,7 +6223,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX03" -ne 0) && ("$HAVE_LIBSTDCXX" -ne 0) ]
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 -stdlib=libstdc++ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6256,7 +6256,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX11" -ne 0 && "$CLANG_COMPILER" -ne 0) ]];
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 -stdlib=libc++ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6289,7 +6289,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX11" -ne 0) && ("$HAVE_LIBSTDCXX" -ne 0) ]
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 -stdlib=libstdc++ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6322,7 +6322,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX14" -ne 0 && "$CLANG_COMPILER" -ne 0) ]];
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 -stdlib=libc++ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6355,7 +6355,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX14" -ne 0) && ("$HAVE_LIBSTDCXX" -ne 0) ]
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 -stdlib=libstdc++ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6388,7 +6388,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX17" -ne 0 && "$CLANG_COMPILER" -ne 0) ]];
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 -stdlib=libc++ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6421,7 +6421,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX17" -ne 0) && ("$HAVE_LIBSTDCXX" -ne 0) ]
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 -stdlib=libstdc++ $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6454,7 +6454,7 @@ if [[ "$IS_DARWIN" -ne 0 && "$HAVE_INTEL_MULTIARCH" -ne 0 && "$HAVE_CXX03" -ne 0
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -arch i386 -arch x86_64 -std=c++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6500,7 +6500,7 @@ if [[ "$IS_DARWIN" -ne 0 && "$HAVE_INTEL_MULTIARCH" -ne 0 && "$HAVE_CXX11" -ne 0
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -arch i386 -arch x86_64 -std=c++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6546,7 +6546,7 @@ if [[ "$IS_DARWIN" -ne 0 && "$HAVE_INTEL_MULTIARCH" -ne 0 && "$HAVE_CXX14" -ne 0
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -arch i386 -arch x86_64 -std=c++14 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6592,7 +6592,7 @@ if [[ "$IS_DARWIN" -ne 0 && "$HAVE_INTEL_MULTIARCH" -ne 0 && "$HAVE_CXX17" -ne 0
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -arch i386 -arch x86_64 -std=c++17 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6638,7 +6638,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_PPC_MULTIARCH" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -arch ppc -arch ppc64 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6684,7 +6684,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX03" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6723,7 +6723,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX11" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6762,7 +6762,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX14" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6801,7 +6801,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$HAVE_CXX17" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6844,7 +6844,7 @@ if [[ "$WANT_BENCHMARKS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 $USER_CXXFLAGS"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6873,7 +6873,7 @@ if [[ "$WANT_BENCHMARKS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 $USER_CXXFLAGS"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6902,7 +6902,7 @@ if [[ "$WANT_BENCHMARKS" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 $USER_CXXFLAGS"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6932,7 +6932,7 @@ if [[ "$IS_MINGW" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6965,7 +6965,7 @@ if [[ "$HAVE_CXX03" -ne 0 && "$HAVE_VALGRIND" -ne 0 ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$VALGRIND_CXXFLAGS -std=c++03 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -6990,7 +6990,7 @@ if [[ ("$HAVE_VALGRIND" -ne 0 && "$HAVE_CXX11" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$VALGRIND_CXXFLAGS -std=c++11 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -7015,7 +7015,7 @@ if [[ ("$HAVE_VALGRIND" -ne 0 && "$HAVE_CXX14" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$VALGRIND_CXXFLAGS -std=c++14 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -7040,7 +7040,7 @@ if [[ ("$HAVE_VALGRIND" -ne 0 && "$HAVE_CXX17" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$VALGRIND_CXXFLAGS -std=c++17 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -7065,7 +7065,7 @@ if [[ ("$HAVE_VALGRIND" -ne 0 && "$HAVE_CXX20" -ne 0) ]]; then
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$VALGRIND_CXXFLAGS -std=c++20 $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -7093,7 +7093,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++03 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
@@ -7113,7 +7113,7 @@ if [[ ("$HAVE_CXX03" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++03 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
     if [[ "$?" -ne 0 ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
         FAILED_LIST+=("Debug, c++03, elevated warnings")
@@ -7137,7 +7137,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++11 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
@@ -7157,7 +7157,7 @@ if [[ ("$HAVE_CXX11" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++11 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
     if [[ "$?" -ne 0 ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
         FAILED_LIST+=("Release, c++11, elevated warnings")
@@ -7181,7 +7181,7 @@ if [[ ("$HAVE_CXX14" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++14 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
@@ -7201,7 +7201,7 @@ if [[ ("$HAVE_CXX14" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++14 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
     if [[ "$?" -ne 0 ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
         FAILED_LIST+=("Release, c++14, elevated warnings")
@@ -7225,7 +7225,7 @@ if [[ ("$HAVE_CXX17" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++17 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
@@ -7245,7 +7245,7 @@ if [[ ("$HAVE_CXX17" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++17 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
 
     if [[ "$?" -ne 0 ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
@@ -7270,7 +7270,7 @@ if [[ ("$HAVE_CXX20" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$DEBUG_CXXFLAGS -std=c++20 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
@@ -7290,7 +7290,7 @@ if [[ ("$HAVE_CXX20" -ne 0 && ("$GCC_COMPILER" -ne 0 || "$CLANG_COMPILER" -ne 0)
     rm -f "${TMPDIR}/test.exe" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -std=c++20 ${WARNING_CXXFLAGS[*]}"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$WARN_RESULTS"
 
     if [[ "$?" -ne 0 ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$WARN_RESULTS"
@@ -7304,7 +7304,7 @@ fi
 if [[ ("$CLANG_COMPILER" -eq 0) ]]; then
 
     CLANG_CXX=$(command -v clang++ 2>/dev/null)
-    "$CLANG_CXX" -x c++ -DCRYPTOPP_ADHOC_MAIN "$test_prog".proto -o "${TMPDIR}/test.exe" &>/dev/null
+    "$CLANG_CXX" -x c++ -DCRYPTOPP_ADHOC_MAIN "${test_prog}".proto -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
 
         ############################################
@@ -7320,7 +7320,7 @@ if [[ ("$CLANG_COMPILER" -eq 0) ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g2 -O3"
-        CXX="$CLANG_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="$CLANG_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
             FAILED_LIST+=("Clang compiler")
@@ -7344,7 +7344,7 @@ fi
 if [[ ("$GCC_COMPILER" -eq 0) ]]; then
 
     GCC_CXX=$(command -v g++ 2>/dev/null)
-    "$GCC_CXX" -x c++ -DCRYPTOPP_ADHOC_MAIN "$test_prog".proto -o "${TMPDIR}/test.exe" &>/dev/null
+    "$GCC_CXX" -x c++ -DCRYPTOPP_ADHOC_MAIN "${test_prog}".proto -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
 
         ############################################
@@ -7360,7 +7360,7 @@ if [[ ("$GCC_COMPILER" -eq 0) ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g2 -O3"
-        CXX="$GCC_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="$GCC_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
             FAILED_LIST+=("GCC compiler")
@@ -7385,9 +7385,9 @@ if [[ ("$INTEL_COMPILER" -eq 0) ]]; then
 
     INTEL_CXX=$(command -v icpc 2>/dev/null)
     if [[ (-z "$INTEL_CXX") ]]; then
-        INTEL_CXX=$(find /opt/intel -name icpc 2>/dev/null | "$GREP" -iv composer | head -1)
+        INTEL_CXX=$(find /opt/intel -name icpc 2>/dev/null | "${GREP}" -iv composer | head -1)
     fi
-    "$INTEL_CXX" -x c++ -DCRYPTOPP_ADHOC_MAIN "$test_prog".proto -o "${TMPDIR}/test.exe" &>/dev/null
+    "$INTEL_CXX" -x c++ -DCRYPTOPP_ADHOC_MAIN "${test_prog}".proto -o "${TMPDIR}/test.exe" &>/dev/null
     if [[ "$?" -eq 0 ]]; then
 
         ############################################
@@ -7403,7 +7403,7 @@ if [[ ("$INTEL_COMPILER" -eq 0) ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g2 -O3"
-        CXX="$INTEL_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="$INTEL_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
             FAILED_LIST+=("Intel compiler")
@@ -7428,7 +7428,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
     MACPORTS_CXX=$(find /opt/local/bin -name 'g++-mp-4*' 2>/dev/null | head -1)
     if [[ (-n "$MACPORTS_CXX") ]]; then
-        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "$test_prog".proto -o "${TMPDIR}/test.exe" &>/dev/null
+        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "${test_prog}".proto -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
 
             ############################################
@@ -7445,7 +7445,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
             # We want to use -stdlib=libstdc++ below, but it causes a compile error. Maybe MacPorts hardwired libc++.
             CXXFLAGS="-DNDEBUG -g2 -O3 -std=c++11"
-            CXX="$MACPORTS_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+            CXX="$MACPORTS_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
             if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
                 echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
                 FAILED_LIST+=("MacPorts 4.x GCC compiler")
@@ -7466,7 +7466,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
     MACPORTS_CXX=$(find /opt/local/bin -name 'g++-mp-5*' 2>/dev/null | head -1)
     if [[ (-n "$MACPORTS_CXX") ]]; then
-        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "$test_prog".proto -o "${TMPDIR}/test.exe" &>/dev/null
+        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "${test_prog}".proto -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
 
             ############################################
@@ -7483,7 +7483,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
             # We want to use -stdlib=libstdc++ below, but it causes a compile error. Maybe MacPorts hardwired libc++.
             CXXFLAGS="-DNDEBUG -g2 -O3 -std=c++11"
-            CXX="$MACPORTS_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+            CXX="$MACPORTS_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
             if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
                 echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
                 FAILED_LIST+=("MacPorts 5.x GCC compiler")
@@ -7504,7 +7504,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
     MACPORTS_CXX=$(find /opt/local/bin -name 'g++-mp-6*' 2>/dev/null | head -1)
     if [[ (-n "$MACPORTS_CXX") ]]; then
-        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "$test_prog".proto -o "${TMPDIR}/test.exe" &>/dev/null
+        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "${test_prog}".proto -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
 
             ############################################
@@ -7521,7 +7521,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
             # We want to use -stdlib=libstdc++ below, but it causes a compile error. Maybe MacPorts hardwired libc++.
             CXXFLAGS="-DNDEBUG -g2 -O3 -std=c++11"
-            CXX="$MACPORTS_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+            CXX="$MACPORTS_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
             if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
                 echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
                 FAILED_LIST+=("MacPorts 6.x GCC compiler")
@@ -7542,7 +7542,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
     MACPORTS_CXX=$(find /opt/local/bin -name 'g++-mp-7*' 2>/dev/null | head -1)
     if [[ (-n "$MACPORTS_CXX") ]]; then
-        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "$test_prog".proto -o "${TMPDIR}/test.exe" &>/dev/null
+        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "${test_prog}".proto -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
 
             ############################################
@@ -7559,7 +7559,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
             # We want to use -stdlib=libstdc++ below, but it causes a compile error. Maybe MacPorts hardwired libc++.
             CXXFLAGS="-DNDEBUG -g2 -O3 -std=c++11"
-            CXX="$MACPORTS_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+            CXX="$MACPORTS_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
             if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
                 echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
                 FAILED_LIST+=("MacPorts 7.x GCC compiler")
@@ -7580,7 +7580,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
     MACPORTS_CXX=$(find /opt/local/bin -name 'clang++-mp-3.9*' 2>/dev/null | head -1)
     if [[ (-n "$MACPORTS_CXX") ]]; then
-        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "$test_prog".proto -o "${TMPDIR}/test.exe" &>/dev/null
+        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "${test_prog}".proto -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
 
             ############################################
@@ -7596,7 +7596,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
             rm -f "${TMPDIR}/test.exe" &>/dev/null
 
             CXXFLAGS="-DNDEBUG -g2 -O3 -std=c++11 -stdlib=libc++"
-            CXX="$MACPORTS_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+            CXX="$MACPORTS_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
             if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
                 echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
                 FAILED_LIST+=("MacPorts 3.9 Clang compiler")
@@ -7617,7 +7617,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
 
     MACPORTS_CXX=$(find /opt/local/bin -name 'clang++-mp-4*' 2>/dev/null | head -1)
     if [[ (-n "$MACPORTS_CXX") ]]; then
-        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "$test_prog".proto -o "${TMPDIR}/test.exe" &>/dev/null
+        "$MACPORTS_CXX" -x c++ -std=c++11 -DCRYPTOPP_ADHOC_MAIN "${test_prog}".proto -o "${TMPDIR}/test.exe" &>/dev/null
         if [[ "$?" -eq 0 ]]; then
 
             ############################################
@@ -7633,7 +7633,7 @@ if [[ ("$IS_DARWIN" -ne 0 && "$MACPORTS_COMPILER" -eq 0) ]]; then
             rm -f "${TMPDIR}/test.exe" &>/dev/null
 
             CXXFLAGS="-DNDEBUG -g2 -O3 -std=c++11 -stdlib=libc++"
-            CXX="$MACPORTS_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+            CXX="$MACPORTS_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
             if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
                 echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
                 FAILED_LIST+=("MacPorts 4.x Clang compiler")
@@ -7673,7 +7673,7 @@ if [[ "$IS_DARWIN" -ne 0 ]]; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="-DNDEBUG -g2 -O3"
-        CXX="$XCODE_CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="$XCODE_CXX" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -7711,7 +7711,7 @@ if [[ ("$IS_CYGWIN" -eq 0) && ("$IS_MINGW" -eq 0) ]]; then
     rm -rf "$INSTALL_DIR" &>/dev/null
 
     CXXFLAGS="$RELEASE_CXXFLAGS -DCRYPTOPP_DATA_DIR='\"$INSTALL_DIR/share/cryptopp/\"' $USER_CXXFLAGS"
-    CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS" "$INSTALL_RESULTS"
+    CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS" "$INSTALL_RESULTS"
 
     if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
         echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS" "$INSTALL_RESULTS"
@@ -7855,7 +7855,7 @@ if true; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$DEBUG_CXXFLAGS"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -7886,7 +7886,7 @@ if true; then
         rm -f "${TMPDIR}/test.exe" &>/dev/null
 
         CXXFLAGS="$RELEASE_CXXFLAGS"
-        CXX="$CXX" CXXFLAGS="$CXXFLAGS" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
+        CXX="${CXX}" CXXFLAGS="${CXXFLAGS}" "$MAKE" "${MAKEARGS[@]}" static dynamic cryptest.exe 2>&1 | tee -a "$TEST_RESULTS"
 
         if [[ ("${PIPESTATUS[0]}" -ne 0) ]]; then
             echo "ERROR: failed to make cryptest.exe" | tee -a "$TEST_RESULTS"
@@ -7969,12 +7969,12 @@ echo "" | tee -a "$TEST_RESULTS"
 echo "************************************************" | tee -a "$TEST_RESULTS" "$WARN_RESULTS"
 echo "" | tee -a "$TEST_RESULTS" "$WARN_RESULTS"
 
-WCOUNT=$("$GREP" -E '(warning:)' $WARN_RESULTS | wc -l | "$AWK" '{print $1}')
+WCOUNT=$("${GREP}" -E '(warning:)' $WARN_RESULTS | wc -l | "${AWK}" '{print $1}')
 if (( "$WCOUNT" == "0" )); then
     echo "No warnings detected" | tee -a "$TEST_RESULTS" "$WARN_RESULTS"
 else
     echo "$WCOUNT warnings detected. See $WARN_RESULTS for details" | tee -a "$TEST_RESULTS" "$WARN_RESULTS"
-    # "$GREP" -n -E '(warning:)' $WARN_RESULTS | "$GREP" -v 'deprecated-declarations'
+    # "${GREP}" -n -E '(warning:)' $WARN_RESULTS | "${GREP}" -v 'deprecated-declarations'
 fi
 echo "" | tee -a "$TEST_RESULTS"
author	Jeffrey Walton <noloader@gmail.com>	2022-05-07 10:22:41 -0400
committer	Jeffrey Walton <noloader@gmail.com>	2022-05-07 10:22:41 -0400
commit	5208cca6178e8cf71e96cd8c6636887909f1a308 (patch)
tree	0ee1f7fadfe4e739f712a06b72fafa3d5b6d4dc8 /TestScripts
parent	59895be61b03f973416724cfe0274693ce73b6a1 (diff)
download	cryptopp-git-5208cca6178e8cf71e96cd8c6636887909f1a308.tar.gz