Script "build-package.sh"
#!/bin/sh

# ------------------------
# build-package.sh
# version 3.3.1.7
# ------------------------

print_pkg_size()
{  
  if [ ! -z "${1}" ]
  then
    if [ -d "${1}" ]; then
      printf "   <directory>  %s\n" "${1}"
    else
      pkg_size=`stat -c%s "${1}" 2>/dev/null || echo "0"`

      # check for bc binary
      bc_binary_found="yes"
      which bc >/dev/null 2>&1 || type bc >/dev/null 2>&1 || bc_binary_found=""

      if [ ! -z ${bc_binary_found} ]; then
        pkg_kb_size=`echo scale=2 \; ${pkg_size}/1024 | bc`
        [ ${pkg_size} -ne 0 ] && printf "%10.1f %s\t%s\n" "${pkg_kb_size}" "KiB" "${1}"
      else
        [ ${pkg_size} -ne 0 ] && printf "\t%s\n" "${1}"
      fi
    fi
  fi
}

# check for parameters

_usage_str="Usage: ${0} [ --leave-builddir ] [ --debug-pkg ] [ --bigsystem ] [ --only-list-pkgs ] package-name"
##_usage_example="for example, ${0} --leave-builddir gcc"

if [ $# -eq 0 ] || [ "${1}" = "--help" ] || [ "${1}" = "--usage" ]; then
  printf "%s\n" "${_usage_str}"
  exit 0
fi

PKGTITLE=""
PKGPREFIX=""
LEAVE_BUILDDIR_OPT=""
DEBUG_PKG_OPT=""
BIGSYSTEM_PREFIX=""
LIST_PKGS_MODE=""
for arg in $@
do
  is_option=`echo "${arg}" | grep -- '\-\-'`
  if [ -z "${is_option}" ]; then
    if [ -z ${PKGTITLE} ]; then
      PKGTITLE=`basename "${arg}"`
      PKGPREFIX=`dirname "${arg}"`
      [ "${PKGPREFIX}" = "." ] && PKGPREFIX=""
      if [ ! -z "${BIGSYSTEM_PREFIX}" ] && [ ! -z "${PKGPREFIX}" ]; then
         printf "Note: %s \"%s\"\n" "--bigsystem overrides package prefix" "${PKGPREFIX}"
       fi
    fi
  else
    [ $arg = "--leave-builddir" ] && LEAVE_BUILDDIR_OPT="yes" && continue
    [ $arg = "--debug-pkg" ] && DEBUG_PKG_OPT="yes" && continue
    if [ $arg = "--bigsystem" ]; then
       if [ ! -z "${PKGPREFIX}" ]; then
         printf "Note: %s \"%s\"\n" "--bigsystem overrides package prefix" "${PKGPREFIX}"
       fi
       BIGSYSTEM_PREFIX="_BIGSYSTEM/"
       continue
    fi
    [ $arg = "--only-list-pkgs" ] && LIST_PKGS_MODE="yes" && continue
    echo "${0}: unknown option '${arg}'"
  fi
done

if [ -z ${PKGTITLE} ]; then
  printf "%s\n" "${_usage_str}"
  exit 0
fi

if [ ${PKGTITLE} = "kernel" ] || [ ${PKGTITLE} = "linux" ] || \
   [ ${PKGTITLE} = "kernel-headers" ] || [ ${PKGTITLE} = "linux-headers" ] || \
   [ ${PKGTITLE} = "kernel_headers" ] || [ ${PKGTITLE} = "linux_headers" ] || \
   [ ${PKGTITLE} = "linux-libre" ] || [ ${PKGTITLE} = "linux_libre" ]; then
  echo "${0} cannot build linux (the kernel); please use 'build-kernelpkg.sh' instead."
  exit 1
fi

[ -z "${BUILD_FARM}" ] && BUILD_FARM="${HOME}/build-farm"
if [ -d "${BUILD_FARM}" ]; then
  [ -z ${LIST_PKGS_MODE} ] && echo "base directory:" "${BUILD_FARM}"
else
  echo "ERROR: base directory '${BUILD_FARM}' doesn't exist. Abort."
  exit 1
fi

if [ ! -z "${BIGSYSTEM_PREFIX}" ]; then
  PKGPREFIX=`basename "${BIGSYSTEM_PREFIX}"`
elif [ ! -z "${PKGPREFIX}" ]; then
  BIGSYSTEM_PREFIX="${PKGPREFIX}"/
fi

[ -z "${PKGBS_DIR}" ] && PKGBS_DIR="${BUILD_FARM}"/BUILD-SCRIPTS
[ -d "${PKGBS_DIR}" ] || PKGBS_DIR=`pwd`
CONFIG_PATH="${PKGBS_DIR}"/"${BIGSYSTEM_PREFIX}"CONFIG
PPFILES_PATH="${PKGBS_DIR}"/"${BIGSYSTEM_PREFIX}"PPFILES

# check for required scripts

if [ ! -f "${PKGBS_DIR}"/get_source_for_pkg.sh ]; then
  echo "ERROR: build farm is broken; can't find script 'get_source_for_pkg.sh'. Abort."
  exit 1
fi
if [ ! -f "${PKGBS_DIR}"/patch_raw_srcpkg.sh ]; then
  echo "ERROR: build farm is broken; can't find script 'patch_raw_srcpkg.sh'. Abort."
  exit 1
fi
if [ ! -f "${PKGBS_DIR}"/srcpkg_to_binpkg.sh ]; then
  echo "ERROR: build farm is broken; can't find script 'srcpkg_to_binpkg.sh'. Abort."
  exit 1
fi

# print package information

if [ ! -z ${BIGSYSTEM_PREFIX} ]; then
  printf "%s; %s: \"%s\"\n" "Big system mode on" "prefix" "${BIGSYSTEM_PREFIX}"
fi

if [ -z ${LIST_PKGS_MODE} ]
then  
  printf "%s " "building"
  [ ! -z ${DEBUG_PKG_OPT} ] && printf "%s " "debug"
  printf "%s %s\n" "package:" "${PKGTITLE}"
  echo "related build system files/directories:"
  rfile_count=0
  [ -f "${PKGBS_DIR}"/"${BIGSYSTEM_PREFIX}"PKGINFO/pkginfo-"${PKGTITLE}" ] && rfile_count=`expr $rfile_count '+' 1` &&
    printf "\t%s (%s)\n" "pkginfo" "'${BIGSYSTEM_PREFIX}PKGINFO/pkginfo-${PKGTITLE}'"
  [ -f "${PKGBS_DIR}"/"${BIGSYSTEM_PREFIX}"SRCINFO/srcinfo-"${PKGTITLE}" ] && rfile_count=`expr $rfile_count '+'    1` &&
    printf "\t%s (%s)\n" "srcinfo" "'${BIGSYSTEM_PREFIX}SRCINFO/srcinfo-${PKGTITLE}'"
  [ -f "${PKGBS_DIR}"/"${BIGSYSTEM_PREFIX}"PATCHCMDS/patchcmds-"${PKGTITLE}" ] && rfile_count=`expr $rfile_count '+' 1` &&
    printf "\t%s (%s)\n" "patchcmds" "'${BIGSYSTEM_PREFIX}PATCHCMDS/patchcmds-${PKGTITLE}'"
  [ -f "${PKGBS_DIR}"/"${BIGSYSTEM_PREFIX}"BUILDCMDS/buildcmds-"${PKGTITLE}" ] && rfile_count=`expr $rfile_count '+' 1` &&
    printf "\t%s (%s)\n" "buildcmds" "'${BIGSYSTEM_PREFIX}BUILDCMDS/buildcmds-${PKGTITLE}'"
  [ -f "${PKGBS_DIR}"/"${BIGSYSTEM_PREFIX}"POSTCMDS/postcmds-"${PKGTITLE}" ] && rfile_count=`expr $rfile_count '+' 1` &&
    printf "\t%s (%s)\n" "postcmds" "'${BIGSYSTEM_PREFIX}POSTCMDS/postcmds-${PKGTITLE}'"
  [ -f "${CONFIG_PATH}"/config-"${PKGTITLE}" ] && rfile_count=`expr $rfile_count '+' 1` &&
    printf "\t%s (%s)\n" "config" "'${BIGSYSTEM_PREFIX}CONFIG/config-${PKGTITLE}'"
  [ -d "${PPFILES_PATH}"/ppfiles-"${PKGTITLE}" ] && rfile_count=`expr $rfile_count '+' 1` &&
    printf "\t%s (%s)\n" "ppfiles/" "'${BIGSYSTEM_PREFIX}PPFILES/ppfiles-${PKGTITLE}/'"
  if [ $rfile_count -eq 0 ]; then
    printf "\t<%s>\n" "none"
  fi
fi

if [ -f "${PKGBS_DIR}"/"${BIGSYSTEM_PREFIX}"PKGINFO/pkginfo-"${PKGTITLE}" ]; then
  echo "------------------- description --------------------"
  cat "${PKGBS_DIR}"/"${BIGSYSTEM_PREFIX}"PKGINFO/pkginfo-"${PKGTITLE}"
  if [ -z ${LIST_PKGS_MODE} ]; then
    echo "----------------------------------------------------"
  fi
fi

if [ -z ${LIST_PKGS_MODE} ]
then  
  # get source package

  raw_src_success=""
  "${PKGBS_DIR}"/get_source_for_pkg.sh "${BIGSYSTEM_PREFIX}${PKGTITLE}"
  [ $? -eq 0 ] && raw_src_success="yes"

  if [ -z ${raw_src_success} ]; then
    echo "('get_source_for_pkg.sh' already said its error message.)"
    exit 1
  fi

  patch_success=""
  "${PKGBS_DIR}"/patch_raw_srcpkg.sh "${BIGSYSTEM_PREFIX}${PKGTITLE}"
  [ $? -eq 0 ] && patch_success="yes"
  cd "${PKGBS_DIR}"

  if [ -z ${patch_success} ]; then
    echo "('patch_raw_srcpkg.sh' already said its error message.)"
    exit 1
  fi

  # build it now

  binpkg_success=""
  if [ -z ${DEBUG_PKG_OPT} ]; then
    "${PKGBS_DIR}"/srcpkg_to_binpkg.sh "${BIGSYSTEM_PREFIX}${PKGTITLE}"
  else
    "${PKGBS_DIR}"/srcpkg_to_binpkg.sh --debug-pkg "${BIGSYSTEM_PREFIX}${PKGTITLE}"
  fi
  [ $? -eq 0 ] && binpkg_success="yes"

  if [ -z ${binpkg_success} ]; then
    echo "('srcpkg_to_binpkg.sh' already said its error message.)"
    exit 1
  fi
fi

cd "${PKGBS_DIR}"
[ -z "${PKGPREFIX}" ] && PKGPREFIX="."

[ -z "${BUILD_DIR}" ] && BUILD_DIR=`ls -tp "${BUILD_FARM}/${PKGPREFIX}/" | grep '/' | sed 's|/||' | grep "${PKGTITLE}" | grep "builddir" | head -1`
[ -z "${BUILD_DIR}" ] && BUILD_DIR=`ls -tp "${BUILD_FARM}/${PKGPREFIX}/" | grep '/' | sed 's|/||' | grep "_${PKGTITLE}_" | head -1`
[ -z "${SOURCE_DIR}" ] && SOURCE_DIR=`ls -tp "${BUILD_FARM}/${PKGPREFIX}/" | grep '/' | sed 's|/||' | grep "${PKGTITLE}" | grep "sourcedir" | head -1`
[ ! -z ${LIST_PKGS_MODE} ] && [ -z "${BUILD_DIR}" ] && BUILD_DIR="${PKGTITLE}".builddir

if [ -z ${LIST_PKGS_MODE} ]
then
  if [ ! -z "${BUILD_DIR}" ]; then
    if [ -z ${binpkg_success} ]; then
      echo "build directory" \(\'"${BUILD_FARM}/${PKGPREFIX}/${BUILD_DIR}"\'\) "left untouched (errors)"
    else
      if [ -z ${LEAVE_BUILDDIR_OPT} ]; then
        printf "removing build directory '%s'..." "${BUILD_FARM}/${PKGPREFIX}/${BUILD_DIR}"
        rm -rf "${BUILD_FARM}/${PKGPREFIX}/${BUILD_DIR}"
        echo " ok"
      else
        echo "build directory" \(\'"${BUILD_FARM}/${PKGPREFIX}/${BUILD_DIR}"\'\) "left untouched (--leave-builddir)"
      fi
    fi
  else
    echo "INTERNAL ERROR: attempt to remove the whole build farm directory! Abort."
    exit 1
  fi
  if [ ! -z "${SOURCE_DIR}" ]; then
    BUILD_DIR=""
    if [ -z ${binpkg_success} ]; then
      echo "source directory" \(\'"${BUILD_FARM}/${PKGPREFIX}/${SOURCE_DIR}"\'\) "left untouched (errors)"
    else
      printf "removing source directory '%s'..." "${BUILD_FARM}/${PKGPREFIX}/${SOURCE_DIR}"
      rm -rf "${BUILD_FARM}/${PKGPREFIX}/${SOURCE_DIR}"
      echo " ok"
    fi
  fi
fi

echo "++++++++++++++++++++++++++++++++++++++++++++++++++++"

pkg_with_version=`echo "${BUILD_DIR}" | sed 's/.builddir//'`
[ -z "${pkg_with_version}" ] && [ ! -z "${SOURCE_DIR}" ] && \
  pkg_with_version=`echo "${SOURCE_DIR}" | sed 's/.sourcedir//'`
[ -z "${pkg_with_version}" ] && \
  pkg_with_version=`ls -tp "${BUILD_FARM}"/PACKAGES/srcpkg/"${PKGPREFIX}"/"${PKGTITLE}"* 2>/dev/null | \
    grep ".srcpkg." | sed -e 's/.srcpkg//' -e 's/.tar//' -e 's/.bz2//'`

pkg_name_tokens=`echo "${pkg_with_version}" | sed "s/-/\n/g" | sed '1!G;h;$!d'`
pkg_arch=`echo "${pkg_name_tokens}" | sed -n '2,2p'`
pkg_libc=`echo "${pkg_name_tokens}" | sed -n '1,1p'`
[ -z "${pkg_arch}" ] && pkg_arch="unknown"
[ -z "${pkg_libc}" ] && pkg_libc="unknown"
[ -z `echo "${pkg_libc}" | grep "\."` ] || pkg_libc="unknown"
if [ "${pkg_arch}" = "unknown" ]; then
  target_triplet=`gcc -v 2>&1 | grep "Target:" | awk '{print $2}' | tr '-' ' '`
  case `uname -m` in
    ppc)
      pkg_arch="powerpc"
      ;;
    *)
      pkg_arch=`echo "${target_triplet}" | awk '{print $1}'`
      ;;
  esac
fi
if [ "${pkg_libc}" = "unknown" ] || [ "${pkg_libc}" = "${PKGTITLE}" ]; then
  target_triplet=`gcc -v 2>&1 | grep "Target:" | awk '{print $2}' | tr '-' ' '`
  pkg_libc=`echo "${target_triplet}" | awk '{print $4}'`
  [ `ls /lib/ld-* | grep uClibc | wc -l` -ne 0 ] && pkg_libc="uclibc"
  [ -z "${pkg_libc}" ] && pkg_libc="unknown"
fi

pkg_with_version=`echo "${pkg_with_version}" | sed -e "s/-${pkg_arch}-${pkg_libc}//"`
srcpkg_pkg=`ls -tp "${BUILD_FARM}"/PACKAGES/srcpkg/"${PKGPREFIX}"/"${pkg_with_version}"* 2>/dev/null | grep ".srcpkg." | grep -v "raw" | head -1`
binpkg_pkg=`ls -tp "${BUILD_FARM}"/PACKAGES/binpkg-"${pkg_arch}"/"${PKGPREFIX}"/"${pkg_with_version}"* 2>/dev/null | grep ".binpkg." | head -1`
if [ -z "${binpkg_pkg}" ]; then
  binpkg_pkg=`ls -tp "${BUILD_FARM}"/PACKAGES/binpkg/"${PKGPREFIX}"/"${pkg_with_version}"* 2>/dev/null | grep ".binpkg." | grep "${pkg_arch}" | head -1`
fi
if [ -z "${binpkg_pkg}" ]; then
  binpkg_pkg=`ls -tp "${BUILD_FARM}"/PACKAGES/binpkg-*/"${PKGPREFIX}"/"${pkg_with_version}"* 2>/dev/null | grep ".binpkg." | grep "${pkg_arch}" | head -1`
fi

[ ! -z "${pkg_with_version}" ] && printf "%s (%s" "${pkg_with_version}" "${pkg_arch}"
if [ -z ${LIST_PKGS_MODE} ]; then echo "+${pkg_libc})"; else echo ")"; fi
echo "packages:"
[ -z "${srcpkg_pkg}" ] || print_pkg_size "${srcpkg_pkg}"
if [ ! -z "${binpkg_pkg}" ]; then
  [ -f "${binpkg_pkg}" ] && print_pkg_size "${binpkg_pkg}"
fi
if [ -z "${srcpkg_pkg}" ] && [ -z "${binpkg_pkg}" ]; then
  printf "\t%s\n" "... no packages found ..."
fi

echo "Done!"
Unless otherwise stated, the content of this page is licensed under GNU Free Documentation License.