#!/bin/bash

# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2009-2016 Stephan Raue (stephan@openelec.tv)

. config/options $1

if [ "$1" = "--all" ]; then
  if [ ! -z "$2" ]; then
    for build_dir in $(ls -1d ${ROOT}/build.*); do
      load_build_config ${build_dir} && ./scripts/build $2
    done
  fi
  exit 0
fi

if [ -z "$1" ]; then
  echo "usage: $0 package_name[:<host|target|init|bootstrap>]"
  exit 1
fi

if [ ! -f $PKG_DIR/package.mk ]; then
  printf "$(print_color CLR_ERROR "$1: no package.mk file found")\n"
  exit 1
fi

# set defaults
PKG_CONFIGURE_SCRIPT=""
PKG_MAKE_OPTS=""
PKG_MAKEINSTALL_OPTS=""

if [ "${1//:/}" != "${1}" ]; then
  PACKAGE_NAME="${1%:*}"
  TARGET="${1#*:}"
else
  PACKAGE_NAME=$1
  TARGET=
fi
[ -z "$TARGET" ] && TARGET="target"

if [ -n "$PKG_ARCH" ]; then
  listcontains "$PKG_ARCH" "!$TARGET_ARCH" && exit 0
  listcontains "$PKG_ARCH" "$TARGET_ARCH" || listcontains "$PKG_ARCH" "any" || exit 0
fi

unset INSTALL

mkdir -p $STAMPS/$PACKAGE_NAME
STAMP=$STAMPS/$PACKAGE_NAME/build_$TARGET

$SCRIPTS/unpack $PACKAGE_NAME

if [ -f $STAMP ] ; then
  . $STAMP
  PKG_DEEPHASH=$(calculate_stamp)
  if [ ! "$PKG_DEEPHASH" = "$STAMP_PKG_DEEPHASH" ] ; then
    rm -f $STAMP
  fi

  if [ ! "$BUILD_WITH_DEBUG" = "$STAMP_BUILD_WITH_DEBUG" ]; then
    rm -f $STAMP
  fi

  if [ "$1" = "u-boot" -a ! "$UBOOT_SYSTEM" = "$STAMP_UBOOT_SYSTEM" ]; then
    rm -f $STAMP
  fi
fi

if [ -f $STAMP ]; then
  # already build, do nothing
  exit 0
fi
rm -f $STAMP

setup_toolchain $TARGET

# unset functions
unset -f configure_package
unset -f pre_build_target
unset -f pre_configure_target
unset -f configure_target
unset -f post_configure_target
unset -f pre_make_target
unset -f make_target
unset -f post_make_target
unset -f pre_makeinstall_target
unset -f makeinstall_target
unset -f post_makeinstall_target

unset -f pre_build_host
unset -f pre_configure_host
unset -f configure_host
unset -f post_configure_host
unset -f pre_make_host
unset -f make_host
unset -f post_make_host
unset -f pre_makeinstall_host
unset -f makeinstall_host
unset -f post_makeinstall_host

unset -f pre_build_init
unset -f pre_configure_init
unset -f configure_init
unset -f post_configure_init
unset -f pre_make_init
unset -f make_init
unset -f post_make_init
unset -f pre_makeinstall_init
unset -f makeinstall_init
unset -f post_makeinstall_init

unset -f pre_build_bootstrap
unset -f pre_configure_bootstrap
unset -f configure_bootstrap
unset -f post_configure_bootstrap
unset -f pre_make_bootstrap
unset -f make_bootstrap
unset -f post_make_bootstrap
unset -f pre_makeinstall_bootstrap
unset -f makeinstall_bootstrap
unset -f post_makeinstall_bootstrap

# configure debug build defaults
if [ "${BUILD_WITH_DEBUG}" = "yes" ]; then
  CMAKE_BUILD_TYPE="Debug"
  MESON_BUILD_TYPE="debug"
