san/_roku_build.sh

#!/bin/sh

_roku_build_completion()
{
    :
}

_roku_repo_root()
{
    eval "cd $1; git rev-parse --show-toplevel"
}

_roku_repo_acramfs_location()
{
    echo "$1/port/realtek/stark/$2/dist/image/acramfs/acramfs.bin"
}

_roku_build()
{
    __build "$@"
}

_roku_build_port()
{
    __build "$@"
}

export ACLOCAL_PATH=/usr/share/aclocal

# This is needed to be able to set brake point on /bin/Application
export PAX_DEBUG=on

__build_help()
{
    cat <<EOF
platform:
        bailey, marlin, porting-kit-stb
icecream:
        local, icecc
target:
        all, addon-checksums, addon-checksum-check, clobber
EOF
}


__build_legacy()
{
    eval $MAKE \
            -C $BUILD_ROOT \
            BUILD_PLATFORM=$BUILD_PLATFORM \
            ${BUILD_PLID:+BUILD_PLID=$BUILD_PLID} \
            ${PLATFORM_TYPE:+PLATFORM_TYPE=$PLATFORM_TYPE} \
            ENABLE_ICECC=$ENABLE_ICECC \
            PAX_DEBUG=$PAX_DEBUG \
            ROOTFSCOMPONENTS_DBG=gdbserver \
            ${BUILD_MODE:+BUILD_MODE=$BUILD_MODE} \
            $OPTIONS \
            -j $JOBS \
            $TARGET
}

__build_os()
{
    eval $MAKE \
            -C $BUILD_ROOT \
            BUILD_PLATFORM=$BUILD_PLATFORM \
            ${BUILD_PLID:+BUILD_PLID=$BUILD_PLID} \
            ${PLATFORM_TYPE:+PLATFORM_TYPE=$PLATFORM_TYPE} \
            ENABLE_ICECC=$ENABLE_ICECC \
            PAX_DEBUG=$PAX_DEBUG \
            ROOTFSCOMPONENTS_DBG=gdbserver \
            ${BUILD_MODE:+BUILD_MODE=$BUILD_MODE} \
            $OPTIONS \
            -j $JOBS \
            $TARGET
}

__build_wdk()
{
    echo test
}

__build_port()
{
    eval $MAKE \
            -C $BUILD_ROOT \
            BUILD_PLATFORM=$BUILD_PLATFORM \
            ${BUILD_PLID:+BUILD_PLID=$BUILD_PLID} \
            ${PLATFORM_TYPE:+PLATFORM_TYPE=$PLATFORM_TYPE} \
            ENABLE_ICECC=$ENABLE_ICECC \
            ${ROKU_OS_DIR:+ROKU_OS_DIR=$ROKU_OS_DIR} \
            ${ROKU_WLAN_DIR:+ROKU_WLAN_DIR=$ROKU_WLAN_DIR} \
            $OPTIONS \
            -j $JOBS \
            $TARGET
}

