diff --git a/bin/zopen b/bin/zopen
index 44b732e86..014d7c950 100755
--- a/bin/zopen
+++ b/bin/zopen
@@ -2,14 +2,14 @@
 #
 # General purpose zopen script
 #
-ZOPEN_DONT_PROCESS_CONFIG=1 
+ZOPEN_DONT_PROCESS_CONFIG=1
 #
 # All zopen-* scripts MUST start with this code to maintain consistency
 #
 setupMyself()
 {
   ME=$(basename $0)
-  MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
   INCDIR="${MYDIR}/../include"
   if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
     echo "Internal Error. Unable to find common.sh file to source" >&2
@@ -43,7 +43,7 @@ printSyntax()
   echo "" >&2
 }
 
-printHelp() 
+printHelp()
 {
   echo "zopen is a general purpose script to be used with the z/OS Open Tools ports." >&2
   printSyntax
@@ -66,67 +66,67 @@ help=false
 version=false
 
 for arg in $*; do
-  case "$arg" in
-    "alt")
-      subcmd='zopen-alt'
-      ;;
-    "build")
-      subcmd='zopen-build'
-      ;;
-    "clean")
-      subcmd='zopen-clean'
-      ;;
-    "download")
-      subcmd='zopen-install'
-      ;;
-    "generate")
-      subcmd='zopen-generate'
-      ;;
-    "init")
-      subcmd='zopen-init'
-      ;;
-    "install")
-      subcmd='zopen-install'
-      ;;
-    "query")
-      subcmd='zopen-query'
-      ;;
-    "list")
-      subcmd='zopen-query'
-      subopts="${subopts} --list"
-      ;;
-    "search")
-      subcmd='zopen-query'
-      subopts="${subopts} --remote-search"
-      ;;
-    "remove")
-      subcmd='zopen-remove'
-      ;;
-    "update-cacert")
-      subcmd='zopen-update-cacert'
-      ;;
-    "upgrade")
-      subcmd='zopen-install'
-      subopts="${subopts} -u"
-      ;;
-    "--version")
-      version=true
-      ;;
-    "--help")
-      help=true
-      ;;
-    *)
-      # let unknown stuff through
-      subopts="${subopts} ${arg}"
-      ;;
+  case "${arg}" in
+  "alt")
+    subcmd='zopen-alt'
+    ;;
+  "build")
+    subcmd='zopen-build'
+    ;;
+  "clean")
+    subcmd='zopen-clean'
+    ;;
+  "download")
+    subcmd='zopen-install'
+    ;;
+  "generate")
+    subcmd='zopen-generate'
+    ;;
+  "init")
+    subcmd='zopen-init'
+    ;;
+  "install")
+    subcmd='zopen-install'
+    ;;
+  "query")
+    subcmd='zopen-query'
+    ;;
+  "list")
+    subcmd='zopen-query'
+    subopts="${subopts} --list"
+    ;;
+  "search")
+    subcmd='zopen-query'
+    subopts="${subopts} --remote-search"
+    ;;
+  "remove")
+    subcmd='zopen-remove'
+    ;;
+  "update-cacert")
+    subcmd='zopen-update-cacert'
+    ;;
+  "upgrade")
+    subcmd='zopen-install'
+    subopts="${subopts} -u"
+    ;;
+  "--version")
+    version=true
+    ;;
+  "--help")
+    help=true
+    ;;
+  *)
+    # let unknown stuff through
+    subopts="${subopts} ${arg}"
+    ;;
   esac
 done
 
-if [ "x${subcmd}" = "x" ]; then
-  if $help; then
+if [ -z "${subcmd}" ]; then
+  if ${help}; then
     printHelp
     exit 0
-  elif $version; then
+  elif ${version}; then
     : # fall through
   else
     printSyntax
@@ -134,13 +134,13 @@ if [ "x${subcmd}" = "x" ]; then
   fi
 fi
 
-if $help; then
+if ${help}; then
   subopts="--help"
 fi
 
-if $version; then
-  if [ "x${subcmd}" = "x" ]; then
-    subopts="$ME"
+if ${version}; then
+  if [ -z "${subcmd}" ]; then
+    subopts="${ME}"
   else
     subopts="${subcmd}"
   fi
diff --git a/bin/zopen-alt b/bin/zopen-alt
index 23b77ba01..f85fe27c1 100755
--- a/bin/zopen-alt
+++ b/bin/zopen-alt
@@ -5,20 +5,21 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 checkWritable
 
-printHelp(){
-cat << HELPDOC
+printHelp()
+{
+  cat << HELPDOC
 zopen alt is a utility for z/OS Open Tools to switch package versions 
 for currently installed packages.
 
@@ -47,29 +48,30 @@ Report bugs at https://github.com/ZOSOpenTools/meta/issues .
 HELPDOC
 }
 
-mergeNewVersion(){
+mergeNewVersion()
+{
   package="$1"
   newver="$2"
-  [ -d "$ZOPEN_PKGINSTALL/$package/$newver" ] || printError "Version '$newver' was not available to set as current"
-  if [ -e "$ZOPEN_PKGINSTALL/$package/$package" ]; then
+  [ -d "${ZOPEN_PKGINSTALL}/${package}/${newver}" ] || printError "Version '${newver}' was not available to set as current"
+  if [ -e "${ZOPEN_PKGINSTALL}/${package}/${package}" ]; then
     printVerbose "Removing main link"
-    rm -rf "$ZOPEN_PKGINSTALL/$package/$package"
+    rm -rf "${ZOPEN_PKGINSTALL}/${package}/${package}"
   fi
-  mergeIntoSystem "$package" "$ZOPEN_PKGINSTALL/$package/$newver" "$ZOPEN_ROOTFS" 
+  mergeIntoSystem "${package}" "${ZOPEN_PKGINSTALL}/${package}/${newver}" "${ZOPEN_ROOTFS}"
   printVerbose "New version merged; checking for orphaned files from previous version"
   # This will remove any old symlinks or dirs that might have changed in an up/downgrade
   # as the merge process overwrites existing files to point to different version. If there was
   # no other version, then $deref will be empty so nothing to uninstall
-  if [ -n "$deref" ]; then
-    unsymlinkFromSystem "$package" "$ZOPEN_ROOTFS" "${ZOPEN_PKGINSTALL}/$package/$deref/.links"
+  if [ -n "${deref}" ]; then
+    unsymlinkFromSystem "${package}" "${ZOPEN_ROOTFS}" "${ZOPEN_PKGINSTALL}/${package}/${deref}/.links"
   else
     printVerbose "No previous version found (no .links) - no unlinking performed"
-  fi 
-  
+  fi
+
   misrc=$?
-  printVerbose "The merge completed with: $misrc"
-  printVerbose "Generating main link from $package to version: $newver"
-  if ! ln -sf "$newver" "$ZOPEN_PKGINSTALL/$package/$package"; then
+  printVerbose "The merge completed with: ${misrc}"
+  printVerbose "Generating main link from ${package} to version: ${newver}"
+  if ! ln -sf "${newver}" "${ZOPEN_PKGINSTALL}/${package}/${package}"; then
     printError "Could not create symbolic link name"
   fi
   touch "${ZOPEN_PKGINSTALL}/${package}/${package}/.active"
@@ -77,113 +79,115 @@ mergeNewVersion(){
   if [ -e "${ZOPEN_PKGINSTALL}/${package}/${package}/.releaseinfo" ]; then
     version=$(cat "${ZOPEN_PKGINSTALL}/${package}/${package}/.releaseinfo")
   fi
-  syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_PACKAGE" "ALT" "setAlt" "Set '${package}' to version:$version;"
+  syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_PACKAGE}" "ALT" "setAlt" "Set '${package}' to version:${version};"
 }
 
-setAlt(){
+setAlt()
+{
   package="$1"
   newver="$2"
-  if [ -e "$ZOPEN_PKGINSTALL/$package/" ]; then
-    printVerbose "$package is either installed or has been previously"
-    found=$(zosfind "$ZOPEN_PKGINSTALL/$package/" -type l -prune -o -type d -print | sed -e "s#$ZOPEN_PKGINSTALL/$package/\([^/]*\).*#\1#" | uniq)
+  if [ -e "${ZOPEN_PKGINSTALL}/${package}/" ]; then
+    printVerbose "${package} is either installed or has been previously"
+    found=$(zosfind "${ZOPEN_PKGINSTALL}/${package}/" -type l -prune -o -type d -print | sed -e "s#${ZOPEN_PKGINSTALL}/${package}/\([^/]*\).*#\1#" | uniq)
   else
-    printVerbose "$package has never been installed on the system"
+    printVerbose "${package} has never been installed on the system"
   fi
-  if [ -z "$found" ]; then
+  if [ -z "${found}" ]; then
     printInfo "No available versions of package '${package}'"
     exit 4
   fi
-  if [ -e "$ZOPEN_PKGINSTALL/$package/$package" ]; then
-    deref=$(ls -l "$ZOPEN_PKGINSTALL/$package/$package" | awk '{ print $(NF) }')
-    printVerbose "Current version: ${deref#$ZOPEN_PKGINSTALL/}"
+  if [ -e "${ZOPEN_PKGINSTALL}/${package}/${package}" ]; then
+    deref=$(ls -l "${ZOPEN_PKGINSTALL}/${package}/${package}" | awk '{ print $(NF) }')
+    printVerbose "Current version: ${deref#"${ZOPEN_PKGINSTALL}"/}"
   fi
-  mergeNewVersion "$package" "$newver"
+  mergeNewVersion "${package}" "${newver}"
 }
 
-selectAlt(){
+selectAlt()
+{
   i=$1
   package=$2
   printVerbose "Selecting alternative"
-    valid=false
-    while ! $valid; do
-      echo "Enter alternative version to use (1-$i): "
-      selection=$(getInput)
-      if [ ! -z "$(echo $selection | sed -e 's/[0-9]*//')" ]; then
-        echo "Invalid input, must be a number between 1 and $i"
-      elif [ "$selection" -ge 1 ] && [ "$selection" -le "$i" ]; then
-        valid=true
-      fi
-    done
-    if [ ! "$selection" -eq "$current" ]; then
-      newver="$(echo $found | awk -v selection="$selection" '
+  valid=false
+  while ! ${valid}; do
+    echo "Enter alternative version to use (1-${i}): "
+    selection=$(getInput)
+    if [ ! -z "$(echo ${selection} | sed -e 's/[0-9]*//')" ]; then
+      echo "Invalid input, must be a number between 1 and ${i}"
+    elif [ "${selection}" -ge 1 ] && [ "${selection}" -le "${i}" ]; then
+      valid=true
+    fi
+  done
+  if [ ! "${selection}" -eq "${current}" ]; then
+    newver="$(echo ${found} | awk -v selection="${selection}" '
         BEGIN {count=0}
               {count = count + 1; if (count=selection) { print $(selection)} }
       ')"
-      printInfo "selecting alternative: $selection: $newver"
-      mergeNewVersion "$package" "$newver"
-    else
-      printInfo "Selection is already current version."
-      exit 0
-    fi
+    printInfo "selecting alternative: ${selection}: ${newver}"
+    mergeNewVersion "${package}" "${newver}"
+  else
+    printInfo "Selection is already current version."
+    exit 0
+  fi
 }
 
-listAlts(){
+listAlts()
+{
   select=$1
   package="$2"
 
-  printVerbose "Checking for the existence of the '$package' package directory within PKGINSTALL"
-  package=$(echo "$package" | awk '{$1=$1};1')
-  if [ -e "$ZOPEN_PKGINSTALL/$package/" ]; then
-    printVerbose "$package is either installed or has been previously"
-    found=$(zosfind "$ZOPEN_PKGINSTALL/$package/" -type l -prune -o -type d -print | sed -e "s#$ZOPEN_PKGINSTALL/$package/\([^/]*\).*#\1#" | uniq)
+  printVerbose "Checking for the existence of the '${package}' package directory within PKGINSTALL"
+  package=$(echo "${package}" | awk '{$1=$1};1')
+  if [ -e "${ZOPEN_PKGINSTALL}/${package}/" ]; then
+    printVerbose "${package} is either installed or has been previously"
+    found=$(zosfind "${ZOPEN_PKGINSTALL}/${package}/" -type l -prune -o -type d -print | sed -e "s#${ZOPEN_PKGINSTALL}/${package}/\([^/]*\).*#\1#" | uniq)
   else
-    printVerbose "$package has never been installed on the system"
+    printVerbose "${package} has never been installed on the system"
   fi
-  if [ -z "$found" ]; then
+  if [ -z "${found}" ]; then
     printInfo "No currently available version of package '${package}'"
     exit 4
   fi
-  if [ -e "$ZOPEN_PKGINSTALL/$package/$package" ]; then
-    deref=$(ls -l "$ZOPEN_PKGINSTALL/$package/$package" | awk '{ print $(NF) }')
-    printVerbose "Current version: ${deref#$ZOPEN_PKGINSTALL/}"
+  if [ -e "${ZOPEN_PKGINSTALL}/${package}/${package}" ]; then
+    deref=$(ls -l "${ZOPEN_PKGINSTALL}/${package}/${package}" | awk '{ print $(NF) }')
+    printVerbose "Current version: ${deref#"${ZOPEN_PKGINSTALL}"/}"
   fi
 
   i=0
   current=0
-# just the below would be simpler, but creates a subshell so can't get the number of entries outside!  
-#  echo "$found" | xargs | tr ' ' '\n' | while read repo; do
-  TMP_FIFO_PIPE="$HOME/altselect.pipe"
-  [ ! -p "$TMP_FIFO_PIPE" ] || rm -f "$TMP_FIFO_PIPE"
-  mkfifo $TMP_FIFO_PIPE
-  echo "$found" | xargs | tr ' ' '\n' >> "$TMP_FIFO_PIPE" &
+  # just the below would be simpler, but creates a subshell so can't get the number of entries outside!
+  #  echo "$found" | xargs | tr ' ' '\n' | while read repo; do
+  TMP_FIFO_PIPE="${HOME}/altselect.pipe"
+  [ ! -p "${TMP_FIFO_PIPE}" ] || rm -f "${TMP_FIFO_PIPE}"
+  mkfifo ${TMP_FIFO_PIPE}
+  echo "${found}" | xargs | tr ' ' '\n' >> "${TMP_FIFO_PIPE}" &
   while read repo; do
-    printVerbose "Parsing repo: '$repo' as '${repo#$ZOPEN_PKGINSTALL/}'"
-    i=$(expr $i + 1)
-    if [ "${deref#$ZOPEN_PKGINSTALL/}" = "${repo#$ZOPEN_PKGINSTALL/}" ]; then
-      current=$i
-      printInfo "${NC}${GREEN}$i: ${repo#$ZOPEN_PKGINSTALL/}  <-  current${NC}"
+    printVerbose "Parsing repo: '${repo}' as '${repo#"${ZOPEN_PKGINSTALL}"/}'"
+    i=$(expr ${i} + 1)
+    if [ "${deref#"${ZOPEN_PKGINSTALL}"/}" = "${repo#"${ZOPEN_PKGINSTALL}"/}" ]; then
+      current=${i}
+      printInfo "${NC}${GREEN}${i}: ${repo#"${ZOPEN_PKGINSTALL}"/}  <-  current${NC}"
     else
-      printInfo "$i: ${repo#"$ZOPEN_PKGINSTALL"/}"
+      printInfo "${i}: ${repo#"${ZOPEN_PKGINSTALL}"/}"
     fi
-  done < "$TMP_FIFO_PIPE"
-  [ ! -p $TMP_FIFO_PIPE ] || rm -rf "$TMP_FIFO_PIPE"
+  done < "${TMP_FIFO_PIPE}"
+  [ ! -p ${TMP_FIFO_PIPE} ] || rm -rf "${TMP_FIFO_PIPE}"
 
-  if $select; then
+  if ${select}; then
     mutexReq "zopen" "zopen"
-    selectAlt "$i" "$package" "$deref"
+    selectAlt "${i}" "${package}" "${deref}"
     unset select
     mutexFree "zopen"
-    listAlts false "$package"
+    listAlts false "${package}"
   fi
   exit 0
 }
 
-
 # Main code start here
 args=$*
 verbose=false
 debug=false
-sett=false  #sett to distinguish from "set" command
+sett=false #sett to distinguish from "set" command
 select=false
 if [ $# -eq 0 ]; then
   printError "Missing program argument"
@@ -191,48 +195,48 @@ fi
 while [ $# -gt 0 ]; do
   printVerbose "Parsing option: $1"
   case "$1" in
-    "-s" | "--set")
-      shift
-      [ $# -lt 2 ] && printError "Missing argument(s) for set option. Check program arguments"
-      sett=true
-      select=false
-      package="$1"
-      newver="$2"
-      shift
+  "-s" | "--set")
+    shift
+    [ $# -lt 2 ] && printError "Missing argument(s) for set option. Check program arguments"
+    sett=true
+    select=false
+    package="$1"
+    newver="$2"
+    shift
+    ;;
+  "--select")
+    select=true
+    sett=false
+    shift
+    [ $# -lt 1 ] && printError "Missing argument for select option."
+    package="$1"
+    ;;
+  "-h" | "--help" | "-?")
+    printHelp "${args}"
+    exit 0
+    ;;
+  "--version")
+    zopen --version ${ME}
+    exit 0
+    ;;
+  "-v" | "--verbose")
+    verbose=true
+    ;;
+  "--debug")
+    verbose=true
+    debug=true
+    ;;
+  *)
+    package="$1" # Multiple packages will result in the last package only
     ;;
-    "--select")
-      select=true
-      sett=false
-      shift
-      [ $# -lt 1 ] && printError "Missing argument for select option."
-      package="$1"
-      ;;
-    "-h" | "--help" | "-?")
-      printHelp "${args}"
-      exit 0
-      ;;
-    "--version")
-      zopen --version $ME
-      exit 0
-      ;;
-    "-v" | "--verbose")
-      verbose=true
-      ;;
-    "--debug")
-      verbose=true
-      debug=true
-      ;;
-    *)
-      package="$1"; # Multiple packages will result in the last package only
-      ;;
   esac
-  shift;
+  shift
 done
 
-if $sett; then
-  setAlt "$package" "$newver"
-elif [ -n "$package" ]; then
-  listAlts $select "$package"
+if ${sett}; then
+  setAlt "${package}" "${newver}"
+elif [ -n "${package}" ]; then
+  listAlts "${select}" "${package}"
 else
   printError "No action verb specified. Run zopen alt --help for command syntax"
 fi
diff --git a/bin/zopen-build b/bin/zopen-build
index ed77aceb9..2567ec4e7 100755
--- a/bin/zopen-build
+++ b/bin/zopen-build
@@ -12,14 +12,14 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
@@ -39,12 +39,12 @@ asciiecho()
   text="$1"
   file="$2"
 
-  if ! echo "${text}" >"${file}"; then
+  if ! echo "${text}" > "${file}"; then
     echo "Unable to echo text to ${file}" >&2
     return 2
   fi
   if [ "$(chtag -p "${file}" | cut -f2 -d' ')" = "IBM-1047" ]; then
-    if ! /bin/iconv -f IBM-1047 -t ISO8859-1 <"${file}" >"${file}_ascii" || ! chtag -tc ISO8859-1 "${file}_ascii" || ! mv "${file}_ascii" "${file}"; then
+    if ! /bin/iconv -f IBM-1047 -t ISO8859-1 < "${file}" > "${file}_ascii" || ! chtag -tc ISO8859-1 "${file}_ascii" || ! mv "${file}_ascii" "${file}"; then
       printError "Unable to convert EBCDIC text to ASCII for ${file}" >&2
     fi
   fi
@@ -120,7 +120,7 @@ User-Provided environment variables:
 
 printFunctions()
 {
-echo "User-Provided functions:
+  echo "User-Provided functions:
   zopen_init                  This function runs after code is downloaded and patched but before the code is built.
   zopen_post_buildenv         This function runs after the 'buildenv' is processed.
   zopen_pre_patch             This function runs before the 'patch' step of the build is run.
@@ -137,51 +137,50 @@ echo "User-Provided functions:
 }
 
 # Temporary files
-for tmp in "$TMPDIR" "$TMP" /tmp
-do
-  if [ ! -z $tmp ] && [ -d $tmp ]; then
+for tmp in "${TMPDIR}" "${TMP}" /tmp; do
+  if [ ! -z ${tmp} ] && [ -d ${tmp} ]; then
     break
   fi
 done
 
-if [ ! -d "$tmp" ]; then
+if [ ! -d "${tmp}" ]; then
   printError "Temporary directory not found. Please specify \$TMPDIR, \$TMP or have a valid /tmp directory"
 fi
 
-TMP_FIFO_PIPE="$tmp/$LOGNAME.pipe"
-ZOPEN_TEMP_C_FILE="$tmp/$LOGNAME.c"
-
+TMP_FIFO_PIPE="${tmp}/${LOGNAME}.pipe"
+ZOPEN_TEMP_C_FILE="${tmp}/${LOGNAME}.c"
 
 # Capture start time before setting trap
-fullBuildStartTime=$SECONDS
+fullBuildStartTime=${SECONDS}
 
 # Remove temoraries on exit and report elapsed time
-cleanupOnExit() {
-    rv=$?
-    [ -f $ZOPEN_TEMP_C_FILE ] && rm -rf $ZOPEN_TEMP_C_FILE
-    [ -p $TMP_FIFO_PIPE ] && rm -rf $TMP_FIFO_PIPE
-    if [ ! -z "$TEE_PID" ]; then
-      if kill -0 $TEE_PID 2>/dev/null; then
-        kill -9 $TEE_PID;
-      fi
+cleanupOnExit()
+{
+  rv=$?
+  [ -f ${ZOPEN_TEMP_C_FILE} ] && rm -rf ${ZOPEN_TEMP_C_FILE}
+  [ -p ${TMP_FIFO_PIPE} ] && rm -rf ${TMP_FIFO_PIPE}
+  if [ ! -z "${TEE_PID}" ]; then
+    if kill -0 ${TEE_PID} 2> /dev/null; then
+      kill -9 ${TEE_PID}
     fi
-    printElapsedTime info "zopen-build" $fullBuildStartTime
-    trap - EXIT # clear the EXIT trap so that it's not double called
-    exit $rv
+  fi
+  printElapsedTime info "zopen-build" ${fullBuildStartTime}
+  trap - EXIT # clear the EXIT trap so that it's not double called
+  exit ${rv}
 }
 
 trap "cleanupOnExit" EXIT INT TERM QUIT HUP
 
 setDefaultBuild()
 {
-  if [ ! -z "$ZOPEN_BUILD_LINE_OPT" ]; then
+  if [ ! -z "${ZOPEN_BUILD_LINE_OPT}" ]; then
     ZOPEN_BUILD_LINE=$(echo "${ZOPEN_BUILD_LINE_OPT}" | tr '[a-z]' '[A-Z]')
   else
     ZOPEN_BUILD_LINE=$(echo "${ZOPEN_BUILD_LINE}" | tr '[a-z]' '[A-Z]')
   fi
 
-  if [ ! -z "$ZOPEN_BUILD_LINE" ]; then
-    printVerbose "Setting build to $ZOPEN_BUILD_LINE"
+  if [ ! -z "${ZOPEN_BUILD_LINE}" ]; then
+    printVerbose "Setting build to ${ZOPEN_BUILD_LINE}"
   fi
 }
 
@@ -198,10 +197,10 @@ setDefaults()
   export ZOPEN_INSTALL_OPTSD="install"
   export ZOPEN_CLEAND="make"
   export ZOPEN_CLEAN_OPTSD="clean"
-  if [ -z "$ZOPEN_IMAGE_DOCKERFILE_NAME" ]; then
+  if [ -z "${ZOPEN_IMAGE_DOCKERFILE_NAME}" ]; then
     export ZOPEN_IMAGE_DOCKERFILE_NAME="Dockerfile"
   fi
-  if [ -z "$ZOPEN_IMAGE_DOCKER_NAME" ]; then
+  if [ -z "${ZOPEN_IMAGE_DOCKER_NAME}" ]; then
     export ZOPEN_IMAGE_DOCKER_NAME="podman"
   fi
   export ZOPEN_TEST_STATUS_ALL_PASSED=0
@@ -226,39 +225,41 @@ setDefaults()
 printSyntax()
 {
   args=$*
-  (echo ""
-  echo "zopen-build is a general purpose build script to be used with the ZOSOpenTools ports."
-  echo "The specifics of how the tool works can be controlled through environment variables."
-  echo "The only environment variables you _must_ specify are to tell zopen-build where the "
-  echo "  source is, and in what format type the source is stored."
-  echo "By default, the environment variables are defined in a file named buildenv in the "
-  echo "  root directory of the <package>port github repository"
-  echo "To see a fully functioning z/OSOpenTools sample port"
-  echo "  see: https://github.com/ZOSOpenTools/zotsampleport"
-  echo ""
-  echo "Syntax: zopen-build [<option>]*"
-  echo "  where <option> may be one or more of:"
-  echo "  -h: print this information"
-  echo "  -v: run in verbose mode"
-  echo "  -vv: run in very verbose mode (sets environment variables V=1 and VERBOSE=1)"
-  echo "  -u|--upgradedeps: upgrade all dependencies by running zopen install"
-  echo "  --buildtype: release|debug. The default is release"
-  echo "  --build: dev|stable. This is the build line to build off of. If no build line is specified, it will use the ZOPEN_BUILD_LINE specified in the build, otherwise it will fallback to ZOPEN_TYPE."
-  echo "  --comp: <compiler dependency>.  The compiler(s) used for building.  The default is comp_xlclang."
-  echo "  --oci: build and publish an OCI image to \$ZOPEN_IMAGE_REGISTRY"
-  echo "  -e <env file>: source <env file> instead of buildenv to establish build environment"
-  echo "  -c|--clean: Deletes all of the build output and forces reconfigure with next build"
-  echo "  -f|--force-rebuild: forces a rebuild, including running bootstrap and configure again"
-  echo "  -g|--get-source: get the source and apply patch without building"
-  echo "  -gp|--generate-pax: generate a pax.Z file based on the install contents"
-  echo "  --forcepatchapply: force apply the patches, where rejected patches are placed into a corresponding file of the same name, with the .rej extension"
-  echo "  --no-set-active: do not change the pinned version"  >&2
-  echo "  -s: exec a shell before running configure.  Useful when manually building ports."
-
-  opts=$(printEnvVar)
-  echo "${opts}"
-  fns=$(printFunctions)
-  echo "${fns}" ) >&2
+  (
+    echo ""
+    echo "zopen-build is a general purpose build script to be used with the ZOSOpenTools ports."
+    echo "The specifics of how the tool works can be controlled through environment variables."
+    echo "The only environment variables you _must_ specify are to tell zopen-build where the "
+    echo "  source is, and in what format type the source is stored."
+    echo "By default, the environment variables are defined in a file named buildenv in the "
+    echo "  root directory of the <package>port github repository"
+    echo "To see a fully functioning z/OSOpenTools sample port"
+    echo "  see: https://github.com/ZOSOpenTools/zotsampleport"
+    echo ""
+    echo "Syntax: zopen-build [<option>]*"
+    echo "  where <option> may be one or more of:"
+    echo "  -h: print this information"
+    echo "  -v: run in verbose mode"
+    echo "  -vv: run in very verbose mode (sets environment variables V=1 and VERBOSE=1)"
+    echo "  -u|--upgradedeps: upgrade all dependencies by running zopen install"
+    echo "  --buildtype: release|debug. The default is release"
+    echo "  --build: dev|stable. This is the build line to build off of. If no build line is specified, it will use the ZOPEN_BUILD_LINE specified in the build, otherwise it will fallback to ZOPEN_TYPE."
+    echo "  --comp: <compiler dependency>.  The compiler(s) used for building.  The default is comp_xlclang."
+    echo "  --oci: build and publish an OCI image to \$ZOPEN_IMAGE_REGISTRY"
+    echo "  -e <env file>: source <env file> instead of buildenv to establish build environment"
+    echo "  -c|--clean: Deletes all of the build output and forces reconfigure with next build"
+    echo "  -f|--force-rebuild: forces a rebuild, including running bootstrap and configure again"
+    echo "  -g|--get-source: get the source and apply patch without building"
+    echo "  -gp|--generate-pax: generate a pax.Z file based on the install contents"
+    echo "  --forcepatchapply: force apply the patches, where rejected patches are placed into a corresponding file of the same name, with the .rej extension"
+    echo "  --no-set-active: do not change the pinned version" >&2
+    echo "  -s: exec a shell before running configure.  Useful when manually building ports."
+
+    opts=$(printEnvVar)
+    echo "${opts}"
+    fns=$(printFunctions)
+    echo "${fns}"
+  ) >&2
 }
 
 processOptions()
@@ -277,84 +278,84 @@ processOptions()
   generatePax=false
   setActive=true
   forcePatchApply=false
-  depsPath="$ZOPEN_PKGINSTALL"
+  depsPath="${ZOPEN_PKGINSTALL}"
   forceUpgradeDeps=false
   while [[ $# -gt 0 ]]; do
     case $1 in
-      "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
-        trap - EXIT 
-        printSyntax "${args}"
-        exit 0
-        ;;
-      "--version")
-        trap - EXIT 
-        zopen --version $ME
-        exit 0
-        ;;
-      "-v" | "--v" | "-verbose" | "--verbose")
-        verbose=true
-        ;;
-      "-vv" | "--vv" | "-veryverbose" | "--veryverbose")
-        export V=1
-        export VERBOSE=1
-        verbose=true
-        ;;
-      "-u" | "--upgradeDeps")
-        forceUpgradeDeps=true
-        ;;
-      "--forcepatchapply")
-        forcePatchApply=true
-        ;;
-      "-buildtype" | "--buildtype" | "-b")
-        shift
-        btype=$(echo "$1" | awk '{print toupper($0)}')
-        if [ "$btype" = "DEBUG" ]; then
-          buildInReleaseMode=false
-        fi
-        ;;
-      "-comp" | "--comp")
-        shift
-        ZOPEN_COMP=$1 # We will uppercase this later
-        ;;
-      "-build" | "--build")
-        shift
-        ZOPEN_BUILD_LINE_OPT=$1
-        ;;
-      "-oci" | "--oci")
-        publishOCI=true
-        ;;
-      "-sc" | "--skipcheck")
-        skipcheck=true
-        ;;
-      "-d" | "--depspath")
-        shift
-        depsPath="${1}|${depsPath}"
-        ;;
-      "--no-set-active")
-        setActive=false  # Install package as normal but keep existing installation as active
-        ;;
-      "-e" | "--env")
-        shift
-        buildEnvFile=$1
-        ;;
-      "-c" | "--clean")
-        cleanupBuild=true
-        ;;
-      "-f" | "--force-rebuild")
-        forceRebuild=true
-        ;;
-      "-g" | "--get-source")
-        getSourceOnly=true
-        ;;
-      "-gp" | "--generate-pax")
-        generatePax=true
-        ;;
-      "-s" | "--shell")
-        startShell=true
-        ;;
-      *)
-        printError "Unknown option ${arg} specified"
-        ;;
+    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+      trap - EXIT
+      printSyntax "${args}"
+      exit 0
+      ;;
+    "--version")
+      trap - EXIT
+      zopen --version ${ME}
+      exit 0
+      ;;
+    "-v" | "--v" | "-verbose" | "--verbose")
+      verbose=true
+      ;;
+    "-vv" | "--vv" | "-veryverbose" | "--veryverbose")
+      export V=1
+      export VERBOSE=1
+      verbose=true
+      ;;
+    "-u" | "--upgradeDeps")
+      forceUpgradeDeps=true
+      ;;
+    "--forcepatchapply")
+      forcePatchApply=true
+      ;;
+    "-buildtype" | "--buildtype" | "-b")
+      shift
+      btype=$(echo "$1" | awk '{print toupper($0)}')
+      if [ "${btype}" = "DEBUG" ]; then
+        buildInReleaseMode=false
+      fi
+      ;;
+    "-comp" | "--comp")
+      shift
+      ZOPEN_COMP=$1 # We will uppercase this later
+      ;;
+    "-build" | "--build")
+      shift
+      ZOPEN_BUILD_LINE_OPT=$1
+      ;;
+    "-oci" | "--oci")
+      publishOCI=true
+      ;;
+    "-sc" | "--skipcheck")
+      skipcheck=true
+      ;;
+    "-d" | "--depspath")
+      shift
+      depsPath="${1}|${depsPath}"
+      ;;
+    "--no-set-active")
+      setActive=false # Install package as normal but keep existing installation as active
+      ;;
+    "-e" | "--env")
+      shift
+      buildEnvFile=$1
+      ;;
+    "-c" | "--clean")
+      cleanupBuild=true
+      ;;
+    "-f" | "--force-rebuild")
+      forceRebuild=true
+      ;;
+    "-g" | "--get-source")
+      getSourceOnly=true
+      ;;
+    "-gp" | "--generate-pax")
+      generatePax=true
+      ;;
+    "-s" | "--shell")
+      startShell=true
+      ;;
+    *)
+      printError "Unknown option ${arg} specified"
+      ;;
     esac
     shift
   done
@@ -362,18 +363,18 @@ processOptions()
 
 loadBuildEnv()
 {
-  if [ ! -r $buildEnvFile ]; then
-    printError "Build environment file '$buildEnvFile' does not exist or is not readable"
+  if [ ! -r ${buildEnvFile} ]; then
+    printError "Build environment file '${buildEnvFile}' does not exist or is not readable"
   fi
 
   # Indicates to .env script that we're in zopen build
   export ZOPEN_IN_ZOPEN_BUILD=1
 
-  . $buildEnvFile
+  . ${buildEnvFile}
 
   setDefaultBuild
 
-  if command -V "zopen_post_buildenv" >/dev/null 2>&1; then
+  if command -V "zopen_post_buildenv" > /dev/null 2>&1; then
     printVerbose "Running zopen_post_buildenv"
     zopen_post_buildenv
   fi
@@ -385,50 +386,50 @@ checkEnv()
 
   if [ ! -z "${ZOPEN_BUILD_LINE}" ]; then
     if [ "${ZOPEN_BUILD_LINE}x" = "DEVx" ]; then
-      if [ -z "$ZOPEN_DEV_DEPS" ]; then
+      if [ -z "${ZOPEN_DEV_DEPS}" ]; then
         printError "Building from dev, but ZOPEN_DEV_DEPS not specified"
       fi
-      ZOPEN_DEPS="$ZOPEN_DEV_DEPS"  
-      if [ -z "$ZOPEN_DEV_URL" ]; then
+      ZOPEN_DEPS="${ZOPEN_DEV_DEPS}"
+      if [ -z "${ZOPEN_DEV_URL}" ]; then
         printError "Building from dev, but ZOPEN_DEV_URL not specified"
       fi
-      ZOPEN_URL="$ZOPEN_DEV_URL"  
-      if [ ! -z "$ZOPEN_DEV_BRANCH" ]; then
-        export ZOPEN_GIT_BRANCH="$ZOPEN_DEV_BRANCH"
+      ZOPEN_URL="${ZOPEN_DEV_URL}"
+      if [ ! -z "${ZOPEN_DEV_BRANCH}" ]; then
+        export ZOPEN_GIT_BRANCH="${ZOPEN_DEV_BRANCH}"
       fi
-      if [ ! -z "$ZOPEN_DEV_TAG" ]; then
-        export ZOPEN_GIT_TAG="$ZOPEN_DEV_TAG"
+      if [ ! -z "${ZOPEN_DEV_TAG}" ]; then
+        export ZOPEN_GIT_TAG="${ZOPEN_DEV_TAG}"
       fi
-      if [ ! -z "$ZOPEN_DEV_TYPE" ]; then
-        export ZOPEN_TYPE="$ZOPEN_DEV_TYPE"
+      if [ ! -z "${ZOPEN_DEV_TYPE}" ]; then
+        export ZOPEN_TYPE="${ZOPEN_DEV_TYPE}"
       else
         extension="${ZOPEN_URL##*.}"
-        if [ "$extension" = "git" ]; then
+        if [ "${extension}" = "git" ]; then
           ZOPEN_TYPE="GIT"
         else
           ZOPEN_TYPE="TARBALL"
         fi
       fi
     elif [ "${ZOPEN_BUILD_LINE}x" = "STABLEx" ]; then
-      if [ -z "$ZOPEN_STABLE_DEPS" ]; then
+      if [ -z "${ZOPEN_STABLE_DEPS}" ]; then
         printError "Building from stable, but ZOPEN_STABLE_DEPS not specified"
       fi
-      ZOPEN_DEPS="$ZOPEN_STABLE_DEPS"  
-      if [ -z "$ZOPEN_STABLE_URL" ]; then
+      ZOPEN_DEPS="${ZOPEN_STABLE_DEPS}"
+      if [ -z "${ZOPEN_STABLE_URL}" ]; then
         printError "Building from stable, but ZOPEN_STABLE_URL not specified"
       fi
-      ZOPEN_URL="$ZOPEN_STABLE_URL"  
-      if [ ! -z "$ZOPEN_STABLE_BRANCH" ]; then
-        export ZOPEN_GIT_BRANCH="$ZOPEN_STABLE_BRANCH"
+      ZOPEN_URL="${ZOPEN_STABLE_URL}"
+      if [ ! -z "${ZOPEN_STABLE_BRANCH}" ]; then
+        export ZOPEN_GIT_BRANCH="${ZOPEN_STABLE_BRANCH}"
       fi
-      if [ ! -z "$ZOPEN_STABLE_TAG" ]; then
-        export ZOPEN_GIT_TAG="$ZOPEN_STABLE_TAG"
+      if [ ! -z "${ZOPEN_STABLE_TAG}" ]; then
+        export ZOPEN_GIT_TAG="${ZOPEN_STABLE_TAG}"
       fi
-      if [ ! -z "$ZOPEN_STABLE_TYPE" ]; then
-        export ZOPEN_TYPE="$ZOPEN_STABLE_TYPE"
+      if [ ! -z "${ZOPEN_STABLE_TYPE}" ]; then
+        export ZOPEN_TYPE="${ZOPEN_STABLE_TYPE}"
       else
         extension="${ZOPEN_URL##*.}"
-        if [ "$extension" = "git" ]; then
+        if [ "${extension}" = "git" ]; then
           ZOPEN_TYPE="GIT"
         else
           ZOPEN_TYPE="TARBALL"
@@ -436,7 +437,7 @@ checkEnv()
       fi
     else
       printError "Unrecognized build line ${ZOPEN_BUILD_LINE}"
-    fi 
+    fi
   else
     if [ "${ZOPEN_TYPE}x" = "TARBALLx" ]; then
       if [ ! -z "${ZOPEN_TARBALL_URL}" ]; then
@@ -458,7 +459,7 @@ checkEnv()
       printHeader "Using bare environment"
     else
       extension="${ZOPEN_URL##*.}"
-      if [ "$extension" = "git" ]; then
+      if [ "${extension}" = "git" ]; then
         ZOPEN_TYPE="GIT"
       else
         ZOPEN_TYPE="TARBALL"
@@ -477,37 +478,37 @@ checkEnv()
   ZOPEN_POST_INSTALL_CODE="zopen_post_install"
   ZOPEN_CHECK_RESULTS_CODE="zopen_check_results"
 
-  if ! command -V "${ZOPEN_CHECK_RESULTS_CODE}" >/dev/null 2>&1; then
+  if ! command -V "${ZOPEN_CHECK_RESULTS_CODE}" > /dev/null 2>&1; then
     if [ "${ZOPEN_CHECK}x" != "skipx" ] && ! ${skipcheck}; then
-       export ZOPEN_CHECK_RESULTS_CODE="${ZOPEN_ROOT}/portchk.sh"
-       if ! [ -x "${ZOPEN_CHECK_RESULTS_CODE}" ]; then
-          printError "zopen_check_results script needs to be provided to check the results."
-       fi
+      export ZOPEN_CHECK_RESULTS_CODE="${ZOPEN_ROOT}/portchk.sh"
+      if ! [ -x "${ZOPEN_CHECK_RESULTS_CODE}" ]; then
+        printError "zopen_check_results script needs to be provided to check the results."
+      fi
     fi
   fi
 
   implicitDeps="sed" # for replaceHardcodedPaths logic
 
-  if [ "${ZOPEN_COMP}x" = "x" ]; then
-    implicitDeps="$implicitDeps comp_xlclang"  
+  if [ -z "${ZOPEN_COMP}" ]; then
+    implicitDeps="${implicitDeps} comp_xlclang"
   else
     # user specified, so normalize in lower case
     ZOPEN_COMP=$(echo "${ZOPEN_COMP}" | tr '[A-Z]' '[a-z]')
-    implicitDeps="$implicitDeps comp_$ZOPEN_COMP"
+    implicitDeps="${implicitDeps} comp_${ZOPEN_COMP}"
   fi
 
   if [ "${ZOPEN_TYPE}x" = "TARBALLx" ]; then
-    if [ "${ZOPEN_URL}x" = "x" ]; then
+    if [ -z "${ZOPEN_URL}" ]; then
       printError "ZOPEN_STABLE_URL, ZOPEN_DEV_URL, ZOPEN_URL or ZOPEN_TARBALL_URL needs to be defined"
     fi
-    if [ "${ZOPEN_DEPS}x" = "x" ]; then
+    if [ -z "${ZOPEN_DEPS}" ]; then
       printError "ZOPEN_STABLE_DEPS, ZOPEN_DEV_DEPS, ZOPEN_DEPS or ZOPEN_TARBALL_DEPS needs to be defined"
     fi
-    implicitDeps="$implicitDeps git curl tar"
+    implicitDeps="${implicitDeps} git curl tar"
     ext=${ZOPEN_URL##*.}
     if [ "${ext}x" = "xzx" ]; then
       implicitDeps="${implicitDeps} xz"
-    elif [ "${ext}x" = "gzx" -o  "${ext}x" = "tgzx" ]; then
+    elif [ "${ext}x" = "gzx" -o "${ext}x" = "tgzx" ]; then
       implicitDeps="${implicitDeps} gzip"
     elif [ "${ext}x" = "bz2x" ]; then
       implicitDeps="${implicitDeps} bzip2"
@@ -515,13 +516,13 @@ checkEnv()
     printVerbose "Implicitly adding tarball dependencies: ${implicitDeps}"
     ZOPEN_DEPS="${implicitDeps} ${ZOPEN_DEPS}"
   elif [ "${ZOPEN_TYPE}x" = "GITx" ]; then
-    if [ "${ZOPEN_URL}x" = "x" ]; then
+    if [ -z "${ZOPEN_URL}" ]; then
       printError "ZOPEN_STABLE_URL, ZOPEN_DEV_URL, ZOPEN_URL or ZOPEN_GIT_URL needs to be defined"
     fi
-    if [ "${ZOPEN_DEPS}x" = "x" ]; then
+    if [ -z "${ZOPEN_DEPS}" ]; then
       printError "ZOPEN_STABLE_DEPS, ZOPEN_DEV_DEPS, ZOPEN_DEPS or ZOPEN_GIT_DEPS needs to be defined"
     fi
-    implicitDeps="$implicitDeps git"
+    implicitDeps="${implicitDeps} git"
     printVerbose "Implicitly adding git dependencies: ${implicitDeps}"
     ZOPEN_DEPS="${implicitDeps} ${ZOPEN_DEPS}"
   fi
@@ -537,43 +538,43 @@ checkEnv()
 
 setDepsEnv()
 {
-  if command -V curl >/dev/null 2>&1; then
+  if command -V curl > /dev/null 2>&1; then
     curlpath=$(dirname "$(command -V curl | cut -f3 -d' ')")
   fi
   initDefaultEnvironment
   # Add base dependencies:
   # zopen bin, and curl
-  export PATH="$utilparentdir/bin:$PATH"
-  if $forceUpgradeDeps; then
-    export PATH="$curlpath:$PATH"
+  export PATH="${utilparentdir}/bin:${PATH}"
+  if ${forceUpgradeDeps}; then
+    export PATH="${curlpath}:${PATH}"
   fi
 
   deps="${ZOPEN_DEPS}"
 
   orig="${PWD}"
   # Filter out duplicate deps
-  deps=$(echo "$deps" | xargs | tr ' ' '\n' | sort -u)
-  for dep in $deps; do
-    printVerbose "Searching for dependency $dep"
-    parseline=$(parseDeps $dep)
-    dep=$(echo $parseline | awk -F'|' '{print $1}')
-    operator=$(echo $parseline | awk -F'|' '{print $2}')
-    requestedMajor=$(echo $parseline | awk -F'|' '{print $3}')
-    requestedMinor=$(echo $parseline | awk -F'|' '{print $4}')
-    requestedPatch=$(echo $parseline | awk -F'|' '{print $5}')
-    requestedSubrelease=$(echo $parseline | awk -F'|' '{print $6}')
+  deps=$(echo "${deps}" | xargs | tr ' ' '\n' | sort -u)
+  for dep in ${deps}; do
+    printVerbose "Searching for dependency ${dep}"
+    parseline=$(parseDeps ${dep})
+    dep=$(echo ${parseline} | awk -F'|' '{print $1}')
+    operator=$(echo ${parseline} | awk -F'|' '{print $2}')
+    requestedMajor=$(echo ${parseline} | awk -F'|' '{print $3}')
+    requestedMinor=$(echo ${parseline} | awk -F'|' '{print $4}')
+    requestedPatch=$(echo ${parseline} | awk -F'|' '{print $5}')
+    requestedSubrelease=$(echo ${parseline} | awk -F'|' '{print $6}')
     requestedVersion="${requestedMajor}.${requestedMinor}.${requestedPatch}.${requestedSubrelease}"
     foundDep=false
-    for path in `echo ${depsPath} | tr '|' '\n'` ; do
-      if [ -r "$path/${dep}/${dep}/.env" ]; then
-        depdir="$path/${dep}/${dep}"
-        versionPath="$depdir/.version"
-        if [ -r "$versionPath" ]; then
-          version=$(cat "$versionPath");
+    for path in $(echo ${depsPath} | tr '|' '\n'); do
+      if [ -r "${path}/${dep}/${dep}/.env" ]; then
+        depdir="${path}/${dep}/${dep}"
+        versionPath="${depdir}/.version"
+        if [ -r "${versionPath}" ]; then
+          version=$(cat "${versionPath}")
         fi
         # Avoid double sourcing the .env if we're forcing an upgrade on it
-        if ! $forceUpgradeDeps; then
-          if ! validateVersion "${version}" "$operator" "${requestedVersion}" "$depdir"; then
+        if ! ${forceUpgradeDeps}; then
+          if ! validateVersion "${version}" "${operator}" "${requestedVersion}" "${depdir}"; then
             continue
           fi
 
@@ -587,35 +588,35 @@ setDepsEnv()
         break
       fi
     done
-    if ! $foundDep || $forceUpgradeDeps; then
-      if ! $forceUpgradeDeps; then
-        if [ -z "$operator" ]; then
-          printWarning "Dependency $dep not found. Downloading via zopen install"
+    if ! ${foundDep} || ${forceUpgradeDeps}; then
+      if ! ${forceUpgradeDeps}; then
+        if [ -z "${operator}" ]; then
+          printWarning "Dependency ${dep} not found. Downloading via zopen install"
         else
-          printWarning "Dependency $dep $operator ${requestedVersion} not found. Downloading via zopen install"
+          printWarning "Dependency ${dep} ${operator} ${requestedVersion} not found. Downloading via zopen install"
         fi
       else
-        printHeader "Upgrading dependency $dep. Installing via zopen install"
+        printHeader "Upgrading dependency ${dep}. Installing via zopen install"
       fi
-      if [ -z "$curlpath" ]; then
+      if [ -z "${curlpath}" ]; then
         printError "Need curl to proceed with installation"
       fi
-      path=$ZOPEN_PKGINSTALL # Install location
-      if ! runAndLog "PATH=\"$curlpath:$PATH\" $MYDIR/zopen-install --install-or-upgrade $dep -v -y"; then
+      path=${ZOPEN_PKGINSTALL} # Install location
+      if ! runAndLog "PATH=\"${curlpath}:${PATH}\" ${MYDIR}/zopen-install --install-or-upgrade ${dep} -v -y"; then
         printError "zopen install command failed"
       fi
-      depdir="$path/${dep}/${dep}"
-      printVerbose "Setting up upgraded $depdir dependency environment"
-      cd "$depdir" && . ./.env
+      depdir="${path}/${dep}/${dep}"
+      printVerbose "Setting up upgraded ${depdir} dependency environment"
+      cd "${depdir}" && . ./.env
       if [ $? -gt 0 ]; then
         printError "Failed to source ${depdir} .env"
       fi
-      versionPath="$depdir/.version"
-      if [ -r "$versionPath" ]; then
-        version=$(cat "$versionPath");
+      versionPath="${depdir}/.version"
+      if [ -r "${versionPath}" ]; then
+        version=$(cat "${versionPath}")
       fi
-      if ! validateVersion "${version}" "$operator" "${requestedVersion}" "$depdir"; then
-        printError "Dependency $depdir upgraded, but does not satisfy \"$operator\" \"${requestedVersion}\""
+      if ! validateVersion "${version}" "${operator}" "${requestedVersion}" "${depdir}"; then
+        printError "Dependency ${depdir} upgraded, but does not satisfy \"${operator}\" \"${requestedVersion}\""
       fi
     fi
   done
@@ -632,7 +633,7 @@ setEnv()
 
   setDepsEnv
 
-  # Dependencies such as libraries may add flags 
+  # Dependencies such as libraries may add flags
   export CPPFLAGS="${ZOPEN_CPPFLAGS} ${ZOPEN_EXTRA_CPPFLAGS}"
   export CFLAGS="${ZOPEN_CFLAGS} ${ZOPEN_EXTRA_CFLAGS}"
   export CXXFLAGS="${ZOPEN_CXXFLAGS} ${ZOPEN_EXTRA_CXXFLAGS}"
@@ -651,51 +652,51 @@ setEnv()
   export LDFLAGS_FOR_BUILD="${LDFLAGS}"
   export LIBS_FOR_BUILD="${LIBS}"
 
-  if [ "${ZOPEN_NUM_JOBS}x" = "x" ]; then
+  if [ -z "${ZOPEN_NUM_JOBS}" ]; then
     ZOPEN_NUM_JOBS=$("${MYDIR}/numcpus.rexx")
 
     # Use half of the CPUs by default
     export ZOPEN_NUM_JOBS=$((ZOPEN_NUM_JOBS / 2))
   fi
 
-  if [ $ZOPEN_NUM_JOBS -lt 1 ]; then
+  if [ ${ZOPEN_NUM_JOBS} -lt 1 ]; then
     export ZOPEN_NUM_JOBS=1
   fi
 
-  if [ "${ZOPEN_BOOTSTRAP}x" = "x" ]; then
+  if [ -z "${ZOPEN_BOOTSTRAP}" ]; then
     export ZOPEN_BOOTSTRAP="${ZOPEN_BOOTSTRAPD}"
   fi
-  if [ "${ZOPEN_BOOTSTRAP_OPTS}x" = "x" ]; then
+  if [ -z "${ZOPEN_BOOTSTRAP_OPTS}" ]; then
     export ZOPEN_BOOTSTRAP_OPTS="${ZOPEN_BOOTSTRAP_OPTSD}"
   fi
-  if [ "${ZOPEN_CONFIGURE}x" = "x" ]; then
+  if [ -z "${ZOPEN_CONFIGURE}" ]; then
     export ZOPEN_CONFIGURE="${ZOPEN_CONFIGURED}"
   fi
-  if [ "${ZOPEN_MAKE}x" = "x" ]; then
+  if [ -z "${ZOPEN_MAKE}" ]; then
     export ZOPEN_MAKE="${ZOPEN_MAKED}"
   fi
-  if [ "${ZOPEN_MAKE_OPTS}x" = "x" ]; then
+  if [ -z "${ZOPEN_MAKE_OPTS}" ]; then
     export ZOPEN_MAKE_OPTS="-j${ZOPEN_NUM_JOBS}"
   fi
-  if [ "${ZOPEN_CHECK}x" = "x" ]; then
+  if [ -z "${ZOPEN_CHECK}" ]; then
     export ZOPEN_CHECK="${ZOPEN_CHECKD}"
   fi
-  if [ "${ZOPEN_CHECK_TIMEOUT}x" = "x" ]; then
+  if [ -z "${ZOPEN_CHECK_TIMEOUT}" ]; then
     export ZOPEN_CHECK_TIMEOUT="${ZOPEN_CHECK_TIMEOUTD}"
   fi
-  if [ "${ZOPEN_CHECK_OPTS}x" = "x" ]; then
+  if [ -z "${ZOPEN_CHECK_OPTS}" ]; then
     export ZOPEN_CHECK_OPTS="${ZOPEN_CHECK_OPTSD}"
   fi
-  if [ "${ZOPEN_INSTALL}x" = "x" ]; then
+  if [ -z "${ZOPEN_INSTALL}" ]; then
     export ZOPEN_INSTALL="${ZOPEN_INSTALLD}"
   fi
-  if [ "${ZOPEN_INSTALL_OPTS}x" = "x" ]; then
+  if [ -z "${ZOPEN_INSTALL_OPTS}" ]; then
     export ZOPEN_INSTALL_OPTS="-j${ZOPEN_NUM_JOBS} ${ZOPEN_INSTALL_OPTSD}"
   fi
-  if [ "${ZOPEN_CLEAN}x" = "x" ]; then
+  if [ -z "${ZOPEN_CLEAN}" ]; then
     export ZOPEN_CLEAN="${ZOPEN_CLEAND}"
   fi
-  if [ "${ZOPEN_CLEAN_OPTS}x" = "x" ]; then
+  if [ -z "${ZOPEN_CLEAN_OPTS}" ]; then
     export ZOPEN_CLEAN_OPTS="${ZOPEN_CLEAN_OPTSD}"
   fi
   LOG_PFX=$(date +%C%y%m%d_%H%M%S)
@@ -707,7 +708,7 @@ setEnv()
 tagBinaryFiles()
 {
   absdir="$1"
-  (cd "${absdir}" && find . -name "*.pdf" -o -name "*.png" -o -name "*.jpg" -o -name "*.gif" -o -name "*.ttf" -o -name "*.wbmp" -o -name "*.gmo" -o -name "*.po" -o -name "*.der"  -o -name "*.xz" -o -name "*.gz" ! -type d ! -type l | xargs -I {} chtag -b {})
+  (cd "${absdir}" && find . -name "*.pdf" -o -name "*.png" -o -name "*.jpg" -o -name "*.gif" -o -name "*.ttf" -o -name "*.wbmp" -o -name "*.gmo" -o -name "*.po" -o -name "*.der" -o -name "*.xz" -o -name "*.gz" ! -type d ! -type l | xargs -I {} chtag -b {})
 }
 
 #
@@ -723,7 +724,7 @@ tagTree()
 
 checkGitVersion()
 {
-  if ! git --version >/dev/null 2>/dev/null; then
+  if ! git --version > /dev/null 2> /dev/null; then
     printError "git is required to download from the git repo"
   fi
   gitraw=$(git --version | awk '{print $3;}')
@@ -737,25 +738,25 @@ checkGitVersion()
 
 gitClone()
 {
-  gitname=$(basename "$ZOPEN_URL")
+  gitname=$(basename "${ZOPEN_URL}")
   dir=${gitname%%.*}
   if [ -d "${dir}" ]; then
     printInfo "Using existing git clone'd directory ${dir}"
   else
     freshBuild=true
     printInfo "Clone and create ${dir}"
-    if [ "$ZOPEN_CLONE_SUBMODULES" = "yes" ]; then
+    if [ "${ZOPEN_CLONE_SUBMODULES}" = "yes" ]; then
       gitOptions=" --recurse-submodules"
     fi
-    if ! runAndLog "git clone \"${ZOPEN_URL}\" $gitOptions"; then
+    if ! runAndLog "git clone \"${ZOPEN_URL}\" ${gitOptions}"; then
       printError "Unable to clone ${gitname} from ${ZOPEN_URL}"
     fi
-    if [ "${ZOPEN_GIT_BRANCH}x" != "x" ]; then
-      if ! git -C "${dir}" checkout "${ZOPEN_GIT_BRANCH}" >/dev/null; then
+    if [ -n "${ZOPEN_GIT_BRANCH}" ]; then
+      if ! git -C "${dir}" checkout "${ZOPEN_GIT_BRANCH}" > /dev/null; then
         printError"Unable to checkout ${ZOPEN_URL} branch ${ZOPEN_GIT_BRANCH}"
       fi
-    elif [ "${ZOPEN_GIT_TAG}x" != "x" ]; then
-      if ! git -C "${dir}" checkout tags/"${ZOPEN_GIT_TAG}" -b "${ZOPEN_GIT_TAG}" >/dev/null; then
+    elif [ -n "${ZOPEN_GIT_TAG}" ]; then
+      if ! git -C "${dir}" checkout tags/"${ZOPEN_GIT_TAG}" -b "${ZOPEN_GIT_TAG}" > /dev/null; then
         printError"Unable to checkout ${ZOPEN_URL} tag ${ZOPEN_GIT_TAG}"
       fi
     fi
@@ -769,7 +770,7 @@ extractTarBall()
   tarballz="$1"
   dir="$2"
 
-  if ! tar --version >/dev/null 2>/dev/null; then
+  if ! tar --version > /dev/null 2> /dev/null; then
     printError "The tar open source package is required by zopen-build. The z/OS default 'tar' is insufficient"
   fi
   tarraw=$(tar --version | head -1 | awk '{print $4;}')
@@ -798,11 +799,11 @@ extractTarBall()
   # Perhaps this can be done with a function but be aware of blanks, newlines, etc. in file names
   #
   if [ "${ZOPEN_GIT_SETUP}x" = "Nx" ]; then
-    if ! git init -b main . >/dev/null || ! git commit --allow-empty -m "Create Empty Repository for patch management" >/dev/null; then
+    if ! git init -b main . > /dev/null || ! git commit --allow-empty -m "Create Empty Repository for patch management" > /dev/null; then
       printError "Unable to initialize empty git repository for tarball"
     fi
   else
-    if ! git init -b main . >/dev/null; then
+    if ! git init -b main . > /dev/null; then
       printError "Unable to initialize git repository for tarball"
     fi
 
@@ -825,11 +826,11 @@ extractTarBall()
       printError "Unable to create .gitattributes for tarball"
     fi
 
-    if ! git add . >/dev/null; then
+    if ! git add . > /dev/null; then
       printError "Unable to add files for git repository"
     fi
 
-    if ! git commit --allow-empty -m "Create Repository for patch management" >/dev/null; then
+    if ! git commit --allow-empty -m "Create Repository for patch management" > /dev/null; then
       printError "Unable to commit git repository"
     fi
   fi
@@ -837,10 +838,10 @@ extractTarBall()
 
 downloadTarBall()
 {
-  if ! curl --version >/dev/null; then
+  if ! curl --version > /dev/null; then
     printError "curl is required to download a tarball"
   fi
-  tarballz=$(basename "$ZOPEN_URL")
+  tarballz=$(basename "${ZOPEN_URL}")
   dir=${tarballz%%.tar.*}
   dir=${dir%%.tgz}
   if [ -d "${dir}" ]; then
@@ -848,7 +849,7 @@ downloadTarBall()
   else
     freshBuild=true
     if ${verbose}; then
-      printVerbose "curl $ZOPEN_CURL_PARAMS -L -o ${tarballz} ${ZOPEN_URL}"
+      printVerbose "curl ${ZOPEN_CURL_PARAMS} -L -o ${tarballz} ${ZOPEN_URL}"
     fi
     #
     # Some older tarballs (openssl) contain a pax_global_header file. Remove it
@@ -861,11 +862,11 @@ downloadTarBall()
     # Make a first call to just get the headers and toss everything out just to
     # set up the cache (requirec for openssl)
     #
-    curlCmd -I "${ZOPEN_URL}" >/dev/null 2>&1
+    curlCmd -I "${ZOPEN_URL}" > /dev/null 2>&1
 
-    if ! curlCmd -L -0 -o "${tarballz}" "${ZOPEN_URL}";  then
+    if ! curlCmd -L -0 -o "${tarballz}" "${ZOPEN_URL}"; then
       if [ -f "${tarballz}" ] && [ $(wc -c "${tarballz}" | awk '{print $1}') -lt 1024 ]; then
-        cat "${tarballz}" >/dev/null
+        cat "${tarballz}" > /dev/null
       else
         printError "Re-try curl for diagnostics"
         curlCmd -L -0 -o /dev/null "${ZOPEN_URL}"
@@ -896,24 +897,24 @@ applyPatches()
   fi
   printHeader "Applying patches"
   if [ "${ZOPEN_TYPE}x" = "TARBALLx" ]; then
-    tarballz=$(basename "$ZOPEN_URL")
+    tarballz=$(basename "${ZOPEN_URL}")
     root_loc=${tarballz%%.tar.*}
     root_loc=${root_loc%%.tgz}
     code_dir="${ZOPEN_ROOT}/${root_loc}"
   else
-    gitname=$(basename "$ZOPEN_URL")
+    gitname=$(basename "${ZOPEN_URL}")
     code_dir="${ZOPEN_ROOT}/${gitname%%.*}"
   fi
 
-  if [ ! -z "$ZOPEN_BUILD_LINE" ]; then
+  if [ ! -z "${ZOPEN_BUILD_LINE}" ]; then
     buildtype_lower=$(echo "${ZOPEN_BUILD_LINE}" | tr '[A-Z]' '[a-z]')
     patch_try_dir="${ZOPEN_ROOT}/${buildtype_lower}-patches"
-    if [ -d "$patch_try_dir" ]; then
-      patch_dir="$patch_try_dir"
+    if [ -d "${patch_try_dir}" ]; then
+      patch_dir="${patch_try_dir}"
     fi
   fi
 
-  if [ -z "$patch_dir" ]; then 
+  if [ -z "${patch_dir}" ]; then
     patch_dir="${ZOPEN_ROOT}/patches"
     if ! [ -d "${patch_dir}" ]; then
       printWarning "${patch_dir} does not exist - no patches to apply"
@@ -921,7 +922,7 @@ applyPatches()
     fi
   fi
 
-  printVerbose "Using patch directory $patch_dir"
+  printVerbose "Using patch directory ${patch_dir}"
 
   moved=false
   if [ -d "${code_dir}/.git-for-patches" ] && ! [ -d "${code_dir}/.git" ]; then
@@ -935,7 +936,7 @@ applyPatches()
   fi
 
   patches=$( (cd "${patch_dir}" && find . -name "*.patch" | sort))
-  if [ "${patches}x" = "x" ]; then
+  if [ -z "${patches}" ]; then
     printWarning "No patches in ${patch_dir} to apply"
     return 0
   fi
@@ -946,7 +947,7 @@ applyPatches()
     printInfo "To re-apply patches, perform a git reset on ${code_dir} prior to running applyPatches again."
     return 0
   else
-    for patch in $patches; do
+    for patch in ${patches}; do
       p="${patch_dir}/${patch}"
 
       patchsize=$(wc -c "${p}" | awk '{ print $1 }')
@@ -954,10 +955,10 @@ applyPatches()
         printWarning "Warning: patch file ${p} is empty - nothing to be done"
       else
         printInfo "Applying ${p}"
-        if $forcePatchApply; then
-          (cd "${code_dir}" && git apply --reject "${p}" 2>&1 )
+        if ${forcePatchApply}; then
+          (cd "${code_dir}" && git apply --reject "${p}" 2>&1)
         else
-          if ! out=$( (cd "${code_dir}" && git apply --check "${p}" 2>&1 && git apply "${p}" 2>&1 )); then
+          if ! out=$( (cd "${code_dir}" && git apply --check "${p}" 2>&1 && git apply "${p}" 2>&1)); then
             printSoftError "Patch of make tree failed (${p})."
             printSoftError "${out}"
             failedcount=$((failedcount + 1))
@@ -974,8 +975,8 @@ applyPatches()
     mv "${code_dir}/.git" "${code_dir}/.git-for-patches" || exit 99
   fi
 
-  if [ $failedcount -ne 0 ]; then
-    exit $failedcount
+  if [ "${failedcount}" -ne 0 ]; then
+    exit "${failedcount}"
   fi
   return 0
 }
@@ -986,7 +987,7 @@ getCode()
   cd "${ZOPEN_ROOT}" || exit 99
 
   if [ "${ZOPEN_TYPE}x" = "BAREx" ]; then
-      return 0
+    return 0
   fi
 
   checkGitVersion
@@ -1010,23 +1011,23 @@ getCode()
 create_fifo_pipe()
 {
   file="$1"
-  if [ -p $TMP_FIFO_PIPE ]; then
-    rm $TMP_FIFO_PIPE
+  if [ -p ${TMP_FIFO_PIPE} ]; then
+    rm ${TMP_FIFO_PIPE}
   fi
-  mkfifo $TMP_FIFO_PIPE
-  chtag -tc 819 $TMP_FIFO_PIPE
+  mkfifo ${TMP_FIFO_PIPE}
+  chtag -tc 819 ${TMP_FIFO_PIPE}
   touch ${file} && chtag -tc 819 ${file}
-  tee ${file} < $TMP_FIFO_PIPE &
+  tee ${file} < ${TMP_FIFO_PIPE} &
   TEE_PID=$!
 }
 
 cleanup()
 {
-  if [ -n "${ZOPEN_CLEAN_CMD}" ] && [ -f "${ZOPEN_LOG_DIR}/config.success" ] && ! $freshBuild; then
+  if [ -n "${ZOPEN_CLEAN_CMD}" ] && [ -f "${ZOPEN_LOG_DIR}/config.success" ] && ! ${freshBuild}; then
     printHeader "Running Cleanup"
     cleanlog="${ZOPEN_LOG_DIR}/${LOG_PFX}_clean.log"
     create_fifo_pipe "${cleanlog}"
-    if ! runAndLog "${ZOPEN_CLEAN_CMD} >$TMP_FIFO_PIPE 2>&1"; then
+    if ! runAndLog "${ZOPEN_CLEAN_CMD} >${TMP_FIFO_PIPE} 2>&1"; then
       printError "Cleanup failed. Log: ${cleanlog}" >&2
     fi
   fi
@@ -1036,15 +1037,15 @@ cleanup()
 
 bootstrap()
 {
-  bootstrapStartTime=$SECONDS
-  if [ -n "${ZOPEN_BOOTSTRAP_CMD}" ] ; then
+  bootstrapStartTime=${SECONDS}
+  if [ -n "${ZOPEN_BOOTSTRAP_CMD}" ]; then
     printHeader "Running Bootstrap"
     if [ -r "${ZOPEN_LOG_DIR}/bootstrap.success" ]; then
       echo "Using previous successful bootstrap. Specify -f to force a bootstrap." >&2
     else
       bootlog="${ZOPEN_LOG_DIR}/${LOG_PFX}_bootstrap.log"
       create_fifo_pipe "${bootlog}"
-      if ! runAndLog "${ZOPEN_BOOTSTRAP_CMD} >$TMP_FIFO_PIPE 2>&1"; then
+      if ! runAndLog "${ZOPEN_BOOTSTRAP_CMD} >${TMP_FIFO_PIPE} 2>&1"; then
         printError "Bootstrap failed. Log: ${bootlog}" >&2
       fi
       touch ${ZOPEN_LOG_DIR}/bootstrap.success
@@ -1052,21 +1053,21 @@ bootstrap()
   else
     printHeader "Skip Bootstrap"
   fi
-  printElapsedTime verbose "bootstrap" $bootstrapStartTime
+  printElapsedTime verbose "bootstrap" "${bootstrapStartTime}"
 
 }
 
 configure()
 {
-  configureStartTime=$SECONDS
-  if [ -n "${ZOPEN_CONFIGURE_CMD}" ] ; then
+  configureStartTime=${SECONDS}
+  if [ -n "${ZOPEN_CONFIGURE_CMD}" ]; then
     printHeader "Running Configure"
     if [ -r "${ZOPEN_LOG_DIR}/config.success" ]; then
       echo "Using previous successful configuration. Specify -f to force a configure." >&2
     else
       configlog="${ZOPEN_LOG_DIR}/${LOG_PFX}_config.log"
       create_fifo_pipe "${configlog}"
-      if ! runAndLog "${ZOPEN_CONFIGURE_CMD} >$TMP_FIFO_PIPE 2>&1"; then
+      if ! runAndLog "${ZOPEN_CONFIGURE_CMD} >${TMP_FIFO_PIPE} 2>&1"; then
         if [ "${ZOPEN_CONFIGURE_MINIMAL}" = "yes" ]; then
           printError "Configure (minimal) failed. Log: ${configlog}"
         else
@@ -1078,16 +1079,16 @@ configure()
   else
     printHeader "Skip Configure"
   fi
-  printElapsedTime verbose "configure" $configureStartTime
+  printElapsedTime verbose "configure" "${configureStartTime}"
 }
 
 build()
 {
-  buildStartTime=$SECONDS
-  if command -V "${ZOPEN_PRE_BUILD_CODE}" >/dev/null 2>&1; then
+  buildStartTime=${SECONDS}
+  if command -V "${ZOPEN_PRE_BUILD_CODE}" > /dev/null 2>&1; then
     printVerbose "Running ${ZOPEN_PRE_BUILD_CODE}"
-    if ! "${ZOPEN_PRE_BUILD_CODE}" ; then
-        printError "Pre build failed."
+    if ! "${ZOPEN_PRE_BUILD_CODE}"; then
+      printError "Pre build failed."
     fi
   fi
 
@@ -1095,7 +1096,7 @@ build()
   if [ -n "${ZOPEN_MAKE_CMD}" ]; then
     printHeader "Running Build"
     create_fifo_pipe "${makelog}"
-    if ! runAndLog "${ZOPEN_MAKE_CMD} > $TMP_FIFO_PIPE 2>&1"; then
+    if ! runAndLog "${ZOPEN_MAKE_CMD} > ${TMP_FIFO_PIPE} 2>&1"; then
       if [ "${ZOPEN_MAKE_MINIMAL}" = "yes" ]; then
         printError "Make (minimal) failed. Log: ${makelog}"
       else
@@ -1105,98 +1106,98 @@ build()
   else
     printHeader "Skipping Build"
   fi
-  printElapsedTime verbose "build" $buildStartTime
+  printElapsedTime verbose "build" "${buildStartTime}"
 }
 
 check()
 {
-  checkStartTime=$SECONDS
-  if command -V "${ZOPEN_PRE_CHECK_CODE}" >/dev/null 2>&1; then
+  checkStartTime=${SECONDS}
+  if command -V "${ZOPEN_PRE_CHECK_CODE}" > /dev/null 2>&1; then
     printVerbose "Running ${ZOPEN_PRE_CHECK_CODE}"
     "${ZOPEN_PRE_CHECK_CODE}" "${ZOPEN_INSTALL_DIR}"
   fi
   checklog="${ZOPEN_LOG_DIR}/${LOG_PFX}_check.log"
-  results=$ZOPEN_TEST_STATUS_SKIPPED # skipped
+  results=${ZOPEN_TEST_STATUS_SKIPPED} # skipped
   if [ -n "${ZOPEN_CHECK_CMD}" ]; then
     printHeader "Running Check"
     create_fifo_pipe "${checklog}"
-    runInBackgroundWithTimeoutAndLog "${ZOPEN_CHECK_CMD} > $TMP_FIFO_PIPE 2>&1" "${ZOPEN_CHECK_TIMEOUT}"
-    if command -V "${ZOPEN_CHECK_RESULTS_CODE}" >/dev/null 2>&1; then
+    runInBackgroundWithTimeoutAndLog "${ZOPEN_CHECK_CMD} > ${TMP_FIFO_PIPE} 2>&1" "${ZOPEN_CHECK_TIMEOUT}"
+    if command -V "${ZOPEN_CHECK_RESULTS_CODE}" > /dev/null 2>&1; then
       testStatus="$(${ZOPEN_CHECK_RESULTS_CODE} "${ZOPEN_LOG_DIR}" "${LOG_PFX}")"
-      printVerbose "Test status:\n$testStatus"
+      printVerbose "Test status:\n${testStatus}"
       testStatusError=false
       checkTotalTests=false
-      if echo "$testStatus" | grep -q -E "actualFailures:[ ]*[0-9]+"; then
-        failures=$(echo "$testStatus" | grep "actualFailures:" | sed -e "s/.*actualFailures://" | tr -d ' ')
+      if echo "${testStatus}" | grep -q -E "actualFailures:[ ]*[0-9]+"; then
+        failures=$(echo "${testStatus}" | grep "actualFailures:" | sed -e "s/.*actualFailures://" | tr -d ' ')
       else
         printSoftError "${ZOPEN_CHECK_RESULTS_CODE} needs to emit an actualFailures:<number> line"
         testStatusError=true
       fi
-      if echo "$testStatus" | grep -q -E "expectedFailures:[ ]*[0-9]+"; then
-        expectedFailures=$(echo "$testStatus" | grep "expectedFailures:" | sed -e "s/.*expectedFailures://" | tr -d ' ')
+      if echo "${testStatus}" | grep -q -E "expectedFailures:[ ]*[0-9]+"; then
+        expectedFailures=$(echo "${testStatus}" | grep "expectedFailures:" | sed -e "s/.*expectedFailures://" | tr -d ' ')
       else
         printSoftError "${ZOPEN_CHECK_RESULTS_CODE} needs to emit an expectedFailures:<number> line"
-      	testStatusError=true
+        testStatusError=true
       fi
-      if echo "$testStatus" | grep -q -E "totalTests:[ ]*[0-9]+"; then
-        totalTests=$(echo "$testStatus" | grep "totalTests:" | sed -e "s/.*totalTests://" | tr -d ' ')
-        if [ $totalTests -eq 0 ]; then
+      if echo "${testStatus}" | grep -q -E "totalTests:[ ]*[0-9]+"; then
+        totalTests=$(echo "${testStatus}" | grep "totalTests:" | sed -e "s/.*totalTests://" | tr -d ' ')
+        if [ ${totalTests} -eq 0 ]; then
           printSoftError "Total tests is 0"
           testStatusError=true
         fi
       else
         printSoftError "${ZOPEN_CHECK_RESULTS_CODE} needs to emit an totalTests:<number> line"
-      	testStatusError=true
+        testStatusError=true
       fi
-      if echo "$testStatus" | grep -q -E "expectedTotalTests:[ ]*[0-9]+"; then
-        expectedTotalTests=$(echo "$testStatus" | grep "expectedTotalTests:" | sed -e "s/.*expectedTotalTests://" | tr -d ' ')
+      if echo "${testStatus}" | grep -q -E "expectedTotalTests:[ ]*[0-9]+"; then
+        expectedTotalTests=$(echo "${testStatus}" | grep "expectedTotalTests:" | sed -e "s/.*expectedTotalTests://" | tr -d ' ')
         checkTotalTests=true
       fi
       if ${testStatusError}; then
-        printError "Test Status:\n$testStatus"
+        printError "Test Status:\n${testStatus}"
       fi
-      success="$((totalTests-failures))"
-      percent="$(echo "$success" "$totalTests" | awk '{printf "%.0f", $1 * 100 / $2}')"
-      percenthundreth="$(echo "$success" "$totalTests" | awk '{printf "%.2f", $1 * 100 / $2}')"
-      summary="$success tests pass out of $totalTests tests - ${percenthundreth}% success rate"
-      printVerbose "Test results: $summary"
-      if ! [ $percent -eq $percent ]; then # not a number
-        results=$ZOPEN_TEST_STATUS_ERROR
+      success="$((totalTests - failures))"
+      percent="$(echo "${success}" "${totalTests}" | awk '{printf "%.0f", $1 * 100 / $2}')"
+      percenthundreth="$(echo "${success}" "${totalTests}" | awk '{printf "%.2f", $1 * 100 / $2}')"
+      summary="${success} tests pass out of ${totalTests} tests - ${percenthundreth}% success rate"
+      printVerbose "Test results: ${summary}"
+      if ! [ ${percent} -eq ${percent} ]; then # not a number
+        results=${ZOPEN_TEST_STATUS_ERROR}
         ZOPEN_STATUS="Error (could not run tests)" # bad return code from check results
       else
-        if [ $percent -eq 100 ]; then
-          results=$ZOPEN_TEST_STATUS_ALL_PASSED
-          ZOPEN_STATUS="Green ($summary)" # All tests passed
-        elif [ $percent -ge 50 ]; then
-          results=$ZOPEN_TEST_STATUS_MOST_PASSED
-          ZOPEN_STATUS="Blue ($summary)" # Most tests passed
-        elif [ $percent -eq 0 ]; then
-          results=$ZOPEN_TEST_STATUS_NONE_PASSED
-          ZOPEN_STATUS="Red ($summary)" # Pretty much non-functional
-        elif [ $percent -lt 50 ]; then
-          results=$ZOPEN_TEST_STATUS_SOME_PASSED
-          ZOPEN_STATUS="Yellow ($summary)" # Most tests failed
+        if [ ${percent} -eq 100 ]; then
+          results=${ZOPEN_TEST_STATUS_ALL_PASSED}
+          ZOPEN_STATUS="Green (${summary})" # All tests passed
+        elif [ ${percent} -ge 50 ]; then
+          results=${ZOPEN_TEST_STATUS_MOST_PASSED}
+          ZOPEN_STATUS="Blue (${summary})" # Most tests passed
+        elif [ ${percent} -eq 0 ]; then
+          results=${ZOPEN_TEST_STATUS_NONE_PASSED}
+          ZOPEN_STATUS="Red (${summary})" # Pretty much non-functional
+        elif [ ${percent} -lt 50 ]; then
+          results=${ZOPEN_TEST_STATUS_SOME_PASSED}
+          ZOPEN_STATUS="Yellow (${summary})" # Most tests failed
         fi
       fi
       if ${checkTotalTests}; then
-        if [ $totalTests -lt $expectedTotalTests ]; then
-          printElapsedTime verbose "check" $checkStartTime
-          printError "Executed tests ($totalTests) is less than expected ($expectedTotalTests). Failing...";
+        if [ ${totalTests} -lt ${expectedTotalTests} ]; then
+          printElapsedTime verbose "check" "${checkStartTime}"
+          printError "Executed tests (${totalTests}) is less than expected (${expectedTotalTests}). Failing..."
         fi
       fi
-      if [ $failures -le $expectedFailures ]; then
-        printElapsedTime verbose "check" $checkStartTime
+      if [ ${failures} -le ${expectedFailures} ]; then
+        printElapsedTime verbose "check" "${checkStartTime}"
         return 0
       else
-        printElapsedTime verbose "check" $checkStartTime
-        printError "Failures ($failures) not less than than expected ($expectedFailures). Failing...";
+        printElapsedTime verbose "check" "${checkStartTime}"
+        printError "Failures (${failures}) not less than than expected (${expectedFailures}). Failing..."
       fi
     fi
   else
     printHeader "Skipping Check"
     ZOPEN_STATUS="Skipped (tests skipped)" # Skipped tests
   fi
-  printElapsedTime verbose "check" $checkStartTime
+  printElapsedTime verbose "check" "${checkStartTime}"
 }
 
 replaceHardcodedPath()
@@ -1205,20 +1206,20 @@ replaceHardcodedPath()
   replaced=$2
   f=$3
   hasHardcodedPaths=true
-  printVerbose "Replacing $orig in $f"
+  printVerbose "Replacing ${orig} in ${f}"
   # only substitute text
-  if /bin/sed -e "" $f 2>/dev/null 1>&2; then
+  if /bin/sed -e "" ${f} 2> /dev/null 1>&2; then
     isWritable=true
-    if [ ! -w "$f" ]; then
+    if [ ! -w "${f}" ]; then
       isWriteable=false
-      chmod "+w" $f
+      chmod "+w" ${f}
     fi
-    cp $f $f.old && \
-    # replace hardcoded path and strip out the -suffix in name to match active
-    sed -e "s#${orig}/\([^/]\+\)/[^/\n '\";]*#${replaced}/\1/\1#g" $f.old > $f &&
-    rm $f.old
-    if ! $isWriteable; then
-      chmod "-w" $f
+    cp ${f} ${f}.old &&
+      # replace hardcoded path and strip out the -suffix in name to match active
+      sed -e "s#${orig}/\([^/]\+\)/[^/\n '\";]*#${replaced}/\1/\1#g" ${f}.old > ${f} &&
+      rm ${f}.old
+    if ! ${isWriteable}; then
+      chmod "-w" ${f}
     fi
   fi
 }
@@ -1226,21 +1227,21 @@ replaceHardcodedPath()
 replaceHardcodedPaths()
 {
   ZOPEN_INSTALL_PREFIX="${ZOPEN_INSTALL_DIR}/../../"
-  ZOPEN_INSTALL_PREFIX=$(cd "${ZOPEN_INSTALL_PREFIX}" >/dev/null 2>&1 && pwd -P)
+  ZOPEN_INSTALL_PREFIX=$(cd "${ZOPEN_INSTALL_PREFIX}" > /dev/null 2>&1 && pwd -P)
 
   printHeader "Replacing hardcoded ${ZOPEN_INSTALL_PREFIX} path"
   hasHardcodedPaths=false
-  for f in $(find ${ZOPEN_INSTALL_DIR}/ -type f | xargs grep -l "${ZOPEN_INSTALL_PREFIX}" 2>/dev/null); do
+  for f in $(find ${ZOPEN_INSTALL_DIR}/ -type f | xargs grep -l "${ZOPEN_INSTALL_PREFIX}" 2> /dev/null); do
     hasHardcodedPaths=true
-    replaceHardcodedPath "${ZOPEN_INSTALL_PREFIX}" "ZOPEN_INSTALL_PREFIX" "$f"
+    replaceHardcodedPath "${ZOPEN_INSTALL_PREFIX}" "ZOPEN_INSTALL_PREFIX" "${f}"
   done
 }
 
 createEnvAndSetup()
 {
   printHeader "Creating ${ZOPEN_INSTALL_DIR}/.env"
-  projectName=$(echo $ZOPEN_NAME | cut -d "-" -f 1 | awk '{print toupper($0)}')
-  cat <<zz >"${ZOPEN_INSTALL_DIR}/.env"
+  projectName=$(echo ${ZOPEN_NAME} | cut -d "-" -f 1 | awk '{print toupper($0)}')
+  cat << zz > "${ZOPEN_INSTALL_DIR}/.env"
 if ! [ -f ./.env ]; then
   echo "Need to source from the .env directory" >&2
   return 0
@@ -1282,34 +1283,33 @@ zz
     echo "MANPATH=\"\${${projectName}_HOME}/share/man:\$MANPATH\"" >> "${ZOPEN_INSTALL_DIR}/.env"
     echo "export MANPATH=\"\$(deleteDuplicateEntries \"\$MANPATH\" \":\")\"" >> "${ZOPEN_INSTALL_DIR}/.env"
   fi
-  if command -V "${ZOPEN_APPEND_TO_ENV_CODE}" >/dev/null 2>&1; then
+  if command -V "${ZOPEN_APPEND_TO_ENV_CODE}" > /dev/null 2>&1; then
     printVerbose "Appending additional environment variables..."
     append_to_env="$(${ZOPEN_APPEND_TO_ENV_CODE})"
   else
     append_to_env="# nothing to do"
   fi
 
-  echo "$append_to_env" > "${ZOPEN_INSTALL_DIR}/.appenv"
+  echo "${append_to_env}" > "${ZOPEN_INSTALL_DIR}/.appenv"
   echo ". ./.appenv" >> "${ZOPEN_INSTALL_DIR}/.env"
 
-  cat <<zz >>"${ZOPEN_INSTALL_DIR}/.env"
+  cat << zz >> "${ZOPEN_INSTALL_DIR}/.env"
 if \$dropTagRedirEnvar; then
   unset _TAG_REDIR_OUT
 fi
 zz
 
-
   # Create setup.sh script
   projectName_lower=$(echo "${projectName}" | tr '[A-Z]' '[a-z]')
-  cat <<zz >"${ZOPEN_INSTALL_DIR}/setup.sh"
+  cat << zz > "${ZOPEN_INSTALL_DIR}/setup.sh"
 #!/bin/sh
 touch \".installing\"
 . ./.env
 echo \"Setting up ${projectName_lower}...\"
 zz
 
-  if $hasHardcodedPaths; then
-    cat <<zz >>"${ZOPEN_INSTALL_DIR}/setup.sh"
+  if ${hasHardcodedPaths}; then
+    cat << zz >> "${ZOPEN_INSTALL_DIR}/setup.sh"
 if [ -f .replacedpath ]; then
   REPLACE_PREFIX_PATH="\$(cat .replacedpath | head -1)"
 else
@@ -1344,30 +1344,30 @@ echo "\${ZOPEN_INSTALL_PREFIX}" > .replacedpath
 zz
   fi
 
-  if command -V "${ZOPEN_APPEND_TO_SETUP_CODE}" >/dev/null 2>&1; then
+  if command -V "${ZOPEN_APPEND_TO_SETUP_CODE}" > /dev/null 2>&1; then
     printVerbose "Appending additional setup code..."
     append_to_setup="$(${ZOPEN_APPEND_TO_SETUP_CODE})"
-    echo "$append_to_setup" >> "${ZOPEN_INSTALL_DIR}/setup.sh"
+    echo "${append_to_setup}" >> "${ZOPEN_INSTALL_DIR}/setup.sh"
   fi
 
-  cat <<zz >>"${ZOPEN_INSTALL_DIR}/setup.sh"
+  cat << zz >> "${ZOPEN_INSTALL_DIR}/setup.sh"
 echo \"Setup completed.\"
 touch \".installed\"
 rm \".installing\"
 zz
 
-  echo "#!/bin/sh" > "${ZOPEN_INSTALL_DIR}/install_test.sh" 
-  if command -V "${ZOPEN_APPEND_TO_VALIDATE_CODE}" >/dev/null 2>&1; then
+  echo "#!/bin/sh" > "${ZOPEN_INSTALL_DIR}/install_test.sh"
+  if command -V "${ZOPEN_APPEND_TO_VALIDATE_CODE}" > /dev/null 2>&1; then
     printVerbose "Appending additional validate code..."
     append_to_validate="$(${ZOPEN_APPEND_TO_VALIDATE_CODE})"
-    echo "$append_to_validate" >> "${ZOPEN_INSTALL_DIR}/install_test.sh"
+    echo "${append_to_validate}" >> "${ZOPEN_INSTALL_DIR}/install_test.sh"
   fi
-  cat <<zz >>"${ZOPEN_INSTALL_DIR}/install_test.sh"
+  cat << zz >> "${ZOPEN_INSTALL_DIR}/install_test.sh"
 exit 0;
 zz
 
-if [ ! -z "$ZOPEN_RUNTIME_DEPS" ]; then
-cat <<ZZ >> "${ZOPEN_INSTALL_DIR}/.env"
+  if [ ! -z "${ZOPEN_RUNTIME_DEPS}" ]; then
+    cat << ZZ >> "${ZOPEN_INSTALL_DIR}/.env"
 if [ -f ".depsenv" ] && [ -z "\$ZOPEN_SOURCING_DEPS" ] ; then
   ZOPEN_SOURCING_DEPS=1
   . ./.depsenv
@@ -1376,17 +1376,17 @@ if [ ! -z "\$ZOPEN_SOURCING_DEPS" ]; then
   unset ZOPEN_SOURCING_DEPS
 fi
 ZZ
-  printHeader "Install dependencies: $ZOPEN_RUNTIME_DEPS"
-  varName=$(echo "$projectName" | sed -e "s/-/_/g")
-    cat <<ZZ >> "${ZOPEN_INSTALL_DIR}/.depsenv"
+    printHeader "Install dependencies: ${ZOPEN_RUNTIME_DEPS}"
+    varName=$(echo "${projectName}" | sed -e "s/-/_/g")
+    cat << ZZ >> "${ZOPEN_INSTALL_DIR}/.depsenv"
 ${varName}_originalDir="\$OLDPWD"
 ZZ
-  echo "$ZOPEN_RUNTIME_DEPS" | xargs | tr ' ' '\n' | sort | while read dep; do
-    # Use the first path specified in the dependency search list to install to
-    if ! runAndLog "PATH=\"$curlpath:$PATH\" $MYDIR/zopen-install --install-or-upgrade $dep -v --no-deps -y"; then
-      printError "Failed to install dependencies"
-    fi
-    cat <<ZZ >> "${ZOPEN_INSTALL_DIR}/.depsenv"
+    echo "${ZOPEN_RUNTIME_DEPS}" | xargs | tr ' ' '\n' | sort | while read dep; do
+      # Use the first path specified in the dependency search list to install to
+      if ! runAndLog "PATH=\"${curlpath}:${PATH}\" ${MYDIR}/zopen-install --install-or-upgrade ${dep} -v --no-deps -y"; then
+        printError "Failed to install dependencies"
+      fi
+      cat << ZZ >> "${ZOPEN_INSTALL_DIR}/.depsenv"
 if [ -f "../../${dep}/${dep}/.env" ]; then
   if [[ \$(type echo) == 'echo is a shell builtin' ]]; then
     pushd "../../${dep}/${dep}" >/dev/null
@@ -1397,14 +1397,14 @@ if [ -f "../../${dep}/${dep}/.env" ]; then
   fi
 fi
 ZZ
-   done
-   cat <<ZZ >> "${ZOPEN_INSTALL_DIR}/.depsenv"
+    done
+    cat << ZZ >> "${ZOPEN_INSTALL_DIR}/.depsenv"
 OLDPWD="\$${varName}_originalDir"
 ZZ
-fi
+  fi
 
-# Add call to setup.sh
-cat <<zz >>"${ZOPEN_INSTALL_DIR}/.env"
+  # Add call to setup.sh
+  cat << zz >> "${ZOPEN_INSTALL_DIR}/.env"
 # Run setup.sh if it hasn't been run yet
 if [ ! -f \".installed\" ] && [ ! -f \".installing\" ] && [ -x \"setup.sh\" ]; then
   ./setup.sh
@@ -1427,26 +1427,26 @@ createReadme()
 generatePropertiesJSON()
 {
   printHeader "Creating Properties JSON"
-  package=$ZOPEN_NAME
-  name=$(echo $package | cut -d "-" -f 1)
-  version=$(echo $package | cut -d "-" -f 2)
+  package=${ZOPEN_NAME}
+  name=$(echo ${package} | cut -d "-" -f 1)
+  version=$(echo ${package} | cut -d "-" -f 2)
 
   # Make the version OCI compat
-  case "$version" in
-      *.*.*.*) ;;
-      *.*.*)  version="$version.0";;
-      *.*)  version="$version.0.0";;
-      *) version="1.0.0.0";;
+  case "${version}" in
+  *.*.*.*) ;;
+  *.*.*) version="${version}.0" ;;
+  *.*) version="${version}.0.0" ;;
+  *) version="1.0.0.0" ;;
   esac
 
-cat <<zz > "${ZOPEN_INSTALL_DIR}/properties.json"  
+  cat << zz > "${ZOPEN_INSTALL_DIR}/properties.json"
 {
 "product": {
   "pax": "${ZOPEN_NAME}.${LOG_PFX}.zos.pax.Z",
-  "name": "$name",
-  "version": "$version",
-  "release": "$LOG_PFX",
-  "summary": "$name on z/OS",
+  "name": "${name}",
+  "version": "${version}",
+  "release": "${LOG_PFX}",
+  "summary": "${name} on z/OS",
   "description": "TODO"
 }}
 zz
@@ -1455,13 +1455,13 @@ zz
 
 install()
 {
-  installStartTime=$SECONDS
+  installStartTime=${SECONDS}
   if [ -n "${ZOPEN_INSTALL_CMD}" ]; then
     if [ -d "${ZOPEN_INSTALL_DIR}" ]; then
       printVerbose "${ZOPEN_INSTALL_DIR} already exists, deleting..."
       rm -rf "${ZOPEN_INSTALL_DIR}"
     fi
-    if command -V "${ZOPEN_PRE_INSTALL_CODE}" >/dev/null 2>&1; then
+    if command -V "${ZOPEN_PRE_INSTALL_CODE}" > /dev/null 2>&1; then
       printVerbose "Running ${ZOPEN_PRE_INSTALL_CODE}"
       "${ZOPEN_PRE_INSTALL_CODE}" "${ZOPEN_INSTALL_DIR}"
     fi
@@ -1469,15 +1469,15 @@ install()
     printHeader "Running Install"
     installlog="${ZOPEN_LOG_DIR}/${LOG_PFX}_install.log"
     create_fifo_pipe "${installlog}"
-    if ! runAndLog "${ZOPEN_INSTALL_CMD} > $TMP_FIFO_PIPE 2>&1"; then
+    if ! runAndLog "${ZOPEN_INSTALL_CMD} > ${TMP_FIFO_PIPE} 2>&1"; then
       printError "Install failed. Log: ${installlog}"
     fi
     replaceHardcodedPaths
     createEnvAndSetup
 
-    if command -V "${ZOPEN_POST_INSTALL_CODE}" >/dev/null 2>&1; then
+    if command -V "${ZOPEN_POST_INSTALL_CODE}" > /dev/null 2>&1; then
       printVerbose "Running ${ZOPEN_POST_INSTALL_CODE}"
-      if ! "${ZOPEN_POST_INSTALL_CODE}" "${ZOPEN_INSTALL_DIR}" ; then
+      if ! "${ZOPEN_POST_INSTALL_CODE}" "${ZOPEN_INSTALL_DIR}"; then
         printError "Post install failed.${installlog}"
       fi
     fi
@@ -1485,10 +1485,9 @@ install()
     createReadme
 
     # Store test.status into installed dir and build dir for cicd
-    asciiecho "$ZOPEN_STATUS" "${ZOPEN_ROOT}/install/test.status"
+    asciiecho "${ZOPEN_STATUS}" "${ZOPEN_ROOT}/install/test.status"
     cp "${ZOPEN_ROOT}/install/test.status" "${ZOPEN_INSTALL_DIR}/test.status"
 
-
     if [ ! -z "${ZOPEN_BUILD_LINE}" ]; then
       asciiecho "${ZOPEN_BUILD_LINE}" "${ZOPEN_INSTALL_DIR}/.buildline"
     fi
@@ -1497,7 +1496,7 @@ install()
       printWarning "A zopen_get_version() function should be defined in the buildenv to extract the version contents"
     else
       versionString=$(zopen_get_version)
-      echo $versionString | awk -F. '{
+      echo ${versionString} | awk -F. '{
         if (NF < 1 || NF > 4) {
           exit 1
         }
@@ -1517,36 +1516,36 @@ install()
       }'
 
       if [ $? -ne 0 ]; then
-        printError "$versionString uses an invalid version format"
+        printError "${versionString} uses an invalid version format"
       fi
-      asciiecho "$versionString" "${ZOPEN_INSTALL_DIR}/.version"
+      asciiecho "${versionString}" "${ZOPEN_INSTALL_DIR}/.version"
       cp "${ZOPEN_INSTALL_DIR}/.version" "${ZOPEN_ROOT}/install/"
     fi
 
-    if [ ! -z "$ZOPEN_RUNTIME_DEPS" ]; then
-      asciiecho "$(echo "$ZOPEN_RUNTIME_DEPS" | xargs | tr ' ' '\n' | sort -u | xargs)" "${ZOPEN_INSTALL_DIR}/.runtimedeps"
+    if [ ! -z "${ZOPEN_RUNTIME_DEPS}" ]; then
+      asciiecho "$(echo "${ZOPEN_RUNTIME_DEPS}" | xargs | tr ' ' '\n' | sort -u | xargs)" "${ZOPEN_INSTALL_DIR}/.runtimedeps"
       cp "${ZOPEN_INSTALL_DIR}/.runtimedeps" "${ZOPEN_ROOT}/install/"
     fi
 
-    buildDeps="$ZOPEN_DEPS"
-    asciiecho "$(echo "$buildDeps" | xargs | tr ' ' '\n' | sort -u | xargs)" "${ZOPEN_INSTALL_DIR}/.builddeps"
+    buildDeps="${ZOPEN_DEPS}"
+    asciiecho "$(echo "${buildDeps}" | xargs | tr ' ' '\n' | sort -u | xargs)" "${ZOPEN_INSTALL_DIR}/.builddeps"
     cp "${ZOPEN_INSTALL_DIR}/.builddeps" "${ZOPEN_ROOT}/install/"
 
-    asciiecho "$LOG_PFX" "${ZOPEN_INSTALL_DIR}/.buildtimestamp"
+    asciiecho "${LOG_PFX}" "${ZOPEN_INSTALL_DIR}/.buildtimestamp"
 
     generatePropertiesJSON
 
-    if $generatePax; then
+    if ${generatePax}; then
       printHeader "Generating pax.Z from ${ZOPEN_INSTALL_DIR}"
       if ! runAndLog "${ZOPEN_PAX_CMD}"; then
         printError "Could not generate pax \"${paxFileName}\""
       fi
     fi
-    if $setActive; then
+    if ${setActive}; then
       PROJECT_NAME="$(echo ${ZOPEN_NAME} | cut -d'-' -f1)"
-      mergeIntoSystem "$PROJECT_NAME" "${ZOPEN_INSTALL_DIR}" "$ZOPEN_ROOTFS" 
-      mkdir -p "$ZOPEN_ROOTFS/etc/profiled/$name"
-      cat << EOF > "$ZOPEN_ROOTFS/etc/profiled/$name/dotenv"
+      mergeIntoSystem "${PROJECT_NAME}" "${ZOPEN_INSTALL_DIR}" "${ZOPEN_ROOTFS}"
+      mkdir -p "${ZOPEN_ROOTFS}/etc/profiled/${name}"
+      cat << EOF > "${ZOPEN_ROOTFS}/etc/profiled/${name}/dotenv"
 curdir=\$(pwd)
 cd "${ZOPEN_INSTALL_DIR}" >/dev/null 2>&1
 if [ -f ".appenv" ]; then
@@ -1559,11 +1558,11 @@ EOF
       printVerbose "Marking this version as installed"
       touch "${ZOPEN_INSTALL_DIR}/.active"
     fi
-    generateOCI $ZOPEN_NAME
+    generateOCI ${ZOPEN_NAME}
   else
     printHeader "Skipping Install"
   fi
-  printElapsedTime verbose "install" $installStartTime
+  printElapsedTime verbose "install" "${installStartTime}"
 }
 
 #
@@ -1580,19 +1579,19 @@ resolveCommands()
     fi
   fi
   # Check if ZOPEN_NAME contains a "-"
-  if [ -z "$(echo "$ZOPEN_NAME" | grep '-')" ]; then
+  if [ -z "$(echo "${ZOPEN_NAME}" | grep '-')" ]; then
     # If not, add the '-DEV' suffix so as not to collide with zopen installed packages
     ZOPEN_NAME="${ZOPEN_NAME}-DEV"
   fi
-  if [ "${ZOPEN_INSTALL_DIR}x" = "x" ]; then
+  if [ -z "${ZOPEN_INSTALL_DIR}" ]; then
     PROJECT_NAME="$(echo ${ZOPEN_NAME} | cut -d'-' -f1)"
-    export ZOPEN_INSTALL_DIR="$ZOPEN_PKGINSTALL/${PROJECT_NAME}/${ZOPEN_NAME}" # Install into dev location
+    export ZOPEN_INSTALL_DIR="${ZOPEN_PKGINSTALL}/${PROJECT_NAME}/${ZOPEN_NAME}" # Install into dev location
   fi
-  if [ "${ZOPEN_LOG_DIR}x" = "x" ]; then
+  if [ -z "${ZOPEN_LOG_DIR}" ]; then
     export ZOPEN_LOG_DIR="${ZOPEN_ROOT}/log"
     if [ ! -z "${ZOPEN_BUILD_LINE}" ]; then
       ZOPEN_LOG_DIR="${ZOPEN_LOG_DIR}.${ZOPEN_BUILD_LINE}"
-    fi 
+    fi
   fi
 
   [[ -d ${ZOPEN_LOG_DIR} ]] || mkdir -p ${ZOPEN_LOG_DIR}
@@ -1603,25 +1602,25 @@ resolveCommands()
     unset ZOPEN_BOOTSTRAP_CMD
   fi
 
-  if [ "${ZOPEN_CONFIGURE_OPTS}x" = "x" ]; then
-      case "${ZOPEN_CONFIGURE}" in
-        (*cmake*)
-          export ZOPEN_CONFIGURE_OPTS="--install-prefix ${ZOPEN_INSTALL_DIR} ${ZOPEN_EXTRA_CONFIGURE_OPTS}"
-          ;;
-        (*)
-          export ZOPEN_CONFIGURE_OPTS="--prefix=${ZOPEN_INSTALL_DIR} ${ZOPEN_EXTRA_CONFIGURE_OPTS}"
-          ;;
-      esac
+  if [ -z "${ZOPEN_CONFIGURE_OPTS}" ]; then
+    case "${ZOPEN_CONFIGURE}" in
+    *cmake*)
+      export ZOPEN_CONFIGURE_OPTS="--install-prefix ${ZOPEN_INSTALL_DIR} ${ZOPEN_EXTRA_CONFIGURE_OPTS}"
+      ;;
+    *)
+      export ZOPEN_CONFIGURE_OPTS="--prefix=${ZOPEN_INSTALL_DIR} ${ZOPEN_EXTRA_CONFIGURE_OPTS}"
+      ;;
+    esac
   fi
   if [ "${ZOPEN_CONFIGURE}x" != "skipx" ]; then
-    if [ "${ZOPEN_CONFIGURE_MINIMAL}x" = "x" ]; then
+    if [ -z "${ZOPEN_CONFIGURE_MINIMAL}" ]; then
       case "${ZOPEN_CONFIGURE}" in
-        (*cmake*)
-          export ZOPEN_CONFIGURE_CMD="\"${ZOPEN_CONFIGURE}\" ${ZOPEN_CONFIGURE_OPTS} -DCMAKE_C_COMPILER=${CC} -DCMAKE_C_FLAGS=\"${CPPFLAGS} ${CFLAGS}\" -DCMAKE_CXX_COMPILER=${CXX} -DCMAKE_CXX_FLAGS=\"${CPPFLAGS} ${CXXFLAGS}\" -DCMAKE_CXX_LINK_LIBRARY_FLAG=\"${LDFLAGS}\" -DCMAKE_C_LINK_LIBRARY_FLAG=\"${LDFLAGS}\" -DCMAKE_CXX_STANDARD_LIBRARIES=\"${LIBS}\" -DCMAKE_C_STANDARD_LIBRARIES=\"${LIBS}\""
-          ;;
-        (*)
-          export ZOPEN_CONFIGURE_CMD="\"${ZOPEN_CONFIGURE}\" ${ZOPEN_CONFIGURE_OPTS} CC=${CC} CPPFLAGS=\"${CPPFLAGS}\" CFLAGS=\"${CFLAGS}\" CXX=${CXX} CXXFLAGS=\"${CXXFLAGS}\" LDFLAGS=\"${LDFLAGS}\" LIBS=\"${LIBS}\" LDLIBS=\"${LIBS}\""
-          ;;
+      *cmake*)
+        export ZOPEN_CONFIGURE_CMD="\"${ZOPEN_CONFIGURE}\" ${ZOPEN_CONFIGURE_OPTS} -DCMAKE_C_COMPILER=${CC} -DCMAKE_C_FLAGS=\"${CPPFLAGS} ${CFLAGS}\" -DCMAKE_CXX_COMPILER=${CXX} -DCMAKE_CXX_FLAGS=\"${CPPFLAGS} ${CXXFLAGS}\" -DCMAKE_CXX_LINK_LIBRARY_FLAG=\"${LDFLAGS}\" -DCMAKE_C_LINK_LIBRARY_FLAG=\"${LDFLAGS}\" -DCMAKE_CXX_STANDARD_LIBRARIES=\"${LIBS}\" -DCMAKE_C_STANDARD_LIBRARIES=\"${LIBS}\""
+        ;;
+      *)
+        export ZOPEN_CONFIGURE_CMD="\"${ZOPEN_CONFIGURE}\" ${ZOPEN_CONFIGURE_OPTS} CC=${CC} CPPFLAGS=\"${CPPFLAGS}\" CFLAGS=\"${CFLAGS}\" CXX=${CXX} CXXFLAGS=\"${CXXFLAGS}\" LDFLAGS=\"${LDFLAGS}\" LIBS=\"${LIBS}\" LDLIBS=\"${LIBS}\""
+        ;;
       esac
       export ZOPEN_CONFIGURE_MINIMAL="no"
     else
@@ -1634,13 +1633,13 @@ resolveCommands()
   fi
 
   verboseOpts=""
-  if [ "$VERBOSE" -eq 1 ]; then
+  if [ "${VERBOSE}" -eq 1 ]; then
     verboseOpts="V=1"
   fi
 
-  if [ "${ZOPEN_MAKE}x" != "skipx" ] && [ ! -z "$(command -v ${ZOPEN_MAKE})" ] ; then
-    if [ "${ZOPEN_MAKE_MINIMAL}x" = "x" ]; then
-      export ZOPEN_MAKE_CMD="\"${ZOPEN_MAKE}\" ${ZOPEN_MAKE_OPTS} $verboseOpts CC=${CC} \"CPPFLAGS=${CPPFLAGS}\" \"CFLAGS=${CFLAGS}\" CXX=${CXX} \"CXXFLAGS=${CXXFLAGS}\" \"LDFLAGS=${LDFLAGS}\" \"LDLIBS=${LIBS}\""
+  if [ "${ZOPEN_MAKE}x" != "skipx" ] && [ ! -z "$(command -v ${ZOPEN_MAKE})" ]; then
+    if [ -z "${ZOPEN_MAKE_MINIMAL}" ]; then
+      export ZOPEN_MAKE_CMD="\"${ZOPEN_MAKE}\" ${ZOPEN_MAKE_OPTS} ${verboseOpts} CC=${CC} \"CPPFLAGS=${CPPFLAGS}\" \"CFLAGS=${CFLAGS}\" CXX=${CXX} \"CXXFLAGS=${CXXFLAGS}\" \"LDFLAGS=${LDFLAGS}\" \"LDLIBS=${LIBS}\""
       export ZOPEN_MAKE_MINIMAL="no"
     else
       export ZOPEN_MAKE_CMD="\"${ZOPEN_MAKE}\" ${ZOPEN_MAKE_OPTS}"
@@ -1651,8 +1650,8 @@ resolveCommands()
   fi
 
   if [ "${ZOPEN_CHECK}x" != "skipx" ] && ! ${skipcheck}; then
-    if [ "${ZOPEN_CHECK_MINIMAL}x" = "x" ]; then
-      export ZOPEN_CHECK_CMD="\"${ZOPEN_CHECK}\" ${ZOPEN_CHECK_OPTS} $verboseOpts CC=${CC} \"CPPFLAGS=${CPPFLAGS}\" \"CFLAGS=${CFLAGS}\" CXX=${CXX} \"CXXFLAGS=${CXXFLAGS}\" \"LDFLAGS=${LDFLAGS}\""
+    if [ -z "${ZOPEN_CHECK_MINIMAL}" ]; then
+      export ZOPEN_CHECK_CMD="\"${ZOPEN_CHECK}\" ${ZOPEN_CHECK_OPTS} ${verboseOpts} CC=${CC} \"CPPFLAGS=${CPPFLAGS}\" \"CFLAGS=${CFLAGS}\" CXX=${CXX} \"CXXFLAGS=${CXXFLAGS}\" \"LDFLAGS=${LDFLAGS}\""
     else
       export ZOPEN_CHECK_CMD="\"${ZOPEN_CHECK}\" ${ZOPEN_CHECK_OPTS}"
     fi
@@ -1664,12 +1663,12 @@ resolveCommands()
 
   if [ "${ZOPEN_INSTALL}x" != "skipx" ] && [ ! -z "$(command -v ${ZOPEN_INSTALL})" ]; then
     case "${ZOPEN_CONFIGURE}" in
-      (*cmake*)
-        export ZOPEN_INSTALL_CMD="\"${ZOPEN_INSTALL}\" ${ZOPEN_INSTALL_OPTS}"
-        ;;
-      (*)
-        export ZOPEN_INSTALL_CMD="\"${ZOPEN_INSTALL}\" ${ZOPEN_INSTALL_OPTS} $verboseOpts CC=${CC} \"CPPFLAGS=${CPPFLAGS}\" \"CFLAGS=${CFLAGS}\" CXX=${CXX} \"CXXFLAGS=${CXXFLAGS}\" \"LDFLAGS=${LDFLAGS}\""
-        ;;
+    *cmake*)
+      export ZOPEN_INSTALL_CMD="\"${ZOPEN_INSTALL}\" ${ZOPEN_INSTALL_OPTS}"
+      ;;
+    *)
+      export ZOPEN_INSTALL_CMD="\"${ZOPEN_INSTALL}\" ${ZOPEN_INSTALL_OPTS} ${verboseOpts} CC=${CC} \"CPPFLAGS=${CPPFLAGS}\" \"CFLAGS=${CFLAGS}\" CXX=${CXX} \"CXXFLAGS=${CXXFLAGS}\" \"LDFLAGS=${LDFLAGS}\""
+      ;;
     esac
     [[ -d ${ZOPEN_ROOT}/install ]] || mkdir -p ${ZOPEN_ROOT}/install
     paxFileName="${ZOPEN_ROOT}/install/${ZOPEN_NAME}.${LOG_PFX}.zos.pax.Z"
@@ -1691,19 +1690,19 @@ resolveCommands()
 generateOCI()
 {
   if ! ${publishOCI}; then
-    return 0;
+    return 0
   fi
   printHeader "Generating OCI Image"
   package=$1
-  name=$(echo $package | cut -d "-" -f 1)
-  version=$(echo $package | cut -d "-" -f 2)
+  name=$(echo ${package} | cut -d "-" -f 1)
+  version=$(echo ${package} | cut -d "-" -f 2)
 
   # Make the version OCI compat
-  case "$version" in
-      *.*.*.*) ;;
-      *.*.*)  version="$version.0";;
-      *.*)  version="$version.0.0";;
-      *) version="1.0.0.0";;
+  case "${version}" in
+  *.*.*.*) ;;
+  *.*.*) version="${version}.0" ;;
+  *.*) version="${version}.0.0" ;;
+  *) version="1.0.0.0" ;;
   esac
 
   dockerfilecontents="
@@ -1714,13 +1713,13 @@ LABEL vendor=OSS
 LABEL version=${version}
 LABEL specification=1.0.0"
 
-  cd ${ZOPEN_INSTALL_DIR}
+  cd ${ZOPEN_INSTALL_DIR} || exit
   if [ -f "${ZOPEN_IMAGE_DOCKERFILE_NAME}" ]; then
     rm -f "${ZOPEN_IMAGE_DOCKERFILE_NAME}"
   fi
   printVerbose "Generating ${ZOPEN_IMAGE_DOCKERFILE_NAME}"
   for file in *; do
-    dockerfilecontents="${dockerfilecontents}\nCOPY $file @{CONTAINER_READWRITE}/$file"
+    dockerfilecontents="${dockerfilecontents}\nCOPY ${file} @{CONTAINER_READWRITE}/${file}"
   done
 
   # Add required .env file
@@ -1728,21 +1727,21 @@ LABEL specification=1.0.0"
   cp .env .zpm/.env
   dockerfilecontents="${dockerfilecontents}\nCOPY .zpm @{CONTAINER_READWRITE}/.zpm"
 
-  if ! asciiecho "$dockerfilecontents" "${ZOPEN_IMAGE_DOCKERFILE_NAME}"; then
+  if ! asciiecho "${dockerfilecontents}" "${ZOPEN_IMAGE_DOCKERFILE_NAME}"; then
     printError "Unable to make ${ZOPEN_IMAGE_DOCKERFILE_NAME}"
   fi
 
-  if [ -z $ZOPEN_IMAGE_REGISTRY ]; then
+  if [ -z ${ZOPEN_IMAGE_REGISTRY} ]; then
     printWarning "Environment variable ZOPEN_IMAGE_REGISTRY is needed to push an OCI image"
-    return 4;
+    return 4
   fi
-  if [ -z $ZOPEN_IMAGE_REGISTRY_ID ]; then
+  if [ -z ${ZOPEN_IMAGE_REGISTRY_ID} ]; then
     printWarning "Environment variable ZOPEN_IMAGE_REGISTRY_ID is needed to push an OCI image"
-    return 4;
+    return 4
   fi
-  if [ -z $ZOPEN_IMAGE_REGISTRY_KEY_FILE ] || [ ! -r $ZOPEN_IMAGE_REGISTRY_KEY_FILE ]; then
+  if [ -z ${ZOPEN_IMAGE_REGISTRY_KEY_FILE} ] || [ ! -r ${ZOPEN_IMAGE_REGISTRY_KEY_FILE} ]; then
     printWarning "Environment variable ZOPEN_IMAGE_REGISTRY_KEY_FILE is needed to push an OCI image"
-    return 4;
+    return 4
   fi
   if [ -z "$(command -v ${ZOPEN_IMAGE_DOCKER_NAME})" ]; then
     printWarning "${ZOPEN_IMAGE_DOCKER_NAME} is not present on your system"
@@ -1750,51 +1749,51 @@ LABEL specification=1.0.0"
   fi
   printVerbose "Generating OCI Image"
   "${ZOPEN_IMAGE_DOCKER_NAME}" build -t "${name}:${version}" .
-  "${ZOPEN_IMAGE_DOCKER_NAME}" push "${name}:${version}" -i $ZOPEN_IMAGE_REGISTRY -u $ZOPEN_IMAGE_REGISTRY_ID -p @$ZOPEN_IMAGE_REGISTRY_KEY_FILE
-  cd -
+  "${ZOPEN_IMAGE_DOCKER_NAME}" push "${name}:${version}" -i ${ZOPEN_IMAGE_REGISTRY} -u ${ZOPEN_IMAGE_REGISTRY_ID} -p @${ZOPEN_IMAGE_REGISTRY_KEY_FILE}
+  cd - || exit
 }
 
 generateZOSLIBHooks()
 {
-# Background:
-#  As part of the build/install process, various tools may require application specific environment variables to be set.
-#  This function generates a C hook zoslib_env_hook() that will be called by ZOSLIB before main is entered.
-#  The function's purpose is to automatically set environment variables before main.
-#  Taking Git as an example, unless Git is installed in the standard location, (e.g. /usr/local/zopen),
-#  it has a requirement to set the following environment variables, GIT_TEMPLATE_DIR, GIT_EXEC_PATH, and
-#  GIT_SSL_CAINFO.
-#  This function takes input from zopen_append_to_zoslib_env. For Git, this looks like:
-# GIT_TEMPLATE_DIR|set|PROJECT_ROOT/share/git-core/templates
-# GIT_EXEC_PATH|set|PROJECT_ROOT/libexec/git-core
-# GIT_SSL_CAINFO|set|PROJECT_ROOT/cacert.pem
-#  The first field is the environment variable. The second field is the action, which is one of set, unset, or prepend.
-#  The last field is the value. For unset, this is left empty. PROJECT_ROOT is replaced by the root directory of where the project is installed to.
-
-zoslib_env=""
-#TODO: In the future, consider locating all shared libraries and adding the LIBPATH automatically
-#zoslib_env="PATH|prepend|PROJECT_ROOT/bin
-#LIBPATH|prepend|PROJECT_ROOT/lib
-#"
-
-if command -V "${ZOPEN_APPEND_TO_ZOSLIB_ENV_CODE}" >/dev/null 2>&1; then
-  printVerbose "Appending additional environment zoslib variables..."
-  zoslib_env="${zoslib_env}$(${ZOPEN_APPEND_TO_ZOSLIB_ENV_CODE})"
-else
-  # Nothing to add, return
-  return;
-fi
+  # Background:
+  #  As part of the build/install process, various tools may require application specific environment variables to be set.
+  #  This function generates a C hook zoslib_env_hook() that will be called by ZOSLIB before main is entered.
+  #  The function's purpose is to automatically set environment variables before main.
+  #  Taking Git as an example, unless Git is installed in the standard location, (e.g. /usr/local/zopen),
+  #  it has a requirement to set the following environment variables, GIT_TEMPLATE_DIR, GIT_EXEC_PATH, and
+  #  GIT_SSL_CAINFO.
+  #  This function takes input from zopen_append_to_zoslib_env. For Git, this looks like:
+  # GIT_TEMPLATE_DIR|set|PROJECT_ROOT/share/git-core/templates
+  # GIT_EXEC_PATH|set|PROJECT_ROOT/libexec/git-core
+  # GIT_SSL_CAINFO|set|PROJECT_ROOT/cacert.pem
+  #  The first field is the environment variable. The second field is the action, which is one of set, unset, or prepend.
+  #  The last field is the value. For unset, this is left empty. PROJECT_ROOT is replaced by the root directory of where the project is installed to.
+
+  zoslib_env=""
+  #TODO: In the future, consider locating all shared libraries and adding the LIBPATH automatically
+  #zoslib_env="PATH|prepend|PROJECT_ROOT/bin
+  #LIBPATH|prepend|PROJECT_ROOT/lib
+  #"
+
+  if command -V "${ZOPEN_APPEND_TO_ZOSLIB_ENV_CODE}" > /dev/null 2>&1; then
+    printVerbose "Appending additional environment zoslib variables..."
+    zoslib_env="${zoslib_env}$(${ZOPEN_APPEND_TO_ZOSLIB_ENV_CODE})"
+  else
+    # Nothing to add, return
+    return
+  fi
 
-printHeader "Generating ZOSLIB Environment Hooks"
+  printHeader "Generating ZOSLIB Environment Hooks"
 
-# Generate directories
-mkdir -p .zoslib_hooks
-cd .zoslib_hooks
+  # Generate directories
+  mkdir -p .zoslib_hooks
+  cd .zoslib_hooks || exit
 
-output="zoslib_env_hook.c"
+  output="zoslib_env_hook.c"
 
-# Defines zoslib_env_hook
+  # Defines zoslib_env_hook
 
-cat <<zz >$output
+  cat << zz > "${output}"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -1816,21 +1815,20 @@ if (getenv("ZOPEN_IN_ZOPEN_BUILD")) {
 }
 zz
 
-
-# Process input
-echo "$zoslib_env" | while read line; do
-  if [ $(echo "$line" | awk -F '|' '{print NF-1}') -ne 2 ]; then
-    printError "$line must have 2 '|' seperators only"
-  fi
-  var=$(echo $line | cut -d '|' -f 1)
-  action=$(echo $line | cut -d '|' -f 2)
-  value=$(echo $line | cut -d '|' -f 3)
-
-  if [ "$action" = "unset" ]; then
-    echo "unsetenv(\"$var\");" >> $output
-  elif [ "$action" = "set" ]; then
-    cat <<zz >>$output
-    value_str = "$value";
+  # Process input
+  echo "${zoslib_env}" | while read line; do
+    if [ $(echo "${line}" | awk -F '|' '{print NF-1}') -ne 2 ]; then
+      printError "${line} must have 2 '|' seperators only"
+    fi
+    var=$(echo ${line} | cut -d '|' -f 1)
+    action=$(echo ${line} | cut -d '|' -f 2)
+    value=$(echo ${line} | cut -d '|' -f 3)
+
+    if [ "${action}" = "unset" ]; then
+      echo "unsetenv(\"${var}\");" >> "${output}"
+    elif [ "${action}" = "set" ]; then
+      cat << zz >> "${output}"
+    value_str = "${value}";
     size = PATH_MAX;
     envar_value = (char*)malloc(size);
     memset(envar_value, 0, size);
@@ -1848,20 +1846,20 @@ echo "$zoslib_env" | while read line; do
       }
     }
 
-    if (!getenv("$var")) {
+    if (!getenv("${var}")) {
       if (getenv("__ZOPEN_DEBUG"))
-        fprintf(stderr, "Setting variable %s=%s\n", "$var", envar_value);
-      if (setenv("$var", envar_value, 1) != 0) {
-        fprintf(stderr, "Error: Setting environment variable %s=%s\n", "$var", envar_value);
+        fprintf(stderr, "Setting variable %s=%s\n", "${var}", envar_value);
+      if (setenv("${var}", envar_value, 1) != 0) {
+        fprintf(stderr, "Error: Setting environment variable %s=%s\n", "${var}", envar_value);
         exit(1);
       }
     }
     free(envar_value);
 zz
-  elif [ "$action" = "prepend" ]; then
-    cat <<zz >>$output
-    value_str = "$value";
-    size = strlen(getenv("$var")) + strlen(value_str) + strlen(root_dir) + 2;
+    elif [ "${action}" = "prepend" ]; then
+      cat << zz >> "${output}"
+    value_str = "${value}";
+    size = strlen(getenv("${var}")) + strlen(value_str) + strlen(root_dir) + 2;
     envar_value = (char*)malloc(size);
     memset(envar_value, 0, size);
 
@@ -1880,38 +1878,38 @@ zz
     }
 
     strcat(envar_value, ":");
-    strcat(envar_value, getenv("$var"));
+    strcat(envar_value, getenv("${var}"));
     if (getenv("__ZOPEN_DEBUG"))
-      fprintf(stderr, "Prepending variable %s=%s\n", "$var", envar_value);
-    if (setenv("$var", envar_value, 1) != 0) {
-      fprintf(stderr, "Error: prepending environment variable %s=%s\n", "$var", envar_value);
+      fprintf(stderr, "Prepending variable %s=%s\n", "${var}", envar_value);
+    if (setenv("${var}", envar_value, 1) != 0) {
+      fprintf(stderr, "Error: prepending environment variable %s=%s\n", "${var}", envar_value);
       exit(1);
     }
     free(envar_value);
 zz
-  else
-    printError "$action is not valid, must be one of set, unset, or prepend"
-  fi
+    else
+      printError "${action} is not valid, must be one of set, unset, or prepend"
+    fi
 
-done
+  done
 
-echo "" >> $output
-echo "return 0;" >> $output
-echo "}" >> $output
+  echo "" >> "${output}"
+  echo "return 0;" >> "${output}"
+  echo "}" >> "${output}"
 
-# xlclang pragma linkage does not work
-if [ "$CC" = "xlclang" ]; then
-  extraOptions="-qexportall"
-fi
-if ! runAndLog "$CC $CFLAGS $CPPFLAGS -DPATH_MAX=1024 $extraOptions -c $output -o ${output}.o"; then
-  printError "Compiler command for $output failed to compile"
-fi
+  # xlclang pragma linkage does not work
+  if [ "${CC}" = "xlclang" ]; then
+    extraOptions="-qexportall"
+  fi
+  if ! runAndLog "${CC} ${CFLAGS} ${CPPFLAGS} -DPATH_MAX=1024 ${extraOptions} -c ${output} -o ${output}.o"; then
+    printError "Compiler command for ${output} failed to compile"
+  fi
 
-# Apply it in both LIB envars because some ports use ZOPEN_EXTRA_LIBS directly
-export ZOPEN_EXTRA_LIBS="${ZOPEN_EXTRA_LIBS} $PWD/${output}.o"
-export LIBS="${LIBS} $PWD/${output}.o"
+  # Apply it in both LIB envars because some ports use ZOPEN_EXTRA_LIBS directly
+  export ZOPEN_EXTRA_LIBS="${ZOPEN_EXTRA_LIBS} ${PWD}/${output}.o"
+  export LIBS="${LIBS} ${PWD}/${output}.o"
 
-cd ..
+  cd ..
 }
 
 #
@@ -1926,7 +1924,10 @@ if ! processOptions $*; then
   exit 4
 fi
 
-export ZOPEN_ROOT=$(cd "$(dirname "$buildEnvFile")"; pwd)
+export ZOPEN_ROOT=$(
+  cd "$(dirname "${buildEnvFile}")" || exit
+  pwd
+)
 
 if ! loadBuildEnv; then
   exit 4
@@ -1944,7 +1945,7 @@ if ! getCode; then
   exit 4
 fi
 
-if command -V "zopen_pre_patch" >/dev/null 2>&1; then
+if command -V "zopen_pre_patch" > /dev/null 2>&1; then
   printVerbose "Running zopen_pre_patch"
   "zopen_pre_patch" "${PWD}"
 fi
@@ -1953,13 +1954,13 @@ if ! applyPatches; then
   exit 4
 fi
 
-if $getSourceOnly; then
+if ${getSourceOnly}; then
   exit 0
 fi
 
 cd "${ZOPEN_ROOT}/${dir}" || exit 99
 
-if [ "${ZOPEN_SRC_DIR}x" != "x" ]; then
+if [ -n "${ZOPEN_SRC_DIR}" ]; then
   cd "${ZOPEN_SRC_DIR}" || exit 99
 fi
 
@@ -1969,22 +1970,22 @@ if ! resolveCommands; then
   exit 4
 fi
 
-if command -V "${ZOPEN_INIT_CODE}" >/dev/null 2>&1; then
+if command -V "${ZOPEN_INIT_CODE}" > /dev/null 2>&1; then
   printVerbose "Running ${ZOPEN_INIT_CODE}"
   "${ZOPEN_INIT_CODE}" "${PWD}"
 fi
 
 if ${startShell}; then
-  if [ "${ZOPEN_SHELL}x" != "x" ]; then
+  if [ -n "${ZOPEN_SHELL}" ]; then
     exec "${ZOPEN_SHELL}"
   else
     exec /bin/sh
   fi
 fi
 
-if $cleanupBuild || $forceRebuild || $freshBuild; then
+if ${cleanupBuild} || ${forceRebuild} || ${freshBuild}; then
   cleanup
-  if $cleanupBuild; then
+  if ${cleanupBuild}; then
     exit 0
   fi
 fi
diff --git a/bin/zopen-clean b/bin/zopen-clean
index c77d8d53e..60a95481f 100755
--- a/bin/zopen-clean
+++ b/bin/zopen-clean
@@ -6,20 +6,21 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 checkWritable
 
-printHelp(){
-cat << HELPDOC
+printHelp()
+{
+  cat << HELPDOC
 zopen clean is a utility for z/OS Open Tools to clean uneeded resources
 from the system to save space and prevent clutter
 
@@ -47,62 +48,63 @@ Report bugs at https://github.com/ZOSOpenTools/meta/issues .
 HELPDOC
 }
 
-
-cleanUnused(){
+cleanUnused()
+{
   needle=$1
-  found=$(zosfind "$ZOPEN_PKGINSTALL" -name "*/${needle}-*" -prune -type d )
-  if [ -z "$found" ]; then
+  found=$(zosfind "${ZOPEN_PKGINSTALL}" -name "*/${needle}-*" -prune -type d)
+  if [ -z "${found}" ]; then
     printInfo "No versions of package '${needle}' found for removal"
     return
   fi
 
-  if isPackageActive "$needle"; then
+  if isPackageActive "${needle}"; then
     printVerbose "Getting the current versions directory [if any]"
-    deref=$(cd "$ZOPEN_PKGINSTALL/$needle/$needle" && pwd -P)
+    deref=$(cd "${ZOPEN_PKGINSTALL}/${needle}/${needle}" && pwd -P)
   else
     printInfo "No currently installed version of package '${needle}'. Removing all versions"
   fi
 
   i=0
   current=0
-# the below would be simpler, but creates a subshell so can't get the number of entries outside!  
-#  echo "$found" | xargs | tr ' ' '\n' | while read repo; do
-  TMP_FIFO_PIPE="$HOME/altselect.pipe"
-  [ ! -p "$TMP_FIFO_PIPE" ] || rm -f "$TMP_FIFO_PIPE"
-  mkfifo "$TMP_FIFO_PIPE"
-  echo "$found" | xargs | tr ' ' '\n'>> "$TMP_FIFO_PIPE" &
+  # the below would be simpler, but creates a subshell so can't get the number of entries outside!
+  #  echo "$found" | xargs | tr ' ' '\n' | while read repo; do
+  TMP_FIFO_PIPE="${HOME}/altselect.pipe"
+  [ ! -p "${TMP_FIFO_PIPE}" ] || rm -f "${TMP_FIFO_PIPE}"
+  mkfifo "${TMP_FIFO_PIPE}"
+  echo "${found}" | xargs | tr ' ' '\n' >> "${TMP_FIFO_PIPE}" &
   while read repo; do
-    printVerbose "Parsing repo: '$repo' as '${repo#$ZOPEN_PKGINSTALL/}'"
-    if [ "${repo}" = "${repo#$ZOPEN_PKGINSTALL/}" ]; then
+    printVerbose "Parsing repo: '${repo}' as '${repo#"${ZOPEN_PKGINSTALL}"/}'"
+    if [ "${repo}" = "${repo#"${ZOPEN_PKGINSTALL}"/}" ]; then
       printVerbose "Working around possible bug in FIFO that converts initial char to alert/bell 0x07/'\a'"
       if ! $(type od); then
         printVerbose "Displaying erroneous string"
         out=$(echo "${repo}" | od -cx)
-        printVerbose "String details:\n '$out'"
+        printVerbose "String details:\n '${out}'"
       fi
-      repo="/$(echo $repo | cut -b 2-)"
-      printVerbose "Repo:='$repo'"
-      syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_W" "$CAT_FILE,$CAT_SYS" "CLEAN" "cleanUnused" "FIFO character issue while reading from $TMP_FIFO_PIPE. Workaround applied"
+      repo="/$(echo ${repo} | cut -b 2-)"
+      printVerbose "Repo:='${repo}'"
+      syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_W}" "${CAT_FILE},${CAT_SYS}" "CLEAN" "cleanUnused" "FIFO character issue while reading from ${TMP_FIFO_PIPE}. Workaround applied"
     fi
-    i=$(expr $i + 1)
-    if [ "${deref#$ZOPEN_PKGINSTALL/}" = "${repo#$ZOPEN_PKGINSTALL/}" ]; then
-      current=$i
-      printInfo "${NC}${GREEN}$i: ${repo#$ZOPEN_PKGINSTALL/}  <-  current${NC}"
+    i=$(expr ${i} + 1)
+    if [ "${deref#"${ZOPEN_PKGINSTALL}"/}" = "${repo#"${ZOPEN_PKGINSTALL}"/}" ]; then
+      current=${i}
+      printInfo "${NC}${GREEN}${i}: ${repo#"${ZOPEN_PKGINSTALL}"/}  <-  current${NC}"
     else
-      rm -rf "$repo" >/dev/null 2>&1 
-      printInfo "$i: ${repo#$ZOPEN_PKGINSTALL/} <- Removed"
-      syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_FILE,$CAT_PACKAGE,$CAT_REMOVE" "CLEAN" "cleanUnused" "Removed unused package at ${repo#$ZOPEN_PKGINSTALL/} "
+      rm -rf "${repo}" > /dev/null 2>&1
+      printInfo "${i}: ${repo#"${ZOPEN_PKGINSTALL}"/} <- Removed"
+      syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_FILE},${CAT_PACKAGE},${CAT_REMOVE}" "CLEAN" "cleanUnused" "Removed unused package at ${repo#"${ZOPEN_PKGINSTALL}"/} "
     fi
-  done < "$TMP_FIFO_PIPE"
-  [ ! -p "$TMP_FIFO_PIPE" ] || rm -f "$TMP_FIFO_PIPE"
-  printInfo "- Removal of unused package versions complete" 
+  done < "${TMP_FIFO_PIPE}"
+  [ ! -p "${TMP_FIFO_PIPE}" ] || rm -f "${TMP_FIFO_PIPE}"
+  printInfo "- Removal of unused package versions complete"
 }
 
-cleanDangling(){
+cleanDangling()
+{
   printVerbose "Removing dangling symlinks from the file structure"
   # As packages can install to any subfolder of the zopen filesystem, need to traverse
-    # along every path under that filesystem
-  if [ "$ZOPEN_ROOTFS" = "/." ]; then
+  # along every path under that filesystem
+  if [ "${ZOPEN_ROOTFS}" = "/." ]; then
     printWarning "With zopen's root configured as '/', traversal to find dangling symlinks"
     printWarning "will occur on ALL mounted file systems, ALL sub-directories and will"
     printWarning "attempt to remove any dangling symlinks it finds, regardless of how they"
@@ -113,7 +115,7 @@ cleanDangling(){
     printWarning "and analysed."
     printWarning "Are you absolutely sure you want to run this option (y/N)?"
     read absolutely < /dev/tty
-    if [ -n "$absolutely" ] && [ "y" = "${absolutely}" ]; then
+    if [ -n "${absolutely}" ] && [ "y" = "${absolutely}" ]; then
       printInfo "- Checking for any dangling symlinks across system"
     else
       exit 4
@@ -121,23 +123,24 @@ cleanDangling(){
   fi
   progressHandler "spinner" "- Dangling link removal complete" &
   ph=$!
-  killph="kill -HUP $ph"
-  addCleanupTrapCmd "$killph"
+  killph="kill -HUP ${ph}"
+  addCleanupTrapCmd "${killph}"
   flecnt=0
-  zosfind "$ZOPEN_ROOTFS" -type l -exec test ! -e {} \; -print | while read sl; do
-    printVerbose "Removing symlink '$sl'"
-    rm -f $sl
-    flecnt=$(expr $flecnt + 1)
+  zosfind "${ZOPEN_ROOTFS}" -type l -exec test ! -e {} \; -print | while read sl; do
+    printVerbose "Removing symlink '${sl}'"
+    rm -f ${sl}
+    flecnt=$(expr ${flecnt} + 1)
   done
-  $killph 2>/dev/null  # if the timer is not running, the kill will fail
-  syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_FILE" "CLEAN" "cleanDangling" "zopen system scanned for dangling symlinks; $flecnt link(s) removed"
+  ${killph} 2> /dev/null # if the timer is not running, the kill will fail
+  syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_FILE}" "CLEAN" "cleanDangling" "zopen system scanned for dangling symlinks; ${flecnt} link(s) removed"
 }
 
-cleanCache(){
-  printVerbose "Cleaning $ZOPEN_ROOTFS/var/cache/zopen"
-  rm -rf "$ZOPEN_ROOTFS/var/cache/zopen/*"
-  syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_FILE" "CLEAN" "cleanCache" "Main cache in $ZOPEN_ROOTFS/var/cache/zopen cleaned"
-  printInfo "- Cache at '$ZOPEN_ROOTFS/var/cache/zopen' cleaned"
+cleanCache()
+{
+  printVerbose "Cleaning ${ZOPEN_ROOTFS}/var/cache/zopen"
+  rm -rf "${ZOPEN_ROOTFS}/var/cache/zopen/*"
+  syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_FILE}" "CLEAN" "cleanCache" "Main cache in ${ZOPEN_ROOTFS}/var/cache/zopen cleaned"
+  printInfo "- Cache at '${ZOPEN_ROOTFS}/var/cache/zopen' cleaned"
 }
 
 # Main code start here
@@ -155,53 +158,52 @@ fi
 while [ $# -gt 0 ]; do
   printVerbose "Parsing option: $1"
   case "$1" in
-      "-u" | "--unused")
-      shift
-      [ $# -lt 1 ] && printError "Missing parameter for 'clean unused' option"
-      unused=true
-      dangling=false
-      cache=false
-      package="$1"
-      ;;
-      "-d" | "--dangling")
-      unused=false
-      dangling=true
-      cache=false
-      ;;
-      "-c" | "--cache")
-      unused=false
-      dangling=false
-      cache=true
-      ;;
-    "-h" | "--help" | "-?" )
-      printHelp "${args}"
-      exit 0
-      ;;
-    "--version" )
-      zopen --version $ME
-      exit 0
-      ;;
-    "-v" | "--verbose")
-      verbose=true
-      ;;
-    "--debug")
-      verbose=true
-      debug=true
-      ;;
-    *)
-      package="$1"; # Use the last unrecognised parameter as the package
-      ;;
+  "-u" | "--unused")
+    shift
+    [ $# -lt 1 ] && printError "Missing parameter for 'clean unused' option"
+    unused=true
+    dangling=false
+    cache=false
+    package="$1"
+    ;;
+  "-d" | "--dangling")
+    unused=false
+    dangling=true
+    cache=false
+    ;;
+  "-c" | "--cache")
+    unused=false
+    dangling=false
+    cache=true
+    ;;
+  "-h" | "--help" | "-?")
+    printHelp "${args}"
+    exit 0
+    ;;
+  "--version")
+    zopen --version ${ME}
+    exit 0
+    ;;
+  "-v" | "--verbose")
+    verbose=true
+    ;;
+  "--debug")
+    verbose=true
+    debug=true
+    ;;
+  *)
+    package="$1" # Use the last unrecognised parameter as the package
+    ;;
   esac
-  shift;
+  shift
 done
 
-if $unused; then 
-  cleanUnused "$package"
+if ${unused}; then
+  cleanUnused "${package}"
 fi
-if $dangling; then 
+if ${dangling}; then
   cleanDangling
 fi
-if $cache; then
+if ${cache}; then
   cleanCache
 fi
-
diff --git a/bin/zopen-compute-builddeps b/bin/zopen-compute-builddeps
index 723ee3a71..249554239 100755
--- a/bin/zopen-compute-builddeps
+++ b/bin/zopen-compute-builddeps
@@ -8,14 +8,14 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
@@ -40,7 +40,7 @@ if [[ $# -eq 1 ]]; then
     syntax
     exit 0
   elif [ "x$1" = "x--version" ]; then
-    zopen --version $ME
+    zopen --version ${ME}
     exit 0
   else
     echo "Unrecognized option $1. Processing terminated" >&2
@@ -53,7 +53,7 @@ rootpkg="$1"
 
 tmpdir="/tmp/blddep_$$"
 
-if ! mkdir "${tmpdir}" ; then
+if ! mkdir "${tmpdir}"; then
   echo "Unable to create temporary directory for computing transitive closure" >&2
   syntax
 fi
@@ -71,8 +71,8 @@ changed=true
 while ${changed}; do
   changed=false
   for pkg in ${deps}; do
-    if ! [[ -v scanned["${pkg}"] ]] ; then
-      if ! git clone "git@github.com:ZOSOpenTools/${pkg}port.git" ; then
+    if ! [[ -v scanned["${pkg}"] ]]; then
+      if ! git clone "git@github.com:ZOSOpenTools/${pkg}port.git"; then
         echo "Unable to clone package ${pkg}" >&2
         exit 4
       else
@@ -80,15 +80,15 @@ while ${changed}; do
         changed=true
       fi
       newpkgs=$(grep "ZOPEN_${primary_type}_DEPS" "${pkg}port/buildenv" | awk -F '"' '{print $2; }')
-      if [ "x${newpkgs}" = "x" ]; then
+      if [ -z "${newpkgs}" ]; then
         # try again with secondary type
         newpkgs=$(grep "ZOPEN_${secondary_type}_DEPS" "${pkg}port/buildenv" | awk -F '"' '{print $2; }')
       fi
-      if $verbose; then
+      if ${verbose}; then
         echo "${pkg} needs ${newpkgs}"
       fi
       for newpkg in ${newpkgs}; do
-        if ! [[ -v scanned["${newpkg}"] ]] ; then
+        if ! [[ -v scanned["${newpkg}"] ]]; then
           deps="${deps} ${newpkg}"
         fi
       done
diff --git a/bin/zopen-generate b/bin/zopen-generate
index 0693a81ce..41a0ba6ff 100755
--- a/bin/zopen-generate
+++ b/bin/zopen-generate
@@ -6,28 +6,28 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
 buildLicenseLookup()
 {
   licensesCSV="${MYDIR}/../data/licenses.csv"
-  if [ ! -r "$licensesCSV" ]; then
-    return 4;
+  if [ ! -r "${licensesCSV}" ]; then
+    return 4
   fi
 
-  validLicenseNames="$(cat $licensesCSV | tail +1 | cut -f1 -d',' | xargs)"
+  validLicenseNames="$(cat ${licensesCSV} | tail +1 | cut -f1 -d',' | xargs)"
 }
 
-printSyntax() 
+printSyntax()
 {
   args=$*
   echo "zopen-generate will generate a zopen compatible project" >&2
@@ -39,7 +39,7 @@ if [[ $# -eq 1 ]]; then
     printSyntax
     exit 0
   elif [ "x$1" = "x--version" ]; then
-    zopen --version $ME
+    zopen --version ${ME}
     exit 0
   else
     echo "Unrecognized option $1. Processing terminated" >&2
@@ -47,36 +47,36 @@ if [[ $# -eq 1 ]]; then
     exit 8
   fi
 fi
- 
+
 buildLicenseLookup
 
 printHeader "Generate a zopen project"
 valid=false
-while ! $valid; do
+while ! ${valid}; do
   echo "What is the project name?"
   name=$(getInput)
-  if ! echo "$name" | grep -q -E "port$"; then
+  if ! echo "${name}" | grep -q -E "port$"; then
     valid=true
   else
-    printWarning "$name must not end with port"
+    printWarning "${name} must not end with port"
   fi
 done
 echo "Provided a description of the project:"
 description=$(getInput)
 
 valid=false
-while ! $valid; do
-  echo "Provide the community license to use for $name's patches: (select from $validLicenseNames)"
+while ! ${valid}; do
+  echo "Provide the community license to use for ${name}'s patches: (select from ${validLicenseNames})"
   license_name="$(getInput | tr -d ' ')"
-  if ! echo " $validLicenseNames" | grep -q " $license_name"; then
-    printWarning "License is not valid, please enter a license from one of these names: $validLicenseNames)"
+  if ! echo " ${validLicenseNames}" | grep -q " ${license_name}"; then
+    printWarning "License is not valid, please enter a license from one of these names: ${validLicenseNames})"
   else
-    licenseName="$(cat $licensesCSV | grep "\"$license_name\"" | cut -f2 -d',')"
-    licenseUrl="$(cat $licensesCSV | grep "\"$license_name\"" | cut -f4 -d',')"
+    licenseName="$(cat ${licensesCSV} | grep "\"${license_name}\"" | cut -f2 -d',')"
+    licenseUrl="$(cat ${licensesCSV} | grep "\"${license_name}\"" | cut -f4 -d',')"
     valid=true
   fi
 done
-echo $licenseUrl
+echo ${licenseUrl}
 
 echo "Enter ${name}'s stable release source url: (Specify a Git or Tarball URL. If none, press enter)"
 stablePath=$(getInput)
@@ -93,19 +93,19 @@ runtimedeps=$(getInput)
 
 project_path="${name}port"
 
-if [ -d $project_path ]; then
+if [ -d ${project_path} ]; then
   while true; do
-    echo "Directory $project_path already exists. Update it? (y, n)"
+    echo "Directory ${project_path} already exists. Update it? (y, n)"
     clobber=$(getInput)
-    if [ "$clobber" = "n" ]; then
+    if [ "${clobber}" = "n" ]; then
       exit 0
-    elif [ "$clobber" = "y" ]; then
+    elif [ "${clobber}" = "y" ]; then
       break
     fi
   done
 fi
 
-printHeader "Generating $project_path zopen project"
+printHeader "Generating ${project_path} zopen project"
 mkdir -p ${name}port/patches
 
 # Create external LICENSE
@@ -113,35 +113,34 @@ touch "${name}port/patches/LICENSE" && chtag -tc 819 "${name}port/patches/LICENS
 echo "${licenseName}\nView license contents at ${licenseUrl}" > "${name}port/patches/LICENSE"
 
 buildenv="${name}port/buildenv"
-touch $buildenv && chtag -tc 819 $buildenv
+touch ${buildenv} && chtag -tc 819 ${buildenv}
 
 cp "${MYDIR}/../data/CONTRIBUTING.md" "${name}port/CONTRIBUTING.md"
 
-if [ ! -z "$stablePath" ]; then
-  buildenvContents="export ZOPEN_STABLE_URL=\"$stablePath\"\n"
+if [ ! -z "${stablePath}" ]; then
+  buildenvContents="export ZOPEN_STABLE_URL=\"${stablePath}\"\n"
 fi
-if [ ! -z "$stableDeps" ]; then
-  buildenvContents="${buildenvContents}export ZOPEN_STABLE_DEPS=\"$stableDeps\"\n"
+if [ ! -z "${stableDeps}" ]; then
+  buildenvContents="${buildenvContents}export ZOPEN_STABLE_DEPS=\"${stableDeps}\"\n"
 fi
 
-if [ ! -z "$devPath" ]; then
-  buildenvContents="${buildenvContents}export ZOPEN_DEV_URL=\"$devPath\"\n"
+if [ ! -z "${devPath}" ]; then
+  buildenvContents="${buildenvContents}export ZOPEN_DEV_URL=\"${devPath}\"\n"
 fi
-if [ ! -z "$devDeps" ]; then
-  buildenvContents="${buildenvContents}export ZOPEN_DEV_DEPS=\"$devDeps\"\n"
+if [ ! -z "${devDeps}" ]; then
+  buildenvContents="${buildenvContents}export ZOPEN_DEV_DEPS=\"${devDeps}\"\n"
 fi
 
-if [ ! -z "$buildline" ] && [ "$buildline" = "dev" ]; then
+if [ ! -z "${buildline}" ] && [ "${buildline}" = "dev" ]; then
   buildenvContents="${buildenvContents}export ZOPEN_BUILD_LINE=\"DEV\"\n"
 else
   buildenvContents="${buildenvContents}export ZOPEN_BUILD_LINE=\"STABLE\"\n"
 fi
 
-if [ ! -z "$runtimedeps" ]; then
-  buildenvContents="${buildenvContents}export ZOPEN_RUNTIME_DEPS=\"$runtimedeps\"\n"
+if [ ! -z "${runtimedeps}" ]; then
+  buildenvContents="${buildenvContents}export ZOPEN_RUNTIME_DEPS=\"${runtimedeps}\"\n"
 fi
 
-
 buildenvContents="${buildenvContents}\nzopen_check_results()
 {
   dir=\"\$1\"
@@ -172,12 +171,12 @@ zopen_get_version()
   echo \"1.0.0\"
 }"
 
-/bin/echo "$buildenvContents" > $buildenv
+/bin/echo "${buildenvContents}" > ${buildenv}
 
-printInfo "$buildenv created"
+printInfo "${buildenv} created"
 
 touch "${name}port/README.md" && chtag -tc 819 "${name}port/README.md"
-cat <<EOT > "${name}port/README.md"
+cat << EOT > "${name}port/README.md"
 ${name}
 
 ${description}
@@ -186,10 +185,10 @@ printInfo "${name}port/README.md created"
 
 createCICD()
 {
-buildline=$1
-touch "${name}port/cicd-$buildline.groovy" && chtag -tc 819 "${name}port/cicd-$buildline.groovy"
-buildlineUpper=$(echo "$buildline" | awk '{print toupper($0)}')
-cat <<EOT > "${name}port/cicd-$buildline.groovy"
+  buildline=$1
+  touch "${name}port/cicd-${buildline}.groovy" && chtag -tc 819 "${name}port/cicd-${buildline}.groovy"
+  buildlineUpper=$(echo "${buildline}" | awk '{print toupper($0)}')
+  cat << EOT > "${name}port/cicd-${buildline}.groovy"
 node('linux')
 {
   stage ('Poll') {
@@ -201,7 +200,7 @@ node('linux')
       userRemoteConfigs: [[url: 'https://github.com/ZOSOpenTools/${name}port.git']]])
   }
   stage('Build') {
-    build job: 'Port-Pipeline', parameters: [string(name: 'PORT_GITHUB_REPO', value: 'https://github.com/ZOSOpenTools/${name}port.git'), string(name: 'PORT_DESCRIPTION', value: '${description}' ), string(name: 'BUILD_LINE', value: '$buildlineUpper') ]
+    build job: 'Port-Pipeline', parameters: [string(name: 'PORT_GITHUB_REPO', value: 'https://github.com/ZOSOpenTools/${name}port.git'), string(name: 'PORT_DESCRIPTION', value: '${description}' ), string(name: 'BUILD_LINE', value: '${buildlineUpper}') ]
   }
 }
 EOT
@@ -211,7 +210,7 @@ createCICD "stable"
 createCICD "dev"
 
 touch "${name}port/.gitignore" && chtag -tc 819 "${name}port/.gitignore"
-cat <<EOT > "${name}port/.gitignore"
+cat << EOT > "${name}port/.gitignore"
 log/
 log.DEV/
 log.STABLE/
@@ -222,10 +221,10 @@ printInfo "${name}port/.gitignore created"
 
 if [ -e "${MYDIR}/../LICENSE" ]; then
   cp "${MYDIR}/../LICENSE" "${name}port/LICENSE"
-elif [ -n "$ZOPEN_ROOTFS" ]; then
-  pkgInstallDir="$(cat "$ZOPEN_ROOTFS/etc/zopen/fstype")"
-  if [ -e "${MYDIR}/../../$pkgInstallDir/meta/meta/LICENSE" ]; then
-    cp "${MYDIR}/../../$pkgInstallDir/meta/meta/LICENSE" "${name}port/LICENSE"
+elif [ -n "${ZOPEN_ROOTFS}" ]; then
+  pkgInstallDir="$(cat "${ZOPEN_ROOTFS}/etc/zopen/fstype")"
+  if [ -e "${MYDIR}/../../${pkgInstallDir}/meta/meta/LICENSE" ]; then
+    cp "${MYDIR}/../../${pkgInstallDir}/meta/meta/LICENSE" "${name}port/LICENSE"
   else
     printError "Could not locate LICENSE file to copy for project"
   fi
diff --git a/bin/zopen-help2man b/bin/zopen-help2man
index 76cd605eb..c9d1acaaf 100755
--- a/bin/zopen-help2man
+++ b/bin/zopen-help2man
@@ -4,14 +4,14 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
@@ -23,8 +23,8 @@ setupMyself
 
 printSyntax()
 {
-  echo "$ME will generate man pages from help and version information for zopen and zopen-* tools" >&2
-  echo "Syntax: $ME DIRECTORY" >&2
+  echo "${ME} will generate man pages from help and version information for zopen and zopen-* tools" >&2
+  echo "Syntax: ${ME} DIRECTORY" >&2
   echo "  where DIRECTORY is the directory to write the man pages to (the directory needs to already exist)" >&2
 }
 
@@ -33,19 +33,19 @@ if [[ $# -eq 1 ]]; then
     printSyntax
     exit 0
   elif [ "x$1" = "x--version" ]; then
-    zopen --version $ME
+    zopen --version ${ME}
     exit 0
   else
     mandir="$1"
   fi
 else
-  echo "Expected one parameter to be passed to $ME. $# were passed in. No action performed" >&2
+  echo "Expected one parameter to be passed to ${ME}. $# were passed in. No action performed" >&2
   printSyntax
   exit 8
 fi
 
 set -e
-export rootdir="$( cd "$MYDIR/../" && dirname "$PWD" >/dev/null 2>&1 && pwd -P )"
+export rootdir="$(cd "${MYDIR}/../" && dirname "${PWD}" > /dev/null 2>&1 && pwd -P)"
 
 help2manopts="--no-discard-stderr -N"
 
@@ -55,7 +55,7 @@ if ! [ -d "${mandir}" ]; then
   exit 8
 fi
 
-if [ "x${MYDIR}" = "x" ] || [ "x${rootdir}" = "x" ]; then
+if [ -z "${MYDIR}" ] || [ -z "${rootdir}" ]; then
   echo "Internal error. Unable to determine version information" >&2
   exit 8
 fi
@@ -64,26 +64,23 @@ tooldirs="${rootdir}/bin"
 
 echo "Man pages will be written to: ${mandir}"
 for tooldir in ${tooldirs}; do
-  for tool in $tooldir/zopen*; do
+  for tool in ${tooldir}/zopen*; do
     basetool=$(basename ${tool})
-    help2man ${help2manopts} "${tool}" >"${mandir}/${basetool}.1"
-    if  $( "${tool}" --help >/dev/null 2>&1 ) ; then
+    help2man ${help2manopts} "${tool}" > "${mandir}/${basetool}.1"
+    if $("${tool}" --help > /dev/null 2>&1); then
       # Tool has implemented --help
-      if  $( "${tool}" --version >/dev/null 2>&1 ) ; then
+      if $("${tool}" --version > /dev/null 2>&1); then
         echo "${basetool}"
-      else 
+      else
         echo "${tool} supports --help but not --version options. man page generation skipped." >&2
       fi
-    else 
+    else
       # Tool has NOT implemented --help
-      if  $( "${tool}" --version >/dev/null 2>&1 ) ; then
+      if $("${tool}" --version > /dev/null 2>&1); then
         echo "${tool} does not support --help but does support man page generation skipped." >&2
-      else 
+      else
         echo "${tool} does not support --help nor --version options. man page generation skipped." >&2
       fi
     fi
   done
 done
-
-
-
diff --git a/bin/zopen-importenvs b/bin/zopen-importenvs
index 0d369baea..4734bde12 100755
--- a/bin/zopen-importenvs
+++ b/bin/zopen-importenvs
@@ -5,22 +5,22 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
 printSyntax()
 {
-  echo "USAGE: . ./$ME [path to buildenv to fetch dependency]" >&2
-  echo "If no argument is specified, zopen-importenvs will source all .env files from $HOME/zopen/prod and $HOME/zopen/boot" >&2
-  echo "If an argument is specified and it represents a buildenv file, zopen-importenvs will source the ZOPEN_*_DEPS specified dependencies from $HOME/zopen/prod and $HOME/zopen/boot" >&2
+  echo "USAGE: . ./${ME} [path to buildenv to fetch dependency]" >&2
+  echo "If no argument is specified, zopen-importenvs will source all .env files from ${HOME}/zopen/prod and ${HOME}/zopen/boot" >&2
+  echo "If an argument is specified and it represents a buildenv file, zopen-importenvs will source the ZOPEN_*_DEPS specified dependencies from ${HOME}/zopen/prod and ${HOME}/zopen/boot" >&2
 }
 
 if [[ $# -eq 1 ]]; then
@@ -28,7 +28,7 @@ if [[ $# -eq 1 ]]; then
     printSyntax
     exit 0
   elif [ "x$1" = "x--version" ]; then
-    zopen --version $ME
+    zopen --version ${ME}
     exit 0
   else
     echo "Unrecognized option $1. Processing terminated" >&2
@@ -37,15 +37,14 @@ if [[ $# -eq 1 ]]; then
   fi
 fi
 
-(return 0 2>/dev/null) && sourced=1 
+(return 0 2> /dev/null) && sourced=1
 # What exit code did that give?
-if [[ $sourced -ne 1 ]] 
-then
-    if [[ $sourced -ne 1 ]]; then
-      echo "zopen-importenvs must be sourced via the . (dot) shell builtin" >&2
-      printSyntax
-      exit 1     
-    fi
+if [[ ${sourced} -ne 1 ]]; then
+  if [[ ${sourced} -ne 1 ]]; then
+    echo "zopen-importenvs must be sourced via the . (dot) shell builtin" >&2
+    printSyntax
+    exit 1
+  fi
 fi
 
 if [ $# -eq 0 ]; then
@@ -53,116 +52,120 @@ if [ $# -eq 0 ]; then
   syntax
 fi
 
-oldWorkDir=`pwd`
-#depsPath has the details of the location of ports whose env files are consumed for sourcing 
-depsPath="$HOME/zopen/prod|$HOME/zopen/boot"
+oldWorkDir=$(pwd)
+#depsPath has the details of the location of ports whose env files are consumed for sourcing
+depsPath="${HOME}/zopen/prod|${HOME}/zopen/boot"
 configFile=~/zopen-config
-if [ -f "$configFile" ]
-then
-    while read -r line
-    do
-      val=$(echo $line | grep "ZOPEN_SEARCH_PATH") 
-      if [ -z $val ] &> /dev/null
-      then
-         continue;
-      else
-         path=$(echo $val | cut -d "=" -f 2) 
-         [ ! -z $path ] && depsPath=$path"/prod|"$path"/boot" && break
-      fi
-    done < "$configFile"
+if [ -f "${configFile}" ]; then
+  while read -r line; do
+    val=$(echo ${line} | grep "ZOPEN_SEARCH_PATH")
+    if [ -z ${val} ] &> /dev/null; then
+      continue
+    else
+      path=$(echo ${val} | cut -d "=" -f 2)
+      [ ! -z ${path} ] && depsPath=${path}"/prod|"${path}"/boot" && break
+    fi
+  done < "${configFile}"
 fi
 
-sourceEnvFromPath () {
-    # arrOfDirs, is an array which holds the names of dirs whose env is set
-     declare -a arrOfDirs
-     unset arrOfDirs[@]
+sourceEnvFromPath()
+{
+  # arrOfDirs, is an array which holds the names of dirs whose env is set
+  declare -a arrOfDirs
+  unset arrOfDirs[@]
 
-    #Loop through zopen/boot & zopen/prod
-     for path in $(echo "$1" | sed "s/|/ /g") ; do
-         if [[ -L "$path" ]]; then
-            path="${path}/"
-         fi
-         [ ! -d "$path" ] && echo "Directory $path does not exist. Skipping." && continue
-         for deps in $(find "${path}" -name ".env")
-         do
-          depdir=$(dirname "${deps}")
-          dirName="$(basename ${depdir})"
+  #Loop through zopen/boot & zopen/prod
+  for path in $(echo "$1" | sed "s/|/ /g"); do
+    if [[ -L "${path}" ]]; then
+      path="${path}/"
+    fi
+    [ ! -d "${path}" ] && echo "Directory ${path} does not exist. Skipping." && continue
+    for deps in $(find "${path}" -name ".env"); do
+      depdir=$(dirname "${deps}")
+      dirName="$(basename ${depdir})"
 
-          #If env from this directory is not sourced then, fetch the env file and source it 
-          if [[ ! " ${arrOfDirs[*]} " =~ " ${dirName} " ]]; then
-             # array doesn't contain hence, source the env file
-             echo "Setting up ${depdir} dependency environment"
-             cd $depdir
-             . ./.env
+      #If env from this directory is not sourced then, fetch the env file and source it
+      if [[ ! " ${arrOfDirs[*]} " =~ " ${dirName} " ]]; then
+        # array doesn't contain hence, source the env file
+        echo "Setting up ${depdir} dependency environment"
+        cd ${depdir} || exit
+        . ./.env
 
-             # If sourcing is successful then, add to array
-             if [ $? -eq 0 ]; then
-                arrOfDirs+=($dirName)
-             fi
-             cd - 
-          else
-             echo "Skipping the set path = $dirName, as it is already sourced" 
-           fi
-         done
-      done 
+        # If sourcing is successful then, add to array
+        if [ $? -eq 0 ]; then
+          arrOfDirs+=(${dirName})
+        fi
+        cd - || exit
+      else
+        echo "Skipping the set path = ${dirName}, as it is already sourced"
+      fi
+    done
+  done
 }
 
 # if the number of arguments passed to script is 0,
 # then , the ports are fetched from $HOME/zopen/prod and $HOME/zopen/boot directory
 # then its env files are fetched and sourced, if they are not already sourced.
-if [ $# -eq 0 ]
-then
-     sourceEnvFromPath ${depsPath}
-else 
-    #If path is provided then builedenv file is fetched from the provided path 
-    pathForBuild=$1
-    if [ ! -d "${HOME}/zopen/boot/" ] && [ ! -d "${HOME}/zopen/prod/" ]; then
-       echo "${HOME}/zopen/boot & ${HOME}/zopen/prod directories do not exist. Exiting"
-       return 1 
-    fi
+if [ $# -eq 0 ]; then
+  sourceEnvFromPath ${depsPath}
+else
+  #If path is provided then builedenv file is fetched from the provided path
+  pathForBuild=$1
+  if [ ! -d "${HOME}/zopen/boot/" ] && [ ! -d "${HOME}/zopen/prod/" ]; then
+    echo "${HOME}/zopen/boot & ${HOME}/zopen/prod directories do not exist. Exiting"
+    return 1
+  fi
 
-    if [ -f ${pathForBuild} ]
-    then
-       filenameInPath="$(basename ${pathForBuild})"
-       if [ "${filenameInPath}" = "buildenv" ]; then
-           ZOPEN_GIT_DEPS=$(. ${pathForBuild}; echo $ZOPEN_GIT_DEPS); 
-           ZOPEN_TARBALL_DEPS=$(. ${pathForBuild}; echo $ZOPEN_TARBALL_DEPS); 
-           ZOPEN_TYPE=$(. ${pathForBuild}; echo $ZOPEN_TYPE); 
-       
-           if [ "${ZOPEN_TYPE}x" = "TARBALLx" ]; then
-              deps="${ZOPEN_TARBALL_DEPS}"
-           else
-              deps="${ZOPEN_GIT_DEPS}"
-           fi
+  if [ -f ${pathForBuild} ]; then
+    filenameInPath="$(basename ${pathForBuild})"
+    if [ "${filenameInPath}" = "buildenv" ]; then
+      ZOPEN_GIT_DEPS=$(
+        . ${pathForBuild}
+        echo ${ZOPEN_GIT_DEPS}
+      )
+      ZOPEN_TARBALL_DEPS=$(
+        . ${pathForBuild}
+        echo ${ZOPEN_TARBALL_DEPS}
+      )
+      ZOPEN_TYPE=$(
+        . ${pathForBuild}
+        echo ${ZOPEN_TYPE}
+      )
 
-           #loop through the dependencies based on if it is tarball or git
-           #and source the env files 
-           for dep in $deps; do
-               fail=true
-               for path in $(echo ${depsPath} | sed "s/|/ /g") ; do
-                   if [ -r "$path/${dep}/.env" ]; then
-                      fail=false
-                      depdir="$path/${dep}"
-                      echo "Setting up ${depdir} dependency environment"
-                      cd "${depdir}"
-                      if [ -x .env ]; then
-                        . ./.env 
-                        #donot check in next dep path as the env for this dependency port is foudn and sourced.
-                        break;
-                      fi
-                   fi
-               done
-               if $fail; then
-                  echo "Unable to find .env for dependency ${dep}"
-               fi
-           done 
-       else 
-           echo "Pass the absolute path to buildenv" 
-	   return 2
-       fi
+      if [ "${ZOPEN_TYPE}x" = "TARBALLx" ]; then
+        deps="${ZOPEN_TARBALL_DEPS}"
+      else
+        deps="${ZOPEN_GIT_DEPS}"
+      fi
+
+      #loop through the dependencies based on if it is tarball or git
+      #and source the env files
+      for dep in ${deps}; do
+        fail=true
+        for path in $(echo ${depsPath} | sed "s/|/ /g"); do
+          if [ -r "${path}/${dep}/.env" ]; then
+            fail=false
+            depdir="${path}/${dep}"
+            echo "Setting up ${depdir} dependency environment"
+            cd "${depdir}" || exit
+            if [ -x .env ]; then
+              . ./.env
+              #donot check in next dep path as the env for this dependency port is foudn and sourced.
+              break
+            fi
+          fi
+        done
+        if ${fail}; then
+          echo "Unable to find .env for dependency ${dep}"
+        fi
+      done
     else
-        sourceEnvFromPath $1
+      echo "Pass the absolute path to buildenv"
+      return 2
     fi
+  else
+    sourceEnvFromPath $1
+  fi
 fi
 
-cd ${oldWorkDir}
+cd ${oldWorkDir} || exit
diff --git a/bin/zopen-init b/bin/zopen-init
index 70158e791..cd1b4aa43 100755
--- a/bin/zopen-init
+++ b/bin/zopen-init
@@ -6,36 +6,36 @@ ZOPEN_DONT_PROCESS_CONFIG=1
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 checkWritable
 
-printSyntax() 
+printSyntax()
 {
   args=$*
   echo "zopen init will initialize the zopen filesystem and configuration (create a <root-dir>/etc/zopen-config file)" >&2
   echo "Syntax: zopen init [<option>] [<root-dir>]" >&2
   echo "  where <option> can be one or more of:" >&2
   echo "  -f <type>: virtual filesystem location for package management; packages will be installed to this location under the <root-dir>" >&2
-  echo "      usrlclz - /usr/local/zopen (default)" >&2 
+  echo "      usrlclz - /usr/local/zopen (default)" >&2
   echo "      zopen - /usr/zopen" >&2
   echo "      prod - zopen standard" >&2
   echo "      ibm  - /usr/lpp" >&2
-  echo "      fhs  - File Hierarchical Standard (/opt)"  >&2
-  echo "      usrlcl - /usr/local">&2
+  echo "      fhs  - File Hierarchical Standard (/opt)" >&2
+  echo "      usrlcl - /usr/local" >&2
   echo "  --re-init: re-initialize a previous installation (if present).  Re-initializing over a previous installation will re-use existing package structures and configurations." >&2
   echo "  --clone: clones the current installation to a different location" >&2
   echo "  --append-to-profile: appends sourcing of zopen-config to .profile" >&2
-  echo "  --releaseline-dev: whether to globally enable Development packages" >&2 
-  echo "  --yes|-y: automatically answer yes to prompts."  >&2
+  echo "  --releaseline-dev: whether to globally enable Development packages" >&2
+  echo "  --yes|-y: automatically answer yes to prompts." >&2
   echo "  -v: run in verbose mode" >&2
   echo "  -?|-h|--help: display help" >&2
 }
@@ -52,107 +52,106 @@ releaselineDev=false
 fslayout="usrlclz"
 while [ $# -gt 0 ]; do
   case "$1" in
-    "-f" | "--fs-layout" )
-      fslayout=$2
-      shift
-      ;;
-    "--re-init" )
-      reinitExisting=true
-      ;;
-    "--clone" )
-      clone=true
-      ;;
-    "--append-to-profile" )
-      appendToProfile=true
-      ;;
-    "--releaseline-dev" )
-      releaselineDev=true
-      ;;
-    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
-      printSyntax "${args}"
-      exit 0
-      ;;
-    "-v" | "--v" | "-verbose" | "--verbose")
-      verbose=true
-      ;;
-    "--version")
-      zopen --version $ME
-      exit 0
-      ;;
-    "--debug") 
-      debug=true
-      ;;
-    "--yes" | "-y")
-      yesToPrompts=true  # Automatically answer 'yes' to any questions
-      ;;
-    *)
-      rootfs=$1;
-      ;;
+  "-f" | "--fs-layout")
+    fslayout=$2
+    shift
+    ;;
+  "--re-init")
+    reinitExisting=true
+    ;;
+  "--clone")
+    clone=true
+    ;;
+  "--append-to-profile")
+    appendToProfile=true
+    ;;
+  "--releaseline-dev")
+    releaselineDev=true
+    ;;
+  "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+    printSyntax "${args}"
+    exit 0
+    ;;
+  "-v" | "--v" | "-verbose" | "--verbose")
+    verbose=true
+    ;;
+  "--version")
+    zopen --version ${ME}
+    exit 0
+    ;;
+  "--debug")
+    debug=true
+    ;;
+  "--yes" | "-y")
+    yesToPrompts=true # Automatically answer 'yes' to any questions
+    ;;
+  *)
+    rootfs=$1
+    ;;
   esac
-  shift;
+  shift
 done
-case "$fslayout" in
-  fhs|ibm|prod|zopen|usrlcl|usrlclz)
+case "${fslayout}" in
+fhs | ibm | prod | zopen | usrlcl | usrlclz) ;;
+*)
+  printError "${NC}${RED}The filesystem layout ${fslayout} is unrecognised"
   ;;
-  *)
-    printError "${NC}${RED}The filesystem layout $fslayout is unrecognised"
-    ;;
 esac
 
 printHeader "Initialize zopen framework"
 
-case "$fslayout" in
-  "usrlclz")
-    zopen_pkginstall="usr/local/zopen"
+case "${fslayout}" in
+"usrlclz")
+  zopen_pkginstall="usr/local/zopen"
   ;;
-  "usrlcl")
-    zopen_pkginstall="usr/local"
+"usrlcl")
+  zopen_pkginstall="usr/local"
   ;;
-  "fhs")
-    zopen_pkginstall="opt"
+"fhs")
+  zopen_pkginstall="opt"
   ;;
-  "ibm")
-    zopen_pkginstall="usr/lpp"
+"ibm")
+  zopen_pkginstall="usr/lpp"
   ;;
-  "prod")
-    zopen_pkginstall="prod"
+"prod")
+  zopen_pkginstall="prod"
   ;;
-  "zopen")
-    zopen_pkginstall="usr/zopen"
+"zopen")
+  zopen_pkginstall="usr/zopen"
   ;;
 esac
 
-if [ -n "$ZOPEN_ROOT_PATH" ]; then
-  rootfs="$ZOPEN_ROOT_PATH"
-  printInfo "- Setting root directory from ZOPEN_ROOT_PATH envvar: $rootfs"
+if [ -n "${ZOPEN_ROOT_PATH}" ]; then
+  rootfs="${ZOPEN_ROOT_PATH}"
+  printInfo "- Setting root directory from ZOPEN_ROOT_PATH envvar: ${rootfs}"
 fi
 
-if [ -z "$rootfs" ]; then
-  if $clone; then
+if [ -z "${rootfs}" ]; then
+  if ${clone}; then
     printInfo "- Enter fully-qualified path to clone-target directory:"
   else
-    printInfo "- Enter fully-qualified path to your zopen root directory (default: $HOME/zopen):"
+    printInfo "- Enter fully-qualified path to your zopen root directory (default: ${HOME}/zopen):"
   fi
   rootfs=$(getInput)
 else
-  printInfo "- Setting root directory from cli: $rootfs"
+  printInfo "- Setting root directory from cli: ${rootfs}"
 fi
 
-if [ -z "$rootfs" ]; then
-  if $clone; then
+if [ -z "${rootfs}" ]; then
+  if ${clone}; then
     printError "- No target location for clone. Stopping."
   fi
   printInfo "- No explicit root set, using default: \$HOME/zopen"
-  rootfs="$HOME/zopen"
+  rootfs="${HOME}/zopen"
 else
   if [ "${rootfs%/}" = '/' ]; then
     printInfo "- Stripping trailing '/' char"
     rootfs="${rootfs%})"
   fi
-  if [ "$rootfs" = "/" ]; then
+  if [ "${rootfs}" = "/" ]; then
     printInfo "- Installing into system root; are you sure (y/N)?"
     sysrootok=$(getInput)
-    if [ -n "$sysrootok" ] && [ "y" = "${sysrootok}" ]; then
+    if [ -n "${sysrootok}" ] && [ "y" = "${sysrootok}" ]; then
       printInfo "- Using '/' as root filesystem"
       rootfs="/." # references below take a root directory
     else
@@ -162,14 +161,14 @@ else
   fi
 fi
 
-printInfo "- Binaries will be symlinked under \"$rootfs/usr/local/bin\". Libraries will be symlinked under \"$rootfs/usr/lib\""
-printInfo "- Packages will be installed and maintained under the directory structure $fslayout ($rootfs/$zopen_pkginstall). To change, re-run with the -f <layout> option."
-if ! $yesToPrompts; then
+printInfo "- Binaries will be symlinked under \"${rootfs}/usr/local/bin\". Libraries will be symlinked under \"${rootfs}/usr/lib\""
+printInfo "- Packages will be installed and maintained under the directory structure ${fslayout} (${rootfs}/${zopen_pkginstall}). To change, re-run with the -f <layout> option."
+if ! ${yesToPrompts}; then
   while true; do
     printInfo "Do you want to continue? [y/n]"
     read continueInstall < /dev/tty
     if [ "y" = "${continueInstall}" ]; then
-      break;
+      break
     fi
     if [ "n" = "${continueInstall}" ]; then
       printInfo "Exiting..."
@@ -178,20 +177,22 @@ if ! $yesToPrompts; then
   done
 fi
 
-configFile="$rootfs/etc/zopen-config"
-if [ -f "$configFile" ]; then
-  if $clone; then
-    [ ! -e "$configFile" ] && printError "- Unable to clone existing configuration; configuration file $configFile could not be read"
+configFile="${rootfs}/etc/zopen-config"
+if [ -f "${configFile}" ]; then
+  if ${clone}; then
+    [ ! -e "${configFile}" ] && printError "- Unable to clone existing configuration; configuration file ${configFile} could not be read"
     printInfo "- Cloning existing configuration"
     configFile="zopen-config.clone"
-  elif [ -e "$configFile" ]; then
-    if ! $reinitExisting; then
+  elif [ -e "${configFile}" ]; then
+    if ! ${reinitExisting}; then
       printWarning "- Existing configuration file found; re-initializing might lose access to previously installed packages. Continue (y/n)?"
       reinit=$(getInput)
     fi
-    if $reinitExisting || { [ -n "$reinit" ] && [ "y" = "${reinit}" ]; }; then
+    if ${reinitExisting} || {
+      [ -n "${reinit}" ] && [ "y" = "${reinit}" ]
+    }; then
       printInfo "- Re-initializing; removing existing zopen-config"
-      rmrf=$(rm -rf "$configFile")
+      rmrf=$(rm -rf "${configFile}")
     else
       printWarning "- Stopping. Pre-existing configuration will be preserved"
       exit 8
@@ -199,72 +200,72 @@ if [ -f "$configFile" ]; then
   fi
 fi
 
-if ! $clone; then
-  printInfo "Checking for existence of specified root: '$rootfs'"
-  [ -e "$rootfs" ] || mkdir -p "$rootfs" || printError "Unable to create zopen root filesystem at '$rootfs'"
-  [ -d "$rootfs" ] || printError "Specified location '$rootfs' is not a directory. Unable to access root file system at '$rootfs'; check permissions"  
-  [ -w "$rootfs" ] || printError "Unable to write to root file system at '$rootfs'; check permissions"  
+if ! ${clone}; then
+  printInfo "Checking for existence of specified root: '${rootfs}'"
+  [ -e "${rootfs}" ] || mkdir -p "${rootfs}" || printError "Unable to create zopen root filesystem at '${rootfs}'"
+  [ -d "${rootfs}" ] || printError "Specified location '${rootfs}' is not a directory. Unable to access root file system at '${rootfs}'; check permissions"
+  [ -w "${rootfs}" ] || printError "Unable to write to root file system at '${rootfs}'; check permissions"
 
   printInfo "- Populating standard file system"
-  [ -e "$rootfs/bin" ] || mkdir -p "$rootfs/bin"
-  [ -e "$rootfs/etc" ] || mkdir -p "$rootfs/etc"
-  [ -e "$rootfs/include" ] || mkdir -p "$rootfs/include"
-  [ -e "$rootfs/usr/share" ] || mkdir -p "$rootfs/usr/share"
-  [ -e "$rootfs/usr/share/man" ] || mkdir -p "$rootfs/usr/share/man"
-  [ -e "$rootfs/usr/share/zopen" ] || mkdir -p "$rootfs/usr/share/zopen"
-  [ -e "$rootfs/var/cache/zopen" ] || mkdir -p "$rootfs/var/cache/zopen"
-  [ -e "$rootfs/var/log" ] || mkdir -p "$rootfs/var/log"
-  [ -e "$rootfs/var/tmp" ] || mkdir -p "$rootfs/var/tmp"
-  
+  [ -e "${rootfs}/bin" ] || mkdir -p "${rootfs}/bin"
+  [ -e "${rootfs}/etc" ] || mkdir -p "${rootfs}/etc"
+  [ -e "${rootfs}/include" ] || mkdir -p "${rootfs}/include"
+  [ -e "${rootfs}/usr/share" ] || mkdir -p "${rootfs}/usr/share"
+  [ -e "${rootfs}/usr/share/man" ] || mkdir -p "${rootfs}/usr/share/man"
+  [ -e "${rootfs}/usr/share/zopen" ] || mkdir -p "${rootfs}/usr/share/zopen"
+  [ -e "${rootfs}/var/cache/zopen" ] || mkdir -p "${rootfs}/var/cache/zopen"
+  [ -e "${rootfs}/var/log" ] || mkdir -p "${rootfs}/var/log"
+  [ -e "${rootfs}/var/tmp" ] || mkdir -p "${rootfs}/var/tmp"
+
   printInfo "- Creating path for bootstrap files"
-  [ -e "$rootfs/boot" ] || mkdir -p "$rootfs/boot"
-  
+  [ -e "${rootfs}/boot" ] || mkdir -p "${rootfs}/boot"
+
   printInfo "- Creating symbolic path for prod redirect files"
-  [ -e "$rootfs/usr/share/zopen/boot" ] || ln -s "$rootfs/boot" "$rootfs/usr/share/zopen/boot"
-  [ -e "$rootfs/etc/zopen" ] || mkdir -p "$rootfs/etc/zopen"
-  echo "$zopen_pkginstall" > "$rootfs/etc/zopen/fstype"
-  
-  [ -e "$rootfs/$zopen_pkginstall" ] || mkdir -p "$rootfs/$zopen_pkginstall"
-  [ -e "$rootfs/usr/share/zopen/prod" ] || ln -s "$rootfs/$zopen_pkginstall" "$rootfs/usr/share/zopen/prod"
+  [ -e "${rootfs}/usr/share/zopen/boot" ] || ln -s "${rootfs}/boot" "${rootfs}/usr/share/zopen/boot"
+  [ -e "${rootfs}/etc/zopen" ] || mkdir -p "${rootfs}/etc/zopen"
+  echo "${zopen_pkginstall}" > "${rootfs}/etc/zopen/fstype"
+
+  [ -e "${rootfs}/${zopen_pkginstall}" ] || mkdir -p "${rootfs}/${zopen_pkginstall}"
+  [ -e "${rootfs}/usr/share/zopen/prod" ] || ln -s "${rootfs}/${zopen_pkginstall}" "${rootfs}/usr/share/zopen/prod"
 else
   printVerbose "Grabbing pkginstall location from within cloned env"
-  if [ -e "$ZOPEN_ROOTFS/etc/zopen/fstype" ]; then
-    zopen_pkginstall=$(cat "$rootfs/etc/zopen/fstype")
+  if [ -e "${ZOPEN_ROOTFS}/etc/zopen/fstype" ]; then
+    zopen_pkginstall=$(cat "${rootfs}/etc/zopen/fstype")
   else
-    printError "Unable to locate $ZOPEN_ROOTFS/etc/zopen/fstype; cannot clone unrecognisable file system"
+    printError "Unable to locate ${ZOPEN_ROOTFS}/etc/zopen/fstype; cannot clone unrecognisable file system"
   fi
 fi
 
-if [ "$ZOPEN_PKGINSTALL" = "$rootfs" ]; then
-   printWarning "Package install location is the zopen root location; this is not recommended. Continue (y/n)"
-   pkgoverlaysrootfs=$(getInput)
-   if [ -n "$pkgoverlaysrootfs" ] && [ "y" = "${pkgoverlaysrootfs}" ]; then
-     printInfo "- Continuing. Packages will be installed into the zopen root location: $rootfs"
-   else
-     printWarning "- Stopping. Existing configuration will be preserved"
-     exit 8
-   fi
+if [ "${ZOPEN_PKGINSTALL}" = "${rootfs}" ]; then
+  printWarning "Package install location is the zopen root location; this is not recommended. Continue (y/n)"
+  pkgoverlaysrootfs=$(getInput)
+  if [ -n "${pkgoverlaysrootfs}" ] && [ "y" = "${pkgoverlaysrootfs}" ]; then
+    printInfo "- Continuing. Packages will be installed into the zopen root location: ${rootfs}"
+  else
+    printWarning "- Stopping. Existing configuration will be preserved"
+    exit 8
+  fi
 fi
 
-ZOPEN_CA_DIR="etc/pki/tls/certs"  # Mimic location on some Linux distributions
+ZOPEN_CA_DIR="etc/pki/tls/certs" # Mimic location on some Linux distributions
 certFileName="cacert.pem"
-if ! $clone; then
-    printInfo "- Creating path for certificate lookups"
-    [ -e "$rootfs/$ZOPEN_CA_DIR" ] || mkdir -p "$rootfs/$ZOPEN_CA_DIR"
+if ! ${clone}; then
+  printInfo "- Creating path for certificate lookups"
+  [ -e "${rootfs}/${ZOPEN_CA_DIR}" ] || mkdir -p "${rootfs}/${ZOPEN_CA_DIR}"
 fi
 
 # Save the configuration to the file - overwrite any existing file with the title initially
-echo "# z/OS Open Tools Configuration file" > "$configFile"
-echo "# Main root location for the zopen installation; can be changed if the " >> "$configFile"
-echo "# underlying root location is copied/moved elsewhere as locations are " >> "$configFile"
-echo "# relative to this envvar value" >> "$configFile"
-echo "ZOPEN_ROOTFS=\"$rootfs\"" >> "$configFile"
-echo "export ZOPEN_ROOTFS" >> "$configFile"
-echo "configStartTime=\$SECONDS" >> "$configFile"
-echo "zot=\"z/OS Open Tools\"" >> "$configFile"
+echo "# z/OS Open Tools Configuration file" > "${configFile}"
+echo "# Main root location for the zopen installation; can be changed if the " >> "${configFile}"
+echo "# underlying root location is copied/moved elsewhere as locations are " >> "${configFile}"
+echo "# relative to this envvar value" >> "${configFile}"
+echo "ZOPEN_ROOTFS=\"${rootfs}\"" >> "${configFile}"
+echo "export ZOPEN_ROOTFS" >> "${configFile}"
+echo "configStartTime=\$SECONDS" >> "${configFile}"
+echo "zot=\"z/OS Open Tools\"" >> "${configFile}"
 
 # Add the profiled processing first so the zopen paths are added first
-cat << EOF >>  "$configFile"
+cat << EOF >> "${configFile}"
 # Temporary file location
 for tmp in "\$TMPDIR" "\$TMP" /tmp
 do
@@ -284,7 +285,7 @@ atExit() {
   [ -p \$TMP_FIFO_PIPE ] && rm -rf \$TMP_FIFO_PIPE
   unset TMP_FIFO_PIPE
   trap - EXIT INT TERM QUIT HUP
-  return $sig
+  return ${sig}
 }
 
 trap "atExit" EXIT INT TERM QUIT HUP
@@ -305,11 +306,11 @@ deleteDuplicateEntries()
 }
 
 # z/OS Open Tools environment variables
-ZOPEN_PKGINSTALL=\$ZOPEN_ROOTFS/$zopen_pkginstall
+ZOPEN_PKGINSTALL=\$ZOPEN_ROOTFS/${zopen_pkginstall}
 export ZOPEN_PKGINSTALL
 ZOPEN_SEARCH_PATH=\$ZOPEN_ROOTFS/usr/share/zopen/
 export ZOPEN_SEARCH_PATH
-ZOPEN_CA=\"\$ZOPEN_ROOTFS/$ZOPEN_CA_DIR/$certFileName\"
+ZOPEN_CA=\"\$ZOPEN_ROOTFS/${ZOPEN_CA_DIR}/${certFileName}\"
 export ZOPEN_CA
 ZOPEN_LOG_PATH=\$ZOPEN_ROOTFS/var/log
 export ZOPEN_LOG_PATH
@@ -365,167 +366,167 @@ EOF
 
 perms="744"
 printVerbose "Giving world read access to config file"
-chmod "$perms" "$configFile"
+chmod "${perms}" "${configFile}"
 
-effuid=$LOGNAME
-effgid=$(id -gn $effuid)
-printVerbose "Ensuring correct uid [$effuid] & gid [$effgid] for configfile if !installing as user (ie su/root/etc)"
-chown "$effuid" "$configFile" 2>/dev/null # suppress if not permitted
-chgrp "$effgid" "$configFile" 2>/dev/null # suppress if not permitted
-printInfo "- Created config in $configFile."
+effuid=${LOGNAME}
+effgid=$(id -gn ${effuid})
+printVerbose "Ensuring correct uid [${effuid}] & gid [${effgid}] for configfile if !installing as user (ie su/root/etc)"
+chown "${effuid}" "${configFile}" 2> /dev/null # suppress if not permitted
+chgrp "${effgid}" "${configFile}" 2> /dev/null # suppress if not permitted
+printInfo "- Created config in ${configFile}."
 
-printInfo "- Root FS available at $rootfs"
+printInfo "- Root FS available at ${rootfs}"
 
-if $clone; then
-  printInfo "- Cloning from $ZOPEN_ROOTFS to $rootfs"
-  cp -fRT "$ZOPEN_ROOTFS" "$rootfs"
-  printInfo "${NC}${CYAN}- Run '. $configFile' to enable cloned environment for current session${NC}"
+if ${clone}; then
+  printInfo "- Cloning from ${ZOPEN_ROOTFS} to ${rootfs}"
+  cp -fRT "${ZOPEN_ROOTFS}" "${rootfs}"
+  printInfo "${NC}${CYAN}- Run '. ${configFile}' to enable cloned environment for current session${NC}"
   printInfo "${NC}${CYAN}- or manually copy cloned configuration to required location and/or modify .profile"
-  syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_PACKAGE,$CAT_FILE" "INIT" "" "zopen environment cloned to $rootfs"
+  syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_PACKAGE},${CAT_FILE}" "INIT" "" "zopen environment cloned to ${rootfs}"
   printInfo "${NC}${GREEN}zopen clone complete.${NC}"
 else
-  export ZOPEN_ROOTFS="$rootfs"
+  export ZOPEN_ROOTFS="${rootfs}"
 
   # Generate any system values that can be user changed
-  echo "15" > "$rootfs/etc/zopen/rm_fileprocs"
+  echo "15" > "${rootfs}/etc/zopen/rm_fileprocs"
 
-  if $releaselineDev; then
+  if ${releaselineDev}; then
     releaseLine="DEV"
-    printInfo "- Configured zopen to use development (DEV) releaseline packages where available" 
+    printInfo "- Configured zopen to use development (DEV) releaseline packages where available"
   else
     releaseLine="STABLE"
     printInfo "- Configured zopen to use stable releaseline packages"
   fi
-  echo "$releaseLine" > "$rootfs/etc/zopen/releaseline"
+  echo "${releaseLine}" > "${rootfs}/etc/zopen/releaseline"
 
   printInfo "- Check for shipped curl pax"
   curlpax="packages/curl-8.1.2.20230707_145137.zos.pax.Z"
 
-  curllcn=$(findrev "${MYDIR}" "$curlpax")
-  echo "$curllcn/$curlpax"
-  if [ -e "$curllcn/$curlpax" ]; then
-    printInfo "- Found $curlpax. Adding to zopen cache to install as bootstrap"
-    cp -f "$curllcn/$curlpax" "$rootfs/var/cache/zopen"
+  curllcn=$(findrev "${MYDIR}" "${curlpax}")
+  echo "${curllcn}/${curlpax}"
+  if [ -e "${curllcn}/${curlpax}" ]; then
+    printInfo "- Found ${curlpax}. Adding to zopen cache to install as bootstrap"
+    cp -f "${curllcn}/${curlpax}" "${rootfs}/var/cache/zopen"
   else
     printError "Could not locate curl pax in the zopen cache"
   fi
   printVerbose "- Expanding curl to bootstrap dir..."
-  cachedir="$rootfs/var/cache/zopen"
-  basecurlpax=$(basename $curlpax)
-  [ -e "$cachedir/$basecurlpax" ] || printError "Could not locate bootstrap curl pax."
-  paxrc=$(pax -rf "$cachedir/$basecurlpax" -s##$rootfs/boot/#)
+  cachedir="${rootfs}/var/cache/zopen"
+  basecurlpax=$(basename "${curlpax}")
+  [ -e "${cachedir}/${basecurlpax}" ] || printError "Could not locate bootstrap curl pax."
+  paxrc=$(pax -rf "${cachedir}/${basecurlpax}" -s##${rootfs}/boot/#)
 
   printInfo "- Check for shipped jq pax"
   jqpax="packages/jq-1.6.20230720_160648.zos.pax.Z"
 
-  jqlcn=$(findrev "${MYDIR}" "$jqpax")
-  if [ -e "$jqlcn/$jqpax" ]; then
-    printInfo "- Found $jqpax. Adding to zopen cache to install as bootstrap"
-    cp -f "$jqlcn/$jqpax" "$rootfs/var/cache/zopen"
+  jqlcn=$(findrev "${MYDIR}" "${jqpax}")
+  if [ -e "${jqlcn}/${jqpax}" ]; then
+    printInfo "- Found ${jqpax}. Adding to zopen cache to install as bootstrap"
+    cp -f "${jqlcn}/${jqpax}" "${rootfs}/var/cache/zopen"
   else
-    printError "$jqpax not found"
+    printError "${jqpax} not found"
   fi
   printVerbose "- Expanding jq to bootstrap dir..."
-  cachedir="$rootfs/var/cache/zopen"
-  basejqpax=$(basename $jqpax)
-  [ -e "$cachedir/$basejqpax" ] || printError "Could not locate bootstrap jq pax."
-  paxrc=$(pax -rf "$cachedir/$basejqpax" -s##$rootfs/boot/#)
+  cachedir="${rootfs}/var/cache/zopen"
+  basejqpax=$(basename "${jqpax}")
+  [ -e "${cachedir}/${basejqpax}" ] || printError "Could not locate bootstrap jq pax."
+  paxrc=$(pax -rf "${cachedir}/${basejqpax}" -s##${rootfs}/boot/#)
 
-  printVerbose "Configuring CA certificate file '$certFileName'"
+  printVerbose "Configuring CA certificate file '${certFileName}'"
   cacertFound=false
-  printVerbose "Check for existing ZOPEN_CA environment variable: $ZOPEN_CA"
-  if [ -n "$ZOPEN_CA" ]; then
+  printVerbose "Check for existing ZOPEN_CA environment variable: ${ZOPEN_CA}"
+  if [ -n "${ZOPEN_CA}" ]; then
     printVerbose "Existing envvar for ZOPEN_CA found"
-    if [ -r "$ZOPEN_CA" ]; then
-      printInfo "- Found existing setting for ZOPEN_CA '$ZOPEN_CA'; reusing certificate"
-      if [ "$ZOPEN_CA" != "$ZOPEN_ROOTFS/$ZOPEN_CA_DIR/$certFileName" ]; then # avoid cp error
-        cp -f "$ZOPEN_CA" "$ZOPEN_ROOTFS/$ZOPEN_CA_DIR"
+    if [ -r "${ZOPEN_CA}" ]; then
+      printInfo "- Found existing setting for ZOPEN_CA '${ZOPEN_CA}'; reusing certificate"
+      if [ "${ZOPEN_CA}" != "${ZOPEN_ROOTFS}/${ZOPEN_CA_DIR}/${certFileName}" ]; then # avoid cp error
+        cp -f "${ZOPEN_CA}" "${ZOPEN_ROOTFS}/${ZOPEN_CA_DIR}"
       fi
       cacertFound=true
     else
-      printVerbose "Unable to use Certificate file '$certFileName' specified in environment variable ZOPEN_CA='$ZOPEN_CA'. "
+      printVerbose "Unable to use Certificate file '${certFileName}' specified in environment variable ZOPEN_CA='${ZOPEN_CA}'. "
     fi
   else
     printVerbose "No current value for ZOPEN_CA environment variable"
   fi
-  if ! $cacertFound; then
-    printVerbose "Checking '${MYDIR}' directory tree for certificate file '$certFileName'"
-    cacertlcn="$(findrev "${MYDIR}" "$certFileName")"
-    if [ -e "$cacertlcn/$certFileName" ]; then
-      printInfo "- Found default certificate file '$certFileName'; copying to zopen file system"
-      cp -f "$cacertlcn/$certFileName" "$ZOPEN_ROOTFS/$ZOPEN_CA_DIR"
+  if ! ${cacertFound}; then
+    printVerbose "Checking '${MYDIR}' directory tree for certificate file '${certFileName}'"
+    cacertlcn="$(findrev "${MYDIR}" "${certFileName}")"
+    if [ -e "${cacertlcn}/${certFileName}" ]; then
+      printInfo "- Found default certificate file '${certFileName}'; copying to zopen file system"
+      cp -f "${cacertlcn}/${certFileName}" "${ZOPEN_ROOTFS}/${ZOPEN_CA_DIR}"
       cacertFound=true
     else
       printVerbose "Could not locate certificate file in directory structure"
     fi
   fi
-  if ! $cacertFound; then
-    cacertlcn="$MYDIR/../../$ZOPEN_CA_DIR/$certFileName"
-    printVerbose "Attempting relative search for certificate file at '$cacertlcn'"
-    if [ -r "$cacertlcn" ]; then
-      printInfo "- Found existing certificate file $certFileName'; copying to zopen file system"
-      cp -f "$cacertlcn" "$ZOPEN_ROOTFS/$ZOPEN_CA_DIR"
+  if ! ${cacertFound}; then
+    cacertlcn="${MYDIR}/../../${ZOPEN_CA_DIR}/${certFileName}"
+    printVerbose "Attempting relative search for certificate file at '${cacertlcn}'"
+    if [ -r "${cacertlcn}" ]; then
+      printInfo "- Found existing certificate file ${certFileName}'; copying to zopen file system"
+      cp -f "${cacertlcn}" "${ZOPEN_ROOTFS}/${ZOPEN_CA_DIR}"
       cacertFound=true
     else
       printVerbose "Relative search did not locate certificate file"
     fi
   fi
-  if ! $cacertFound; then
-    printError "Could not find '$certFileName' to copy to new environment. Re-run 'zopen init' with the '--verbose' option for more details"
+  if ! ${cacertFound}; then
+    printError "Could not find '${certFileName}' to copy to new environment. Re-run 'zopen init' with the '--verbose' option for more details"
   fi
 
-  if [ -r "$ZOPEN_ROOTFS/$ZOPEN_CA_DIR/$certFileName" ]; then
+  if [ -r "${ZOPEN_ROOTFS}/${ZOPEN_CA_DIR}/${certFileName}" ]; then
     printInfo "- Setting certificate environment variable"
-    export SSL_CERT_FILE="$ZOPEN_ROOTFS/$ZOPEN_CA_DIR/$certFileName"
+    export SSL_CERT_FILE="${ZOPEN_ROOTFS}/${ZOPEN_CA_DIR}/${certFileName}"
   else
-    printError "- Could not access '$certFileName' in '$ZOPEN_ROOTFS/$ZOPEN_CA_DIR'"
+    printError "- Could not access '${certFileName}' in '${ZOPEN_ROOTFS}/${ZOPEN_CA_DIR}'"
   fi
-  
+
   # Need to source the .env file from within the actual curl directory and cannot
   # spawn sub-process otherwise no access to environment from this script so run inline
   printVerbose "Sourcing environment to trigger any setup required for packages"
-  curldir="$(ls $rootfs/boot | grep curl)"
-  [ -e "$rootfs/boot/$curldir" ] || printError "Could not locate curl for bootstrap. Re-run 'zopen init' to retry"
-  chmod -R 755 "$rootfs/boot/$curldir"
-  curwd=$PWD
-  cd "$rootfs/boot/$curldir/" || printError "Could not access boot curl directory. Re-run 'zopen init' to retry"
+  curldir="$(ls ${rootfs}/boot | grep curl)"
+  [ -e "${rootfs}/boot/${curldir}" ] || printError "Could not locate curl for bootstrap. Re-run 'zopen init' to retry"
+  chmod -R 755 "${rootfs}/boot/${curldir}"
+  curwd=${PWD}
+  cd "${rootfs}/boot/${curldir}/" || printError "Could not access boot curl directory. Re-run 'zopen init' to retry"
   . ./.env
-  cd "$curwd"  || printError "Could not change to $curwd. Re-run 'zopen init' to retry"
+  cd "${curwd}" || printError "Could not change to ${curwd}. Re-run 'zopen init' to retry"
 
-  jqdir="$(ls $rootfs/boot | grep jq)"
-  [ -e "$rootfs/boot/$jqdir" ] || printError "Could not locate jq for bootstrap. Re-run 'zopen init' to retry"
-  chmod -R 755 "$rootfs/boot/$jqdir"
-  curwd=$PWD
-  cd "$rootfs/boot/$jqdir/" || printError "Could not access boot curl directory. Re-run 'zopen init' to retry"
+  jqdir="$(ls ${rootfs}/boot | grep jq)"
+  [ -e "${rootfs}/boot/${jqdir}" ] || printError "Could not locate jq for bootstrap. Re-run 'zopen init' to retry"
+  chmod -R 755 "${rootfs}/boot/${jqdir}"
+  curwd=${PWD}
+  cd "${rootfs}/boot/${jqdir}/" || printError "Could not access boot curl directory. Re-run 'zopen init' to retry"
   . ./.env
-  cd "$curwd"  || printError "Could not change to $curwd. Re-run 'zopen init' to retry"
-  
+  cd "${curwd}" || printError "Could not change to ${curwd}. Re-run 'zopen init' to retry"
+
   printInfo "- Updating CA cert"
-  ZOPEN_CA="$ZOPEN_ROOTFS/$ZOPEN_CA_DIR"
-  mkdir -p "$ZOPEN_CA"
-  runAndLog "${MYDIR}/zopen-update-cacert -f $ZOPEN_CA -v"
+  ZOPEN_CA="${ZOPEN_ROOTFS}/${ZOPEN_CA_DIR}"
+  mkdir -p "${ZOPEN_CA}"
+  runAndLog "${MYDIR}/zopen-update-cacert -f ${ZOPEN_CA} -v"
   [ $? -ne 0 ] && exit $?
-  export ZOPEN_CA="$ZOPEN_CA/cacert.pem"
+  export ZOPEN_CA="${ZOPEN_CA}/cacert.pem"
 
   printInfo "- Sourcing environment"
-  . "$configFile"
+  . "${configFile}"
   printInfo "- Using bootstrapped curl and jq to install updated versions (if available)"
   toolInstall=$(runAndLog "${MYDIR}/zopen-install -y curl jq meta")
   toolInstall=$?
-  [ $toolInstall -ne 0 ] && printError "Unable to install curl, jq and/or meta; see previous errors and retry the initilisation using the '--re-init' parameter"
-  . "$configFile"
+  [ "${toolInstall}" -ne 0 ] && printError "Unable to install curl, jq and/or meta; see previous errors and retry the initilisation using the '--re-init' parameter"
+  . "${configFile}"
 
   printInfo "- zopen bootstrapping complete"
 
-  if $appendToProfile; then
-    if ! grep -q ". $rootfs/etc/zopen-config" "$HOME/.profile"; then
+  if ${appendToProfile}; then
+    if ! grep -q ". ${rootfs}/etc/zopen-config" "${HOME}/.profile"; then
       printVerbose "Line not present (grep returned non-0)"
-  cat << EOF >>  "$HOME/.profile"
-  [ -e "$rootfs/etc/zopen-config" ] && . $rootfs/etc/zopen-config
+      cat << EOF >> "${HOME}/.profile"
+  [ -e "${rootfs}/etc/zopen-config" ] && . ${rootfs}/etc/zopen-config
 EOF
     fi
   fi
-  printInfo "${NC}${YELLOW}IMPORTANT: Run '. $rootfs/etc/zopen-config' to enable zopen environment for current session or add it to your .profile.${NC}"
-  syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_PACKAGE,$CAT_FILE" "INIT" "" "zopen environment initialised as $ZOPEN_ROOTFS"
+  printInfo "${NC}${YELLOW}IMPORTANT: Run '. ${rootfs}/etc/zopen-config' to enable zopen environment for current session or add it to your .profile.${NC}"
+  syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_PACKAGE},${CAT_FILE}" "INIT" "" "zopen environment initialised as ${ZOPEN_ROOTFS}"
   printInfo "${NC}${GREEN}zopen initialization complete.${NC}"
 fi
diff --git a/bin/zopen-install b/bin/zopen-install
index c37bc2eb4..d2ceef55a 100755
--- a/bin/zopen-install
+++ b/bin/zopen-install
@@ -5,19 +5,19 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 checkWritable
 
-printSyntax() 
+printSyntax()
 {
   args=$*
   echo "zopen install is a utility to download/install a z/OS Open Tools package."
@@ -25,17 +25,17 @@ printSyntax()
   echo "  where <option> may be one or more of:" >&2
   echo "  --help: print this help." >&2
   echo "  --version: print version" >&2
-  echo "  -u|--update|--upgrade: updates installed z/OS Open Tools packages."  >&2
-  echo "  --install-or-upgrade: installs the package if not installed, or upgrades the package if installed."  >&2
-  echo "  --reinstall: reinstall already installed z/OS Open Tools packages."  >&2
+  echo "  -u|--update|--upgrade: updates installed z/OS Open Tools packages." >&2
+  echo "  --install-or-upgrade: installs the package if not installed, or upgrades the package if installed." >&2
+  echo "  --reinstall: reinstall already installed z/OS Open Tools packages." >&2
   echo "  --nosymlink: do not integrate into filesystem through symlink redirection. " >&2
   echo "  --release-line <stable|dev>: the release line to build off of." >&2
-  echo "  --no-deps: do not install dependencies."  >&2
-  echo "  --cache-only: do not install dependencies."  >&2
-  echo "  --no-set-active: do not change the pinned version"  >&2
-  echo "  --skip-upgrade: do not upgrade."  >&2
-  echo "  --yes|-y: automatically answer yes to prompts."  >&2
-  echo "  --select: select a version to install."  >&2
+  echo "  --no-deps: do not install dependencies." >&2
+  echo "  --cache-only: do not install dependencies." >&2
+  echo "  --no-set-active: do not change the pinned version" >&2
+  echo "  --skip-upgrade: do not upgrade." >&2
+  echo "  --yes|-y: automatically answer yes to prompts." >&2
+  echo "  --select: select a version to install." >&2
   echo "  -v: run in verbose mode" >&2
   echo "  --download-only: download package to current directory" >&2
   echo "  --local-install: download and unpackage to current directory" >&2
@@ -46,33 +46,34 @@ printSyntax()
 installDependencies()
 (
   name=$1
-  printVerbose "List of dependencies to install: $dependencies"
-  skipupgrade_lcl=$skipupgrade
+  printVerbose "List of dependencies to install: ${dependencies}"
+  skipupgrade_lcl=${skipupgrade}
   skipupgrade=true
-  echo "$dependencies" | xargs | tr ' ' '\n' | sort | while read dep; do
-    printVerbose "Removing '$dep' from dependency queue '$dependencies'"
-    dependencies=$(echo "$dependencies" | sed -e "s/$dep//" | tr -s ' ')
-    handlePackageInstall "$dep"
+  echo "${dependencies}" | xargs | tr ' ' '\n' | sort | while read dep; do
+    printVerbose "Removing '${dep}' from dependency queue '${dependencies}'"
+    dependencies=$(echo "${dependencies}" | sed -e "s/${dep}//" | tr -s ' ')
+    handlePackageInstall "${dep}"
   done
-  skipupgrade=$skipupgrade_lcl
+  skipupgrade=${skipupgrade_lcl}
 )
 
-handlePackageInstall(){
+handlePackageInstall()
+{
 
   fullname="$1"
-  printVerbose "Name to install: $fullname, parsing any version ('=') or tag ('%') has been specified"
-  name=$(echo "$fullname" | sed -e 's#[=%].*##')
+  printVerbose "Name to install: ${fullname}, parsing any version ('=') or tag ('%') has been specified"
+  name=$(echo "${fullname}" | sed -e 's#[=%].*##')
   repo="${name}"
-  versioned=$(echo "$fullname" | cut -s -d '=' -f 2)
-  tagged=$(echo "$fullname" | cut -s -d '%' -f 2)
-  printVerbose "Name:$name;version:$versioned;tag:$tagged;repo:$repo"
-  printHeader "Installing package: $name"
+  versioned=$(echo "${fullname}" | cut -s -d '=' -f 2)
+  tagged=$(echo "${fullname}" | cut -s -d '%' -f 2)
+  printVerbose "Name:${name};version:${versioned};tag:${tagged};repo:${repo}"
+  printHeader "Installing package: ${name}"
 
   getAllReleasesFromGithub "${repo}"
 
-  if $localInstall; then
+  if ${localInstall}; then
     printVerbose "Local install to current directory"
-    rootInstallDir="$PWD"
+    rootInstallDir="${PWD}"
   else
     printVerbose "Setting install root to: ${ZOPEN_PKGINSTALL}"
     rootInstallDir="${ZOPEN_PKGINSTALL}"
@@ -83,10 +84,10 @@ handlePackageInstall(){
   printVerbose "Finding version/release information"
   if [ -e "${rootInstallDir}/${name}/${name}/.releaseinfo" ]; then
     originalFileVersion=$(cat "${rootInstallDir}/${name}/${name}/.releaseinfo")
-    printVerbose "Found originalFileVersion=$originalFileVersion (port is already installed)"
+    printVerbose "Found originalFileVersion=${originalFileVersion} (port is already installed)"
   elif [ -e "${rootInstallDir}/${name}/${name}/.version" ]; then
     originalFileVersion=$(cat "${rootInstallDir}/${name}/${name}/.version")
-    printVerbose "Found originalFileVersion=$originalFileVersion (port is already installed)"
+    printVerbose "Found originalFileVersion=${originalFileVersion} (port is already installed)"
   else
     printVerbose "Could not detect existing installation at ${rootInstallDir}/${name}/${name}"
   fi
@@ -95,196 +96,196 @@ handlePackageInstall(){
   installedReleaseLine=""
   if [ -e "${rootInstallDir}/${name}/${name}/.releaseline" ]; then
     installedReleaseLine=$(cat "${rootInstallDir}/${name}/${name}/.releaseline")
-    printVerbose "Installed product from releaseline: $installedReleaseLine"
+    printVerbose "Installed product from releaseline: ${installedReleaseLine}"
   else
     printVerbose "No current releaseline for package"
   fi
-  
+
   releaseMetadata=""
   downloadURL=""
   # Options where the user explicitly sets a version/tag/releaseline currently ignore any configured release-line,
   # either for a previous package install or system default
-  if [ ! "x" = "x$versioned" ]; then
-    printVerbose "Specific version $versioned requested - checking existence and URL"
-    requestedMajor=$(echo "$versioned" | awk -F'.' '{print $1}')
-    requestedMinor=$(echo "$versioned" | awk -F'.' '{print $2}')
-    requestedPatch=$(echo "$versioned" | awk -F'.' '{print $3}')
-    requestedSubrelease=$(echo "$versioned" | awk -F'.' '{print $4}')
+  if [ -n "${versioned}" ]; then
+    printVerbose "Specific version ${versioned} requested - checking existence and URL"
+    requestedMajor=$(echo "${versioned}" | awk -F'.' '{print $1}')
+    requestedMinor=$(echo "${versioned}" | awk -F'.' '{print $2}')
+    requestedPatch=$(echo "${versioned}" | awk -F'.' '{print $3}')
+    requestedSubrelease=$(echo "${versioned}" | awk -F'.' '{print $4}')
     requestedVersion="${requestedMajor}\\\.${requestedMinor}\\\.${requestedPatch}\\\.${requestedSubrelease}"
-    printVerbose "Finding URL for latest release matching version prefix: requestedVersion: $requestedVersion"
-    releaseMetadata=$(/bin/printf "%s" "$releases" | jq -e -r '. | map(select(.assets[].name | test("'$requestedVersion'")))[0]')
-  elif [ ! "x" = "x$tagged" ]; then
-    printVerbose "Explicit tagged version '$tagged' specified. Checking for match"
-    releaseMetadata=$(/bin/printf "%s" "$releases" | jq -e -r '.[] | select(.tag_name == "'$tagged'")')
+    printVerbose "Finding URL for latest release matching version prefix: requestedVersion: ${requestedVersion}"
+    releaseMetadata=$(/bin/printf "%s" "${releases}" | jq -e -r '. | map(select(.assets[].name | test("'${requestedVersion}'")))[0]')
+  elif [ -n "${tagged}" ]; then
+    printVerbose "Explicit tagged version '${tagged}' specified. Checking for match"
+    releaseMetadata=$(/bin/printf "%s" "${releases}" | jq -e -r '.[] | select(.tag_name == "'${tagged}'")')
     printVerbose "Use quick check for asset to check for existence of metadata for specific messages"
-    asset=$(/bin/printf "%s" "$releaseMetadata" | jq -e -r '.assets[0]')
+    asset=$(/bin/printf "%s" "${releaseMetadata}" | jq -e -r '.assets[0]')
     if [ $? -ne 0 ]; then
-      printError "Could not find release tagged '$tagged' in repo '$repo'"
+      printError "Could not find release tagged '${tagged}' in repo '${repo}'"
     fi
-  elif $selectVersion; then
+  elif ${selectVersion}; then
     # Explicitly allow the user to select a release to install; useful if there are broken installs
     # as a known good release can be found, selected and pinned!
     printVerbose "List individual releases and allow selection"
-    i=$(/bin/printf "%s" "$releases" | jq -r 'length - 1')
+    i=$(/bin/printf "%s" "${releases}" | jq -r 'length - 1')
     printInfo "Versions available for install:"
-    /bin/printf "%s" "$releases" | jq -e -r 'to_entries | map("\(.key): \(.value.tag_name) - \(.value.assets[0].name) - size: \(.value.assets[0].expanded_size/ (1024 * 1024))mb")[]'
+    /bin/printf "%s" "${releases}" | jq -e -r 'to_entries | map("\(.key): \(.value.tag_name) - \(.value.assets[0].name) - size: \(.value.assets[0].expanded_size/ (1024 * 1024))mb")[]'
 
     printVerbose "Getting user selection"
     valid=false
-    while ! $valid; do
-      echo "Enter version to install (0-$i): "
+    while ! ${valid}; do
+      echo "Enter version to install (0-${i}): "
       read selection < /dev/tty
-      if [[ ! -z $(echo "$selection" | sed -e 's/[0-9]*//') ]]; then
-        echo "Invalid input, must be a number between 0 and $i"
-      elif [ "$selection" -ge 0 ] && [ "$selection" -le "$i" ]; then
+      if [[ ! -z $(echo "${selection}" | sed -e 's/[0-9]*//') ]]; then
+        echo "Invalid input, must be a number between 0 and ${i}"
+      elif [ "${selection}" -ge 0 ] && [ "${selection}" -le "${i}" ]; then
         valid=true
       fi
     done
-    printVerbose "Selecting item $selection from array"
-    releaseMetadata="$(/bin/printf "%s" "$releases" | jq -e -r ".[$selection]")"
-
-  elif [ ! -z "$releaseLine" ]; then  
-    printVerbose "Install from release line '$releaseLine' specified"
-    validatedReleaseLine=$(validateReleaseLine "$releaseLine")
-    if [ -z "$validatedReleaseLine" ]; then
-      printError "Invalid releaseline specified: '$releaseLine'; Valid values: DEV or STABLE"
+    printVerbose "Selecting item ${selection} from array"
+    releaseMetadata="$(/bin/printf "%s" "${releases}" | jq -e -r ".[${selection}]")"
+
+  elif [ ! -z "${releaseLine}" ]; then
+    printVerbose "Install from release line '${releaseLine}' specified"
+    validatedReleaseLine=$(validateReleaseLine "${releaseLine}")
+    if [ -z "${validatedReleaseLine}" ]; then
+      printError "Invalid releaseline specified: '${releaseLine}'; Valid values: DEV or STABLE"
     fi
     printVerbose "Finding latest asset on the release line"
-    releaseMetadata="$(/bin/printf "%s" "$releases" | jq -e -r '. | map(select(.tag_name | startswith("'$releaseLine'")))[0]')"
+    releaseMetadata="$(/bin/printf "%s" "${releases}" | jq -e -r '. | map(select(.tag_name | startswith("'${releaseLine}'")))[0]')"
     printVerbose "Use quick check for asset to check for existence of metadata"
-    asset="$(/bin/printf "%s" "$releaseMetadata" | jq -e -r '.assets[0]')"
+    asset="$(/bin/printf "%s" "${releaseMetadata}" | jq -e -r '.assets[0]')"
     if [ $? -ne 0 ]; then
-      printError "Could not find release-line $releaseLine for repo: $repo"
+      printError "Could not find release-line ${releaseLine} for repo: ${repo}"
     fi
-    
+
   else
     printVerbose "No explicit version/tag/releaseline, checking for pre-existing package&releaseline"
-    if [ -n "$installedReleaseLine" ]; then
-      printVerbose "Found existing releaseline '$installedReleaseLine', restricting to only that releaseline"
-      validatedReleaseLine="$installedReleaseLine"  # Already validated when stored
-    else 
+    if [ -n "${installedReleaseLine}" ]; then
+      printVerbose "Found existing releaseline '${installedReleaseLine}', restricting to only that releaseline"
+      validatedReleaseLine="${installedReleaseLine}" # Already validated when stored
+    else
       printVerbose "Checking for system-configured releaseline"
-      sysrelline=$(cat "$ZOPEN_ROOTFS/etc/zopen/releaseline" | awk ' {print toupper($1)}')
-      printVerbose "Validating value: $sysrelline"
-      validatedReleaseLine=$(validateReleaseLine "$sysrelline")
-      if [ -n "$validatedReleaseLine" ]; then
-        printVerbose "zopen system configured to use releaseline '$sysrelline'; restricting to that releaseline"
+      sysrelline=$(cat "${ZOPEN_ROOTFS}/etc/zopen/releaseline" | awk ' {print toupper($1)}')
+      printVerbose "Validating value: ${sysrelline}"
+      validatedReleaseLine=$(validateReleaseLine "${sysrelline}")
+      if [ -n "${validatedReleaseLine}" ]; then
+        printVerbose "zopen system configured to use releaseline '${sysrelline}'; restricting to that releaseline"
       else
-        printWarning "zopen misconfigured to use an unknown releaseline of '$sysrelline'; defaulting to STABLE packages"
-        printWarning "Set the contents of '$ZOPEN_ROOTFS/etc/zopen/releaseline' to a valid value to remove this message"
+        printWarning "zopen misconfigured to use an unknown releaseline of '${sysrelline}'; defaulting to STABLE packages"
+        printWarning "Set the contents of '${ZOPEN_ROOTFS}/etc/zopen/releaseline' to a valid value to remove this message"
         printWarning "Valid values are: DEV | STABLE"
         validatedReleaseLine="STABLE"
       fi
     fi
     # We have some situations that could arise
-      # 1. the port being installed has no releaseline tagging yet (ie. no releases tagged STABLE_* or DEV_*)
-      # 2. system is configured for STABLE but only has DEV stream available
-      # 3. system is configured for DEV but only has DEV stream available
-      # 4. the port being installed has got full releaseline tagging
-      # The issue could arise that the user has switched the system from DEV->STABLE or vice-versa so package
-      # stream mismatches could arise but in normal case, once a package is installed [that has releaseline tagging]
-      # then that specific releaseline will be used
-    printVerbose "Finding any releases tagged with $validatedReleaseLine and getting the first (newest/latest)"
-    releaseMetadata="$(/bin/printf "%s" "$releases" | jq -e -r '. | map(select(.tag_name | startswith("'$validatedReleaseLine'")))[0]')"
+    # 1. the port being installed has no releaseline tagging yet (ie. no releases tagged STABLE_* or DEV_*)
+    # 2. system is configured for STABLE but only has DEV stream available
+    # 3. system is configured for DEV but only has DEV stream available
+    # 4. the port being installed has got full releaseline tagging
+    # The issue could arise that the user has switched the system from DEV->STABLE or vice-versa so package
+    # stream mismatches could arise but in normal case, once a package is installed [that has releaseline tagging]
+    # then that specific releaseline will be used
+    printVerbose "Finding any releases tagged with ${validatedReleaseLine} and getting the first (newest/latest)"
+    releaseMetadata="$(/bin/printf "%s" "${releases}" | jq -e -r '. | map(select(.tag_name | startswith("'${validatedReleaseLine}'")))[0]')"
     printVerbose "Use quick check for asset to check for existence of metadata"
-    asset="$(/bin/printf "%s" "$releaseMetadata" | jq -e -r '.assets[0]')"
+    asset="$(/bin/printf "%s" "${releaseMetadata}" | jq -e -r '.assets[0]')"
     if [ $? -eq 0 ]; then
       # Case 4...
-      printVerbose "Found a specific '$validatedReleaseLine' release-line tagged version; installing..."
+      printVerbose "Found a specific '${validatedReleaseLine}' release-line tagged version; installing..."
     else
       # Case 2 & 3
-      printVerbose "No releases on releaseline '$validatedReleaseLine'; checking alternative releaseline"
-      alt=$(echo "$validatedReleaseLine" | awk ' /DEV/ { print "STABLE" } /STABLE/ { print "DEV" }')
-      releaseMetadata="$(/bin/printf "%s" "$releases" | jq -e -r '. | map(select(.tag_name | startswith("'$alt'")))[0]')"
+      printVerbose "No releases on releaseline '${validatedReleaseLine}'; checking alternative releaseline"
+      alt=$(echo "${validatedReleaseLine}" | awk ' /DEV/ { print "STABLE" } /STABLE/ { print "DEV" }')
+      releaseMetadata="$(/bin/printf "%s" "${releases}" | jq -e -r '. | map(select(.tag_name | startswith("'${alt}'")))[0]')"
       printVerbose "Use quick check for asset to check for existence of metadata"
-      asset="$(/bin/printf "%s" "$releaseMetadata" | jq -e -r '.assets[0]')"
+      asset="$(/bin/printf "%s" "${releaseMetadata}" | jq -e -r '.assets[0]')"
       if [ $? -eq 0 ]; then
-        printVerbose "Found a release on the '$alt' release line so release tagging is active"
-        if [ "DEV" = "$validatedReleaseLine" ]; then
+        printVerbose "Found a release on the '${alt}' release line so release tagging is active"
+        if [ "DEV" = "${validatedReleaseLine}" ]; then
           # The system will be configured to use DEV packages where available but if none, use latest
           printInfo "No specific DEV releaseline package, using latest available"
-          releaseMetadata="$(/bin/printf "%s" "$releases" | jq -e -r ".[0]")"
+          releaseMetadata="$(/bin/printf "%s" "${releases}" | jq -e -r ".[0]")"
         else
           printVerbose "The system is configured to only use STABLE releaseline packages but there are none"
-          printInfo "No release available on the '$validatedReleaseLine' releaseline."
+          printInfo "No release available on the '${validatedReleaseLine}' releaseline."
         fi
       else
         # Case 1 - old package that has no release tagging yet (no DEV or STABLE), just install latest
         printVerbose "Installing latest release"
-        releaseMetadata="$(/bin/printf "%s" "$releases" | jq -e -r ".[0]")"
+        releaseMetadata="$(/bin/printf "%s" "${releases}" | jq -e -r ".[0]")"
       fi
     fi
   fi
 
-  printVerbose "Getting specific asset details from metadata: $releaseMetadata"
-  if [ -z "$asset" ] || [ "null" = "$asset" ]; then
+  printVerbose "Getting specific asset details from metadata: ${releaseMetadata}"
+  if [ -z "${asset}" ] || [ "null" = "${asset}" ]; then
     printVerbose "Asset not found during previous logic; setting now"
-    asset=$(/bin/printf "%s" "$releaseMetadata" | jq -e -r '.assets[0]')
+    asset=$(/bin/printf "%s" "${releaseMetadata}" | jq -e -r '.assets[0]')
   fi
-  if [ "x" = "x$asset" ]; then
+  if [ -z "${asset}" ]; then
     printError "Unable to determine download asset for ${name}"
   fi
 
-  tagname=$(/bin/printf "%s" "$releaseMetadata" | jq -e -r ".tag_name" | sed "s/\([^_]*\)_.*/\1/")
-  installedReleaseLine=$(validateReleaseLine "$tagname" )
+  tagname=$(/bin/printf "%s" "${releaseMetadata}" | jq -e -r ".tag_name" | sed "s/\([^_]*\)_.*/\1/")
+  installedReleaseLine=$(validateReleaseLine "${tagname}")
 
-  downloadURL=$(/bin/printf "%s" "$asset" | jq -e -r '.url')
-  size=$(/bin/printf "%s" "$asset" | jq -e -r '.expanded_size')
+  downloadURL=$(/bin/printf "%s" "${asset}" | jq -e -r '.url')
+  size=$(/bin/printf "%s" "${asset}" | jq -e -r '.expanded_size')
 
-  if [ "x" = "x$downloadURL" ]; then
+  if [ -z "${downloadURL}" ]; then
     printError "Unable to determine download location for ${name}"
   fi
-  downloadFile=$(basename "$downloadURL")
-  downloadFileVer=$(echo "$downloadFile" |sed -E 's/.*-(.*)\.zos\.pax\.Z/\1/')
-  printVerbose "Downloading port from URL: $downloadURL to file: $downloadFile (ver=$downloadFileVer)"
+  downloadFile=$(basename "${downloadURL}")
+  downloadFileVer=$(echo "${downloadFile}" | sed -E 's/.*-(.*)\.zos\.pax\.Z/\1/')
+  printVerbose "Downloading port from URL: ${downloadURL} to file: ${downloadFile} (ver=${downloadFileVer})"
 
-  if $downloadOnly; then
+  if ${downloadOnly}; then
     printVerbose "Skipping installation, downloading only"
   else
     printVerbose "Install=${downloadFileVer};Original=${originalFileVersion};${upgradeInstalled};${installOrUpgrade};${reinstall}"
     if [ "${downloadFileVer}" = "${originalFileVersion}" ]; then
-      if ! $reinstall; then
+      if ! ${reinstall}; then
         printInfo "${NC}${GREEN}Package ${name} is already installed at the requested version: ${downloadFileVer}${NC}"
-        return;
+        return
       fi
-      printInfo "- Reinstalling version '$downloadFileVer' of ${name}..."
+      printInfo "- Reinstalling version '${downloadFileVer}' of ${name}..."
     fi
 
     printVerbose "Checking if package is not installed but scheduled for upgrade"
-    if [ "x" = "x$originalFileVersion" ]; then
+    if [ -z "${originalFileVersion}" ]; then
       printVerbose "No previous version found"
-      if $installOrUpgrade; then
+      if ${installOrUpgrade}; then
         printVerbose "Package ${name} was not installed so not upgrading but installing"
-      elif $upgradeInstalled; then
+      elif ${upgradeInstalled}; then
         printError "Package ${name} can not be upgraded as it is not installed!"
-        continue;
+        continue
       fi
       unInstallOldVersion=false
       printInfo "- Installing ${name}..."
-    elif $skipupgrade; then
+    elif ${skipupgrade}; then
       printInfo "Package ${name} has a newer release '${downloadFileVer}' but explicitly skipping"
-      continue;
-    elif ! $setactive; then
+      continue
+    elif ! ${setactive}; then
       printVerbose "Current version '${originalFileVersion}' will remain active"
       unInstallOldVersion=false
     else
       printVerbose "Previous version '${originalFileVersion}' installed"
       if [ -e "${rootInstallDir}/${name}/${name}/.pinned" ]; then
         printWarning "- Version '${originalFileVersion}' has been pinned; upgrade to '${downloadFileVer}' skipped"
-        syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_PACKAGE,$CAT_INSTALL" "DOWNLOAD" "handlePackageInstall" "Attempt to change pinned package '${name}' skipped"
-        continue;
+        syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_PACKAGE},${CAT_INSTALL}" "DOWNLOAD" "handlePackageInstall" "Attempt to change pinned package '${name}' skipped"
+        continue
       else
         printInfo "- Replacing ${name} version '${originalFileVersion}' with '${downloadFileVer}'"
         unInstallOldVersion=true
-        currentversiondir=$(cd "$rootInstallDir/$name/${name}" && pwd -P)
-        currentlinkfile="$currentversiondir/.links"
+        currentversiondir=$(cd "${rootInstallDir}/${name}/${name}" && pwd -P)
+        currentlinkfile="${currentversiondir}/.links"
       fi
     fi
   fi
 
   printVerbose "Ensuring we are in the correct working download location '${downloadDir}'"
-  cd "${downloadDir}"
-  if [ ! $downloadOnly ] || [ ! $localInstall ]; then
+  cd "${downloadDir}" || exit
+  if [ ! -n "${downloadOnly}" ] || [ ! -n "${localInstall}" ]; then
     printVerbose "Checking current directory for already downloaded package [file name comparison]"
     location="current directory"
   else
@@ -292,60 +293,60 @@ handlePackageInstall(){
     location="zopen package cache"
   fi
 
-  pax=$downloadFile
-  if [ -f "$pax" ]; then
+  pax=${downloadFile}
+  if [ -f "${pax}" ]; then
     printInfo "- Found existing file '${pax}' in ${location}"
   else
-    printInfo "- Downloading $pax file from remote to ${location}..."
-    if ! $verbose; then
+    printInfo "- Downloading ${pax} file from remote to ${location}..."
+    if ! ${verbose}; then
       redirectToDevNull="2>/dev/null"
     fi
 
-    progressHandler "network" "- Downloaded $pax file from remote to ${location}." &
+    progressHandler "network" "- Downloaded ${pax} file from remote to ${location}." &
     ph=$!
-    killph="kill -HUP $ph"
-    addCleanupTrapCmd "$killph"
+    killph="kill -HUP ${ph}"
+    addCleanupTrapCmd "${killph}"
 
     if ! runAndLog "curlCmd -L '${downloadURL}' -O ${redirectToDevNull}"; then
       printError "Could not download from ${downloadURL}. Correct any errors and potentially retry"
-      continue;
+      continue
     fi
-    $killph 2>/dev/null  # if the timer is not running, the kill will fail
-    syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_NETWORK,$CAT_PACKAGE,$CAT_FILE" "DOWNLOAD" "handlePackageInstall" "Downloaded remote file '$pax'"
+    ${killph} 2> /dev/null # if the timer is not running, the kill will fail
+    syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_NETWORK},${CAT_PACKAGE},${CAT_FILE}" "DOWNLOAD" "handlePackageInstall" "Downloaded remote file '${pax}'"
   fi
   if [ ! -f "${pax}" ]; then
     printError "${pax} was not found after download!?!"
   fi
 
-  if $downloadOnly; then
-    printVerbose "Pax was downloaded to local dir '$downloadDir'"
-  elif $cacheOnly; then
-    printVerbose "Pax was downloaded to zopen cache '$downloadDir'"
+  if ${downloadOnly}; then
+    printVerbose "Pax was downloaded to local dir '${downloadDir}'"
+  elif ${cacheOnly}; then
+    printVerbose "Pax was downloaded to zopen cache '${downloadDir}'"
   else
-    printVerbose "Installing $pax"
+    printVerbose "Installing ${pax}"
     installdirname="${name}/${pax%.pax.Z}" # Use full pax name as default
 
-    printInfo "- Processing $pax..."
+    printInfo "- Processing ${pax}..."
     baseinstalldir="."
     paxredirect=""
-    if ! $localInstall; then
-      baseinstalldir="$rootInstallDir"
-      paxredirect="-s %[^/]*/%$rootInstallDir/$installdirname/%"
-      printVerbose "Non-local install, extracting with '$paxredirect'"
+    if ! ${localInstall}; then
+      baseinstalldir="${rootInstallDir}"
+      paxredirect="-s %[^/]*/%${rootInstallDir}/${installdirname}/%"
+      printVerbose "Non-local install, extracting with '${paxredirect}'"
     else
       printInfo "- Local install specified"
-      paxredirect="-s %[^/]*/%$installdirname/%"
-      printVerbose "Non-local install, extracting with '$paxredirect'"
+      paxredirect="-s %[^/]*/%${installdirname}/%"
+      printVerbose "Non-local install, extracting with '${paxredirect}'"
     fi
 
-    megabytes=$(echo "scale=2; $size / (1024 * 1024)" | bc)
-    printInfo "After this operation, $megabytes MB of additional disk space will be used."
-    if ! $yesToPrompts; then
+    megabytes=$(echo "scale=2; ${size} / (1024 * 1024)" | bc)
+    printInfo "After this operation, ${megabytes} MB of additional disk space will be used."
+    if ! ${yesToPrompts}; then
       while true; do
         printInfo "Do you want to continue? [y/n]"
         read continueInstall < /dev/tty
         if [ "y" = "${continueInstall}" ]; then
-          break;
+          break
         fi
         if [ "n" = "${continueInstall}" ]; then
           mutexFree "zopen"
@@ -355,59 +356,59 @@ handlePackageInstall(){
       done
     fi
 
-    printVerbose "Check for existing directory for version '$installdirname'"
-    if [ -d "$baseinstalldir/$installdirname" ]; then 
+    printVerbose "Check for existing directory for version '${installdirname}'"
+    if [ -d "${baseinstalldir}/${installdirname}" ]; then
       printInfo "- Clearing existing directory and contents"
-      rm -rf "$baseinstalldir/$installdirname"
+      rm -rf "${baseinstalldir}/${installdirname}"
     fi
 
-    if ! runLogProgress "pax -rf $pax -p p $paxredirect ${redirectToDevNull}" "Expanding $pax" "Expanded"; then
+    if ! runLogProgress "pax -rf ${pax} -p p ${paxredirect} ${redirectToDevNull}" "Expanding ${pax}" "Expanded"; then
       printWarning "Errors unpaxing, package directory state unknown"
-      printInfo    "Use zopen alt to select previous version"
-      continue;
+      printInfo "Use zopen alt to select previous version"
+      continue
     fi
-    if $localInstall; then
+    if ${localInstall}; then
       rm -f "${pax}"
     fi
 
-    if $setactive; then
-      if [ -L "$baseinstalldir/$name/${name}" ]; then
-        printVerbose "Removing old symlink '$baseinstalldir/$name/${name}'"
-        rm -f "$baseinstalldir/$name/${name}"
+    if ${setactive}; then
+      if [ -L "${baseinstalldir}/${name}/${name}" ]; then
+        printVerbose "Removing old symlink '${baseinstalldir}/${name}/${name}'"
+        rm -f "${baseinstalldir}/${name}/${name}"
       fi
-      if ! ln -s "$baseinstalldir/$installdirname" "$baseinstalldir/$name/${name}"; then
+      if ! ln -s "${baseinstalldir}/${installdirname}" "${baseinstalldir}/${name}/${name}"; then
         printError "Could not create symbolic link name"
-      fi 
-    fi 
+      fi
+    fi
 
     printVerbose "Adding version '${downloadFileVer}' to info file"
     # Add file version information as a .releaseinfo file
-    echo "$downloadFileVer" > "${baseinstalldir}/$installdirname/.releaseinfo"
+    echo "${downloadFileVer}" > "${baseinstalldir}/${installdirname}/.releaseinfo"
 
     # Check for a .version file from the pax - if present good, if not
     # generate one from the file name as the tag isn't granular enough to really
     # be used in dependency checks
-    if [ ! -f "${baseinstalldir}/$installdirname/.version" ]; then
-      echo "$downloadFileVer" > "${baseinstalldir}/$installdirname/.version"
+    if [ ! -f "${baseinstalldir}/${installdirname}/.version" ]; then
+      echo "${downloadFileVer}" > "${baseinstalldir}/${installdirname}/.version"
     fi
 
-    printVerbose "Adding releaseline '$installedReleaseLine' metadata to ${baseinstalldir}/$installdirname/.releaseline"
-    echo "$installedReleaseLine" > "${baseinstalldir}/$installdirname/.releaseline"
+    printVerbose "Adding releaseline '${installedReleaseLine}' metadata to ${baseinstalldir}/${installdirname}/.releaseline"
+    echo "${installedReleaseLine}" > "${baseinstalldir}/${installdirname}/.releaseline"
 
-    if $setactive; then
-      if ! $nosymlink; then
-        mergeIntoSystem "$name" "${baseinstalldir}/$installdirname" "$ZOPEN_ROOTFS" 
+    if ${setactive}; then
+      if ! ${nosymlink}; then
+        mergeIntoSystem "${name}" "${baseinstalldir}/${installdirname}" "${ZOPEN_ROOTFS}"
         misrc=$?
-        printVerbose "The merge completed with: $misrc"
+        printVerbose "The merge completed with: ${misrc}"
       fi
 
       printInfo "- Checking for env file"
       if [ -f ${baseinstalldir}/${name}/${name}/.env -o -f ${baseinstalldir}/${name}/${name}/.appenv ]; then
         printInfo "- .env file found, adding to profiled processing"
-        mkdir -p "$ZOPEN_ROOTFS/etc/profiled/$name"
-        cat << EOF > "$ZOPEN_ROOTFS/etc/profiled/$name/dotenv"
+        mkdir -p "${ZOPEN_ROOTFS}/etc/profiled/${name}"
+        cat << EOF > "${ZOPEN_ROOTFS}/etc/profiled/${name}/dotenv"
 curdir=\$(pwd)
-cd "$baseinstalldir/$name/$name" >/dev/null 2>&1
+cd "${baseinstalldir}/${name}/${name}" >/dev/null 2>&1
 # If .appenv exists, source it as it's quicker
 if [ -f ".appenv" ]; then
   . ./.appenv
@@ -420,23 +421,23 @@ EOF
         cd "${baseinstalldir}/${name}/${name}" && ./setup.sh
       fi
     fi
-    if $unInstallOldVersion; then
+    if ${unInstallOldVersion}; then
       printVerbose "New version merged; checking for orphaned files from previous version"
       # This will remove any old symlinks or dirs that might have changed in an upgrade
       # as the merge process overwrites existing files to point to different version
-      unsymlinkFromSystem "$name" "$ZOPEN_ROOTFS" "$currentlinkfile"
+      unsymlinkFromSystem "${name}" "${ZOPEN_ROOTFS}" "${currentlinkfile}"
     fi
 
-    if $setactive; then
+    if ${setactive}; then
       printVerbose "Marking this version as installed"
       touch "${baseinstalldir}/${name}/${name}/.active"
-      installedList="$name $installedList"
-      syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_INSTALL,$CAT_PACKAGE" "DOWNLOAD" "handlePackageInstall" "Installed package:'$name';version:$downloadFileVer;install_dir='$baseinstalldir/$installdirname';"
+      installedList="${name} ${installedList}"
+      syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_INSTALL},${CAT_PACKAGE}" "DOWNLOAD" "handlePackageInstall" "Installed package:'${name}';version:${downloadFileVer};install_dir='${baseinstalldir}/${installdirname}';"
     fi
 
-    if $doNotInstallDeps; then
-        printInfo "- Skipping dependency installation"
-    elif $reinstall; then
+    if ${doNotInstallDeps}; then
+      printInfo "- Skipping dependency installation"
+    elif ${reinstall}; then
       printVerbose "- Reinstalling so no dependency reinstall (unless explicitly listed)"
     else
       printInfo "- Checking for runtime dependencies"
@@ -445,32 +446,32 @@ EOF
         dependencies=$(cat "${baseinstalldir}/${name}/${name}/.runtimedeps")
       fi
       printVerbose "Checking for runtime dependencies from the git metadata"
-      if echo "$statusline" | grep "Runtime Dependencies:" >/dev/null; then
-        gitmetadependencies="$(echo "$statusline" | sed -e "s#.*Runtime Dependencies:<\/b> ##" -e "s#<br />.*##")"
-        if [ ! "$gitmetadependencies" = "No dependencies" ]; then
-          dependencies="$dependencies $gitmetadependencies"
+      if echo "${statusline}" | grep "Runtime Dependencies:" > /dev/null; then
+        gitmetadependencies="$(echo "${statusline}" | sed -e "s#.*Runtime Dependencies:<\/b> ##" -e "s#<br />.*##")"
+        if [ ! "${gitmetadependencies}" = "No dependencies" ]; then
+          dependencies="${dependencies} ${gitmetadependencies}"
         fi
       fi
-      dependencies=$(deleteDuplicateEntries "$dependencies" " ")
-      if [ ! "x" = "x$dependencies" ]; then
-        printInfo "- $name depends on: $dependencies"
+      dependencies=$(deleteDuplicateEntries "${dependencies}" " ")
+      if [ -n "${dependencies}" ]; then
+        printInfo "- ${name} depends on: ${dependencies}"
         printInfo "- Installing dependencies"
-        installDependencies "$name" "$dependencies"
+        installDependencies "${name}" "${dependencies}"
       else
         printInfo "- No runtime dependencies found"
       fi
     fi
-    printInfo "${NC}${GREEN}Successfully installed $name${NC}"
+    printInfo "${NC}${GREEN}Successfully installed ${name}${NC}"
   fi # (download only)
 }
 
 installPorts()
 (
   ports="$1"
-  printVerbose "Ports to install: $ports"
-  echo "$ports" | xargs | tr ' ' '\n' | while read port; do
+  printVerbose "Ports to install: ${ports}"
+  echo "${ports}" | xargs | tr ' ' '\n' | while read port; do
     mutexReq "zopen" "zopen"
-    handlePackageInstall "$port"
+    handlePackageInstall "${port}"
     mutexFree "zopen"
   done
 )
@@ -495,87 +496,87 @@ yesToPrompts=false
 chosenRepos=""
 while [ $# -gt 0 ]; do
   case "$1" in
-    "-u" | "--update" | "-update" | "-upgrade" | "--upgrade")
-      upgradeInstalled=true  # Upgrade packages
-      ;;
-    "-r" | "-reinstall" | "--reinstall")
-      reinstall=true  # If package already installed, reinstall
-      ;;
-    "--install-or-upgrade")
-      installOrUpgrade=true  # Upgrade package or install if not present
-      ;;
-    "--local-install")
-      localInstall=true # Install the package into current directory
-      ;;
-    "--no-symlink")
-      nosymlink=true  # Do not mesh the package into the file system; leave as stand-alone
-      ;;
-    "--no-deps")
-      doNotInstallDeps=true
-      ;;
-    "--cache-only")
-      cacheOnly=true  # Download remote pax file to cache only (no install)
-      ;;
-    "--release-line")
-      shift
-      releaseLine=$(echo "$1" | awk '{print toupper($0)}')
-      ;;
-    "--yes" | "-y")
-      yesToPrompts=true  # Automatically answer 'yes' to any questions
-      ;;
-    "--download-only")
-      downloadOnly=true  # Download remote pax file to current directory only
-      ;;
-    "--no-set-active")
-      setactive=false  # Install package as normal but keep existing installation as active
-      ;;
-    "--skip-upgrade")
-      skipupgrade=true  # Do not upgrade any packages
-      ;;
-    "--all")
-      all=true  # Install all packages
-      ;;
-    "--select")
-      selectVersion=true  # Display a selction table to allow version picking
-      ;;
-    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
-      printSyntax "${args}"
-      exit 0
-      ;;
-    "--debug")
-      verbose=true
-      debug=true
-      ;;
-    "-v" | "--v" | "-verbose" | "--verbose")
-      verbose=true
-      ;;
-    "--version")
-      zopen --version $ME
-      exit 0
-      ;;
-    *)
-      chosenRepos="$chosenRepos $1";
-      ;;
+  "-u" | "--update" | "-update" | "-upgrade" | "--upgrade")
+    upgradeInstalled=true # Upgrade packages
+    ;;
+  "-r" | "-reinstall" | "--reinstall")
+    reinstall=true # If package already installed, reinstall
+    ;;
+  "--install-or-upgrade")
+    installOrUpgrade=true # Upgrade package or install if not present
+    ;;
+  "--local-install")
+    localInstall=true # Install the package into current directory
+    ;;
+  "--no-symlink")
+    nosymlink=true # Do not mesh the package into the file system; leave as stand-alone
+    ;;
+  "--no-deps")
+    doNotInstallDeps=true
+    ;;
+  "--cache-only")
+    cacheOnly=true # Download remote pax file to cache only (no install)
+    ;;
+  "--release-line")
+    shift
+    releaseLine=$(echo "$1" | awk '{print toupper($0)}')
+    ;;
+  "--yes" | "-y")
+    yesToPrompts=true # Automatically answer 'yes' to any questions
+    ;;
+  "--download-only")
+    downloadOnly=true # Download remote pax file to current directory only
+    ;;
+  "--no-set-active")
+    setactive=false # Install package as normal but keep existing installation as active
+    ;;
+  "--skip-upgrade")
+    skipupgrade=true # Do not upgrade any packages
+    ;;
+  "--all")
+    all=true # Install all packages
+    ;;
+  "--select")
+    selectVersion=true # Display a selction table to allow version picking
+    ;;
+  "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+    printSyntax "${args}"
+    exit 0
+    ;;
+  "--debug")
+    verbose=true
+    debug=true
+    ;;
+  "-v" | "--v" | "-verbose" | "--verbose")
+    verbose=true
+    ;;
+  "--version")
+    zopen --version ${ME}
+    exit 0
+    ;;
+  *)
+    chosenRepos="${chosenRepos} $1"
+    ;;
   esac
-  shift;
+  shift
 done
 
 if [ -z "${chosenRepos}" ]; then
-  if ! $all && ! $upgradeInstalled; then
+  if ! ${all} && ! ${upgradeInstalled}; then
     printInfo "No ports selected for installation"
     exit 4
   fi
-  if $upgradeInstalled; then
+  if ${upgradeInstalled}; then
     printVerbose "No specific port to upgrade, upgrade all installed packages"
     printInfo "- Querying for installed packages"
     progressHandler "spinner" "- Query complete" &
     ph=$!
-    killph="kill -HUP $ph"
-    addCleanupTrapCmd "$killph"
+    killph="kill -HUP ${ph}"
+    addCleanupTrapCmd "${killph}"
     chosenRepos="$(${MYDIR}/zopen-query list --installed --no-header --no-versions)"
-    $killph 2>/dev/null  # if the timer is not running, the kill will fail
-  elif $all; then
-    if ! $yesToPrompts; then
+    ${killph} 2> /dev/null # if the timer is not running, the kill will fail
+  elif ${all}; then
+    if ! ${yesToPrompts}; then
       printInfo "Enter 'all' to confirm full installation [takes a long time so be sure!]:"
       confirmall=$(getInput)
       if [ ! "xall" = "x${confirmall}" ]; then
@@ -591,29 +592,29 @@ export SSL_CERT_FILE="${ZOPEN_CA}"
 export GIT_SSL_CAINFO="${ZOPEN_CA}"
 export CURL_CA_BUNDLE="${ZOPEN_CA}"
 
-if $downloadOnly; then
-  downloadDir="$PWD"
-  printVerbose "Downloading pax to current directory '$downloadDir'"
-elif $localInstall; then
-  downloadDir="$PWD"
-  printVerbose "Installing to current directory '$downloadDir'"
+if ${downloadOnly}; then
+  downloadDir="${PWD}"
+  printVerbose "Downloading pax to current directory '${downloadDir}'"
+elif ${localInstall}; then
+  downloadDir="${PWD}"
+  printVerbose "Installing to current directory '${downloadDir}'"
 else
-  printVerbose "Installing to zopen file system: $ZOPEN_ROOTFS"
-  if [ -z "$ZOPEN_ROOTFS" ]; then
+  printVerbose "Installing to zopen file system: ${ZOPEN_ROOTFS}"
+  if [ -z "${ZOPEN_ROOTFS}" ]; then
     printError "Unable to locate zopen file system, \$ZOPEN_ROOTFS is undefined"
   fi
-  downloadDir="$ZOPEN_ROOTFS/var/cache/zopen"
+  downloadDir="${ZOPEN_ROOTFS}/var/cache/zopen"
 fi
 
 if [ ! -d "${downloadDir}" ]; then
   mkdir -p "${downloadDir}"
   if [ $? -gt 0 ]; then
-    printError "Could not create download directory: $downloadDir"
+    printError "Could not create download directory: ${downloadDir}"
   fi
 fi
 
 if [ -n "${downloadDir}" ] && [ -d "${downloadDir}" ]; then
-  cd "${downloadDir}"
+  cd "${downloadDir}" || exit
 fi
 
 printVerbose "Working directory: ${downloadDir}"
@@ -621,36 +622,36 @@ printVerbose "Working directory: ${downloadDir}"
 printInfo "- Querying remote repo for latest package information"
 getReposFromGithub
 grfgRc=$?
-$killph 2>/dev/null  # if the timer is not running, the kill will fail
-[ 0 -ne $grfgRc ] && exit $grfgRc;
+${killph} 2> /dev/null # if the timer is not running, the kill will fail
+[ 0 -ne "${grfgRc}" ] && exit "${grfgRc}"
 
 foundPort=false
 installArray=""
 
-if $all; then
+if ${all}; then
   for repo in $(echo ${repo_results}); do
-    installArray="$installArray $repo"
+    installArray="${installArray} ${repo}"
   done
-  installArray=$(strtrim "$installArray")
+  installArray=$(strtrim "${installArray}")
 else
   for chosenRepo in $(echo "${chosenRepos}" | tr ',' '\n'); do
-    printVerbose "Processing repo: $chosenrepo"
+    printVerbose "Processing repo: ${chosenrepo}"
     printVerbose "Stripping any version (%), tag (#) or port suffixes"
-    toolrepo=$(echo "$chosenRepo" | sed -e 's#%.*##' -e 's#=.*##' -e 's#.*port##')
+    toolrepo=$(echo "${chosenRepo}" | sed -e 's#%.*##' -e 's#=.*##' -e 's#.*port##')
     printVerbose "Adding prefix and 'port' suffix" # quicker than testing for presence!
-    toolfound=$(echo "${repo_results}" | awk -vtoolrepo="$toolrepo" '$0 == toolrepo {print}') 
-    if [ "$toolfound" = "$toolrepo" ]; then
-      printVerbose "Adding '$chosenRepo' to the install queue"
-      installArray="$installArray $chosenRepo"
+    toolfound=$(echo "${repo_results}" | awk -vtoolrepo="${toolrepo}" '$0 == toolrepo {print}')
+    if [ "${toolfound}" = "${toolrepo}" ]; then
+      printVerbose "Adding '${chosenRepo}' to the install queue"
+      installArray="${installArray} ${chosenRepo}"
       printVerbose "Removing valid port from input list"
-      chosenRepos=$(echo "$chosenRepos" | sed -e "s#$chosenRepo##")
+      chosenRepos=$(echo "${chosenRepos}" | sed -e "s#${chosenRepo}##")
     fi
   done
 fi
 printVerbose "Checking whether any ports remain in the input list"
-chosenRepos=$(strtrim "$chosenRepos")
-if [ -n "$chosenRepos" ]; then
-  printError "The following requested port(s) do not exist:\n\t$(echo $chosenRepos | tr -s '[:space:]')"
+chosenRepos=$(strtrim "${chosenRepos}")
+if [ -n "${chosenRepos}" ]; then
+  printError "The following requested port(s) do not exist:\n\t$(echo ${chosenRepos} | tr -s '[:space:]')"
 fi
 
-installPorts "$installArray"
+installPorts "${installArray}"
diff --git a/bin/zopen-md2man b/bin/zopen-md2man
index 7ec48418c..5d9e08a0c 100755
--- a/bin/zopen-md2man
+++ b/bin/zopen-md2man
@@ -7,14 +7,14 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
@@ -29,7 +29,7 @@ if [[ $# -eq 1 ]]; then
     printSyntax
     exit 0
   elif [ "x$1" = "x--version" ]; then
-    zopen --version $ME
+    zopen --version ${ME}
     exit 0
   else
     echo "Unrecognized option $1. Processing terminated" >&2
@@ -45,10 +45,10 @@ zopen_date=$(date "+%B %d %Y")
 mandir="${MYDIR}/man1" ## may want this elsewhere
 
 for mdf in "${curdir}"/*.md; do
-	bf=$(basename $mdf)
-	zopen_tool=${bf%%.md}
+  bf=$(basename ${mdf})
+  zopen_tool=${bf%%.md}
 
-header="---
+  header="---
 title: ${zopen_tool}
 section: 1
 header: User Manual
@@ -56,7 +56,7 @@ footer: ${zopen_version}
 date: ${zopen_date}
 ---
 "
-	body=$(cat ${mdf})
-	manfile="${mandir}/${zopen_tool}.1.gz"
-	echo "${header}${body}" | pandoc -s -f markdown -t man | gzip >${manfile}
+  body=$(cat ${mdf})
+  manfile="${mandir}/${zopen_tool}.1.gz"
+  echo "${header}${body}" | pandoc -s -f markdown -t man | gzip > ${manfile}
 done
diff --git a/bin/zopen-migrate-buildenv b/bin/zopen-migrate-buildenv
index af08c055c..4b8ddf036 100755
--- a/bin/zopen-migrate-buildenv
+++ b/bin/zopen-migrate-buildenv
@@ -8,14 +8,14 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
diff --git a/bin/zopen-migrate-groovy b/bin/zopen-migrate-groovy
index 180d6a9db..e02c2c509 100755
--- a/bin/zopen-migrate-groovy
+++ b/bin/zopen-migrate-groovy
@@ -10,14 +10,14 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
@@ -54,7 +54,7 @@ node('linux')
   stage ('Poll') {
                // Poll from upstream:
                checkout([
-                       $class: 'GitSCM',
+                       ${class}: 'GitSCM',
                        branches: [[name: '*/...']],
                        doGenerateSubmoduleConfigurations: false,
                        extensions: [],
@@ -77,6 +77,5 @@ ${description}
 }
 "
 
-echo "${dev}" >cicd-dev.groovy
-echo "${stable}" >cicd-stable.groovy
-
+echo "${dev}" > cicd-dev.groovy
+echo "${stable}" > cicd-stable.groovy
diff --git a/bin/zopen-query b/bin/zopen-query
index b6e88744c..8bb2cd970 100755
--- a/bin/zopen-query
+++ b/bin/zopen-query
@@ -5,26 +5,26 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
-printSyntax() 
+printSyntax()
 {
   args=$*
   echo "zopen query is a utility for z/OS Open Tools to query packages and repos." >&2
   echo "Syntax: zopen-query [<option>]* [<package]*" >&2
   echo "  where <option> may be one or more of:" >&2
-  echo "  --help: print this help"  >&2
-  echo "  --version: print version"  >&2
-  echo "  --list: list all available z/OS Open Tools."  >&2
+  echo "  --help: print this help" >&2
+  echo "  --version: print version" >&2
+  echo "  --list: list all available z/OS Open Tools." >&2
   echo "  --remote-search: regex match package against available z/OS Open Tools" >&2
   echo "  -i : --installed: list install z/OS Open Tools." >&2
   echo " --upgradeable: list packages where an upgrade is available." >&2
@@ -33,26 +33,27 @@ printSyntax()
   echo "  -d | --details: include full details for listings." >&2
   echo "  --no-header: suppress the header for the output." >&2
   echo "  --no-version:  suppress version information, return package names." >&2
-  echo "  --filter <color>: apply filter based on quality (green - all tests passing, blue - most tests passing, yellow - some tests passing, red - no tests passing, or skipped (no filter by default))"  >&2
+  echo "  --filter <color>: apply filter based on quality (green - all tests passing, blue - most tests passing, yellow - some tests passing, red - no tests passing, or skipped (no filter by default))" >&2
   echo " and <package> is an optional list of one or more packages." >&2
 }
 
-colorizepct(){
+colorizepct()
+{
   percentage=$1
-  if [ -z "$percentage" ]; then
+  if [ -z "${percentage}" ]; then
     colored="${RED}"
-  elif [ ! "$percentage" = "${percentage#Skipped}" ]; then
+  elif [ ! "${percentage}" = "${percentage#Skipped}" ]; then
     colored="${RED}"
-  elif [ $percentage -eq 100 ]; then
+  elif [ ${percentage} -eq 100 ]; then
     colored="${GREEN}"
-  elif [ $percentage -gt 50 ]; then
+  elif [ ${percentage} -gt 50 ]; then
     colored="${BLUE}"
-  elif [ $percentage -gt 0 ]; then
+  elif [ ${percentage} -gt 0 ]; then
     colored="{YELLOW}"
   else
     colored="${RED}"
   fi
-  echo "$colored"
+  echo "${colored}"
 }
 
 printDetailListEntries()
@@ -61,32 +62,32 @@ printDetailListEntries()
   needle=$2
   onlyUpgradesAvailable=$3
 
-  if [ "$details" -eq 0 ]; then
+  if [ "${details}" -eq 0 ]; then
     scrcols=$(getScreenCols)
     numcols=4
-    colwidth=$((scrcols / numcols -1 ))
-    printVerbose "Screen width: $scrcols; colwidth:$colwidth"
-    if [ ! -z "$1" ] && ! $noheader; then
+    colwidth=$((scrcols / numcols - 1))
+    printVerbose "Screen width: ${scrcols}; colwidth:${colwidth}"
+    if [ ! -z "$1" ] && ! ${noheader}; then
       printf "${NC}${UNDERLINE}%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s${NC}\n" "Package" "Installed" "Available" "Latest Tag"
     fi
-    echo "$repoArray" | xargs | tr ' ' '\n' | sort | while read repo; do
+    echo "${repoArray}" | xargs | tr ' ' '\n' | sort | while read repo; do
       listport=false
-      if [ -z "$needle" ]; then
+      if [ -z "${needle}" ]; then
         listport=true
       else
-        printVerbose "Attempting regex find with needle: '$needle'"
-        if expr "$repo" : "$needle" 1>/dev/null; then
+        printVerbose "Attempting regex find with needle: '${needle}'"
+        if expr "${repo}" : "${needle}" 1> /dev/null; then
           listport=true
         fi
       fi
-    
-      if $listport; then
-        latest=$(jq -e -r '.release_data."'$repo'"[0]' "$JSON_CACHE")
+
+      if ${listport}; then
+        latest=$(jq -e -r '.release_data."'${repo}'"[0]' "${JSON_CACHE}")
         if [ $? -ne 0 ]; then
           printError "Unable to retrieve remote information"
         fi
-        latestVersion=$(/bin/printf "%s" "$latest" | jq -e -r '.assets[0].name' | sed -E 's/.*-(.*)\.zos\.pax\.Z/\1/')
-        pkghome="$ZOPEN_PKGINSTALL/${repo}/${repo}"
+        latestVersion=$(/bin/printf "%s" "${latest}" | jq -e -r '.assets[0].name' | sed -E 's/.*-(.*)\.zos\.pax\.Z/\1/')
+        pkghome="${ZOPEN_PKGINSTALL}/${repo}/${repo}"
         if [ -e "${pkghome}/.releaseinfo" ]; then
           originalVersion=$(cat "${pkghome}/.releaseinfo")
         else
@@ -97,109 +98,112 @@ printDetailListEntries()
         else
           dotversion="N/A"
         fi
-        if [ "$onlyUpgradesAvailable" -gt 0 ]; then
-          if [ "$originalVersion" = "Not installed" -o "$originalVersion" = "$latestVersion" ]; then
-            continue;
-          fi 
+        if [ "${onlyUpgradesAvailable}" -gt 0 ]; then
+          if [ "${originalVersion}" = "Not installed" -o "${originalVersion}" = "${latestVersion}" ]; then
+            continue
+          fi
         fi
-        if ! $noversions; then
-          printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s\n" "$repo" "$originalVersion" "$dotversion" "$latestVersion"
+        if ! ${noversions}; then
+          printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s\n" "${repo}" "${originalVersion}" "${dotversion}" "${latestVersion}"
         else
-          printf "%s\n" "$repo"
+          printf "%s\n" "${repo}"
         fi
-      fi 
+      fi
     done
   else
-    printVerbose "Checking repoArray: $repoArray"
+    printVerbose "Checking repoArray: ${repoArray}"
     scrcols=$(getScreenCols)
     numcols=6
-    colwidth=$((scrcols / numcols -1 ))
-    printVerbose "Screen width: $scrcols; colwidth:$colwidth"
-    if ! $noheader; then
+    colwidth=$((scrcols / numcols - 1))
+    printVerbose "Screen width: ${scrcols}; colwidth:${colwidth}"
+    if ! ${noheader}; then
       printf "${NC}${UNDERLINE}%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s${NC}\n" "Package" "Installed" "Latest Tag" "Download Size" "Expanded Size" "Quality"
     fi
-    echo "$repoArray" | xargs | tr ' ' '\n' | sort | while read repo; do
+    echo "${repoArray}" | xargs | tr ' ' '\n' | sort | while read repo; do
       listport=false
-      if [ -z "$needle" ]; then
+      if [ -z "${needle}" ]; then
         listport=true
       else
-        printVerbose "Attempting regex find with needle: '$needle'"
-        if expr "$repo" : "$needle" 1>/dev/null; then
+        printVerbose "Attempting regex find with needle: '${needle}'"
+        if expr "${repo}" : "${needle}" 1> /dev/null; then
           listport=true
         fi
       fi
-    
-      if $listport; then
-        pkghome="$ZOPEN_PKGINSTALL/${repo}/${repo}"
+
+      if ${listport}; then
+        pkghome="${ZOPEN_PKGINSTALL}/${repo}/${repo}"
         if [ -e "${pkghome}/.releaseinfo" ]; then
           originalTag=$(cat "${pkghome}/.releaseinfo")
         else
           originalTag="Not installed"
         fi
-        latest=$(jq -e -r '.release_data."'$repo'"[0]' "$JSON_CACHE")
+        latest=$(jq -e -r '.release_data."'${repo}'"[0]' "${JSON_CACHE}")
         case $? in
-          1) printVerbose "No latest release for port";
-               printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s ${NC}${RED}%-${colwidth}s${NC}\n" "$repo" "$originalTag" "Unknown" "Unknown" "Unknown" "Unknown" 
-               ;;
-          0) printVerbose "Latest release request successful";  
-               latestTag="$(/bin/printf "%s" "$latest" | jq -e -r '.tag_name')"
-               passed="$(/bin/printf "%s" "$latest" | jq -e -r '.assets[0].passed_tests')"
-               total="$(/bin/printf "%s" "$latest" | jq -e -r '.assets[0].total_tests')"
-               expandedsize="$(/bin/printf "%s" "$latest" | jq -e -r '.assets[0].expanded_size')"
-               downloadsize="$(/bin/printf "%s" "$latest" | jq -e -r '.assets[0].size')"
-               if [ "$onlyUpgradesAvailable" -gt 0 ]; then
-                 if [ "$originalTag" = "Not installed" -o "$originalTag" = "$latestTag" ]; then
-                   continue;
-                 fi 
-               fi
-               if [ $total -gt 0 ]; then
-                 percentage=$(echo "scale=0; 100 * ($passed) / $total" | bc)
-               fi
-               printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s " "$repo" "$originalTag" "$latestTag" 
-               printf " %-${colwidth}s"  "$downloadsize"
-               printf " %-${colwidth}s"  "$expandedsize"
+        1)
+          printVerbose "No latest release for port"
+          printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s ${NC}${RED}%-${colwidth}s${NC}\n" "${repo}" "${originalTag}" "Unknown" "Unknown" "Unknown" "Unknown"
+          ;;
+        0)
+          printVerbose "Latest release request successful"
+          latestTag="$(/bin/printf "%s" "${latest}" | jq -e -r '.tag_name')"
+          passed="$(/bin/printf "%s" "${latest}" | jq -e -r '.assets[0].passed_tests')"
+          total="$(/bin/printf "%s" "${latest}" | jq -e -r '.assets[0].total_tests')"
+          expandedsize="$(/bin/printf "%s" "${latest}" | jq -e -r '.assets[0].expanded_size')"
+          downloadsize="$(/bin/printf "%s" "${latest}" | jq -e -r '.assets[0].size')"
+          if [ "${onlyUpgradesAvailable}" -gt 0 ]; then
+            if [ "${originalTag}" = "Not installed" -o "${originalTag}" = "${latestTag}" ]; then
+              continue
+            fi
+          fi
+          if [ ${total} -gt 0 ]; then
+            percentage=$(echo "scale=0; 100 * (${passed}) / ${total}" | bc)
+          fi
+          printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s " "${repo}" "${originalTag}" "${latestTag}"
+          printf " %-${colwidth}s" "${downloadsize}"
+          printf " %-${colwidth}s" "${expandedsize}"
 
-               if [ -z "$percentage" ]; then
-                 printf "${NC}${RED}%-${colwidth}s${NC}" "No tests"
-               else
-                 printf "${NC}%s%-${colwidth}s${NC}" "$(colorizepct "$percentage" )" "$percentage%"
-               fi
-               printf "\n"
-               ;;
-          *) printError "Error while trying to retrieve latest repo release";;
+          if [ -z "${percentage}" ]; then
+            printf "${NC}${RED}%-${colwidth}s${NC}" "No tests"
+          else
+            printf "${NC}%s%-${colwidth}s${NC}" "$(colorizepct "${percentage}")" "${percentage}%"
+          fi
+          printf "\n"
+          ;;
+        *) printError "Error while trying to retrieve latest repo release" ;;
         esac
 
       fi
-      continue;   
+      continue
     done
   fi
   exit 0
 }
-printInstalledEntries(){
+printInstalledEntries()
+{
   scrcols=$(getScreenCols)
-  [ $details -eq 0 ] && numcols=4 || numcols=6
-  colwidth=$(($scrcols / $numcols -1 ))
-  printVerbose "Screen width: $scrcols; colwidth:$colwidth"
-  if [ ! -z "$1" ] && ! $noheader; then
-    if [ $details -eq 0 ]; then
+  [ "${details}" -eq 0 ] && numcols=4 || numcols=6
+  colwidth=$((${scrcols} / ${numcols} - 1))
+  printVerbose "Screen width: ${scrcols}; colwidth:${colwidth}"
+  if [ ! -z "$1" ] && ! ${noheader}; then
+    if [ "${details}" -eq 0 ]; then
       printf "${NC}${UNDERLINE}%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s${NC}\n" "Package" "Installed" "File" "Releaseline"
     else
       printf "${NC}${UNDERLINE}%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s${NC}\n" "Package" "Installed" "File" "Releaseline" "Expanded Size" "Quality"
     fi
   fi
   printVerbose "Getting list of symlinks in the package install directory (that point to specific versions)"
-  installedPackages=$(cd "$ZOPEN_PKGINSTALL" && zosfind . -type l)
-  printVerbose "Packages: $installedPackages"
-  echo "$installedPackages" | xargs | tr ' ' '\n' | sort | while read repo; do
+  installedPackages=$(cd "${ZOPEN_PKGINSTALL}" && zosfind . -type l)
+  printVerbose "Packages: ${installedPackages}"
+  echo "${installedPackages}" | xargs | tr ' ' '\n' | sort | while read repo; do
     repo="${repo##*/}"
-    pkghome="$ZOPEN_PKGINSTALL/${repo}/${repo}"
+    pkghome="${ZOPEN_PKGINSTALL}/${repo}/${repo}"
     if [ ! -e "${pkghome}/.active" ]; then
-      printVerbose "Symlink '$repo' in '$ZOPEN_PKGINSTALL' is not active; skipping"
+      printVerbose "Symlink '${repo}' in '${ZOPEN_PKGINSTALL}' is not active; skipping"
       continue
     fi
 
-    if $noversions; then
-      printf "%s\n" "$repo"
+    if ${noversions}; then
+      printf "%s\n" "${repo}"
       continue
     fi
 
@@ -218,56 +222,57 @@ printInstalledEntries(){
     if [ -e "${pkghome}/.releaseline" ]; then
       releaseline=$(cat "${pkghome}/.releaseline")
     fi
-    if [ -z "$releaseline" ]; then
+    if [ -z "${releaseline}" ]; then
       releaseline="n/a"
     fi
-  
-    printVerbose "Original tag: $originalTag for repo: $repo"
+
+    printVerbose "Original tag: ${originalTag} for repo: ${repo}"
     if [ -z "$1" ]; then
-      printInfo "$originalTag"
+      printInfo "${originalTag}"
     else
-      fileversion="$( cd "$ZOPEN_PKGINSTALL/${repo}/${repo}" >/dev/null 2>&1 && pwd -P | xargs basename)"
-      printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s" "$repo" "$dotversion" "$fileversion" "$releaseline"
-      if [ $details -eq 1 ]; then
+      fileversion="$(cd "${ZOPEN_PKGINSTALL}/${repo}/${repo}" > /dev/null 2>&1 && pwd -P | xargs basename)"
+      printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s" "${repo}" "${dotversion}" "${fileversion}" "${releaseline}"
+      if [ "${details}" -eq 1 ]; then
         # Extra headers: disk size and quality
-        disksizestr=$(du "$ZOPEN_PKGINSTALL/${repo}" |tail -n 1 )
-        disksizestr=$(echo $disksizestr | sed 's#\([0-9]*\).*#\1#')
-        disksize=$(( $disksizestr * 512 ))
-        printf "%-${colwidth}d" $disksize
+        disksizestr=$(du "${ZOPEN_PKGINSTALL}/${repo}" | tail -n 1)
+        disksizestr=$(echo ${disksizestr} | sed 's#\([0-9]*\).*#\1#')
+        disksize=$((${disksizestr} * 512))
+        printf "%-${colwidth}d" "${disksize}"
 
         if [ -e "${pkghome}/test.status" ]; then
           teststatus=$(cat "${pkghome}/test.status")
-          percentage=$(echo "$teststatus" | sed 's/[^-]*-\([^%\.]*\).*/\1/')
-          printf "${NC}$s%-${colwidth}s${NC}" "$(colorizepct "$percentage")" "$percentage"
+          percentage=$(echo "${teststatus}" | sed 's/[^-]*-\([^%\.]*\).*/\1/')
+          printf "${NC}${s}%-${colwidth}s${NC}" "$(colorizepct "${percentage}")" "${percentage}"
         else
-           printf "${NC}${RED}%-${colwidth}s${NC}" "No tests"
+          printf "${NC}${RED}%-${colwidth}s${NC}" "No tests"
         fi
       fi
-      
+
       printf "\n"
     fi
   done
   exit 0
 }
 
-whatProvides(){
+whatProvides()
+{
   needle="$1"
-  printVerbose "Finding matches outside of ZOPEN_PKGINSTALL ($ZOPEN_PKGINSTALL)"
+  printVerbose "Finding matches outside of ZOPEN_PKGINSTALL (${ZOPEN_PKGINSTALL})"
   # Find any symlinks that match the needle and can then be dereferenced
-  found=$(zosfind "$ZOPEN_ROOTFS" -name "$ZOPEN_PKGINSTALL/\*" -prune -o -type l -print | grep "${needle}") 
-  printVerbose "Found list: '$found'"
-  if [[ -z "$found" ]]; then
+  found=$(zosfind "${ZOPEN_ROOTFS}" -name "${ZOPEN_PKGINSTALL}/\*" -prune -o -type l -print | grep "${needle}")
+  printVerbose "Found list: '${found}'"
+  if [[ -z "${found}" ]]; then
     printInfo "No package provides '${needle}'"
   else
-    matches=$(echo "$found"| wc -w | tr -d ' ' ) 
-    printInfo "Found ${matches} match$([ $matches = 1 ] && echo "" || echo "es") for regex '${needle}' on the system"
-    echo "$found" | xargs | tr ' ' '\n' | while read foundmatch; do
-      printVerbose "Parsing '$foundmatch'"
-      if [ ! -d "$foundmatch" ]; then
-      dereferenced=$(deref "$foundmatch")
-      fullpackage=$(echo "$dereferenced" | sed "s#$ZOPEN_PKGINSTALL/\([^/]*\).*#\1#")
-      
-      printInfo "Package '$fullpackage' provides: '$foundmatch'"
+    matches=$(echo "${found}" | wc -w | tr -d ' ')
+    printInfo "Found ${matches} match$([ ${matches} = 1 ] && echo "" || echo "es") for regex '${needle}' on the system"
+    echo "${found}" | xargs | tr ' ' '\n' | while read foundmatch; do
+      printVerbose "Parsing '${foundmatch}'"
+      if [ ! -d "${foundmatch}" ]; then
+        dereferenced=$(deref "${foundmatch}")
+        fullpackage=$(echo "${dereferenced}" | sed "s#${ZOPEN_PKGINSTALL}/\([^/]*\).*#\1#")
+
+        printInfo "Package '${fullpackage}' provides: '${foundmatch}'"
       fi
     done
   fi
@@ -290,66 +295,66 @@ fi
 while [[ $# -gt 0 ]]; do
   printVerbose "Parsing option: $1"
   case "$1" in
-    "--list")
-      list=1;
-      localoption=false;
-      ;;
-    "-i" | "--installed")
-      localoption=true;
-      installed=1;
-      list=;
+  "--list")
+    list=1
+    localoption=false
+    ;;
+  "-i" | "--installed")
+    localoption=true
+    installed=1
+    list=
+    ;;
+  "-wp" | "--whatprovides")
+    localoption=true
+    whatprovides=1
+    shift
+    [ ! -z $1 ] || printError "Missing file argument"
+    needle=$1
+    ;;
+  "--remote-search")
+    localoption=false
+    remotesearch=1
+    shift
+    [ ! -z $1 ] || printError "Missing package argument"
+    needle=$1
     ;;
-    "-wp" | "--whatprovides")
-      localoption=true;
-      whatprovides=1;
-      shift;
-      [ ! -z $1 ] || printError "Missing file argument";
-      needle=$1;
+  "--no-header")
+    noheader=true
     ;;
-    "--remote-search")
-      localoption=false;
-      remotesearch=1;
-      shift;
-      [ ! -z $1 ] || printError "Missing package argument";
-      needle=$1;
+  "--upgradeable")
+    upgradeable=true
     ;;
-    "--no-header")
-      noheader=true;
+  "--no-versions")
+    noversions=true
+    noheader=true # headers do not mean anything without versions!
     ;;
-    "--upgradeable")
-      upgradeable=true;
+  "-f" | "--filter")
+    filter=$2
+    shift
     ;;
-    "--no-versions")
-      noversions=true;
-      noheader=true; # headers do not mean anything without versions!
+  "-d" | "--details")
+    details=1
     ;;
-    "-f" | "--filter")
-      filter=$2;
-      shift
-      ;;
-    "-d"  | "--details")
-      details=1;
+  "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+    printSyntax "${args}"
+    exit 0
+    ;;
+  "--version")
+    zopen --version ${ME}
+    exit 0
+    ;;
+  "-v" | "--v" | "-verbose" | "--verbose")
+    verbose=true
+    ;;
+  -*)
+    printError "Unknown option '$1'"
+    ;;
+
+  *)
+    chosenRepos="${chosenRepos} $1"
     ;;
-    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
-      printSyntax "${args}"
-      exit 0
-      ;;
-    "--version")
-      zopen --version $ME
-      exit 0
-      ;;
-    "-v" | "--v" | "-verbose" | "--verbose")
-      verbose=true
-      ;;
-    -*)
-      printError "Unknown option '$1'"
-      ;;
-     
-    *)
-      chosenRepos="$chosenRepos $1";
-      ;;
   esac
-  shift;
+  shift
 done
 
 checkIfConfigLoaded
@@ -358,24 +363,24 @@ export SSL_CERT_FILE="${ZOPEN_CA}"
 export GIT_SSL_CAINFO="${ZOPEN_CA}"
 export CURL_CA_BUNDLE="${ZOPEN_CA}"
 
-if [ ! -z "$filter" ]; then
-  filter=$(echo "$filter" | awk '{print tolower($0)}')
-  case "$filter" in
-      blue|green|yellow|red|skipped) ;;
-      *) printError "The filter must be one of blue|green|yellow|red"
+if [ ! -z "${filter}" ]; then
+  filter=$(echo "${filter}" | awk '{print tolower($0)}')
+  case "${filter}" in
+  blue | green | yellow | red | skipped) ;;
+  *) printError "The filter must be one of blue|green|yellow|red" ;;
   esac
 fi
 
-if ! $localoption; then
+if ! ${localoption}; then
   # Retrieve all repositories
   getReposFromGithub
   grfgRc=$?
-  [ 0 -ne $grfgRc ] && exit $grfgRc;
-  repoArray="$repo_results"
+  [ 0 -ne "${grfgRc}" ] && exit "${grfgRc}"
+  repoArray="${repo_results}"
 fi
 
-! $upgradeable || printDetailListEntries $details "" 1
-[ -z "$remotesearch" ] || printDetailListEntries $details "$needle" 0
-[ -z "$list" ] || printDetailListEntries $details "" 0
-[ -z "$installed" ] || printInstalledEntries $details "" 0
-[ -z "$whatprovides" ] || whatProvides "$needle"
+! ${upgradeable} || printDetailListEntries "${details}" "" 1
+[ -z "${remotesearch}" ] || printDetailListEntries "${details}" "${needle}" 0
+[ -z "${list}" ] || printDetailListEntries "${details}" "" 0
+[ -z "${installed}" ] || printInstalledEntries "${details}" "" 0
+[ -z "${whatprovides}" ] || whatProvides "${needle}"
diff --git a/bin/zopen-remove b/bin/zopen-remove
index 4b2ee2e64..9eeceb285 100755
--- a/bin/zopen-remove
+++ b/bin/zopen-remove
@@ -5,70 +5,71 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 checkWritable
 
-printSyntax() 
+printSyntax()
 {
   args=$*
   echo "zopen remove is a utility to remove installed z/OS Open Tools packages."
   echo "Syntax: zopen remove [<option>]* <package, ...>" >&2
   echo "  where <option> may be one or more of:" >&2
-  echo "  --help: print this help"  >&2
-  echo "  --version: print version"  >&2
-  echo "  -p|--purge: remove package, the versioned directory and any cached file"  >&2
+  echo "  --help: print this help" >&2
+  echo "  --version: print version" >&2
+  echo "  -p|--purge: remove package, the versioned directory and any cached file" >&2
   echo "  -v: run in verbose mode" >&2
   echo "  and <package> is a list of one or more projects to uninstall" >&2
 }
 
-removePackages(){
+removePackages()
+{
   pkglist=$*
 
-  echo "$pkglist" | xargs | tr ' ' '\n' | sort | while read pkg; do
-    printHeader "Removing package: $pkg"
-    printInfo "- Checking status of package '$pkg'"
-    if [ ! -f $ZOPEN_PKGINSTALL/$pkg/$pkg/.active ]; then 
-      printInfo "${NC}${YELLOW}Package '$pkg' is not installed${NC}"
+  echo "${pkglist}" | xargs | tr ' ' '\n' | sort | while read pkg; do
+    printHeader "Removing package: ${pkg}"
+    printInfo "- Checking status of package '${pkg}'"
+    if [ ! -f ${ZOPEN_PKGINSTALL}/${pkg}/${pkg}/.active ]; then
+      printInfo "${NC}${YELLOW}Package '${pkg}' is not installed${NC}"
     else
       printInfo "- Package installed, unmeshing from system"
       version="unknown"
-      if [ -e "${ZOPEN_PKGINSTALL}/${pkg}/$pkg/.releaseinfo" ]; then
-        version=$(cat "${ZOPEN_PKGINSTALL}/${pkg}/$pkg/.releaseinfo")
+      if [ -e "${ZOPEN_PKGINSTALL}/${pkg}/${pkg}/.releaseinfo" ]; then
+        version=$(cat "${ZOPEN_PKGINSTALL}/${pkg}/${pkg}/.releaseinfo")
       fi
 
-      if [ -e "$ZOPEN_PKGINSTALL/$pkg/$pkg" ]; then
-        deref=$(cd "$ZOPEN_PKGINSTALL/$pkg/$pkg" && pwd -P | awk -F/ '{ print $(NF)}')
-        installedlinksfile="$ZOPEN_PKGINSTALL/$pkg/$deref/.links"
-        if $purge; then
+      if [ -e "${ZOPEN_PKGINSTALL}/${pkg}/${pkg}" ]; then
+        deref=$(cd "${ZOPEN_PKGINSTALL}/${pkg}/${pkg}" && pwd -P | awk -F/ '{ print $(NF)}')
+        installedlinksfile="${ZOPEN_PKGINSTALL}/${pkg}/${deref}/.links"
+        if ${purge}; then
           printInfo "- Purging package"
           printVerbose "Checking if we are currently in a directory that is to be purged"
-          [ "${PWD##$ZOPEN_PKGINSTALL/$pkg/$pkg}" != "$PWD" ] && cd $ZOPEN_PKGINSTALL
-          rm -rf $(cd "$ZOPEN_PKGINSTALL/$pkg/$pkg" && pwd -P)
-          syslog $ZOPEN_LOG_PATH/audit.log $LOG_A "$CAT_PACKAGE,$CAT_REMOVE" "REMOVE" "removePackage" "Purging package:'${needle};version:$version;"
+          [ "${PWD##"${ZOPEN_PKGINSTALL}"/"${pkg}"/"${pkg}"}" != "${PWD}" ] && cd ${ZOPEN_PKGINSTALL} || exit
+          rm -rf $(cd "${ZOPEN_PKGINSTALL}/${pkg}/${pkg}" && pwd -P)
+          syslog ${ZOPEN_LOG_PATH}/audit.log ${LOG_A} "${CAT_PACKAGE},${CAT_REMOVE}" "REMOVE" "removePackage" "Purging package:'${needle};version:${version};"
         else
           printInfo "- Removing metadata file to mark uninstall"
-          rm -f "$ZOPEN_PKGINSTALL/$pkg/$pkg/.active"
+          rm -f "${ZOPEN_PKGINSTALL}/${pkg}/${pkg}/.active"
           printInfo "- Breaking link from current to versioned"
-          rm -f "$ZOPEN_PKGINSTALL/$pkg/$pkg"
+          rm -f "${ZOPEN_PKGINSTALL}/${pkg}/${pkg}"
         fi
         printVerbose "Main symlink removed, removing dangling symlinks"
-        unsymlinkFromSystem "$pkg" "$ZOPEN_ROOTFS" "$installedlinksfile"
+        unsymlinkFromSystem "${pkg}" "${ZOPEN_ROOTFS}" "${installedlinksfile}"
       fi
 
       printInfo "- Removing profiled entry"
-      [ -d "$ZOPEN_ROOTFS/etc/profiled/$pkg" ] && rm -rf "$ZOPEN_ROOTFS/etc/profiled/$pkg"
+      [ -d "${ZOPEN_ROOTFS}/etc/profiled/${pkg}" ] && rm -rf "${ZOPEN_ROOTFS}/etc/profiled/${pkg}"
 
-      syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_PACKAGE,$CAT_REMOVE" "REMOVE" "removePackage" "Removed package:'${needle};version:$version;"
-      printInfo "${NC}${GREEN}Successfully removed: $pkg${NC}"
+      syslog "${ZOPEN_LOG_PATH}/audit.log" "${LOG_A}" "${CAT_PACKAGE},${CAT_REMOVE}" "REMOVE" "removePackage" "Removed package:'${needle};version:${version};"
+      printInfo "${NC}${GREEN}Successfully removed: ${pkg}${NC}"
     fi
   done
 }
@@ -81,28 +82,28 @@ purge=false
 chosenRepos=""
 while [[ $# -gt 0 ]]; do
   case "$1" in
-    "-p" | "--purge")
-      purge=true
-      ;;
-    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
-      printSyntax "${args}"
-      exit 0
-      ;;
-    "--version")
-      zopen --version $ME
-      exit 0
-      ;;
-    "-v" | "--v" | "-verbose" | "--verbose")
-      verbose=true
-      ;;
-    *)
-      chosenRepos="$chosenRepos $1";
-      ;;
+  "-p" | "--purge")
+    purge=true
+    ;;
+  "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+    printSyntax "${args}"
+    exit 0
+    ;;
+  "--version")
+    zopen --version ${ME}
+    exit 0
+    ;;
+  "-v" | "--v" | "-verbose" | "--verbose")
+    verbose=true
+    ;;
+  *)
+    chosenRepos="${chosenRepos} $1"
+    ;;
   esac
-  shift;
+  shift
 done
 
-[[ ! -z "$chosenRepos" ]] || printError "No packages selected for removal" 
+[[ ! -z "${chosenRepos}" ]] || printError "No packages selected for removal"
 mutexReq "zopen" "zopen"
-removePackages "$chosenRepos"
+removePackages "${chosenRepos}"
 mutexFree "zopen"
diff --git a/bin/zopen-split-patch b/bin/zopen-split-patch
index 596521293..a4c6308c8 100755
--- a/bin/zopen-split-patch
+++ b/bin/zopen-split-patch
@@ -4,14 +4,14 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
@@ -26,7 +26,7 @@ if [ "x$1" = "x--help" ]; then
   printSyntax
   exit 0
 elif [ "x$1" = "x--version" ]; then
-  zopen --version $ME
+  zopen --version ${ME}
   exit 0
 fi
 
@@ -34,12 +34,12 @@ if [ $# -lt 1 ]; then
   exit 4
 fi
 
-if ! mkdir -p "${pd}" ; then
+if ! mkdir -p "${pd}"; then
   printf 'Unable to create patch directory: %s. No patch files created\n' "${pd}" >&2
   exit 8
 fi
 
-for aggregate in $@ ; do
+for aggregate in $@; do
   info=$(grep -n '^diff --git' "${aggregate}")
   lastline=$(wc -l "$1" | awk '{ print $1; }')
   lines=$(printf "%s" "${info}" | awk -F: ' { print $1; }')
@@ -56,24 +56,24 @@ for aggregate in $@ ; do
   start=''
   i=-1
   printf '%s\n' "${lines}" | while IFS= read -r end; do
-    if [ "x${start}" != "x" ]; then
+    if [ -n "${start}"" ]; then
       af="${file[i]}.patch"
       d=$(dirname "${af}")
       rf=$(basename "${af}")
-      if ! mkdir -p "${pd}/${d}" ; then
+      if ! mkdir -p "${pd}/${d}"; then
         printf 'Unable to create directory %s. Partial splitting has been performed under %s', "${d}" "${pd}" >&2
         exit 8
       fi
       #printf "%s/%s/%s %d %d\n" "${pd}" "${d}" "${rf}" "${start}" "${end}"
-      taillines=$((end-start))
-      headlines=$((end-1))
+      taillines=$((end - start))
+      headlines=$((end - 1))
       content=$(head -n "${headlines}" "${aggregate}" | tail -n "${taillines}")
-      if ! printf '%s\n' "${content}" >"${pd}/${d}/${rf}" ; then
+      if ! printf '%s\n' "${content}" > "${pd}/${d}/${rf}"; then
         printf 'Unable to write patch file to %s. Partial splitting has been performed under %s', "${pd}/${d}/${rf}" "${pd}" >&2
         exit 8
       fi
     fi
     start="${end}"
-    i=$((i+1))
+    i=$((i + 1))
   done
 done
diff --git a/bin/zopen-update-cacert b/bin/zopen-update-cacert
index 1ab1dbd5a..bf893afdc 100755
--- a/bin/zopen-update-cacert
+++ b/bin/zopen-update-cacert
@@ -7,36 +7,36 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 checkWritable
 
 # Temporary files
-for tmp in "$TMPDIR" "$TMP" /tmp
-do
-  if [ ! -z "$tmp" ] && [ -d "$tmp" ]; then
-    TEMP_CACERT="$tmp/$LOGNAME.$RANDOM.cacert.pem"
+for tmp in "${TMPDIR}" "${TMP}" /tmp; do
+  if [ ! -z "${tmp}" ] && [ -d "${tmp}" ]; then
+    TEMP_CACERT="${tmp}/${LOGNAME}.${RANDOM}.cacert.pem"
     break
   fi
 done
 
-cleanupOnExit() {
-    rv=$?
-    [ -f "$TEMP_CACERT" ] && rm -rf "$TEMP_CACERT"
-    exit $rv
+cleanupOnExit()
+{
+  rv=$?
+  [ -f "${TEMP_CACERT}" ] && rm -rf "${TEMP_CACERT}"
+  exit "${rv}"
 }
 
 trap "cleanupOnExit" EXIT INT TERM QUIT HUP
 
-printHelp() 
+printHelp()
 {
   args=$*
   echo "zopen-update-cacert:"
@@ -60,48 +60,47 @@ getCACertFromCurl()
   printVerbose "Using $(type curl)"
   printVerbose "Downloading ${cacert_update_url}"
   nocertverify=""
-  if [ ! -f "$SSL_CERT_FILE" ]; then
+  if [ ! -f "${SSL_CERT_FILE}" ]; then
     printVerbose "No cacert file present"
-    if $insecureFallback; then 
+    if ${insecureFallback}; then
       printWarning "Using insecure fallback"
       nocertverify="-k "
     fi
   fi
   curlver="$(type curl)"
   crc=$?
-  [ $crc -ne 0 ] && printError "Could not locate curl to download certificate."
+  [ "${crc}" -ne 0 ] && printError "Could not locate curl to download certificate."
 
-  printVerbose "Type of curl: $curlver"
-  if ! curlCmd -L $nocertverify -o "$TEMP_CACERT" ${cacert_update_url}  ; then
+  printVerbose "Type of curl: ${curlver}"
+  if ! curlCmd -L ${nocertverify} -o "${TEMP_CACERT}" "${cacert_update_url}"; then
     printError "curl command could not download from: ${cacert_update_url}"
   fi
 
-  if [ ! -f "$TEMP_CACERT" ]; then
-    printError "$TEMP_CACERT was not downloaded"
+  if [ ! -f "${TEMP_CACERT}" ]; then
+    printError "${TEMP_CACERT} was not downloaded"
   fi
 }
 
 updateCACert()
 {
-  printInfo "Re-creating $ZOPEN_CA"
-  cp "$TEMP_CACERT" "$ZOPEN_CA"
+  printInfo "Re-creating ${ZOPEN_CA}"
+  cp "${TEMP_CACERT}" "${ZOPEN_CA}"
 }
 
 # Main code start here
 verbose=false
-export default_dir="$( cd "${MYDIR}/../" && pwd -P )"
+export default_dir="$(cd "${MYDIR}/../" && pwd -P)"
 export cacert_update_url="https://curl.se/ca/cacert.pem"
 
 # Temporary files
-for tmp in "$TMPDIR" "$TMP" /tmp
-do
-  if [ ! -z "$tmp" ] && [ -d "$tmp" ]; then
-    TEMP_CACERT="$tmp/$LOGNAME.$RANDOM.cacert.pem"
+for tmp in "${TMPDIR}" "${TMP}" /tmp; do
+  if [ ! -z "${tmp}" ] && [ -d "${tmp}" ]; then
+    TEMP_CACERT="${tmp}/${LOGNAME}.${RANDOM}.cacert.pem"
     break
   fi
 done
 
-if [ -z "$TEMP_CACERT" ]; then
+if [ -z "${TEMP_CACERT}" ]; then
   printError "Could not find a temporary write location in \$TMPDIR, \$TMP, or /tmp"
 fi
 
@@ -111,40 +110,40 @@ forceUpdate=false
 insecureFallback=false
 while [[ $# -gt 0 ]]; do
   case "$1" in
-    "-f" | "-force" | "--force")
-      forceUpdate=true;
-      ;;
-    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+  "-f" | "-force" | "--force")
+    forceUpdate=true
+    ;;
+  "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+    printHelp "${args}"
+    exit 0
+    ;;
+  "--version")
+    zopen --version ${ME}
+    exit 0
+    ;;
+  "-i" | "--insecure-fallback")
+    insecureFallback=true
+    ;;
+  "-v" | "--v" | "-verbose" | "--verbose")
+    verbose=true
+    ;;
+  *)
+    if [ "${1#-*}" = "$1" ]; then
+      dir="$1"
+    else
+      echo "Unknown option: $1"
       printHelp "${args}"
-      exit 0
-      ;;
-    "--version")
-      zopen --version $ME
-      exit 0
-      ;;
-    "-i" | "--insecure-fallback")
-      insecureFallback=true
-      ;;
-    "-v" | "--v" | "-verbose" | "--verbose")
-      verbose=true
-      ;;
-    *)
-      if [ "${1#-*}" = "$1" ]; then
-        dir="$1"
-      else
-        echo "Unknown option: $1"
-        printHelp "${args}"
-        exit 8
-      fi
-      ;;
+      exit 8
+    fi
+    ;;
   esac
-  shift;
+  shift
 done
 
 ZOPEN_CA="${dir}/cacert.pem"
 
 if ! [ -r "${ZOPEN_CA}" ]; then
-  forceUpdate=true 
+  forceUpdate=true
 fi
 
 printHeader "Getting latest CA Certificate"
@@ -154,21 +153,20 @@ if ! getCACertFromCurl; then
   fi
 fi
 
-
-if $forceUpdate; then
+if ${forceUpdate}; then
   updateCACert
-elif ! diff "$TEMP_CACERT" "$ZOPEN_CA" >/dev/null; then
+elif ! diff "${TEMP_CACERT}" "${ZOPEN_CA}" > /dev/null; then
   while true; do
-    printWarning "Your local cacert '$ZOPEN_CA' is outdated or does not exist. Would you like to update it? (y, n)"
+    printWarning "Your local cacert '${ZOPEN_CA}' is outdated or does not exist. Would you like to update it? (y, n)"
     update=$(getInput)
-    if [ "$update" = "n" ]; then
+    if [ "${update}" = "n" ]; then
       exit 0
-    elif [ "$update" = "y" ]; then
+    elif [ "${update}" = "y" ]; then
       break
     fi
   done
 
   updateCACert
 else
-  printInfo "Your cacert '$ZOPEN_CA' is already up to date"
+  printInfo "Your cacert '${ZOPEN_CA}' is already up to date"
 fi
diff --git a/bin/zopen-version b/bin/zopen-version
index 3964a94ce..911e9d12d 100755
--- a/bin/zopen-version
+++ b/bin/zopen-version
@@ -4,22 +4,22 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
 printSyntax()
 {
-  echo "$ME prints version information for ${package}"
-  echo "Usage: $ME [OPTION] tool"
-  echo "   or: $ME [OPTION]"
+  echo "${ME} prints version information for ${package}"
+  echo "Usage: ${ME} [OPTION] tool"
+  echo "   or: ${ME} [OPTION]"
   echo "Syntax: zopen-version [OPTIONS]"
   echo "where OPTIONS can be:"
   echo "  --help: print this help"
diff --git a/bin/zopen-versions b/bin/zopen-versions
index 9c0d04bea..2aab1ffb5 100755
--- a/bin/zopen-versions
+++ b/bin/zopen-versions
@@ -4,14 +4,14 @@
 #
 setupMyself()
 {
-        ME=$(basename $0)
-        MYDIR="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
-        INCDIR="${MYDIR}/../include"
-        if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
-                echo "Internal Error. Unable to find common.sh file to source" >&2
-                exit 8
-        fi
-        . "${INCDIR}/common.sh"
+  ME=$(basename $0)
+  MYDIR="$(cd "$(dirname "$0")" > /dev/null 2>&1 && pwd -P)"
+  INCDIR="${MYDIR}/../include"
+  if ! [ -d "${INCDIR}" ] && ! [ -f "${INCDIR}/common.sh" ]; then
+    echo "Internal Error. Unable to find common.sh file to source" >&2
+    exit 8
+  fi
+  . "${INCDIR}/common.sh"
 }
 setupMyself
 
@@ -31,7 +31,7 @@ if [[ $# -eq 1 ]]; then
     printSyntax
     exit 0
   elif [ "x$1" = "x--version" ]; then
-    zopen --version $ME
+    zopen --version ${ME}
     exit 0
   else
     echo "Unrecognized option $1. Processing terminated" >&2
@@ -41,17 +41,17 @@ if [[ $# -eq 1 ]]; then
 fi
 
 if [ $# -eq 0 ]; then
-  root="$HOME/zopen/prod"
+  root="${HOME}/zopen/prod"
 else
   root="$1"
 fi
 
 if [ -d "${root}" ]; then
   echo "Using ${root} for determining z/OS tarball versions" >&2
-else 
+else
   if [ "x${root}" = "x-?" ] || [ "x${root}" = "x-help" ]; then
     :
-  else 
+  else
     echo "Unable to find ${root} for determining z/OS tarball versions" >&2
   fi
   syntax
@@ -69,23 +69,22 @@ else
 fi
 
 version_files=$(find "${root}" -name ".version")
-brew_version_info=$(curl https://formulae.brew.sh/formula/ 2>/dev/null | grep '<td>')
+brew_version_info=$(curl https://formulae.brew.sh/formula/ 2> /dev/null | grep '<td>')
 for rawtool in ${tools}; do
   tool=${rawtool%%port}
   version_file=$(echo "${version_files}" | grep "${tool}-" | head -n 1)
-  if [ "x${version_file}" = "x" ]; then
+  if [ -z "${version_file}" ]; then
     :
     #echo "No version file for ${tool}. ${tool} skipped" >&2
   else
     version="$(cat ${version_file})"
     brew_line=$(echo "${brew_version_info}" | grep -n ">${tool}<" | awk -F: '{print $1}')
-    if [ "x${brew_line}" = "x" ]; then
+    if [ -z "${brew_line}" ]; then
       brew_version="unknown"
     else
-      next_brew_line=$((brew_line+1))
+      next_brew_line=$((brew_line + 1))
       brew_version=$(echo "${brew_version_info}" | sed -n "${next_brew_line}p" | awk -F '<|>' '{print $3}')
     fi
     echo "${tool} zos-version ${version} brew-version ${brew_version}"
   fi
 done
-
diff --git a/include/common.sh b/include/common.sh
index 5d1cc9b5d..6d7b3cd58 100755
--- a/include/common.sh
+++ b/include/common.sh
@@ -6,16 +6,16 @@ export ZOPEN_CLEANUP="stty echo" # set this as a default to ensure line visibili
 addCleanupTrapCmd()
 {
   newCmd=$(echo "$1" | sed -e 's/^[ ]*//' -e 's/[ ]*$//')
-  if [ -z "$ZOPEN_CLEANUP" ]; then
-    export ZOPEN_CLEANUP="$newCmd"
+  if [ -z "${ZOPEN_CLEANUP}" ]; then
+    export ZOPEN_CLEANUP="${newCmd}"
   else
-    export ZOPEN_CLEANUP="$(deleteDuplicateEntriesRedux "$ZOPEN_CLEANUP; $newCmd" ";")"
+    export ZOPEN_CLEANUP="$(deleteDuplicateEntriesRedux "${ZOPEN_CLEANUP}; ${newCmd}" ";")"
   fi
 }
 
-cleanupFunction() 
+cleanupFunction()
 {
-  [ -n "$ZOPEN_CLEANUP" ] && $(eval "$ZOPEN_CLEANUP" 2>/dev/null)
+  [ -n "${ZOPEN_CLEANUP}" ] && $(eval "${ZOPEN_CLEANUP}" 2> /dev/null)
   trap - EXIT INT TERM QUIT HUP
   unset ZOPEN_CLEANUP
 }
@@ -24,18 +24,18 @@ trap "cleanupFunction" EXIT INT TERM QUIT HUP
 isPackageActive()
 {
   pkg="$1"
-  printDebug "Checking if '$pkg' is installed and active"
-  installedPackage=$(cd "$ZOPEN_PKGINSTALL" && zosfind . -name ".active" | grep "/$pkg/")
+  printDebug "Checking if '${pkg}' is installed and active"
+  installedPackage=$(cd "${ZOPEN_PKGINSTALL}" && zosfind . -name ".active" | grep "/${pkg}/")
   cmdrc=$?
   # Return 1 for true/Package is Active, 0 for false/Package is not active
-  [ $cmdrc -eq 0 ] && return 1 || return 0
+  [ "${cmdrc}" -eq 0 ] && return 1 || return 0
 }
 
 curlCmd()
 {
-  # Take the list of parameters and concat them with  
+  # Take the list of parameters and concat them with
   # any custom parameters the user requires in ZOPEN_CURL_PARAMS
-  curl $ZOPEN_CURL_PARAMS $*
+  curl ${ZOPEN_CURL_PARAMS} $*
 }
 
 validateReleaseLine()
@@ -52,21 +52,21 @@ validateReleaseLine()
 deref()
 {
   testpath="$1"
-  if [ -L "$testpath" ]; then
-    child=$(basename "$testpath")
-    symlink=$(ls -l "$testpath" | sed 's/.*-> \(.*\)/\1/')
-    parent=$(dirname "$testpath")
-    relpath="$parent/$symlink"
-    relparent=$(dirname "$relpath")
-    abspath=$(cd "$relparent" && pwd -P)
-    testpath="$abspath/$child"
-    deref "$testpath"
+  if [ -L "${testpath}" ]; then
+    child=$(basename "${testpath}")
+    symlink=$(ls -l "${testpath}" | sed 's/.*-> \(.*\)/\1/')
+    parent=$(dirname "${testpath}")
+    relpath="${parent}/${symlink}"
+    relparent=$(dirname "${relpath}")
+    abspath=$(cd "${relparent}" && pwd -P)
+    testpath="${abspath}/${child}"
+    deref "${testpath}"
   else
-    [ -n "$testpath" ] && echo "$testpath" && unset testpath
+    [ -n "${testpath}" ] && echo "${testpath}" && unset testpath
   fi
 }
 
-defineANSI() 
+defineANSI()
 {
   # Standard tty codes
   ESC="\047"
@@ -89,7 +89,7 @@ defineANSI()
     UNDERLINE="${esc}[4m"
     NC="${esc}[0m"
   else
-# unset esc RED GREEN YELLOW BOLD UNDERLINE NC
+    # unset esc RED GREEN YELLOW BOLD UNDERLINE NC
 
     esc=''
     BLACK=''
@@ -111,17 +111,17 @@ ansiline()
   deltax=$1
   deltay=$2
   echostr=$3
-  if [ $deltax -gt 0 ]; then
-    echostr="${ESC}[${deltax}A$echostr"
-  elif [ $deltax -lt 0 ]; then
-    echostr="${ESC}[$(expr $deltax \* -1)A$echostr"
+  if [ ${deltax} -gt 0 ]; then
+    echostr="${ESC}[${deltax}A${echostr}"
+  elif [ ${deltax} -lt 0 ]; then
+    echostr="${ESC}[$(expr ${deltax} \* -1)A${echostr}"
   fi
-  if [ $deltay -gt 0 ]; then
-    echostr="${ESC}[${deltax}C$echostr"
-  elif [ $deltay -lt 0 ]; then
-    echostr="${ESC}[$(expr $deltax \* -1)D$echostr"
+  if [ ${deltay} -gt 0 ]; then
+    echostr="${ESC}[${deltax}C${echostr}"
+  elif [ ${deltay} -lt 0 ]; then
+    echostr="${ESC}[$(expr ${deltax} \* -1)D${echostr}"
   fi
- /bin/echo "${echostr}"
+  /bin/echo "${echostr}"
 
 }
 
@@ -142,14 +142,14 @@ zosfind()
   /bin/find $*
 }
 
-findrev() 
+findrev()
 {
   haystack="$1"
   needle="$2"
-  while [[ "$haystack" != "" && "$haystack" != "/" && "$haystack" != "./" && ! -e "$haystack/$needle" ]]; do
+  while [[ "${haystack}" != "" && "${haystack}" != "/" && "${haystack}" != "./" && ! -e "${haystack}/${needle}" ]]; do
     haystack=${haystack%/*}
   done
-  echo "$haystack"
+  echo "${haystack}"
 }
 
 strtrim()
@@ -161,7 +161,7 @@ defineEnvironment()
 {
   # Required for proper operation of z/OS auto-conversion support
   export _BPXK_AUTOCVT=ON
-  export _CEE_RUNOPTS="$_CEE_RUNOPTS FILETAG(AUTOCVT,AUTOTAG) POSIX(ON)"
+  export _CEE_RUNOPTS="${_CEE_RUNOPTS} FILETAG(AUTOCVT,AUTOTAG) POSIX(ON)"
   export _TAG_REDIR_ERR=txt
   export _TAG_REDIR_IN=txt
   export _TAG_REDIR_OUT=txt
@@ -193,48 +193,51 @@ printColors()
 mutexReq()
 {
   mutex=$1
-  lockdir="$ZOPEN_ROOTFS/var/lock"
-  [ -e lockdir ] || mkdir -p $lockdir
-  mutex="$lockdir/$mutex"
+  lockdir="${ZOPEN_ROOTFS}/var/lock"
+  [ -e lockdir ] || mkdir -p ${lockdir}
+  mutex="${lockdir}/${mutex}"
   mypid=$(exec sh -c 'echo $PPID')
-  if [ -e "$mutex" ]; then
-    lockedpid=$(cat $mutex)
-    { [ ! "$lockedpid" = "$mypid" ] && [ ! "$lockedpid" = "$PPID" ]; } && kill -0 "$lockedpid" 2>/dev/null && echo "Aborting, Active process '$lockedpid' holds the '$2' lock: '$mutex'" && exit -1
+  if [ -e "${mutex}" ]; then
+    lockedpid=$(cat ${mutex})
+    {
+      [ ! "${lockedpid}" = "${mypid}" ] && [ ! "${lockedpid}" = "${PPID}" ]
+    } && kill -0 "${lockedpid}" 2> /dev/null && echo "Aborting, Active process '${lockedpid}' holds the '$2' lock: '${mutex}'" && exit -1
   fi
-  addCleanupTrapCmd "rm -rf $mutex"
-  echo "$mypid" > $mutex
+  addCleanupTrapCmd "rm -rf ${mutex}"
+  echo "${mypid}" > ${mutex}
 }
 
 mutexFree()
 {
   mutex=$1
-  lockdir="$ZOPEN_ROOTFS/var/lock"
-  mutex="$lockdir/$mutex"
-  [ -e "$mutex" ] && rm -f $mutex
+  lockdir="${ZOPEN_ROOTFS}/var/lock"
+  mutex="${lockdir}/${mutex}"
+  [ -e "${mutex}" ] && rm -f ${mutex}
 }
 
-relativePath2(){
+relativePath2()
+{
   sourcePath=$1
   targetPath=$2
-  currentIFS="$IFS"
+  currentIFS="${IFS}"
   IFS="/"
   relativePath=''
-  set -- $targetPath
-  for elem in $sourcePath; do
-      if [ -z "$relativePath" ]; then
-        if [ "$1" = "$elem" ]; then
-            shift
-            continue
-        else
-          relativePath="../$elem"
-        fi
+  set -- ${targetPath}
+  for elem in ${sourcePath}; do
+    if [ -z "${relativePath}" ]; then
+      if [ "$1" = "${elem}" ]; then
+        shift
+        continue
       else
-        if [ -z "$1" ]; then
-          relativePath="$relativePath/$elem"
-        else
-          relativePath="../$relativePath/$elem"
-        fi
+        relativePath="../${elem}"
       fi
+    else
+      if [ -z "$1" ]; then
+        relativePath="${relativePath}/${elem}"
+      else
+        relativePath="../${relativePath}/${elem}"
+      fi
+    fi
     if [ $# -gt 0 ]; then
       shift
     fi
@@ -242,95 +245,95 @@ relativePath2(){
   # if the target is longer than the source, there might be some additional
   # elements in the shifted $0 to append
   if [ $# -gt 0 ]; then
-     relativePath=$relativePath/$(echo $* | sed "s/ /\//g")
+    relativePath=${relativePath}/$(echo $* | sed "s/ /\//g")
   fi
-  IFS="$currentIFS"
-  echo "$relativePath"
+  IFS="${currentIFS}"
+  echo "${relativePath}"
 }
 
 # Merges a package directory's symlinks into the main zopen root filesystem
 mergeIntoSystem()
 {
-  name=$1          # Name of the package being processed
-  versioneddir=$2  # The directory where the unpax occurred
+  name=$1         # Name of the package being processed
+  versioneddir=$2 # The directory where the unpax occurred
   rootfs="$3"
   rebaseusr="$4"
 
-  [ -z "$rebaseusr" ] && rebaseusr="usr/local"
+  [ -z "${rebaseusr}" ] && rebaseusr="usr/local"
 
-  currentDir="$PWD"
-  targetdir="$rootfs/$rebaseusr"     # The main rootfs/usr location
+  currentDir="${PWD}"
+  targetdir="${rootfs}/${rebaseusr}" # The main rootfs/usr location
 
   printDebug "Calculating the offset path to store from root"
-  offset=$(dirname "${versioneddir#$rootfs/}")
-  version=$(basename $versioneddir)
+  offset=$(dirname "${versioneddir#"${rootfs}"/}")
+  version=$(basename ${versioneddir})
   tmptime=$(date +%Y%m%d%H%M%S)
-  processingDir="$rootfs/tmp/zopen.$tmptime"
-  printDebug "Temporary processing dir evaluated to: $processingDir"
+  processingDir="${rootfs}/tmp/zopen.${tmptime}"
+  printDebug "Temporary processing dir evaluated to: ${processingDir}"
 
-  virtualStore="$processingDir/$offset"
-  printDebug "Creating virtual store at: $virtualStore"
-  mkdir -p "$virtualStore"
+  virtualStore="${processingDir}/${offset}"
+  printDebug "Creating virtual store at: ${virtualStore}"
+  mkdir -p "${virtualStore}"
 
   printDebug "Moving from main store location (unpax-dir) to processing store"
-  mv "$versioneddir" "$virtualStore"
+  mv "${versioneddir}" "${virtualStore}"
 
   printDebug "Creating main linked directory in store"
-  $(cd "$virtualStore" && ln -s "$version" "$name")
+  $(cd "${virtualStore}" && ln -s "${version}" "${name}")
 
   printDebug "Creating virtual root directory structure"
-  mkdir -p "$processingDir/$rebaseusr"
+  mkdir -p "${processingDir}/${rebaseusr}"
 
   printDebug "Generating relative symlinks in processing location"
-  relpath=$(relativePath2 "$virtualStore/$name" "$processingDir/$rebaseusr")
-  [ "$relpath" = "/" ] && printError "Relative path calculated as root directory itself!?!"
+  relpath=$(relativePath2 "${virtualStore}/${name}" "${processingDir}/${rebaseusr}")
+  [ "${relpath}" = "/" ] && printError "Relative path calculated as root directory itself!?!"
 
   printDebug "Generating symlink tree"
-  
+
   printDebug "Creating directory structure"
-  curdir="$PWD"
-  cd "$virtualStore/$name"
-   # since 'ln *' doesn't invoke globbing to allow multiple files at once,
-   # abuse the Recurse option; this results in "already exists" errors but 
-   # ignore them as the first call should generate the correct link but 
-   # subsequent calls would generate a symlink that has incorrect dereferencing 
-   # and ignoring them is actually faster than individually creating the links!
+  curdir="${PWD}"
+  cd "${virtualStore}/${name}" || exit
+  # since 'ln *' doesn't invoke globbing to allow multiple files at once,
+  # abuse the Recurse option; this results in "already exists" errors but
+  # ignore them as the first call should generate the correct link but
+  # subsequent calls would generate a symlink that has incorrect dereferencing
+  # and ignoring them is actually faster than individually creating the links!
   zosfind . -type d | sort -r | while read dir; do
-    dir=$(echo "$dir" | sed "s#^./##")
-    printDebug "Processing dir: $dir" 
-    [ $dir = "." ] && continue;
-    mkdir -p "$processingDir/$rebaseusr/$dir"
-    cd "$processingDir/$rebaseusr/$dir"
-    dirrelpath=$(relativePath2 "$virtualStore/$name/$dir" "$processingDir/$rebaseusr/$dir")
-    ln -Rs "$dirrelpath/" "." 2>/dev/null
-  done 
+    dir=$(echo "${dir}" | sed "s#^./##")
+    printDebug "Processing dir: ${dir}"
+    [ ${dir} = "." ] && continue
+    mkdir -p "${processingDir}/${rebaseusr}/${dir}"
+    cd "${processingDir}/${rebaseusr}/${dir}" || exit
+    dirrelpath=$(relativePath2 "${virtualStore}/${name}/${dir}" "${processingDir}/${rebaseusr}/${dir}")
+    ln -Rs "${dirrelpath}/" "." 2> /dev/null
+  done
 
   printDebug "Moving unpaxed processing-directory back to main rootfs store"
   # this *must* be done before the merge step below or relative symlinks can't
   # work
-  versioneddirname=$(basename "$versioneddir")
-  mv "$virtualStore/$versioneddirname" "$rootfs/$offset"
+  versioneddirname=$(basename "${versioneddir}")
+  mv "${virtualStore}/${versioneddirname}" "${rootfs}/${offset}"
+
+  tarfile="${name}.usr.tar"
+  printDebug "Merge symlinks into main filesystem using tmp tar file ${tarfile}"
 
-  tarfile="$name.usr.tar"
-  printDebug "Merge symlinks into main filesystem using tmp tar file $tarfile"
-  
   printDebug "Generating intermediary tar file"
   # Need '-S' to allow long symlinks
-  $(cd "$processingDir" && tar -S -cf "$tarfile" "usr")
+  $(cd "${processingDir}" && tar -S -cf "${tarfile}" "usr")
 
   printDebug "Generating listing for remove processing (including main symlink)"
-  listing=$(tar tf "$processingDir/$tarfile" 2>/dev/null| sort -r)
-  echo "Installed files:" > "$versioneddir/.links"
-  echo "$listing" >>  "$versioneddir/.links"
-  
+  listing=$(tar tf "${processingDir}/${tarfile}" 2> /dev/null | sort -r)
+  echo "Installed files:" > "${versioneddir}/.links"
+  echo "${listing}" >> "${versioneddir}/.links"
+
   printDebug "Extracting tar to rootfs"
-  cd "$processingDir" && tar xf "$tarfile" -C "$rootfs" 2>/dev/null
+  cd "${processingDir}" && tar xf "${tarfile}" -C "${rootfs}" 2> /dev/null
 
   printDebug "Cleaning temp resources"
-  rm -rf "$processingDir" 2>/dev/null
+  rm -rf "${processingDir}" 2> /dev/null
 
   printDebug "Switching to previous cwd - current work dir was purged"
-  cd "$currentDir"
+  cd "${currentDir}" || exit
 
   printInfo "- Integration complete"
   return 0
@@ -346,70 +349,70 @@ unsymlinkFromSystem()
   pkg=$1
   rootfs=$2
   dotlinks=$3
-  if [ -e "$dotlinks" ]; then
-    printInfo "- Checking for obsoleted files in $rootfs/usr/ tree from $pkg"
+  if [ -e "${dotlinks}" ]; then
+    printInfo "- Checking for obsoleted files in ${rootfs}/usr/ tree from ${pkg}"
     # Use sed to skip header line in .links file
     # Note that the contents of the links file are ordered such that
     # processing occurs depth-first; if, after removing orphaned symlinks,
     # a directory is empty, then it can be removed.
-    nfiles=$(sed '1d;$d' "$dotlinks" | wc -l  | tr -d ' ')
+    nfiles=$(sed '1d;$d' "${dotlinks}" | wc -l | tr -d ' ')
     flecnt=0
     pct=0
 
     printDebug "Creating Temporary dirname file"
-    tempDirFile="$ZOPEN_ROOTFS/tmp/zopen.rmdir.$RANDOM"
-    tempTrash="$tempDirFile.trash"
-    [ -e "$tempDirFile" ] && rm -f "$tempDirFile" >/dev/null 2>&1
-    touch "$tempDirFile"
-    addCleanupTrapCmd "rm -rf $tempDirFile"
-    printDebug "Using temporary file $tempDirFile"
+    tempDirFile="${ZOPEN_ROOTFS}/tmp/zopen.rmdir.${RANDOM}"
+    tempTrash="${tempDirFile}.trash"
+    [ -e "${tempDirFile}" ] && rm -f "${tempDirFile}" > /dev/null 2>&1
+    touch "${tempDirFile}"
+    addCleanupTrapCmd "rm -rf ${tempDirFile}"
+    printDebug "Using temporary file ${tempDirFile}"
     printInfo "- Checking ${nfiles} potential links"
 
     rm_fileprocs=15
-    [ -e "$rootfs/etc/zopen/rm_fileprocs" ] && rm_fileprocs=$(cat "$rootfs/etc/zopen/rm_fileprocs")
-    threshold=$(( nfiles / rm_fileprocs))
-    threshold=$(( threshold + 1 ))
-    printDebug "Threshold of files per worker [files/procs] calculated as: $threshold"
-    [ $threshold -le 50 ] && threshold=50 && printVerbose "Threshold below min: using 50" # Don't spawn too many
+    [ -e "${rootfs}/etc/zopen/rm_fileprocs" ] && rm_fileprocs=$(cat "${rootfs}/etc/zopen/rm_fileprocs")
+    threshold=$((nfiles / rm_fileprocs))
+    threshold=$((threshold + 1))
+    printDebug "Threshold of files per worker [files/procs] calculated as: ${threshold}"
+    [ "${threshold}" -le 50 ] && threshold=50 && printVerbose "Threshold below min: using 50" # Don't spawn too many
     printDebug "Starting spinner..."
     progressHandler "spinner" "- Complete" &
     ph=$!
-    killph="kill -HUP $ph"
-    addCleanupTrapCmd "$killph"
+    killph="kill -HUP ${ph}"
+    addCleanupTrapCmd "${killph}"
 
     printDebug "Spawning as subshell to handle threading"
     # Note that this all must happen in a subshell as the above started
-    # progressHandler is a signal-terminated process - and a wait issued in 
+    # progressHandler is a signal-terminated process - and a wait issued in
     # the parent will never complete until that ph is signalled/terminated!
     deletethreads=$(
       tid=0
       filenames=""
       while read filetounlink; do
-        tid=$(( tid + 1 ))
-        filetounlink=$(echo "$filetounlink" | sed 's/\(.*\).symbolic.*/\1/')
-        filenames=$(/bin/printf "%s\n%s" "$filenames" "$filetounlink")
-        if [ "$(( tid % threshold ))" -eq 0 ]; then
-          deletethread "$filenames" "$tempDirFile" &
+        tid=$((tid + 1))
+        filetounlink=$(echo "${filetounlink}" | sed 's/\(.*\).symbolic.*/\1/')
+        filenames=$(/bin/printf "%s\n%s" "${filenames}" "${filetounlink}")
+        if [ "$((tid % threshold))" -eq 0 ]; then
+          deletethread "${filenames}" "${tempDirFile}" &
           printDebug "Started delete thread: $!"
           filenames=""
         fi
-      done <<EOF
-$(sed '1d;$d' "$dotlinks")
+      done << EOF
+$(sed '1d;$d' "${dotlinks}")
 EOF
-      if [ -n "$filenames" ]; then
+      if [ -n "${filenames}" ]; then
         # Handle when there are not enough to trigger the threshold of a new thread above,
         # there will still be items in the "array"
-        deletethread "$filenames" "$tempDirFile" #&
+        deletethread "${filenames}" "${tempDirFile}" #&
         printDebug "Started delete thread: $!"
       fi
-      wait 
+      wait
     )
-    $killph 2>/dev/null  # if the timer is not running, the kill will fail
-    if [ -e "$tempDirFile" ]; then
-      ndirs=$(cat "$tempDirFile" | uniq | wc -l  | tr -d ' ')
+    ${killph} 2> /dev/null # if the timer is not running, the kill will fail
+    if [ -e "${tempDirFile}" ]; then
+      ndirs=$(cat "${tempDirFile}" | uniq | wc -l | tr -d ' ')
       printInfo "- Checking ${ndirs} dir links"
-      for d in $(cat "$tempDirFile" | uniq | sort -r) ; do 
-        [ -d "$d" ] && rmdir "$d" >/dev/null 2>&1
+      for d in $(cat "${tempDirFile}" | uniq | sort -r); do
+        [ -d "${d}" ] && rmdir "${d}" > /dev/null 2>&1
       done
     fi
   else
@@ -421,40 +424,40 @@ deletethread()
 {
   filestodelete="$1"
   tempDirFile="$2"
-  echo "$filestodelete"| while read filetounlink; do
-    deletetask "$tempDirFile" "$filetounlink" 
+  echo "${filestodelete}" | while read filetounlink; do
+    deletetask "${tempDirFile}" "${filetounlink}"
   done
 }
 
-deletetask() 
+deletetask()
 {
-    tempDirFile="$1"
-    filename="$2"
-    [ -z "$filename" ] && return 0
-    filename="$ZOPEN_ROOTFS/$filename"
-    if [ -d "$filename" ]; then
-        # Add to the queue for checking once files are gone if unique
-        ispresent=$(grep "^$filename[ ]*$" "$tempDirFile")
-        if [ -z "$ispresent" ]; then
-          echo " $filename " >> "$tempDirFile"
-        else
-          alreadyfound=""
-        fi
-    elif [ -L "$filename" ]; then
-      if [ ! -f "$filename" ]; then
-        # the linked-to file no longer exists (ie. the symlink is dangling)
-        rm -f "$filename" >/dev/null 2>&1
-      fi
-    else 
-      echo "Unprocessable file: '$filename'" >> "$tempTrash" 
+  tempDirFile="$1"
+  filename="$2"
+  [ -z "${filename}" ] && return 0
+  filename="${ZOPEN_ROOTFS}/${filename}"
+  if [ -d "${filename}" ]; then
+    # Add to the queue for checking once files are gone if unique
+    ispresent=$(grep "^${filename}[ ]*$" "${tempDirFile}")
+    if [ -z "${ispresent}" ]; then
+      echo " ${filename} " >> "${tempDirFile}"
+    else
+      alreadyfound=""
     fi
+  elif [ -L "${filename}" ]; then
+    if [ ! -f "${filename}" ]; then
+      # the linked-to file no longer exists (ie. the symlink is dangling)
+      rm -f "${filename}" > /dev/null 2>&1
+    fi
+  else
+    echo "Unprocessable file: '${filename}'" >> "${tempTrash}"
+  fi
 }
 
 zopenInitialize()
 {
   defineEnvironment
   defineANSI
-  if [ -z "$ZOPEN_DONT_PROCESS_CONFIG" ]; then
+  if [ -z "${ZOPEN_DONT_PROCESS_CONFIG}" ]; then
     processConfig
   fi
 
@@ -467,8 +470,8 @@ printDebug()
   if ${debug}; then
     printColors "${NC}${BLUE}${BOLD}:DEBUG:${NC}: '${1}'" >&2
   fi
-  [ ! -z "$xtrc" ] && set -x
-  return 0;
+  [ ! -z "${xtrc}" ] && set -x
+  return 0
 }
 
 printVerbose()
@@ -477,16 +480,16 @@ printVerbose()
   if ${verbose}; then
     printColors "${NC}${GREEN}${BOLD}VERBOSE${NC}: '${1}'" >&2
   fi
-  [ ! -z "$xtrc" ] && set -x
-  return 0;
+  [ ! -z "${xtrc}" ] && set -x
+  return 0
 }
 
 printHeader()
 {
   [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   printColors "${NC}${YELLOW}${BOLD}${UNDERLINE}${1}${NC}" >&2
-  [ ! -z "$xtrc" ] && set -x
-  return 0;
+  [ ! -z "${xtrc}" ] && set -x
+  return 0
 }
 
 runAndLog()
@@ -495,9 +498,9 @@ runAndLog()
   eval "$1"
   rc=$?
   if [ ! -z "${SSH_TTY}" ]; then
-    chtag -r $SSH_TTY
+    chtag -r ${SSH_TTY}
   fi
-  return $rc
+  return "${rc}"
 }
 
 runLogProgress()
@@ -513,17 +516,17 @@ runLogProgress()
   else
     completeText="Complete"
   fi
-  progressHandler "spinner" "- $completeText" &
+  progressHandler "spinner" "- ${completeText}" &
   ph=$!
-  killph="kill -HUP $ph"
-  addCleanupTrapCmd "$killph"
+  killph="kill -HUP ${ph}"
+  addCleanupTrapCmd "${killph}"
   eval "$1"
   rc=$?
   if [ ! -z "${SSH_TTY}" ]; then
-    chtag -r $SSH_TTY
+    chtag -r ${SSH_TTY}
   fi
-  $killph 2>/dev/null  # if the timer is not running, the kill will fail
-  return $rc
+  ${killph} 2> /dev/null # if the timer is not running, the kill will fail
+  return "${rc}"
 }
 
 spinloop()
@@ -531,9 +534,9 @@ spinloop()
   # in the absence of generic ms/ns reporting, spin-loop instead - not ideal
   # but without pre-reqing packages...
   i=$1
-  while [ $i -ge 0 ]; do
+  while [ ${i} -ge 0 ]; do
     true > /dev/null
-    i=$(( i - 1 ))
+    i=$((i - 1))
   done
 }
 
@@ -541,14 +544,14 @@ progressNetwork()
 {
   # Loop until signal received
   icon="-----"
-  ansiline 0 0 "$icon"
-  while : ; do
+  ansiline 0 0 "${icon}"
+  while :; do
     spinloop 1000
-    case "$icon" in
-      '-----') icon='>----';; '>----') icon='->---';; '->---') icon='-->--';; '-->--') icon='--->-';; '--->-') icon='---->';;
-      '---->') icon='----<';; '----<') icon='---<-';; '---<-') icon='--<--';; '--<--') icon='-<---';; '-<---') icon='<----';; '<----') icon='-----';;
+    case "${icon}" in
+    '-----') icon='>----' ;; '>----') icon='->---' ;; '->---') icon='-->--' ;; '-->--') icon='--->-' ;; '--->-') icon='---->' ;;
+    '---->') icon='----<' ;; '----<') icon='---<-' ;; '---<-') icon='--<--' ;; '--<--') icon='-<---' ;; '-<---') icon='<----' ;; '<----') icon='-----' ;;
     esac
-    ansiline 1 -1 "$icon"
+    ansiline 1 -1 "${icon}"
   done
 }
 
@@ -556,31 +559,31 @@ progressSpinner()
 {
   # Loop until signal received
   icon="-"
-  ansiline 0 0 "$icon"
-  while : ; do
+  ansiline 0 0 "${icon}"
+  while :; do
     spinloop 1000
-    case "$icon" in
-      '-') icon='\';; '\') icon='|';; '|') icon='/';; '/') icon='-';;
+    case "${icon}" in
+    '-') icon='\' ;; '\') icon='|' ;; '|') icon='/' ;; '/') icon='-' ;;
     esac
-    ansiline 1 -1 "$icon"
+    ansiline 1 -1 "${icon}"
   done
 }
 
-progressHandler() 
+progressHandler()
 {
-    if [ ! "${_BPX_TERMPATH-x}" = "OMVS" ] && [ -z "${NO_COLOR}" ] && [ ! "${FORCE_COLOR-x}" = "0" ] && [ -t 1 ] && [ -t 2 ]; then
-      [ -z "${-%%*x*}" ] && set +x  # Disable -x debug if set for this process
-      type=$1
-      completiontext=$2  # Custom end text (when the process is complete)
-      
-      trapcmd="exit;"
-      [ -n "$completiontext" ] && trapcmd="/bin/echo \"\047[1A\047[30D\047[2K$completiontext\"; $trapcmd"
-      trap "$trapcmd" HUP
-      case "$type" in
-        "network") progressNetwork;;
-        *)         progressSpinner;;
-      esac
-		fi
+  if [ ! "${_BPX_TERMPATH-x}" = "OMVS" ] && [ -z "${NO_COLOR}" ] && [ ! "${FORCE_COLOR-x}" = "0" ] && [ -t 1 ] && [ -t 2 ]; then
+    [ -z "${-%%*x*}" ] && set +x # Disable -x debug if set for this process
+    type=$1
+    completiontext=$2 # Custom end text (when the process is complete)
+
+    trapcmd="exit;"
+    [ -n "${completiontext}" ] && trapcmd="/bin/echo \"\047[1A\047[30D\047[2K${completiontext}\"; ${trapcmd}"
+    trap "${trapcmd}" HUP
+    case "${type}" in
+    "network") progressNetwork ;;
+    *) progressSpinner ;;
+    esac
+  fi
 }
 
 runInBackgroundWithTimeoutAndLog()
@@ -588,41 +591,41 @@ runInBackgroundWithTimeoutAndLog()
   command="$1"
   timeout="$2"
 
-  printVerbose "$command with timeout of ${timeout}s"
-  eval "$command &; TEEPID=$!"
+  printVerbose "${command} with timeout of ${timeout}s"
+  eval "${command} &; TEEPID=$!"
   PID=$!
   n=0
-  while [ $n -le $timeout ]; do
-    kill -0 $PID 2>/dev/null
+  while [ ${n} -le ${timeout} ]; do
+    kill -0 "${PID}" 2> /dev/null
     if [ $? != 0 ]; then
-      wait $PID
+      wait "${PID}"
       if [ ! -z "${SSH_TTY}" ]; then
-        chtag -r $SSH_TTY
+        chtag -r ${SSH_TTY}
       fi
       rc=$?
-      return $rc
+      return "${rc}"
     else
       sleep 1
-      n=`expr $n + 1`
+      n=$(expr ${n} + 1)
     fi
   done
-  kill -9 $PID
-  kill -9 $TEEPID
-  printError "TIMEOUT: (PID: $PID): $command"
+  kill -9 "${PID}"
+  kill -9 ${TEEPID}
+  printError "TIMEOUT: (PID: ${PID}): ${command}"
 }
 
 printSoftError()
 {
   [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   printColors "${NC}${RED}${BOLD}***ERROR: ${NC}${RED}${1}${NC}" >&2
-  [ -n "$xtrc" ] && set -x
+  [ -n "${xtrc}" ] && set -x
 }
 
 printError()
 {
   [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   printColors "${NC}${RED}${BOLD}***ERROR: ${NC}${RED}${1}${NC}" >&2
-  [ -n "$xtrc" ] && set -x
+  [ -n "${xtrc}" ] && set -x
   mutexFree "zopen" # prevent lock from lingering around after an error
   cleanupFunction
   exit 4
@@ -632,35 +635,35 @@ printWarning()
 {
   [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   printColors "${NC}${YELLOW}${BOLD}***WARNING: ${NC}${YELLOW}${1}${NC}" >&2
-  [ -n "$xtrc" ] && set -x
-  return 0;
+  [ -n "${xtrc}" ] && set -x
+  return 0
 }
 
 printInfo()
 {
   [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   printColors "$1" >&2
-  [ -n "$xtrc" ] && set -x
-  return 0;
+  [ -n "${xtrc}" ] && set -x
+  return 0
 }
 
 # Used to input sensitive data - turns off echo to the screen for the input
 getInputHidden()
 {
-  # Register trap-handler to try and ensure that we restore the screen to display 
-  # chars in the event the script is terminated early (eg. user hits CTRL-C instead of 
+  # Register trap-handler to try and ensure that we restore the screen to display
+  # chars in the event the script is terminated early (eg. user hits CTRL-C instead of
   # answering the masked question)
   addCleanupTrapCmd "stty echo"
   stty -echo
   read zopen_input
-  echo $zopen_input
+  echo ${zopen_input}
   stty echo
 }
 
 getInput()
 {
   read zopen_input
-  echo $zopen_input
+  echo ${zopen_input}
 }
 
 printElapsedTime()
@@ -668,44 +671,45 @@ printElapsedTime()
   printType=$1
   functionName=$2
   startTime=$3
-  elapsedTime=$(( $SECONDS - $startTime ))
+  elapsedTime=$((${SECONDS} - ${startTime}))
 
-  elapsedTimeOutput="$functionName completed in $elapsedTime seconds."
+  elapsedTimeOutput="${functionName} completed in ${elapsedTime} seconds."
 
-  case $printType in
-    "info")
-      printInfo "$elapsedTimeOutput"
-      ;;
-    "verbose")
-      printVerbose "$elapsedTimeOutput"
-      ;;
+  case ${printType} in
+  "info")
+    printInfo "${elapsedTimeOutput}"
+    ;;
+  "verbose")
+    printVerbose "${elapsedTimeOutput}"
+    ;;
   esac
 }
 
 processConfig()
 {
   export ZOPEN_QUICK_LOAD=1
-  if [ -z "$ZOPEN_ROOTFS" ]; then
-    relativeRootDir="$(cd "$(dirname "$0")/../.." >/dev/null 2>&1 && pwd -P)"
-    if [ -f "$relativeRootDir/etc/zopen-config" ]; then
-      . "$relativeRootDir/etc/zopen-config"
+  if [ -z "${ZOPEN_ROOTFS}" ]; then
+    relativeRootDir="$(cd "$(dirname "$0")/../.." > /dev/null 2>&1 && pwd -P)"
+    if [ -f "${relativeRootDir}/etc/zopen-config" ]; then
+      . "${relativeRootDir}/etc/zopen-config"
     else
       printError "Source the zopen-config prior to running $0"
     fi
   fi
 }
 
-checkIfConfigLoaded() {
+checkIfConfigLoaded()
+{
   if [ -z "${ZOPEN_CA}" ]; then
     errorMessage="\$ZOPEN_CA was not set. Ensure zopen init has run and zopen-config has been sourced."
   fi
   if [ ! -r "${ZOPEN_CA}" ]; then
     errorMessage="Certificate at ${ZOPEN_CA} could not be accessed. Ensure zopen init has run and zopen-config has been sourced."
   fi
-  
+
   if [ ! -z "${errorMessage}" ]; then
-    if [ -r "$mydir/../../../etc/zopen-config" ]; then
-      relativeConfigDir="$(cd "$(dirname "$mydir")/../../etc/" >/dev/null 2>&1 && pwd -P)"
+    if [ -r "${mydir}/../../../etc/zopen-config" ]; then
+      relativeConfigDir="$(cd "$(dirname "${mydir}")/../../etc/" > /dev/null 2>&1 && pwd -P)"
       errorMessage="${errorMessage} Run '. ${relativeConfigDir}/zopen-config'  or add it to your .profile."
     fi
     printError "${errorMessage}"
@@ -715,41 +719,41 @@ checkIfConfigLoaded() {
 parseDeps()
 {
   dep="$1"
-  version=$(echo $dep | awk -F '[>=<]+' '{print $2}')
-  if [ -z "$version" ]; then
+  version=$(echo ${dep} | awk -F '[>=<]+' '{print $2}')
+  if [ -z "${version}" ]; then
     operator=""
-    dep=$(echo $dep | awk -F '[>=<]+' '{print $1}')
+    dep=$(echo ${dep} | awk -F '[>=<]+' '{print $1}')
   else
-    operator=$(echo $dep | awk -F '[0-9.]+' '{print $1}' | awk -F '^[a-zA-Z]+' '{print $2}')
-    dep=$(echo $dep | awk -F '[>=<]+' '{print $1}')
-    case $operator in
-      ">=") ;;
-      "=") ;;
-      *) printError "$operator is not supported."
+    operator=$(echo ${dep} | awk -F '[0-9.]+' '{print $1}' | awk -F '^[a-zA-Z]+' '{print $2}')
+    dep=$(echo ${dep} | awk -F '[>=<]+' '{print $1}')
+    case ${operator} in
+    ">=") ;;
+    "=") ;;
+    *) printError "${operator} is not supported." ;;
     esac
-    major=$(echo $version | awk -F. '{print $1}')
-    minor=$(echo $version | awk -F. '{print $2}')
-    if [ -z "$minor" ]; then
+    major=$(echo ${version} | awk -F. '{print $1}')
+    minor=$(echo ${version} | awk -F. '{print $2}')
+    if [ -z "${minor}" ]; then
       minor=0
     fi
-    patch=$(echo $version | awk -F. '{print $3}')
-    if [ -z "$patch" ]; then
+    patch=$(echo ${version} | awk -F. '{print $3}')
+    if [ -z "${patch}" ]; then
       patch=0
     fi
-    prerelease=$(echo $version | awk -F. '{print $4}')
-    if [ -z "$prerelease" ]; then
+    prerelease=$(echo ${version} | awk -F. '{print $4}')
+    if [ -z "${prerelease}" ]; then
       prerelease=0
     fi
   fi
 
-  echo "$dep|$operator|$major|$minor|$patch|$prerelease"
+  echo "${dep}|${operator}|${major}|${minor}|${patch}|${prerelease}"
 }
 
 compareVersions()
 {
   v1="$1"
   v2="$2"
-  awk -v v1="$v1" -v v2="$v2" '
+  awk -v v1="${v1}" -v v2="${v2}" '
   function vercmp(v1, v2) {
     n1 = split(v1, v1_array, ".")
     n2 = split(v2, v2_array, ".")
@@ -780,49 +784,49 @@ validateVersion()
   operator=$2
   requestedVersion=$3
   dependency=$4
-  if [ -n "$operator" ] && [ -z "$version" ]; then
-    printVerbose "$operator ${requestedVersion} requsted, but no version file found in $versionPath." 
+  if [ -n "${operator}" ] && [ -z "${version}" ]; then
+    printVerbose "${operator} ${requestedVersion} requsted, but no version file found in ${versionPath}."
     return 1
-  elif [ ! -z "$operator" ] && ! compareVersions "${version}" "${requestedVersion}"; then
-    printVerbose "$dependency does not satisfy ${version} $operator ${requestedVersion}"
+  elif [ ! -z "${operator}" ] && ! compareVersions "${version}" "${requestedVersion}"; then
+    printVerbose "${dependency} does not satisfy ${version} ${operator} ${requestedVersion}"
     return 1
   fi
   return 0
 }
 
-deleteDuplicateEntries() 
+deleteDuplicateEntries()
 {
   value=$1
   delim=$2
-  echo "$value$delim" | awk -v RS="$delim" '!($0 in a) {a[$0]; printf("%s%s", col, $0); col=RS; }' | sed "s/${delim}$//"
+  echo "${value}${delim}" | awk -v RS="${delim}" '!($0 in a) {a[$0]; printf("%s%s", col, $0); col=RS; }' | sed "s/${delim}$//"
 }
 
 # reworked version of above to strip blank elements between delims
-deleteDuplicateEntriesRedux() 
+deleteDuplicateEntriesRedux()
 {
   value=$1
   delim=$2
-  echo "$value" | awk -v RS="$delim" -v ORS="$delim" ' {gsub("^[ ]+|[ ]$", "", $0); if (NF>0 && !a[$0]++) {print } }' | sed "s/${delim}$//"
+  echo "${value}" | awk -v RS="${delim}" -v ORS="${delim}" ' {gsub("^[ ]+|[ ]$", "", $0); if (NF>0 && !a[$0]++) {print } }' | sed "s/${delim}$//"
 }
 
 # Logging Types
-LOG_E="ERROR"    # If there was a failure and a command failed
-LOG_W="WARNING"  # If an error occurred but there was a workaround/fallback
-LOG_I="INFO"     # General information
-LOG_A="AUDIT"    # Security-type log for admin activities
+LOG_E="ERROR"   # If there was a failure and a command failed
+LOG_W="WARNING" # If an error occurred but there was a workaround/fallback
+LOG_I="INFO"    # General information
+LOG_A="AUDIT"   # Security-type log for admin activities
 
 # Logging Categories - more than one possible for a log entry
-CAT_CONFIG="C"    # Configuration change
-CAT_FILE="F"      # File handling (eg. downloading)
-CAT_INSTALL="I"   # Install processing
-CAT_NETWORK="N"   # Network processing
-CAT_PKG="P"       # Package handling
-CAT_QUERY="Q"     # Query processing
-CAT_REMOVE="R"    # Removal handling
-CAT_SYS="S"       # Related to the underlying native z/OS system
-CAT_ZOPEN="Z"     # Related to the zopen system itself
-
-syslog() 
+CAT_CONFIG="C"  # Configuration change
+CAT_FILE="F"    # File handling (eg. downloading)
+CAT_INSTALL="I" # Install processing
+CAT_NETWORK="N" # Network processing
+CAT_PKG="P"     # Package handling
+CAT_QUERY="Q"   # Query processing
+CAT_REMOVE="R"  # Removal handling
+CAT_SYS="S"     # Related to the underlying native z/OS system
+CAT_ZOPEN="Z"   # Related to the zopen system itself
+
+syslog()
 {
   fd=$1
   type=$2
@@ -830,59 +834,60 @@ syslog()
   module=$4
   location=$5
   msg=$6
-  if [ ! -e "$fd" ]; then
-    mkdir -p "$(dirname "$fd")"
-    touch "$fd"
+  if [ ! -e "${fd}" ]; then
+    mkdir -p "$(dirname "${fd}")"
+    touch "${fd}"
   fi
-  echo $(date +"%F %T") $(id | cut -d' ' -f1)::$module:$type:$categories:$location:$msg >> $fd
+  echo $(date +"%F %T") $(id | cut -d' ' -f1)::${module}:${type}:${categories}:${location}:${msg} >> ${fd}
 }
 
-downloadJSONCache() 
+downloadJSONCache()
 {
-  if [ -z "$JSON_CACHE" ]; then
-    JSON_CACHE="$ZOPEN_ROOTFS/var/cache/zopen/zopen_releases.json"
-    JSON_TIMESTAMP="$ZOPEN_ROOTFS/var/cache/zopen/zopen_releases.timestamp"
-    JSON_TIMESTAMP_CURRENT="$ZOPEN_ROOTFS/var/cache/zopen/zopen_releases.timestamp.current"
-    if ! curlCmd -L -s -I "$ZOPEN_JSON_CACHE_URL" -o "$JSON_TIMESTAMP_CURRENT"; then
-      printError "Failed to obtain json cache timestamp from $ZOPEN_JSON_CACHE_URL"
+  if [ -z "${JSON_CACHE}" ]; then
+    JSON_CACHE="${ZOPEN_ROOTFS}/var/cache/zopen/zopen_releases.json"
+    JSON_TIMESTAMP="${ZOPEN_ROOTFS}/var/cache/zopen/zopen_releases.timestamp"
+    JSON_TIMESTAMP_CURRENT="${ZOPEN_ROOTFS}/var/cache/zopen/zopen_releases.timestamp.current"
+    if ! curlCmd -L -s -I "${ZOPEN_JSON_CACHE_URL}" -o "${JSON_TIMESTAMP_CURRENT}"; then
+      printError "Failed to obtain json cache timestamp from ${ZOPEN_JSON_CACHE_URL}"
     fi
-    chtag -tc 819 "$JSON_TIMESTAMP_CURRENT"
+    chtag -tc 819 "${JSON_TIMESTAMP_CURRENT}"
 
-    if [ -f "$JSON_CACHE" ] && [ -f "$JSON_TIMESTAMP" ] && [ "$(grep 'Last-Modified' "$JSON_TIMESTAMP_CURRENT")" = "$(grep 'Last-Modified' "$JSON_TIMESTAMP")" ]; then
-      return;
+    if [ -f "${JSON_CACHE}" ] && [ -f "${JSON_TIMESTAMP}" ] && [ "$(grep 'Last-Modified' "${JSON_TIMESTAMP_CURRENT}")" = "$(grep 'Last-Modified' "${JSON_TIMESTAMP}")" ]; then
+      return
     fi
 
-    mv "$JSON_TIMESTAMP_CURRENT" "$JSON_TIMESTAMP"
-    if ! curlCmd -L -s -o "$JSON_CACHE" "$ZOPEN_JSON_CACHE_URL" ; then
-      printError "Failed to obtain json cache from $ZOPEN_JSON_CACHE_URL"
+    mv "${JSON_TIMESTAMP_CURRENT}" "${JSON_TIMESTAMP}"
+    if ! curlCmd -L -s -o "${JSON_CACHE}" "${ZOPEN_JSON_CACHE_URL}"; then
+      printError "Failed to obtain json cache from ${ZOPEN_JSON_CACHE_URL}"
     fi
-    chtag -tc 819 "$JSON_CACHE"
+    chtag -tc 819 "${JSON_CACHE}"
   fi
 
-  if [ ! -f "$JSON_CACHE" ]; then
-    printError "Could not download json cache from $ZOPEN_JSON_CACHE_URL"
+  if [ ! -f "${JSON_CACHE}" ]; then
+    printError "Could not download json cache from ${ZOPEN_JSON_CACHE_URL}"
   fi
 }
 
 getReposFromGithub()
 {
   downloadJSONCache
-  repo_results="$(cat "$JSON_CACHE" | jq -r '.release_data | keys[]')"
+  repo_results="$(cat "${JSON_CACHE}" | jq -r '.release_data | keys[]')"
 }
 
-getAllReleasesFromGithub(){
+getAllReleasesFromGithub()
+{
   downloadJSONCache
   repo="$1"
-  releases="$(jq -e -r '.release_data."'$repo'"' "$JSON_CACHE")"
+  releases="$(jq -e -r '.release_data."'${repo}'"' "${JSON_CACHE}")"
   if [ $? -ne 0 ]; then
-    printError "Could not get all releases for $repo"
+    printError "Could not get all releases for ${repo}"
   fi
 }
 
 initDefaultEnvironment()
 {
-  export ZOPEN_OLD_PATH=$PATH       # Preserve PATH in case scripts need to access it
-  export ZOPEN_OLD_LIBPATH=$LIBPATH # Preserve LIBPATH in case scripts need to access it
+  export ZOPEN_OLD_PATH=${PATH}       # Preserve PATH in case scripts need to access it
+  export ZOPEN_OLD_LIBPATH=${LIBPATH} # Preserve LIBPATH in case scripts need to access it
   export PATH="$(getconf PATH)"
   export _CEE_RUNOPTS="FILETAG(AUTOCVT,AUTOTAG) POSIX(ON)"
   unset MANPATH
@@ -892,16 +897,16 @@ initDefaultEnvironment()
 
 #
 # checkWritable prints a message and exits if the directory above INCDIR
-# is not writable. This is a safe location to check for and should be 
-# writable on a 'dev' environment 
+# is not writable. This is a safe location to check for and should be
+# writable on a 'dev' environment
 #
 checkWritable()
 {
-  if [ "x$INCDIR" = "x" ]; then
+  if [ -z "${INCDIR}" ]; then
     echo "Internal error. Caller has to have set INCDIR" >&2
     exit 16
   fi
-  ROOTDIR="$( cd "${INCDIR}/../" >/dev/null 2>&1 && pwd -P )"
+  ROOTDIR="$(cd "${INCDIR}/../" > /dev/null 2>&1 && pwd -P)"
   if ! [ -w "${ROOTDIR}" ]; then
     printError "Tried to run an update operation (${ME}) in a read-only tools distribution" >&2
     exit 8
diff --git a/tools/format_and_check_scripts.sh b/tools/format_and_check_scripts.sh
new file mode 100755
index 000000000..81f33018a
--- /dev/null
+++ b/tools/format_and_check_scripts.sh
@@ -0,0 +1,52 @@
+#!/bin/sh
+
+format=false
+shellcheck=false
+verbose=false
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    -f | --format)
+      format=true
+      ;;
+    -s | --shellcheck)
+      shellcheck=true
+      ;;
+    -v | --verbose)
+      verbose=true
+      ;;
+    *)
+      if [ -f "$1" ]; then
+        files="$files $1"
+      else
+        echo "Ignoring invalid file: $1"
+      fi
+      ;;
+  esac
+  shift
+done
+
+if [ "$format" = false ] && [ "$shellcheck" = false ]; then
+  echo "Usage: $0 [-f | --format] [-s | --shellcheck] [-v | --verbose] [file1.sh file2.sh ...]"
+  exit 1
+fi
+
+if [ "$format" = true ]; then
+  for file in $files; do
+    if [ "$verbose" = true ]; then
+      echo "Formatting $file..."
+    fi
+    shfmt -i 2 -fn -sr -w "$file"
+  done
+fi
+
+if [ "$shellcheck" = true ]; then
+  for file in $files; do
+    if [ "$verbose" = true ]; then
+      echo "Running ShellCheck on $file..."
+    fi
+    #TODO: change to -z checks: Avoids https://www.shellcheck.net/wiki/SC2268
+    #TODO: change to "$@" - Avoids https://www.shellcheck.net/wiki/SC2086
+    shellcheck --shell sh -f diff -o all -e SC2268,SC2086 "$file" | git apply
+  done
+fi