else
  CMAKE_BUILD_TYPE="MinSizeRel"
  MESON_BUILD_TYPE="plain"
fi

# configure TARGET build defaults
TARGET_CONFIGURE_OPTS="--host=$TARGET_NAME \
                       --build=$HOST_NAME \
                       --prefix=/usr \
                       --bindir=/usr/bin \
                       --sbindir=/usr/sbin \
                       --sysconfdir=/etc \
                       --libdir=/usr/lib \
                       --libexecdir=/usr/lib \
                       --localstatedir=/var \
                       --disable-static \
                       --enable-shared"

CMAKE_GENERATOR_NINJA="-GNinja \
                       -DCMAKE_EXPORT_COMPILE_COMMANDS=ON"

TARGET_CMAKE_OPTS="-DCMAKE_TOOLCHAIN_FILE=$CMAKE_CONF \
                   -DCMAKE_INSTALL_PREFIX=/usr \
                   -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE"

TARGET_MESON_OPTS="--prefix=/usr \
                   --bindir=/usr/bin \
                   --sbindir=/usr/sbin \
                   --sysconfdir=/etc \
                   --libdir=/usr/lib \
                   --libexecdir=/usr/lib \
                   --localstatedir=/var \
                   --buildtype=$MESON_BUILD_TYPE"

# configure HOST build defaults
HOST_CONFIGURE_OPTS="--host=$HOST_NAME \
                     --build=$HOST_NAME \
                     --prefix=$TOOLCHAIN \
                     --bindir=$TOOLCHAIN/bin \
                     --sbindir=$TOOLCHAIN/sbin \
                     --sysconfdir=$TOOLCHAIN/etc \
                     --libexecdir=$TOOLCHAIN/lib \
                     --localstatedir=$TOOLCHAIN/var \
                     --disable-static \
                     --enable-shared"

HOST_CMAKE_OPTS="$CMAKE_GENERATOR \
                 -DCMAKE_TOOLCHAIN_FILE=$CMAKE_CONF \
                 -DCMAKE_INSTALL_PREFIX=$TOOLCHAIN"

HOST_MESON_OPTS="--prefix=$TOOLCHAIN \
                 --bindir=$TOOLCHAIN/bin \
                 --sbindir=$TOOLCHAIN/sbin \
                 --sysconfdir=$TOOLCHAIN/etc \
                 --libdir=$TOOLCHAIN/lib \
                 --libexecdir=$TOOLCHAIN/lib \
                 --localstatedir=$TOOLCHAIN/var \
                 --buildtype=plain"

# configure INIT build defaults
INIT_CONFIGURE_OPTS="$TARGET_CONFIGURE_OPTS"
INIT_CMAKE_OPTS="$TARGET_CMAKE_OPTS"
INIT_MESON_OPTS="$TARGET_MESON_OPTS"

# configure BOOTSTRAP build defaults
BOOTSTRAP_CONFIGURE_OPTS="$HOST_CONFIGURE_OPTS"
BOOTSTRAP_CMAKE_OPTS="$HOST_CMAKE_OPTS"
BOOTSTRAP_MESON_OPTS="$HOST_MESON_OPTS"

# include buildfile
. $PKG_DIR/package.mk

# finalise package configuration
if [ "$(type -t configure_package)" = "function" ]; then
  configure_package
fi

# build dependencies, only when PKG_DEPENDS_? is filled
unset _pkg_depends
case "$TARGET" in
  "target") _pkg_depends="$PKG_DEPENDS_TARGET";;
  "host") _pkg_depends="$PKG_DEPENDS_HOST";;
  "init") _pkg_depends="$PKG_DEPENDS_INIT";;
  "bootstrap") _pkg_depends="$PKG_DEPENDS_BOOTSTRAP";;
esac
for p in $_pkg_depends; do
  $SCRIPTS/build $p
done

