Subversion Repositories DevTools

################################################################################

#

#   NOTE:

#   This script will be run under a simple 'sh'

#   Jats will run .sh files under .sh. This is script to JATS and not

#   a stand alone program.

#

#   NOTE: sh under RHEL4 is more forgiving than under UBUNTU and SOLARIS

#         Test on multiple platforms.

#

################################################################################

#

# Force failed command to exit this shell - all commands must report success

set -e

echo

echo

#------------------------------------------------------------------------------

# Takes $1 and removes all relative paths (. and ..) from it.  The cleaned up

# directory is written to stdout.

#------------------------------------------------------------------------------

cleanup_dir ()

{

    DIR_PARTS=`echo $1 | sed "s|/| |g"`

    CLEANUP_DIR=""

    for PART in ${DIR_PARTS}; do

        if [ "${PART}" != "." ]; then

            if [ "${PART}" = ".." ]; then

                CLEANUP_DIR=`echo "${CLEANUP_DIR}" | sed "s|/[^/]*$||"`

            else

                CLEANUP_DIR="${CLEANUP_DIR}/${PART}"

            fi

        fi

    done

    echo ${CLEANUP_DIR}

} 

#------------------------------------------------------------------------------

# Extract arguments - order not important except that the first argument is

# the launch script

#------------------------------------------------------------------------------

unset CLEAN

unset COPY_MODS_DIRS

unset DOWNLOAD_PKG

unset DOWNLOAD_PKG_AUTO

unset DEBIAN_PACKAGE

unset APPLY_PATCHES

unset APPLY_MODS

unset CONFIG_VARIENT

unset WORK_DIR_NAME

unset XGCC_IN_PATH;

for arg in "$@" ; do

    val=${arg##*=}

    tag=${arg%%=*}

    case $tag in

        -XGccInPath)            XGCC_IN_PATH=1;; 

        -CopyModsDirs)          COPY_MODS_DIRS=1;;           

        -clean)                 CLEAN=1;;

        -ShellBuild)            SHELL_BUILD="$val";;

        -BuildName)             BUILD_NAME=$val;;

        -BuildVersion)          BUILD_VERSION=$val;;

        -Platform)              PLATFORM=$val;;

        -Type)                  TYPE=$val;;

        -Arch)                  ARCH=$val;;

        -MachType)              MACHTYPE=$val;;

        -BuildRoot)             BUILD_ROOT=$val;;

        -InterfaceDir)          INTERFACE_DIR=$val;;

        -LocalDir)              LOCAL_DIR=$val;;

        -LocalIncDir)           LOCAL_INC_DIR=$val;;

        -LocalBinDir)           LOCAL_BIN_DIR=$val;;

        -LocalLibDir)           LOCAL_LIB_DIR=$val;;

        -BinDir)                BIN_DIR=$val;;

        -LibDir)                LIB_DIR=$val;;

        -ObjDir)                OBJ_DIR=$val;;

        -PackageBinDir)         PKG_BIN_DIR=$val;;

        -PackageIncDir)         PKG_INC_DIR=$val;;

        -PackageLibDir)         PKG_LIB_DIR=$val;;

        -PackagePkgDir)         PKG_PKG_DIR=$val;;

        -PackageToolDir)        PKG_TOOL_DIR=$val;;

        -PackageToolBin)        PKG_TOOL_BIN_DIR=$val;;

        -PackageToolScript)     PKG_TOOL_SCRIPT_DIR=$val;;

        -PackageDir)            PKG_DIR=$val;;

        -CompilerPath)          COMPILER_DIR="$val";;

        -DownloadPkg)           DOWNLOAD_PKG="$val";;

        -DebianPackage)         DEBIAN_PACKAGE=$val;;

        -ApplyPatches)          APPLY_PATCHES=1;;

        -ApplyMods)             APPLY_MODS=1;;

        -ConfigVarient)         CONFIG_VARIENT=$val;;

        -WorkDir)               WORK_DIR_NAME=$val;;

        -WorkDirSuffix)         WORK_DIR_SUFFIX=$val;;

        *)                      echo "Unknown tag: $tag=$val"

    esac

done