# declar -a __build_configs = (
__build()
{
    local REPO_ROKU_OS_DIR=$REPO_ROOT/os/dist/rootfs/Carbon14_dev_stb.OBJ/export/package/porting_kit/os
    local REPO_DOCKER_MAKE=$REPO_ROOT/os/scripts/docker/localcontainer/docker-u20-make
    local MAKE=$DOCKER_MAKE
    local ROKU_OS_DIR=
    local BUILD_PLATFORM=carbon
    local PLATFORM_TYPE=
    local ENABLE_ICECC=0
    local JOBS=$(nproc)
    local TARGET=all
    local BUILD_MODE=dev
    local PAX_DEBUG=on
    local OPTIONS=

    #
    # Root of repository
    #
    local REPO_ROOT=$(git rev-parse --show-toplevel)
    if [ "$?" -ne "0" ]; then
        REPO_ROOT=$(p4 -Ztag -F %clientRoot% info)
    fi
    if [ -z "$REPO_ROOT" ] || [ ! -d "$REPO_ROOT" ]; then
        echo "build: Cannot find workspace root directory." >&2
        exit 1
    fi
    local BUILD_ROOT=$REPO_ROOT/os

    #
    # Parse arguments
    #
    while [ $# -gt 0 ]; do
        case "$1" in
        wdk)
            BUILD_ROOT=$REPO_ROOT/os
            BUILD_PLATFORM=carbon
            TARGET=wdk-kit
            BUILD_PLID=00
            if [ "$1" == "streambar"]; then
                PLATFORM_TYPE=WDK_STREAMBAR
            else
                PLATFORM_TYPE=WDK_STB
            fi
            ;;
        porting-kit|\
        streambar|\
        stb)
            BUILD_ROOT=$REPO_ROOT/os
            BUILD_PLATFORM=carbon
            TARGET=porting-kit
            BUILD_PLID=00
            if [ "$1" == "streambar"]; then
                PLATFORM_TYPE=STREAMBAR
            else
                PLATFORM_TYPE=STB
            fi
            ;;
        tests|\
        unittests)
            BUILD_PLATFORM=host
            PLATFORM_TYPE=unittests
            TARGET=build-tests-all
            PAX_DEBUG=off
            ;;
        host|\
        hoststatic|\
        unity|\
        native)
            BUILD_PLATFORM=$1
            PAX_DEBUG=off
            MAKE=$DOCKER_MAKE
            TARGET=all
            ;;
        reno|\
        nemo|\
        rockett|\
        bailey|\
        marlin|\
        brewster|\
        benjamin|\
        benjaminw|\
        loggan|\
        lockhart|\
        madison)
            local ROOT_DIR="$(basename $REPO_ROOT)"
            if [ "$ROOT_DIR" == "stark" ] || \
               [ "$ROOT_DIR" == "hank" ]; then
                local BUILD_ROOT="$REPO_ROOT/$1"
                local ROKU_OS_DIR=$REPO_ROOT/../../../os/dist/rootfs/Carbon14_dev_stb.OBJ/export/package/porting_kit/os
                # local ROKU_WLAN_DIR=$REPO_ROOT/common/wlan
                local TARGET=image
            else
                local BUILD_ROOT=$REPO_ROOT/os
            fi
            BUILD_PLATFORM=$1
            ;;
        icecc)
            ENABLE_ICECC=1
            JOBS=256
            ;;
        port-only)
            ROKU_OS_DIR=$REPO_ROKU_OS_DIR
            ;;
        local)
            ENABLE_ICECC=0
            JOBS=$(nproc)
            ;;
        all|\
        addon-checksums|\
        addon-checksum-check|\
        clean|\
        cleanall|\
        clobber|\
        build-tests-all|\
        build-tests-ZipMountServerTest|\
        build-tests-FuseServerTest|\
        build-tests-PluginPackageManagemnetPluginUnitTests|\
        make_custom_package|\
        clobber-all)
            TARGET=$1
            ;;
        build-integration-tests)
            OPTIONS+="BUILD_INTEGRATION_TESTS=true"
            ;;
        here)
            BUILD_ROOT="."
            ;;
        nopax)
            PAX_DEBUG=off
            ;;
        make)
            MAKE=make
            ;;
        docker)
            MAKE=$DOCKER_MAKE
            ;;
        debug)
            BUILD_MODE=dbg
            ;;
        help)
            build_help
            return
            ;;
        *)
            echo "Really? Do you mean that?"
            return
            ;;
        esac
        shift
    done

    # Fallback to make if docker image not found.
    if [ -e $MAKE ]; then
        local MAKE=make
    fi

    if [ "$BUILD_PLATFORM" == "carbon" ]; then
        __build_os
    elif [ "$TARGET" == "image" ]; then
        __build_port
    else
        __build_legacy
    fi
}

###############################################################################
#
#   Build Completion
#
__build_completion_contains()
{
    # Platforms
    for WORD in "$@"; do
        if [[ "${COMP_WORDS[*]}" =~ "$WORD" ]]; then
            return 1
        fi
    done
    return 0
}

__build_completion_add_if()
{
    __build_completion_contains "$@"
    if [[ $? == 0 ]]; then
        CANDIDATES+=" $@"
    fi
}

complete -F __build_completion build
__build_completion()
{
    local CANDIDATES="help clobber tests addon-checksums"

    # Docker
    __build_completion_add_if docker make

    # Build hosts
    __build_completion_add_if icecc local

    # Port dir
    __build_completion_add_if port-only

    # Platforms
    __build_completion_add_if native marlin bailey loggan lockhart porting-kit streambar stb

    COMPREPLY=($(compgen -W "$CANDIDATES" "${COMP_WORDS[${COMP_CWORD}]}"))
}