if [ "${BUILD_WITH_DEBUG}" = "yes" ]; then
  printf "%${BUILD_INDENT}c $(print_color CLR_BUILD "BUILD")    $PACKAGE_NAME $(print_color CLR_TARGET "($TARGET)") [DEBUG]\n" ' '>&$SILENT_OUT
else
  printf "%${BUILD_INDENT}c $(print_color CLR_BUILD "BUILD")    $PACKAGE_NAME $(print_color CLR_TARGET "($TARGET)")\n" ' '>&$SILENT_OUT
fi
export BUILD_INDENT=$((${BUILD_INDENT:-1}+$BUILD_INDENT_SIZE))

# virtual packages dont must be build, they only contains dependencies, so dont go further here
if [ "$PKG_SECTION" = "virtual" ]; then
  PKG_DEEPHASH=$(calculate_stamp)
  for i in PKG_NAME PKG_DEEPHASH BUILD_WITH_DEBUG; do
    echo "STAMP_$i=\"${!i}\"" >> $STAMP
  done

  exit 0
fi

# configure other variables
if [ "$TARGET" = "target" ]; then
  INSTALL=$PKG_BUILD/.install_pkg
elif [ "$TARGET" = "init" ]; then
  INSTALL=$PKG_BUILD/.install_init
fi

# clean up
if [ ! -z "$INSTALL" ] ; then
  if [ -d "$INSTALL" ] ; then
    rm -rf $INSTALL
  fi
fi

# setup configure script
if [ -z "$PKG_CONFIGURE_SCRIPT" ]; then
  PKG_CONFIGURE_SCRIPT="$PKG_BUILD/configure"
else
  PKG_CONFIGURE_SCRIPT="$PKG_BUILD/$PKG_CONFIGURE_SCRIPT"
fi

if [ -z "$PKG_CMAKE_SCRIPT" ]; then
  PKG_CMAKE_SCRIPT="$PKG_BUILD/CMakeLists.txt"
fi

if [ -z "$PKG_MESON_SCRIPT" ]; then
  PKG_MESON_SCRIPT="$PKG_BUILD/meson.build"
fi

# auto detect toolchain
_auto_toolchain=""
if [ -z "$PKG_TOOLCHAIN" -o "$PKG_TOOLCHAIN" = "auto" ]; then
  if [ -f "$PKG_MESON_SCRIPT" ]; then
    PKG_TOOLCHAIN="meson"
  elif [ -f "$PKG_CMAKE_SCRIPT" ]; then
    PKG_TOOLCHAIN="cmake"
  elif [ -f "$PKG_CONFIGURE_SCRIPT" ]; then
    PKG_TOOLCHAIN="configure"
  elif [ -f $PKG_BUILD/Makefile ]; then
    PKG_TOOLCHAIN="make"
  else
    echo "Not possible to detect toolchain automatically. Add PKG_TOOLCHAIN= to package.mk"
    exit 1
  fi
  _auto_toolchain=" (auto-detect)"
fi
if ! listcontains "meson cmake cmake-make configure ninja make autotools manual" "$PKG_TOOLCHAIN"; then
  printf "$(print_color bold-red "ERROR:") unknown toolchain $PKG_TOOLCHAIN"
  exit 1
fi
printf "%${BUILD_INDENT}c $(print_color CLR_TOOLCHAIN "TOOLCHAIN")    $PKG_TOOLCHAIN${_auto_toolchain}\n" ' '>&$SILENT_OUT

# make autoreconf
if [ "$PKG_TOOLCHAIN" = "autotools" ]; then
  $SCRIPTS/autoreconf $PACKAGE_NAME
fi

# include build template and build
if [ "$(type -t pre_build_$TARGET)" = "function" ]; then
  pre_build_$TARGET
fi

# ensure $PKG_BUILD is there. (installer? PKG_URL="")
if [ ! -d $PKG_BUILD ] ; then
  mkdir -p $PKG_BUILD
fi

cd $PKG_BUILD