if [ "${DOWNLOAD_PKG}" = "-DownloadPkg" ]; then

    DOWNLOAD_PKG_NAME=${BUILD_NAME}

    DOWNLOAD_PKG_VER=`echo ${BUILD_VERSION} | sed "s|\.[0-9]\+\.cots||"`

    DOWNLOAD_PKG=${DOWNLOAD_PKG_NAME}-${DOWNLOAD_PKG_VER}

else

    DOWNLOAD_PKG_VER=`echo ${DOWNLOAD_PKG} | sed "s|.*-||"`    

    DOWNLOAD_PKG_NAME=`echo ${DOWNLOAD_PKG} | sed "s|-${DOWNLOAD_PKG_VER}||"`    

fi

#------------------------------------------------------------------------------

# Dump JATS information for debugging purposes

#------------------------------------------------------------------------------

echo "="

echo "   JATS SUPPLIED FIELDS"

echo "="

echo " ShellBuild     = ${SHELL_BUILD}"

echo " BuildName      = ${BUILD_NAME} ${BUILD_VERSION}"

echo " Platform       = ${PLATFORM}"

echo " Type           = ${TYPE}"

echo " Arch           = ${ARCH}"

echo " MachType       = ${MACHTYPE}"

echo " BuildRoot      = ${BUILD_ROOT}"

echo " InterfaceDir   = ${INTERFACE_DIR}"

echo " LocalDir       = ${LOCAL_DIR}"

if [ ${DOWNLOAD_PKG} ]; then

    echo " DownloadPkg    = ${DOWNLOAD_PKG}"

fi    

echo " BinDir         = ${BIN_DIR}"

echo " LibDir         = ${LIB_DIR}"

echo " ObjDir         = ${OBJ_DIR}"

echo " PkgDir         = ${PKG_DIR}"

echo " PackageBinDir  = ${PKG_BIN_DIR}"

echo " PackageIncDir  = ${PKG_INC_DIR}"

echo " PackageLibDir  = ${PKG_LIB_DIR}"

echo " PackagePkgDir  = ${PKG_PKG_DIR}"

echo " CompilerDir    = ${COMPILER_DIR}"

echo "="

echo

echo

#------------------------------------------------------------------------------

# Determine host and build environments

#------------------------------------------------------------------------------

case ${MACHTYPE} in

    linux_i386)  

        COMPILE_BUILD="i386-cross-linux-gnu"

        ;;

    *)      

        echo "Unknown MACHTYPE=${MACHTYPE}"

        exit 1

        ;;

esac

case ${ARCH} in

    *603E*|*powerpc*)  

        COMPILE_HOST="powerpc-603e-linux-gnu"

        LINUX_HOST_ARCH=powerpc

        ;;

    ARMV9*)  

        COMPILE_HOST="arm-9tdmi-linux-gnu"

        LINUX_HOST_ARCH=arm

        ;;

    ARM926EJ*)

        COMPILE_HOST="arm-926ejs-linux-gnueabi"

        LINUX_HOST_ARCH=arm

        if [ "${XGCC_IN_PATH}" != "" ]; then

            echo "-XGccInPath is *NOT* supported by this platform by this version of ShellBuild"

            echo "Correct your shellbuild script so that it is not required."

            exit 1

        fi

        ;;

    armiwmmxt*)

        COMPILE_HOST="arm-iwmmxt-linux-gnueabi"

        LINUX_HOST_ARCH=arm

        if [ "${XGCC_IN_PATH}" != "" ]; then

            echo "-XGccInPath is *NOT* supported by this platform by this version of ShellBuild"

            echo "Correct your shellbuild script so that it is not required."

            exit 1

        fi

        ;;

    *I386*)

        if [ "${PLATFORM}" = "LINUX_I386" ]; then

            COMPILE_HOST="i386-cross-linux-gnu"

        elif [ "${PLATFORM}" = "UBUNTU12" ]; then

            COMPILE_HOST="i686-linux-gnu"

        else

            COMPILE_HOST="i586-unknown-linux-gnu"

        fi

        LINUX_HOST_ARCH=x86

        ;;

    *)

        echo "Unknown ARCH=${ARCH}"

        exit 1

        ;;

