WebSVN – DevTools – /shellbuild/trunk/src/shellbuild_linux.sh

################################################################################
# COPYRIGHT - VIX IP PTY LTD ("VIX"). ALL RIGHTS RESERVED.
#
#   NOTE:
#   This script will be run under a simple 'sh'
#   Jats will run .sh files under .sh. 
#   This is a 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

#------------------------------------------------------------------------------
# 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}
} 

#----------------------------------------------------------------------------
#   Print a pretty banner
#----------------------------------------------------------------------------
banner()
{
    printf '\n%.80s\n' "===== ${1} =========================================================================" 
}

#----------------------------------------------------------------------------
#   Print a pretty printers
#   pitem   - print item and value ( if value is not empty )
#   pitem3  - print item and value ( if item3 is not empty )
#   plist   - print item and list of values
#----------------------------------------------------------------------------
pitem ()
{
    if [ -n "$2" ]; then 
        printf ' %-15s = %s\n' "$1" "$2"
    fi
}

pitem3 ()
{
    if [ -n "$3" ]; then 
        printf ' %-15s = %s\n' "$1" "$2"
    fi
}

plist ()
{
    TITLE=` printf ' %-15s =' "$1"`
    shift
    for INC in $*; do
        echo "${TITLE} ${INC}"
        TITLE="                  "
    done
}


#------------------------------------------------------------------------------
# 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;
PATCHES_DIR=patches
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;;
        -PatchDir)              PATCHES_DIR=$val;;
        -IgnorePatchErr)        IGNORE_PATH_ERR=$val;;
        -Toolset)               ISA_TOOLSET=1;;

        *)                      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

if [ "${IGNORE_PATH_ERR}" != "1" ]; then
    IGNORE_PATH_ERR=0
fi

#------------------------------------------------------------------------------
# Dump JATS information for debugging purposes
#------------------------------------------------------------------------------
banner "JATS SUPPLIED FIELDS"
pitem "ShellBuild" "${SHELL_BUILD}"
pitem "BuildName" "${BUILD_NAME} ${BUILD_VERSION}"
pitem "Platform" "${PLATFORM}"
pitem "Type" "${TYPE}"
pitem "Arch" "${ARCH}"
pitem "MachType" "${MACHTYPE}"
pitem "BuildRoot" "${BUILD_ROOT}"
pitem "InterfaceDir" "${INTERFACE_DIR}"
pitem "LocalDir" "${LOCAL_DIR}"
pitem "DownloadPkg" "${DOWNLOAD_PKG}"
pitem "BinDir" "${BIN_DIR}"
pitem "LibDir" "${LIB_DIR}"
pitem "ObjDir" "${OBJ_DIR}"
pitem "PkgDir" "${PKG_DIR}"
pitem "PackageBinDir" "${PKG_BIN_DIR}"
pitem "PackageIncDir" "${PKG_INC_DIR}"
pitem "PackageLibDir" "${PKG_LIB_DIR}"
pitem "PackagePkgDir" "${PKG_PKG_DIR}"
pitem "CompilerDir" "${COMPILER_DIR}"
pitem "PatchDir" "${PATCHES_DIR}"

pitem "WorkDir" "${WORK_DIR_NAME}"
pitem "WorkDirSuffix" "${WORK_DIR_SUFFIX}"

if [ ${ISA_TOOLSET} ]; then
    echo " Toolset Packaging Support"
    pitem "PackageToolDir" "${PKG_TOOL_DIR}"
    pitem "PackageToolBin" "${PKG_TOOL_BIN_DIR}"
    pitem "PackageToolScript" "${PKG_TOOL_SCRIPT_DIR}"
fi    