if [ -f "$PKG_CONFIGURE_SCRIPT" -o -f "$PKG_CMAKE_SCRIPT" -o -f "$PKG_MESON_SCRIPT" ]; then
  case "$TARGET" in
    "target")    PKG_REAL_BUILD="$PKG_BUILD/.$TARGET_NAME" ;;
    "host")      PKG_REAL_BUILD="$PKG_BUILD/.$HOST_NAME" ;;
    "init")      PKG_REAL_BUILD="$PKG_BUILD/.$TARGET_NAME-$TARGET" ;;
    "bootstrap") PKG_REAL_BUILD="$PKG_BUILD/.$HOST_NAME-$TARGET" ;;
  esac
  mkdir -p $PKG_REAL_BUILD
  cd $PKG_REAL_BUILD
  
  MESON_CONF="$PKG_REAL_BUILD/meson.conf"
fi

# configure
if [ "$(type -t pre_configure_$TARGET)" = "function" ]; then
  pre_configure_$TARGET
fi
if [ "$(type -t configure_$TARGET)" = "function" ]; then
  configure_$TARGET
else
  case "$PKG_TOOLCHAIN:$TARGET" in
    # meson builds
    "meson:target")
      create_meson_conf $TARGET $MESON_CONF
      echo "Executing (target): meson $TARGET_MESON_OPTS --cross-file=$MESON_CONF $PKG_MESON_OPTS_TARGET $(dirname $PKG_MESON_SCRIPT)" | tr -s " "
      CC="$HOST_CC" CXX="$HOST_CXX" meson $TARGET_MESON_OPTS --cross-file=$MESON_CONF $PKG_MESON_OPTS_TARGET $(dirname $PKG_MESON_SCRIPT)
      ;;
    "meson:host")
      create_meson_conf $TARGET $MESON_CONF
      echo "Executing (host): meson $HOST_MESON_OPTS --cross-file=$MESON_CONF $PKG_MESON_OPTS_HOST $(dirname $PKG_MESON_SCRIPT)" | tr -s " "
      meson $HOST_MESON_OPTS --cross-file=$MESON_CONF $PKG_MESON_OPTS_HOST $(dirname $PKG_MESON_SCRIPT)
      ;;
    "meson:init")
      create_meson_conf $TARGET $MESON_CONF
      echo "Executing (init): meson $INIT_MESON_OPTS --cross-file=$MESON_CONF $PKG_MESON_OPTS_INIT $(dirname $PKG_MESON_SCRIPT)" | tr -s " "
      meson $INIT_MESON_OPTS --cross-file=$MESON_CONF $PKG_MESON_OPTS_INIT $(dirname $PKG_MESON_SCRIPT)
      ;;
    "meson:bootstrap")
      create_meson_conf $TARGET $MESON_CONF
      echo "Executing (bootstrap): meson $BOOTSTRAP_MESON_OPTS --cross-file=$MESON_CONF $PKG_MESON_OPTS_BOOTSTRAP $(dirname $PKG_MESON_SCRIPT)" | tr -s " "
      meson $BOOTSTRAP_MESON_OPTS --cross-file=$MESON_CONF $PKG_MESON_OPTS_BOOTSTRAP $(dirname $PKG_MESON_SCRIPT)
      ;;

    # cmake builds with ninja
    "cmake:target")
      echo "Executing (target): cmake $CMAKE_GENERATOR_NINJA $TARGET_CMAKE_OPTS $PKG_CMAKE_OPTS_TARGET $(dirname $PKG_CMAKE_SCRIPT)" | tr -s " "
      cmake $CMAKE_GENERATOR_NINJA $TARGET_CMAKE_OPTS $PKG_CMAKE_OPTS_TARGET $(dirname $PKG_CMAKE_SCRIPT)
      ;;
    "cmake:host")
      echo "Executing (host): cmake $CMAKE_GENERATOR_NINJA $HOST_CMAKE_OPTS $PKG_CMAKE_OPTS_HOST $(dirname $PKG_CMAKE_SCRIPT)" | tr -s " "
      cmake $CMAKE_GENERATOR_NINJA $HOST_CMAKE_OPTS $PKG_CMAKE_OPTS_HOST $(dirname $PKG_CMAKE_SCRIPT)
      ;;
    "cmake:init")
      echo "Executing (init): cmake $CMAKE_GENERATOR_NINJA $INIT_CMAKE_OPTS $PKG_CMAKE_OPTS_INIT $(dirname $PKG_CMAKE_SCRIPT)" | tr -s " "
      cmake $CMAKE_GENERATOR_NINJA $INIT_CMAKE_OPTS $PKG_CMAKE_OPTS_INIT $(dirname $PKG_CMAKE_SCRIPT)
      ;;
    "cmake:bootstrap")
      echo "Executing (bootstrap): cmake $CMAKE_GENERATOR_NINJA $BOOTSTRAP_CMAKE_OPTS $PKG_CMAKE_OPTS_BOOTSTRAP $(dirname $PKG_CMAKE_SCRIPT)" | tr -s " "
      cmake $CMAKE_GENERATOR_NINJA $BOOTSTRAP_CMAKE_OPTS $PKG_CMAKE_OPTS_BOOTSTRAP $(dirname $PKG_CMAKE_SCRIPT)
      ;;

    # cmake builds with make
    "cmake-make:target")
      echo "Executing (target): cmake $TARGET_CMAKE_OPTS $PKG_CMAKE_OPTS_TARGET $(dirname $PKG_CMAKE_SCRIPT)" | tr -s " "
      cmake $TARGET_CMAKE_OPTS $PKG_CMAKE_OPTS_TARGET $(dirname $PKG_CMAKE_SCRIPT)
      ;;
    "cmake-make:host")
      echo "Executing (host): cmake $HOST_CMAKE_OPTS $PKG_CMAKE_OPTS_HOST $(dirname $PKG_CMAKE_SCRIPT)" | tr -s " "
      cmake $HOST_CMAKE_OPTS $PKG_CMAKE_OPTS_HOST $(dirname $PKG_CMAKE_SCRIPT)
      ;;
    "cmake-make:init")
      echo "Executing (init): cmake $INIT_CMAKE_OPTS $PKG_CMAKE_OPTS_INIT $(dirname $PKG_CMAKE_SCRIPT)" | tr -s " "
      cmake $INIT_CMAKE_OPTS $PKG_CMAKE_OPTS_INIT $(dirname $PKG_CMAKE_SCRIPT)
      ;;
    "cmake-make:bootstrap")
      echo "Executing (bootstrap): cmake $BOOTSTRAP_CMAKE_OPTS $PKG_CMAKE_OPTS_BOOTSTRAP $(dirname $PKG_CMAKE_SCRIPT)" | tr -s " "
      cmake $BOOTSTRAP_CMAKE_OPTS $PKG_CMAKE_OPTS_BOOTSTRAP $(dirname $PKG_CMAKE_SCRIPT)
      ;;

    # configure builds
    "configure:target"|"autotools:target")
      echo "Executing (target): $PKG_CONFIGURE_SCRIPT $TARGET_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_TARGET" | tr -s " "
      $PKG_CONFIGURE_SCRIPT $TARGET_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_TARGET
      ;;
    "configure:host"|"autotools:host")
      echo "Executing (host): $PKG_CONFIGURE_SCRIPT $HOST_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_HOST" | tr -s " "
      $PKG_CONFIGURE_SCRIPT $HOST_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_HOST
      ;;
    "configure:init"|"autotools:init")
      echo "Executing (init): $PKG_CONFIGURE_SCRIPT $INIT_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_INIT" | tr -s " "
      $PKG_CONFIGURE_SCRIPT $INIT_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_INIT
      ;;
    "configure:bootstrap"|"autotools:bootstrap")
      echo "Executing (bootstrap): $PKG_CONFIGURE_SCRIPT $BOOTSTRAP_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_BOOTSTRAP" | tr -s " "
      $PKG_CONFIGURE_SCRIPT $BOOTSTRAP_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_BOOTSTRAP
      ;;
  esac