esac

# Setup the location of the cross compiler

if [ "${COMPILE_HOST}" = "i386-redhat-linux" ] || [ "${COMPILER_DIR}" = "gcc" ]; then

    XGCC_BASE_DIR=

else

    XGCC_BASE_DIR=`echo ${COMPILER_DIR} | sed 's|/[^/]*/[^/]*$||'`

    XGCC_BASE_DIR=`cleanup_dir ${XGCC_BASE_DIR}`

fi

# Determine the location of the generated files

CWD=`pwd`

BIN_DIR=`cleanup_dir ${CWD}/${BIN_DIR}`

LIB_DIR=`cleanup_dir ${CWD}/${LIB_DIR}`

OBJ_DIR=`cleanup_dir ${CWD}/${OBJ_DIR}`

PKG_DIR=`cleanup_dir ${CWD}/${PKG_DIR}`

PKG_BIN_DIR=`cleanup_dir ${CWD}/${PKG_BIN_DIR}`

PKG_INC_DIR=`cleanup_dir ${CWD}/${PKG_INC_DIR}`

PKG_LIB_DIR=`cleanup_dir ${CWD}/${PKG_LIB_DIR}`

PKG_PKG_DIR=`cleanup_dir ${CWD}/${PKG_PKG_DIR}`

PKG_TOOL_DIR=`cleanup_dir ${CWD}/${PKG_TOOL_DIR}`

PKG_TOOL_BIN_DIR=`cleanup_dir ${CWD}/${PKG_TOOL_BIN_DIR}`

PKG_TOOL_SCRIPT_DIR=`cleanup_dir ${CWD}/${PKG_TOOL_SCRIPT_DIR}`

BASE_DIR=`cleanup_dir ${CWD}/${BUILD_ROOT}`

INTERFACE_DIR=`cleanup_dir ${CWD}/${INTERFACE_DIR}`

LOCAL_DIR=`cleanup_dir ${CWD}/${LOCAL_DIR}`

LOCAL_INC_DIR=`cleanup_dir ${CWD}/${LOCAL_INC_DIR}`

LOCAL_BIN_DIR=`cleanup_dir ${CWD}/${LOCAL_BIN_DIR}`

LOCAL_LIB_DIR=`cleanup_dir ${CWD}/${LOCAL_LIB_DIR}`

LCL_SRC_DIR=${BASE_DIR}/src

SHARE_SRC_DIR=${LCL_SRC_DIR}

SHARE_BASE_DIR=${BASE_DIR}

DEB_PKG_DIR=${LIB_DIR}

AFC_DIR=${DEB_PKG_DIR}/afc

AFC_BIN_DIR=${AFC_DIR}/bin

AFC_LIB_DIR=${AFC_DIR}/lib

AFC_SHARE_DIR=${AFC_DIR}/share

DEB_DIR=`cleanup_dir ${CWD}/${DEBIAN_PACKAGE}`

# Find the launch script

LAUNCH_SCRIPT=`cleanup_dir ${LCL_SRC_DIR}/${SHELL_BUILD}`

if [ ! -f ${LAUNCH_SCRIPT} ]; then

    echo "Specified shell build script ${LAUNCH_SCRIPT} does not exist."

    exit 1

fi

REL_BASE_DIR=../..