#------------------------------------------------------------------------------
# Determine host and build environments
#------------------------------------------------------------------------------
case ${MACHTYPE} in
    linux_i386)     COMPILE_BUILD="i386-cross-linux-gnu" ;;
    linux_x64)      COMPILE_BUILD="x86_64-linux-gnu" ;;
    linux_el7_x64)  COMPILE_BUILD="x86_64-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
        ;;

    armunknown*)
        if [ "${PLATFORM}" = "STIBAXIO" ]; then
            COMPILE_HOST="arm-linux-gnueabi"
        else
            COMPILE_HOST="arm-unknown-linux-gnueabi"
        fi

        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}" = "UBUNTU12C11" ] || [ "${PLATFORM}" = "UBUNTU12C11_INSTRUMENT" ] ; then
            COMPILE_HOST="i686-vix_ubuntu12_c11-linux-gnu"

        elif [ "${PLATFORM}" = "UBUNTU12" ] || [ "${PLATFORM}" = "UBUNTU12_INSTRUMENT" ] ; then
            COMPILE_HOST="i686-linux-gnu"
            
            # Hack to create missing tools expected by the build process.
            SHELLBUILD_PATH="$(pwd)/${BUILD_ROOT}/_shellbuild"
            rm -fr "${SHELLBUILD_PATH}"
            mkdir -p "${SHELLBUILD_PATH}/bin"
            PATH="${PATH}:${SHELLBUILD_PATH}/bin"
            ln -s /usr/bin/ar "${SHELLBUILD_PATH}/bin/${COMPILE_HOST}-ar"
            ln -s /usr/bin/ranlib "${SHELLBUILD_PATH}/bin/${COMPILE_HOST}-ranlib"
        else
            COMPILE_HOST="i586-unknown-linux-gnu"
        fi
        LINUX_HOST_ARCH=x86
        ;;

        X86_64)
        COMPILE_HOST="x86_64-linux-gnu"
        LINUX_HOST_ARCH=x86_64
                ;;

    *)
        case ${PLATFORM} in
            ANDROIDARM)     COMPILE_HOST="arm-linux-androideabi" ;;
            ANDROIDMIPS)    COMPILE_HOST="mipsel-linux-android" ;;
            ANDROIDX86)     COMPILE_HOST="i686-linux-android" ;;
            ANDROIDARMV7)   COMPILE_HOST="arm-linux-androideabi" ;;
            ANDROIDARM64)   COMPILE_HOST="aarch64-linux-android" ;;
            ANDROIDMIPS64)  COMPILE_HOST="mips64el-linux-android" ;;
            ANDROIDX86_64)  COMPILE_HOST="x86_64-linux-android" ;;

            *)
                echo "Unknown ARCH=${ARCH}"
                exit 1
                ;;
        esac

esac

# Setup the location of the cross compiler
if [ "${COMPILE_HOST}" = "i386-redhat-linux" ] || [ "${COMPILER_DIR}" = "gcc" ] || [ "${COMPILE_HOST}" = "i686-linux-gnu" ] || [ "${COMPILE_HOST}" = "x86_64-linux-gnu" ]; then
    XGCC_BASE_DIR=
    STRIP=strip
else
    XGCC_BASE_DIR=`echo ${COMPILER_DIR} | sed 's|/[^/]*/[^/]*$||'`
    XGCC_BASE_DIR=`cleanup_dir ${XGCC_BASE_DIR}`
    STRIP=${XGCC_BASE_DIR}/bin/${COMPILE_HOST}-strip
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=$(echo ${BIN_DIR} | sed "s|\.BIN$|\.DEBPKG|")
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
    if [ -n "${WORK_DIR_NAME}" ] ; then
        UNTAR_DIR=${LCL_SRC_DIR}/${WORK_DIR_NAME}
    else
        UNTAR_DIR=${LCL_SRC_DIR}/${DOWNLOAD_PKG}
    fi
    WORK_DIR=${UNTAR_DIR}.${PLATFORM}${TYPE}
else
    WORK_DIR=${LCL_SRC_DIR}
    if [ ${WORK_DIR_NAME} ]; then
        WORK_DIR=${LCL_SRC_DIR}/${WORK_DIR_NAME}
    fi
fi

#
#   Suffix allows the package to be built multiple times for the one target
#   Example: Client/Server or Native/Host or Static/Dynamic ...
#   
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=
NORMAL_PLATFORM=$(echo ${PLATFORM} | sed "s|_INSTRUMENT$||")


DJOIN=""
DLIST="
${PKG_INC_DIR}
${LOCAL_DIR}/inc
${INTERFACE_DIR}/include/${PLATFORM}
${INTERFACE_DIR}/include/LINUX
${INTERFACE_DIR}/include
"

# Modify for derivative platforms.
if [ "${NORMAL_PLATFORM}" != "${PLATFORM}" ]; then
    DLIST="${DLIST} ${INTERFACE_DIR}/include/${NORMAL_PLATFORM}"
fi

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}
"

# Modify for derivative platforms.
if [ "${NORMAL_PLATFORM}" != "${PLATFORM}" ]; then
    DLIST="${DLIST} ${INTERFACE_DIR}/lib/${NORMAL_PLATFORM}"
fi

for dtest in ${DLIST} ; do
    if [ -d $dtest ] ; then
        LIBPATH="${LIBPATH}${DJOIN}-L$dtest"
        DJOIN=" "
    fi
done



# Dump configuration
banner "BUILD CONFIGURATION"
pitem "Compile Host"    "${COMPILE_HOST}"
pitem "Compile Build"   "${COMPILE_BUILD}"
pitem "XGCC Base Dir"   "${XGCC_BASE_DIR}"
pitem "Base Dir"        "${BASE_DIR}"
pitem "Work Dir Name"   "${WORK_DIR_NAME}"

