Lakka-LibreELEC/scripts/build

#!/bin/bash

################################################################################
#      This file is part of OpenELEC - http://www.openelec.tv
#      Copyright (C) 2009-2016 Stephan Raue (stephan@openelec.tv)
#
#  OpenELEC is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 2 of the License, or
#  (at your option) any later version.
#
#  OpenELEC is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with OpenELEC.  If not, see <http://www.gnu.org/licenses/>.
################################################################################

. config/options $1

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

if [ ! -f $PKG_DIR/package.mk ]; then
  printf "${boldred}$1: no package.mk file found${endcolor}\n"
  exit 1
fi

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

  PACKAGE_NAME=$(echo $1 | awk -F : '{print $1}')
  TARGET=$(echo $1 | awk -F : '{print $2}')
  if [ -z "$TARGET" ]; then
    TARGET="target"
  fi

if [ -n "$PKG_ARCH" -a ! "$PKG_ARCH" = "any" ]; then
  echo "$PKG_ARCH" | grep -q "$TARGET_ARCH" || exit 0
  echo "$PKG_ARCH" | grep -q "\-$TARGET_ARCH" && exit 0
fi

unset INSTALL

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

$SCRIPTS/unpack $PACKAGE_NAME

STAMP_DEPENDS="$PKG_DIR $PKG_NEED_UNPACK $PROJECT_DIR/$PROJECT/patches/$PKG_NAME"

if [ -f $STAMP ] ; then
  . $STAMP
  PKG_DEEPMD5=$(find $STAMP_DEPENDS -exec md5sum {} \; 2>/dev/null | sort | md5sum | cut -d" " -f1)
  if [ ! "$PKG_DEEPMD5" = "$STAMP_PKG_DEEPMD5" ] ; then
    rm -f $STAMP
  fi
fi