if [ ${DOWNLOAD_PKG} ]; then

    # This is the set of available download directories, consisting of downloads/

    # and a download directory that is offset from the location of the build

    # script src directory.

    unset TAR_DECOMP_ARG

    TMP=`echo ${SHELL_BUILD} | sed "s|/src/.*||"`

    TMP=`cleanup_dir ${CWD}/${TMP}`

    DDIR_ELSEWHERE=${TMP}

    DOWNLOAD_DIRS="${TMP} ${BASE_DIR}"

    for DDIR in ${DOWNLOAD_DIRS}; do

        TMP=${DDIR}/downloads/${DOWNLOAD_PKG}.tar.bz2

        if [ -e ${TMP} ]; then

            TARBALL_FILE=${TMP}

            SHARE_SRC_DIR=${DDIR}/src

            SHARE_BASE_DIR=${DDIR}

            TAR_DECOMP_ARG=j

        else

            TMP=${DDIR}/downloads/${DOWNLOAD_PKG}.tar.gz

            if [ -e ${TMP} ]; then

                TARBALL_FILE=${TMP}

                SHARE_SRC_DIR=${DDIR}/src

                SHARE_BASE_DIR=${DDIR}

                TAR_DECOMP_ARG=z

            else

                TMP=${DDIR}/downloads/${DOWNLOAD_PKG}.tgz

                if [ -e ${TMP} ]; then

                    TARBALL_FILE=${TMP}

                    SHARE_SRC_DIR=${DDIR}/src

                    SHARE_BASE_DIR=${DDIR}

                    TAR_DECOMP_ARG=z

                else

                    TMP=${DDIR}/downloads/${DOWNLOAD_PKG}.zip

                    if [ -e ${TMP} ]; then

                        TARBALL_FILE=${TMP}

                        SHARE_SRC_DIR=${DDIR}/src

                        SHARE_BASE_DIR=${DDIR}

                        TAR_DECOMP_ARG=unzip

                    fi

                fi

            fi

        fi    

    done

    if [ "${SHARE_BASE_DIR}" = "${DDIR_ELSEWHERE}" ]; then

        REL_BASE_DIR=../$(echo ${SHELL_BUILD} | sed "s|/src/.*||")

    fi

    if [ "${TAR_DECOMP_ARG}" = "" ]; then

        echo "Could not find download file ${DOWNLOAD_PKG}.<tar.gz|tar.bz2|tgz|zip> in any of { ${DOWNLOAD_DIRS} }"

        exit 1

    fi

    UNTAR_DIR=${LCL_SRC_DIR}/${DOWNLOAD_PKG}

    WORK_DIR=${UNTAR_DIR}.${PLATFORM}${TYPE}

else

    WORK_DIR=${LCL_SRC_DIR}

fi

#

#   Setup WORK_DIR

#   This can be deduced from the tar-file, but in some cases the name

#   must be specified

#

if [ ${WORK_DIR_NAME} ]; then

    WORK_DIR=${LCL_SRC_DIR}/${WORK_DIR_NAME}

fi

if [ ${WORK_DIR_SUFFIX} ]; then

    WORK_DIR=${WORK_DIR}${WORK_DIR_SUFFIX}

fi    

#

#   Extend compiler and linker search paths to access data within

#   packages imported via BuildPkgArchive

#

#   Include the packageing directory - its used for builds that

#   build multiple packages.

#

#   Only include paths that exist

#

INCLUDE=

LIBPATH=

DJOIN=""

DLIST="

${PKG_INC_DIR}

${LOCAL_DIR}/inc

${INTERFACE_DIR}/include/${PLATFORM}

${INTERFACE_DIR}/include/LINUX

${INTERFACE_DIR}/include

"

for dtest in ${DLIST} ; do

    if [ -d $dtest ] ; then

        INCLUDE="${INCLUDE}${DJOIN}-I$dtest"

        DJOIN=" "

    fi

done

DJOIN=""

DLIST="

${PKG_LIB_DIR}

${LOCAL_DIR}/lib/${PLATFORM}

${INTERFACE_DIR}/lib/${PLATFORM}

"

for dtest in ${DLIST} ; do

    if [ -d $dtest ] ; then

        LIBPATH="${LIBPATH}${DJOIN}-L$dtest"

        DJOIN=" "

    fi

done

# Dump configuration

echo "="

echo "   BUILD CONFIGURATION"

echo "="

echo " Compile Host   = ${COMPILE_HOST}"

echo " Compile Build  = ${COMPILE_BUILD}"

echo " XGCC Base Dir  = ${XGCC_BASE_DIR}"

echo " Base Dir       = ${BASE_DIR}"

if [ ${WORK_DIR_NAME} ]; then

    echo " Work Dir Name  = ${WORK_DIR_NAME}"

fi  

if [ ${DOWNLOAD_PKG} ]; then

    echo " Tarball File   = ${TARBALL_FILE}"

    echo " Working Dir    = ${WORK_DIR}"

fi