fi
if [ "$(type -t post_configure_$TARGET)" = "function" ]; then
  post_configure_$TARGET
fi

# make
if [ "$(type -t pre_make_$TARGET)" = "function" ]; then
  pre_make_$TARGET
fi
if [ "$(type -t make_$TARGET)" = "function" ]; then
  make_$TARGET
else
  case "$PKG_TOOLCHAIN:$TARGET" in
    # ninja based builds
    "meson:target"|"cmake:target"|"ninja:target")
      echo "Executing (target): ninja $PKG_MAKE_OPTS_TARGET" | tr -s " "
      ninja $NINJA_OPTS $PKG_MAKE_OPTS_TARGET
      ;;
    "meson:host"|"cmake:host"|"ninja:host")
      echo "Executing (host): ninja $PKG_MAKE_OPTS_HOST" | tr -s " "
      ninja $NINJA_OPTS $PKG_MAKE_OPTS_HOST
      ;;
    "meson:init"|"cmake:init"|"ninja:init")
      echo "Executing (init): ninja $PKG_MAKE_OPTS_INIT" | tr -s " "
      ninja $NINJA_OPTS $PKG_MAKE_OPTS_INIT
      ;;
    "meson:bootstrap"|"cmake:bootstrap"|"ninja:bootstrap")
      echo "Executing (bootstrap): ninja $PKG_MAKE_OPTS_BOOTSTRAP" | tr -s " "
      ninja $NINJA_OPTS $PKG_MAKE_OPTS_BOOTSTRAP
      ;;

    # make based builds
    "configure:target"|"cmake-make:target"|"autotools:target"|"make:target")
      echo "Executing (target): make $PKG_MAKE_OPTS_TARGET" | tr -s " "
      make $PKG_MAKE_OPTS_TARGET
      ;;
    "configure:host"|"cmake-make:host"|"autotools:host"|"make:host")
      echo "Executing (host): make $PKG_MAKE_OPTS_HOST" | tr -s " "
      make $PKG_MAKE_OPTS_HOST
      ;;
    "configure:init"|"cmake-make:init"|"autotools:init"|"make:init")
      echo "Executing (init): make $PKG_MAKE_OPTS_INIT" | tr -s " "
      make $PKG_MAKE_OPTS_INIT
      ;;
    "configure:bootstrap"|"cmake-make:bootstrap"|"autotools:bootstrap"|"make:bootstrap")
      echo "Executing (bootstrap): make $PKG_MAKE_OPTS_BOOTSTRAP" | tr -s " "
      make $PKG_MAKE_OPTS_BOOTSTRAP
      ;;
  esac