if [ ${DOWNLOAD_PKG} ]; then
    pitem  "Tarball File" "${TARBALL_FILE}"
    pitem3 "UnTar Dir" "${UNTAR_DIR}" "${WORK_DIR_NAME}"
    pitem  "Working Dir" "${WORK_DIR}"
fi

plist "Includes" ${INCLUDE}
plist "Library Path" ${LIBPATH}
pitem "Debian Package"  "${DEB_PKG_DIR}"
pitem "Launch Script"   "${LAUNCH_SCRIPT}"

banner "Package Build"
# 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_DECOMPRESS - Source extracted
#   COMPLETE_CONFIGURE - CONFIGURE completed
#   COMPLETE_BUILD - Build competed
#
COMPLETE_PREFIX=${WORK_DIR}/.complete-
COMPLETE_DECOMPRESS=${COMPLETE_PREFIX}decompress
COMPLETE_CONFIGURE=${COMPLETE_PREFIX}configure
COMPLETE_BUILD=${COMPLETE_PREFIX}build

#
#   Clean up request
#   No building - just a clean of previous builds
#
if [ ${CLEAN} ]; then

    if [ ${DOWNLOAD_PKG} ]; then
        echo " --> Cleaning generated files"
        cd ${BASE_DIR}
        rm -fr ${WORK_DIR}
    fi        

    echo " --> Deleting temp work area"
    SHELLBUILD_PATH="$(pwd)/_shellbuild"
    rm -fr "${SHELLBUILD_PATH}"
    
    echo " --> Deleting binary, object, and library directories"
    rm -fr ${BIN_DIR}
    rm -fr ${LIB_DIR}
    rm -fr ${OBJ_DIR}
    rm -fr ${DEB_PKG_DIR}

    if [ ${DEBIAN_PACKAGE} ]; then
        echo " --> Deleting Debian Build Files "
        rm -fr ${DEB_DIR}
    fi
    
    exit 0
fi

#
#   Attempt to bypass the enture build
#   If its already been compeleted without error
#
if [ -e ${COMPLETE_BUILD} ]; then
    echo " --> Build already completed for ${PLATFORM}${TYPE}"
    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}

if [ ${ISA_TOOLSET} ]; then
    echo " --> Creating package toolset directories"
    mkdir -p ${PKG_TOOL_DIR}
    mkdir -p ${PKG_TOOL_BIN_DIR}
    mkdir -p ${PKG_TOOL_SCRIPT_DIR}
fi

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
       
        if [ ! -d ${UNTAR_DIR} ] ; then
            echo "Error: Tar file did not extract into the expected directory"
            echo "       Expected: ${UNTAR_DIR}"
            exit 1
        fi

        cd ${UNTAR_DIR}
        PATCHES_DIR=${SHARE_BASE_DIR}/${PATCHES_DIR}
        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 -t -p1 < ${PATCHES_DIR}/${PATCH}; then
                        echo "Applied patch ${PATCH}"
                        echo ""
                    else
                        if [ "${IGNORE_PATH_ERR}" = "1" ]; then
                            echo "Patch ${PATCH} errors ignored"
                        else 
                            echo "Patch ${PATCH} failed"
                            exit 1
                        fi
                    fi
                done    
            fi
        fi
        PATCHES_DIR=${PATCHES_DIR}.${PLATFORM}
        if [ -d ${PATCHES_DIR} ]; then
            PATCHES=`cd ${PATCHES_DIR} && find . -name "*.patch" | sort`
            if [ "${PATCHES}" != "" ]; then
                echo " --> Apply external patches for ${PLATFORM}"
                for PATCH in ${PATCHES}; do
                    if patch -t -p1 < ${PATCHES_DIR}/${PATCH}; then
                        echo "Applied patch ${PATCH}"
                        echo ""
                    else
                        if [ "${IGNORE_PATH_ERR}" = "1" ]; then
                            echo "Patch ${PATCH} errors ignored"
                        else 
                            echo "Patch ${PATCH} failed"
                            exit 1
                        fi
                    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|" "-es|TAG_DEBPKGDIR|${DEB_PKG_DIR}|" > ${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 ${AFC_DIR}
rmdir_empty ${AFC_BIN_DIR}
rmdir_empty ${AFC_LIB_DIR}
rmdir_empty ${AFC_SHARE_DIR}
rmdir_empty ${DEB_PKG_DIR}
rmdir_empty ${BASE_DIR}/pkg

touch ${COMPLETE_BUILD}
echo " --> End of ShellBuild"
Subversion Repositories DevTools

(root)/shellbuild/trunk/src/shellbuild_linux.sh – Rev 7480