TITLE="Includes       ="

for INC in ${INCLUDE}; do

        echo " ${TITLE} ${INC}"

        TITLE="                "

done

TITLE="Library Path   ="

for LIB in ${LIBPATH}; do

        echo " ${TITLE} ${LIB}"

        TITLE="                "

done

if [ ${DEBIAN_PACKAGE} ]; then

    echo " Debian Package = ${DEB_PKG_DIR}"

fi

echo " Launch Script  = ${LAUNCH_SCRIPT}"

echo "="

echo

echo

# Prepare the environment

echo " --> Preparing environment"

LIBTOOL=${XGCC_BASE_DIR}/bin/${COMPILE_HOST}-libtool

if [ -e ${LIBTOOL} ]; then

    echo " --> Using toolchain libtool"

else

    echo " --> Using environment libtool"

    LIBTOOL=/usr/bin/libtool

fi

export LIBTOOL

unset CC

unset CXX

unset CPP

unset CPPFLAGS

unset LD_LIBRARY_PATH

export CC CXX CPP CPPFLAGS LD_LIBRARY_PATH

unset MAKE

unset MAKEFLAGS

unset MAKEOVERRIDES

unset MAKELEVEL

export CFLAGS="${CFLAGS} ${INCLUDE}"

export CXXFLAGS="${CXXFLAGS} ${INCLUDE}"

export CCFLAGS="${CCFLAGS} ${INCLUDE}"

export CPPFLAGS="${CPPFLAGS} ${INCLUDE}"

export LDFLAGS="${LDFLAGS} ${LIBPATH}"

if [ "${XGCC_IN_PATH}" != "" ]; then

    XGCC_COMPILER_PATH="${XGCC_BASE_DIR}/${COMPILE_HOST}/bin"

    XGCC_IN_PATH_PREFIX_DIR=${XGCC_BASE_DIR}/${COMPILE_HOST}

else

    XGCC_COMPILER_PATH="${XGCC_BASE_DIR}/bin"

    XGCC_IN_PATH_PREFIX_DIR=/afc

fi

#

#   Do not prepend the compiler path if it is already present in PATH

#   In particular do not prepend /usr/bin as this will prevent tools

#   provided in packages (eg bison) from overriding local versions

#

if ! expr -- ":${PATH}:" : ".*:${XGCC_COMPILER_PATH}:" > /dev/null ; then

    export PATH="${XGCC_COMPILER_PATH}:${PATH}"

    echo " --> Prepending compiler path"

fi

#

# Environment - CHOST is used by some packages (e.g., zlib) to set the 

# host environment compiler.

#

export CHOST=${COMPILE_HOST}

#

# These are special files used to track completion of tasks allowing for partial

# rebuilds during development.

#

COMPLETE_PREFIX=${LCL_SRC_DIR}/.complete${DOWNLOAD_PKG}.${PLATFORM}${TYPE}.

COMPLETE_DECOMPRESS=${COMPLETE_PREFIX}decompress${WORK_DIR_SUFFIX}

COMPLETE_CONFIGURE=${COMPLETE_PREFIX}configure${WORK_DIR_SUFFIX}

#

#   Clean up request

#   No building - just a clean of previous builds

#

if [ ${CLEAN} ]; then

    echo " --> Removing all completion tags"

    rm -fr ${LCL_SRC_DIR}/.complete*

    if [ ${DOWNLOAD_PKG} ]; then

        echo " --> Cleaning generated files"

        cd ${BASE_DIR}

        rm -fr ${WORK_DIR}

    fi        

    echo " --> Deleting binary, object, and library directories"

    rm -fr ${BIN_DIR}

    rm -fr ${LIB_DIR}

    rm -fr ${OBJ_DIR}

    if [ ${DEBIAN_PACKAGE} ]; then

        echo " --> Deleting Debian Build Files "

        rm -fr ${DEB_DIR}

    fi

    exit 0

fi

echo " --> Creating package directories"

mkdir -p ${PKG_BIN_DIR}

mkdir -p ${PKG_INC_DIR}

mkdir -p ${PKG_LIB_DIR}

mkdir -p ${PKG_PKG_DIR}