fi
if [ "$(type -t post_make_$TARGET)" = "function" ]; then
  post_make_$TARGET
fi

# make install
if [ "$(type -t pre_makeinstall_$TARGET)" = "function" ]; then
  pre_makeinstall_$TARGET
fi
if [ "$(type -t makeinstall_$TARGET)" = "function" ]; then
  makeinstall_$TARGET
else
  case "$PKG_TOOLCHAIN:$TARGET" in
    # ninja based builds
    "meson:target"|"cmake:target")
      DESTDIR=$SYSROOT_PREFIX ninja install $PKG_MAKEINSTALL_OPTS_TARGET
      DESTDIR=$INSTALL ninja install $PKG_MAKEINSTALL_OPTS_TARGET
      ;;
    "meson:host"|"cmake:host")
      ninja install $PKG_MAKEINSTALL_OPTS_HOST
      ;;
    "meson:init"|"cmake:init")
      DESTDIR=$INSTALL ninja install $PKG_MAKEINSTALL_OPTS_INIT
      ;;
    "meson:bootstrap"|"cmake:bootstrap")
      ninja install $PKG_MAKEINSTALL_OPTS_BOOTSTRAP
      ;;

    # make based builds
    "configure:target"|"cmake-make:target"|"autotools:target"|"make:target")
      $MAKEINSTALL $PKG_MAKEINSTALL_OPTS_TARGET
      make install DESTDIR=$INSTALL $PKG_MAKEINSTALL_OPTS_TARGET
      ;;
    "configure:host"|"cmake-make:host"|"autotools:host"|"make:host")
      make install $PKG_MAKEINSTALL_OPTS_HOST
      ;;
    "configure:init"|"cmake-make:init"|"autotools:init"|"make:init")
      make install DESTDIR=$INSTALL $PKG_MAKEINSTALL_OPTS_INIT
      ;;
    "configure:bootstrap"|"cmake-make:bootstrap"|"autotools:bootstrap"|"make:bootstrap")
      make install $PKG_MAKEINSTALL_OPTS_BOOTSTRAP
      ;;
  esac