if [ ! -f $STAMP ]; then
  rm -f $STAMP

  if [ "$TARGET" = "bootstrap" -o "$TARGET" = "init" ]; then
    setup_toolchain target
  else
    setup_toolchain $TARGET
  fi

  # unset functions
    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 TARGET build defaults
    unset -v TARGET_CONFIGURE_OPTS
    TARGET_CONFIGURE_OPTS="--host=$TARGET_NAME \
                           --build=$HOST_NAME \
                           --prefix=/usr \
                           --bindir=/usr/bin \
                           --sbindir=/usr/sbin \
                           --sysconfdir=/etc \
                           --libexecdir=/usr/lib \
                           --localstatedir=/var \
                           --disable-static \
                           --enable-shared"

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

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

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

  # include buildfile
    . $PKG_DIR/package.mk

    if [ "$TARGET" = "target" ]; then
      for p in $PKG_DEPENDS_TARGET; do
        $SCRIPTS/build $p
      done
    elif [ "$TARGET" = "host" ]; then
      for p in $PKG_DEPENDS_HOST; do
        $SCRIPTS/build $p
      done
    elif [ "$TARGET" = "init" ]; then
      for p in $PKG_DEPENDS_INIT; do
        $SCRIPTS/build $p
      done
    elif [ "$TARGET" = "bootstrap" ]; then
      for p in $PKG_DEPENDS_BOOTSTRAP; do
        $SCRIPTS/build $p
      done
    fi

    printf "%${BUILD_INDENT}c ${boldyellow}BUILD${endcolor}    $PACKAGE_NAME ${boldwhite}($TARGET)${endcolor}\n" ' '>&$SILENT_OUT
    export BUILD_INDENT=$((${BUILD_INDENT:-1}+$BUILD_INDENT_SIZE))

    if [ "$PKG_AUTORECONF" = yes ]; then
      $SCRIPTS/autoreconf $PACKAGE_NAME
    fi

    # virtual packages dont must be build, they only contains dependencies, so dont go further here
    if [ ! "$PKG_SECTION" = "virtual" ]; then

      # configure other variables
      if [ "$TARGET" = "target" ]; then
        INSTALL=$ROOT/$PKG_BUILD/.install_pkg
      elif [ "$TARGET" = "init" ]; then
        INSTALL=$ROOT/$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="$ROOT/$PKG_BUILD/configure"
      else
        PKG_CONFIGURE_SCRIPT="$ROOT/$PKG_BUILD/$PKG_CONFIGURE_SCRIPT"
      fi
      if [ -z "$PKG_CMAKE_SCRIPT" ]; then
        PKG_CMAKE_SCRIPT="$ROOT/$PKG_BUILD/CMakeLists.txt"
      else
        PKG_CMAKE_SCRIPT="$ROOT/$PKG_BUILD/$PKG_CMAKE_SCRIPT"
      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 [ "$TARGET" = "target" ]; then
        if [ -f "$PKG_CONFIGURE_SCRIPT" -o -f "$PKG_CMAKE_SCRIPT" ]; then
          mkdir -p .$TARGET_NAME
          cd .$TARGET_NAME
        fi
      elif [ "$TARGET" = "host" ]; then
        if [ -f "$PKG_CONFIGURE_SCRIPT" -o -f "$PKG_CMAKE_SCRIPT" ]; then
          mkdir -p .$HOST_NAME
          cd .$HOST_NAME
        fi
      elif [ "$TARGET" = "init" ]; then
        if [ -f "$PKG_CONFIGURE_SCRIPT" -o -f "$PKG_CMAKE_SCRIPT" ]; then
          mkdir -p .$TARGET_NAME-init
          cd .$TARGET_NAME-init
        fi
      elif [ "$TARGET" = "bootstrap" ]; then
        if [ -f "$PKG_CONFIGURE_SCRIPT" -o -f "$PKG_CMAKE_SCRIPT" ]; then
          mkdir -p .$TARGET_NAME-bootstrap
          cd .$TARGET_NAME-bootstrap
        fi
      fi

      # configure
      if [ "$(type -t pre_configure_$TARGET)" = "function" ]; then
        pre_configure_$TARGET
      fi
      if [ "$(type -t configure_$TARGET)" = "function" ]; then
        configure_$TARGET
      elif [ -f "$PKG_CONFIGURE_SCRIPT" ]; then
        if [ "$TARGET" = "target" ]; then
          $PKG_CONFIGURE_SCRIPT $TARGET_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_TARGET
        elif [ "$TARGET" = "host" ]; then
          $PKG_CONFIGURE_SCRIPT $HOST_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_HOST
        elif [ "$TARGET" = "init" ]; then
          $PKG_CONFIGURE_SCRIPT $INIT_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_INIT
        elif [ "$TARGET" = "bootstrap" ]; then
          $PKG_CONFIGURE_SCRIPT $BOOTSTRAP_CONFIGURE_OPTS $PKG_CONFIGURE_OPTS_BOOTSTRAP
        fi
      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
        if [ "$TARGET" = "target" ]; then
          make $PKG_MAKE_OPTS_TARGET
        elif [ "$TARGET" = "host" ]; then
          make $PKG_MAKE_OPTS_HOST
        elif [ "$TARGET" = "init" ]; then
          make $PKG_MAKE_OPTS_INIT
        elif [ "$TARGET" = "bootstrap" ]; then
          make $PKG_MAKE_OPTS_BOOTSTRAP
        fi
      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
        if [ "$TARGET" = "target" ]; then
          $MAKEINSTALL $PKG_MAKEINSTALL_OPTS_TARGET
          make install DESTDIR=$INSTALL $PKG_MAKEINSTALL_OPTS_TARGET
        elif [ "$TARGET" = "host" ]; then
          make install $PKG_MAKEINSTALL_OPTS_HOST
        elif [ "$TARGET" = "init" ]; then
          make install DESTDIR=$INSTALL $PKG_MAKEINSTALL_OPTS_INIT
        elif [ "$TARGET" = "bootstrap" ]; then
          $MAKEINSTALL $PKG_MAKEINSTALL_OPTS_BOOTSTRAP
        fi
      fi
      if [ "$(type -t post_makeinstall_$TARGET)" = "function" ]; then
        post_makeinstall_$TARGET
      fi

      if [ "$TARGET" = "target" -o "$TARGET" = "init" ]; then
       if [ -d $INSTALL ] ; then
         for i in $INSTALL $INSTALL/usr; do
            rm -rf $i/include
            rm -rf $i/lib/cmake
            rm -rf $i/lib/pkgconfig
            rm -rf $i/man
            rm -rf $i/share/aclocal
            rm -rf $i/share/bash-completion
            rm -rf $i/share/doc
            rm -rf $i/share/gtk-doc
            rm -rf $i/share/info
            rm -rf $i/share/locale
            rm -rf $i/share/man
            rm -rf $i/share/pkgconfig
            find $i -name "*.la" -exec rm -f "{}" ";" 2>/dev/null || true
            find $i -name "*.a" -exec rm -f "{}" ";" 2>/dev/null || true
            find $i -name "*.so*T" -exec rm -f "{}" ";" 2>/dev/null || true
            # patch backups nonsense
            find $i -name "*.orig" -exec rm -f "{}" ";" 2>/dev/null || true
            # kodi / addons nonsense
            find $i -name "addon.xml.in" -exec rm -f "{}" ";" 2>/dev/null || true
            find $i -name "Makefile.in" -exec rm -f "{}" ";" 2>/dev/null || true
          done

          find $INSTALL -type d -exec rmdir -p "{}" ";" 2>/dev/null || true

          if [ ! "$DEBUG" = yes ]; then
            $STRIP `find $INSTALL -name "*.so" 2>/dev/null` 2>/dev/null || :
            $STRIP `find $INSTALL -name "*.so.[0-9]*" 2>/dev/null` 2>/dev/null || :
          fi
        fi
      fi

      cd $ROOT
    fi  # ! "$PKG_SECTION" = "virtual"

    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_DEEPMD5=$(find $STAMP_DEPENDS -exec md5sum {} \; 2>/dev/null | sort | md5sum | cut -d" " -f1)
    for i in PKG_NAME PKG_DEEPMD5; do
      eval val=\$$i
      echo "STAMP_$i=\"$val\"" >> $STAMP
    done
fi