mkdir -p ${AFC_DIR}

mkdir -p ${AFC_BIN_DIR}

mkdir -p ${AFC_LIB_DIR}

mkdir -p ${AFC_SHARE_DIR}

mkdir -p ${PKG_TOOL_DIR}

mkdir -p ${PKG_TOOL_BIN_DIR}

mkdir -p ${PKG_TOOL_SCRIPT_DIR}

unset MENUCONFIG_FILE

if [ ${DOWNLOAD_PKG} ]; then

    MODS_DIR=${SHARE_BASE_DIR}/${DOWNLOAD_PKG_NAME}_${DOWNLOAD_PKG_VER}_mods

    # Find and export the configuration file (if any).

    VIX_CONFIG=${MODS_DIR}/vix.config

    if [ ! -f ${VIX_CONFIG} ]; then

        VIX_CONFIG=${MODS_DIR}/VXP.config

        if [ ! -f ${VIX_CONFIG} ]; then

            VIX_CONFIG=${MODS_DIR}/ERG.config

        fi

    fi

    if [ -f ${VIX_CONFIG} ]; then

        echo " --> Config file is $VIX_CONFIG"

        MENUCONFIG_FILE=`echo "${VIX_CONFIG}" | sed "s|${MODS_DIR}|${REL_BASE_DIR}/${DOWNLOAD_PKG_NAME}_${DOWNLOAD_PKG_VER}_mods|g"`

        export MENUCONFIG_FILE

    else

        echo " --> No configuration file found"

    fi

    if [ -e ${COMPLETE_DECOMPRESS} ]; then

        echo " --> Already extracted ${DOWNLOAD_PKG}"

    else

        echo " --> Deleting existing build objects directory"

        rm -fr ${UNTAR_DIR}

        rm -fr ${WORK_DIR}

        echo " --> Extracting ${DOWNLOAD_PKG}"

        cd ${LCL_SRC_DIR}

        # For Zip file use unzip instead of tar

        if [ "${TAR_DECOMP_ARG}" = "unzip" ]; then

            unzip ${TARBALL_FILE}

        else

            tar -x${TAR_DECOMP_ARG}pf ${TARBALL_FILE}

        fi

        cd ${UNTAR_DIR}

        PATCHES_DIR=${SHARE_BASE_DIR}/patches

        if [ -d ${PATCHES_DIR} ]; then

            PATCHES=`cd ${PATCHES_DIR} && find . -name "*.patch" | sort`

            if [ "${PATCHES}" != "" ]; then

                echo " --> Apply external patches"

                for PATCH in ${PATCHES}; do

                    if patch -p1 < ${PATCHES_DIR}/${PATCH}; then

                        echo "Applied patch ${PATCH}"

                        echo ""

                    else

                        echo "Patch ${PATCH} failed"

                        exit 1

                    fi

                done    

            fi

        fi

        #

        #   When a 'mods' directory is present we need to sym-link all the 

        #   files from there into the source tree.

        #

        cd ${UNTAR_DIR}

        if [ -d ${MODS_DIR} ]; then

            echo " --> Applying modifications from ${MODS_DIR}"

            echo "     Base relative directory is  ${REL_BASE_DIR}"

            if [ "${COPY_MODS_DIRS}" != "" ]; then

                echo "     Directories are copied"

            else

                echo "     Directories are symlinked"

            fi                

            create_mods()

            {

                local SRC

                local REL

                local DST

                local NAME

                local MOD_DIR=$1

                local REL_DEPTH=$2

                for SRC in `ls ${MOD_DIR}`; do

                    SRC=${MOD_DIR}${SRC}

                    REL=`echo "${SRC}" | sed "s|${MODS_DIR}|${REL_DEPTH}/${DOWNLOAD_PKG_NAME}_${DOWNLOAD_PKG_VER}_mods|g"`

                    DST=`echo "${SRC}" | sed "s|${MODS_DIR}/||g"`

                    if [ -d "${SRC}" ]; then

                        if [ -e "${DST}" ]; then

                            create_mods ${SRC}/ ../${REL_DEPTH}

                        else

                            if [ "${COPY_MODS_DIRS}" != "" ]; then

                                echo "       * Creating directory ${DST}"

                                mkdir -p ${DST}

                                create_mods ${SRC}/ ../${REL_DEPTH}

                            else

                                echo "       * Creating directory ${DST} symlink"

                                ln -s ${REL} ${DST}

                                if [ $? != 0 ]; then

                                    echo "ERROR: Could not create symlink from ${REL} to ${DST}"

                                    exit 1

                                fi

                            fi                                

                        fi

                    else

                        if [ -e "${DST}" ]; then

                            echo "       * Replacing file ${DST} with symlink"

                            rm -f ${DST}

                        else

                            echo "       * Creating file ${DST} symlink"

                        fi

                        ln -s ${REL} ${DST}

                        if [ $? != 0 ]; then

                            echo "ERROR: Could not create symlink from ${REL} to ${DST}"

                            exit 1

                        fi

                    fi

                done

            }

            create_mods ${MODS_DIR}/ ${REL_BASE_DIR}

            if [ "$MENUCONFIG_FILE" != "" ]; then

                if [ -e .config ]; then

                    echo "       * Replacing .config with symlink"

                    rm -f .config

                else

                    echo "       * Creating .config symlink"

                fi

                ln -s ${MENUCONFIG_FILE} .config

            fi

        fi

        mv ${UNTAR_DIR} ${WORK_DIR} 

        touch ${COMPLETE_DECOMPRESS}

    fi        