fi
if [ "$(type -t post_makeinstall_$TARGET)" = "function" ]; then
  post_makeinstall_$TARGET
fi

if [ "$TARGET" = "target" -o "$TARGET" = "init" ]; then
  if [ -d $INSTALL ] ; then
    rm -rf $INSTALL/{usr/,}include
    rm -rf $INSTALL/{usr/,}lib/cmake
    rm -rf $INSTALL/{usr/,}lib/pkgconfig
    rm -rf $INSTALL/{usr/,}man
    rm -rf $INSTALL/{usr/,}share/aclocal
    rm -rf $INSTALL/{usr/,}share/bash-completion
    rm -rf $INSTALL/{usr/,}share/doc
    rm -rf $INSTALL/{usr/,}share/gtk-doc
    rm -rf $INSTALL/{usr/,}share/info
    rm -rf $INSTALL/{usr/,}share/locale
    rm -rf $INSTALL/{usr/,}share/man
    rm -rf $INSTALL/{usr/,}share/pkgconfig
    rm -rf $INSTALL/{usr/,}share/zsh
    rm -rf $INSTALL/{usr/,}var
    find $INSTALL \( -name "*.orig" \
                  -o -name "*.rej" \
                  -o -name "*.a" \
                  -o -name "*.la" \
                  -o -name "*.o" \
                  -o -name "*.in" \
                  -o -name ".git*" \) \
        -exec rm -f {} \; 2>/dev/null || :
    find $INSTALL -type d -exec rmdir -p {} \; 2>/dev/null || :

    if [ ! "${BUILD_WITH_DEBUG}" = "yes" ]; then
      $STRIP `find $INSTALL \
        -type f -name "*.so*" \
        ! -name "ld-*.so" \
        ! -name "libc-*.so" \
        ! -name "libpthread-*.so" \
        ! -name "libthread_db-*so" \
        2>/dev/null` 2>/dev/null || :
        if [ "$TARGET" = "init" ]; then
          $STRIP `find $INSTALL -type f -name "*.so*" 2>/dev/null` 2>/dev/null || :
        fi
        $STRIP `find $INSTALL/bin $INSTALL/usr/bin $INSTALL/sbin $INSTALL/usr/sbin \
          -type f -executable 2>/dev/null` 2>/dev/null || :
    fi
  fi
fi

cd $ROOT

for i in `find $SYSROOT_PREFIX/usr/lib/ -name "*.la" 2>/dev/null`; do \
  $SED "s:\(['= ]\)/usr:\\1$SYSROOT_PREFIX/usr:g" $i; \
done

PKG_DEEPHASH=$(calculate_stamp)
for i in PKG_NAME PKG_DEEPHASH BUILD_WITH_DEBUG; do
  echo "STAMP_$i=\"${!i}\"" >> $STAMP
done

if [ "$1" = "u-boot" ]; then
  echo "STAMP_UBOOT_SYSTEM=\"${UBOOT_SYSTEM}\"" >> $STAMP
fi