fi

#

#   Source the users script

#   This is processed in the context of this script

#

mkdir -p ${WORK_DIR}

cd ${WORK_DIR}

. ${LAUNCH_SCRIPT}

if [ ${DEBIAN_PACKAGE} ]; then 

    echo " --> Creating Debian packaging scripts"

    unset TOOL_DIR

    for DIR in `echo ${PATH} | sed "s|\:| |g"`; do

        if [ -f ${DIR}/debbuild.pl ]; then

            TOOL_DIR=`cleanup_dir ${DIR}`

        fi

    done

    if [ ${TOOL_DIR} ]; then

        DEBBUILD_PL=${TOOL_DIR}/debbuild.pl

        echo "      - Found ${DEBBUILD_PL}"

        rm -fr ${DEB_DIR}

        mkdir -p ${DEB_DIR}

        # Replace TAGS in the debbuild.pl file

        DEB_DESC="${BUILD_NAME} ${BUILD_VERSION} for ${PLATFORM}"

        cat ${DEBBUILD_PL} | sed "-es|TAG_DESCRIPTION|${DEB_DESC}|" "-es|TAG_POSTINSTALL|${DEB_DIR}/postinstall|" > ${DEB_DIR}/debbuild.pl

        cp ${TOOL_DIR}/postinstall ${DEB_DIR}/postinstall

    else

        echo "ERROR: Cannot find debbuild.pl in the PATH"

        exit 1

    fi

fi    

echo " --> Removing unnecesary files resulting from the make install"

if [ -d ${PKG_LIB_DIR} ] ; then

    DEL_FILES=`find ${PKG_LIB_DIR} -type f -name '*.la'`

    for FILE in ${DEL_FILES}; do

            echo "      - Deleting ${FILE}"

            rm -f ${FILE}

    done

fi

echo " --> Cleaning up empty directories"

# Deletes directory $1 if it does not contain any other files or directories

rmdir_empty()

{

    if [ -d "$1" ] ; then

        # -A = do not list . and ..

        # -Q = enclose entry names in double quotes

        # -l = list one file per line

        # -F = appends each directory with a '/' 

        DIRS=`ls -A -Q -l -F "$1" | grep "\".*\"\/" | sed "s|.* \"||" | sed "s|\"\/||"`

        for DIR in ${DIRS}; do

            rmdir_empty $1/${DIR}

        done

        LS=`ls -A -Q -l -F "$1" | grep "\"" | sed "s|^.* \"||" | sed "s|\".*||"`

        if [ "${LS}" = "" ]; then

            rmdir $1

        fi

    fi

}

rmdir_empty ${DEB_PKG_DIR}

rmdir_empty ${BASE_DIR}/pkg

echo " --> End of ShellBuild"